diff --git a/.gitignore b/.gitignore
index 189e07153..010914716 100644
--- a/.gitignore
+++ b/.gitignore
@@ -62,5 +62,4 @@ tool/target
 runtime-testsuite/target
 tool-testsuite/target
 runtime/Cpp/demo/generated
-runtime/Cpp/demo/Mac/antlrcpp.xcodeproj/xcuserdata
-runtime/Cpp/demo/Mac/antlrcpp.xcodeproj/project.xcworkspace/xcuserdata
+xcuserdata
diff --git a/.travis.yml b/.travis.yml
new file mode 100644
index 000000000..faf7fcfa0
--- /dev/null
+++ b/.travis.yml
@@ -0,0 +1,19 @@
+sudo: true
+language: java
+script:
+  - mvn install
+jdk:
+  - openjdk6
+  - oraclejdk7
+  - oraclejdk8
+before_install:
+  - sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys 3FA7E0328081BFF6A14DA29AA6A19B38D3D831EF
+  - sudo add-apt-repository ppa:fkrull/deadsnakes -y
+  - sudo add-apt-repository ppa:rwky/nodejs -y
+  - sudo apt-get update -qq
+  - sudo apt-get install -qq python3.5
+  - sudo apt-get install -qq nodejs
+  - echo "deb http://download.mono-project.com/repo/debian wheezy/snapshots/3.12.1 main" | sudo tee /etc/apt/sources.list.d/mono-xamarin.list
+  - sudo apt-get install -qq mono-complete
+  - python --version
+  - python3 --version
diff --git a/CHANGES.txt b/CHANGES.txt
index 8e4d978e3..b2eef1054 100644
--- a/CHANGES.txt
+++ b/CHANGES.txt
@@ -1,5 +1,45 @@
+****************************************************************************
+As of ANTLR 4.2.1, March 25 2014, we are no longer updating this file. Instead,
+we are using the github release mechanism. For example, here is
+4.2.1 release notes:
+
+https://github.com/antlr/antlr4/releases/tag/4.2.1
+****************************************************************************
+
 ANTLR v4 Honey Badger
 
+January 15, 2014
+
+* Unit tests for lexer actions from yesterday.
+* Refactored TreeView so we can refresh tree externally w/o creating new one.
+  Needed for intellij plugin.
+
+January 14, 2014
+
+* Updated serialized ATN representation of lexer actions, allowing the lexer
+  interpreter to execute the majority of lexer commands (#408)
+
+January 12, 2014
+
+* Support executing precedence predicates during the SLL phase of
+  adaptivePredict (#401). The result is a massive performance boost for grammars
+  containing direct left-recursion (improvements of 5% to 1000+% have been
+  observed, depending on the grammar and input).
+
+December 29, 2013
+
+* Internal change: Tool.loadGrammar() -> parseGrammar(). Tool.load()->parse()
+
+* Added Tool.loadGrammar(fileName) that completely parses, extracts implicit lexer,
+  and processes into Grammar object. Does not geneate code.  Use
+  Grammar.getImplicitLexer() to get the lexer created during processing of
+  combined grammar.
+
+* Added Grammar.load(fileName) that creates Tool object for you. loadGrammar()
+  lets you create your own Tool for setting error handlers etc...
+
+	final Grammar g = Grammar.load("/tmp/MyGrammar.g4");
+
 December 19, 2013
 
 * Sam:
@@ -14,19 +54,19 @@ November 24, 2013
 
 * Ter adds tree pattern matching.  Preferred interface:
 
-	   ParseTree t = parser.expr();
-	   ParseTreePattern p = parser.compileParseTreePattern("<ID>+0", MyParser.RULE_expr);
-	   ParseTreeMatch m = p.match(t);
-	   String id = m.get("ID");
+	ParseTree t = parser.expr();
+	ParseTreePattern p = parser.compileParseTreePattern("<ID>+0", MyParser.RULE_expr);
+	ParseTreeMatch m = p.match(t);
+	String id = m.get("ID");
 
   or
 
-		String xpath = "//blockStatement/*";
-		String treePattern = "int <Identifier> = <expression>;";
-		ParseTreePattern p =
-			parser.compileParseTreePattern(treePattern,
-										   JavaParser.RULE_localVariableDeclarationStatement);
-		List<ParseTreeMatch> matches = p.findAll(tree, xpath);
+	String xpath = "//blockStatement/*";
+	String treePattern = "int <Identifier> = <expression>;";
+	ParseTreePattern p =
+		parser.compileParseTreePattern(treePattern,
+									   JavaParser.RULE_localVariableDeclarationStatement);
+	List<ParseTreeMatch> matches = p.findAll(tree, xpath);
 
 November 20, 2013
 
diff --git a/LICENSE.txt b/LICENSE.txt
index 49a546774..95d0a2554 100644
--- a/LICENSE.txt
+++ b/LICENSE.txt
@@ -1,5 +1,5 @@
 [The "BSD license"]
-Copyright (c) 2013 Terence Parr, Sam Harwell
+Copyright (c) 2015 Terence Parr, Sam Harwell
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
diff --git a/README.md b/README.md
new file mode 100644
index 000000000..c1d6902de
--- /dev/null
+++ b/README.md
@@ -0,0 +1,47 @@
+# ANTLR v4
+
+**ANTLR** (ANother Tool for Language Recognition) is a powerful parser generator for reading, processing, executing, or translating structured text or binary files. It's widely used to build languages, tools, and frameworks. From a grammar, ANTLR generates a parser that can build parse trees and also generates a listener interface (or visitor) that makes it easy to respond to the recognition of phrases of interest.
+
+*Given day-job constraints, my time working on this project is limited so I'll have to focus first on fixing bugs rather than changing/improving the feature set. Likely I'll do it in bursts every few months. Please do not be offended if your bug or pull request does not yield a response! --parrt*
+
+## Authors and major contributors
+
+* [Terence Parr](http://www.cs.usfca.edu/~parrt/), parrt@cs.usfca.edu
+ANTLR project lead and supreme dictator for life
+[University of San Francisco](http://www.usfca.edu/)
+* [Sam Harwell](http://tunnelvisionlabs.com/) (Tool co-author, Java and C# target)
+* Eric Vergnaud (Javascript, Python2, Python3 targets and significant work on C# target)
+
+## Useful information
+
+* [Release notes](https://github.com/antlr/antlr4/releases)
+* [Getting started with v4](https://raw.githubusercontent.com/antlr/antlr4/master/doc/getting-started.md)
+* [Official site](http://www.antlr.org/)
+* [Documentation](https://raw.githubusercontent.com/antlr/antlr4/master/doc/index.md)
+* [FAQ](https://raw.githubusercontent.com/antlr/antlr4/master/doc/faq/index.md)
+* [API](http://www.antlr.org/api/Java/index.html)
+* [ANTLR v3](http://www.antlr3.org/)
+* [v3 to v4 Migration, differences](https://raw.githubusercontent.com/antlr/antlr4/master/doc/faq/general.md)
+
+You might also find the following pages useful, particularly if you want to mess around with the various target languages.
+ 
+* [How to build ANTLR itself](https://raw.githubusercontent.com/antlr/antlr4/master/doc/building-antlr.md)
+* [How we create and deploy an ANTLR release](https://raw.githubusercontent.com/antlr/antlr4/master/doc/releasing-antlr.md)
+
+## The Definitive ANTLR 4 Reference
+
+Programmers run into parsing problems all the time. Whether it’s a data format like JSON, a network protocol like SMTP, a server configuration file for Apache, a PostScript/PDF file, or a simple spreadsheet macro language—ANTLR v4 and this book will demystify the process. ANTLR v4 has been rewritten from scratch to make it easier than ever to build parsers and the language applications built on top. This completely rewritten new edition of the bestselling Definitive ANTLR Reference shows you how to take advantage of these new features.
+
+You can buy the book [The Definitive ANTLR 4 Reference](http://amzn.com/1934356999) at amazon or an [electronic version at the publisher's site](https://pragprog.com/book/tpantlr2/the-definitive-antlr-4-reference).
+
+You will find the [Book source code](http://pragprog.com/titles/tpantlr2/source_code) useful.
+
+## Additional grammars
+[This repository](https://github.com/antlr/grammars-v4) is a collection of grammars without actions where the
+root directory name is the all-lowercase name of the language parsed
+by the grammar. For example, java, cpp, csharp, c, etc...
+
+Travis Status
+---------
+
+<a href="https://travis-ci.org/antlr/antlr4"><img src="https://api.travis-ci.org/antlr/antlr4.png"></a>
diff --git a/README.txt b/README.txt
deleted file mode 100644
index 8aac63ffd..000000000
--- a/README.txt
+++ /dev/null
@@ -1,121 +0,0 @@
-ANTLR v4
-
-Terence Parr, parrt@cs.usfca.edu
-ANTLR project lead and supreme dictator for life
-University of San Francisco
-
-INTRODUCTION
-
-Hi and welcome to the Honey Badger 4.1 release of ANTLR!
-
-INSTALLATION
-
-UNIX
-
-0. Install Java (version 1.6 or higher)
-
-1. Download
-
-   $ cd /usr/local/lib
-   $ curl -O http://www.antlr4.org/download/antlr-4.1-complete.jar
-
-   Or just download in browser using URL:
-
-       http://www.antlr4.org/download/antlr-4.1-complete.jar
-
-   and put it somewhere rational like /usr/local/lib.
-
-2. Add antlr-4.1-complete.jar to your CLASSPATH:
-
-   $ export CLASSPATH=".:/usr/local/lib/antlr-4.1-complete.jar:$CLASSPATH"
-
-   Is also a good idea to put this in your .bash_profile or whatever your
-   startup script is.
-
-3. Create aliases for the ANTLR Tool, and TestRig.
-
-   $ alias antlr4='java -jar /usr/local/lib/antlr-4.1-complete.jar'
-   $ alias grun='java org.antlr.v4.runtime.misc.TestRig'
-
-WINDOWS (Thanks to Graham Wideman)
-
-0. Install Java (version 1.6 or higher)
-
-1. Download http://antlr.org/download/antlr-4.1-complete.jar
-   Save to your directory for 3rd party Java libraries, say C:\Javalib
-
-2. Add antlr-4.1-complete.jar to CLASSPATH, either:
-
- * Permanently: Using System Properties dialog > Environment variables >
-   Create or append to CLASSPATH variable
-
- * Temporarily, at command line:
-   SET CLASSPATH=C:\Javalib\antlr-4.1-complete.jar;%CLASSPATH%
-
-3. Create short convenient commands for the ANTLR Tool, and TestRig,
-   using batch files or doskey commands:
-
- * Batch files (in directory in system PATH)
-
-   antlr4.bat: java org.antlr.v4.Tool %*
-   run.bat:   java org.antlr.v4.runtime.misc.TestRig %*
-
- * Or, use doskey commands:
-
-   doskey antlr4=java org.antlr.v4.Tool $*
-   doskey grun  =java org.antlr.v4.runtime.misc.TestRig $*
-
-TESTING INSTALLATION
-
-Either launch org.antlr.v4.Tool directly:
-
-$ java org.antlr.v4.Tool
-ANTLR Parser Generator Version 4.1
-    -o ___              specify output directory where all output is generated
-    -lib ___            specify location of .tokens files
-...
-
-or use -jar option on java:
-
-$ java -jar /usr/local/lib/antlr-4.1-complete.jar
-ANTLR Parser Generator Version 4.1
-    -o ___              specify output directory where all output is generated
-    -lib ___            specify location of .tokens files
-...
-
-
-EXAMPLE
-
-In a temporary directory, put the following grammar inside file Hello.g4:
-
-// Define a grammar called Hello
-// match keyword hello followed by an identifier
-// match lower-case identifiers
-grammar Hello;
-r : 'hello' ID ;
-ID : [a-z]+ ;
-WS : [ \t\n]+ -> skip ; // skip spaces, tabs, newlines
-
-Then run ANTLR the tool on it:
-
-$ cd /tmp
-$ antlr4 Hello.g4
-$ javac Hello*.java
-
-Now test it:
-
-$ grun Hello r -tree
-hello parrt
-^D
-(r hello parrt)
-
-(That ^D means EOF on unix; it's ^Z in Windows.) The -tree option prints
-the parse tree in LISP notation.
-
-BOOK SOURCE CODE
-
-http://pragprog.com/titles/tpantlr2/source_code
-
-GRAMMARS
-
-https://github.com/antlr/grammars-v4
diff --git a/antlr4-maven-plugin/.classpath b/antlr4-maven-plugin/.classpath
deleted file mode 100644
index 595a5bf4f..000000000
--- a/antlr4-maven-plugin/.classpath
+++ /dev/null
@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<classpath>
-	<classpathentry kind="src" output="target/classes" path="src/main/java"/>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
-	<classpathentry kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER"/>
-	<classpathentry kind="output" path="target/classes"/>
-</classpath>
diff --git a/antlr4-maven-plugin/.project b/antlr4-maven-plugin/.project
deleted file mode 100644
index 1aedcc067..000000000
--- a/antlr4-maven-plugin/.project
+++ /dev/null
@@ -1,23 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>antlr4-maven-plugin</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>org.eclipse.jdt.core.javabuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-		<buildCommand>
-			<name>org.eclipse.m2e.core.maven2Builder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>org.eclipse.jdt.core.javanature</nature>
-		<nature>org.eclipse.m2e.core.maven2Nature</nature>
-	</natures>
-</projectDescription>
diff --git a/antlr4-maven-plugin/.settings/org.eclipse.core.resources.prefs b/antlr4-maven-plugin/.settings/org.eclipse.core.resources.prefs
deleted file mode 100644
index 99f26c020..000000000
--- a/antlr4-maven-plugin/.settings/org.eclipse.core.resources.prefs
+++ /dev/null
@@ -1,2 +0,0 @@
-eclipse.preferences.version=1
-encoding/<project>=UTF-8
diff --git a/antlr4-maven-plugin/.settings/org.eclipse.jdt.core.prefs b/antlr4-maven-plugin/.settings/org.eclipse.jdt.core.prefs
deleted file mode 100644
index 60105c1b9..000000000
--- a/antlr4-maven-plugin/.settings/org.eclipse.jdt.core.prefs
+++ /dev/null
@@ -1,5 +0,0 @@
-eclipse.preferences.version=1
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
-org.eclipse.jdt.core.compiler.compliance=1.6
-org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
-org.eclipse.jdt.core.compiler.source=1.6
diff --git a/antlr4-maven-plugin/.settings/org.eclipse.m2e.core.prefs b/antlr4-maven-plugin/.settings/org.eclipse.m2e.core.prefs
deleted file mode 100644
index f897a7f1c..000000000
--- a/antlr4-maven-plugin/.settings/org.eclipse.m2e.core.prefs
+++ /dev/null
@@ -1,4 +0,0 @@
-activeProfiles=
-eclipse.preferences.version=1
-resolveWorkspaceProjects=true
-version=1
diff --git a/antlr4-maven-plugin/pom.xml b/antlr4-maven-plugin/pom.xml
index 3e518518a..b9e144d33 100644
--- a/antlr4-maven-plugin/pom.xml
+++ b/antlr4-maven-plugin/pom.xml
@@ -1,9 +1,8 @@
 <!--
 
- [The "BSD license"]
-
- ANTLR        - Copyright (c) 2005-2010 Terence Parr
- Maven Plugin - Copyright (c) 2009      Jim Idle
+[The "BSD license"]
+ ANTLR        - Copyright (c) Terence Parr, Sam Harwell
+ Maven Plugin - Copyright (c) Jim Idle
 
  All rights reserved.
 
@@ -30,178 +29,132 @@
  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
   -->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <parent>
+    <groupId>org.antlr</groupId>
+    <artifactId>antlr4-master</artifactId>
+    <version>4.5.4-SNAPSHOT</version>
+  </parent>
+  <artifactId>antlr4-maven-plugin</artifactId>
+  <packaging>maven-plugin</packaging>
+  <name>ANTLR 4 Maven plugin</name>
+  <description>Maven plugin for ANTLR 4 grammars</description>
 
+  <prerequisites>
+    <maven>3.0</maven>
+  </prerequisites>
 
+  <!-- Ancilliary information for completeness -->
+  <inceptionYear>2009</inceptionYear>
 
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+  <!-- ============================================================================= -->
 
-    <modelVersion>4.0.0</modelVersion>
+  <!-- What are we depedent on for the Mojos to execute? We need the plugin 
+    API itself and of course we need the ANTLR Tool and runtime and any of their 
+    dependencies, which we inherit. The Tool itself provides us with all the 
+    dependencies, so we need only name it here. -->
+  <dependencies>
 
-    <parent>
-        <groupId>org.antlr</groupId>
-        <artifactId>antlr4-master</artifactId>
-        <version>4.1.1-SNAPSHOT</version>
-    </parent>
+    <!-- The things we need to build the target language recognizer -->
+    <dependency>
+      <groupId>org.apache.maven</groupId>
+      <artifactId>maven-plugin-api</artifactId>
+      <version>3.0.5</version>
+      <scope>compile</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.apache.maven</groupId>
+      <artifactId>maven-project</artifactId>
+      <version>2.2.1</version>
+    </dependency>
+    <dependency>
+      <groupId>org.codehaus.plexus</groupId>
+      <artifactId>plexus-compiler-api</artifactId>
+      <version>2.2</version>
+    </dependency>
+    <dependency>
+      <groupId>org.sonatype.plexus</groupId>
+      <artifactId>plexus-build-api</artifactId>
+      <version>0.0.7</version>
+    </dependency>
+    <!-- The version of ANTLR tool that this version of the plugin controls. 
+      We have decided that this should be in lockstep with ANTLR itself, other 
+      than -1 -2 -3 etc patch releases. -->
+    <dependency>
+      <groupId>org.antlr</groupId>
+      <artifactId>antlr4</artifactId>
+      <version>${project.version}</version>
+    </dependency>
+    <!-- Testing requirements... -->
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <version>4.11</version>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.apache.maven.shared</groupId>
+      <artifactId>maven-plugin-testing-harness</artifactId>
+      <version>1.1</version>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.apache.maven.plugin-tools</groupId>
+      <artifactId>maven-plugin-annotations</artifactId>
+      <version>3.2</version>
+      <scope>provided</scope>
+    </dependency>
+  </dependencies>
 
-    <artifactId>antlr4-maven-plugin</artifactId>
-    <packaging>maven-plugin</packaging>
+  <build>
+    <plugins>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-plugin-plugin</artifactId>
+        <version>3.3</version>
+        <configuration>
+          <!-- see http://jira.codehaus.org/browse/MNG-5346 -->
+          <skipErrorNoDescriptorsFound>true</skipErrorNoDescriptorsFound>
+        </configuration>
+        <executions>
+          <execution>
+            <id>mojo-descriptor</id>
+            <goals>
+              <goal>descriptor</goal>
+            </goals>
+          </execution>
+          <execution>
+            <id>help-goal</id>
+            <goals>
+              <goal>helpmojo</goal>
+            </goals>
+          </execution>
+        </executions>
+      </plugin>
+    </plugins>
+  </build>
 
-    <name>ANTLR 4 Maven plugin</name>
-    <description>Maven plugin for ANTLR 4 grammars</description>
-    <url>http://www.antlr.org</url>
-
-    <prerequisites>
-        <maven>3.0</maven>
-    </prerequisites>
-    
-    <!-- Ancilliary information for completeness
-      -->
-    <inceptionYear>2009</inceptionYear>
-
-    <!-- ============================================================================= -->
-
-    <!--
-
-     What are we depedent on for the Mojos to execute? We need the
-     plugin API itself and of course we need the ANTLR Tool and runtime
-     and any of their dependencies, which we inherit. The Tool itself provides
-     us with all the dependencies, so we need only name it here.
-      -->
-    <dependencies>
-
-        <!--
-          The things we need to build the target language recognizer
-          -->
-        <dependency>
-            <groupId>org.apache.maven</groupId>
-            <artifactId>maven-plugin-api</artifactId>
-            <version>3.0.5</version>
-            <scope>compile</scope>
-        </dependency>
-
-        <dependency>
-            <groupId>org.apache.maven</groupId>
-            <artifactId>maven-project</artifactId>
-            <version>2.2.1</version>
-        </dependency>
-
-        <dependency>
-            <groupId>org.codehaus.plexus</groupId>
-            <artifactId>plexus-compiler-api</artifactId>
-            <version>2.2</version>
-        </dependency>
-
-        <!--
-         The version of ANTLR tool that this version of the plugin controls.
-         We have decided that this should be in lockstep with ANTLR itself, other
-         than -1 -2 -3 etc patch releases.
-          -->
-        <dependency>
-            <groupId>org.antlr</groupId>
-            <artifactId>antlr4</artifactId>
-            <version>${project.version}</version>
-        </dependency>
-
-        <!--
-          Testing requirements...
-          -->
-        <dependency>
-
-            <groupId>junit</groupId>
-            <artifactId>junit</artifactId>
-            <version>4.11</version>
-            <scope>test</scope>
-
-        </dependency>
-
-        <dependency>
-            <groupId>org.apache.maven.shared</groupId>
-            <artifactId>maven-plugin-testing-harness</artifactId>
-            <version>1.1</version>
-            <scope>test</scope>
-        </dependency>
-
-        <dependency>
-            <groupId>org.apache.maven.plugin-tools</groupId>
-            <artifactId>maven-plugin-annotations</artifactId>
-            <version>3.2</version>
-            <scope>provided</scope>
-        </dependency>
-
-    </dependencies>
-    
-    <build>
-
-        <defaultGoal>install</defaultGoal>
-
-        <plugins>
-
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-plugin-plugin</artifactId>
-                <version>3.2</version>
-                <configuration>
-                    <!-- see http://jira.codehaus.org/browse/MNG-5346 -->
-                    <skipErrorNoDescriptorsFound>true</skipErrorNoDescriptorsFound>
-                </configuration>
-                <executions>
-                    <execution>
-                        <id>mojo-descriptor</id>
-                        <goals>
-                            <goal>descriptor</goal>
-                        </goals>
-                    </execution>
-                    <execution>
-                        <id>help-goal</id>
-                        <goals>
-                            <goal>helpmojo</goal>
-                        </goals>
-                    </execution>
-                </executions>
-            </plugin>
-
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-site-plugin</artifactId>
-                <version>3.3</version>
-            </plugin>
-
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-project-info-reports-plugin</artifactId>
-                <version>2.7</version>
-                <configuration>
-                    <dependencyLocationsEnabled>false</dependencyLocationsEnabled>
-                </configuration>
-            </plugin>
-
-        </plugins>
-
-    </build>
-
-    <reporting>
-        <plugins>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-plugin-plugin</artifactId>
-                <version>3.2</version>
-            </plugin>
-
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-javadoc-plugin</artifactId>
-                <version>2.9</version>
-                <configuration>
-                    <quiet>true</quiet>
-                </configuration>
-            </plugin>
-
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-jxr-plugin</artifactId>
-                <version>2.3</version>
-            </plugin>
-        </plugins>
-    </reporting>
+  <reporting>
+    <plugins>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-plugin-plugin</artifactId>
+        <version>3.3</version>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-javadoc-plugin</artifactId>
+        <version>2.9</version>
+        <configuration>
+          <quiet>true</quiet>
+        </configuration>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-jxr-plugin</artifactId>
+        <version>2.3</version>
+      </plugin>
+    </plugins>
+  </reporting>
 </project>
diff --git a/antlr4-maven-plugin/resources/META-INF/m2e/lifecycle-mapping-metadata.xml b/antlr4-maven-plugin/resources/META-INF/m2e/lifecycle-mapping-metadata.xml
new file mode 100644
index 000000000..de806eee9
--- /dev/null
+++ b/antlr4-maven-plugin/resources/META-INF/m2e/lifecycle-mapping-metadata.xml
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8"?>
+<lifecycleMappingMetadata>
+    <pluginExecutions>
+        <pluginExecution>
+            <pluginExecutionFilter>
+                <goals>
+                    <goal>antlr4</goal>
+                </goals>
+            </pluginExecutionFilter>
+            <action>
+                <execute>
+                    <runOnIncremental>true</runOnIncremental>
+                    <runOnConfiguration>true</runOnConfiguration>
+                </execute>
+            </action>
+        </pluginExecution>
+    </pluginExecutions>
+</lifecycleMappingMetadata>
diff --git a/antlr4-maven-plugin/src/main/java/org/antlr/mojo/antlr4/Antlr4ErrorLog.java b/antlr4-maven-plugin/src/main/java/org/antlr/mojo/antlr4/Antlr4ErrorLog.java
index e573b7a5f..b2518786e 100644
--- a/antlr4-maven-plugin/src/main/java/org/antlr/mojo/antlr4/Antlr4ErrorLog.java
+++ b/antlr4-maven-plugin/src/main/java/org/antlr/mojo/antlr4/Antlr4ErrorLog.java
@@ -28,10 +28,14 @@
 */
 package org.antlr.mojo.antlr4;
 
-import org.antlr.v4.runtime.misc.NotNull;
+import org.antlr.v4.Tool;
 import org.antlr.v4.tool.ANTLRMessage;
 import org.antlr.v4.tool.ANTLRToolListener;
 import org.apache.maven.plugin.logging.Log;
+import org.sonatype.plexus.build.incremental.BuildContext;
+import org.stringtemplate.v4.ST;
+
+import java.io.File;
 
 /**
  * This implementation of {@link ANTLRToolListener} reports messages to the
@@ -41,6 +45,8 @@ import org.apache.maven.plugin.logging.Log;
  */
 public class Antlr4ErrorLog implements ANTLRToolListener {
 
+    private final Tool tool;
+    private final BuildContext buildContext;
     private final Log log;
 
     /**
@@ -48,43 +54,70 @@ public class Antlr4ErrorLog implements ANTLRToolListener {
      *
      * @param log The Maven log
      */
-    public Antlr4ErrorLog(@NotNull Log log) {
+    public Antlr4ErrorLog(Tool tool, BuildContext buildContext, Log log) {
+        this.tool = tool;
+        this.buildContext = buildContext;
         this.log = log;
     }
 
     /**
      * {@inheritDoc}
-     * <p/>
+     * <p>
      * This implementation passes the message to the Maven log.
-     *
+     * </p>
      * @param message The message to send to Maven
      */
     @Override
     public void info(String message) {
+        if (tool.errMgr.formatWantsSingleLineMessage()) {
+            message = message.replace('\n', ' ');
+        }
         log.info(message);
     }
 
     /**
      * {@inheritDoc}
-     * <p/>
+     * <p>
      * This implementation passes the message to the Maven log.
-     *
+     * </p>
      * @param message The message to send to Maven.
      */
     @Override
     public void error(ANTLRMessage message) {
-        log.error(message.toString());
+        ST msgST = tool.errMgr.getMessageTemplate(message);
+        String outputMsg = msgST.render();
+        if (tool.errMgr.formatWantsSingleLineMessage()) {
+            outputMsg = outputMsg.replace('\n', ' ');
+        }
+
+        log.error(outputMsg);
+
+        if (message.fileName != null) {
+            String text = message.getMessageTemplate(false).render();
+            buildContext.addMessage(new File(message.fileName), message.line, message.charPosition, text, BuildContext.SEVERITY_ERROR, message.getCause());
+        }
     }
 
     /**
      * {@inheritDoc}
-     * <p/>
+     * <p>
      * This implementation passes the message to the Maven log.
-     *
+     * </p>
      * @param message
      */
     @Override
     public void warning(ANTLRMessage message) {
-        log.warn(message.toString());
+        ST msgST = tool.errMgr.getMessageTemplate(message);
+        String outputMsg = msgST.render();
+        if (tool.errMgr.formatWantsSingleLineMessage()) {
+            outputMsg = outputMsg.replace('\n', ' ');
+        }
+
+        log.warn(outputMsg);
+
+        if (message.fileName != null) {
+            String text = message.getMessageTemplate(false).render();
+            buildContext.addMessage(new File(message.fileName), message.line, message.charPosition, text, BuildContext.SEVERITY_WARNING, message.getCause());
+        }
     }
 }
diff --git a/antlr4-maven-plugin/src/main/java/org/antlr/mojo/antlr4/Antlr4Mojo.java b/antlr4-maven-plugin/src/main/java/org/antlr/mojo/antlr4/Antlr4Mojo.java
index a190b13bf..d8712ee6a 100644
--- a/antlr4-maven-plugin/src/main/java/org/antlr/mojo/antlr4/Antlr4Mojo.java
+++ b/antlr4-maven-plugin/src/main/java/org/antlr/mojo/antlr4/Antlr4Mojo.java
@@ -32,13 +32,13 @@ package org.antlr.mojo.antlr4;
 import org.antlr.v4.Tool;
 import org.antlr.v4.codegen.CodeGenerator;
 import org.antlr.v4.runtime.misc.MultiMap;
-import org.antlr.v4.runtime.misc.NotNull;
 import org.antlr.v4.runtime.misc.Utils;
 import org.antlr.v4.tool.Grammar;
 import org.apache.maven.plugin.AbstractMojo;
 import org.apache.maven.plugin.MojoExecutionException;
 import org.apache.maven.plugin.MojoFailureException;
 import org.apache.maven.plugin.logging.Log;
+import org.apache.maven.plugins.annotations.Component;
 import org.apache.maven.plugins.annotations.LifecyclePhase;
 import org.apache.maven.plugins.annotations.Mojo;
 import org.apache.maven.plugins.annotations.Parameter;
@@ -49,11 +49,13 @@ import org.codehaus.plexus.compiler.util.scan.SimpleSourceInclusionScanner;
 import org.codehaus.plexus.compiler.util.scan.SourceInclusionScanner;
 import org.codehaus.plexus.compiler.util.scan.mapping.SourceMapping;
 import org.codehaus.plexus.compiler.util.scan.mapping.SuffixMapping;
+import org.sonatype.plexus.build.incremental.BuildContext;
 
 import java.io.BufferedWriter;
 import java.io.File;
-import java.io.FileWriter;
 import java.io.IOException;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
 import java.io.StringWriter;
 import java.io.Writer;
 import java.net.URI;
@@ -143,10 +145,11 @@ public class Antlr4Mojo extends AbstractMojo {
 	 * the generate phase of the plugin. Note that the plugin is smart enough to
 	 * realize that imported grammars should be included but not acted upon
 	 * directly by the ANTLR Tool.
-	 * <p/>
+	 * <p>
 	 * A set of Ant-like inclusion patterns used to select files from the source
 	 * directory for processing. By default, the pattern
 	 * <code>**&#47;*.g4</code> is used to select grammar files.
+	 * </p>
 	 */
     @Parameter
     protected Set<String> includes = new HashSet<String>();
@@ -181,6 +184,9 @@ public class Antlr4Mojo extends AbstractMojo {
 	@Parameter(defaultValue = "${basedir}/src/main/antlr4/imports")
     private File libDirectory;
 
+	@Component
+	private BuildContext buildContext;
+
     public File getSourceDirectory() {
         return sourceDirectory;
     }
@@ -206,9 +212,9 @@ public class Antlr4Mojo extends AbstractMojo {
      * The main entry point for this Mojo, it is responsible for converting
      * ANTLR 4.x grammars into the target language specified by the grammar.
      *
-     * @throws MojoExecutionException if a configuration or grammar error causes
+     * @exception MojoExecutionException if a configuration or grammar error causes
      * the code generation process to fail
-     * @throws MojoFailureException if an instance of the ANTLR 4 {@link Tool}
+     * @exception MojoFailureException if an instance of the ANTLR 4 {@link Tool}
      * cannot be created
      */
     @Override
@@ -347,9 +353,9 @@ public class Antlr4Mojo extends AbstractMojo {
     /**
      *
      * @param sourceDirectory
-     * @throws InclusionScanException
+     * @exception InclusionScanException
      */
-    @NotNull
+
     private List<List<String>> processGrammarFiles(List<String> args, File sourceDirectory) throws InclusionScanException {
         // Which files under the source set should we be looking for as grammar files
         SourceMapping mapping = new SuffixMapping("g4", Collections.<String>emptySet());
@@ -366,6 +372,22 @@ public class Antlr4Mojo extends AbstractMojo {
         scan.addSourceMapping(mapping);
         Set<File> grammarFiles = scan.getIncludedSources(sourceDirectory, null);
 
+        // We don't want the plugin to run for every grammar, regardless of whether
+        // it's changed since the last compilation. Check the mtime of the tokens vs
+        // the grammar file mtime to determine whether we even need to execute.
+        Set<File> grammarFilesToProcess = new HashSet<File>();
+
+        for (File grammarFile : grammarFiles) {
+            String tokensFileName = grammarFile.getName().split("\\.")[0] + ".tokens";
+            File outputFile = new File(outputDirectory, tokensFileName);
+            if ( (! outputFile.exists()) ||
+                 outputFile.lastModified() < grammarFile.lastModified() ) {
+                grammarFilesToProcess.add(grammarFile);
+            }
+        }
+
+        grammarFiles = grammarFilesToProcess;
+
         if (grammarFiles.isEmpty()) {
             getLog().info("No grammars to process");
 			return Collections.emptyList();
@@ -375,6 +397,12 @@ public class Antlr4Mojo extends AbstractMojo {
 		// Iterate each grammar file we were given and add it into the tool's list of
 		// grammars to process.
 		for (File grammarFile : grammarFiles) {
+			if (!buildContext.hasDelta(grammarFile)) {
+				continue;
+			}
+
+			buildContext.removeMessages(grammarFile);
+
 			getLog().debug("Grammar file '" + grammarFile.getPath() + "' detected.");
 
 			String relPathBase = findSourceSubdir(sourceDirectory, grammarFile.getPath());
@@ -452,7 +480,7 @@ public class Antlr4Mojo extends AbstractMojo {
 
 		public CustomTool(String[] args) {
 			super(args);
-			addListener(new Antlr4ErrorLog(getLog()));
+			addListener(new Antlr4ErrorLog(this, buildContext, getLog()));
 		}
 
 		@Override
@@ -486,8 +514,8 @@ public class Antlr4Mojo extends AbstractMojo {
 
 			URI relativePath = project.getBasedir().toURI().relativize(outputFile.toURI());
 			getLog().debug("  Writing file: " + relativePath);
-			FileWriter fw = new FileWriter(outputFile);
-			return new BufferedWriter(fw);
+			OutputStream outputStream = buildContext.newFileOutputStream(outputFile);
+			return new BufferedWriter(new OutputStreamWriter(outputStream));
 		}
 	}
 }
diff --git a/build.xml b/build.xml
deleted file mode 100644
index e447a3394..000000000
--- a/build.xml
+++ /dev/null
@@ -1,279 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project name="ANTLR4" default="distribute" basedir=".">
-    <target name="basic-init">
-        <property file="user.build.properties"/>
-        <property name="dist.dir" value="${basedir}/dist" />
-        <property name="build.dir" value="${basedir}/build" />
-        <property name="lib.dir" value="${basedir}/lib" />
-    </target>
-
-    <target name="antlr3-init" depends="basic-init">
-        <property name="antlr3.version" value="3.5"/>
-        <property name="antlr3.jar.name" value="antlr-${antlr3.version}-complete-no-st3.jar"/>
-        <property name="antlr3.jar" value="${lib.dir}/${antlr3.jar.name}"/>
-        <mkdir dir="${lib.dir}"/>
-        <get src="http://antlr3.org/download/${antlr3.jar.name}" dest="${antlr3.jar}" skipexisting="true"/>
-        <path id="cp.antlr3" path="${antlr3.jar}"/>
-
-        <property name="build.antlr3.dir" value="${build.dir}/generated-sources/antlr3" />
-        <property name="antlr3.touch" value="${build.dir}/antlr3-${antlr3.version}.touch"/>
-    </target>
-
-    <target name="antlr4-init" depends="basic-init">
-        <property name="antlr4.version" value="4.1"/>
-        <property name="antlr4.jar.name" value="antlr-${antlr4.version}-complete.jar"/>
-        <property name="antlr4.jar" value="${lib.dir}/${antlr4.jar.name}"/>
-        <mkdir dir="${lib.dir}"/>
-        <get src="http://antlr.org/download/${antlr4.jar.name}" dest="${antlr4.jar}" skipexisting="true"/>
-        <path id="cp.antlr4" path="${antlr4.jar}"/>
-
-        <property name="build.antlr4.dir" value="${build.dir}/generated-sources/antlr4" />
-        <property name="antlr4.touch" value="${build.dir}/antlr4-${antlr4.version}.touch"/>
-    </target>
-
-    <target name="build-init" depends="basic-init">
-        <property name="version" value="4.1.1-dev"/>
-        <property name="build.sysclasspath" value="ignore"/>
-        <property name="install.root.dir" value="${dist.dir}/antlr-${version}" />
-        <property name="jar.file" value="${dist.dir}/antlr-${version}-complete.jar" />
-    </target>
-
-    <target name="clean" depends="basic-init">
-        <delete dir="${build.dir}" includeemptydirs="true"/>
-        <delete dir="${dist.dir}" includeemptydirs="true"/>
-    </target>
-
-    <target name="clean-all" depends="clean">
-        <delete dir="${lib.dir}" includeemptydirs="true"/>
-    </target>
-
-    <target name="antlr3-up-to-date" depends="basic-init,antlr3-init">
-        <uptodate targetfile="${antlr3.touch}" property="is.antlr3.uptodate">
-            <srcfiles dir="${basedir}/tool/src">
-                <include name="**/*.g"/>
-                <include name="**/*.tokens"/>
-            </srcfiles>
-            <srcfiles file="${antlr3.jar}"/>
-        </uptodate>
-    </target>
-
-    <target name="antlr4-up-to-date" depends="basic-init,antlr4-init">
-        <uptodate targetfile="${antlr4.touch}" property="is.antlr4.uptodate">
-            <srcfiles dir="${basedir}/tool/src">
-                <include name="**/*.g4"/>
-                <include name="**/*.tokens"/>
-            </srcfiles>
-            <srcfiles file="${antlr4.jar}"/>
-        </uptodate>
-    </target>
-
-    <target name="up-to-date" depends="antlr3-up-to-date,antlr4-up-to-date,build-init">
-        <uptodate targetfile="${jar.file}" property="is.source.uptodate">
-            <srcfiles dir="${basedir}/tool/src">
-                <include name="**/*.java"/>
-                <include name="**/*.g"/>
-                <include name="**/*.tokens"/>
-            </srcfiles>
-            <srcfiles dir="${basedir}/tool/resources">
-                <include name="**/*.st"/>
-                <include name="**/*.stg"/>
-            </srcfiles>
-            <srcfiles dir="${basedir}/runtime/Java/src/">
-                <include name="**/*.java"/>
-                <include name="**/*.g"/>
-                <include name="**/*.st"/>
-                <include name="**/*.stg"/>
-            </srcfiles>
-            <srcfiles dir="${build.antlr3.dir}"/>
-            <srcfiles file="${basedir}/runtime/Java/lib/org.abego.treelayout.core.jar"/>
-            <srcfiles file="${antlr3.jar}"/>
-        </uptodate>
-
-        <condition property="is.jar.uptodate">
-            <and>
-                <istrue value="${is.source.uptodate}"/>
-                <istrue value="${is.antlr3.uptodate}"/>
-            </and>
-        </condition>
-    </target>
-
-    <macrodef name="antlr3">
-        <attribute name="srcpath"/>
-        <element name="args" optional="true"/>
-        <sequential>
-            <local name="path.antlr3.local"/>
-            <local name="sources.antlr3.local"/>
-            <path id="path.antlr3.local">
-                <fileset dir="${basedir}/tool/src/@{srcpath}" includes="*.g"/>
-            </path>
-            <pathconvert pathsep=" " property="sources.antlr3.local" refid="path.antlr3.local">
-                <map from="${basedir}/tool/src/@{srcpath}/" to=""/>
-            </pathconvert>
-            <mkdir dir="${build.antlr3.dir}/@{srcpath}"/>
-            <java classname="org.antlr.Tool" fork="true" failonerror="true" maxmemory="300m"
-                  dir="${basedir}/tool/src/@{srcpath}">
-                <arg value="-o"/>
-                <arg value="${build.antlr3.dir}/@{srcpath}"/>
-                <args/>
-                <arg line="${sources.antlr3.local}"/>
-                <classpath>
-                    <path refid="cp.antlr3"/>
-                    <pathelement location="${java.class.path}"/>
-                </classpath>
-            </java>
-        </sequential>
-    </macrodef>
-
-    <macrodef name="antlr4">
-        <attribute name="srcpath"/>
-        <element name="args" optional="true"/>
-        <sequential>
-            <local name="path.antlr4.local"/>
-            <local name="sources.antlr4.local"/>
-            <path id="path.antlr4.local">
-                <fileset dir="${basedir}/runtime/Java/src/@{srcpath}" includes="*.g4"/>
-            </path>
-            <pathconvert pathsep=" " property="sources.antlr4.local" refid="path.antlr4.local">
-                <map from="${basedir}/runtime/Java/src/@{srcpath}/" to=""/>
-            </pathconvert>
-            <mkdir dir="${build.antlr4.dir}/@{srcpath}"/>
-            <java classname="org.antlr.v4.Tool" fork="true" failonerror="true" maxmemory="300m"
-                  dir="${basedir}/runtime/Java/src/@{srcpath}">
-                <arg value="-o"/>
-                <arg value="${build.antlr4.dir}/@{srcpath}"/>
-                <args/>
-                <arg line="${sources.antlr4.local}"/>
-                <classpath>
-                    <path refid="cp.antlr4"/>
-                    <pathelement location="${java.class.path}"/>
-                </classpath>
-            </java>
-        </sequential>
-    </macrodef>
-
-	<target name="antlr3" depends="build-init,antlr3-init,antlr3-up-to-date" unless="is.antlr3.uptodate">
-        <mkdir dir="${build.antlr3.dir}" />
-
-        <path id="sources.antlr3">
-            <fileset dir="${basedir}/tool/src" includes="**/*.g"/>
-        </path>
-        <pathconvert pathsep="${line.separator}  " property="echo.sources.antlr3" refid="sources.antlr3">
-            <map from="${basedir}/tool/src/" to=""/>
-        </pathconvert>
-        <echo message="Generating ANTLR 3 grammars:${line.separator}  ${echo.sources.antlr3}"/>
-
-        <antlr3 srcpath="org/antlr/v4/parse"/>
-
-        <antlr3 srcpath="org/antlr/v4/codegen">
-            <args>
-                <arg value="-lib"/>
-                <arg value="${build.antlr3.dir}/org/antlr/v4/parse"/>
-            </args>
-        </antlr3>
-
-        <touch file="${antlr3.touch}" mkdirs="true"/>
-	</target>
-
-    <target name="antlr4" depends="build-init,antlr4-init,antlr4-up-to-date" unless="is.antlr4.uptodate">
-           <mkdir dir="${build.antlr4.dir}" />
-
-           <path id="sources.antlr4">
-               <fileset dir="${basedir}/runtime/Java/src" includes="**/*.g4"/>
-           </path>
-           <pathconvert pathsep="${line.separator}  " property="echo.sources.antlr4" refid="sources.antlr4">
-               <map from="${basedir}/runtime/Java/src/" to=""/>
-           </pathconvert>
-           <echo message="Generating ANTLR 4 grammars:${line.separator}  ${echo.sources.antlr4}"/>
-
-           <antlr4 srcpath="org/antlr/v4/runtime/tree/xpath">
-                <args>
-                    <arg value="-package"/>
-                    <arg value="org.antlr.v4.runtime.tree.xpath"/>
-                </args>
-           </antlr4>
-
-           <touch file="${antlr4.touch}" mkdirs="true"/>
-   	</target>
-
-    <target name="compile" depends="build-init,antlr3,antlr4,up-to-date" description="Compile for generic OS" unless="is.jar.uptodate">
-        <mkdir dir="${build.dir}/classes"/>
-        <javac
-                destdir="${build.dir}/classes"
-                source="1.5"
-                target="1.5"
-                debug="true"
-                excludes="org/antlr/v4/test/**">
-            <compilerarg value="-Xlint"/>
-            <compilerarg value="-Xlint:-serial"/>
-            <classpath>
-                <path refid="cp.antlr3"/>
-                <pathelement location="${basedir}/runtime/Java/lib/org.abego.treelayout.core.jar"/>
-            </classpath>
-            <src path="${basedir}/tool/src:${basedir}/runtime/Java/src:${build.antlr3.dir}:${build.antlr4.dir}"/>
-        </javac>
-    </target>
-
-    <target name="build-jar" depends="up-to-date,compile" description="Build ANTLR 4.jar" unless="is.jar.uptodate">
-        <mkdir dir="${dist.dir}"/>
-
-        <jar jarfile="${jar.file}">
-            <fileset dir="${build.dir}/classes" includes="**/*.class"/>
-	    <fileset dir="${basedir}/tool/resources">
-		    <include name="**/*.st"/>
-		    <include name="**/*.stg"/>
-	    </fileset>
-            <zipfileset includes="org/antlr/**, org/antlr/stringtemplate/**, org/stringtemplate/v4/**" src="${antlr3.jar}"/>
-            <zipfileset includes="**/*.class" src="${basedir}/runtime/Java/lib/org.abego.treelayout.core.jar"/>
-            <manifest>
-                <attribute name="Version" value="${version}"/>
-                <attribute name="Main-Class" value="org.antlr.v4.Tool"/>
-            </manifest>
-        </jar>
-    </target>
-
-    <target name="zip-source" depends="compile">
-        <mkdir dir="${install.root.dir}"/>
-
-        <mkdir dir="${install.root.dir}/src"/>
-        <copy todir="${install.root.dir}/src">
-			<fileset dir="${basedir}/tool/src/">
-				<include name="**/*.java"/>
-				<include name="**/*.g"/>
-				<include name="**/*.st"/>
-				<include name="**/*.stg"/>
-			</fileset>
-			<fileset dir="${basedir}/tool/resources/">
-				<include name="**/*.st"/>
-				<include name="**/*.stg"/>
-			</fileset>
-			<fileset dir="${basedir}/runtime/Java/src/">
-				<include name="**/*.java"/>
-				<include name="**/*.g"/>
-				<include name="**/*.st"/>
-				<include name="**/*.stg"/>
-			</fileset>
-			<fileset dir="${build.antlr3.dir}"/>
-        </copy>
-
-        <copy todir="${install.root.dir}">
-            <fileset dir=".">
-                <include name="build.properties"/>
-                <include name="build.xml"/>
-                <include name="LICENSE.txt"/>
-                <include name="README.txt"/>
-                <include name="doxyfile"/>
-            </fileset>
-        </copy>
-
-        <copy todir="${install.root.dir}/lib" file="${antlr3.jar}">
-        </copy>
-
-        <zip destfile="${dist.dir}/antlr-${version}-src.zip">
-            <zipfileset dir="${install.root.dir}" prefix="antlr-${version}"/>
-        </zip>
-    </target>
-
-    <target name="distribute" depends="clean, zip-source, build-jar">
-    </target>
-
-</project>
diff --git a/build/Antlr4.Runtime.nuspec b/build/Antlr4.Runtime.nuspec
new file mode 100644
index 000000000..f629ba1fe
--- /dev/null
+++ b/build/Antlr4.Runtime.nuspec
@@ -0,0 +1,64 @@
+<?xml version="1.0" encoding="utf-8"?>
+<package xmlns="http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd">
+  <metadata>
+    <id>Antlr4.Runtime</id>
+    <version>0.0.0</version>
+    <authors>Sam Harwell, Terence Parr</authors>
+    <owners>Sam Harwell</owners>
+    <description>The runtime library for parsers generated by the C# target of ANTLR 4. This package supports projects targeting .NET 2.0 or newer, and built using Visual Studio 2008 or newer.</description>
+    <language>en-us</language>
+    <projectUrl>https://github.com/sharwell/antlr4cs</projectUrl>
+    <licenseUrl>https://raw.github.com/sharwell/antlr4cs/master/LICENSE.txt</licenseUrl>
+    <iconUrl>https://raw.github.com/antlr/website-antlr4/master/images/icons/antlr.png</iconUrl>
+    <copyright>Copyright © Sam Harwell 2014</copyright>
+    <releaseNotes>https://github.com/sharwell/antlr4cs/releases/v$version$</releaseNotes>
+    <requireLicenseAcceptance>true</requireLicenseAcceptance>
+    <tags>antlr antlr4 parsing</tags>
+    <title>ANTLR 4 Runtime</title>
+    <summary>The runtime library for parsers generated by the C# target of ANTLR 4.</summary>
+  </metadata>
+  <files>
+    <!-- Runtime Libraries -->
+
+    <file src="..\runtime\CSharp\Antlr4.Runtime\bin\net20\$Configuration$\Antlr4.Runtime.dll" target="lib\net20"/>
+    <file src="..\runtime\CSharp\Antlr4.Runtime\bin\net20\$Configuration$\Antlr4.Runtime.pdb" target="lib\net20"/>
+    <file src="..\runtime\CSharp\Antlr4.Runtime\bin\net20\$Configuration$\Antlr4.Runtime.xml" target="lib\net20"/>
+
+    <file src="..\runtime\CSharp\Antlr4.Runtime\bin\net30\$Configuration$\Antlr4.Runtime.dll" target="lib\net30"/>
+    <file src="..\runtime\CSharp\Antlr4.Runtime\bin\net30\$Configuration$\Antlr4.Runtime.pdb" target="lib\net30"/>
+    <file src="..\runtime\CSharp\Antlr4.Runtime\bin\net30\$Configuration$\Antlr4.Runtime.xml" target="lib\net30"/>
+
+    <file src="..\runtime\CSharp\Antlr4.Runtime\bin\net35-client\$Configuration$\Antlr4.Runtime.dll" target="lib\net35-client"/>
+    <file src="..\runtime\CSharp\Antlr4.Runtime\bin\net35-client\$Configuration$\Antlr4.Runtime.pdb" target="lib\net35-client"/>
+    <file src="..\runtime\CSharp\Antlr4.Runtime\bin\net35-client\$Configuration$\Antlr4.Runtime.xml" target="lib\net35-client"/>
+
+    <file src="..\runtime\CSharp\Antlr4.Runtime\bin\net40-client\$Configuration$\Antlr4.Runtime.dll" target="lib\net40-client"/>
+    <file src="..\runtime\CSharp\Antlr4.Runtime\bin\net40-client\$Configuration$\Antlr4.Runtime.pdb" target="lib\net40-client"/>
+    <file src="..\runtime\CSharp\Antlr4.Runtime\bin\net40-client\$Configuration$\Antlr4.Runtime.xml" target="lib\net40-client"/>
+
+    <file src="..\runtime\CSharp\Antlr4.Runtime\bin\net45\$Configuration$\Antlr4.Runtime.dll" target="lib\net45"/>
+    <file src="..\runtime\CSharp\Antlr4.Runtime\bin\net45\$Configuration$\Antlr4.Runtime.pdb" target="lib\net45"/>
+    <file src="..\runtime\CSharp\Antlr4.Runtime\bin\net45\$Configuration$\Antlr4.Runtime.xml" target="lib\net45"/>
+
+    <file src="..\runtime\CSharp\Antlr4.Runtime\bin\net35-cf\$Configuration$\Antlr4.Runtime.dll" target="lib\net35-cf"/>
+    <file src="..\runtime\CSharp\Antlr4.Runtime\bin\net35-cf\$Configuration$\Antlr4.Runtime.pdb" target="lib\net35-cf"/>
+    <file src="..\runtime\CSharp\Antlr4.Runtime\bin\net35-cf\$Configuration$\Antlr4.Runtime.xml" target="lib\net35-cf"/>
+
+    <file src="..\runtime\CSharp\Antlr4.Runtime\bin\portable-net40\$Configuration$\Antlr4.Runtime.dll" target="lib\portable-net4+sl5+netcore45+wpa81+wp8+MonoAndroid1+MonoTouch1"/>
+    <file src="..\runtime\CSharp\Antlr4.Runtime\bin\portable-net40\$Configuration$\Antlr4.Runtime.pdb" target="lib\portable-net4+sl5+netcore45+wpa81+wp8+MonoAndroid1+MonoTouch1"/>
+    <file src="..\runtime\CSharp\Antlr4.Runtime\bin\portable-net40\$Configuration$\Antlr4.Runtime.xml" target="lib\portable-net4+sl5+netcore45+wpa81+wp8+MonoAndroid1+MonoTouch1"/>
+
+    <file src="..\runtime\CSharp\Antlr4.Runtime\bin\portable-net45\$Configuration$\Antlr4.Runtime.dll" target="lib\portable-net45+netcore45+wpa81+wp8+MonoAndroid1+MonoTouch1"/>
+    <file src="..\runtime\CSharp\Antlr4.Runtime\bin\portable-net45\$Configuration$\Antlr4.Runtime.pdb" target="lib\portable-net45+netcore45+wpa81+wp8+MonoAndroid1+MonoTouch1"/>
+    <file src="..\runtime\CSharp\Antlr4.Runtime\bin\portable-net45\$Configuration$\Antlr4.Runtime.xml" target="lib\portable-net45+netcore45+wpa81+wp8+MonoAndroid1+MonoTouch1"/>
+
+    <file src="..\runtime\CSharp\Antlr4.Runtime\bin\netcore45\$Configuration$\Antlr4.Runtime.dll" target="lib\netcore45"/>
+    <file src="..\runtime\CSharp\Antlr4.Runtime\bin\netcore45\$Configuration$\Antlr4.Runtime.pdb" target="lib\netcore45"/>
+    <file src="..\runtime\CSharp\Antlr4.Runtime\bin\netcore45\$Configuration$\Antlr4.Runtime.xml" target="lib\netcore45"/>
+
+    <!-- Source Code -->
+
+    <file exclude="..\runtime\CSharp\Antlr4.Runtime\obj\**\*.cs" src="..\runtime\CSharp\Antlr4.Runtime\**\*.cs" target="src"/>
+    <file src="..\runtime\CSharp\Antlr4.Runtime\**\$Configuration$\*Lexer.cs" target="src"/>
+  </files>
+</package>
diff --git a/build/Antlr4.VS2008.nuspec b/build/Antlr4.VS2008.nuspec
new file mode 100644
index 000000000..36ffe7ec9
--- /dev/null
+++ b/build/Antlr4.VS2008.nuspec
@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="utf-8"?>
+<package xmlns="http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd">
+  <metadata minClientVersion="2.7">
+    <id>Antlr4.VS2008</id>
+    <version>0.0.0</version>
+    <authors>Sam Harwell, Terence Parr</authors>
+    <owners>Sam Harwell</owners>
+    <description>The C# target of the ANTLR 4 parser generator for Visual Studio 2008 projects. This package supports projects targeting .NET 2.0 or newer, and built using Visual Studio 2008.</description>
+    <language>en-us</language>
+    <projectUrl>https://github.com/sharwell/antlr4cs</projectUrl>
+    <licenseUrl>https://raw.github.com/sharwell/antlr4cs/master/LICENSE.txt</licenseUrl>
+    <iconUrl>https://raw.github.com/antlr/website-antlr4/master/images/icons/antlr.png</iconUrl>
+    <copyright>Copyright © Sam Harwell 2014</copyright>
+    <releaseNotes>https://github.com/sharwell/antlr4cs/releases/v$version$</releaseNotes>
+    <requireLicenseAcceptance>true</requireLicenseAcceptance>
+    <developmentDependency>true</developmentDependency>
+    <tags>antlr antlr4 parsing</tags>
+    <title>ANTLR 4 (Visual Studio 2008)</title>
+    <summary>The C# target of the ANTLR 4 parser generator for Visual Studio 2008 projects.</summary>
+    <dependencies>
+      <dependency id="Antlr4.Runtime" version="$version$" />
+    </dependencies>
+  </metadata>
+  <files>
+    <!-- Tools -->
+
+    <file src="..\tool\target\antlr4-csharp-$CSharpToolVersion$-complete.jar" target="tools"/>
+
+    <!-- Build Configuration -->
+
+    <file src="..\runtime\CSharp\Antlr4BuildTasks\bin\net35\$Configuration$\Antlr4.net35.props" target="build\Antlr4.props"/>
+    <file src="..\runtime\CSharp\Antlr4BuildTasks\bin\net35\$Configuration$\Antlr4.net35.targets" target="build\Antlr4.targets"/>
+    <file src="..\runtime\CSharp\Antlr4BuildTasks\bin\net35\$Configuration$\Antlr4BuildTasks.net35.dll" target="build"/>
+  </files>
+</package>
diff --git a/build/Antlr4.nuspec b/build/Antlr4.nuspec
new file mode 100644
index 000000000..9dc4e4754
--- /dev/null
+++ b/build/Antlr4.nuspec
@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="utf-8"?>
+<package xmlns="http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd">
+  <metadata minClientVersion="2.7">
+    <id>Antlr4</id>
+    <version>0.0.0</version>
+    <authors>Sam Harwell, Terence Parr</authors>
+    <owners>Sam Harwell</owners>
+    <description>The C# target of the ANTLR 4 parser generator for Visual Studio 2010+ projects. This package supports projects targeting .NET 2.0 or newer, and built using Visual Studio 2010 or newer.</description>
+    <language>en-us</language>
+    <projectUrl>https://github.com/sharwell/antlr4cs</projectUrl>
+    <licenseUrl>https://raw.github.com/sharwell/antlr4cs/master/LICENSE.txt</licenseUrl>
+    <iconUrl>https://raw.github.com/antlr/website-antlr4/master/images/icons/antlr.png</iconUrl>
+    <copyright>Copyright © Sam Harwell 2014</copyright>
+    <releaseNotes>https://github.com/sharwell/antlr4cs/releases/v$version$</releaseNotes>
+    <requireLicenseAcceptance>true</requireLicenseAcceptance>
+    <developmentDependency>true</developmentDependency>
+    <tags>antlr antlr4 parsing</tags>
+    <title>ANTLR 4</title>
+    <summary>The C# target of the ANTLR 4 parser generator for Visual Studio 2010+ projects.</summary>
+    <dependencies>
+      <dependency id="Antlr4.Runtime" version="$version$" />
+    </dependencies>
+  </metadata>
+  <files>
+    <!-- Tools -->
+
+    <file src="..\tool\target\antlr4-csharp-$CSharpToolVersion$-complete.jar" target="tools"/>
+
+    <!-- Build Configuration -->
+
+    <file src="..\runtime\CSharp\Antlr4BuildTasks\bin\net40\$Configuration$\Antlr4.net40.props" target="build\Antlr4.props"/>
+    <file src="..\runtime\CSharp\Antlr4BuildTasks\bin\net40\$Configuration$\Antlr4.net40.targets" target="build\Antlr4.targets"/>
+    <file src="..\runtime\CSharp\Antlr4BuildTasks\bin\net40\$Configuration$\Antlr4BuildTasks.net40.dll" target="build"/>
+  </files>
+</package>
diff --git a/build/build.ps1 b/build/build.ps1
new file mode 100644
index 000000000..5dcc5e607
--- /dev/null
+++ b/build/build.ps1
@@ -0,0 +1,139 @@
+param (
+	[switch]$Debug,
+	[string]$VisualStudioVersion = "12.0",
+	[switch]$NoClean,
+	[string]$Java6Home,
+	[string]$MavenHome,
+	[string]$MavenRepo = "$($env:USERPROFILE)\.m2",
+	[switch]$SkipMaven,
+	[switch]$SkipKeyCheck
+)
+
+# build the solutions
+$SolutionPath = "..\Runtime\CSharp\Antlr4.sln"
+$CF35SolutionPath = "..\Runtime\CSharp\Antlr4.VS2008.sln"
+
+# make sure the script was run from the expected path
+if (!(Test-Path $SolutionPath)) {
+	echo "The script was run from an invalid working directory."
+	exit 1
+}
+
+. .\version.ps1
+
+If ($Debug) {
+	$BuildConfig = 'Debug'
+} Else {
+	$BuildConfig = 'Release'
+}
+
+If ($NoClean) {
+	$Target = 'build'
+} Else {
+	$Target = 'rebuild'
+}
+
+If (-not $MavenHome) {
+	$MavenHome = $env:M2_HOME
+}
+
+$Java6RegKey = 'HKLM:\SOFTWARE\JavaSoft\Java Runtime Environment\1.6'
+$Java6RegValue = 'JavaHome'
+If (-not $Java6Home -and (Test-Path $Java6RegKey)) {
+	$JavaHomeKey = Get-Item -LiteralPath $Java6RegKey
+	If ($JavaHomeKey.GetValue($Java6RegValue, $null) -ne $null) {
+		$JavaHomeProperty = Get-ItemProperty $Java6RegKey $Java6RegValue
+		$Java6Home = $JavaHomeProperty.$Java6RegValue
+	}
+}
+
+# this is configured here for path checking, but also in the .props and .targets files
+[xml]$pom = Get-Content "..\tool\pom.xml"
+$CSharpToolVersionNodeInfo = Select-Xml "/mvn:project/mvn:version" -Namespace @{mvn='http://maven.apache.org/POM/4.0.0'} $pom
+$CSharpToolVersion = $CSharpToolVersionNodeInfo.Node.InnerText.trim()
+
+# build the main project
+$msbuild = "$env:windir\Microsoft.NET\Framework64\v4.0.30319\msbuild.exe"
+
+&$msbuild '/nologo' '/m' '/nr:false' "/t:$Target" "/p:Configuration=$BuildConfig" "/p:VisualStudioVersion=$VisualStudioVersion" $SolutionPath
+if ($LASTEXITCODE -ne 0) {
+	$host.ui.WriteErrorLine('Build failed, aborting!')
+	exit $p.ExitCode
+}
+
+# build the compact framework project
+$msbuild = "$env:windir\Microsoft.NET\Framework\v4.0.30319\msbuild.exe"
+
+&$msbuild '/nologo' '/m' '/nr:false' '/t:rebuild' "/p:Configuration=$BuildConfig" $CF35SolutionPath
+if ($LASTEXITCODE -ne 0) {
+	$host.ui.WriteErrorLine('.NET 3.5 Compact Framework Build failed, aborting!')
+	exit $p.ExitCode
+}
+
+if (-not (Test-Path 'nuget')) {
+	mkdir "nuget"
+}
+
+# Build the Java library using Maven
+If (-not $SkipMaven) {
+	$OriginalPath = $PWD
+
+	cd '..\tool'
+	$MavenPath = "$MavenHome\bin\mvn.bat"
+	If (-not (Test-Path $MavenPath)) {
+		$host.ui.WriteErrorLine("Couldn't locate Maven binary: $MavenPath")
+		cd $OriginalPath
+		exit 1
+	}
+
+	If (-not (Test-Path $Java6Home)) {
+		$host.ui.WriteErrorLine("Couldn't locate Java 6 installation: $Java6Home")
+		cd $OriginalPath
+		exit 1
+	}
+
+	$MavenGoal = 'package'
+	&$MavenPath '-DskipTests=true' '--errors' '-e' '-Dgpg.useagent=true' "-Djava6.home=$Java6Home" '-Psonatype-oss-release' $MavenGoal
+	if ($LASTEXITCODE -ne 0) {
+		$host.ui.WriteErrorLine('Maven build of the C# Target custom Tool failed, aborting!')
+		cd $OriginalPath
+		exit $p.ExitCode
+	}
+
+	cd $OriginalPath
+}
+
+$JarPath = "..\tool\target\antlr4-csharp-$CSharpToolVersion-complete.jar"
+if (!(Test-Path $JarPath)) {
+	$host.ui.WriteErrorLine("Couldn't locate the complete jar used for building C# parsers: $JarPath")
+	exit 1
+}
+
+# By default, do not create a NuGet package unless the expected strong name key files were used
+if (-not $SkipKeyCheck) {
+	. .\keys.ps1
+
+	foreach ($pair in $Keys.GetEnumerator()) {
+		$assembly = Resolve-FullPath -Path "..\runtime\CSharp\Antlr4.Runtime\bin\$($pair.Key)\$BuildConfig\Antlr4.Runtime.dll"
+		# Run the actual check in a separate process or the current process will keep the assembly file locked
+		powershell -Command ".\check-key.ps1 -Assembly '$assembly' -ExpectedKey '$($pair.Value)' -Build '$($pair.Key)'"
+		if ($LASTEXITCODE -ne 0) {
+			Exit $p.ExitCode
+		}
+	}
+}
+
+$packages = @(
+	'Antlr4.Runtime'
+	'Antlr4'
+	'Antlr4.VS2008')
+
+$nuget = '..\runtime\CSharp\.nuget\NuGet.exe'
+ForEach ($package in $packages) {
+	If (-not (Test-Path ".\$package.nuspec")) {
+		$host.ui.WriteErrorLine("Couldn't locate NuGet package specification: $package")
+		exit 1
+	}
+
+	&$nuget 'pack' ".\$package.nuspec" '-OutputDirectory' 'nuget' '-Prop' "Configuration=$BuildConfig" '-Version' "$AntlrVersion" '-Prop' "M2_REPO=$M2_REPO" '-Prop' "CSharpToolVersion=$CSharpToolVersion" '-Symbols'
+}
diff --git a/build/check-key.ps1 b/build/check-key.ps1
new file mode 100644
index 000000000..b92a9cdcc
--- /dev/null
+++ b/build/check-key.ps1
@@ -0,0 +1,31 @@
+param(
+	[string]$Assembly,
+	[string]$ExpectedKey,
+	[string]$Build = $null
+)
+
+function Get-PublicKeyToken() {
+	param([string]$assembly = $null)
+	if ($assembly) {
+		$bytes = $null
+		$bytes = [System.Reflection.Assembly]::ReflectionOnlyLoadFrom($assembly).GetName().GetPublicKeyToken()
+		if ($bytes) {
+			$key = ""
+			for ($i=0; $i -lt $bytes.Length; $i++) {
+				$key += "{0:x2}" -f $bytes[$i]
+			}
+
+			$key
+		}
+	}
+}
+
+if (-not $Build) {
+	$Build = $Assembly
+}
+
+$actual = Get-PublicKeyToken -assembly $Assembly
+if ($actual -ne $ExpectedKey) {
+	$host.ui.WriteErrorLine("Invalid publicKeyToken for '$Build'; expected '$ExpectedKey' but found '$actual'")
+	exit 1
+}
diff --git a/build/keys.ps1 b/build/keys.ps1
new file mode 100644
index 000000000..4e2f34250
--- /dev/null
+++ b/build/keys.ps1
@@ -0,0 +1,17 @@
+# Note: these values may only change during minor release
+$Keys = @{
+	'net20' = '7983ae52036899ac'
+	'net30' = '7671200403f6656a'
+	'net35-cf' = '770a97458f51159e'
+	'net35-client' = '4307381ae04f9aa7'
+	'net40-client' = 'bb1075973a9370c4'
+	'net45' = 'edc21c04cf562012'
+	'netcore45' = 'e4e9019902d0b6e2'
+	'portable-net40' = '90bf14da8e1462b4'
+	'portable-net45' = '3d23c8e77559f391'
+}
+
+function Resolve-FullPath() {
+	param([string]$Path)
+	[System.IO.Path]::GetFullPath((Join-Path (pwd) $Path))
+}
diff --git a/build/push.ps1 b/build/push.ps1
new file mode 100644
index 000000000..17791c1cd
--- /dev/null
+++ b/build/push.ps1
@@ -0,0 +1,29 @@
+. .\version.ps1
+
+If ($AntlrVersion.EndsWith('-dev')) {
+	$host.ui.WriteErrorLine("Cannot push development version '$AntlrVersion' to NuGet.")
+	Exit 1
+}
+
+$packages = @(
+	'Antlr4.Runtime'
+	'Antlr4'
+	'Antlr4.VS2008')
+
+# Make sure all packages exist before pushing any packages
+ForEach ($package in $packages) {
+	If (-not (Test-Path ".\nuget\$package.$AntlrVersion.nupkg")) {
+		$host.ui.WriteErrorLine("Couldn't locate NuGet package: $JarPath")
+		exit 1
+	}
+
+	If (-not (Test-Path ".\nuget\$package.$AntlrVersion.symbols.nupkg")) {
+		$host.ui.WriteErrorLine("Couldn't locate NuGet symbols package: $JarPath")
+		exit 1
+	}
+}
+
+$nuget = '..\runtime\CSharp\.nuget\NuGet.exe'
+ForEach ($package in $packages) {
+	&$nuget 'push' ".\nuget\$package.$AntlrVersion.nupkg"
+}
diff --git a/build/version.ps1 b/build/version.ps1
new file mode 100644
index 000000000..457481bd8
--- /dev/null
+++ b/build/version.ps1
@@ -0,0 +1 @@
+$AntlrVersion = "4.5.1"
diff --git a/contributors.txt b/contributors.txt
index 91c887522..203aa1eec 100644
--- a/contributors.txt
+++ b/contributors.txt
@@ -55,3 +55,41 @@ YYYY/MM/DD, github id, Full name, email
 2013/01/29, metadave, Dave Parfitt, diparfitt@gmail.com
 2013/03/06, bkiers, Bart Kiers, bkiers@gmail.com
 2013/08/20, cayhorstmann, Cay Horstmann, cay@horstmann.com
+2014/03/18, aphyr, Kyle Kingsbury, aphyr@aphyr.com
+2014/06/07, ericvergnaud, Eric Vergnaud, eric.vergnaud@wanadoo.fr
+2014/07/04, jimidle, Jim Idle, jimi@Idle.ws
+2014/09/04. jeduden, Jan-Eric Duden, jeduden@gmail.com
+2014/09/27, petrbel, Petr Bělohlávek, antlr@petrbel.cz
+2014/10/18, sergiusignacius, Sérgio Silva, serge.a.silva@gmail.com
+2014/10/26, bdkearns, Brian Kearns, bdkearns@gmail.com
+2014/10/27, michaelpj, Michael Peyton Jones, michaelpj@gmail.com
+2015/01/29, TomLottermann, Thomas Lottermann, tomlottermann@gmail.com
+2015/02/15, pavlo, Pavlo Lysov, pavlikus@gmail.com
+2015/03/07, RedTailedHawk, Lawrence Parker, larry@answerrocket.com
+2015/04/03, rljacobson, Robert Jacobson, rljacobson@gmail.com
+2015/04/06, ojakubcik, Ondrej Jakubcik, ojakubcik@gmail.com
+2015/04/29, jszheng, Jinshan Zheng, zheng_js@hotmail.com
+2015/05/08, ViceIce, Michael Kriese, michael.kriese@gmx.de
+2015/05/09, lkraz, Luke Krasnoff, luke.krasnoff@gmail.com
+2015/05/12, Pursuit92, Josh Chase, jcjoshuachase@gmail.com
+2015/05/20, peturingi, Pétur Ingi Egilsson, petur@petur.eu
+2015/05/27, jcbrinfo, Jean-Christophe Beaupré, jcbrinfo@users.noreply.github.com
+2015/06/29, jvanzyl, Jason van Zyl, jason@takari.io
+2015/08/18, krzkaczor, Krzysztof Kaczor, krzysztof@kaczor.io
+2015/09/18, worsht, Rajiv Subrahmanyam, rajiv.public@gmail.com
+2015/09/24, HSorensen, Henrik Sorensen, henrik.b.sorensen@gmail.com
+2015/10/06, brwml, Bryan Wilhelm, bryan.wilhelm@microsoft.com
+2015/10/08, fedotovalex, Alex Fedotov, me@alexfedotov.com
+2015/10/12, KvanTTT, Ivan Kochurkin, ivan.kochurkin@gmail.com
+2015/10/21, martin-probst, Martin Probst, martin-probst@web.de
+2015/10/21, hkff, Walid Benghabrit, walid.benghabrit@mines-nantes.fr
+2015/11/12, cooperra, Robbie Cooper, cooperra@users.noreply.github.com
+2015/11/25, abego, Udo Borkowski, ub@abego.org
+2015/12/17, sebadur, Sebastian Badur, sebadur@users.noreply.github.com
+2015/12/23, pboyer, Peter Boyer, peter.b.boyer@gmail.com
+2015/12/24, dtymon, David Tymon, david.tymon@gmail.com
+2016/02/18, reitzig, Raphael Reitzig, reitzig[at]cs.uni-kl.de
+2016/03/10, mike-lischke, Mike Lischke, mike@lischke-online.de
+2016/03/27, beardlybread, Bradley Steinbacher, bradley.j.steinbacher@gmail.com
+2016/03/29, msteiger, Martin Steiger, antlr@martin-steiger.de
+2016/03/28, gagern, Martin von Gagern, gagern@ma.tum.de
diff --git a/doc/IDEs.md b/doc/IDEs.md
new file mode 100644
index 000000000..c36d68f10
--- /dev/null
+++ b/doc/IDEs.md
@@ -0,0 +1,8 @@
+# Integrating ANTLR into Development Systems
+
+The Java target is the reference implementation mirrored by other targets. The following pages help you integrate ANTLR into development environments and build systems appropriate for your target language.  As of January 2015, we have Java, C#, Python 2, Python 3, and JavaScript targets.
+
+The easiest thing is probably just to use an [ANTLR plug-in](http://www.antlr.org/tools.html) for your favorite development environment.
+ 
+Java IDE Integration
+C# IDE Integration
diff --git a/doc/ace-javascript-target.md b/doc/ace-javascript-target.md
new file mode 100644
index 000000000..fbba9e9b9
--- /dev/null
+++ b/doc/ace-javascript-target.md
@@ -0,0 +1,247 @@
+# Integrating ANTLR JavaScript parsers with ACE editor
+
+Having the ability to parse code other than JavaScript is great, but nowadays users expect to be able to edit code with nice edit features such as keyword highlighting, indentation and brace matching, and advanced ones such as syntax checking.
+
+I have been through the process of integrating an ANTLR parser with ACE, the dominant code editor for web based code editing. Information about ACE can be found on their web site. 
+
+This page describes my experience, and humbly aims to help you get started. It is not however a reference guide, and no support is provided.
+
+## Architecture
+
+The ACE editor is organized as follows
+
+1. The editor itself is a <div> which once initialized comprises a number of elements. This UI element is responsible for the display, and the generation of edit events.
+1. The editor relies on a Session, which manages events and configuration.
+1. The code itself is stored in a Document. Any insertion or deletion of text is reflected in the Document.
+1. Keyword highlighting, indentation and brace matching are delegated to a mode. There is no direct equivalent of an ACE mode in ANTLR. While keywords are the equivalent of ANTLR lexer tokens, indentation and brace matching are edit tasks, not parsing ones. A given ACE editor can only have one mode, which corresponds to the language being edited. There is no need for ANTLR integration to support keyword highlighting, indentation and brace matching.
+1. Syntax checking is delegated to a worker. This is where ANTLR integration is needed. If syntax checking is enabled, ACE asks the mode to create a worker. In JavaScript, workers run in complete isolation i.e. they don't share code or variables with other workers, or with the HTML page itself.
+1. The below diagram describes how the whole system works. In green are the components *you* need to provide. You'll notice that there is no need to load ANTLR in the HTML page itself. You'll also notice that ACE maintains a document in each thread. This is done through low level events sent by the ACE session to the worker which describe the delta. Once applied to the worker document, a high level event is triggered, which is easy to handle since at this point the worker document is a perfect copy of the UI document.  
+
+<img src=images/ACE-Architecture.001.png>
+
+## Step-by-step guide
+
+The first thing to do is to create an editor in your html page. This is thoroughly described in the ACE documentation, so we'll just sum it up here:
+
+```xml
+<script src="../js/ace/ace.js" type="text/javascript" charset="utf-8"></script>
+<script>
+    var editor = ace.edit("editor");
+</script>
+```
+
+This should give you a working editor. You may want to control its sizing using CSS. I personally load the editor in an iframe and set its style to position: absolute, top: 0, left: 0 etc... but I'm sure you know better than me how to achieve results. 
+
+The second thing to do is to configure the ACE editor to use your mode i.e. language configuration. A good place to start is to inherit from the built-in TextMode. The following is a very simple example, which only caters for comments, literals, and a limited subset of separators and keywords :
+
+```javascript
+ace.define('ace/mode/my-mode',["require","exports","module","ace/lib/oop","ace/mode/text","ace/mode/text_highlight_rules", "ace/worker/worker_client" ], function(require, exports, module) {
+    var oop = require("ace/lib/oop");
+    var TextMode = require("ace/mode/text").Mode;
+    var TextHighlightRules = require("ace/mode/text_highlight_rules").TextHighlightRules;
+
+    var MyHighlightRules = function() {
+        var keywordMapper = this.createKeywordMapper({
+            "keyword.control": "if|then|else",
+            "keyword.operator": "and|or|not",
+            "keyword.other": "class",
+            "storage.type": "int|float|text",
+            "storage.modifier": "private|public",
+            "support.function": "print|sort",
+            "constant.language": "true|false"
+  }, "identifier");
+        this.$rules = {
+            "start": [
+                { token : "comment", regex : "//" },
+                { token : "string",  regex : '["](?:(?:\\\\.)|(?:[^"\\\\]))*?["]' },
+                { token : "constant.numeric", regex : "0[xX][0-9a-fA-F]+\\b" },
+                { token : "constant.numeric", regex: "[+-]?\\d+(?:(?:\\.\\d*)?(?:[eE][+-]?\\d+)?)?\\b" },
+                { token : "keyword.operator", regex : "!|%|\\\\|/|\\*|\\-|\\+|~=|==|<>|!=|<=|>=|=|<|>|&&|\\|\\|" },
+                { token : "punctuation.operator", regex : "\\?|\\:|\\,|\\;|\\." },
+                { token : "paren.lparen", regex : "[[({]" },
+                { token : "paren.rparen", regex : "[\\])}]" },
+                { token : "text", regex : "\\s+" },
+                { token: keywordMapper, regex: "[a-zA-Z_$][a-zA-Z0-9_$]*\\b" }
+            ]
+        };
+    };
+    oop.inherits(MyHighlightRules, TextHighlightRules);
+
+    var MyMode = function() {
+        this.HighlightRules = MyHighlightRules;
+    };
+    oop.inherits(MyMode, TextMode);
+
+    (function() {
+
+        this.$id = "ace/mode/my-mode";
+
+    }).call(MyMode.prototype);
+
+    exports.Mode = MyMode;
+});
+```
+
+Now if you store the above in a file called "my-mode.js", setting the ACE Editor becomes straightforward:
+
+```xml
+<script src="../js/ace/ace.js" type="text/javascript" charset="utf-8"></script>
+<script src="../js/my-mode.js" type="text/javascript" charset="utf-8"></script>
+<script>
+    var editor = ace.edit("editor");
+    editor.getSession().setMode("ace/mode/my-mode");
+</script>
+```
+
+At this point you should have a working editor, able to highlight keywords. You may wonder why you need to set the tokens when you have already done so in your ANTLR lexer grammar. First, ACE expects a classification (control, operator, type...) which does not exist in ANTLR. Second, there is no need for ANTLR to achieve this, since ACE comes with its own lexer.
+
+Ok, now that we have a working editor comes the time where we need syntax validation. This is where the worker comes in the picture.
+
+Creating the worker is the responsibility of the mode you provide. So you need to enhance it with something like the following:
+ 
+```javascript
+var WorkerClient = require("ace/worker/worker_client").WorkerClient;
+this.createWorker = function(session) {
+    this.$worker = new WorkerClient(["ace"], "ace/worker/my-worker", "MyWorker", "../js/my-worker.js");
+    this.$worker.attachToDocument(session.getDocument());
+
+    this.$worker.on("errors", function(e) {
+        session.setAnnotations(e.data);
+    });
+
+    this.$worker.on("annotate", function(e) {
+        session.setAnnotations(e.data);
+    });
+
+    this.$worker.on("terminate", function() {
+        session.clearAnnotations();
+    });
+
+    return this.$worker;
+
+};
+```
+
+The above code needs to be placed in the existing worker, after: 
+
+```javascript
+this.$id = "ace/mode/my-mode";
+```
+
+Please note that the mode code runs on the UI side, not the worker side. The event handlers here are for events sent by the worker, not to the worker.
+
+Obviously the above won't work out of the box, because you need to provide the "my-worker.js" file.
+
+Creating a worker from scratch is not something I've tried. Simply put, your worker needs to handle all messages sent by ACE using the WorkerClient created by the mode. This is not a simple task, and is better delegated to existing ACE code, so we can focus on tasks specific to our language.
+
+What I did is I started from "mode-json.js", a rather simple worker which comes with ACE, stripped out all JSON validation related stuff out of it, and saved the remaining code in a file name "worker-base.js" which you can find [here](resources/worker-base.js). Once this done, I was able to create a simple worker, as follows:
+
+```javascript
+importScripts("worker-base.js");
+ace.define('ace/worker/my-worker',["require","exports","module","ace/lib/oop","ace/worker/mirror"], function(require, exports, module) {
+    "use strict";
+
+    var oop = require("ace/lib/oop");
+    var Mirror = require("ace/worker/mirror").Mirror;
+
+    var MyWorker = function(sender) {
+        Mirror.call(this, sender);
+        this.setTimeout(200);
+        this.$dialect = null;
+    };
+
+    oop.inherits(MyWorker, Mirror);
+
+    (function() {
+
+        this.onUpdate = function() {
+            var value = this.doc.getValue();
+            var annotations = validate(value);
+            this.sender.emit("annotate", annotations);
+        };
+
+    }).call(MyWorker.prototype);
+
+    exports.MyWorker = MyWorker;
+});
+
+var validate = function(input) {
+    return [ { row: 0, column: 0, text: "MyMode says Hello!", type: "error" } ];
+};
+```
+
+At this point, you should have an editor which displays an error icon next to the first line. When you hover over the error icon, it should display: MyMode says Hello!. Is that not a friendly worker? Yum.
+
+What remains to be done is have our validate function actually validate the input. Finally ANTLR comes in the picture!
+
+To start with, let's load ANTLR and your parser, listener etc.. Easy, since you could write:
+
+```js
+var antlr4 = require('antlr4/index');
+```
+
+This may work, but it's actually unreliable. The reason is that the require function used by ANTLR, which exactly mimics the NodeJS require function, uses a different syntax than the require function that comes with ACE. So we need to bring in a require function that conforms to the NodeJS syntax. I personally use one that comes from Torben Haase's Honey project, which you can find here. But hey, now we're going to have 2 'require' functions not compatible with each other! Indeed, this is why you need to take special care, as follows:
+
+```js
+// load nodejs compatible require
+var ace_require = require;
+require = undefined;
+var Honey = { 'requirePath': ['..'] }; // walk up to js folder, see Honey docs
+importScripts("../lib/require.js");
+var antlr4_require = require;
+require = ace_require;
+```
+Now it's safe to load antlr, and the parsers generated for your language. Assuming that your language files (generated or hand-built) are in a folder with an index.js file that calls require for each file, your parser loading code can be as simple as follows:
+```js
+// load antlr4 and myLanguage
+var antlr4, mylanguage;
+try {
+    require = antlr4_require;
+    antlr4 = require('antlr4/index');
+    mylanguage = require('mylanguage/index');
+} finally {
+    require = ace_require;
+}
+```
+Please note the try-finally construct. ANTLR uses 'require' synchronously so it's perfectly safe to ignore the ACE 'require' while running ANTLR code. ACE itself does not guarantee synchronous execution, so you are much safer always switching 'require' back to 'ace_require'.
+Now detecting deep syntax errors in your code is a task for your ANTLR listener or visitor or whatever piece of code you've delegated this to. We're not going to describe this here, since it would require some knowledge of your language. However, detecting grammar syntax errors is something ANTLR does beautifully (isn't that why you went for ANTLR in the first place?). So what we will illustrate here is how to report grammar syntax errors. I have no doubt that from there, you will be able to extend the validator to suit your specific needs.
+Whenever ANTLR encounters an unexpected token, it fires an error. By default, the error is routed to an error listener which simply writes to the console.
+What we need to do is replace this listener by our own listener, se we can route errors to the ACE editor. First, let's create such a listener:
+```js
+// class for gathering errors and posting them to ACE editor
+var AnnotatingErrorListener = function(annotations) {
+    antlr4.error.ErrorListener.call(this);
+    this.annotations = annotations;
+    return this;
+};
+
+AnnotatingErrorListener.prototype = Object.create(antlr4.error.ErrorListener.prototype);
+AnnotatingErrorListener.prototype.constructor = AnnotatingErrorListener;
+
+AnnotatingErrorListener.prototype.syntaxError = function(recognizer, offendingSymbol, line, column, msg, e) {
+    this.annotations.push({
+        row: line - 1,
+        column: column,
+        text: msg,
+        type: "error"
+ });
+};
+```
+With this, all that remains to be done is plug the listener in when we parse the code. Here is how I do it:
+```js
+var validate = function(input) {
+    var stream = new antlr4.InputStream(input);
+    var lexer = new mylanguage.MyLexer(stream);
+    var tokens = new antlr4.CommonTokenStream(lexer);
+    var parser = new mylanguage.MyParser(tokens);
+    var annotations = [];
+    var listener = new AnnotatingErrorListener(annotations)
+    parser.removeErrorListeners();
+    parser.addErrorListener(listener);
+    parser.parseMyRule();
+    return annotations;
+};
+```
+You know what? That's it! You now have an ACE editor that does syntax validation using ANTLR! I hope you find this useful, and simple enough to get started.
+What I did not address here is packaging, not something I'm an expert at. The good news is that it makes development simple, since I don't have to run any compilation process. I just edit my code, reload my editor page, and check how it goes.
+Now wait, hey! How do you debug this? Well, as usual, using Chrome, since neither Firefox or Safari are able to debug worker code. What a shame...
diff --git a/doc/actions.md b/doc/actions.md
new file mode 100644
index 000000000..91b6de1e4
--- /dev/null
+++ b/doc/actions.md
@@ -0,0 +1,204 @@
+# Actions and Attributes
+
+In Chapter 10, Attributes and Actions, we learned how to embed actions within grammars and looked at the most common token and rule attributes. This section summarizes the important syntax and semantics from that chapter and provides a complete list of all available attributes. (You can learn more about actions in the grammar from the free excerpt on listeners and actions.)
+
+Actions are blocks of text written in the target language and enclosed in curly braces. The recognizer triggers them according to their locations within the grammar. For example, the following rule emits "found a decl" after the parser has seen a valid declaration:
+
+```
+decl: type ID ';' {System.out.println("found a decl");} ;
+type: 'int' | 'float' ;
+```
+
+Most often, actions access the attributes of tokens and rule references:
+
+```
+decl: type ID ';'
+      {System.out.println("var "+$ID.text+":"+$type.text+";");}
+    | t=ID id=ID ';'
+      {System.out.println("var "+$id.text+":"+$t.text+";");}
+    ;
+```
+
+## Token Attributes
+
+All tokens have a collection of predefined, read-only attributes. The attributes include useful token properties such as the token type and text matched for a token. Actions can access these attributes via $ label.attribute where label labels a particular instance of a token reference (a and b in the example below are used in the action code as $a and $b). Often, a particular token is only referenced once in the rule, in which case the token name itself can be used unambiguously in the action code (token INT can be used as $INT in the action). The following example illustrates token attribute expression syntax:
+
+```
+r : INT {int x = $INT.line;}
+    ( ID {if ($INT.line == $ID.line) ...;} )?
+    a=FLOAT b=FLOAT {if ($a.line == $b.line) ...;}
+  ;
+```
+
+The action within the `(...)?` subrule can see the `INT` token matched before it in the outer level.
+
+Because there are two references to the `FLOAT` token, a reference to `$FLOAT` in an action is not unique; you must use labels to specify which token reference you’re interested in.
+
+Token references within different alternatives are unique because only one of them can be matched for any invocation of the rule. For example, in the following rule, actions in both alternatives can reference $ID directly without using a label:
+
+```
+ 	r : ... ID {System.out.println($ID.text);}
+ 	| ... ID {System.out.println($ID.text);}
+ 	;
+```
+
+To access the tokens matched for literals, you must use a label:
+
+```
+ 	stat: r='return' expr ';' {System.out.println("line="+$r.line);} ;
+```
+
+Most of the time you access the attributes of the token, but sometimes it is useful to access the Token object itself because it aggregates all the attributes. Further, you can use it to test whether an optional subrule matched a token:
+
+```
+ 	stat: 'if' expr 'then' stat (el='else' stat)?
+ 	{if ( $el!=null ) System.out.println("found an else");}
+ 	| ...
+ 	;
+```
+
+`$T` and `$L` evaluate to `Token` objects for token name `T` and token label `L`. `$ll` evaluates to `List<Token>` for list label `ll`. `$T.attr` evaluates to the type and value specified in the following table for attribute `attr`:
+
+
+|Attribute|Type|Description|
+|---------|----|-----------|
+|text|String|The text matched for the token; translates to a call to getText. Example: $ID.text.|
+|type|int|The token type (nonzero positive integer) of the token such as INT; translates to a call to getType. Example: $ID.type.|
+|line|int|The line number on which the token occurs, counting from 1; translates to a call to getLine. Example: $ID.line.|
+|pos|int|The character position within the line at which the token’s first character occurs counting from zero; translates to a call togetCharPositionInLine. Example: $ID.pos.|
+|index|int|The overall index of this token in the token stream, counting from zero; translates to a call to getTokenIndex. Example: $ID.index.|
+|channel|int|The token’s channel number. The parser tunes to only one channel, effectively ignoring off-channel tokens. The default channel is 0 (Token.DEFAULT_CHANNEL), and the default hidden channel is Token.HIDDEN_CHANNEL. Translates to a call to getChannel. Example: $ID.channel.|
+|int|int|The integer value of the text held by this token; it assumes that the text is a valid numeric string. Handy for building calculators and so on. Translates to Integer.valueOf(text-of-token). Example: $INT.int.|
+
+## Parser Rule Attributes
+
+ANTLR predefines a number of read-only attributes associated with parser rule references that are available to actions. Actions can access rule attributes only for references that precede the action. The syntax is $ r.attr for rule name r or a label assigned to a rule reference. For example, $expr.text returns the complete text matched by a preceding invocation of rule expr:
+
+```
+returnStat : 'return' expr {System.out.println("matched "+$expr.text);} ;
+```
+
+Using a rule label looks like this:
+
+```
+returnStat : 'return' e=expr {System.out.println("matched "+e.text);} ;
+```
+
+You can also use `$ followed by the name of the attribute to access the value associated with the currently executing rule. For example, `$start` is the starting token of the current rule.
+
+```
+returnStat : 'return' expr {System.out.println("first token "+$start.getText());} ;
+```
+
+`$r` and `$rl` evaluate to `ParserRuleContext` objects of type `RContext` for rule name `r` and rule label `rl`. `$rll` evaluates to `List<RContext>` for rule list label `rll`. `$r.attr` evaluates to the type and value specified in the following table for attribute `attr`:
+
+|Attribute|Type|Description|
+|---------|----|-----------|
+|text|String|The text matched for a rule or the text matched from the start of the rule up until the point of the `$text` expression evaluation. Note that this includes the text for all tokens including those on hidden channels, which is what you want because usually that has all the whitespace and comments. When referring to the current rule, this attribute is available in any action including any exception actions.|
+|start|Token|The first token to be potentially matched by the rule that is on the main token channel; in other words, this attribute is never a hidden token. For rules that end up matching no tokens, this attribute points at the first token that could have been matched by this rule. When referring to the current rule, this attribute is available to any action within the rule.|
+|stop|Token|The last nonhidden channel token to be matched by the rule. When referring to the current rule, this attribute is available only to the after and finally actions.|
+|ctx|ParserRuleContext|The rule context object associated with a rule invocation. All of the other attributes are available through this attribute. For example, `$ctx.start` accesses the start field within the current rules context object. It’s the same as `$start`.|
+
+## Dynamically-Scoped Attributes
+
+You can pass information to and from rules using parameters and return values, just like functions in a general-purpose programming language. Programming languages don’t allow functions to access the local variables or parameters of invoking functions, however. For example, the following reference to local variable xfrom a nested method call is illegal in Java:
+
+```java
+void f() {
+	int x = 0;
+	g();
+}
+void g() {
+	h();
+}
+void h() {
+	int y = x; // INVALID reference to f's local variable x
+}
+```
+
+Variable x is available only within the scope of f, which is the text lexically delimited by curly brackets. For this reason, Java is said to use lexical scoping. Lexical scoping is the norm for most programming languages. Languages that allow methods further down in the call chain to access local variables defined earlier are said to use dynamic scoping. The term dynamic refers to the fact that a compiler cannot statically determine the set of visible variables. This is because the set of variables visible to a method changes depending on who calls that method.
+
+It turns out that, in the grammar realm, distant rules sometimes need to communicate with each other, mostly to provide context information to rules matched below in the rule invocation chain. (Naturally, this assumes that you are using actions directly in the grammar instead of the parse-tree listener event mechanism.) ANTLR allows dynamic scoping in that actions can access attributes from invoking rules using syntax `$r::x` where `r` is a rule name and `x` is an attribute within that rule. It is up to the programmer to ensure that `r` is in fact an invoking rule of the current rule. A runtime exception occurs if `r` is not in the current call chain when you access `$r::x`.
+
+To illustrate the use of dynamic scoping, consider the real problem of defining variables and ensuring that variables in expressions are defined. The following grammar defines the symbols attribute where it belongs in the block rule but adds variable names to it in rule `decl`. Rule `stat` then consults the list to see whether variables have been defined.
+
+```
+grammar DynScope;
+ 
+prog: block ;
+ 
+block
+	/* List of symbols defined within this block */
+	locals [
+	List<String> symbols = new ArrayList<String>()
+	]
+	: '{' decl* stat+ '}'
+	// print out all symbols found in block
+	// $block::symbols evaluates to a List as defined in scope
+	{System.out.println("symbols="+$symbols);}
+	;
+ 
+/** Match a declaration and add identifier name to list of symbols */
+decl: 'int' ID {$block::symbols.add($ID.text);} ';' ;
+ 
+/** Match an assignment then test list of symbols to verify
+ * that it contains the variable on the left side of the assignment.
+ * Method contains() is List.contains() because $block::symbols
+ * is a List.
+ */
+stat: ID '=' INT ';'
+	{
+	if ( !$block::symbols.contains($ID.text) ) {
+	System.err.println("undefined variable: "+$ID.text);
+	}
+	}
+	| block
+	;
+ 
+ID : [a-z]+ ;
+INT : [0-9]+ ;
+WS : [ \t\r\n]+ -> skip ;
+```
+
+Here’s a simple build and test sequence:
+
+```bash
+$ antlr4 DynScope.g4
+$ javac DynScope*.java
+$ grun DynScope prog
+=> 	{
+=> 	int i;
+=> 	i = 0;
+=> 	j = 3;
+=> 	}
+=> 	EOF
+<= 	undefined variable: j
+ 	symbols=[i]
+```
+
+There’s an important difference between a simple field declaration in a `@members` action and dynamic scoping. symbols is a local variable and so there is a copy for each invocation of rule `block`. That’s exactly what we want for nested blocks so that we can reuse the same input variable name in an inner block. For example, the following nested code block redefines i in the inner scope. This new definition must hide the definition in the outer scope.
+
+```
+{
+	int i;
+	int j;
+	i = 0;
+	{
+		int i;
+		int x;
+		x = 5;
+	}
+	x = 3;
+}
+```
+
+Here’s the output generated for that input by DynScope:
+
+```bash
+$ grun DynScope prog nested-input
+symbols=[i, x]
+undefined variable: x
+symbols=[i, j]
+```
+
+Referencing `$block::symbols` accesses the `symbols` field of the most recently invoked `block`’s rule context object. If you need access to a symbols instance from a rule invocation farther up the call chain, you can walk backwards starting at the current context, `$ctx`. Use `getParent` to walk up the chain.
diff --git a/doc/adding-tests.md b/doc/adding-tests.md
new file mode 100644
index 000000000..769383d31
--- /dev/null
+++ b/doc/adding-tests.md
@@ -0,0 +1,119 @@
+# Adding unit tests
+
+## Generating Runtime Tests
+
+Because ANTLR supports multiple target languages, the unit tests are broken into two groups: the unit tests that test the tool itself (in `tool-testsuite`)  and the unit tests that test the parser runtimes (in antlr4/runtime-testsuite). To avoid a lot of cut-and-paste, we generate all **runtime** tests from a set of templates using [runtime-testsuite/src/org/antlr/v4/testgen/TestGenerator.java](../runtime-testsuite/src/org/antlr/v4/testgen/TestGenerator.java). The `mvn` command is simple to use:
+
+```
+$ cd ~/antlr/code/antlr4/runtime-testsuite
+$ mvn -Pgen generate-test-sources
+...
+rootDir = /Users/parrt/antlr/code/antlr4/runtime-testsuite
+outputDir = /Users/parrt/antlr/code/antlr4/runtime-testsuite/test
+templates = /Users/parrt/antlr/code/antlr4/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates
+target = ALL
+browsers = false
+viz = false
+```
+
+It basically runs the Java program:
+
+```bash
+$ java org.antlr.v4.testgen.TestGenerator \
+	-root ~/antlr/code/antlr4/runtime-testsuite \
+	-outdir ~/antlr/code/antlr4/runtime-testsuite/test \
+	-templates ~/antlr/code/antlr4/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates
+```
+
+## Adding a runtime test
+
+For each target, you will find an `Index.stg` file with a dictionary of all test groups. E.g., `runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Index.stg` looks like:
+
+```
+TestFolders ::= [
+        "CompositeLexers": [],
+        "CompositeParsers": [],
+        "FullContextParsing": [],
+        "LeftRecursion": [],
+        "LexerErrors": [],
+        "LexerExec": [],
+        "Listeners": [],
+        "ParserErrors": [],
+        "ParserExec": [],
+        "ParseTrees": [],
+        "Performance": [],
+        "SemPredEvalLexer": [],
+        "SemPredEvalParser": [],
+        "Sets": []
+]
+```
+
+Then each group has a subdirectory with another index. E.g., `Sets/Index.stg` looks like:
+
+```
+TestTemplates ::= [
+        "SeqDoesNotBecomeSet": [],
+        "ParserSet": [],
+        "ParserNotSet": [],
+        "ParserNotToken": [],
+        "ParserNotTokenWithLabel": [],
+        "RuleAsSet": [],
+        "NotChar": [],
+        "OptionalSingleElement": [],
+...
+```
+
+For every name mentioned, you will find a `.stg` file with the actual test. E.g., `Sets/StarSet.stg`:
+
+```
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "abaac"
+
+Rule() ::= "a"
+
+Output() ::= <<
+abaac<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a : ('a'|'b')* 'c' {<InputText():writeln()>} ;
+>>
+```
+
+### Cross-language actions embedded within grammars
+
+To get:
+
+```
+System.out.println($set.stop);
+```
+
+Use instead the language-neutral:
+
+```
+<writeln("$set.stop")>
+```
+
+File `runtime-testsuite/resources/org/antlr/v4/test/runtime/java/Java.test.stg` has templates like:
+
+```
+writeln(s) ::= <<System.out.println(<s>);>>
+```
+
+## Adding an ANTLR tool unit test
+
+Just go into the appropriate Java test class in dir `antlr4/tool-testsuite/test/org/antlr/v4/test/tool` and add your unit test.
+
+
diff --git a/doc/building-antlr.md b/doc/building-antlr.md
new file mode 100644
index 000000000..f6780d970
--- /dev/null
+++ b/doc/building-antlr.md
@@ -0,0 +1,125 @@
+# Building ANTLR
+
+Most programmers do not need the information on this page because they will simply download the appropriate jar(s) or use ANTLR through maven (via ANTLR's antlr4-maven-plugin). If you would like to fork the project and fix bugs or tweak the runtime code generation, then you will almost certainly need to build ANTLR itself. There are two components:
+
+ 1. the tool that compiles grammars down into parsers and lexers in one of the target languages
+ 1. the runtime used by those generated parsers and lexers.
+
+I will assume that the root directory is `/tmp` for the purposes of explaining how to build ANTLR in this document.
+
+# Get the source
+
+The first step is to get the Java source code from the ANTLR 4 repository at github. You can download the repository from github, but the easiest thing to do is simply clone the repository on your local disk:
+
+```bash
+$ cd /tmp
+/tmp $ git clone git@github.com:antlr/antlr4.git
+Cloning into 'antlr4'...
+remote: Counting objects: 43273, done.
+remote: Compressing objects: 100% (57/57), done.
+remote: Total 43273 (delta 26), reused 0 (delta 0)
+Receiving objects: 100% (43273/43273), 18.76 MiB | 1.60 MiB/s, done.
+Resolving deltas: 100% (22419/22419), done.
+Checking connectivity... done.
+```
+
+# Compile
+
+```bash
+$ cd /tmp
+$ git clone git@github.com:antlr/antlr4.git
+Cloning into 'antlr4'...
+remote: Counting objects: 59858, done.
+remote: Compressing objects: 100% (57/57), done.
+remote: Total 59858 (delta 28), reused 9 (delta 9), pack-reused 59786
+Receiving objects: 100% (59858/59858), 31.10 MiB | 819.00 KiB/s, done.
+Resolving deltas: 100% (31898/31898), done.
+Checking connectivity... done.
+$ cd antlr4
+$ mvn compile
+..
+[INFO] Reactor Summary:
+[INFO] 
+[INFO] ANTLR 4 ............................................ SUCCESS [  0.447 s]
+[INFO] ANTLR 4 Runtime .................................... SUCCESS [  3.113 s]
+[INFO] ANTLR 4 Tool ....................................... SUCCESS [ 14.408 s]
+[INFO] ANTLR 4 Maven plugin ............................... SUCCESS [  1.276 s]
+[INFO] ANTLR 4 Runtime Test Generator ..................... SUCCESS [  0.773 s]
+[INFO] ANTLR 4 Tool Tests ................................. SUCCESS [  6.920 s]
+[INFO] ------------------------------------------------------------------------
+[INFO] BUILD SUCCESS
+...
+```
+
+# Testing tool and targets
+
+In order to perform the tests on all target languages, make sure that you have `mono` and `nodejs` installed. For example, on OS X:
+
+```bash
+$ brew install mono
+$ brew install node
+```
+
+To run the tests and **install into local repository** `~/.m2/repository/org/antlr`, do this:
+
+```bash
+$ mvn install
+...
+-------------------------------------------------------
+ T E S T S
+-------------------------------------------------------
+Running org.antlr.v4.test.runtime.csharp.TestCompositeLexers
+dir /var/folders/s1/h3qgww1x0ks3pb30l8t1wgd80000gn/T/TestCompositeLexers-1446068612451
+Starting build /usr/bin/xbuild /p:Configuration=Release /var/folders/s1/h3qgww1x0ks3pb30l8t1wgd80000gn/T/TestCompositeLexers-1446068612451/Antlr4.Test.mono.csproj
+dir /var/folders/s1/h3qgww1x0ks3pb30l8t1wgd80000gn/T/TestCompositeLexers-1446068615081
+Starting build /usr/bin/xbuild /p:Configuration=Release /var/folders/s1/h3qgww1x0ks3pb30l8t1wgd80000gn/T/TestCompositeLexers-1446068615081/Antlr4.Test.mono.csproj
+Tests run: 2, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 3.451 sec
+Running org.antlr.v4.test.runtime.csharp.TestCompositeParsers
+dir /var/folders/s1/h3qgww1x0ks3pb30l8t1wgd80000gn/T/TestCompositeParsers-1446068615864
+antlr reports warnings from [-visitor, -Dlanguage=CSharp, -o, /var/folders/s1/h3qgww1x0ks3pb30l8t1wgd80000gn/T/TestCompositeParsers-1446068615864, -lib, /var/folders/s1/h3qgww1x0ks3pb30l8t1wgd80000gn/T/TestCompositeParsers-1446068615864, -encoding, UTF-8, /var/folders/s1/h3qgww1x0ks3pb30l8t1wgd80000gn/T/TestCompositeParsers-1446068615864/M.g4]
+...
+[INFO] ------------------------------------------------------------------------
+[INFO] Reactor Summary:
+[INFO] 
+[INFO] ANTLR 4 ............................................ SUCCESS [  0.462 s]
+[INFO] ANTLR 4 Runtime .................................... SUCCESS [  9.163 s]
+[INFO] ANTLR 4 Tool ....................................... SUCCESS [  3.683 s]
+[INFO] ANTLR 4 Maven plugin ............................... SUCCESS [  1.897 s]
+[INFO] ANTLR 4 Runtime Test Generator ..................... SUCCESS [07:11 min]
+[INFO] ANTLR 4 Tool Tests ................................. SUCCESS [ 16.694 s]
+[INFO] ------------------------------------------------------------------------
+[INFO] BUILD SUCCESS
+[INFO] ------------------------------------------------------------------------
+[INFO] Total time: 07:43 min
+...
+```
+
+You should see these jars (building 4.5.2-SNAPSHOT):
+
+```bash
+/Users/parrt/.m2/repository/org/antlr $ find antlr4* -name '*.jar'
+antlr4/4.5/antlr4-4.5.jar
+antlr4/4.5.2-SNAPSHOT/antlr4-4.5.2-SNAPSHOT-tests.jar
+antlr4/4.5.2-SNAPSHOT/antlr4-4.5.2-SNAPSHOT.jar
+antlr4-maven-plugin/4.5/antlr4-maven-plugin-4.5.jar
+antlr4-maven-plugin/4.5.2-SNAPSHOT/antlr4-maven-plugin-4.5.2-SNAPSHOT.jar
+antlr4-runtime/4.5/antlr4-runtime-4.5.jar
+antlr4-runtime/4.5.2-SNAPSHOT/antlr4-runtime-4.5.2-SNAPSHOT.jar
+antlr4-runtime-testsuite/4.5.2-SNAPSHOT/antlr4-runtime-testsuite-4.5.2-SNAPSHOT-tests.jar
+antlr4-runtime-testsuite/4.5.2-SNAPSHOT/antlr4-runtime-testsuite-4.5.2-SNAPSHOT.jar
+antlr4-tool-testsuite/4.5.2-SNAPSHOT/antlr4-tool-testsuite-4.5.2-SNAPSHOT.jar
+```
+
+Note that ANTLR is written in itself, which is why maven downloads antlr4-4.5.jar for boostrapping 4.5.2-SNAPSHOT purposes.
+
+To build without running the tests (saves about 8 minutes), do this:
+
+```bash
+mvn -DskipTests install
+```
+
+## Building ANTLR in Intellij IDE
+
+After download ANTLR source, just "import project from existing sources" and click on the "Maven Projects" tab in right gutter of IDE. It should build stuff in the background automatically and look like:
+
+<img src=images/intellij-maven.png width=200>
\ No newline at end of file
diff --git a/doc/creating-a-language-target.md b/doc/creating-a-language-target.md
new file mode 100644
index 000000000..fe6150cb0
--- /dev/null
+++ b/doc/creating-a-language-target.md
@@ -0,0 +1,22 @@
+# Creating an ANTLR Language Target
+
+This document describes how to make ANTLR generate parsers in a new language, *X*.
+
+## Overview
+
+Creating a new target involves the following key elements:
+
+1. For the tool, create class *X*Target as a subclass of class `Target` in package `org.antlr.v4.codegen.target`. This class describes language specific details about escape characters and strings and so on. There is very little to do here typically.
+1. Create *X*.stg in directory tool/resources/org/antlr/v4/tool/templates/codegen/*X*/*X*.stg. This is a [StringTemplate](http://www.stringtemplate.org/) group file (`.stg`) that tells ANTLR how to express all of the parsing elements needed to generate code.  You will see templates called `ParserFile`, `Parser`, `Lexer`, `CodeBlockForAlt`, `AltBlock`, etc... Each of these must be described how to build the indicated chunk of code. Your best bet is to find the closest existing target, copy that template file, and tweak to suit.
+1. Create a runtime library to support the parsers generated by ANTLR. Under directory runtime/*X*, you are in complete control of the directory structure as dictated by common usage of that target language. For example, Java has: `runtime/Java/lib` and `runtime/Java/src` directories. Under `src`, you will find a directory structure for package `org.antlr.v4.runtime` and below.
+1. Create a template file for runtime tests. All you have to do is provide a few simple templates that indicate how to print values and declare variables. Our runtime test mechanism in dir `runtime-testsuite` will automatically generate code in a new target and check the results. All it needs to know is how to generate a test rig (i.e., a `main` program), how to define various class fields, compare members and so on. You must create a *X* directory underneath `runtime-testsuite/resources/org/antlr/v4/test/runtime`. Again, your best bet is to copy the templates from the closest language to your target and tweak it to suit.
+
+## Getting started
+
+1. Fork the `antlr/antlr4` repository at github to your own user so that you have repository `username/antlr4`.
+2. Clone `username/antlr4`, forked repository, to your local disk.  Your remote `origin` will be the forked repository on GitHub. Add a remote `upstream` to the original `antlr/antlr4` repository (URL `https://github.com/antlr/antlr4.git`). Changes that you would like to contribute back to the project are done with [pull requests](https://help.github.com/articles/using-pull-requests/).
+3. Try to build it before doing anything
+```bash
+$ mvn compile
+```
+That should proceed with success. See [Building ANTLR](building-antlr.md) for more details. (That link does not currently work as I have that documentation in a branch. see https://github.com/parrt/antlr4/blob/move-doc-to-repo/doc/building-antlr.md for now.)
diff --git a/doc/csharp-target.md b/doc/csharp-target.md
new file mode 100644
index 000000000..05c2df7c1
--- /dev/null
+++ b/doc/csharp-target.md
@@ -0,0 +1,99 @@
+# C&sharp;
+
+See also [Sam Harwell's Alternative C# target](https://github.com/tunnelvisionlabs/antlr4cs)
+
+### Which frameworks are supported?
+
+The C# runtime is CLS compliant, and only requires a corresponding 3.5 .Net framework.
+
+In practice, the runtime has been extensively tested against:
+
+* Microsoft .Net 3.5 framework
+* Mono .Net 3.5 framework
+
+No issue was found, so you should find that the runtime works pretty much against any recent .Net framework.
+
+### How do I get started?
+
+You will find full instructions on the Git web page for ANTLR C# runtime.
+ 
+### How do I use the runtime from my project?
+
+(i.e., How do I run the generated lexer and/or parser?)
+
+Let's suppose that your grammar is named, as above, "MyGrammar".
+
+Let's suppose this parser comprises a rule named "StartRule"
+
+The tool will have generated for you the following files:
+
+*  MyGrammarLexer.cs
+*   MyGrammarParser.cs
+*   MyGrammarListener.cs (if you have not activated the -no-listener option)
+*   MyGrammarBaseListener.js (if you have not activated the -no-listener option)
+*   MyGrammarVisitor.js (if you have activated the -visitor option)
+*   MyGrammarBaseVisitor.js (if you have activated the -visitor option)
+
+Now a fully functioning code might look like the following:
+
+```
+using Antlr4.Runtime;
+     
+public void MyParseMethod() {
+      String input = "your text to parse here";
+      AntlrInputStream stream = new InputStream(input);
+      ITokenSource lexer = new MyGrammarLexer(stream);
+      ITokenStream tokens = new CommonTokenStream(lexer);
+      MyGrammarParser parser = new MyGrammarParser(tokens);
+      parser.buildParseTrees = true;
+      IParseTree tree = parser.StartRule();
+}
+```
+
+This program will work. But it won't be useful unless you do one of the following:
+
+* you visit the parse tree using a custom listener
+* you visit the parse tree using a custom visitor
+* your grammar comprises production code (like AntLR3)
+
+(please note that production code is target specific, so you can't have multi target grammars that include production code)
+ 
+### How do I create and run a custom listener?
+
+Let's suppose your MyGrammar grammar comprises 2 rules: "key" and "value".
+
+The antlr4 tool will have generated the following listener (only partial code shown here): 
+
+```
+interface IMyGrammarParserListener : IParseTreeListener {
+      void EnterKey (MyGrammarParser.KeyContext context);
+      void ExitKey (MyGrammarParser.KeyContext context);
+      void EnterValue (MyGrammarParser.ValueContext context);
+      void ExitValue (MyGrammarParser.ValueContext context);
+}
+```
+ 
+In order to provide custom behavior, you might want to create the following class:
+ 
+```
+class KeyPrinter : MyGrammarBaseListener {
+    // override default listener behavior
+    void ExitKey (MyGrammarParser.KeyContext context) {
+        Console.WriteLine("Oh, a key!");
+    }
+}
+```
+   
+In order to execute this listener, you would simply add the following lines to the above code:
+ 
+ 
+```
+...
+IParseTree tree = parser.StartRule() - only repeated here for reference
+KeyPrinter printer = new KeyPrinter();
+ParseTreeWalker.DEFAULT.walk(printer, tree);
+```
+        
+Further information can be found from The Definitive ANTLR Reference book.
+
+The C# implementation of ANTLR is as close as possible to the Java one, so you shouldn't find it difficult to adapt the examples for C#.
diff --git a/doc/faq/actions-preds.md b/doc/faq/actions-preds.md
new file mode 100644
index 000000000..46fe9759c
--- /dev/null
+++ b/doc/faq/actions-preds.md
@@ -0,0 +1,11 @@
+# Actions and semantic predicates
+
+## How do I test if an optional rule was matched?
+
+For optional rule references such as the initialization clause in the following
+
+```
+decl : 'var' ID (EQUALS expr)? ;
+```
+
+testing to see if that clause was matched can be done using `$EQUALS!=null` or `$expr.ctx!=null` where `$expr.ctx` points to the context or parse tree created for that reference to rule expr.
\ No newline at end of file
diff --git a/doc/faq/error-handling.md b/doc/faq/error-handling.md
new file mode 100644
index 000000000..ebc329909
--- /dev/null
+++ b/doc/faq/error-handling.md
@@ -0,0 +1,5 @@
+# Error handling
+
+## How do I perform semantic checking with ANTLR?
+
+See [How to implement error handling in ANTLR4](http://stackoverflow.com/questions/21613421/how-to-implement-error-handling-in-antlr4/21615751#21615751).
diff --git a/doc/faq/general.md b/doc/faq/general.md
new file mode 100644
index 000000000..fb9c386f5
--- /dev/null
+++ b/doc/faq/general.md
@@ -0,0 +1,100 @@
+# General
+
+## Why do we need ANTLR v4?
+
+*Oliver Zeigermann asked me some questions about v4. Here is our conversation.*
+
+*See the [preface from the book](http://media.pragprog.com/titles/tpantlr2/preface.pdf)*
+
+**Q: Why is the new version of ANTLR also called “honey badger”?**
+
+ANTLR v4 is called the honey badger release after the fearless hero of the YouTube sensation, The Crazy Nastyass Honey Badger.
+
+**Q: Why did you create a new version of ANTLR?**
+
+Well, I start creating a new version because v3 had gotten very messy on the inside and also relied on grammars written in ANTLR v2. Unfortunately, v2's open-source license was unclear and so projects such as Eclipse could not include v3 because of its dependency on v2. In the end, Sam Harwell converted all of the v2 grammars into v3 so that v3 was written in itself. Because v3 has a very clean BSD license, the Eclipse project okayed for inclusion in that project in the summer of 2011.
+
+As I was rewriting ANTLR, I wanted to experiment with a new variation of the LL(\*) parsing algorithm. As luck would have it, I came up with a cool new version called adaptive LL(\*) that pushes all of the grammar analysis effort to runtime. The parser warms up like Java does with its JIT on-the-fly compiler; the code gets faster and faster the longer it runs. The benefit is that the adaptive algorithm is much stronger than the static LL(\*) grammar analysis algorithm in v3. Honey Badger takes any grammar that you give it; it just doesn't give a damn. (v4 accepts even left recursive grammars, except for indirectly left recursive grammars where x calls y which calls x).
+
+v4 is the culmination of 25 years of research into parsers and parser generators. I think I finally know what I want to build. :)
+
+**Q: What makes you excited about ANTLR4?**
+
+The biggest thing is the new adaptive parsing strategy, which lets us accept any grammar we care to write. That gives us a huge productivity boost because we can now write much more natural expression rules (which occur in almost every grammar). For example, bottom-up parser generators such as yacc let you write very natural grammars like this:
+
+```
+e : e '*' e
+  | e '+' e
+  | INT
+  ;
+```
+
+ANTLR v4 will also take that grammar now, translating it secretly to a non-left recursive version.
+
+Another big thing with v4 is that my goal has shifted from performance to ease-of-use. For example, ANTLR automatically can build parse trees for you and generate listeners and visitors. This is not only a huge productivity win, but also an important step forward in building grammars that don't depend on embedded actions. Those embedded actions (raw Java code or whatever) locked the grammar into use with only one language. If we keep all of the actions out of the grammar and put them into external visitors, we can reuse the same grammar to generate code in any language for which we have an ANTLR target.
+
+**Q: What do you think are the things people had problems with in ANTLR3?**
+
+The biggest problem was figuring out why ANTLR did not like their grammar. The static analysis often could not figure out how to generate a parser for the grammar. This problem totally goes away with the honey badger because it will take just about anything you give it without a whimper.
+
+**Q: And what with other compiler generator tools?**
+
+The biggest problem for the average practitioner is that most parser generators do not produce code you can load into a debugger and step through. This immediately removes bottom-up parser generators and the really powerful GLR parser generators from consideration by the average programmer. There are a few other tools that generate source code like ANTLR does, but they don't have v4's adaptive LL(\*) parsers. You will be stuck with contorting your grammar to fit the needs of the tool's weaker, say, LL(k) parsing strategy. PEG-based tools have a number of weaknesses, but to mention one, they have essentially no error recovery because they cannot report an error and until they have parsed the entire input.
+
+**Q: What are the main design decisions in ANTLR4?**
+
+Ease-of-use over performance. I will worry about performance later. Simplicity over complexity. For example, I have taken out explicit/manual AST construction facilities and the tree grammar facilities. For 20 years I've been trying to get people to go that direction, but I've since decided that it was a mistake. It's much better to give people a parser generator that can automatically build trees and then let them use pure code to do whatever tree walking they want. People are extremely familiar and comfortable with visitors, for example.
+
+**Q: What do you think people will like most on ANTLR4?**
+
+The lack of errors when you run your grammar through ANTLR. The automatic tree construction and listener/visitor generation.
+
+**What do you think are the problems people will try to solve with ANTLR4?**
+
+In my experience, almost no one uses parser generators to build commercial compilers. So, people are using ANTLR for their everyday work, building everything from configuration files to little scripting languages.
+
+In response to a question about this entry from stackoverflow.com: I believe that compiler developers are very concerned with parsing speed, error reporting, and error recovery. For that, they want absolute control over their parser. Also, some languages are so complicated, such as C++, that parser generators might build parsers slower than compiler developers want. The compiler developers also like the control of a recursive-descent parser for predicating the parse to handle context-sensitive constructs such as `T(i)` in C++.
+
+There is also likely a sense that parsing is the easy part of building a compiler so they don't immediately jump automatically to parser generators. I think this is also a function of previous generation parser generators. McPeak's Elkhound GLR-based parser generator is powerful enough and fast enough, in the hands of someone that knows what they're doing, to be suitable for compilers. I can also attest to the fact that ANTLR v4 is now powerful enough and fast enough to compete well with handbuilt parsers. E.g., after warm-up, it's now taking just 1s to parse the entire JDK java/\* library.
+
+## What is the difference between ANTLR 3 and 4?
+
+The biggest difference between ANTLR 3 and 4 is that ANTLR 4 takes any grammar you give it unless the grammar had indirect left recursion. That means we don't need syntactic predicates or backtracking so ANTLR 4 does not support that syntax; you will get a warning for using it. ANTLR 4 allows direct left recursion so that expressing things like arithmetic expression syntax is very easy and natural:
+
+```
+expr : expr '*' expr
+     | expr '+' expr
+     | INT
+     ;
+```
+
+ANTLR 4 automatically constructs parse trees for you and abstract syntax tree (AST) construction is no longer an option. See also What if I need ASTs not parse trees for a compiler, for example?
+
+Another big difference is that we discourage the use of actions directly within the grammar because ANTLR 4 automatically generates [listeners and visitors](https://raw.githubusercontent.com/antlr/antlr4/master/doc/listeners.md) for you to use that trigger method calls when some phrases of interest are recognized during a tree walk after parsing. See also [Parse Tree Matching and XPath](https://raw.githubusercontent.com/antlr/antlr4/master/doc/tree-matching.md).
+
+Semantic predicates are still allowed in both the parser and lexer rules as our actions.  For efficiency sake keep semantic predicates to the right edge of lexical rules.
+
+There are no tree grammars because we use listeners and visitors instead.
+
+## Why is my expression parser slow?
+
+Make sure to use two-stage parsing. See example in [bug report](https://github.com/antlr/antlr4/issues/374).
+
+```Java
+
+CharStream input = new ANTLRFileStream(args[0]);
+ExprLexer lexer = new ExprLexer(input);
+CommonTokenStream tokens = new CommonTokenStream(lexer);
+ExprParser parser = new ExprParser(tokens);
+parser.getInterpreter().setPredictionMode(PredictionMode.SLL);
+try {
+    parser.stat();  // STAGE 1
+}
+catch (Exception ex) {
+    tokens.reset(); // rewind input stream
+    parser.reset();
+    parser.getInterpreter().setPredictionMode(PredictionMode.LL);
+    parser.stat();  // STAGE 2
+    // if we parse ok, it's LL not SLL
+}
+```
diff --git a/doc/faq/getting-started.md b/doc/faq/getting-started.md
new file mode 100644
index 000000000..bd0d4ffae
--- /dev/null
+++ b/doc/faq/getting-started.md
@@ -0,0 +1,11 @@
+# Getting started
+
+## How to I install and run a simple grammar?
+
+See [Getting Started with ANTLR v4](https://raw.githubusercontent.com/antlr/antlr4/master/doc/getting-started.md).
+
+## Why does my parser test program hang?
+
+Your test program is likely not hanging but simply waiting for you to type some input for standard input. Don't forget that you need to type the end of file character, generally on a line by itself, at the end of the input. On a Mac or Linux machine it is ctrl-D, as gawd intended, or ctrl-Z on a Windows machine.
+
+See [Getting Started with ANTLR v4](https://raw.githubusercontent.com/antlr/antlr4/master/doc/getting-started.md).
\ No newline at end of file
diff --git a/doc/faq/index.md b/doc/faq/index.md
new file mode 100644
index 000000000..734fc6c13
--- /dev/null
+++ b/doc/faq/index.md
@@ -0,0 +1,50 @@
+# Frequently-Asked Questions (FAQ)
+
+This is the main landing page for the ANTLR 4 FAQ. The links below will take you to the appropriate file containing all answers for that subcategory.
+
+*To add to or improve this FAQ, [fork](https://help.github.com/articles/fork-a-repo/) the [antlr/antlr4 repo](https://github.com/antlr/antlr4) then update this `doc/faq/index.md` or file(s) in that directory.  Submit a [pull request](https://help.github.com/articles/creating-a-pull-request/) to get your changes incorporated into the main repository. Do not mix code and FAQ updates in the sample pull request.* **You must sign the contributors.txt certificate of origin with your pull request if you've not done so before.**
+
+## Getting Started
+
+* [How to I install and run a simple grammar?](getting-started.md)
+* [Why does my parser test program hang?](getting-started.md)
+
+## Installation
+
+* [Why can't ANTLR (grun) find my lexer or parser?](installation.md)
+* [Why can't I run the ANTLR tool?](installation.md)
+* [Why doesn't my parser compile?](installation.md)
+
+## General
+
+* [Why do we need ANTLR v4?](general.md)
+* [What is the difference between ANTLR 3 and 4?](general.md)
+* [Why is my expression parser slow?](general.md)
+
+## Grammar syntax
+
+## Lexical analysis
+
+* [How can I parse non-ASCII text and use characters in token rules?](lexical.md)
+* [How do I replace escape characters in string tokens?](lexical.md)
+* [Why are my keywords treated as identifiers?](lexical.md)
+* [Why are there no whitespace tokens in the token stream?](lexical.md)
+
+## Parse Trees
+
+* [How do I get the input text for a parse-tree subtree?](parse-trees.md)
+* [What if I need ASTs not parse trees for a compiler, for example?](parse-trees.md)
+* [When do I use listener/visitor vs XPath vs Tree pattern matching?](parse-trees.md)
+
+## Translation
+
+* [ASTs vs parse trees](parse-trees.md)
+* [Decoupling input walking from output generation](parse-trees.md)
+
+## Actions and semantic predicates
+
+* [How do I test if an optional rule was matched?](actions-preds.md)
+
+## Error handling
+
+* [How do I perform semantic checking with ANTLR?](error-handling.md)
diff --git a/doc/faq/installation.md b/doc/faq/installation.md
new file mode 100644
index 000000000..fb945dac8
--- /dev/null
+++ b/doc/faq/installation.md
@@ -0,0 +1,60 @@
+# Installation
+
+Please read carefully: [Getting Started with ANTLR v4](https://raw.githubusercontent.com/antlr/antlr4/master/doc/getting-started.md).
+
+## Why can't ANTLR (grun) find my lexer or parser?
+
+If you see "Can't load Hello as lexer or parser", it's because you don't have '.' (current directory) in your CLASSPATH.
+
+```bash
+$ alias antlr4='java -jar /usr/local/lib/antlr-4.2.2-complete.jar'
+$ alias grun='java org.antlr.v4.runtime.misc.TestRig'
+$ export CLASSPATH="/usr/local/lib/antlr-4.2.2-complete.jar"
+$ antlr4 Hello.g4
+$ javac Hello*.java
+$ grun Hello r -tree
+Can't load Hello as lexer or parser
+$
+```
+
+For mac/linux, use:
+
+```bash
+export CLASSPATH=".:/usr/local/lib/antlr-4.2.2-complete.jar:$CLASSPATH"
+```
+
+or for Windows:
+
+```
+SET CLASSPATH=.;C:\Javalib\antlr4-complete.jar;%CLASSPATH%
+```
+
+**See the dot at the beginning?** It's critical.
+
+## Why can't I run the ANTLR tool?
+
+If you get a no class definition found error, you are missing the ANTLR jar in your `CLASSPATH` (or you might only have the runtime jar):
+
+```bash
+/tmp $ java org.antlr.v4.Tool Hello.g4
+Exception in thread "main" java.lang.NoClassDefFoundError: org/antlr/v4/Tool
+Caused by: java.lang.ClassNotFoundException: org.antlr.v4.Tool
+    at java.net.URLClassLoader$1.run(URLClassLoader.java:202)
+    at java.security.AccessController.doPrivileged(Native Method)
+    at java.net.URLClassLoader.findClass(URLClassLoader.java:190)
+    at java.lang.ClassLoader.loadClass(ClassLoader.java:306)
+    at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:301)
+    at java.lang.ClassLoader.loadClass(ClassLoader.java:247)
+```
+
+## Why doesn't my parser compile?
+
+If you see these kinds of errors, it's because you don't have the runtime or complete ANTLR library in your CLASSPATH.
+
+```bash
+/tmp $ javac Hello*.java
+HelloBaseListener.java:3: package org.antlr.v4.runtime does not exist
+import org.antlr.v4.runtime.ParserRuleContext;
+                           ^
+...
+```
diff --git a/doc/faq/lexical.md b/doc/faq/lexical.md
new file mode 100644
index 000000000..371d1f93b
--- /dev/null
+++ b/doc/faq/lexical.md
@@ -0,0 +1,63 @@
+# Lexical analysis
+
+## How can I parse non-ASCII text and use characters in token rules?
+
+See [Using non-ASCII characters in token rules](http://stackoverflow.com/questions/28126507/antlr4-using-non-ascii-characters-in-token-rules/28129510#28129510).
+
+## How do I replace escape characters in string tokens?
+
+Unfortunately, manipulating the text of the token matched by a lexical rule is cumbersome (as of 4.2).  You have to build up a buffer and then set the text at the end. Actions in the lexer execute at the associated position in the input just like they do in the parser. Here's an example that does escape character replacement in strings. It's not pretty but it works.
+
+```
+grammar Foo;
+ 
+@members {
+StringBuilder buf = new StringBuilder(); // can't make locals in lexer rules
+}
+ 
+STR :   '"'
+        (   '\\'
+            (   'r'     {buf.append('\r');}
+            |   'n'     {buf.append('\n');}
+            |   't'     {buf.append('\t');}
+            |   '\\'    {buf.append('\\');}
+            |   '\"'   {buf.append('"');}
+            )
+        |   ~('\\'|'"') {buf.append((char)_input.LA(-1));}
+        )*
+        '"'
+        {setText(buf.toString()); buf.setLength(0); System.out.println(getText());}
+    ;
+```
+
+It's easier and more efficient to return original input string and then use a small function to rewrite the string later during a parse tree walk or whatever. But, here's how to do it from within the lexer.
+
+Lexer actions don't work in the interpreter, which includes xpath and tree patterns.
+
+For more on the argument against doing complicated things in the lexer, see the [related lexer-action issue at github](https://github.com/antlr/antlr4/issues/483#issuecomment-37326067).
+
+## Why are my keywords treated as identifiers?
+
+Keywords such as `begin` are also valid identifiers lexically and so that input is ambiguous. To resolve ambiguities, ANTLR gives precedence to the lexical rules specified first. That implies that you must put the identifier rule after all of your keywords:
+
+```
+grammar T;
+ 
+decl : DEF 'int' ID ';'
+ 
+DEF : 'def' ;   // ambiguous with ID as is 'int'
+ID  : [a-z]+ ;
+```
+
+Notice that literal `'int'` is also physically before the ID rule and will also get precedence.
+
+## Why are there no whitespace tokens in the token stream?
+
+The lexer is not sending white space to the parser, which means that the rewrite stream doesn't have access to the tokens either. It is because of the skip lexer command:
+
+```
+WS : [ \t\r\n\u000C]+ -> skip
+   ;
+```
+
+You have to change all those to `-> channel(HIDDEN)` which will send them to the parser on a different channel, making them available in the token stream, but invisible to the parser.
\ No newline at end of file
diff --git a/doc/faq/parse-trees.md b/doc/faq/parse-trees.md
new file mode 100644
index 000000000..5a243cedb
--- /dev/null
+++ b/doc/faq/parse-trees.md
@@ -0,0 +1,73 @@
+# Parse Trees
+
+## How do I get the input text for a parse-tree subtree?
+
+In ParseTree, you have this method:
+
+```java
+/** Return the combined text of all leaf nodes. Does not get any
+ * off-channel tokens (if any) so won't return whitespace and
+ * comments if they are sent to parser on hidden channel.
+ */
+String getText();
+```
+
+But, you probably want this method from TokenStream:
+
+```java
+/**
+ * Return the text of all tokens in the source interval of the specified
+ * context. This method behaves like the following code, including potential
+ * exceptions from the call to {@link #getText(Interval)}, but may be
+ * optimized by the specific implementation.
+ *
+ * <p>If {@code ctx.getSourceInterval()} does not return a valid interval of
+ * tokens provided by this stream, the behavior is unspecified.</p>
+ *
+ * <pre>
+ * TokenStream stream = ...;
+ * String text = stream.getText(ctx.getSourceInterval());
+ * </pre>
+ *
+ * @param ctx The context providing the source interval of tokens to get
+ * text for.
+ * @return The text of all tokens within the source interval of {@code ctx}.
+ */
+public String getText(RuleContext ctx);
+```
+
+That is, do this:
+
+```
+mytokens.getText(mySubTree);
+```
+
+## What if I need ASTs not parse trees for a compiler, for example?
+
+For writing a compiler, either generate [LLVM-type static-single-assignment](http://llvm.org/docs/LangRef.html) form or construct an AST from the parse tree using a listener or visitor. Or, use actions in grammar, turning off auto-parse-tree construction.
+
+## When do I use listener/visitor vs XPath vs Tree pattern matching?
+
+### XPath
+
+XPath works great when you need to find specific nodes, possibly in certain contexts. The context is limited to the parents on the way to the root of the tree. For example, if you want to find all ID nodes, use path `//ID`. If you want all variable declarations, you might use path `//vardecl`.  If you only want fields declarations, then you can use some context information via path `/classdef/vardecl`, which would only find vardecls that our children of class definitions. You can merge the results of multiple XPath `findAll()`s simulating a set union for XPath. The only caveat is that the order from the original tree is not preserved when you union multiple `findAll()` sets.
+
+### Tree pattern matching
+
+Use tree pattern matching when you want to find specific subtree structures such as all assignments to 0 using pattern `x = 0;`.  (Recall that these are very convenient because you specify the tree structure in the concrete syntax of the language described by the grammar.) If you want to find all assignments of any kind, you can use pattern `x = <expr>;` where `<expr>` will find any expression. This works great for matching particular substructures and therefore gives you a bit more ability to specify context. I.e., instead of just finding all identifiers, you can find all identifiers on the left hand side of an expression.
+
+### Listeners/Visitors
+
+Using the listener or visitor interfaces give you the most power but require implementing more methods. It might be more challenging to discover the emergent behavior of the listener than a simple tree pattern matcher that says *go find me X under node Y*.
+
+Listeners are great when you want to visit many nodes in a tree.
+
+Listeners allow you to compute and save context information necessary for processing at various nodes. For example, when building a symbol table manager for a compiler or translator, you need to compute symbol scopes such as globals, class, function, and code block. When you enter a class or function, you push a new scope and then pop it when you exit that class or function. When you see a symbol, you need to define it or look it up in the proper scope. By having enter/exit listener functions push and pop scopes, listener functions for defining variables simply say something like:
+
+```java
+scopeStack.peek().define(new VariableSymbol("foo"))
+```
+
+That way each listener function does not have to compute its appropriate scope.
+
+Examples: [DefScopesAndSymbols.java](https://github.com/mantra/compiler/blob/master/src/java/mantra/semantics/DefScopesAndSymbols.java) and [SetScopeListener.java](https://github.com/mantra/compiler/blob/master/src/java/mantra/semantics/SetScopeListener.java) and [VerifyListener.java](https://github.com/mantra/compiler/blob/master/src/java/mantra/semantics/VerifyListener.java)
\ No newline at end of file
diff --git a/doc/faq/translation.md b/doc/faq/translation.md
new file mode 100644
index 000000000..3f452128f
--- /dev/null
+++ b/doc/faq/translation.md
@@ -0,0 +1,9 @@
+# Translation
+
+## ASTs vs parse trees
+
+I used to do specialized AST (**abstract** syntax tree) nodes rather than (concrete) parse trees because I used to think more about compilation and generating bytecode/assembly code. When I started thinking more about translation, I started using parse trees. For v4, I realized that I did mostly translation.  I guess what I'm saying is that maybe parse trees are not as good as ASTs for generating bytecodes. Personally, I would rather see `(+ 3 4)` rather than `(expr 3 + 4)` for generating byte codes, but it's not the end of the world. (*Can someone fill this in?*)
+
+## Decoupling input walking from output generation
+
+I suggest creating an intermediate model that represents your output. You walk the parse tree to collect information and create your model. Then, you could almost certainly automatically walk this internal model to generate output based upon stringtemplates that match the class names of the internal model. In other words, define a special `IFStatement` object that has all of the fields you want and then create them as you walk the parse tree. This decoupling of the input from the output is very powerful. Just because we have a parse tree listener doesn't mean that the parse tree itself is necessarily the best data structure to hold all information necessary to generate code. Imagine a situation where the output is the exact reverse of the input. In that case, you really want to walk the input just to collect data. Generating output should be driven by the internal model not the way it was represented in the input.
\ No newline at end of file
diff --git a/doc/getting-started.md b/doc/getting-started.md
new file mode 100644
index 000000000..2530ba4a4
--- /dev/null
+++ b/doc/getting-started.md
@@ -0,0 +1,131 @@
+# Getting Started with ANTLR v4
+
+Hi and welcome to the version 4 release of ANTLR! It's named after the fearless hero of the [Crazy Nasty-Ass Honey Badger](http://www.youtube.com/watch?v=4r7wHMg5Yjg) since ANTLR v4 takes whatever you give it--it just doesn't give a crap! See [Why do we need ANTLR v4?](faq/general.md) and the [preface of the ANTLR v4 book](http://media.pragprog.com/titles/tpantlr2/preface.pdf).
+
+## Installation
+
+ANTLR is really two things: a tool that translates your grammar to a parser/lexer in Java (or other target language) and the runtime needed by the generated parsers/lexers. Even if you are using the ANTLR Intellij plug-in or ANTLRWorks to run the ANTLR tool, the generated code will still need the runtime library. 
+
+The first thing you should do is probably download and install a development tool plug-in. Even if you only use such tools for editing, they are great. Then, follow the instructions below to get the runtime environment available to your system to run generated parsers/lexers.  In what follows, I talk about antlr-4.5-complete.jar, which has the tool and the runtime and any other support libraries (e.g., ANTLR v4 is written in v3).
+
+If you are going to integrate ANTLR into your existing build system using mvn, ant, or want to get ANTLR into your IDE such as eclipse or intellij, see Integrating ANTLR into Development Systems.
+
+### UNIX
+
+0. Install Java (version 1.6 or higher)
+1. Download
+```
+$ cd /usr/local/lib
+$ curl -O http://www.antlr.org/download/antlr-4.5-complete.jar
+```
+Or just download in browser from website:
+    [http://www.antlr.org/download.html](http://www.antlr.org/download.html)
+and put it somewhere rational like `/usr/local/lib`.
+2. Add `antlr-4.5-complete.jar` to your `CLASSPATH`:
+```
+$ export CLASSPATH=".:/usr/local/lib/antlr-4.5-complete.jar:$CLASSPATH"
+```
+It's also a good idea to put this in your `.bash_profile` or whatever your startup script is.
+3. Create aliases for the ANTLR Tool, and `TestRig`.
+```
+$ alias antlr4='java -Xmx500M -cp "/usr/local/lib/antlr-4.5-complete.jar:$CLASSPATH" org.antlr.v4.Tool'
+$ alias grun='java org.antlr.v4.runtime.misc.TestRig'
+```
+
+### WINDOWS
+
+(*Thanks to Graham Wideman*)
+
+0. Install Java (version 1.6 or higher)
+1. Download antlr-4.5-complete.jar (or whatever version) from [http://www.antlr.org/download/](http://www.antlr.org/download/)
+Save to your directory for 3rd party Java libraries, say `C:\Javalib`
+2. Add `antlr-4.5-complete.jar` to CLASSPATH, either:
+  * Permanently: Using System Properties dialog > Environment variables > Create or append to `CLASSPATH` variable
+  * Temporarily, at command line:
+```
+SET CLASSPATH=.;C:\Javalib\antlr-4.5-complete.jar;%CLASSPATH%
+```
+3. Create short convenient commands for the ANTLR Tool, and TestRig, using batch files or doskey commands:
+  * Batch files (in directory in system PATH) antlr4.bat and grun.bat
+```
+java org.antlr.v4.Tool %*
+```
+```
+java org.antlr.v4.runtime.misc.TestRig %*
+```
+  * Or, use doskey commands:
+```
+doskey antlr4=java org.antlr.v4.Tool $*
+doskey grun =java org.antlr.v4.runtime.misc.TestRig $*
+```
+
+### Testing the installation
+
+Either launch org.antlr.v4.Tool directly:
+
+```
+$ java org.antlr.v4.Tool
+ANTLR Parser Generator Version 4.5
+-o ___ specify output directory where all output is generated
+-lib ___ specify location of .tokens files
+...
+```
+
+or use -jar option on java:
+
+```
+$ java -jar /usr/local/lib/antlr-4.5-complete.jar
+ANTLR Parser Generator Version 4.5
+-o ___ specify output directory where all output is generated
+-lib ___ specify location of .tokens files
+...
+```
+
+## A First Example
+
+In a temporary directory, put the following grammar inside file Hello.g4:
+Hello.g4
+
+```
+// Define a grammar called Hello
+grammar Hello;
+r  : 'hello' ID ;         // match keyword hello followed by an identifier
+ID : [a-z]+ ;             // match lower-case identifiers
+WS : [ \t\r\n]+ -> skip ; // skip spaces, tabs, newlines
+```
+
+Then run ANTLR the tool on it:
+
+```
+$ cd /tmp
+$ antlr4 Hello.g4
+$ javac Hello*.java
+```
+
+Now test it:
+
+```
+$ grun Hello r -tree
+hello parrt
+^D
+(r hello parrt)
+(That ^D means EOF on unix; it's ^Z in Windows.) The -tree option prints the parse tree in LISP notation.
+It's nicer to look at parse trees visually.
+$ grun Hello r -gui
+hello parrt
+^D
+```
+
+That pops up a dialog box showing that rule `r` matched keyword `hello` followed by identifier `parrt`.
+
+![](images/hello-parrt.png)
+
+## Book source code
+
+The book has lots and lots of examples that should be useful to. You can download them here for free:
+
+[http://pragprog.com/titles/tpantlr2/source_code](http://pragprog.com/titles/tpantlr2/source_code)
+
+Also, there is a large collection of grammars for v4 at github:
+
+[https://github.com/antlr/grammars-v4](https://github.com/antlr/grammars-v4)
diff --git a/doc/grammars.md b/doc/grammars.md
new file mode 100644
index 000000000..c40d974b6
--- /dev/null
+++ b/doc/grammars.md
@@ -0,0 +1,184 @@
+# Grammar Structure
+
+A grammar is essentially a grammar declaration followed by a list of rules, but has the general form:
+
+```
+/** Optional javadoc style comment */
+grammar Name; ①
+options {...}
+import ... ;
+ 	
+tokens {...}
+channels {...} // lexer only
+@actionName {...}
+ 	 
+rule1 // parser and lexer rules, possibly intermingled
+...
+ruleN
+```
+
+The file name containing grammar `X` must be called `X.g4`. You can specify options, imports, token specifications, and actions in any order. There can be at most one each of options, imports, and token specifications. All of those elements are optional except for the header ① and at least one rule. Rules take the basic form:
+
+```
+ruleName : alternative1 | ... | alternativeN ;
+```
+
+Parser rule names must start with a lowercase letter and lexer rules must start with a capital letter.
+
+Grammars defined without a prefix on the `grammar` header are combined grammars that can contain both lexical and parser rules. To make a parser grammar that only allows parser rules, use the following header.
+
+```
+parser grammar Name;
+...
+```
+
+And, naturally, a pure lexer grammar looks like this:
+
+```
+lexer grammar Name;
+...
+```
+
+Only lexer grammars can contain `mode` specifications.
+
+Only lexer grammars can contain custom channels specifications
+
+```
+channels {
+  WHITESPACE_CHANNEL,
+  COMMENTS_CHANNEL
+}
+```
+
+Those channels can then be used like enums within lexer rules:
+
+```
+WS : [ \r\t\n]+ -> channel(WHITESPACE_CHANNEL) ;
+```
+
+Sections 15.5, [Lexer Rules](http://pragprog.com/book/tpantlr2/the-definitive-antlr-4-reference) and Section 15.3, [Parser Rules](http://pragprog.com/book/tpantlr2/the-definitive-antlr-4-reference) contain details on rule syntax. Section 15.8, Options describes grammar options and Section 15.4, Actions and Attributes has information on grammar-level actions.
+
+## Grammar Imports
+
+Grammar `imports` let you break up a grammar into logical and reusable chunks, as we saw in [Importing Grammars](http://pragprog.com/book/tpantlr2/the-definitive-antlr-4-reference). ANTLR treats imported grammars very much like object-oriented programming languages treat superclasses. A grammar inherits all of the rules, tokens specifications, and named actions from the imported grammar. Rules in the “main grammar” override rules from imported grammars to implement inheritance.
+
+Think of `import` as more like a smart include statement (which does not include rules that are already defined). The result of all imports is a single combined grammar; the ANTLR code generator sees a complete grammar and has no idea there were imported grammars.
+
+To process a main grammar, the ANTLR tool loads all of the imported grammars into subordinate grammar objects. It then merges the rules, token types, and named actions from the imported grammars into the main grammar. In the diagram below, the grammar on the right illustrates the effect of grammar `MyELang` importing grammar `ELang`.
+
+<img src=images/combined.png width=400>
+
+`MyELang` inherits rules `stat`, `WS`, and `ID`, but overrides rule `expr` and adds `INT`. Here’s a sample build and test run that shows `MyELang` can recognize integer expressions whereas the original `ELang` can’t. The third, erroneous input statement triggers an error message that also demonstrates the parser was looking for `MyELang`’s expr not `ELang`’s.
+
+```
+$ antlr4 MyELang.g4
+$ javac MyELang*.java
+$ grun MyELang stat
+=> 	34;
+=> 	a;
+=> 	;
+=> 	EOF
+<= 	line 3:0 extraneous input ';' expecting {INT, ID}
+```
+
+If there were any `tokens` specifications, the main grammar would merge the token sets. Any named actions such as `@members` would be merged. In general, you should avoid named actions and actions within rules in imported grammars since that limits their reuse. ANTLR also ignores any options in imported grammars.
+
+Imported grammars can also import other grammars. ANTLR pursues all imported grammars in a depth-first fashion. If two or more imported grammars define rule `r`, ANTLR chooses the first version of `r` it finds. In the following diagram, ANTLR examines grammars in the following order `Nested`, `G1`, `G3`, `G2`.
+
+<img src=images/nested.png width=350>
+
+`Nested` includes the `r` rule from `G3` because it sees that version before the `r` in `G2`.
+
+Not every kind of grammar can import every other kind of grammar:
+
+* Lexer grammars can import lexers.
+* Parsers can import parsers.
+* Combined grammars can import lexers or parsers.
+
+ANTLR adds imported rules to the end of the rule list in a main lexer grammar. That means lexer rules in the main grammar get precedence over imported rules. For example, if a main grammar defines rule `IF : ’if’ ;` and an imported grammar defines rule `ID : [a-z]+ ;` (which also recognizes `if`), the imported `ID` won’t hide the main grammar’s `IF` token definition.
+
+## Tokens Section
+
+The purpose of the `tokens` section is to define token types needed by a grammar for which there is no associated lexical rule. The basic syntax is:
+
+```
+tokens { Token1, ..., TokenN }
+```
+
+Most of the time, the tokens section is used to define token types needed by actions in the grammar as shown in Section 10.3, [Recognizing Languages whose Keywords Aren’t Fixed](http://pragprog.com/book/tpantlr2/the-definitive-antlr-4-reference):
+
+```
+// explicitly define keyword token types to avoid implicit definition warnings
+tokens { BEGIN, END, IF, THEN, WHILE }
+ 
+@lexer::members { // keywords map used in lexer to assign token types
+Map<String,Integer> keywords = new HashMap<String,Integer>() {{
+	put("begin", KeywordsParser.BEGIN);
+	put("end", KeywordsParser.END);
+	...
+}};
+}
+```
+
+The `tokens` section really just defines a set of tokens to add to the overall set.
+
+```
+$ cat Tok.g4
+grammar Tok;
+tokens { A, B, C }
+a : X ;
+$ antlr4 Tok.g4
+warning(125): Tok.g4:3:4: implicit definition of token X in parser
+$ cat Tok.tokens
+A=1
+B=2
+C=3
+X=4
+```
+
+## Actions at the Grammar Level
+
+Currently there are only two defined named actions (for the Java target) used outside of grammar rules: `header` and `members`. The former injects code into the generated recognizer class file, before the recognizer class definition, and the latter injects code into the recognizer class definition, as fields and methods.
+
+For combined grammars, ANTLR injects the actions into both the parser and the lexer. To restrict an action to the generated parser or lexer, use `@parser::name` or `@lexer::name`.
+
+Here’s an example where the grammar specifies a package for the generated code:
+
+```
+grammar Count;
+ 
+@header {
+package foo;
+}
+ 
+@members {
+int count = 0;
+}
+ 
+list
+@after {System.out.println(count+" ints");}
+: INT {count++;} (',' INT {count++;} )*
+;
+ 
+INT : [0-9]+ ;
+WS : [ \r\t\n]+ -> skip ;
+```
+
+The grammar itself then should be in directory `foo` so that ANTLR generates code in that same `foo` directory (at least when not using the `-o` ANTLR tool option):
+
+```
+$ cd foo
+$ antlr4 Count.g4 # generates code in the current directory (foo)
+$ ls
+Count.g4		CountLexer.java	CountParser.java
+Count.tokens	CountLexer.tokens
+CountBaseListener.java CountListener.java
+$ javac *.java
+$ cd ..
+$ grun foo.Count list
+=> 	9, 10, 11
+=> 	EOF
+<= 	3 ints
+```
+
+The Java compiler expects classes in package `foo` to be in directory `foo`.
diff --git a/doc/images/ACE-Architecture.001.png b/doc/images/ACE-Architecture.001.png
new file mode 100644
index 000000000..ef36f98a8
Binary files /dev/null and b/doc/images/ACE-Architecture.001.png differ
diff --git a/doc/images/combined.png b/doc/images/combined.png
new file mode 100644
index 000000000..8131bb31b
Binary files /dev/null and b/doc/images/combined.png differ
diff --git a/doc/images/foreign.png b/doc/images/foreign.png
new file mode 100644
index 000000000..daaa8d83d
Binary files /dev/null and b/doc/images/foreign.png differ
diff --git a/doc/images/hello-parrt.png b/doc/images/hello-parrt.png
new file mode 100644
index 000000000..5bc0596ed
Binary files /dev/null and b/doc/images/hello-parrt.png differ
diff --git a/doc/images/idea-prefs-after-install.png b/doc/images/idea-prefs-after-install.png
new file mode 100644
index 000000000..2d5c8bde7
Binary files /dev/null and b/doc/images/idea-prefs-after-install.png differ
diff --git a/doc/images/idea-prefs.png b/doc/images/idea-prefs.png
new file mode 100644
index 000000000..ab375b86c
Binary files /dev/null and b/doc/images/idea-prefs.png differ
diff --git a/doc/images/intellij-maven.png b/doc/images/intellij-maven.png
new file mode 100644
index 000000000..775e532ef
Binary files /dev/null and b/doc/images/intellij-maven.png differ
diff --git a/doc/images/nested-fuzzy.png b/doc/images/nested-fuzzy.png
new file mode 100644
index 000000000..4da816c52
Binary files /dev/null and b/doc/images/nested-fuzzy.png differ
diff --git a/doc/images/nested.png b/doc/images/nested.png
new file mode 100644
index 000000000..9c9bb1de9
Binary files /dev/null and b/doc/images/nested.png differ
diff --git a/doc/images/nonascii.png b/doc/images/nonascii.png
new file mode 100644
index 000000000..c431feedc
Binary files /dev/null and b/doc/images/nonascii.png differ
diff --git a/doc/images/nonnested-fuzzy.png b/doc/images/nonnested-fuzzy.png
new file mode 100644
index 000000000..d17594255
Binary files /dev/null and b/doc/images/nonnested-fuzzy.png differ
diff --git a/doc/images/process.png b/doc/images/process.png
new file mode 100644
index 000000000..5185aaec5
Binary files /dev/null and b/doc/images/process.png differ
diff --git a/doc/images/teronbook.png b/doc/images/teronbook.png
new file mode 100644
index 000000000..3eb53d8d8
Binary files /dev/null and b/doc/images/teronbook.png differ
diff --git a/doc/images/tertalk.png b/doc/images/tertalk.png
new file mode 100644
index 000000000..069db0a83
Binary files /dev/null and b/doc/images/tertalk.png differ
diff --git a/doc/images/tpantlr2.png b/doc/images/tpantlr2.png
new file mode 100644
index 000000000..fb2e5c61e
Binary files /dev/null and b/doc/images/tpantlr2.png differ
diff --git a/doc/images/tpdsl.png b/doc/images/tpdsl.png
new file mode 100644
index 000000000..05f137a03
Binary files /dev/null and b/doc/images/tpdsl.png differ
diff --git a/doc/images/xyz.png b/doc/images/xyz.png
new file mode 100644
index 000000000..ab08138d3
Binary files /dev/null and b/doc/images/xyz.png differ
diff --git a/doc/images/xyz_opt.png b/doc/images/xyz_opt.png
new file mode 100644
index 000000000..61d98948e
Binary files /dev/null and b/doc/images/xyz_opt.png differ
diff --git a/doc/images/xyz_plus.png b/doc/images/xyz_plus.png
new file mode 100644
index 000000000..2f6fb984b
Binary files /dev/null and b/doc/images/xyz_plus.png differ
diff --git a/doc/images/xyz_star.png b/doc/images/xyz_star.png
new file mode 100644
index 000000000..7a7841efd
Binary files /dev/null and b/doc/images/xyz_star.png differ
diff --git a/doc/index.md b/doc/index.md
new file mode 100644
index 000000000..96d557377
--- /dev/null
+++ b/doc/index.md
@@ -0,0 +1,66 @@
+# ANTLR 4 Documentation
+
+Please check [Frequently asked questions (FAQ)](faq/index.md) before asking questions on stackoverflow or antlr-discussion list.
+
+Notes:
+<ul>
+<li>To add to or improve this documentation, <a href=https://help.github.com/articles/fork-a-repo>fork</a> the <a href=https://github.com/antlr/antlr4>antlr/antlr4 repo</a> then update this `doc/index.md` or file(s) in that directory.  Submit a <a href=https://help.github.com/articles/creating-a-pull-request>pull request</a> to get your changes incorporated into the main repository. Do not mix code and documentation updates in the sample pull request. <b>You must sign the contributors.txt certificate of origin with your pull request if you've not done so before.</b></li>
+
+<li>Copyright © 2012, The Pragmatic Bookshelf.  Pragmatic Bookshelf grants a nonexclusive, irrevocable, royalty-free, worldwide license to reproduce, distribute, prepare derivative works, and otherwise use this contribution as part of the ANTLR project and associated documentation.</li>
+
+<li>This text was copied with permission from the <a href=http://pragprog.com/book/tpantlr2/the-definitive-antlr-4-reference>The Definitive ANTLR 4 Reference</a>, though it is being morphed over time as the tool changes.</li>
+</ul>
+
+Links in the documentation refer to various sections of the book but have been redirected to the general book page on the publisher's site. There are two excerpts on the publisher's website that might be useful to you without having to purchase the book: [Let's get Meta](http://media.pragprog.com/titles/tpantlr2/picture.pdf) and [Building a Translator with a Listener](http://media.pragprog.com/titles/tpantlr2/listener.pdf). You should also consider reading the following books (the vid describes the reference book):
+
+<a href=""><img src=images/tpantlr2.png width=120></a>
+<a href=""><img src=images/tpdsl.png width=120></a>
+<a href="https://www.youtube.com/watch?v=OAoA3E-cyug"><img src=images/teronbook.png width=250></a>
+                 
+This documentation is a reference and summarizes grammar syntax and the key semantics of ANTLR grammars. The source code for all examples in the book, not just this chapter, are free at the publisher's website. The following video is a general tour of ANTLR 4 and includes a description of how to use parse tree listeners to process Java files easily:
+
+<a href="https://vimeo.com/59285751"><img src=images/tertalk.png width=200></a>
+
+## Sections
+
+* [Getting Started with ANTLR v4](getting-started.md)
+
+* [Grammar Lexicon](lexicon.md)
+
+* [Grammar Structure](grammars.md)
+
+* [Parser Rules](parser-rules.md)
+
+* [Left-recursive rules](left-recursion.md)
+
+* [Actions and Attributes](actions.md)
+
+* [Lexer Rules](lexer-rules.md)
+
+* [Wildcard Operator and Nongreedy Subrules](wildcard.md)
+
+* [Parse Tree Listeners](listeners.md)
+
+* [Parse Tree Matching and XPath](tree-matching.md)
+
+* [Semantic Predicates](predicates.md)
+
+* [Options](options.md)
+
+* [ANTLR Tool Command Line Options](tool-options.md)
+
+* [Runtime Libraries and Code Generation Targets](targets.md)
+
+* [Parser and lexer interpreters](interpreters.md)
+
+* [Resources](resources.md)
+
+# Building / releasing ANTLR itself
+
+* [Building ANTLR itself](building-antlr.md)
+
+* [Cutting an ANTLR Release](releasing-antlr.md)
+
+* [Adding ANTLR unit tests](adding-tests.md)
+
+* [Creating an ANTLR Language Target](creating-a-language-target.md)
diff --git a/doc/interpreters.md b/doc/interpreters.md
new file mode 100644
index 000000000..c99e6d580
--- /dev/null
+++ b/doc/interpreters.md
@@ -0,0 +1,79 @@
+# Parser and lexer interpreters
+
+*Since ANTLR 4.2*
+
+For small parsing tasks it is sometimes convenient to use ANTLR in interpreted mode, rather than generating a parser in a particular target, compiling it and running it as part of your application. Here's some sample code that creates lexer and parser Grammar objects and then creates interpreters. Once we have a ParserInterpreter, we can use it to parse starting in any rule we like, given a rule index (which the Grammar can provide).
+
+```java
+LexerGrammar lg = new LexerGrammar(
+    "lexer grammar L;\n" +
+    "A : 'a' ;\n" +
+    "B : 'b' ;\n" +
+    "C : 'c' ;\n");
+Grammar g = new Grammar(
+    "parser grammar T;\n" +
+    "s : (A|B)* C ;\n",
+    lg);   
+LexerInterpreter lexEngine =
+    lg.createLexerInterpreter(new ANTLRInputStream(input));
+CommonTokenStream tokens = new CommonTokenStream(lexEngine);
+ParserInterpreter parser = g.createParserInterpreter(tokens);
+ParseTree t = parser.parse(g.rules.get(startRule).index);
+```
+
+You can also load combined grammars from a file:
+
+```java
+public static ParseTree parse(String fileName,
+                              String combinedGrammarFileName,
+                              String startRule)
+    throws IOException
+{
+    final Grammar g = Grammar.load(combinedGrammarFileName);
+    LexerInterpreter lexEngine = g.createLexerInterpreter(new ANTLRFileStream(fileName));
+    CommonTokenStream tokens = new CommonTokenStream(lexEngine);
+    ParserInterpreter parser = g.createParserInterpreter(tokens);
+    ParseTree t = parser.parse(g.getRule(startRule).index);
+    System.out.println("parse tree: "+t.toStringTree(parser));
+    return t;
+}
+```
+
+Then:
+
+```java
+ParseTree t = parse("T.om",
+                    MantraGrammar,
+                    "compilationUnit");
+```
+ 
+To load separate lexer/parser grammars, do this:
+
+```java
+public static ParseTree parse(String fileNameToParse,
+                              String lexerGrammarFileName,
+                              String parserGrammarFileName,
+                              String startRule)
+    throws IOException
+{
+    final LexerGrammar lg = (LexerGrammar) Grammar.load(lexerGrammarFileName);
+    final Grammar pg = Grammar.load(parserGrammarFileName, lg);
+    ANTLRFileStream input = new ANTLRFileStream(fileNameToParse);
+    LexerInterpreter lexEngine = lg.createLexerInterpreter(input);
+    CommonTokenStream tokens = new CommonTokenStream(lexEngine);
+    ParserInterpreter parser = pg.createParserInterpreter(tokens);
+    ParseTree t = parser.parse(pg.getRule(startRule).index);
+    System.out.println("parse tree: " + t.toStringTree(parser));
+    return t;
+}
+```
+
+Then:
+
+```java
+ParseTree t = parse(fileName, XMLLexerGrammar, XMLParserGrammar, "document");
+```
+
+This is also how we will integrate instantaneous parsing into ANTLRWorks2 and development environment plug-ins.
+
+See [TestParserInterpreter.java](https://github.com/antlr/antlr4/blob/master/tool-testsuite/test/org/antlr/v4/test/tool/TestParserInterpreter.java).
diff --git a/doc/java-target.md b/doc/java-target.md
new file mode 100644
index 000000000..f6e615482
--- /dev/null
+++ b/doc/java-target.md
@@ -0,0 +1,244 @@
+# Java
+
+## Development environments
+
+### Intellij
+
+There is a very complete and useful plug-in for intellij 12-14, you can grab at the [download page](https://plugins.jetbrains.com/plugin/7358?pr=). Check the [plugin readme](https://github.com/antlr/intellij-plugin-v4) for feature set. Just go to the preferences and click on the "Install plug-in from disk..." button from this dialog box:
+
+<img src="images/idea-prefs.png">
+
+Select the intellij-plugin-1.x.zip (or whatever version) file and hit okay or apply. It will ask you to restart the IDE. If you look at the plug-ins again, you will see:
+
+<img src="images/idea-prefs-after-install.png">
+
+Also, I have prepared a [video](https://youtu.be/eW4WFgRtFeY) that will help you generate grammars and so on using ANTLR v4 in Intellij (w/o the plugin).
+
+### Eclipse
+
+Edgar Espina has created an [eclipse plugin for ANTLR v4](https://youtu.be/eW4WFgRtFeY). Features: Advanced Syntax Highlighting, Automatic Code Generation (on save), Manual Code Generation (through External Tools menu), Code Formatter (Ctrl+Shift+F), Syntax Diagrams, Advanced Rule Navigation between files (F3), Quick fixes.
+
+### NetBeans
+
+Sam Harwell's [ANTLRWorks2](http://tunnelvisionlabs.com/products/demo/antlrworks) works also as a plug-in, not just a stand-alone tool built on top of NetBeans.
+
+## Build systems
+
+### ant
+
+### mvn
+
+*Maven Plugin Reference*
+
+The reference pages for the latest version of the Maven plugin for ANTLR 4 can be found here:
+
+[http://www.antlr.org/api/maven-plugin/latest/index.html](http://www.antlr.org/api/maven-plugin/latest/index.html)
+
+*Walkthrough*
+
+This section describes how to create a simple Antlr 4 project and build it using maven. We are going to use the ArrayInit.g4 example from chapter 3 of the book, and bring it under maven. We will need to rename files and modify them. We will conclude by building a portable stand alone application.
+
+Generate the skeleton. To generate the maven skeleton, type these commands:
+
+```bash
+mkdir SimpleAntlrMavenProject
+cd SimpleAntlrMavenProject
+mvn archetype:generate -DgroupId=org.abcd.examples -DartifactId=array-example -Dpackage=org.abcd.examples.ArrayInit -Dversion=1.0
+# Accept all the default values
+cd array-example
+```
+
+Maven will ask a series of questions, simply accept the default answers by hitting enter.
+
+Move into the directory created by maven:
+
+```bash
+cd array-example
+```
+
+We can use the find command to see the files created by maven:
+
+```bash
+$ find . -type f
+./pom.xml
+./src/test/java/org/abcd/examples/ArrayInit/AppTest.java
+./src/main/java/org/abcd/examples/ArrayInit/App.java
+```
+
+We need to edit the pom.xml file extensively. The App.java will be renamed to ArrayInit.java and will contain the main ANTLR java program which we will download from the book examples. The AppTest.java file will be renamed ArrayInitTest.java but will remain the empty test as created by maven. We will also be adding the grammar file ArrayInit.g4 from the book examples in there.
+
+Get the examples for the book and put them in the Downloads folder. To obtain the ArrayInit.g4 grammar from the book, simply download it:
+
+```bash
+pushd ~/Downloads
+wget http://media.pragprog.com/titles/tpantlr2/code/tpantlr2-code.tgz
+tar xvfz tpantlr2-code.tgz
+popd
+```
+
+Copy the grammar to the maven project. The grammar file goes into a special folder under the src/ directory. The folder name must match the maven package name org.abcd.examples.ArrayInit.
+
+```bash
+mkdir -p src/main/antlr4/org/abcd/examples/ArrayInit
+cp ~/Downloads/code/starter/ArrayInit.g4 src/main/antlr4/org/abcd/examples/ArrayInit
+```
+
+Copy the main program to the maven project. We replace the maven App.java file with the main java program from the book. In the book, that main program is called Test.java, we rename it to ArrayInit.java:
+
+```bash
+# Remove the maven file
+rm ./src/main/java/org/abcd/examples/ArrayInit/App.java
+# Copy and rename the example from the book
+cp ~/Downloads/code/starter/Test.java ./src/main/java/org/abcd/examples/ArrayInit/ArrayInit.java
+```
+
+Spend a few minutes to read the main program. Notice that it reads the standard input stream. We need to remember this when we run the application.
+
+Edit the ArrayInit.java file. We need to add a package declaration and to rename the class. Edit the file ./src/main/java/org/abcd/examples/ArrayInit/ArrayInit.java in your favorite editor. The head of the file should look like this when you are done:
+
+```java
+package org.abcd.examples.ArrayInit;
+import org.antlr.v4.runtime.*;
+import org.antlr.v4.runtime.tree.*;
+ 
+public class ArrayInit {
+...
+```
+
+Edit the ArrayInitTest.java file. Maven creates a test file called AppTest.java, we need to rename it to match the name of our application:
+
+```bash
+pushd src/test/java/org/abcd/examples/ArrayInit
+mv AppTest.java ArrayInitTest.java
+sed 's/App/ArrayInit/g' ArrayInitTest.java >ArrayInitTest.java.tmp
+mv ArrayInitTest.java.tmp ArrayInitTest.java
+popd
+```
+
+Edit the pom.xml file. Now we need to extensively modify the pom.xml file. The final product looks like this:
+
+```xml
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>org.abcd.examples</groupId>
+  <artifactId>array-init</artifactId>
+  <version>1.0</version>
+  <packaging>jar</packaging>
+  <name>array-init</name>
+  <url>http://maven.apache.org</url>
+  <properties>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+  </properties>
+  <dependencies>
+    <dependency>
+      <groupId>org.antlr</groupId>
+      <artifactId>antlr4-runtime</artifactId>
+      <version>4.5</version>
+    </dependency>
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <version>3.8.1</version>
+    </dependency>
+  </dependencies>
+  <build>
+    <plugins>
+      <!-- This plugin sets up maven to use Java 7 -->
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-compiler-plugin</artifactId>
+        <version>3.1</version>
+        <configuration>
+          <source>1.7</source>
+          <target>1.7</target>
+        </configuration>
+      </plugin>
+      <!-- Plugin to compile the g4 files ahead of the java files
+           See https://github.com/antlr/antlr4/blob/master/antlr4-maven-plugin/src/site/apt/examples/simple.apt.vm
+           Except that the grammar does not need to contain the package declaration as stated in the documentation (I do not know why)
+           To use this plugin, type:
+             mvn antlr4:antlr4
+           In any case, Maven will invoke this plugin before the Java source is compiled
+        -->
+      <plugin>
+        <groupId>org.antlr</groupId>
+        <artifactId>antlr4-maven-plugin</artifactId>
+        <version>4.5</version>
+        <executions>
+          <execution>
+            <goals>
+              <goal>antlr4</goal>
+            </goals>
+          </execution>
+        </executions>
+      </plugin>
+      <!-- plugin to create a self-contained portable package
+           This allows us to execute our application like this:
+           java -cp target/array-init-1.0-jar-with-dependencies.jar org.abcd.examples.ArrayInit.ArrayInit
+         -->
+      <plugin>
+        <artifactId>maven-assembly-plugin</artifactId>
+        <configuration>
+          <descriptorRefs>
+            <descriptorRef>jar-with-dependencies</descriptorRef>
+          </descriptorRefs>
+        </configuration>
+        <executions>
+          <execution>
+            <id>simple-command</id>
+            <phase>package</phase>
+            <goals>
+              <goal>attached</goal>
+            </goals>
+          </execution>
+        </executions>
+      </plugin>
+    </plugins>
+  </build>
+</project>
+```
+
+This concludes the changes we had to make. We can look at the list of files we have with the find command:
+
+```bash
+$ find . -type f
+./pom.xml
+./src/test/java/org/abcd/examples/ArrayInit/ArrayInitTest.java
+./src/main/antlr4/org/abcd/examples/ArrayInit/ArrayInit.g4
+./src/main/java/org/abcd/examples/ArrayInit/ArrayInit.java
+```
+
+Building a stand alone application. With all the files now in place, we can ask maven to create a standalone application. The following command does this:
+
+```bash
+mvn package
+```
+
+Maven creates a self-contained jar file called target/array-init-1.0-jar-with-dependencies.jar. We can execute the jar file, but remember that it expects some input on the command line, which means the command will hang on the command line until we feed it some input:
+
+```bash
+java -cp target/array-init-1.0-jar-with-dependencies.jar org.abcd.examples.ArrayInit.ArrayInit
+```
+
+And let's feed it the following input:
+
+```bash
+{1,2,3}
+^D
+```
+
+The ^D signals the end of the input to the standard input stream and gets the rest of the application going. You should see the following output:
+
+```bash
+(init { (value 1) , (value 2) , (value 3) })
+```
+
+You can also build a jar file without the dependencies, and execute it with a maven command instead:
+
+```bash
+mvn install
+mvn exec:java -Dexec.mainClass=org.abcd.examples.ArrayInit.ArrayInit
+{1,2,3}
+^D
+```
\ No newline at end of file
diff --git a/doc/javascript-target.md b/doc/javascript-target.md
new file mode 100644
index 000000000..97ab22160
--- /dev/null
+++ b/doc/javascript-target.md
@@ -0,0 +1,157 @@
+# JavaScript
+
+## Which browsers are supported?
+
+In theory, all browsers supporting ECMAScript 5.1.
+
+In practice, this target has been extensively tested against:
+
+* Firefox 34.0.5
+* Safari 8.0.2
+* Chrome 39.0.2171
+* Explorer 11.0.3
+ 
+The tests were conducted using Selenium. No issue was found, so you should find that the runtime works pretty much against any recent JavaScript engine.
+
+## Is NodeJS supported?
+
+The runtime has also been extensively tested against Node.js 0.10.33. No issue was found.
+
+## How to create a JavaScript lexer or parser?
+
+This is pretty much the same as creating a Java lexer or parser, except you need to specify the language target, for example:
+
+```bash
+$ antlr4 -Dlanguage=JavaScript MyGrammar.g4
+```
+
+For a full list of antlr4 tool options, please visit the [tool documentation page](tool-options.md).
+
+## Where can I get the runtime?
+
+Once you've generated the lexer and/or parser code, you need to download the runtime.
+
+The JavaScript runtime is available from the ANTLR web site [download section](http://www.antlr.org/download/index.html). The runtime is provided in the form of source code, so no additional installation is required.
+
+We will not document here how to refer to the runtime from your project, since this would differ a lot depending on your project type and IDE. 
+
+## How do I get the runtime in my browser?
+
+The runtime is quite big and is currently maintained in the form of around 50 scripts, which follow the same structure as the runtimes for other targets (Java, C#, Python...).
+
+This structure is key in keeping code maintainable and consistent across targets.
+
+However, it would be a bit of a problem when it comes to get it into a browser. Nobody wants to write 50 times:
+
+```
+<script src='lib/myscript.js'>
+```
+
+In order to avoid having to do this, and also to have the exact same code for browsers and Node.js, we rely on a script which provides the equivalent of the Node.js 'require' function.
+
+This script is provided by Torben Haase, and is NOT part of ANTLR JavaScript runtime, although the runtime heavily relies on it. Please note that syntax for 'require' in NodeJS is different from the one implemented by RequireJS and similar frameworks.  
+
+So in short, assuming you have at the root of your web site, both the 'antlr4' directory and a 'lib' directory with 'require.js' inside it, all you need to put in your HTML header is the following:
+
+```xml
+<script src='lib/require.js'>
+<script>
+    var antlr4 = require('antlr4/index');
+ </script>
+```
+
+This will load the runtime asynchronously.
+
+## How do I get the runtime in Node.js?
+
+Right now, there is no npm package available, so you need to register a link instead. This can be done by running the following command from the antlr4 directory:
+
+```bash
+$ npm link antlr4
+```
+
+This will install antlr4 using the package.son descriptor that comes with the script.
+ 
+## How do I run the generated lexer and/or parser?
+
+Let's suppose that your grammar is named, as above, "MyGrammar". Let's suppose this parser comprises a rule named "StartRule". The tool will have generated for you the following files:
+
+*   MyGrammarLexer.js
+*   MyGrammarParser.js
+*   MyGrammarListener.js (if you have not activated the -no-listener option)
+*   MyGrammarVisitor.js (if you have activated the -visitor option)
+   
+(Developers used to Java/C# ANTLR will notice that there is no base listener or visitor generated, this is because JavaScript having no support for interfaces, the generated listener and visitor are fully fledged classes)
+
+Now a fully functioning script might look like the following:
+
+```javascript
+   var input = "your text to parse here"
+   var chars = new antlr4.InputStream(input);
+   var lexer = new MyGrammarLexer.MyGrammarLexer(chars);
+   var tokens  = new antlr4.CommonTokenStream(lexer);
+   var parser = new MyGrammarParser.MyGrammarParser(tokens);
+   parser.buildParseTrees = true;
+   var tree = parser.MyStartRule();
+```
+
+This program will work. But it won't be useful unless you do one of the following:
+
+* you visit the parse tree using a custom listener
+* you visit the parse tree using a custom visitor
+* your grammar comprises production code (like AntLR3)
+ 
+(please note that production code is target specific, so you can't have multi target grammars that include production code)
+ 
+## How do I create and run a custom listener?
+
+Let's suppose your MyGrammar grammar comprises 2 rules: "key" and "value". The antlr4 tool will have generated the following listener: 
+
+```javascript
+   MyGrammarListener = function(ParseTreeListener) {
+       // some code here
+   }
+   // some code here
+   MyGrammarListener.prototype.enterKey = function(ctx) {};
+   MyGrammarListener.prototype.exitKey = function(ctx) {};
+   MyGrammarListener.prototype.enterValue = function(ctx) {};
+   MyGrammarListener.prototype.exitValue = function(ctx) {};
+```
+
+In order to provide custom behavior, you might want to create the following class:
+  
+```javascript
+    KeyPrinter = function() {
+         MyGrammarListener.call(this); // inherit default listener
+         return this;
+    };
+ 
+// inherit default listener
+KeyPrinter.prototype = Object.create(MyGrammarListener.prototype);
+KeyPrinter.prototype.constructor = KeyPrinter;
+ 
+// override default listener behavior
+       KeyPrinter.prototype.exitKey = function(ctx) {      
+       console.log("Oh, a key!");
+   }; 
+```
+
+In order to execute this listener, you would simply add the following lines to the above code:
+ 
+```javascript
+        ...
+       tree = parser.StartRule() - only repeated here for reference
+   var printer = new KeyPrinter();
+ antlr4.tree.ParseTreeWalker.DEFAULT.walk(printer, tree);
+```
+
+## How do I integrate my parser with ACE editor?
+
+This specific task is described in this [dedicated page](ace-javascript-target.md).
+ 
+## How can I learn more about ANTLR?
+ 
+
+Further information can be found from  "The definitive ANTLR 4 reference" book.
+
+The JavaScript implementation of ANTLR is as close as possible to the Java one, so you shouldn't find it difficult to adapt the book's examples to JavaScript.
diff --git a/doc/left-recursion.md b/doc/left-recursion.md
new file mode 100644
index 000000000..3430e10e9
--- /dev/null
+++ b/doc/left-recursion.md
@@ -0,0 +1,50 @@
+# Left-recursive rules
+
+The most natural expression of some common language constructs is left recursive. For example C declarators and arithmetic expressions. Unfortunately, left recursive specifications of arithmetic expressions are typically ambiguous but much easier to write out than the multiple levels required in a typical top-down grammar. Here is a sample ANTLR 4 grammar with a left recursive expression rule:
+
+```
+stat: expr '=' expr ';' // e.g., x=y; or x=f(x);
+    | expr ';'          // e.g., f(x); or f(g(x));
+    ;
+expr: expr '*' expr
+    | expr '+' expr
+    | expr '(' expr ')' // f(x)
+    | id
+    ;
+```
+
+In straight context free grammars, such a rule is ambiguous because `1+2*3` it can interpret either operator as occurring first, but ANTLR rewrites that to be non-left recursive and unambiguous using semantic predicates:
+
+```
+expr[int pr] : id
+               ( {4 >= $pr}? '*' expr[5]
+               | {3 >= $pr}? '+' expr[4]
+               | {2 >= $pr}? '(' expr[0] ')'
+               )*
+             ;
+```
+
+The predicates resolve ambiguities by comparing the precedence of the current operator against the precedence of the previous operator. An expansion of expr[pr] can match only those subexpressions whose precedence meets or exceeds pr.
+
+## Formal rules
+
+The formal 4.0, 4.1 ANTLR left-recursion elimination rules were changed (simplified) for 4.2 and are laid out in the [ALL(*) tech report](http://www.antlr.org/papers/allstar-techreport.pdf):
+
+* Binary expressions are expressions which contain a recursive invocation of the rule as the first and last element of the alternative.
+* Suffix expressions contain a recursive invocation of the rule as the first element of the alternative, but not as the last element.
+* Prefix expressions contain a recursive invocation of the rule as the last element of the alternative, but not as the first element.
+
+There is no such thing as a "ternary" expression--they are just binary expressions in disguise.
+
+The right associativity specifiers used to be on the individual tokens but it's done on alternative basis anyway so the option is now on the individual alternative; e.g.,
+
+```
+e : e '*' e
+  | e '+' e
+  |<assoc=right> e '?' e ':' e
+  |<assoc=right> e '=' e
+  | INT
+  ;
+```
+
+If your 4.0 or 4.1 grammar uses a right-associative ternary operator, you will need to update your grammar to include `<assoc=right>` on the alternative operator. To smooth the transition, `<assoc=right>` is still allowed on token references but it is ignored.
diff --git a/doc/lexer-rules.md b/doc/lexer-rules.md
new file mode 100644
index 000000000..adda9e8b0
--- /dev/null
+++ b/doc/lexer-rules.md
@@ -0,0 +1,283 @@
+# Lexer Rules
+
+A lexer grammar is composed of lexer rules, optionally broken into multiple modes. Lexical modes allow us to split a single lexer grammar into multiple sublexers. The lexer can only return tokens matched by rules from the current mode.
+
+Lexer rules specify token definitions and more or less follow the syntax of parser rules except that lexer rules cannot have arguments, return values, or local variables. Lexer rule names must begin with an uppercase letter, which distinguishes them from parser rule names:
+
+```
+/** Optional document comment */
+TokenName : alternative1 | ... | alternativeN ;
+```
+
+You can also define rules that are not tokens but rather aid in the recognition of tokens. These fragment rules do not result in tokens visible to the parser:
+
+```
+fragment
+HelperTokenRule : alternative1 | ... | alternativeN ;
+```
+
+For example, `DIGIT` is a pretty common fragment rule:
+
+```
+INT : DIGIT+ ; // references the DIGIT helper rule
+fragment DIGIT : [0-9] ; // not a token by itself
+```
+
+## Lexical Modes
+
+Modes allow you to group lexical rules by context, such as inside and outside of XML tags. It’s like having multiple sublexers, one for context. The lexer can only return tokens matched by entering a rule in the current mode. Lexers start out in the so-called default mode. All rules are considered to be within the default mode unless you specify a mode command. Modes are not allowed within combined grammars, just lexer grammars. (See grammar `XMLLexer` from [Tokenizing XML](http://pragprog.com/book/tpantlr2/the-definitive-antlr-4-reference).)
+
+```
+rules in default mode
+...
+mode MODE1;
+rules in MODE1
+...
+mode MODEN;
+rules in MODEN
+...
+```
+
+## Lexer Rule Elements
+
+Lexer rules allow two constructs that are unavailable to parser rules: the .. range operator and the character set notation enclosed in square brackets, [characters]. Don’t confuse character sets with arguments to parser rules. [characters] only means character set in a lexer. Here’s a summary of all lexer rule elements:
+
+<table>
+<tr>
+<th>Syntax</th><th>Description</th>
+</tr>
+<tr>
+<td>T</td><td>
+Match token T at the current input position. Tokens always begin with a capital letter.</td>
+</tr>
+
+<tr>
+<td>’literal’</td><td>
+Match that character or sequence of characters. E.g., ’while’ or ’=’.</td>
+</tr>
+
+<tr>
+<td>[char set]</td><td>
+Match one of the characters specified in the character set. Interpret x-y as set of characters between range x and y, inclusively. The following escaped characters are interpreted as single special characters: \n, \r, \b, \t, and \f. To get ], \, or - you must escape them with \. You can also use Unicode character specifications: \uXXXX. Here are a few examples:
+
+<pre>
+WS : [ \n\u000D] -> skip ; // same as [ \n\r]
+ 	
+ID : [a-zA-Z] [a-zA-Z0-9]* ; // match usual identifier spec
+ 	
+DASHBRACK : [\-\]]+ ; // match - or ] one or more times
+</pre>
+</td>
+</tr>
+
+<tr>
+<td>’x’..’y’</td><td>
+Match any single character between range x and y, inclusively. E.g., ’a’..’z’. ’a’..’z’ is identical to [a-z].</td>
+</tr>
+
+<tr>
+<td>T</td><td>
+Invoke lexer rule T; recursion is allowed in general, but not left recursion. T can be a regular token or fragment rule.
+ 	
+<pre>
+ID : LETTER (LETTER|'0'..'9')* ;
+ 	
+fragment
+LETTER : [a-zA-Z\u0080-\u00FF_] ;
+</pre>
+</td>
+</tr>
+
+<tr>
+<td>.</td><td>
+The dot is a single-character wildcard that matches any single character. Example:
+<pre>
+ESC : '\\' . ; // match any escaped \x character
+</pre>
+</td>
+</tr>
+
+<tr>
+<td>{«action»}</td><td>
+Lexer actions can appear anywhere as of 4.2, not just at the end of the outermost alternative. The lexer executes the actions at the appropriate input position, according to the placement of the action within the rule. To execute a single action for a role that has multiple alternatives, you can enclose the alts in parentheses and put the action afterwards:
+ 	
+<pre>
+END : ('endif'|'end') {System.out.println("found an end");} ;
+</pre>
+
+<p>The action conforms to the syntax of the target language. ANTLR copies the action’s contents into the generated code verbatim; there is no translation of expressions like $x.y as there is in parser actions.</p>
+<p>
+Only actions within the outermost token rule are executed. In other words, if STRING calls ESC_CHAR and ESC_CHAR has an action, that action is not executed when the lexer starts matching in STRING.</p></td>
+</tr>
+
+<tr>
+<td>{«p»}?</td><td>
+Evaluate semantic predicate «p». If «p» evaluates to false at runtime, the surrounding rule becomes “invisible” (nonviable). Expression «p» conforms to the target language syntax. While semantic predicates can appear anywhere within a lexer rule, it is most efficient to have them at the end of the rule. The one caveat is that semantic predicates must precede lexer actions. See Predicates in Lexer Rules.</td>
+</tr>
+
+<tr>
+<td>~x</td><td>
+Match any single character not in the set described by x. Set x can be a single character literal, a range, or a subrule set like ~(’x’|’y’|’z’) or ~[xyz]. Here is a rule that uses ~ to match any character other than characters using ~[\r\n]*:
+<pre> 	
+COMMENT : '#' ~[\r\n]* '\r'? '\n' -> skip ;
+</pre>
+</td>
+</tr>
+</table>
+
+Just as with parser rules, lexer rules allow subrules in parentheses and EBNF operators: `?`, `*`, `+`. The `COMMENT` rule illustrates the `*` and `?` operators. A common use of `+` is `[0-9]+` to match integers. Lexer subrules can also use the nongreedy `?` suffix on those EBNF operators.
+
+## Recursive Lexer Rules
+
+ANTLR lexer rules can be recursive, unlike most lexical grammar tools. This comes in really handy when you want to match nested tokens like nested action blocks: `{...{...}...}`.
+
+```
+lexer grammar Recur;
+ 
+ACTION : '{' ( ACTION | ~[{}] )* '}' ;
+ 
+WS : [ \r\t\n]+ -> skip ;
+```
+
+## Redundant String Literals
+
+Be careful that you don’t specify the same string literal on the right-hand side of multiple lexer rules. Such literals are ambiguous and could match multiple token types. ANTLR makes this literal unavailable to the parser. The same is true for rules across modes. For example, the following lexer grammar defines two tokens with the same character sequence:
+
+```
+lexer grammar L;
+AND : '&' ;
+mode STR;
+MASK : '&' ;
+```
+
+A parser grammar cannot reference literal ’&’, but it can reference the name of the tokens:
+
+```
+parser grammar P;
+options { tokenVocab=L; }
+a : '&' // results in a tool error: no such token
+    AND // no problem
+    MASK // no problem
+  ;
+```
+
+Here’s a build and test sequence:
+
+```bash
+$ antlr4 L.g4 # yields L.tokens file needed by tokenVocab option in P.g4
+$ antlr4 P.g4
+error(126): P.g4:3:4: cannot create implicit token for string literal '&' in non-combined grammar
+```
+
+## Lexer Rule Actions
+
+An ANTLR lexer creates a Token object after matching a lexical rule. Each request for a token starts in `Lexer.nextToken`, which calls `emit` once it has identified a token. `emit` collects information from the current state of the lexer to build the token. It accesses fields `_type`, `_text`, `_channel`, `_tokenStartCharIndex`, `_tokenStartLine`, and `_tokenStartCharPositionInLine`. You can set the state of these with the various setter methods such as `setType`. For example, the following rule turns `enum` into an identifier if `enumIsKeyword` is false.
+
+```
+ENUM : 'enum' {if (!enumIsKeyword) setType(Identifier);} ;
+```
+
+ANTLR does no special `$x` attribute translations in lexer actions (unlike v3).
+
+There can be at most a single action for a lexical rule, regardless of how many alternatives there are in that rule.
+
+## Lexer Commands
+
+To avoid tying a grammar to a particular target language, ANTLR supports lexer commands. Unlike arbitrary embedded actions, these commands follow specific syntax and are limited to a few common commands. Lexer commands appear at the end of the outermost alternative of a lexer rule definition. Like arbitrary actions, there can only be one per token rule. A lexer command consists of the `->` operator followed by one or more command names that can optionally take parameters:
+
+```
+TokenName : «alternative» -> command-name
+TokenName : «alternative» -> command-name («identifier or integer»)
+```
+
+An alternative can have more than one command separated by commas. Here are the valid command names:
+
+* skip
+* more
+* popMode
+* mode( x )
+* pushMode( x )
+* type( x )
+* channel( x )
+
+See the book source code for usage, some examples of which are shown here:
+
+### skip
+
+A 'skip' command tells the lexer to get another token and throw out the current text.
+
+```
+ID : [a-zA-Z]+ ; // match identifiers
+INT : [0-9]+ ; // match integers
+NEWLINE:'\r'? '\n' ; // return newlines to parser (is end-statement signal)
+WS : [ \t]+ -> skip ; // toss out whitespace
+```
+
+### mode(), pushMode(), popMode, and more
+
+The mode commands alter the mode stack and hence the mode of the lexer. The 'more' command forces the lexer to get another token but without throwing out the current text. The token type will be that of the "final" rule matched (i.e., the one without a more or skip command).
+
+```
+// Default "mode": Everything OUTSIDE of a tag
+COMMENT : '<!--' .*? '-->' ;
+CDATA   : '<![CDATA[' .*? ']]>' ;OPEN : '<' -> pushMode(INSIDE) ;
+ ...
+XMLDeclOpen : '<?xml' S -> pushMode(INSIDE) ;
+SPECIAL_OPEN: '<?' Name -> more, pushMode(PROC_INSTR) ;
+// ----------------- Everything INSIDE of a tag ---------------------
+mode INSIDE;
+CLOSE        : '>' -> popMode ;
+SPECIAL_CLOSE: '?>' -> popMode ; // close <?xml...?>
+SLASH_CLOSE  : '/>' -> popMode ;
+```
+
+Also check out:
+
+```
+lexer grammar Strings;
+LQUOTE : '"' -> more, mode(STR) ;
+WS : [ \r\t\n]+ -> skip ;
+mode STR;
+STRING : '"' -> mode(DEFAULT_MODE) ; // token we want parser to see
+TEXT : . -> more ; // collect more text for string
+```
+
+Popping the bottom layer of a mode stack will result in an exception. Switching modes with `mode` changes the current stack top.  More than one `more` is the same as just one and the position does not matter.
+
+### type()
+
+```
+lexer grammar SetType;
+tokens { STRING }
+DOUBLE : '"' .*? '"'   -> type(STRING) ;
+SINGLE : '\'' .*? '\'' -> type(STRING) ;
+WS     : [ \r\t\n]+    -> skip ;
+```
+
+For multiple 'type()' commands, only the rightmost has an effect.
+
+### channel()
+
+```
+BLOCK_COMMENT
+	: '/*' .*? '*/' -> channel(HIDDEN)
+	;
+LINE_COMMENT
+	: '//' ~[\r\n]* -> channel(HIDDEN)
+	;
+... 
+// ----------
+// Whitespace
+//
+// Characters and character constructs that are of no import
+// to the parser and are used to make the grammar easier to read
+// for humans.
+//
+WS : [ \t\r\n\f]+ -> channel(HIDDEN) ;
+```
+
+As of 4.5, you can also define channel names like enumerations with the following construct above the lexer rules:
+
+```
+channels { WSCHANNEL, MYHIDDEN }
+```
diff --git a/doc/lexicon.md b/doc/lexicon.md
new file mode 100644
index 000000000..804a7456c
--- /dev/null
+++ b/doc/lexicon.md
@@ -0,0 +1,110 @@
+# Grammar Lexicon
+
+The lexicon of ANTLR is familiar to most programmers because it follows the syntax of C and its derivatives with some extensions for grammatical descriptions.
+
+## Comments
+
+There are single-line, multiline, and Javadoc-style comments:
+
+```
+/** This grammar is an example illustrating the three kinds
+ * of comments.
+ */
+grammar T;
+/* a multi-line
+  comment
+*/
+
+/** This rule matches a declarator for my language */
+decl : ID ; // match a variable name
+```
+
+The Javadoc comments are hidden from the parser and are ignored at the moment.  They are intended to be used only at the start of the grammar and any rule.
+
+## Identifiers
+
+Token names always start with a capital letter and so do lexer rules as defined by Java’s `Character.isUpperCase` method. Parser rule names always start with a lowercase letter (those that fail `Character.isUpperCase`). The initial character can be followed by uppercase and lowercase letters, digits, and underscores. Here are some sample names:
+
+```
+ID, LPAREN, RIGHT_CURLY // token names/rules
+expr, simpleDeclarator, d2, header_file // rule names
+```
+
+Like Java, ANTLR accepts Unicode characters in ANTLR names:
+
+<img src=images/nonascii.png width=100>
+
+To support Unicode parser and lexer rule names, ANTLR uses the following rule:
+
+```
+ID : a=NameStartChar NameChar*
+     {  
+     if ( Character.isUpperCase(getText().charAt(0)) ) setType(TOKEN_REF);
+     else setType(RULE_REF);
+     }  
+   ;
+```
+
+Rule `NameChar` identifies the valid identifier characters:
+
+```
+fragment
+NameChar
+   : NameStartChar
+   | '0'..'9'
+   | '_'
+   | '\u00B7'
+   | '\u0300'..'\u036F'
+   | '\u203F'..'\u2040'
+   ;
+fragment
+NameStartChar
+   : 'A'..'Z' | 'a'..'z'
+   | '\u00C0'..'\u00D6'
+   | '\u00D8'..'\u00F6'
+   | '\u00F8'..'\u02FF'
+   | '\u0370'..'\u037D'
+   | '\u037F'..'\u1FFF'
+   | '\u200C'..'\u200D'
+   | '\u2070'..'\u218F'
+   | '\u2C00'..'\u2FEF'
+   | '\u3001'..'\uD7FF'
+   | '\uF900'..'\uFDCF'
+   | '\uFDF0'..'\uFFFD'
+   ;
+```
+
+Rule `NameStartChar` is the list of characters that can start an identifier (rule, token, or label name):
+These more or less correspond to `isJavaIdentifierPart` and `isJavaIdentifierStart` in Java’s Character class. Make sure to use the `-encoding` option on the ANTLR tool if your grammar file is not in UTF-8 format, so that ANTLR reads characters properly.
+
+## Literals
+
+ANTLR does not distinguish between character and string literals as most languages do. All literal strings one or more characters in length are enclosed in single quotes such as `’;’`, `’if’`, `’>=’`, and `’\’'` (refers to the one-character string containing the single quote character). Literals never contain regular expressions.
+
+Literals can contain Unicode escape sequences of the form `\uXXXX`, where XXXX is the hexadecimal Unicode character value. For example, `’\u00E8’` is the French letter with a grave accent: `’è’`. ANTLR also understands the usual special escape sequences: `’\n’` (newline), `’\r’` (carriage return), `’\t’` (tab), `’\b’` (backspace), and `’\f’` (form feed). You can use Unicode characters directly within literals or use the Unicode escape sequences:
+
+```
+grammar Foreign;
+a : '外' ;
+```
+
+The recognizers that ANTLR generates assume a character vocabulary containing all Unicode characters. The input file encoding assumed by the runtime library depends on the target language. For the Java target, the runtime library assumes files are in UTF-8. Using the constructors, you can specify a different encoding. See, for example, ANTLR’s `ANTLRFileStream`.
+
+## Actions
+
+Actions are code blocks written in the target language. You can use actions in a number of places within a grammar, but the syntax is always the same: arbitrary text surrounded by curly braces. You don’t need to escape a closing curly character if it’s in a string or comment: `"}"` or `/*}*/`. If the curlies are balanced, you also don’t need to escape }: `{...}`. Otherwise, escape extra curlies with a backslash: `\{` or `\}`. The action text should conform to the target language as specified with thelanguage option.
+
+Embedded code can appear in: `@header` and `@members` named actions, parser and lexer rules, exception catching specifications, attribute sections for parser rules (return values, arguments, and locals), and some rule element options (currently predicates).
+
+The only interpretation ANTLR does inside actions relates to grammar attributes; see [Token Attributes](http://pragprog.com/book/tpantlr2/the-definitive-antlr-4-reference) and Chapter 10, [Attributes and Actions](http://pragprog.com/book/tpantlr2/the-definitive-antlr-4-reference). Actions embedded within lexer rules are emitted without any interpretation or translation into generated lexers.
+
+## Keywords
+
+Here’s a list of the reserved words in ANTLR grammars:
+
+```
+import, fragment, lexer, parser, grammar, returns,
+locals, throws, catch, finally, mode, options, tokens
+```
+  
+Also, although it is not a keyword, do not use the word `rule` as a rule name. Further, do not use any keyword of the target language as a token, label, or rule name. For example, rule `if` would result in a generated function called `if`.  That would not compile obviously.
diff --git a/doc/listeners.md b/doc/listeners.md
new file mode 100644
index 000000000..c3bcad9c1
--- /dev/null
+++ b/doc/listeners.md
@@ -0,0 +1,38 @@
+# Parse Tree Listeners
+
+*Partially taken from publically visible [excerpt from ANTLR 4 book](http://media.pragprog.com/titles/tpantlr2/picture.pdf)*
+
+By default, ANTLR-generated parsers build a data structure called a parse tree or syntax tree that records how the parser recognized the structure of the input sentence and component phrases.
+
+<img src=images/process.png>
+
+The interior nodes of the parse tree are phrase names that group and identify their children. The root node is the most abstract phrase name, in this case `stat` (short for statement). The leaves of a parse tree are always the input tokens. Parse trees sit between a language recognizer and an interpreter or translator implementation. They are extremely effective data structures because they contain all of the input and complete knowledge of how the parser grouped the symbols into phrases. Better yet, they are easy to understand and the parser generates them automatically (unless you turn them off with `parser.setBuildParseTree(false)`).
+
+Because we specify phrase structure with a set of rules, parse tree subtree roots correspond to grammar rule names. ANTLR has a ParseTreeWalker that knows how to walk these parse trees and trigger events in listener implementation objects that you can create. The ANTLR tool generates listener interfaces for you also, unless you turn that off with a commandline option. You can also have it generate visitors. For example from a Java.g4 grammar, ANTLR generates:
+
+```java
+public interface JavaListener extends ParseTreeListener<Token> {
+  void enterClassDeclaration(JavaParser.ClassDeclarationContext ctx);
+  void exitClassDeclaration(JavaParser.ClassDeclarationContext ctx);
+  void enterMethodDeclaration(JavaParser.MethodDeclarationContext ctx);
+ ...
+}
+```
+
+where there is an enter and exit method for each rule in the parser grammar. ANTLR also generates a base listener with the fall empty implementations of all listener interface methods, in this case called JavaBaseListener. You can build your listener by subclassing this base and overriding the methods of interest.
+
+Assuming you've created a listener object called `MyListener`, here is how to call the Java parser and walk the parse tree:
+
+```java
+JavaLexer lexer = new JavaLexer(input);
+CommonTokenStream tokens = new CommonTokenStream(lexer);
+JavaParser parser = new JavaParser(tokens);
+JavaParser.CompilationUnitContext tree = parser.compilationUnit(); // parse a compilationUnit
+
+MyListener extractor = new MyListener(parser);
+ParseTreeWalker.DEFAULT.walk(extractor, tree); // initiate walk of tree with listener in use of default walker
+```
+
+Listeners and visitors are great because they keep application-specific code out of grammars, making grammars easier to read and preventing them from getting entangled with a particular application.
+
+See the book for more information on listeners and to learn how to use visitors. (The biggest difference between the listener and visitor mechanisms is that listener methods are called independently by an ANTLR-provided walker object, whereas visitor methods must walk their children with explicit visit calls.  Forgetting to invoke visitor methods on a node’s children, means those subtrees don’t get visited.)
diff --git a/doc/options.md b/doc/options.md
new file mode 100644
index 000000000..7ce277551
--- /dev/null
+++ b/doc/options.md
@@ -0,0 +1,101 @@
+# Options
+
+There are a number of options that you can specify at the grammar and rule element level. (There are currently no rule options.) These change how ANTLR generates code from your grammar. The general syntax is:
+
+```
+options { name1=value1; ... nameN=valueN; } // ANTLR not target language syntax
+```
+
+where a value can be an identifier, a qualified identifier (for example, a.b.c), a string, a multi-line string in curly braces `{...}`, and an integer.
+
+## Grammar Options
+
+All grammars can use the following options. In combined grammars, all options except language pertain only to the generated parser. Options may be set either within the grammar file using the options syntax (described above) or when invoking ANTLR on the command line, using the `-D` option. (see Section 15.9, [ANTLR Tool Command Line Options](tool-options.md).) The following examples demonstrate both mechanisms; note that `-D` overrides options within the grammar.
+
+* `superClass`. Set the superclass of the generated parser or lexer. For combined grammars, it sets the superclass of the parser.
+```
+$ cat Hi.g4
+grammar Hi;
+a : 'hi' ;
+$ antlr4 -DsuperClass=XX Hi.g4
+$ grep 'public class' HiParser.java
+public class HiParser extends XX {
+$ grep 'public class' HiLexer.java
+public class HiLexer extends Lexer {
+```
+* `language` Generate code in the indicated language, if ANTLR is able to do so. Otherwise, you will see an error message like this:
+```
+$ antlr4 -Dlanguage=C MyGrammar.g4
+error(31):  ANTLR cannot generate C code as of version 4.0
+```
+* `tokenVocab` ANTLR assigns token type numbers to the tokens as it encounters them in a file. To use different token type values, such as with a separate lexer, use this option to have ANTLR pull in the <fileextension>tokens</fileextension> file. ANTLR generates a <fileextension>tokens</fileextension> file from each grammar.
+```
+$ cat SomeLexer.g4
+lexer grammar SomeLexer;
+ID : [a-z]+ ;
+$ cat R.g4
+parser grammar R;
+options {tokenVocab=SomeLexer;}
+tokens {A,B,C} // normally, these would be token types 1, 2, 3
+a : ID ;
+$ antlr4 SomeLexer.g4
+$ cat SomeLexer.tokens 
+ID=1
+$ antlr4 R.g4
+$ cat R.tokens
+A=2
+B=3
+C=4
+ID=1
+```
+* `TokenLabelType` ANTLR normally uses type <class>Token</class> when it generates variables referencing tokens. If you have passed a <class>TokenFactory</class> to your parser and lexer so that they create custom tokens, you should set this option to your specific type. This ensures that the context objects know your type for fields and method return values.
+```
+$ cat T2.g4
+grammar T2;
+options {TokenLabelType=MyToken;}
+a : x=ID ;
+$ antlr4 T2.g4
+$ grep MyToken T2Parser.java
+    public MyToken x;
+```
+* `contextSuperClass`. Specify the super class of parse tree internal nodes. Default is `ParserRuleContext`. Should derive from ultimately `RuleContext` at minimum.
+Java target can use `contextSuperClass=org.antlr.v4.runtime.RuleContextWithAltNum` for convenience. It adds a backing field for `altNumber`, the alt matched for the associated rule node. 
+
+## Rule Options
+
+There are currently no valid rule-level options, but the tool still supports the following syntax for future use:
+
+```
+rulename
+options {...}
+ 	: ...
+ 	;
+```
+
+## Rule Element Options
+
+Token options have the form `T<name=value>` as we saw in Section 5.4, [Dealing with Precedence, Left Recursion, and Associativity](http://pragprog.com/book/tpantlr2/the-definitive-antlr-4-reference). The only token option is `assoc`, and it accepts values `left` and `right`. Here’s a sample grammar with a left-recursive expression rule that specifies a token option on the `^` exponent operator token:
+
+```
+grammar ExprLR;
+ 	 
+expr : expr '^'<assoc=right> expr
+ 	| expr '*' expr // match subexpressions joined with '*' operator
+ 	| expr '+' expr // match subexpressions joined with '+' operator
+ 	| INT // matches simple integer atom
+ 	;
+ 	 
+INT : '0'..'9'+ ;
+WS : [ \n]+ -> skip ;
+```
+
+Semantic predicates also accept an option, per [Catching failed semantic predicates](http://pragprog.com/book/tpantlr2/the-definitive-antlr-4-reference). The only valid option is the `fail` option, which takes either a string literal in double-quotes or an action that evaluates to a string. The string literal or string result from the action should be the message to emit upon predicate failure.
+
+```
+ints[int max]
+ 	locals [int i=1]
+ 	: INT ( ',' {$i++;} {$i<=$max}?<fail={"exceeded max "+$max}> INT )*
+ 	;
+```
+
+The action can execute a function as well as compute a string when a predicate fails: `{...}?<fail={doSomethingAndReturnAString()}>`
diff --git a/doc/parser-rules.md b/doc/parser-rules.md
new file mode 100644
index 000000000..2fa7d6b5c
--- /dev/null
+++ b/doc/parser-rules.md
@@ -0,0 +1,480 @@
+# Parser Rules
+
+Parsers consist of a set of parser rules either in a parser or a combined grammar. A Java application launches a parser by invoking the rule function, generated by ANTLR, associated with the desired start rule. The most basic rule is just a rule name followed by a single alternative terminated with a semicolon:
+
+```
+ 	/** Javadoc comment can precede rule */
+ 	retstat : 'return' expr ';' ;
+```
+
+Rules can also have alternatives separated by the | 
+
+```
+operator:
+ 	stat: retstat
+ 	| 'break' ';'
+ 	| 'continue' ';'
+ 	;
+```
+
+Alternatives are either a list of rule elements or empty. For example, here’s a rule with an empty alternative that makes the entire rule optional:
+
+```
+superClass
+ 	: 'extends' ID
+ 	| // empty means other alternative(s) are optional
+ 	;
+```
+
+## Alternative Labels
+
+As we saw in Section 7.4, Labeling Rule Alternatives for Precise Event Methods, we can get more precise parse-tree listener events by labeling the outermost alternatives of a rule using the # operator. All alternatives within a rule must be labeled, or none of them. Here are two rules with labeled alternatives.
+
+```
+grammar T;
+stat: 'return' e ';' # Return
+ 	| 'break' ';' # Break
+ 	;
+e   : e '*' e # Mult
+    | e '+' e # Add
+    | INT # Int
+    ;
+```
+
+Alternative labels do not have to be at the end of the line and there does not have to be a space after the # symbol.
+ANTLR generates a rule context class definition for each label. For example, here is the listener that ANTLR generates:
+
+```java
+public interface AListener extends ParseTreeListener {
+ 	void enterReturn(AParser.ReturnContext ctx);
+ 	void exitReturn(AParser.ReturnContext ctx);
+ 	void enterBreak(AParser.BreakContext ctx);
+ 	void exitBreak(AParser.BreakContext ctx);
+ 	void enterMult(AParser.MultContext ctx);
+ 	void exitMult(AParser.MultContext ctx);
+ 	void enterAdd(AParser.AddContext ctx);
+ 	void exitAdd(AParser.AddContext ctx);
+ 	void enterInt(AParser.IntContext ctx);
+ 	void exitInt(AParser.IntContext ctx);
+}
+```
+
+There are enter and exit methods associated with each labeled alternative. The parameters to those methods are specific to alternatives.
+
+You can reuse the same label on multiple alternatives to indicate that the parse tree walker should trigger the same event for those alternatives. For example, here’s a variation on rule e from grammar A above:
+
+```
+ 	e : e '*' e # BinaryOp
+ 	| e '+' e # BinaryOp
+ 	| INT # Int
+ 	;
+```
+
+ANTLR would generate the following listener methods for e:
+
+```java
+ 	void enterBinaryOp(AParser.BinaryOpContext ctx);
+ 	void exitBinaryOp(AParser.BinaryOpContext ctx);
+ 	void enterInt(AParser.IntContext ctx);
+ 	void exitInt(AParser.IntContext ctx);
+ ```
+
+ANTLR gives errors if an alternative name conflicts with a rule name. Here’s another rewrite of rule e where two 
+alternative labels conflict with rule names:
+
+```
+ 	e : e '*' e # e
+ 	| e '+' e # Stat
+ 	| INT # Int
+ 	;
+```
+
+The context objects generated from rule names and labels get capitalized and so label Stat conflicts with rule stat:
+
+```bash
+ 	$ antlr4 A.g4
+ 	error(124): A.g4:5:23: rule alt label e conflicts with rule e
+ 	error(124): A.g4:6:23: rule alt label Stat conflicts with rule stat
+ 	warning(125): A.g4:2:13: implicit definition of token INT in parser
+```
+
+## Rule Context Objects
+
+ANTLR generates methods to access the rule context objects (parse tree nodes) associated with each rule reference. For rules with a single rule reference, ANTLR generates a method with no arguments. Consider the following rule.
+
+```
+ 	inc : e '++' ;
+```
+
+ANTLR generates this context class:
+
+```java
+public static class IncContext extends ParserRuleContext {
+ 	public EContext e() { ... } // return context object associated with e
+ 	...
+}
+```
+
+ANTLR also provide support to access context objects when there is more than a single reference to a rule:
+
+```
+field : e '.' e ;
+```
+
+ANTLR generates a method with an index to access the ith element as well as a method to get context for all references to that rule:
+
+```java
+public static class FieldContext extends ParserRuleContext {
+ 	public EContext e(int i) { ... } // get ith e context
+ 	public List<EContext> e() { ... } // return ALL e contexts
+ 	...
+}
+```
+
+If we had another rule, s, that references field, an embedded action could access the list of e rule matches performed by field:
+
+```
+s : field
+ 	{
+ 	List<EContext> x = $field.ctx.e();
+ 	...
+ 	}
+;
+```
+
+A listener or visitor could do the same thing. Given a pointer to a FieldContext object, f, f.e() would return List<EContext>.
+
+## Rule Element Labels
+
+You can label rule elements using the = operator to add fields to the rule context objects:
+
+```
+stat: 'return' value=e ';' # Return
+ 	| 'break' ';' # Break
+ 	;
+```
+
+Here value is the label for the return value of rule e, which is defined elsewhere.
+Labels become fields in the appropriate parse tree node class. In this case, label value becomes a field in ReturnContext because of the Return alternative label:
+
+```java
+public static class ReturnContext extends StatContext {
+ 	public EContext value;
+ 	...
+}
+```
+
+It’s often handy to track a number of tokens, which you can do with the += “list label” operator. For example, the following rule creates a list of the Token objects matched for a simple array construct:
+
+```
+ 	array : '{' el+=INT (',' el+=INT)* '}' ;
+```
+
+ANTLR generates a List field in the appropriate rule context class:
+
+```
+ 	public static class ArrayContext extends ParserRuleContext {
+ 	public List<Token> el = new ArrayList<Token>();
+ 	...
+ 	}
+```
+
+These list labels also work for rule references:
+
+```
+ 	elist : exprs+=e (',' exprs+=e)* ;
+```
+
+ANTLR generates a field holding the list of context objects:
+
+```
+ 	public static class ElistContext extends ParserRuleContext {
+ 	public List<EContext> exprs = new ArrayList<EContext>();
+ 	...
+ 	}
+```
+
+## Rule Elements
+
+Rule elements specify what the parser should do at a given moment just like statements in a programming language. The elements can be rule, token, string literal like expression, ID, and ’return’. Here’s a complete list of the rule elements (we’ll look at actions and predicates in more detail later):
+
+<table>
+<tr>
+<th>Syntax</th><th>Description</th>
+</tr>
+<tr>
+<td>T</td><td>
+Match token T at the current input position. Tokens always begin with a capital letter.</td>
+</tr>
+<tr>
+<td>’literal’</td><td>
+Match the string literal at the current input position. A string literal is simply a token with a fixed string.</td>
+</tr>
+<tr>
+<td>r</td><td>
+Match rule r at current input position, which amounts to invoking the rule just like a function call. Parser rule names always begin with a lowercase letter.</td>
+</tr>
+<tr>
+<td>r [«args»]</td><td>
+Match rule r at current input position, passing in a list of arguments just like a function call. The arguments inside the square brackets are in the syntax of the target language and are usually a comma-separated list of expressions.</td>
+</tr>
+<tr>
+<td>{«action»}</td><td>
+Execute an action immediately after the preceding alternative element and immediately before the following alternative element. The action conforms to the syntax of the target language. ANTLR copies the action code to the generated class verbatim, except for substituting attribute and token references such as $x and $x.y.</td>
+</tr>
+<tr>
+<td>{«p»}?</td><td>
+Evaluate semantic predicate «p». Do not continue parsing past a predicate if «p» evaluates to false at runtime. Predicates encountered during prediction, when ANTLR distinguishes between alternatives, enable or disable the alternative(s) surrounding the predicate(s).</td>
+</tr>
+<tr>
+<td>.</td><td>
+Match any single token except for the end of file token. The “dot” operator is called the wildcard.</td>
+</tr>
+</table>
+
+When you want to match everything but a particular token or set of tokens, use the `~` “not” operator. This operator is rarely used in the parser but is available. `~INT` matches any token except the `INT` token. `~’,’` matches any token except the comma. `~(INT|ID)` matches any token except an INT or an ID.
+
+Token, string literal, and semantic predicate rule elements can take options. See Rule Element Options.
+
+## Subrules
+
+A rule can contain alternative blocks called subrules (as allowed in Extended BNF Notation: EBNF). A subrule is like a rule that lacks a name and is enclosed in parentheses. Subrules can have one or more alternatives inside the parentheses. Subrules cannot define attributes with locals and returns like rules can. There are four kinds of subrules (x, y, and z represent grammar fragments):
+
+<table>
+<tr>
+<th>Syntax</th><th>Description</th>
+</tr>
+<tr>
+<td><img src=images/xyz.png></td><td>(x|y|z).
+Match any alternative within the subrule exactly once. Example:
+<br>
+<tt>
+returnType : (type | 'void') ;
+</tt>
+</td>
+</tr>
+<tr>
+<td><img src=images/xyz_opt.png></td><td>(x|y|z)?
+Match nothing or any alternative within subrule. Example:
+<br>
+<tt>	
+classDeclaration
+    : 'class' ID (typeParameters)? ('extends' type)?
+      ('implements' typeList)?
+ 	   classBody
+    ;
+</tt>
+<tr>
+<td><img src=images/xyz_star.png></td><td>(x|y|z)*
+Match an alternative within subrule zero or more times. Example:
+<br>
+<tt>
+annotationName : ID ('.' ID)* ;
+</tt>
+</tr>
+<tr>	
+<td><img src=images/xyz_plus.png></td><td>(x|y|z)+
+Match an alternative within subrule one or more times. Example:
+<br>
+<tt>
+annotations : (annotation)+ ;
+</tt>
+</td>
+</tr>
+</table>
+
+You can suffix the `?`, `*`, and `+` subrule operators with the nongreedy operator, which is also a question mark: `??`, `*?`, and `+?`. See Section 15.6, Wildcard Operator and Nongreedy Subrules.
+
+As a shorthand, you can omit the parentheses for subrules composed of a single alternative with a single rule element reference. For example, `annotation+` is the same as `(annotation)+` and `ID+` is the same as `(ID)+`. Labels also work with the shorthand. `ids+=INT+` make a list of `INT` token objects.
+
+## Catching Exceptions
+
+When a syntax error occurs within a rule, ANTLR catches the exception, reports the error, attempts to recover (possibly by consuming more tokens), and then returns from the rule. Every rule is wrapped in a `try/catch/finally` statement:
+
+```
+void r() throws RecognitionException {
+ 	try {
+ 		rule-body
+ 	}
+ 	catch (RecognitionException re) {
+	 	_errHandler.reportError(this, re);
+	 	_errHandler.recover(this, re);
+ 	}
+ 	finally {
+		exitRule();
+ 	}
+}
+```
+
+In Section 9.5, Altering ANTLR’s Error Handling Strategy, we saw how to use a strategy object to alter ANTLR’s error handling. Replacing the strategy changes the strategy for all rules, however. To alter the exception handling for a single rule, specify an exception after the rule definition:
+
+```
+r : ...
+  ;
+  catch[RecognitionException e] { throw e; }
+```
+
+That example shows how to avoid default error reporting and recovery. r rethrows the exception, which is useful when it makes more sense for a higher-level rule to report the error. Specifying any exception clause, prevents ANTLR from generating a clause to handle `RecognitionException`.
+
+You can specify other exceptions as well:
+
+```
+r : ...
+  ;
+  catch[FailedPredicateException fpe] { ... }
+  catch[RecognitionException e] { ... }
+```
+
+The code snippets inside curly braces and the exception “argument” actions must be written in the target language; Java, in this case.
+When you need to execute an action even if an exception occurs, put it into the `finally` clause:
+
+```
+r : ...
+  ;
+  // catch blocks go first
+  finally { System.out.println("exit rule r"); }
+```
+
+The finally clause executes right before the rule triggers `exitRule` before returning. If you want to execute an action after the rule finishes matching the alternatives but before it does its cleanup work, use an `after` action.
+
+Here’s a complete list of exceptions:
+
+<table>
+<tr>
+<th>Exception name</th><th>Description</th>
+</tr>
+<tr>
+<td>RecognitionException</td><td>
+The superclass of all exceptions thrown by an ANTLR-generated recognizer. It’s a subclass of RuntimeException to avoid the hassles of checked exceptions. This exception records where the recognizer (lexer or parser) was in the input, where it was in the ATN (internal graph data structure representing the grammar), the rule invocation stack, and what kind of problem occurred.</td>
+</tr>
+<tr>
+<td>NoViableAltException</td><td>
+Indicates that the parser could not decide which of two or more paths to take by looking at the remaining input. This exception tracks the starting token of the offending input and also knows where the parser was in the various paths when the error occurred.</td>
+</tr>
+<tr>
+<td>LexerNoViableAltException</td><td>
+The equivalent of NoViableAltException but for lexers only.</td>
+</tr>
+<tr>
+<td>InputMismatchException</td><td>
+The current input Token does not match what the parser expected.</td>
+</tr>
+<tr>
+<td>FailedPredicateException</td><td>
+A semantic predicate that evaluates to false during prediction renders the surrounding alternative nonviable. Prediction occurs when a rule is predicting which alternative to take. If all viable paths disappear, parser will throw NoViableAltException. This predicate gets thrown by the parser when a semantic predicate evaluates to false outside of prediction, during the normal parsing process of matching tokens and calling rules.</td>
+</tr>
+</table>
+
+## Rule Attribute Definitions
+
+There are a number of action-related syntax elements associated with rules to be aware of. Rules can have arguments, return values, and local variables just like functions in a programming language. (Rules can have actions embedded among the rule elements, as we’ll see in Section 15.4, Actions and Attributes.) ANTLR collects all of the variables you define and stores them in the rule context object. These variables are usually called attributes. Here’s the general syntax showing all possible attribute definition locations:
+
+```
+rulename[args] returns [retvals] locals [localvars] : ... ;
+```
+
+The attributes defined within those [...] can be used like any other variable. Here is a sample rule that copies parameters to return values:
+
+```
+// Return the argument plus the integer value of the INT token
+add[int x] returns [int result] : '+=' INT {$result = $x + $INT.int;} ;
+```
+
+As with the grammar level, you can specify rule-level named actions. For rules, the valid names are init and after. As the names imply, parsers execute init actions immediately before trying to match the associated rule and execute after actions immediately after matching the rule. ANTLR after actions do not execute as part of the finally code block of the generated rule function. Use the ANTLR finally action to place code in the generated rule function finally code block.
+The actions come after any argument, return value, or local attribute definition actions. The row rule preamble from Section 10.2, Accessing Token and Rule Attributes illustrates the syntax nicely:
+actions/CSV.g4
+
+```
+/** Derived from rule "row : field (',' field)* '\r'? '\n' ;" */
+row[String[] columns]
+   returns [Map<String,String> values]
+   locals [int col=0]
+	@init {
+	$values = new HashMap<String,String>();
+	}
+	@after {
+	if ($values!=null && $values.size()>0) {
+	System.out.println("values = "+$values);
+	}
+	}
+	: ...
+	;
+```
+
+Rule row takes argument columns, returns values, and defines local variable col. The “actions” in square brackets are copied directly into the generated code:
+
+```java
+public class CSVParser extends Parser {
+	...
+	public static class RowContext extends ParserRuleContext {
+		public String [] columns;
+		public Map<String,String> values;
+		public int col=0;
+		...
+	}
+	...
+}
+```
+
+The generated rule functions also specify the rule arguments as function arguments, but they are quickly copied into the local RowContext object:
+
+```java
+public class CSVParser extends Parser {
+ 	...
+ 	public final RowContext row(String [] columns) throws RecognitionException {
+	 	RowContext _localctx = new RowContext(_ctx, 4, columns);
+	 	enterRule(_localctx, RULE_row);
+	 	...
+ 	}
+ 	...
+}
+```
+
+ANTLR tracks nested `[...]` within the action so that `String[]` columns is parsed properly. It also tracks angle brackets so that commas within generic type parameters do not signify the start of another attribute. `Map<String,String>` values is one attribute definition.
+
+There can be multiple attributes in each action, even for return values. Use a comma to separate attributes within the same action:
+
+```
+a[Map<String,String> x, int y] : ... ;
+```
+
+ANTLR interprets that action to define two arguments, x and y:
+
+```java
+public final AContext a(Map<String,String> x, int y)
+	throws RecognitionException
+{
+	AContext _localctx = new AContext(_ctx, 0, x, y);
+	enterRule(_localctx, RULE_a);
+	...
+}
+```
+
+## Start Rules and EOF
+
+A start rule is the rule engaged first by the parser; it’s the rule function called by the language application. For example, a language application that parsed to Java code might call `parser.compilationUnit()` for a `JavaParser` object called `parser`. Any rule in the grammar can act as a start rule.
+
+Start rules don’t necessarily consume all of the input. They consume only as much input as needed to match an alternative of the rule. For example, consider the following rule that matches one, two, or three tokens, depending on the input.
+
+```
+s : ID
+  | ID '+'
+  | ID '+' INT
+  ;
+```
+
+Upon `a+3`, rule `s` matches the third alternative. Upon `a+b`, it matches the second alternative and ignores the final `b` token. Upon `a b`, it matches the first alternative, ignoring the `b` token. The parser does not consume the complete input in the latter two cases because rule `s` doesn’t explicitly say that end of file must occur after matching an alternative of the rule.
+
+This default functionality is very useful for building things like IDEs. Imagine the IDE wanting to parse a method somewhere in the middle of a big Java file. Calling rule `methodDeclaration` should try to match just a method and ignore whatever comes next.
+
+On the other hand, rules that describe entire input files should reference special predefined-token `EOF`. If they don’t, you might scratch your head for a while wondering why the start rule doesn’t report errors for any input no matter what you give it. Here’s a rule that’s part of a grammar for reading configuration files:
+
+```
+config : element*; // can "match" even with invalid input.
+```
+
+Invalid input would cause `config` to return immediately without matching any input and without reporting an error. Here’s the proper specification:
+
+```
+file : element* EOF; // don't stop early. must match all input
+```
\ No newline at end of file
diff --git a/doc/predicates.md b/doc/predicates.md
new file mode 100644
index 000000000..09998c425
--- /dev/null
+++ b/doc/predicates.md
@@ -0,0 +1,164 @@
+# Semantic Predicates
+
+Semantic predicates, `{...}?`, are boolean expressions written in the target language that indicate the validity of continuing the parse along the path "guarded" by the predicate. Predicates can appear anywhere within a parser rule just like actions can, but only those appearing on the left edge of alternatives can affect prediction (choosing between alternatives).  This section provides all of the fine print regarding the use of semantic predicates in parser and lexer rules. Let's start out by digging deeper into how the parser incorporates predicates into parsing decisions.
+
+## Making Predicated Parsing Decisions
+
+ANTLR's general decision-making strategy is to find all viable alternatives and then ignore the alternatives guarded with predicates that currently evaluate to false. (A viable alternative is one that matches the current input.) If more than one viable alternative remains, the parser chooses the alternative specified first in the decision.
+
+Consider a variant of C++ where array references also use parentheses instead of square brackets. If we only predicate one of the alternatives, we still have an ambiguous decision in expr:
+
+```
+expr: ID '(' expr ')' // array reference (ANTLR picks this one)
+ 	| {istype()}? ID '(' expr ')' // ctor-style typecast
+ 	| ID '(' expr ')' // function call
+ 	;
+```
+
+In this case, all three alternatives are viable for input `x(i)`. When `x` is not a type name, the predicate evaluates to false, leaving only the first and third alternatives as possible matches for expr. ANTLR automatically chooses the first alternative matching the array reference to resolve the ambiguity. Leaving ANTLR with more than one viable alternative because of too few predicates is probably not a good idea. It's best to cover n viable alternatives with at least n-1 predicates. In other words, don't build rules like expr with too few predicates.
+
+Sometimes, the parser finds multiple visible predicates associated with a single choice. No worries. ANTLR just combines the predicates with appropriate logical operators to conjure up a single meta-predicate on-the-fly.
+
+For example, the decision in rule `stat` joins the predicates from both alternatives of expr with the `||` operator to guard the second stat alternative:
+
+```
+stat: decl | expr ;
+decl: ID ID ;
+expr: {istype()}? ID '(' expr ')' // ctor-style typecast
+ 	| {isfunc()}? ID '(' expr ')' // function call
+ 	;
+```
+
+The parser will only predict an expr from stat when `istype()||isfunc()` evaluates to true. This makes sense because the parser should only choose to match an expression if the upcoming `ID` is a type name or function name. It wouldn't make sense to just test one of the predicates in this case. Note that, when the parser gets to `expr` itself, the parsing decision tests the predicates individually, one for each alternative.
+
+If multiple predicates occur in a sequence, the parser joins them with the `&&` operator. For example, consider changing `stat` to include a predicate before the call `toexpr`:
+
+```
+stat: decl | {java5}? expr ;
+```
+
+Now, the parser would only predict the second alternative if `java5&&(istype()||isfunc())` evaluated to true.
+
+Turning to the code inside the predicates themselves now, keep in mind the following guidelines.
+
+Even when the parser isn't making decisions, predicates can deactivate alternatives, causing rules to fail. This happens when a rule only has a single alternative. There is no choice to make, but ANTLR evaluates the predicate as part of the normal parsing process, just like it does for actions. That means that the following rule always fails to match.
+
+```
+prog: {false}? 'return' INT ; // throws FailedPredicateException
+```
+
+ANTLR converts `{false}?` in the grammar to a conditional in the generated parser:
+
+```
+if ( !false ) throw new FailedPredicateException(...);
+```
+
+So far, all of the predicates we've seen have been visible and available to the prediction process, but that's not always the case.
+
+## Finding Visible Predicates
+
+The parser will not evaluate predicates during prediction that occur after an action or token reference. Let's think about the relationship between actions and predicates first.
+
+ANTLR has no idea what's inside the raw code of an action and so it must assume any predicate could depend on side effects of that action. Imagine an action that computed value `x` and a predicate that tested `x`. Evaluating that predicate before the action executed to create `x` would violate the implied order of operations within the grammar.
+
+More importantly, the parser can't execute actions until it has decided which alternative to match. That's because actions have side effects and we can't undo things like print statements. For example, in the following rule, the parser can't execute the action in front of the `{java5}?` predicate before committing to that alternative.
+
+```
+@members {boolean allowgoto=false;}
+stat: {System.out.println("goto"); allowgoto=true;} {java5}? 'goto' ID ';'
+ 	| ...
+ 	;
+```
+
+If we can't execute the action during prediction, we shouldn't evaluate the `{java5}?` predicate because it depends on that action.
+
+The prediction process also can't see through token references. Token references have the side effect of advancing the input one symbol. A predicate that tested the current input symbol would find itself out of sync if the parser shifted it over the token reference. For example, in the following grammar, the predicates expect `getCurrentToken` to return an `ID` token.
+
+```
+stat: '{' decl '}'
+ 	| '{' stat '}'
+ 	;
+decl: {istype(getCurrentToken().getText())}? ID ID ';' ;
+expr: {isvar(getCurrentToken().getText())}? ID ;
+```
+
+The decision in stat can't test those predicates because, at the start of stat, the current token is a left curly. To preserve the semantics, ANTLR won't test the predicates in that decision.
+
+Visible predicates are those that prediction encounters before encountering an action or token. The prediction process ignores nonvisible predicates, treating them as if they don't exist.
+
+In rare cases, the parser won't be able to use a predicate, even if it's visible to a particular decision. That brings us to our next fine print topic.
+
+## Using Context-Dependent Predicates
+
+A predicate that depends on a parameter or local variable of the surrounding rule, is considered a context-dependent predicate. Clearly, we can only evaluate such predicates within the rules in which they're defined. For example, it makes no sense for the decision in prog below to test context-dependent predicate `{$i<=5}?`. That `$i` local variable is not even defined in `prog`.
+
+```
+prog: vec5
+ 	| ...
+ 	;
+vec5
+locals [int i=1]
+ 	: ( {$i<=5}? INT {$i++;} )* // match 5 INTs
+ 	;
+```
+
+ANTLR ignores context-dependent predicates that it can't evaluate in the proper context. Normally the proper context is simply the rule defining the predicate, but sometimes the parser can't even evaluate a context-dependent predicate from within the same rule! Detecting these cases is done on-the-fly at runtime during adaptive LL(*) prediction.
+
+For example, prediction for the optional branch of the else subrule in stat below "falls off" the end of stat and continues looking for symbols in the invoking prog rule.
+
+```
+prog: stat+ ; // stat can follow stat
+stat
+locals [int i=0]
+ 	: {$i==0}? 'if' expr 'then' stat {$i=5;} ('else' stat)?
+ 	| 'break' ';'
+ 	;
+```
+
+The prediction process is trying to figure out what can follow an if statement other than an else clause. Since the input can have multiple stats in a row, the prediction for the optional branch of the else subrule reenters stat. This time, of course, it gets a new copy of `$i` with a value of 0, not 5. ANTLR ignores context-dependent predicate `{$i==0}?` because it knows that the parser isn't in the original stat call. The predicate would test a different version of `$i` so the parser can't evaluate it.
+
+The fine print for predicates in the lexer more or less follow these same guidelines, except of course lexer rules can't have parameters and local variables. Let's look at all of the lexer-specific guidelines in the next section.
+
+## Predicates in Lexer Rules
+
+In parser rules, predicates must appear on the left edge of alternatives to aid in alternative prediction. Lexers, on the other hand, prefer predicates on the right edge of lexer rules because they choose rules after seeing a token's entire text. Predicates in lexer rules can technically be anywhere within the rule. Some positions might be more or less efficient than others; ANTLR makes no guarantees about the optimal spot. A predicate in a lexer rule might be executed multiple times even during a single token match. You can embed multiple predicates per lexer rule and they are evaluated as the lexer reaches them during matching.
+
+Loosely speaking, the lexer's goal is to choose the rule that matches the most input characters. At each character, the lexer decides which rules are still viable. Eventually, only a single rule will be still viable. At that point, the lexer creates a token object according the rule's token type and matched text.
+
+Sometimes the lexer is faced with more than a single viable matching rule. For example, input enum would match an `ENUM` rule and an `ID` rule. If the next character after enum is a space, neither rule can continue. The lexer resolves the ambiguity by choosing the viable rule specified first in the grammar. That's why we have to place keyword rules before an identifier rule like this:
+
+```
+ENUM : 'enum' ;
+ID : [a-z]+ ;
+```
+
+If, on the other hand, the next character after input `enum` is a letter, then only `ID` is viable.
+
+Predicates come into play by pruning the set of viable lexer rules. When the lexer encounters a false predicate, it deactivates that rule just like parsers deactivate alternatives with false predicates.
+
+Like parser predicates, lexer predicates can't depend on side effects from lexer actions. That's because actions can only execute after the lexer positively identifies the rule to match. Since predicates are part of the rule selection process, they can't rely on action side effects. Lexer actions must appear after predicates in lexer rules. As an example, here's another way to match enum as a keyword in the lexer:
+
+```
+ENUM: [a-z]+ {getText().equals("enum")}?
+	   {System.out.println("enum!");}
+    ;
+ID  : [a-z]+ {System.out.println("ID "+getText());} ;
+```
+
+The print action in `ENUM` appears last and executes only if the current input matches `[a-z]+` and the predicate is true. Let's build and test `Enum3` to see if it distinguishes between enum and an identifier:
+
+```bash
+$ antlr4 Enum3.g4
+$ javac Enum3.java
+$ grun Enum3 tokens
+=> 	enum abc
+=> 	EOF
+<= 	enum!
+ 	ID abc
+```
+
+That works great, but it's really just for instructional purposes. It's easier to understand and more efficient to match enum keywords with a simple rule like this:
+
+```
+ENUM : 'enum' ;
+```
diff --git a/doc/python-target.md b/doc/python-target.md
new file mode 100644
index 000000000..f081cb099
--- /dev/null
+++ b/doc/python-target.md
@@ -0,0 +1,128 @@
+# Python (2 and 3)
+
+The examples from the ANTLR 4 book converted to Python are [here](https://github.com/jszheng/py3antlr4book).
+
+There are 2 Python targets: `Python2` and `Python3`. This is because there is only limited compatibility between those 2 versions of the language. Please refer to the [Python documentation](https://wiki.python.org/moin/Python2orPython3) for full details.
+
+How to create a Python lexer or parser?
+This is pretty much the same as creating a Java lexer or parser, except you need to specify the language target, for example:
+
+```
+$ antlr4 -Dlanguage=Python2 MyGrammar.g4
+```
+
+or
+
+```
+$ antlr4 -Dlanguage=Python3 MyGrammar.g4
+```
+
+For a full list of antlr4 tool options, please visit the tool documentation page.
+
+## Where can I get the runtime?
+
+Once you've generated the lexer and/or parser code, you need to download the runtime. The Python runtimes are available from PyPI:
+
+* https://pypi.python.org/pypi/antlr4-python2-runtime/
+* https://pypi.python.org/pypi/antlr4-python3-runtime/
+
+The runtimes are provided in the form of source code, so no additional installation is required.
+
+We will not document here how to refer to the runtime from your Python project, since this would differ a lot depending on your project type and IDE. 
+
+## How do I run the generated lexer and/or parser?
+
+Let's suppose that your grammar is named, as above, "MyGrammar". Let's suppose this parser comprises a rule named "StartRule". The tool will have generated for you the following files:
+
+* MyGrammarLexer.py
+* MyGrammarParser.py
+* MyGrammarListener.py (if you have not activated the -no-listener option)
+* MyGrammarVisitor.py (if you have activated the -visitor option)
+
+(Developers used to Java/C# AntLR will notice that there is no base listener or visitor generated, this is because Python having no support for interfaces, the generated listener and visitor are fully fledged classes)
+
+Now a fully functioning script might look like the following:
+ 
+```python
+from antlr4 import *
+from MyGrammarLexer import MyGrammarLexer
+from MyGrammarParser import MyGrammarParser
+ 
+def main(argv):
+    input = FileStream(argv[1])
+    lexer = MyGrammarLexer(input)
+    stream = CommonTokenStream(lexer)
+    parser = MyGrammarParser(stream)
+    tree = parser.StartRule()
+ 
+if __name__ == '__main__':
+    main(sys.argv)
+```
+
+This program will work. But it won't be useful unless you do one of the following:
+
+* you visit the parse tree using a custom listener
+* you visit the parse tree using a custom visitor
+* your grammar comprises production code (like ANTLR3)
+
+(please note that production code is target specific, so you can't have multi target grammars that include production code, except for very limited use cases, see below)
+ 
+## How do I create and run a custom listener?
+
+Let's suppose your MyGrammar grammar comprises 2 rules: "key" and "value". The antlr4 tool will have generated the following listener: 
+
+```python
+class MyGrammarListener(ParseTreeListener):
+    def enterKey(self, ctx):
+        pass
+    def exitKey(self, ctx):
+        pass
+    def enterValue(self, ctx):
+        pass
+    def exitValue(self, ctx):
+        pass
+```
+ 
+In order to provide custom behavior, you might want to create the following class:
+  
+```python
+class KeyPrinter(MyGrammarListener):     
+    def exitKey(self, ctx):         
+        print("Oh, a key!") 
+```
+ 
+In order to execute this listener, you would simply add the following lines to the above code:
+ 
+```
+       ...
+       tree = parser.StartRule() - only repeated here for reference
+   printer = KeyPrinter()
+   walker = ParseTreeWalker()
+   walker.walk(printer, tree)
+```
+ 
+Further information can be found from the ANTLR 4 definitive guide.
+
+The Python implementation of ANTLR is as close as possible to the Java one, so you shouldn't find it difficult to adapt the examples for Python.
+
+## Target agnostic grammars
+
+If your grammar is targeted to Python only, you may ignore the following. But if your goal is to get your Java parser to also run in Python, then you might find it useful.
+
+1. Do not embed production code inside your grammar. This is not portable and will not be. Move all your code to listeners or visitors.
+1. The only production code absolutely required to sit with the grammar should be semantic predicates, like:
+```
+ID {$text.equals("test")}?
+```
+
+Unfortunately, this is not portable, but you can work around it. The trick involves:
+
+* deriving your parser from a parser you provide, such as BaseParser
+* implementing utility methods in this BaseParser, such as "isEqualText"
+* adding a "self" field to the Java/C# BaseParser, and initialize it with "this"
+
+Thanks to the above, you should be able to rewrite the above semantic predicate as follows:
+
+```
+ID {$self.isEqualText($text,"test")}?
+```
diff --git a/doc/releasing-antlr.md b/doc/releasing-antlr.md
new file mode 100644
index 000000000..05815086e
--- /dev/null
+++ b/doc/releasing-antlr.md
@@ -0,0 +1,268 @@
+# Cutting an ANTLR Release
+
+## Github
+
+Create a pre-release or full release at github; [Example 4.5-rc-1](https://github.com/antlr/antlr4/releases/tag/4.5-rc-1).
+
+Wack any existing tag as mvn will create one and it fails if already there.
+
+```
+$ git tag -d 4.5.2
+$ git push origin :refs/tags/4.5.2
+$ git push upstream :refs/tags/4.5.2
+```
+
+## Bump version
+
+Edit the repository looking for 4.5 or whatever and update it. Bump version in the following files:
+
+ * runtime/Java/src/org/antlr/v4/runtime/RuntimeMetaData.java
+ * runtime/Python2/setup.py
+ * runtime/Python2/src/antlr4/Recognizer.py
+ * runtime/Python3/setup.py
+ * runtime/Python3/src/antlr4/Recognizer.py
+ * runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Properties/AssemblyInfo.cs
+ * runtime/JavaScript/src/antlr4/package.json
+ * runtime/JavaScript/src/antlr4/Recognizer.js
+ * tool/src/org/antlr/v4/codegen/target/CSharpTarget.java
+ * tool/src/org/antlr/v4/codegen/target/JavaScriptTarget.java
+ * tool/src/org/antlr/v4/codegen/target/Python2Target.java
+ * tool/src/org/antlr/v4/codegen/target/Python3Target.java
+
+Here is a simple script to display any line from the critical files with, say, `4.5` in it:
+
+```bash
+find /tmp/antlr4 -type f -exec grep -l '4\.5' {} \;
+```
+
+Commit to repository.
+
+## Maven Repository Settings
+
+First, make sure you have maven set up to communicate with staging servers etc...  Create file `~/.m2/settings.xml` with appropriate username/password for staging server and gpg.keyname/passphrase for signing. Make sure it has strict visibility privileges to just you. On unix, it looks like:
+
+```bash
+beast:~/.m2 $ ls -l settings.xml 
+-rw-------  1 parrt  staff  914 Jul 15 14:42 settings.xml
+```
+
+Here is the file template
+
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  User-specific configuration for maven. Includes things that should not
+  be distributed with the pom.xml file, such as developer identity, along with
+  local settings, like proxy information.
+-->
+<settings>
+   <servers>
+        <server>
+          <id>sonatype-nexus-staging</id>
+          <username>sonatype-username</username>
+          <password>XXX</password>
+        </server>
+        <server>
+          <id>sonatype-nexus-snapshots</id>
+          <username>sonatype-username</username>
+          <password>XXX</password>
+        </server>
+   </servers>
+    <profiles>
+            <profile>
+              <activation>
+                    <activeByDefault>false</activeByDefault>
+              </activation>
+              <properties>
+                    <gpg.keyname>UUU</gpg.keyname>
+                    <gpg.passphrase>XXX</gpg.passphrase>
+              </properties>
+            </profile>
+    </profiles>
+</settings>
+```
+
+## Maven release
+
+The maven deploy lifecycle phased deploys the artifacts and the poms for the ANTLR project to the [sonatype remote staging server](https://oss.sonatype.org/content/repositories/snapshots/).
+
+```bash
+mvn deploy -DskipTests
+```
+
+With JDK 1.7 (not 6 or 8), do this:
+
+```bash
+mvn release:prepare -Darguments="-DskipTests"
+```
+
+It will start out by asking you the version number:
+
+```
+...
+What is the release version for "ANTLR 4"? (org.antlr:antlr4-master) 4.5.2: : 4.5.2
+What is the release version for "ANTLR 4 Runtime"? (org.antlr:antlr4-runtime) 4.5.2: : 
+What is the release version for "ANTLR 4 Tool"? (org.antlr:antlr4) 4.5.2: : 
+What is the release version for "ANTLR 4 Maven plugin"? (org.antlr:antlr4-maven-plugin) 4.5.2: : 
+What is the release version for "ANTLR 4 Runtime Test Generator"? (org.antlr:antlr4-runtime-testsuite) 4.5.2: : 
+What is the release version for "ANTLR 4 Tool Tests"? (org.antlr:antlr4-tool-testsuite) 4.5.2: : 
+What is SCM release tag or label for "ANTLR 4"? (org.antlr:antlr4-master) antlr4-master-4.5.2: : 4.5.2
+What is the new development version for "ANTLR 4"? (org.antlr:antlr4-master) 4.5.3-SNAPSHOT:
+...
+```
+
+Maven will go through your pom.xml files to update versions from 4.5.2-SNAPSHOT to 4.5.2 for release and then to 4.5.3-SNAPSHOT after release, which is done with:
+
+```bash
+mvn release:perform -Darguments="-DskipTests"
+```
+
+Maven will use git to push pom.xml changes. (big smile)
+
+Now, go here:
+
+&nbsp;&nbsp;&nbsp;&nbsp;[https://oss.sonatype.org/#welcome](https://oss.sonatype.org/#welcome)
+
+and on the left click "Staging Repositories". You click the staging repo and close it, then you refresh, click it and release it. It's done when you see it here:
+
+&nbsp;&nbsp;&nbsp;&nbsp;[http://repo1.maven.org/maven2/org/antlr/antlr4-runtime/](http://repo1.maven.org/maven2/org/antlr/antlr4-runtime/)
+
+Copy the jars to antlr.org site and update download/index.html
+
+```bash
+cp ~/.m2/repository/org/antlr/antlr4-runtime/4.5.2/antlr4-runtime-4.5.2.jar ~/antlr/sites/website-antlr4/download/antlr-runtime-4.5.2.jar
+cp ~/.m2/repository/org/antlr/antlr4/4.5.2/antlr4-4.5.2.jar ~/antlr/sites/website-antlr4/download/antlr-4.5.2-complete.jar
+cd ~/antlr/sites/website-antlr4/download
+git add antlr-4.5.2-complete.jar
+git add antlr-runtime-4.5.2.jar 
+```
+
+Update on site:
+
+*   download.html
+*   index.html
+*   api/index.html
+*   download/index.html
+*   scripts/topnav.js
+
+```
+git commit -a -m 'add 4.5.2 jars'
+git push origin gh-pages
+```
+
+## Deploying Targets
+
+### JavaScript
+
+```bash
+cd runtime/JavaScript/src
+zip -r /tmp/antlr-javascript-runtime-4.5.2.zip antlr4
+cp /tmp/antlr-javascript-runtime-4.5.2.zip ~/antlr/sites/website-antlr4/download
+# git add, commit, push
+```
+
+Move target to website
+
+```bash
+pushd ~/antlr/sites/website-antlr4/download
+git add antlr-javascript-runtime-4.5.2.zip
+git commit -a -m 'update JS runtime'
+git push origin gh-pages
+popd
+```
+
+### CSharp
+
+```bash
+cd ~/antlr/code/antlr4/runtime/CSharp/runtime/CSharp
+# kill previous ones manually as "xbuild /t:Clean" didn't seem to do it
+rm Antlr4.Runtime/bin/net20/Release/Antlr4.Runtime.dll
+rm Antlr4.Runtime/obj/net20/Release/Antlr4.Runtime.dll
+# build
+xbuild /p:Configuration=Release Antlr4.Runtime/Antlr4.Runtime.mono.csproj
+# zip it up to get a version number on zip filename
+zip --junk-paths /tmp/antlr-csharp-runtime-4.5.2.zip Antlr4.Runtime/bin/net35/Release/Antlr4.Runtime.dll
+cp /tmp/antlr-csharp-runtime-4.5.2.zip ~/antlr/sites/website-antlr4/download
+```
+
+Move target to website
+
+```bash
+pushd ~/antlr/sites/website-antlr4/download
+git add antlr-csharp-runtime-4.5.2.zip
+git commit -a -m 'update C# runtime'
+git push origin gh-pages
+popd
+```
+
+### Python
+
+The Python targets get deployed with `setup.py`. First, set up `~/.pypirc` with tight privileges:
+
+```bash
+beast:~ $ ls -l ~/.pypirc
+-rw-------  1 parrt  staff  267 Jul 15 17:02 /Users/parrt/.pypirc
+```
+
+```
+[distutils] # this tells distutils what package indexes you can push to
+index-servers =
+    pypi
+    pypitest
+
+[pypi]
+repository: https://pypi.python.org/pypi
+username: parrt
+password: XXX
+
+[pypitest]
+repository: https://testpypi.python.org/pypi
+username: parrt
+```
+
+Then run the usual python set up stuff:
+
+```bash
+cd ~/antlr/code/antlr4/runtime/Python2
+# assume you have ~/.pypirc set up
+python setup.py register -r pypi
+python setup.py sdist bdist_wininst upload -r pypi
+```
+
+and do again for Python 3 target
+
+```bash
+cd ~/antlr/code/antlr4/runtime/Python3
+# assume you have ~/.pypirc set up
+python setup.py register -r pypi
+python setup.py sdist bdist_wininst upload -r pypi
+```
+
+Add links to the artifacts from download.html
+
+## Update javadoc for runtime and tool
+
+First gen javadoc:
+
+```bash
+$ cd antlr4
+$ mvn -DskipTests javadoc:jar install
+```
+
+Then copy to website:
+
+```bash
+cd ~/antlr/sites/website-antlr4/api
+git checkout gh-pages
+git pull origin gh-pages
+cd Java
+jar xvf ~/.m2/repository/org/antlr/antlr4-runtime/4.5.2/antlr4-runtime-4.5.2-javadoc.jar
+cd ../JavaTool
+jar xvf ~/.m2/repository/org/antlr/antlr4/4.5.2/antlr4-4.5.2-javadoc.jar
+git commit -a -m 'freshen api doc'
+git push origin gh-pages
+```
+
+## Update Intellij plug-in
+
+Rebuild antlr plugin with new antlr jar.
diff --git a/doc/resources.md b/doc/resources.md
new file mode 100644
index 000000000..8ee31a3c8
--- /dev/null
+++ b/doc/resources.md
@@ -0,0 +1,33 @@
+# Articles and Resources
+
+## Books
+
+<a href=""><img src=images/tpantlr2.png width=120></a>
+<a href=""><img src=images/tpdsl.png width=120></a>
+
+<a href="https://www.youtube.com/watch?v=OAoA3E-cyug"><img src=images/teronbook.png width=250></a>
+
+## Articles
+
+* [Playing with ANTLR4, Primefaces extensions for Code Mirror and web-based DSLs](http://leonotepad.blogspot.com.br/2014/01/playing-with-antlr4-primefaces.html)
+* [A Tale of Two Grammars](https://dexvis.wordpress.com/2012/11/22/a-tale-of-two-grammars/)
+* [ANTLR 4: using the lexer, parser and listener with example grammar](http://www.theendian.com/blog/antlr-4-lexer-parser-and-listener-with-example-grammar/)
+* [Creating External DSLs using ANTLR and Java](http://java.dzone.com/articles/creating-external-dsls-using)
+
+## Presentations
+
+* [Introduction to ANTLR 4 by Oliver Zeigermann](https://docs.google.com/presentation/d/1XS_VIdicCQVonPK6AGYkWTp-3VeHfGuD2l8yNMpAfuQ/edit#slide=id.p)
+
+## Videos
+
+<a href="https://vimeo.com/59285751"><img src=images/tertalk.png width=200></a>
+
+## Resources
+
+* [Stack overflow ANTLR4 tag](http://stackoverflow.com/questions/tagged/antlr4)
+* [Antlr 4 with C# and Visual Studio 2012](http://programming-pages.com/2013/12/14/antlr-4-with-c-and-visual-studio-2012/)
+* [ANTLR Language Support in VisualStudio](http://visualstudiogallery.msdn.microsoft.com/25b991db-befd-441b-b23b-bb5f8d07ee9f)
+* [Upgrading to ANTLR 4 with C#](http://andrevdm.blogspot.com/2013/08/upgrading-to-antlr-4-with-c.html)
+* [Generate parsers with Antlr4 via Maven](http://ljelonek.wordpress.com/2014/01/03/generate-parsers-with-antlr4-via-maven/)
+* [Exploring ANTLR v4](http://johnsquibb.like97.com/blog/read/exploring-antlr-v4)
+* [antlr4dart](http://pub.dartlang.org/packages/antlr4dart)
\ No newline at end of file
diff --git a/doc/resources/worker-base.js b/doc/resources/worker-base.js
new file mode 100644
index 000000000..3494b3916
--- /dev/null
+++ b/doc/resources/worker-base.js
@@ -0,0 +1,1079 @@
+"no use strict";
+(function(e) {
+    if (typeof e.window != "undefined" && e.document) return;
+    e.console = function() {
+        var e = Array.prototype.slice.call(arguments, 0);
+        postMessage({
+            type: "log",
+            data: e
+        })
+    }, e.console.error = e.console.warn = e.console.log = e.console.trace = e.console, e.window = e, e.ace = e, e.onerror = function(e, t, n, r, i) {
+        postMessage({
+            type: "error",
+            data: {
+                message: e,
+                file: t,
+                line: n,
+                col: r,
+                stack: i.stack
+            }
+        })
+    }, e.normalizeModule = function(t, n) {
+        if (n.indexOf("!") !== -1) {
+            var r = n.split("!");
+            return e.normalizeModule(t, r[0]) + "!" + e.normalizeModule(t, r[1])
+        }
+        if (n.charAt(0) == ".") {
+            var i = t.split("/")
+                .slice(0, -1)
+                .join("/");
+            n = (i ? i + "/" : "") + n;
+            while (n.indexOf(".") !== -1 && s != n) {
+                var s = n;
+                n = n.replace(/^\.\//, "")
+                    .replace(/\/\.\//, "/")
+                    .replace(/[^\/]+\/\.\.\//, "")
+            }
+        }
+        return n
+    }, e.require = function(t, n) {
+        n || (n = t, t = null);
+        if (!n.charAt) throw new Error("worker.js require() accepts only (parentId, id) as arguments");
+        n = e.normalizeModule(t, n);
+        var r = e.require.modules[n];
+        if (r) return r.initialized || (r.initialized = !0, r.exports = r.factory()
+            .exports), r.exports;
+        var i = n.split("/");
+        if (!e.require.tlns) return console.log("unable to load " + n);
+        i[0] = e.require.tlns[i[0]] || i[0];
+        var s = i.join("/") + ".js";
+        return e.require.id = n, importScripts(s), e.require(t, n)
+    }, e.require.modules = {}, e.require.tlns = {}, e.define = function(t, n, r) {
+        arguments.length == 2 ? (r = n, typeof t != "string" && (n = t, t = e.require.id)) : arguments.length == 1 && (r = t, n = [], t = e.require.id);
+        if (typeof r != "function") {
+            e.require.modules[t] = {
+                exports: r,
+                initialized: !0
+            };
+            return
+        }
+        n.length || (n = ["require", "exports", "module"]);
+        var i = function(n) {
+            return e.require(t, n)
+        };
+        e.require.modules[t] = {
+            exports: {},
+            factory: function() {
+                var e = this,
+                    t = r.apply(this, n.map(function(t) {
+                        switch (t) {
+                            case "require":
+                                return i;
+                            case "exports":
+                                return e.exports;
+                            case "module":
+                                return e;
+                            default:
+                                return i(t)
+                        }
+                    }));
+                return t && (e.exports = t), e
+            }
+        }
+    }, e.define.amd = {}, e.initBaseUrls = function(t) {
+        require.tlns = t
+    }, e.initSender = function() {
+        var n = e.require("ace/lib/event_emitter")
+                .EventEmitter,
+            r = e.require("ace/lib/oop"),
+            i = function() {};
+        return function() {
+            r.implement(this, n), this.callback = function(e, t) {
+                postMessage({
+                    type: "call",
+                    id: t,
+                    data: e
+                })
+            }, this.emit = function(e, t) {
+                postMessage({
+                    type: "event",
+                    name: e,
+                    data: t
+                })
+            }
+        }.call(i.prototype), new i
+    };
+    var t = e.main = null,
+        n = e.sender = null;
+    e.onmessage = function(r) {
+        var i = r.data;
+        if (i.command) {
+            if (!t[i.command]) throw new Error("Unknown command:" + i.command);
+            t[i.command].apply(t, i.args)
+        } else if (i.init) {
+            initBaseUrls(i.tlns), require("ace/lib/es5-shim"), n = e.sender = initSender();
+            var s = require(i.module)[i.classname];
+            t = e.main = new s(n)
+        } else i.event && n && n._signal(i.event, i.data)
+    }
+})(this), ace.define("ace/lib/oop", ["require", "exports", "module"], function(e, t, n) {
+    "use strict";
+    t.inherits = function(e, t) {
+        e.super_ = t, e.prototype = Object.create(t.prototype, {
+            constructor: {
+                value: e,
+                enumerable: !1,
+                writable: !0,
+                configurable: !0
+            }
+        })
+    }, t.mixin = function(e, t) {
+        for (var n in t) e[n] = t[n];
+        return e
+    }, t.implement = function(e, n) {
+        t.mixin(e, n)
+    }
+}), ace.define("ace/lib/event_emitter", ["require", "exports", "module"], function(e, t, n) {
+    "use strict";
+    var r = {},
+        i = function() {
+            this.propagationStopped = !0
+        },
+        s = function() {
+            this.defaultPrevented = !0
+        };
+    r._emit = r._dispatchEvent = function(e, t) {
+        this._eventRegistry || (this._eventRegistry = {}), this._defaultHandlers || (this._defaultHandlers = {});
+        var n = this._eventRegistry[e] || [],
+            r = this._defaultHandlers[e];
+        if (!n.length && !r) return;
+        if (typeof t != "object" || !t) t = {};
+        t.type || (t.type = e), t.stopPropagation || (t.stopPropagation = i), t.preventDefault || (t.preventDefault = s), n = n.slice();
+        for (var o = 0; o < n.length; o++) {
+            n[o](t, this);
+            if (t.propagationStopped) break
+        }
+        if (r && !t.defaultPrevented) return r(t, this)
+    }, r._signal = function(e, t) {
+        var n = (this._eventRegistry || {})[e];
+        if (!n) return;
+        n = n.slice();
+        for (var r = 0; r < n.length; r++) n[r](t, this)
+    }, r.once = function(e, t) {
+        var n = this;
+        t && this.addEventListener(e, function r() {
+            n.removeEventListener(e, r), t.apply(null, arguments)
+        })
+    }, r.setDefaultHandler = function(e, t) {
+        var n = this._defaultHandlers;
+        n || (n = this._defaultHandlers = {
+            _disabled_: {}
+        });
+        if (n[e]) {
+            var r = n[e],
+                i = n._disabled_[e];
+            i || (n._disabled_[e] = i = []), i.push(r);
+            var s = i.indexOf(t);
+            s != -1 && i.splice(s, 1)
+        }
+        n[e] = t
+    }, r.removeDefaultHandler = function(e, t) {
+        var n = this._defaultHandlers;
+        if (!n) return;
+        var r = n._disabled_[e];
+        if (n[e] == t) {
+            var i = n[e];
+            r && this.setDefaultHandler(e, r.pop())
+        } else if (r) {
+            var s = r.indexOf(t);
+            s != -1 && r.splice(s, 1)
+        }
+    }, r.on = r.addEventListener = function(e, t, n) {
+        this._eventRegistry = this._eventRegistry || {};
+        var r = this._eventRegistry[e];
+        return r || (r = this._eventRegistry[e] = []), r.indexOf(t) == -1 && r[n ? "unshift" : "push"](t), t
+    }, r.off = r.removeListener = r.removeEventListener = function(e, t) {
+        this._eventRegistry = this._eventRegistry || {};
+        var n = this._eventRegistry[e];
+        if (!n) return;
+        var r = n.indexOf(t);
+        r !== -1 && n.splice(r, 1)
+    }, r.removeAllListeners = function(e) {
+        this._eventRegistry && (this._eventRegistry[e] = [])
+    }, t.EventEmitter = r
+}), ace.define("ace/range", ["require", "exports", "module"], function(e, t, n) {
+    "use strict";
+    var r = function(e, t) {
+            return e.row - t.row || e.column - t.column
+        },
+        i = function(e, t, n, r) {
+            this.start = {
+                row: e,
+                column: t
+            }, this.end = {
+                row: n,
+                column: r
+            }
+        };
+    (function() {
+        this.isEqual = function(e) {
+            return this.start.row === e.start.row && this.end.row === e.end.row && this.start.column === e.start.column && this.end.column === e.end.column
+        }, this.toString = function() {
+            return "Range: [" + this.start.row + "/" + this.start.column + "] -> [" + this.end.row + "/" + this.end.column + "]"
+        }, this.contains = function(e, t) {
+            return this.compare(e, t) == 0
+        }, this.compareRange = function(e) {
+            var t, n = e.end,
+                r = e.start;
+            return t = this.compare(n.row, n.column), t == 1 ? (t = this.compare(r.row, r.column), t == 1 ? 2 : t == 0 ? 1 : 0) : t == -1 ? -2 : (t = this.compare(r.row, r.column), t == -1 ? -1 : t == 1 ? 42 : 0)
+        }, this.comparePoint = function(e) {
+            return this.compare(e.row, e.column)
+        }, this.containsRange = function(e) {
+            return this.comparePoint(e.start) == 0 && this.comparePoint(e.end) == 0
+        }, this.intersects = function(e) {
+            var t = this.compareRange(e);
+            return t == -1 || t == 0 || t == 1
+        }, this.isEnd = function(e, t) {
+            return this.end.row == e && this.end.column == t
+        }, this.isStart = function(e, t) {
+            return this.start.row == e && this.start.column == t
+        }, this.setStart = function(e, t) {
+            typeof e == "object" ? (this.start.column = e.column, this.start.row = e.row) : (this.start.row = e, this.start.column = t)
+        }, this.setEnd = function(e, t) {
+            typeof e == "object" ? (this.end.column = e.column, this.end.row = e.row) : (this.end.row = e, this.end.column = t)
+        }, this.inside = function(e, t) {
+            return this.compare(e, t) == 0 ? this.isEnd(e, t) || this.isStart(e, t) ? !1 : !0 : !1
+        }, this.insideStart = function(e, t) {
+            return this.compare(e, t) == 0 ? this.isEnd(e, t) ? !1 : !0 : !1
+        }, this.insideEnd = function(e, t) {
+            return this.compare(e, t) == 0 ? this.isStart(e, t) ? !1 : !0 : !1
+        }, this.compare = function(e, t) {
+            return !this.isMultiLine() && e === this.start.row ? t < this.start.column ? -1 : t > this.end.column ? 1 : 0 : e < this.start.row ? -1 : e > this.end.row ? 1 : this.start.row === e ? t >= this.start.column ? 0 : -1 : this.end.row === e ? t <= this.end.column ? 0 : 1 : 0
+        }, this.compareStart = function(e, t) {
+            return this.start.row == e && this.start.column == t ? -1 : this.compare(e, t)
+        }, this.compareEnd = function(e, t) {
+            return this.end.row == e && this.end.column == t ? 1 : this.compare(e, t)
+        }, this.compareInside = function(e, t) {
+            return this.end.row == e && this.end.column == t ? 1 : this.start.row == e && this.start.column == t ? -1 : this.compare(e, t)
+        }, this.clipRows = function(e, t) {
+            if (this.end.row > t) var n = {
+                row: t + 1,
+                column: 0
+            };
+            else if (this.end.row < e) var n = {
+                row: e,
+                column: 0
+            };
+            if (this.start.row > t) var r = {
+                row: t + 1,
+                column: 0
+            };
+            else if (this.start.row < e) var r = {
+                row: e,
+                column: 0
+            };
+            return i.fromPoints(r || this.start, n || this.end)
+        }, this.extend = function(e, t) {
+            var n = this.compare(e, t);
+            if (n == 0) return this;
+            if (n == -1) var r = {
+                row: e,
+                column: t
+            };
+            else var s = {
+                row: e,
+                column: t
+            };
+            return i.fromPoints(r || this.start, s || this.end)
+        }, this.isEmpty = function() {
+            return this.start.row === this.end.row && this.start.column === this.end.column
+        }, this.isMultiLine = function() {
+            return this.start.row !== this.end.row
+        }, this.clone = function() {
+            return i.fromPoints(this.start, this.end)
+        }, this.collapseRows = function() {
+            return this.end.column == 0 ? new i(this.start.row, 0, Math.max(this.start.row, this.end.row - 1), 0) : new i(this.start.row, 0, this.end.row, 0)
+        }, this.toScreenRange = function(e) {
+            var t = e.documentToScreenPosition(this.start),
+                n = e.documentToScreenPosition(this.end);
+            return new i(t.row, t.column, n.row, n.column)
+        }, this.moveBy = function(e, t) {
+            this.start.row += e, this.start.column += t, this.end.row += e, this.end.column += t
+        }
+    })
+        .call(i.prototype), i.fromPoints = function(e, t) {
+        return new i(e.row, e.column, t.row, t.column)
+    }, i.comparePoints = r, i.comparePoints = function(e, t) {
+        return e.row - t.row || e.column - t.column
+    }, t.Range = i
+}), ace.define("ace/anchor", ["require", "exports", "module", "ace/lib/oop", "ace/lib/event_emitter"], function(e, t, n) {
+    "use strict";
+    var r = e("./lib/oop"),
+        i = e("./lib/event_emitter")
+            .EventEmitter,
+        s = t.Anchor = function(e, t, n) {
+            this.$onChange = this.onChange.bind(this), this.attach(e), typeof n == "undefined" ? this.setPosition(t.row, t.column) : this.setPosition(t, n)
+        };
+    (function() {
+        r.implement(this, i), this.getPosition = function() {
+            return this.$clipPositionToDocument(this.row, this.column)
+        }, this.getDocument = function() {
+            return this.document
+        }, this.$insertRight = !1, this.onChange = function(e) {
+            var t = e.data,
+                n = t.range;
+            if (n.start.row == n.end.row && n.start.row != this.row) return;
+            if (n.start.row > this.row) return;
+            if (n.start.row == this.row && n.start.column > this.column) return;
+            var r = this.row,
+                i = this.column,
+                s = n.start,
+                o = n.end;
+            if (t.action === "insertText")
+                if (s.row === r && s.column <= i) {
+                    if (s.column !== i || !this.$insertRight) s.row === o.row ? i += o.column - s.column : (i -= s.column, r += o.row - s.row)
+                } else s.row !== o.row && s.row < r && (r += o.row - s.row);
+            else t.action === "insertLines" ? (s.row !== r || i !== 0 || !this.$insertRight) && s.row <= r && (r += o.row - s.row) : t.action === "removeText" ? s.row === r && s.column < i ? o.column >= i ? i = s.column : i = Math.max(0, i - (o.column - s.column)) : s.row !== o.row && s.row < r ? (o.row === r && (i = Math.max(0, i - o.column) + s.column), r -= o.row - s.row) : o.row === r && (r -= o.row - s.row, i = Math.max(0, i - o.column) + s.column) : t.action == "removeLines" && s.row <= r && (o.row <= r ? r -= o.row - s.row : (r = s.row, i = 0));
+            this.setPosition(r, i, !0)
+        }, this.setPosition = function(e, t, n) {
+            var r;
+            n ? r = {
+                row: e,
+                column: t
+            } : r = this.$clipPositionToDocument(e, t);
+            if (this.row == r.row && this.column == r.column) return;
+            var i = {
+                row: this.row,
+                column: this.column
+            };
+            this.row = r.row, this.column = r.column, this._signal("change", {
+                old: i,
+                value: r
+            })
+        }, this.detach = function() {
+            this.document.removeEventListener("change", this.$onChange)
+        }, this.attach = function(e) {
+            this.document = e || this.document, this.document.on("change", this.$onChange)
+        }, this.$clipPositionToDocument = function(e, t) {
+            var n = {};
+            return e >= this.document.getLength() ? (n.row = Math.max(0, this.document.getLength() - 1), n.column = this.document.getLine(n.row)
+                .length) : e < 0 ? (n.row = 0, n.column = 0) : (n.row = e, n.column = Math.min(this.document.getLine(n.row)
+                .length, Math.max(0, t))), t < 0 && (n.column = 0), n
+        }
+    })
+        .call(s.prototype)
+}), ace.define("ace/document", ["require", "exports", "module", "ace/lib/oop", "ace/lib/event_emitter", "ace/range", "ace/anchor"], function(e, t, n) {
+    "use strict";
+    var r = e("./lib/oop"),
+        i = e("./lib/event_emitter")
+            .EventEmitter,
+        s = e("./range")
+            .Range,
+        o = e("./anchor")
+            .Anchor,
+        u = function(e) {
+            this.$lines = [], e.length === 0 ? this.$lines = [""] : Array.isArray(e) ? this._insertLines(0, e) : this.insert({
+                row: 0,
+                column: 0
+            }, e)
+        };
+    (function() {
+        r.implement(this, i), this.setValue = function(e) {
+            var t = this.getLength();
+            this.remove(new s(0, 0, t, this.getLine(t - 1)
+                .length)), this.insert({
+                row: 0,
+                column: 0
+            }, e)
+        }, this.getValue = function() {
+            return this.getAllLines()
+                .join(this.getNewLineCharacter())
+        }, this.createAnchor = function(e, t) {
+            return new o(this, e, t)
+        }, "aaa".split(/a/)
+            .length === 0 ? this.$split = function(e) {
+            return e.replace(/\r\n|\r/g, "\n")
+                .split("\n")
+        } : this.$split = function(e) {
+            return e.split(/\r\n|\r|\n/)
+        }, this.$detectNewLine = function(e) {
+            var t = e.match(/^.*?(\r\n|\r|\n)/m);
+            this.$autoNewLine = t ? t[1] : "\n", this._signal("changeNewLineMode")
+        }, this.getNewLineCharacter = function() {
+            switch (this.$newLineMode) {
+                case "windows":
+                    return "\r\n";
+                case "unix":
+                    return "\n";
+                default:
+                    return this.$autoNewLine || "\n"
+            }
+        }, this.$autoNewLine = "", this.$newLineMode = "auto", this.setNewLineMode = function(e) {
+            if (this.$newLineMode === e) return;
+            this.$newLineMode = e, this._signal("changeNewLineMode")
+        }, this.getNewLineMode = function() {
+            return this.$newLineMode
+        }, this.isNewLine = function(e) {
+            return e == "\r\n" || e == "\r" || e == "\n"
+        }, this.getLine = function(e) {
+            return this.$lines[e] || ""
+        }, this.getLines = function(e, t) {
+            return this.$lines.slice(e, t + 1)
+        }, this.getAllLines = function() {
+            return this.getLines(0, this.getLength())
+        }, this.getLength = function() {
+            return this.$lines.length
+        }, this.getTextRange = function(e) {
+            if (e.start.row == e.end.row) return this.getLine(e.start.row)
+                .substring(e.start.column, e.end.column);
+            var t = this.getLines(e.start.row, e.end.row);
+            t[0] = (t[0] || "")
+                .substring(e.start.column);
+            var n = t.length - 1;
+            return e.end.row - e.start.row == n && (t[n] = t[n].substring(0, e.end.column)), t.join(this.getNewLineCharacter())
+        }, this.$clipPosition = function(e) {
+            var t = this.getLength();
+            return e.row >= t ? (e.row = Math.max(0, t - 1), e.column = this.getLine(t - 1)
+                .length) : e.row < 0 && (e.row = 0), e
+        }, this.insert = function(e, t) {
+            if (!t || t.length === 0) return e;
+            e = this.$clipPosition(e), this.getLength() <= 1 && this.$detectNewLine(t);
+            var n = this.$split(t),
+                r = n.splice(0, 1)[0],
+                i = n.length == 0 ? null : n.splice(n.length - 1, 1)[0];
+            return e = this.insertInLine(e, r), i !== null && (e = this.insertNewLine(e), e = this._insertLines(e.row, n), e = this.insertInLine(e, i || "")), e
+        }, this.insertLines = function(e, t) {
+            return e >= this.getLength() ? this.insert({
+                row: e,
+                column: 0
+            }, "\n" + t.join("\n")) : this._insertLines(Math.max(e, 0), t)
+        }, this._insertLines = function(e, t) {
+            if (t.length == 0) return {
+                row: e,
+                column: 0
+            };
+            while (t.length > 2e4) {
+                var n = this._insertLines(e, t.slice(0, 2e4));
+                t = t.slice(2e4), e = n.row
+            }
+            var r = [e, 0];
+            r.push.apply(r, t), this.$lines.splice.apply(this.$lines, r);
+            var i = new s(e, 0, e + t.length, 0),
+                o = {
+                    action: "insertLines",
+                    range: i,
+                    lines: t
+                };
+            return this._signal("change", {
+                data: o
+            }), i.end
+        }, this.insertNewLine = function(e) {
+            e = this.$clipPosition(e);
+            var t = this.$lines[e.row] || "";
+            this.$lines[e.row] = t.substring(0, e.column), this.$lines.splice(e.row + 1, 0, t.substring(e.column, t.length));
+            var n = {
+                    row: e.row + 1,
+                    column: 0
+                },
+                r = {
+                    action: "insertText",
+                    range: s.fromPoints(e, n),
+                    text: this.getNewLineCharacter()
+                };
+            return this._signal("change", {
+                data: r
+            }), n
+        }, this.insertInLine = function(e, t) {
+            if (t.length == 0) return e;
+            var n = this.$lines[e.row] || "";
+            this.$lines[e.row] = n.substring(0, e.column) + t + n.substring(e.column);
+            var r = {
+                    row: e.row,
+                    column: e.column + t.length
+                },
+                i = {
+                    action: "insertText",
+                    range: s.fromPoints(e, r),
+                    text: t
+                };
+            return this._signal("change", {
+                data: i
+            }), r
+        }, this.remove = function(e) {
+            e instanceof s || (e = s.fromPoints(e.start, e.end)), e.start = this.$clipPosition(e.start), e.end = this.$clipPosition(e.end);
+            if (e.isEmpty()) return e.start;
+            var t = e.start.row,
+                n = e.end.row;
+            if (e.isMultiLine()) {
+                var r = e.start.column == 0 ? t : t + 1,
+                    i = n - 1;
+                e.end.column > 0 && this.removeInLine(n, 0, e.end.column), i >= r && this._removeLines(r, i), r != t && (this.removeInLine(t, e.start.column, this.getLine(t)
+                    .length), this.removeNewLine(e.start.row))
+            } else this.removeInLine(t, e.start.column, e.end.column);
+            return e.start
+        }, this.removeInLine = function(e, t, n) {
+            if (t == n) return;
+            var r = new s(e, t, e, n),
+                i = this.getLine(e),
+                o = i.substring(t, n),
+                u = i.substring(0, t) + i.substring(n, i.length);
+            this.$lines.splice(e, 1, u);
+            var a = {
+                action: "removeText",
+                range: r,
+                text: o
+            };
+            return this._signal("change", {
+                data: a
+            }), r.start
+        }, this.removeLines = function(e, t) {
+            return e < 0 || t >= this.getLength() ? this.remove(new s(e, 0, t + 1, 0)) : this._removeLines(e, t)
+        }, this._removeLines = function(e, t) {
+            var n = new s(e, 0, t + 1, 0),
+                r = this.$lines.splice(e, t - e + 1),
+                i = {
+                    action: "removeLines",
+                    range: n,
+                    nl: this.getNewLineCharacter(),
+                    lines: r
+                };
+            return this._signal("change", {
+                data: i
+            }), r
+        }, this.removeNewLine = function(e) {
+            var t = this.getLine(e),
+                n = this.getLine(e + 1),
+                r = new s(e, t.length, e + 1, 0),
+                i = t + n;
+            this.$lines.splice(e, 2, i);
+            var o = {
+                action: "removeText",
+                range: r,
+                text: this.getNewLineCharacter()
+            };
+            this._signal("change", {
+                data: o
+            })
+        }, this.replace = function(e, t) {
+            e instanceof s || (e = s.fromPoints(e.start, e.end));
+            if (t.length == 0 && e.isEmpty()) return e.start;
+            if (t == this.getTextRange(e)) return e.end;
+            this.remove(e);
+            if (t) var n = this.insert(e.start, t);
+            else n = e.start;
+            return n
+        }, this.applyDeltas = function(e) {
+            for (var t = 0; t < e.length; t++) {
+                var n = e[t],
+                    r = s.fromPoints(n.range.start, n.range.end);
+                n.action == "insertLines" ? this.insertLines(r.start.row, n.lines) : n.action == "insertText" ? this.insert(r.start, n.text) : n.action == "removeLines" ? this._removeLines(r.start.row, r.end.row - 1) : n.action == "removeText" && this.remove(r)
+            }
+        }, this.revertDeltas = function(e) {
+            for (var t = e.length - 1; t >= 0; t--) {
+                var n = e[t],
+                    r = s.fromPoints(n.range.start, n.range.end);
+                n.action == "insertLines" ? this._removeLines(r.start.row, r.end.row - 1) : n.action == "insertText" ? this.remove(r) : n.action == "removeLines" ? this._insertLines(r.start.row, n.lines) : n.action == "removeText" && this.insert(r.start, n.text)
+            }
+        }, this.indexToPosition = function(e, t) {
+            var n = this.$lines || this.getAllLines(),
+                r = this.getNewLineCharacter()
+                    .length;
+            for (var i = t || 0, s = n.length; i < s; i++) {
+                e -= n[i].length + r;
+                if (e < 0) return {
+                    row: i,
+                    column: e + n[i].length + r
+                }
+            }
+            return {
+                row: s - 1,
+                column: n[s - 1].length
+            }
+        }, this.positionToIndex = function(e, t) {
+            var n = this.$lines || this.getAllLines(),
+                r = this.getNewLineCharacter()
+                    .length,
+                i = 0,
+                s = Math.min(e.row, n.length);
+            for (var o = t || 0; o < s; ++o) i += n[o].length + r;
+            return i + e.column
+        }
+    })
+        .call(u.prototype), t.Document = u
+}), ace.define("ace/lib/lang", ["require", "exports", "module"], function(e, t, n) {
+    "use strict";
+    t.last = function(e) {
+        return e[e.length - 1]
+    }, t.stringReverse = function(e) {
+        return e.split("")
+            .reverse()
+            .join("")
+    }, t.stringRepeat = function(e, t) {
+        var n = "";
+        while (t > 0) {
+            t & 1 && (n += e);
+            if (t >>= 1) e += e
+        }
+        return n
+    };
+    var r = /^\s\s*/,
+        i = /\s\s*$/;
+    t.stringTrimLeft = function(e) {
+        return e.replace(r, "")
+    }, t.stringTrimRight = function(e) {
+        return e.replace(i, "")
+    }, t.copyObject = function(e) {
+        var t = {};
+        for (var n in e) t[n] = e[n];
+        return t
+    }, t.copyArray = function(e) {
+        var t = [];
+        for (var n = 0, r = e.length; n < r; n++) e[n] && typeof e[n] == "object" ? t[n] = this.copyObject(e[n]) : t[n] = e[n];
+        return t
+    }, t.deepCopy = function s(e) {
+        if (typeof e != "object" || !e) return e;
+        var t;
+        if (Array.isArray(e)) {
+            t = [];
+            for (var n = 0; n < e.length; n++) t[n] = s(e[n]);
+            return t
+        }
+        var r = e.constructor;
+        if (r === RegExp) return e;
+        t = r();
+        for (var n in e) t[n] = s(e[n]);
+        return t
+    }, t.arrayToMap = function(e) {
+        var t = {};
+        for (var n = 0; n < e.length; n++) t[e[n]] = 1;
+        return t
+    }, t.createMap = function(e) {
+        var t = Object.create(null);
+        for (var n in e) t[n] = e[n];
+        return t
+    }, t.arrayRemove = function(e, t) {
+        for (var n = 0; n <= e.length; n++) t === e[n] && e.splice(n, 1)
+    }, t.escapeRegExp = function(e) {
+        return e.replace(/([.*+?^${}()|[\]\/\\])/g, "\\$1")
+    }, t.escapeHTML = function(e) {
+        return e.replace(/&/g, "&#38;")
+            .replace(/"/g, "&#34;")
+            .replace(/'/g, "&#39;")
+            .replace(/</g, "&#60;")
+    }, t.getMatchOffsets = function(e, t) {
+        var n = [];
+        return e.replace(t, function(e) {
+            n.push({
+                offset: arguments[arguments.length - 2],
+                length: e.length
+            })
+        }), n
+    }, t.deferredCall = function(e) {
+        var t = null,
+            n = function() {
+                t = null, e()
+            },
+            r = function(e) {
+                return r.cancel(), t = setTimeout(n, e || 0), r
+            };
+        return r.schedule = r, r.call = function() {
+            return this.cancel(), e(), r
+        }, r.cancel = function() {
+            return clearTimeout(t), t = null, r
+        }, r.isPending = function() {
+            return t
+        }, r
+    }, t.delayedCall = function(e, t) {
+        var n = null,
+            r = function() {
+                n = null, e()
+            },
+            i = function(e) {
+                n == null && (n = setTimeout(r, e || t))
+            };
+        return i.delay = function(e) {
+            n && clearTimeout(n), n = setTimeout(r, e || t)
+        }, i.schedule = i, i.call = function() {
+            this.cancel(), e()
+        }, i.cancel = function() {
+            n && clearTimeout(n), n = null
+        }, i.isPending = function() {
+            return n
+        }, i
+    }
+}), ace.define("ace/worker/mirror", ["require", "exports", "module", "ace/document", "ace/lib/lang"], function(e, t, n) {
+    "use strict";
+    var r = e("../document")
+            .Document,
+        i = e("../lib/lang"),
+        s = t.Mirror = function(e) {
+            this.sender = e;
+            var t = this.doc = new r(""),
+                n = this.deferredUpdate = i.delayedCall(this.onUpdate.bind(this)),
+                s = this;
+            e.on("change", function(e) {
+                t.applyDeltas(e.data);
+                if (s.$timeout) return n.schedule(s.$timeout);
+                s.onUpdate()
+            })
+        };
+    (function() {
+        this.$timeout = 500, this.setTimeout = function(e) {
+            this.$timeout = e
+        }, this.setValue = function(e) {
+            this.doc.setValue(e), this.deferredUpdate.schedule(this.$timeout)
+        }, this.getValue = function(e) {
+            this.sender.callback(this.doc.getValue(), e)
+        }, this.onUpdate = function() {}, this.isPending = function() {
+            return this.deferredUpdate.isPending()
+        }
+    })
+        .call(s.prototype)
+}), ace.define("ace/lib/es5-shim", ["require", "exports", "module"], function(e, t, n) {
+    function r() {}
+
+    function w(e) {
+        try {
+            return Object.defineProperty(e, "sentinel", {}), "sentinel" in e
+        } catch (t) {}
+    }
+
+    function H(e) {
+        return e = +e, e !== e ? e = 0 : e !== 0 && e !== 1 / 0 && e !== -1 / 0 && (e = (e > 0 || -1) * Math.floor(Math.abs(e))), e
+    }
+
+    function B(e) {
+        var t = typeof e;
+        return e === null || t === "undefined" || t === "boolean" || t === "number" || t === "string"
+    }
+
+    function j(e) {
+        var t, n, r;
+        if (B(e)) return e;
+        n = e.valueOf;
+        if (typeof n == "function") {
+            t = n.call(e);
+            if (B(t)) return t
+        }
+        r = e.toString;
+        if (typeof r == "function") {
+            t = r.call(e);
+            if (B(t)) return t
+        }
+        throw new TypeError
+    }
+    Function.prototype.bind || (Function.prototype.bind = function(t) {
+        var n = this;
+        if (typeof n != "function") throw new TypeError("Function.prototype.bind called on incompatible " + n);
+        var i = u.call(arguments, 1),
+            s = function() {
+                if (this instanceof s) {
+                    var e = n.apply(this, i.concat(u.call(arguments)));
+                    return Object(e) === e ? e : this
+                }
+                return n.apply(t, i.concat(u.call(arguments)))
+            };
+        return n.prototype && (r.prototype = n.prototype, s.prototype = new r, r.prototype = null), s
+    });
+    var i = Function.prototype.call,
+        s = Array.prototype,
+        o = Object.prototype,
+        u = s.slice,
+        a = i.bind(o.toString),
+        f = i.bind(o.hasOwnProperty),
+        l, c, h, p, d;
+    if (d = f(o, "__defineGetter__")) l = i.bind(o.__defineGetter__), c = i.bind(o.__defineSetter__), h = i.bind(o.__lookupGetter__), p = i.bind(o.__lookupSetter__);
+    if ([1, 2].splice(0)
+            .length != 2)
+        if (! function() {
+                function e(e) {
+                    var t = new Array(e + 2);
+                    return t[0] = t[1] = 0, t
+                }
+                var t = [],
+                    n;
+                t.splice.apply(t, e(20)), t.splice.apply(t, e(26)), n = t.length, t.splice(5, 0, "XXX"), n + 1 == t.length;
+                if (n + 1 == t.length) return !0
+            }()) Array.prototype.splice = function(e, t) {
+            var n = this.length;
+            e > 0 ? e > n && (e = n) : e == void 0 ? e = 0 : e < 0 && (e = Math.max(n + e, 0)), e + t < n || (t = n - e);
+            var r = this.slice(e, e + t),
+                i = u.call(arguments, 2),
+                s = i.length;
+            if (e === n) s && this.push.apply(this, i);
+            else {
+                var o = Math.min(t, n - e),
+                    a = e + o,
+                    f = a + s - o,
+                    l = n - a,
+                    c = n - o;
+                if (f < a)
+                    for (var h = 0; h < l; ++h) this[f + h] = this[a + h];
+                else if (f > a)
+                    for (h = l; h--;) this[f + h] = this[a + h];
+                if (s && e === c) this.length = c, this.push.apply(this, i);
+                else {
+                    this.length = c + s;
+                    for (h = 0; h < s; ++h) this[e + h] = i[h]
+                }
+            }
+            return r
+        };
+        else {
+            var v = Array.prototype.splice;
+            Array.prototype.splice = function(e, t) {
+                return arguments.length ? v.apply(this, [e === void 0 ? 0 : e, t === void 0 ? this.length - e : t].concat(u.call(arguments, 2))) : []
+            }
+        }
+    Array.isArray || (Array.isArray = function(t) {
+        return a(t) == "[object Array]"
+    });
+    var m = Object("a"),
+        g = m[0] != "a" || !(0 in m);
+    Array.prototype.forEach || (Array.prototype.forEach = function(t) {
+        var n = F(this),
+            r = g && a(this) == "[object String]" ? this.split("") : n,
+            i = arguments[1],
+            s = -1,
+            o = r.length >>> 0;
+        if (a(t) != "[object Function]") throw new TypeError;
+        while (++s < o) s in r && t.call(i, r[s], s, n)
+    }), Array.prototype.map || (Array.prototype.map = function(t) {
+        var n = F(this),
+            r = g && a(this) == "[object String]" ? this.split("") : n,
+            i = r.length >>> 0,
+            s = Array(i),
+            o = arguments[1];
+        if (a(t) != "[object Function]") throw new TypeError(t + " is not a function");
+        for (var u = 0; u < i; u++) u in r && (s[u] = t.call(o, r[u], u, n));
+        return s
+    }), Array.prototype.filter || (Array.prototype.filter = function(t) {
+        var n = F(this),
+            r = g && a(this) == "[object String]" ? this.split("") : n,
+            i = r.length >>> 0,
+            s = [],
+            o, u = arguments[1];
+        if (a(t) != "[object Function]") throw new TypeError(t + " is not a function");
+        for (var f = 0; f < i; f++) f in r && (o = r[f], t.call(u, o, f, n) && s.push(o));
+        return s
+    }), Array.prototype.every || (Array.prototype.every = function(t) {
+        var n = F(this),
+            r = g && a(this) == "[object String]" ? this.split("") : n,
+            i = r.length >>> 0,
+            s = arguments[1];
+        if (a(t) != "[object Function]") throw new TypeError(t + " is not a function");
+        for (var o = 0; o < i; o++)
+            if (o in r && !t.call(s, r[o], o, n)) return !1;
+        return !0
+    }), Array.prototype.some || (Array.prototype.some = function(t) {
+        var n = F(this),
+            r = g && a(this) == "[object String]" ? this.split("") : n,
+            i = r.length >>> 0,
+            s = arguments[1];
+        if (a(t) != "[object Function]") throw new TypeError(t + " is not a function");
+        for (var o = 0; o < i; o++)
+            if (o in r && t.call(s, r[o], o, n)) return !0;
+        return !1
+    }), Array.prototype.reduce || (Array.prototype.reduce = function(t) {
+        var n = F(this),
+            r = g && a(this) == "[object String]" ? this.split("") : n,
+            i = r.length >>> 0;
+        if (a(t) != "[object Function]") throw new TypeError(t + " is not a function");
+        if (!i && arguments.length == 1) throw new TypeError("reduce of empty array with no initial value");
+        var s = 0,
+            o;
+        if (arguments.length >= 2) o = arguments[1];
+        else
+            do {
+                if (s in r) {
+                    o = r[s++];
+                    break
+                }
+                if (++s >= i) throw new TypeError("reduce of empty array with no initial value")
+            } while (!0);
+        for (; s < i; s++) s in r && (o = t.call(void 0, o, r[s], s, n));
+        return o
+    }), Array.prototype.reduceRight || (Array.prototype.reduceRight = function(t) {
+        var n = F(this),
+            r = g && a(this) == "[object String]" ? this.split("") : n,
+            i = r.length >>> 0;
+        if (a(t) != "[object Function]") throw new TypeError(t + " is not a function");
+        if (!i && arguments.length == 1) throw new TypeError("reduceRight of empty array with no initial value");
+        var s, o = i - 1;
+        if (arguments.length >= 2) s = arguments[1];
+        else
+            do {
+                if (o in r) {
+                    s = r[o--];
+                    break
+                }
+                if (--o < 0) throw new TypeError("reduceRight of empty array with no initial value")
+            } while (!0);
+        do o in this && (s = t.call(void 0, s, r[o], o, n)); while (o--);
+        return s
+    });
+    if (!Array.prototype.indexOf || [0, 1].indexOf(1, 2) != -1) Array.prototype.indexOf = function(t) {
+        var n = g && a(this) == "[object String]" ? this.split("") : F(this),
+            r = n.length >>> 0;
+        if (!r) return -1;
+        var i = 0;
+        arguments.length > 1 && (i = H(arguments[1])), i = i >= 0 ? i : Math.max(0, r + i);
+        for (; i < r; i++)
+            if (i in n && n[i] === t) return i;
+        return -1
+    };
+    if (!Array.prototype.lastIndexOf || [0, 1].lastIndexOf(0, -3) != -1) Array.prototype.lastIndexOf = function(t) {
+        var n = g && a(this) == "[object String]" ? this.split("") : F(this),
+            r = n.length >>> 0;
+        if (!r) return -1;
+        var i = r - 1;
+        arguments.length > 1 && (i = Math.min(i, H(arguments[1]))), i = i >= 0 ? i : r - Math.abs(i);
+        for (; i >= 0; i--)
+            if (i in n && t === n[i]) return i;
+        return -1
+    };
+    Object.getPrototypeOf || (Object.getPrototypeOf = function(t) {
+        return t.__proto__ || (t.constructor ? t.constructor.prototype : o)
+    });
+    if (!Object.getOwnPropertyDescriptor) {
+        var y = "Object.getOwnPropertyDescriptor called on a non-object: ";
+        Object.getOwnPropertyDescriptor = function(t, n) {
+            if (typeof t != "object" && typeof t != "function" || t === null) throw new TypeError(y + t);
+            if (!f(t, n)) return;
+            var r, i, s;
+            r = {
+                enumerable: !0,
+                configurable: !0
+            };
+            if (d) {
+                var u = t.__proto__;
+                t.__proto__ = o;
+                var i = h(t, n),
+                    s = p(t, n);
+                t.__proto__ = u;
+                if (i || s) return i && (r.get = i), s && (r.set = s), r
+            }
+            return r.value = t[n], r
+        }
+    }
+    Object.getOwnPropertyNames || (Object.getOwnPropertyNames = function(t) {
+        return Object.keys(t)
+    });
+    if (!Object.create) {
+        var b;
+        Object.prototype.__proto__ === null ? b = function() {
+            return {
+                __proto__: null
+            }
+        } : b = function() {
+            var e = {};
+            for (var t in e) e[t] = null;
+            return e.constructor = e.hasOwnProperty = e.propertyIsEnumerable = e.isPrototypeOf = e.toLocaleString = e.toString = e.valueOf = e.__proto__ = null, e
+        }, Object.create = function(t, n) {
+            var r;
+            if (t === null) r = b();
+            else {
+                if (typeof t != "object") throw new TypeError("typeof prototype[" + typeof t + "] != 'object'");
+                var i = function() {};
+                i.prototype = t, r = new i, r.__proto__ = t
+            }
+            return n !== void 0 && Object.defineProperties(r, n), r
+        }
+    }
+    if (Object.defineProperty) {
+        var E = w({}),
+            S = typeof document == "undefined" || w(document.createElement("div"));
+        if (!E || !S) var x = Object.defineProperty
+    }
+    if (!Object.defineProperty || x) {
+        var T = "Property description must be an object: ",
+            N = "Object.defineProperty called on non-object: ",
+            C = "getters & setters can not be defined on this javascript engine";
+        Object.defineProperty = function(t, n, r) {
+            if (typeof t != "object" && typeof t != "function" || t === null) throw new TypeError(N + t);
+            if (typeof r != "object" && typeof r != "function" || r === null) throw new TypeError(T + r);
+            if (x) try {
+                return x.call(Object, t, n, r)
+            } catch (i) {}
+            if (f(r, "value"))
+                if (d && (h(t, n) || p(t, n))) {
+                    var s = t.__proto__;
+                    t.__proto__ = o, delete t[n], t[n] = r.value, t.__proto__ = s
+                } else t[n] = r.value;
+            else {
+                if (!d) throw new TypeError(C);
+                f(r, "get") && l(t, n, r.get), f(r, "set") && c(t, n, r.set)
+            }
+            return t
+        }
+    }
+    Object.defineProperties || (Object.defineProperties = function(t, n) {
+        for (var r in n) f(n, r) && Object.defineProperty(t, r, n[r]);
+        return t
+    }), Object.seal || (Object.seal = function(t) {
+        return t
+    }), Object.freeze || (Object.freeze = function(t) {
+        return t
+    });
+    try {
+        Object.freeze(function() {})
+    } catch (k) {
+        Object.freeze = function(t) {
+            return function(n) {
+                return typeof n == "function" ? n : t(n)
+            }
+        }(Object.freeze)
+    }
+    Object.preventExtensions || (Object.preventExtensions = function(t) {
+        return t
+    }), Object.isSealed || (Object.isSealed = function(t) {
+        return !1
+    }), Object.isFrozen || (Object.isFrozen = function(t) {
+        return !1
+    }), Object.isExtensible || (Object.isExtensible = function(t) {
+        if (Object(t) === t) throw new TypeError;
+        var n = "";
+        while (f(t, n)) n += "?";
+        t[n] = !0;
+        var r = f(t, n);
+        return delete t[n], r
+    });
+    if (!Object.keys) {
+        var L = !0,
+            A = ["toString", "toLocaleString", "valueOf", "hasOwnProperty", "isPrototypeOf", "propertyIsEnumerable", "constructor"],
+            O = A.length;
+        for (var M in {
+            toString: null
+        }) L = !1;
+        Object.keys = function I(e) {
+            if (typeof e != "object" && typeof e != "function" || e === null) throw new TypeError("Object.keys called on a non-object");
+            var I = [];
+            for (var t in e) f(e, t) && I.push(t);
+            if (L)
+                for (var n = 0, r = O; n < r; n++) {
+                    var i = A[n];
+                    f(e, i) && I.push(i)
+                }
+            return I
+        }
+    }
+    Date.now || (Date.now = function() {
+        return (new Date)
+            .getTime()
+    });
+    var _ = "	\n\f\r \u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u2028\u2029\ufeff";
+    if (!String.prototype.trim || _.trim()) {
+        _ = "[" + _ + "]";
+        var D = new RegExp("^" + _ + _ + "*"),
+            P = new RegExp(_ + _ + "*$");
+        String.prototype.trim = function() {
+            return String(this)
+                .replace(D, "")
+                .replace(P, "")
+        }
+    }
+    var F = function(e) {
+        if (e == null) throw new TypeError("can't convert " + e + " to object");
+        return Object(e)
+    }
+})
\ No newline at end of file
diff --git a/doc/targets.md b/doc/targets.md
new file mode 100644
index 000000000..170431d93
--- /dev/null
+++ b/doc/targets.md
@@ -0,0 +1,23 @@
+# Runtime Libraries and Code Generation Targets
+
+This page lists the available and upcoming ANTLR runtimes. Please note that you won't find here language specific code generators. This is because there is only one tool, written in Java, which is able to generate lexer and parser code for all targets, through command line options. The tool can be invoked from the command line, or any integration plugin to popular IDEs and build systems: Eclipse, IntelliJ, Visual Studio, Maven. So whatever your environment and target is, you should be able to run the tool and produce the code in the targeted language. As of writing, the available targets are the following:
+
+* [Java](java-target.md)<br>
+The [ANTLR v4 book](http://pragprog.com/book/tpantlr2/the-definitive-antlr-4-reference) has a decent summary of the runtime library.  We have added a useful XPath feature since the book was printed that lets you select bits of parse trees.
+<br>[Runtime API](http://www.antlr.org/api/Java/index.html)
+<br>See [Getting Started with ANTLR v4](getting-started.md)
+
+* [C#](csharp-target.md)
+* [Python](python-target.md) (2 and 3)
+* [JavaScript](javascript-target.md)
+* Swift (not yet available)
+* C++ (not yet available)
+
+## Target feature parity
+
+New features generally appear in the Java target and then migrate to the other targets, but these other targets don't always get updated in the same overall tool release. This section tries to identify features added to Java that have not been added to the other targets.
+
+|Feature|Java|C&sharp;|JavaScript|Python2|Python3|Swift|C++|
+|---|---|---|---|---|---|---|---|
+|Ambiguous tree construction|4.5.1|-|-|-|-|-|-|
+
diff --git a/doc/tool-options.md b/doc/tool-options.md
new file mode 100644
index 000000000..fe5d4a399
--- /dev/null
+++ b/doc/tool-options.md
@@ -0,0 +1,161 @@
+# ANTLR Tool Command Line Options
+
+If you invoke the ANTLR tool without command line arguments, you’ll get a help message:
+
+```bash
+$ antlr4
+ANTLR Parser Generator  Version 4.5
+ -o ___              specify output directory where all output is generated
+ -lib ___            specify location of grammars, tokens files
+ -atn                generate rule augmented transition network diagrams
+ -encoding ___       specify grammar file encoding; e.g., euc-jp
+ -message-format ___ specify output style for messages in antlr, gnu, vs2005
+ -long-messages      show exception details when available for errors and warnings
+ -listener           generate parse tree listener (default)
+ -no-listener        don't generate parse tree listener
+ -visitor            generate parse tree visitor
+ -no-visitor         don't generate parse tree visitor (default)
+ -package ___        specify a package/namespace for the generated code
+ -depend             generate file dependencies
+ -D<option>=value    set/override a grammar-level option
+ -Werror             treat warnings as errors
+ -XdbgST             launch StringTemplate visualizer on generated code
+ -XdbgSTWait         wait for STViz to close before continuing
+ -Xforce-atn         use the ATN simulator for all predictions
+ -Xlog               dump lots of logging info to antlr-timestamp.log
+```
+
+Here are more details on the options:
+
+## `-o outdir`
+
+ANTLR generates output files in the current directory by default. This option specifies the output directory where ANTLR should generate parsers, listeners, visitors, and tokens files.
+ 	
+```bash
+$ antlr4 -o /tmp T.g4
+$ ls /tmp/T*
+/tmp/T.tokens /tmp/TListener.java
+/tmp/TBaseListener.java /tmp/TParser.java
+```
+
+## `-lib libdir`
+
+When looking for tokens files and imported grammars, ANTLR normally looks in the current directory. This option specifies which directory to look in instead. It is only used for resolving grammar references for the import statement and the tokenVocab option. The path to the primary grammar must always be fully specified.
+ 	
+$ cat /tmp/B.g4
+ 	
+parser grammar B;
+ 	
+x : ID ;
+ 	
+$ cat A.g4
+ 	
+grammar A;
+ 	
+import B;
+ 	
+s : x ;
+ 	
+ID : [a-z]+ ;
+ 	
+$ antlr4 -lib /tmp A.g4
+
+## `-atn`
+
+Generate DOT graph files that represent the internal ATN (augmented transition network) data structures that ANTLR uses to represent grammars. The files come out as Grammar.rule .dot. If the grammar is a combined grammar, the lexer rules are named Grammar Lexer.rule .dot.
+ 	
+$ cat A.g4
+ 	
+grammar A;
+ 	
+s : b ;
+ 	
+b : ID ;
+ 	
+ID : [a-z]+ ;
+ 	
+$ antlr4 -atn A.g4
+ 	
+$ ls *.dot
+ 	
+A.b.dot A.s.dot ALexer.ID.dot
+
+## `-encoding encodingname`
+
+By default ANTLR loads grammar files using the UTF-8 encoding, which is a very common character file encoding that degenerates to ASCII for characters that fit in one byte. There are many character file encodings from around the world. If that grammar file is not the default encoding for your locale, you need this option so that ANTLR can properly interpret grammar files. This does not affect the input to the generated parsers, just the encoding of the grammars themselves.
+
+## `-message-format format`
+
+ANTLR generates warning and error messages using templates from directory tool/resources/org/antlr/v4/tool/templates/messages/formats. By default, ANTLR uses the antlr.stg (StringTemplate group) file. You can change this to gnu or vs2005 to have ANTLR generate messages appropriate for Emacs or Visual Studio. To make your own called X, create resource org/antlr/v4/tool/templates/messages/formats/ X and place it in the CLASSPATH.
+
+## `-listener`
+
+This option tells ANTLR to generate a parse tree listener and is the default.
+
+## `-no-listener`
+
+This option tells ANTLR not to generate a parse tree listener.
+
+## `-visitor`
+
+ANTLR does not generate parse tree visitors by default. This option turns that feature on. ANTLR can generate both parse tree listeners and visitors; this option and -listener aren’t mutually exclusive.
+
+## `-no-visitor`
+
+Tell ANTLR not to generate a parse tree visitor; this is the default.
+
+## `-package`
+
+Use this option to specify a package or namespace for ANTLR-generated files. Alternatively, you can add a @header {...} action but that ties the grammar to a specific language. If you use this option and @header, make sure that the header action does not contain a package specification otherwise the generated code will have two of them.
+
+## `-depend`
+
+Instead of generating a parser and/or lexer, generate a list of file dependencies, one per line. The output shows what each grammar depends on and what it generates. This is useful for build tools that need to know ANTLR grammar dependencies. Here’s an example:
+ 	
+```bash
+$ antlr4 -depend T.g	
+T.g: A.tokens
+TParser.java : T.g
+T.tokens : T.g
+TLexer.java : T.g
+TListener.java : T.g
+TBaseListener.java : T.g
+```
+
+If you use -lib libdir with -depend and grammar option tokenVocab=A, then the dependencies include the library path as well: T.g: libdir/A.tokens. The output is also sensitive to the -o outdir option: outdir/TParser.java : T.g.
+
+## `-D<option>=value`
+
+Use this option to override or set a grammar-level option in the specified grammar or grammars. This option is useful for generating parsers in different languages without altering the grammar itself. (I expect to have other targets in the near future.)
+ 	
+```bash
+$ antlr4 -Dlanguage=Java T.g4 # default
+$ antlr4 -Dlanguage=C T.g4
+error(31): ANTLR cannot generate C code as of version 4.0b3
+```
+
+## `-Werror`
+
+As part of a large build, ANTLR warning messages could go unnoticed. Turn on this option to have warnings treated as errors, causing the ANTLR tool to report failure back to the invoking commandline shell.
+There are also some extended options that are useful mainly for debugging ANTLR itself:
+
+## `-Xsave-lexer`
+
+ANTLR generates both a parser and a lexer from a combined grammar. To create the lexer, ANTLR extracts a lexer grammar from the combined grammar. Sometimes it’s useful to see what that looks like if it’s not clear what token rules ANTLR is creating. This does not affect the generated parsers or lexers.
+
+## `-XdbgST`
+
+For those building a code generation target, this option brings up a window showing the generated code and the templates used to generate that code. It invokes the StringTemplate inspector window.
+
+## `-Xforce-atn`
+
+ANTLR normally builds traditional “switch on token type” decisions where possible (one token of lookahead is sufficient to distinguish between all alternatives in a decision). To force even these simple decisions into the adaptive LL(*) mechanism, use this option.
+
+## `-Xlog`
+
+This option creates a log file containing lots of information messages from ANTLR as it processes your grammar. If you would like to see how ANTLR translates your left-recursive rules, turn on this option and look in the resulting log file.
+ 	
+```bash
+$ antlr4 -Xlog T.g4 	
+wrote ./antlr-2012-09-06-17.56.19.log
+```
diff --git a/doc/tree-matching.md b/doc/tree-matching.md
new file mode 100644
index 000000000..f4c6d278c
--- /dev/null
+++ b/doc/tree-matching.md
@@ -0,0 +1,156 @@
+# Parse Tree Matching and XPath
+
+*Since ANTLR 4.2*
+
+ANTLR 4 introduced a visitor and listener mechanism that lets you implement DOM visiting or SAX-analogous event processing of tree nodes. This works great. For example, if all you care about is looking at Java method declarations, grab the `Java.g4` file and then override methodDeclaration in `JavaBaseListener`. From there, a `ParseTreeWalker` can trigger calls to your overridden method as it walks the tree. Easy things are easy.
+
+This mechanism works more or less on a node-level basis. In other words, for every method declaration subtree root, your `methodDeclaration()` would get called. There are many situations where we care more about subtrees not just nodes. We might want to:
+
+* Collect method declarations within a particular context (i.e., nested within another method) or methods with specific structure or specific types (e.g., `void <ID>() { }`). We'll combine `XPath` and tree pattern matching for this.
+* Group translation operations by patterns in the tree rather than spreading operations across listener event methods.
+* Get a list of all assignments anywhere in the tree. It's much easier to say *go find me all "... = ... ;" subtrees* rather than creating a class just to get a listener method for rule assignment and then passing the listener to the parse tree walker.
+
+The other important idea here is that, since we're talking about parse trees not abstract syntax trees, we can use concrete patterns instead of tree syntax. For example, we can say `x = 0;` instead of AST `(= x 0)` where the `;` would probably stripped before it went into the AST.
+
+## Parse tree patterns
+
+To test a subtree to see if it has a particular structure, we use a tree pattern. We also often want to extract descendents from the subtree based upon the structure. A very simple example is checking to see if a subtree matches an assignment statement. The pattern might look like the following in your language:
+
+```
+<ID> = <expr>;
+```
+
+where "tags" in angle brackets represent either token or rule references in the associated grammar. ANTLR converts that string to a parse tree with special nodes that represent any token `ID` and rule `expr` subtree. To create this parse tree, the pattern matching compiler needs to know which rule in the grammar the pattern conforms to. In this case it might be statement. Here is how we could test a tree, `t`, to see if it matches that pattern:
+
+```java
+ParseTree t = ...; // assume t is a statement
+ParseTreePattern p = parser.compileParseTreePattern("<ID> = <expr>;", MyParser.RULE_statement);
+ParseTreeMatch m = p.match(t);
+if ( m.succeeded() ) {...}
+```
+
+We can also test for specific expressions or token values. For example, the following checks to see if `t` is an expression consisting of an identifier added to 0:
+
+```java
+ParseTree t = ...; // assume t is an expression
+ParseTreePattern p = parser.compileParseTreePattern("<ID>+0", MyParser.RULE_expr);
+ParseTreeMatch m = p.match(t);
+```
+
+We can also ask the `ParseTreeMatch` result to pull out the token matched to the `<ID>` tag:
+
+```java
+String id = m.get("ID");
+```
+
+You can change the tag delimiters using a method on the pattern matcher:
+
+```java
+ParseTreePatternMatcher m = new ParseTreePatternMatcher();
+m.setDelimiters("<<", ">>", "$"); // $ is the escape character
+```
+
+This would allow pattern `<<ID>> = <<expr>> ;$<< ick $>>` to be interpreted as elements: `ID`, ` = `, `expr`, and ` ;<< ick >>`.
+
+```java
+String xpath = "//blockStatement/*";
+String treePattern = "int <Identifier> = <expression>;";
+ParseTreePattern p =
+parser.compileParseTreePattern(treePattern,
+JavaParser.RULE_localVariableDeclarationStatement);
+List<ParseTreeMatch> matches = p.findAll(tree, xpath);
+```
+
+### Pattern labels
+
+The tree pattern matcher tracks the nodes in the tree at matches against the tags in a tree pattern. That way we can use the `get()` and `getAll()` methods to retrieve components of the matched subtree. For example, for pattern `<ID>`, `get("ID")` returns the node matched for that `ID`. If more than one node matched the specified token or rule tag, only the first match is returned. If there is no node associated with the label, this returns null.
+
+You can also label the tags with identifiers. If the label is the name of a parser rule or token in the grammar, the resulting list from `getAll()` (or node from `get()`) will contain both the parse trees matching rule or tags explicitly labeled with the label and the complete set of parse trees matching the labeled and unlabeled tags in the pattern for the parser rule or token. For example, if label is `foo`, the result will contain all of the following.
+
+* Parse tree nodes matching tags of the form `<foo:anyRuleName>` and `<foo:AnyTokenName>`.
+* Parse tree nodes matching tags of the form `<anyLabel:foo>`.
+* Parse tree nodes matching tags of the form `<foo>`.
+
+### Creating parse trees with the pattern matcher
+
+You can use the parse tree pattern compiler to create parse trees for partial input fragments. Just use method `ParseTreePattern.getPatternTree()`.
+
+See [TestParseTreeMatch.java](https://github.com/antlr/antlr4/blob/master/tool-testsuite/test/org/antlr/v4/test/tool/TestParseTreeMatcher.java).
+
+## Using XPath to identify parse tree node sets
+
+XPath paths are strings representing nodes or subtrees you would like to select within a parse tree. It's useful to collect subsets of the parse tree to process. For example you might want to know where all assignments are in a method or all variable declarations that are initialized.
+
+A path is a series of node names with the following separators.
+
+| Expression |Description|
+|---------|-----------|
+|nodename|	Nodes with the token or rule name nodename
+|/|	The root node but `/X` is the same as `X` since the tree you pass to xpath is assumed to be the root. Because it looks better, start all of your patterns with `/` (or `//` below).|
+|//|	All nodes in the tree that match the next element in the path. E.g., `//ID` finds all `ID` token nodes in the tree.|
+|!|	Any node except for the next element in the path. E.g., `/classdef/!field` should find all children of `classdef` root node that are not `field` subtrees.|
+
+Examples:
+
+```
+/prog/func, -> all funcs under prog at root
+/prog/*, -> all children of prog at root
+/*/func, -> all func kids of any root node
+prog, -> prog must be root node
+/prog, -> prog must be root node
+/*, -> any root
+*, -> any root
+//ID, -> any ID in tree
+//expr/primary/ID, -> any ID child of a primary under any expr
+//body//ID, -> any ID under a body
+//'return', -> any 'return' literal in tree
+//primary/*, -> all kids of any primary
+//func/*/stat, -> all stat nodes grandkids of any func node
+/prog/func/'def', -> all def literal kids of func kid of prog
+//stat/';', -> all ';' under any stat node
+//expr/primary/!ID, -> anything but ID under primary under any expr node
+//expr/!primary, -> anything but primary under any expr node
+//!*, -> nothing anywhere
+/!*, -> nothing at root
+```
+
+Given a parse tree, the typical mechanism for visiting those nodes is the following loop:
+
+```java
+for (ParseTree t : XPath.findAll(tree, xpath, parser) ) {
+    ... process t ...
+}
+```
+
+E.g., here is a general formula for making a list of the text associated with every node identified by a path specification:
+
+```java
+List<String> nodes = new ArrayList<String>();
+for (ParseTree t : XPath.findAll(tree, xpath, parser) ) {
+    if ( t instanceof RuleContext) {
+        RuleContext r = (RuleContext)t;
+        nodes.add(parser.getRuleNames()[r.getRuleIndex()]);    }      
+    else { 
+        TerminalNode token = (TerminalNode)t;
+        nodes.add(token.getText());
+    }      
+}
+```
+
+## Combining XPath and tree pattern matching
+
+Naturally you can combine the use of XPath to find a set of root nodes and then use tree pattern matching to identify a certain subset of those and extract component nodes.
+
+```java
+// assume we are parsing Java
+ParserRuleContext tree = parser.compilationUnit();
+String xpath = "//blockStatement/*"; // get children of blockStatement
+String treePattern = "int <Identifier> = <expression>;";
+ParseTreePattern p =
+    parser.compileParseTreePattern(treePattern,   
+        ExprParser.RULE_localVariableDeclarationStatement);
+List<ParseTreeMatch> matches = p.findAll(tree, xpath);
+System.out.println(matches);
+```
+
+See [TestXPath.java](https://github.com/antlr/antlr4/blob/master/tool-testsuite/test/org/antlr/v4/test/tool/TestXPath.java).
diff --git a/doc/wildcard.md b/doc/wildcard.md
new file mode 100644
index 000000000..f3d1c3a0b
--- /dev/null
+++ b/doc/wildcard.md
@@ -0,0 +1,228 @@
+# Wildcard Operator and Nongreedy Subrules
+
+EBNF subrules like `(...)?`, `(...)*` and `(...)+` are greedy—They consume as much input as possible, but sometimes that’s not what’s needed. Constructs like `.*` consume until the end of the input in the lexer and sometimes in the parser. We want that loop to be nongreedy so we need to use different syntax: `.*?` borrowed from regular expression notation. We can make any subrule that has a `?`, `*`, or `+` suffix nongreedy by adding another `?` suffix. Such nongreedy subrules are allowed in both the parser and the lexer, but they are used much more frequently in the lexer.
+
+## Nongreedy Lexer Subrules
+
+Here’s the very common C-style comment lexer rule that consumes any characters until it sees the trailing `*/`:
+
+```
+COMMENT : '/*' .*? '*/' -> skip ; // .*? matches anything until the first */
+```
+
+Here’s another example that matches strings that allow \" as an escaped quote character:
+
+```
+grammar Nongreedy;
+s : STRING+ ;
+STRING : '"' ( '\\"' | . )*? '"' ; // match "foo", "\"", "x\"\"y", ...
+WS : [ \r\t\n]+ -> skip ;
+```
+
+```bash
+$ antlr4 Nongreedy.g4
+$ javac Nongreedy*.java
+$ grun Nongreedy s -tokens
+=> 	"quote:\""
+=> 	EOF
+<= 	[@0,0:9='"quote:\""',<1>,1:0]
+ 	[@1,11:10='<EOF>',<-1>,2:0]
+```
+
+Nongreedy subrules should be used sparingly because they complicate the recognition problem and sometimes make it tricky to decipher how the lexer will match text. Here is how the lexer chooses token rules:
+
+<ol>
+<li>The primary goal is to match the lexer rule that recognizes the most input characters.
+
+```
+INT : [0-9]+ ;
+DOT : '.' ; // match period
+FLOAT : [0-9]+ '.' ; // match FLOAT upon '34.' not INT then DOT
+```
+</li>
+<li>
+If more than one lexer rule matches the same input sequence, the priority goes to the rule occurring first in the grammar file.
+
+```
+DOC : '/**' .*? '*/' ; // both rules match /** foo */, resolve to DOC
+CMT : '/*' .*? '*/' ;
+```
+</li>
+<li>
+Nongreedy subrules match the fewest number of characters that still allows the surrounding lexical rule to match.
+
+```
+/** Match anything except \n inside of double angle brackets */
+STRING : '<<' ~'\n'*? '>>' ; // Input '<<foo>>>>' matches STRING then END
+END    : '>>' ;
+```
+</li>
+<li>
+<p>After crossing through a nongreedy subrule within a lexical rule, all decision-making from then on is "first match wins."
+</p>
+<p>
+For example, literal `ab` in rule right-hand side (grammar fragment) `.*? (’a’|’ab’)` is dead code and can never be matched. If the input is ab, the first alternative, ’a’, matches the first character and therefore succeeds. (’a’|’ab’) by itself on the right-hand side of a rule properly matches the second alternative for input ab. This quirk arises from a nongreedy design decision that’s too complicated to go into here.</p>
+<li>
+</ol>
+
+To illustrate the different ways to use loops within lexer rules, consider the following grammar, which has three different action-like tokens (using different delimiters so that they all fit within one example grammar).
+
+```
+ACTION1 : '{' ( STRING | . )*? '}' ; // Allows {"foo}
+ACTION2 : '[' ( STRING | ~'"' )*? ']' ; // Doesn't allow ["foo]; nongreedy *?
+ACTION3 : '<' ( STRING | ~[">] )* '>' ; // Doesn't allow <"foo>; greedy *
+STRING : '"' ( '\\"' | . )*? '"' ;
+```
+
+Rule `ACTION1` allows unterminated strings, such as `"foo`, because input `"foo` matches to the wildcard part of the loop. It doesn’t have to go into rule `STRING` to match a quote. To fix that, rule `ACTION2` uses `~’"’` to match any character but the quote. Expression `~’"’` is still ambiguous with the `’]’` that ends the rule, but the fact that the subrule is nongreedy means that the lexer will exit the loop upon a right square bracket. To avoid a nongreedy subrule, make the alternatives explicit. Expression `~[">]` matches anything but the quote and right angle bracket. Here’s a sample run:
+
+```bash
+$ antlr4 Actions.g4
+$ javac Actions*.java
+$ grun Actions tokens -tokens
+=> 	{"foo}
+=> 	EOF
+<= 	[@0,0:5='{"foo}',<1>,1:0]
+ 	[@1,7:6='<EOF>',<-1>,2:0]
+=> 	$ grun Actions tokens -tokens
+=> 	["foo]
+=> 	EOF
+<= 	line 1:0 token recognition error at: '["foo]
+ 	'
+ 	[@0,7:6='<EOF>',<-1>,2:0]
+=> 	$ grun Actions tokens -tokens
+=> 	<"foo>
+=> 	EOF
+<= 	line 1:0 token recognition error at: '<"foo>
+ 	'
+ 	[@0,7:6='<EOF>',<-1>,2:0]
+```
+
+## Nongreedy Parser Subrules
+
+Nongreedy subrules and wildcard are also useful within parsers to do *fuzzy parsing* where the goal is to extract information from an input file without having to specify the full grammar. In contrast to nongreedy lexer decision-making, parsers always make globally correct decisions. A parser never makes a decision that will ultimately cause valid input to fail later on during the parse. Here is the central idea: Nongreedy parser subrules match the shortest sequence of tokens that preserves a successful parse for a valid input sentence.
+
+For example, here are the key rules that demonstrate how to pull integer constants out of an arbitrary Java file:
+
+```
+grammar FuzzyJava;
+ 
+/** Match anything in between constant rule matches */
+file : .*? (constant .*?)+ ;
+ 
+/** Faster alternate version (Gets an ANTLR tool warning about
+ * a subrule like .* in parser that you can ignore.)
+ */
+altfile : (constant | .)* ; // match a constant or any token, 0-or-more times
+
+/** Match things like "public static final SIZE" followed by anything */
+constant
+    :   'public' 'static' 'final' 'int' Identifier
+        {System.out.println("constant: "+$Identifier.text);}
+    ;
+ 
+Identifier : [a-zA-Z_$] [a-zA-Z_$0-9]* ; // simplified
+```
+
+The grammar contains a greatly simplified set of lexer rules from a real Java lexer; the whole file about 60 lines. The recognizer still needs to handle string and character constants as well as comments so it doesn’t get out of sync, trying to match a constant inside of the string for example. The only unusual lexer rule performs “match any character not matched by another lexer rule” functionality:
+
+```
+OTHER : . -> skip ;
+```
+
+This catchall lexer rule and the `.*?` subrule in the parser are the critical ingredients for fuzzy parsing.
+
+Here’s a sample file that we can run into the fuzzy parser:
+
+```java
+import java.util.*;
+public class C {
+    public static final int A = 1;
+    public static final int B = 1;
+    public void foo() { }
+    public static final int C = 1;
+}
+```
+
+And here’s the build and test sequence:
+
+```bash
+$ antlr4 FuzzyJava.g4
+$ javac FuzzyJava*.java
+$ grun FuzzyJava file C.java
+constant: A
+constant: B
+constant: C
+```
+
+Notice that it totally ignores everything except for the `public static final int` declarations. This all happens with only two parser rules.
+
+Now let's try matching some simple class defs w/o having to build parser rules for the junk inside.  Here want to catch just `A` and `B`:
+
+```
+class A {
+        String name = "parrt";
+}
+
+class B {
+        int x;   
+        int getDubX() {
+                return 2*x;
+        }
+}
+```
+
+This grammar does it.
+
+```
+grammar Island;
+file : clazz* ;
+clazz : 'class' ID '{' ignore '}' ;
+ignore : (method|.)*? ;
+method : type ID '()' block ;
+type : 'int' | 'void' ;
+block : '{' (block | .)*? '}' ;
+ID : [a-zA-Z] [a-zA-Z0-9]* ;
+WS : [ \r\t\n]+ -> skip ;
+ANY : . ;
+```
+
+You get:
+
+<img src=images/nonnested-fuzzy.png width=450>
+
+Now let's try some nested classes
+
+```
+class A {
+        String name = "parrt";
+        class Nested {
+            any filthy shite we want in here { }}}}}}
+        }
+}
+
+class B {
+        int x;   
+        int getDubX() {
+                return 2*x;
+        }
+}
+
+```
+
+```
+grammar Island;
+file : clazz* ;
+clazz : 'class' ID '{' ignore '}' ;
+ignore : (method|clazz|.)*? ; // <- only change is to add clazz alt here
+method : type ID '()' block ;
+type : 'int' | 'void' ;
+block : '{' (block | .)*? '}' ;
+ID : [a-zA-Z] [a-zA-Z0-9]* ;
+WS : [ \r\t\n]+ -> skip ;
+ANY : . ;
+```
+
+You get:
+
+<img src=images/nested-fuzzy.png width=600>
\ No newline at end of file
diff --git a/pom.xml b/pom.xml
index ed26a8501..1755b2610 100644
--- a/pom.xml
+++ b/pom.xml
@@ -1,212 +1,131 @@
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <parent>
+    <groupId>org.sonatype.oss</groupId>
+    <artifactId>oss-parent</artifactId>
+    <version>9</version>
+  </parent>
+  <groupId>org.antlr</groupId>
+  <artifactId>antlr4-master</artifactId>
+  <version>4.5.4-SNAPSHOT</version>
+  <packaging>pom</packaging>
 
-    <parent>
-        <groupId>org.sonatype.oss</groupId>
-        <artifactId>oss-parent</artifactId>
-        <version>7</version>
-    </parent>
-
-    <modelVersion>4.0.0</modelVersion>
-    <groupId>org.antlr</groupId>
-    <artifactId>antlr4-master</artifactId>
-    <version>4.1.1-SNAPSHOT</version>
-    <packaging>pom</packaging>
-
-    <name>ANTLR 4</name>
-    <description>ANTLR 4 Master Build POM</description>
+  <name>ANTLR 4</name>
+  <description>ANTLR 4 Master Build POM</description>
+  <url>http://www.antlr.org</url>
+  <inceptionYear>1992</inceptionYear>
+  <organization>
+    <name>ANTLR</name>
     <url>http://www.antlr.org</url>
-    <inceptionYear>1992</inceptionYear>
-    <organization>
-        <name>ANTLR</name>
-        <url>http://www.antlr.org</url>
-    </organization>
+  </organization>
 
-    <licenses>
-        <license>
-            <name>The BSD License</name>
-            <url>http://www.antlr.org/license.html</url>
-            <distribution>repo</distribution>
-        </license>
-    </licenses>
+  <licenses>
+    <license>
+      <name>The BSD License</name>
+      <url>http://www.antlr.org/license.html</url>
+      <distribution>repo</distribution>
+    </license>
+  </licenses>
 
-    <developers>
+  <developers>
+    <developer>
+      <name>Terence Parr</name>
+      <url>http://antlr.org/wiki/display/~admin/Home</url>
+      <roles>
+        <role>Project lead - ANTLR</role>
+      </roles>
+    </developer>
+    <developer>
+      <name>Sam Harwell</name>
+      <url>http://tunnelvisionlabs.com</url>
+      <roles>
+        <role>Developer</role>
+      </roles>
+    </developer>
+    <developer>
+      <name>Eric Vergnaud</name>
+      <roles>
+        <role>Developer - JavaScript, C#, Python 2, Python 3</role>
+      </roles>
+    </developer>
+    <developer>
+      <name>Jim Idle</name>
+      <email>jimi@idle.ws</email>
+      <url>http://www.linkedin.com/in/jimidle</url>
+      <roles>
+        <role>Developer - Maven Plugin</role>
+      </roles>
+    </developer>
+    <developer>
+      <name>Mike Lischke</name>
+      <roles>
+        <role>Developer - C++ Target</role>
+      </roles>
+    </developer>
+  </developers>
 
-        <developer>
-            <name>Terence Parr</name>
-            <url>http://antlr.org/wiki/display/~admin/Home</url>
-            <roles>
-                <role>Project lead - ANTLR</role>
-            </roles>
-        </developer>
+  <modules>
+    <module>runtime/Java</module>
+    <module>tool</module>
+    <module>antlr4-maven-plugin</module>
+    <module>tool-testsuite</module>
+    <module>runtime-testsuite</module>
+  </modules>
 
-        <developer>
-            <name>Sam Harwell</name>
-            <url>http://tunnelvisionlabs.com</url>
-            <roles>
-                <role>Developer</role>
-            </roles>
-        </developer>
+  <properties>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
+    <antlr.testinprocess>true</antlr.testinprocess>
+    <maven.compiler.source>1.6</maven.compiler.source>
+    <maven.compiler.target>1.6</maven.compiler.target>
+  </properties>
 
-        <developer>
-            <name>Jim Idle</name>
-            <email>jimi@idle.ws</email>
-            <url>http://www.linkedin.com/in/jimidle</url>
-            <roles>
-                <role>Developer - Maven Plugin</role>
-            </roles>
-        </developer>
+  <mailingLists>
+    <mailingList>
+      <name>antlr-discussion</name>
+      <archive>https://groups.google.com/forum/?fromgroups#!forum/antlr-discussion</archive>
+    </mailingList>
+  </mailingLists>
 
-    </developers>
+  <issueManagement>
+    <system>GitHub Issues</system>
+    <url>https://github.com/antlr/antlr4/issues</url>
+  </issueManagement>
 
-    <modules>
-        <module>runtime/Java</module>
-        <module>tool</module>
-        <module>antlr4-maven-plugin</module>
-    </modules>
+  <scm>
+    <url>https://github.com/antlr/antlr4/tree/master</url>
+    <connection>scm:git:git://github.com/antlr/antlr4.git</connection>
+    <developerConnection>scm:git:git@github.com:antlr/antlr4.git</developerConnection>
+    <tag>HEAD</tag>
+  </scm>
 
-    <properties>
-        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
-        <java5.home>${env.JAVA5_HOME}</java5.home>
-        <java6.home>${env.JAVA6_HOME}</java6.home>
-        <bootclasspath.java5>${java5.home}/lib/rt.jar</bootclasspath.java5>
-        <bootclasspath.java6>${java6.home}/lib/rt.jar</bootclasspath.java6>
-        <bootclasspath.compile>${bootclasspath.java6}</bootclasspath.compile>
-        <bootclasspath.testCompile>${bootclasspath.java6}</bootclasspath.testCompile>
-        <antlr.testinprocess>true</antlr.testinprocess>
-    </properties>
-
-    <mailingLists>
-        <mailingList>
-            <name>antlr-discussion</name>
-            <archive>https://groups.google.com/forum/?fromgroups#!forum/antlr-discussion</archive>
-        </mailingList>
-    </mailingLists>
-
-    <issueManagement>
-        <system>GitHub Issues</system>
-        <url>https://github.com/antlr/antlr4/issues</url>
-    </issueManagement>
-
-    <scm>
-        <url>https://github.com/antlr/antlr4/tree/master</url>
-        <connection>scm:git:git://github.com/antlr/antlr4.git</connection>
-        <developerConnection>scm:git:git@github.com:antlr/antlr4.git</developerConnection>
-    </scm>
-
-    <profiles>
-        <profile>
-            <id>sonatype-oss-release</id>
-            <build>
-                <plugins>
-                    <plugin>
-                        <groupId>org.apache.maven.plugins</groupId>
-                        <artifactId>maven-compiler-plugin</artifactId>
-                        <executions>
-                            <execution>
-                                <id>default-compile</id>
-                                <configuration>
-                                    <compilerArguments>
-                                        <bootclasspath>${bootclasspath.compile}</bootclasspath>
-                                    </compilerArguments>
-                                </configuration>
-                            </execution>
-                            <execution>
-                                <id>default-testCompile</id>
-                                <configuration>
-                                    <compilerArguments>
-                                        <bootclasspath>${bootclasspath.testCompile}</bootclasspath>
-                                    </compilerArguments>
-                                </configuration>
-                            </execution>
-                        </executions>
-                    </plugin>
-                </plugins>
-            </build>
-        </profile>
-    </profiles>
-
-    <build>
-        <plugins>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-compiler-plugin</artifactId>
-                <version>3.1</version>
-                <configuration>
-                    <sourceDirectory>src</sourceDirectory>
-                    <showWarnings>true</showWarnings>
-                    <showDeprecation>true</showDeprecation>
-                </configuration>
-
-                <executions>
-                    <execution>
-                        <id>default-compile</id>
-                        <configuration>
-                            <source>1.6</source>
-                            <target>1.6</target>
-                            <compilerArgument>-Xlint:-serial</compilerArgument>
-                            <compilerArguments>
-                                <Xlint/>
-                            </compilerArguments>
-                        </configuration>
-                    </execution>
-                    <execution>
-                        <id>default-testCompile</id>
-                        <configuration>
-                            <source>1.6</source>
-                            <target>1.6</target>
-                            <compilerArgument>-Xlint:-serial</compilerArgument>
-                            <compilerArguments>
-                                <Xlint/>
-                            </compilerArguments>
-                        </configuration>
-                    </execution>
-                </executions>
-            </plugin>
-
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-jar-plugin</artifactId>
-                <version>2.4</version>
-                <configuration>
-                    <archive>
-                        <manifest>
-                            <addDefaultImplementationEntries>true</addDefaultImplementationEntries>
-                        </manifest>
-                    </archive>
-                </configuration>
-            </plugin>
-
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-surefire-plugin</artifactId>
-                <version>2.15</version>
-            </plugin>
-
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-source-plugin</artifactId>
-                <!-- override the version inherited from the parent -->
-                <version>2.2.1</version>
-            </plugin>
-
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-javadoc-plugin</artifactId>
-                <!-- override the version inherited from the parent -->
-                <version>2.9</version>
-                <configuration>
-                    <quiet>true</quiet>
-                </configuration>
-            </plugin>
-
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-gpg-plugin</artifactId>
-                <!-- override the version inherited from the parent -->
-                <version>1.4</version>
-            </plugin>
-        </plugins>
-    </build>
+  <build>
+    <resources>
+      <resource>
+        <directory>resources</directory>
+      </resource>
+    </resources>
+    <testSourceDirectory>test</testSourceDirectory>
+    <testResources>
+      <testResource>
+        <directory>test</directory>
+      </testResource>
+    </testResources>
+    <pluginManagement>
+      <plugins>
+        <plugin>
+          <groupId>org.apache.maven.plugins</groupId>
+          <artifactId>maven-compiler-plugin</artifactId>
+          <configuration>
+            <source>${maven.compiler.source}</source>
+            <target>${maven.compiler.target}</target>
+          </configuration>
+        </plugin>
+        <plugin>
+          <groupId>org.apache.maven.plugins</groupId>
+          <artifactId>maven-javadoc-plugin</artifactId>
+        </plugin>
+      </plugins>
+    </pluginManagement>
+  </build>
 </project>
diff --git a/runtime-testsuite/README.md b/runtime-testsuite/README.md
new file mode 100644
index 000000000..7073e0062
--- /dev/null
+++ b/runtime-testsuite/README.md
@@ -0,0 +1,9 @@
+# Runtime Test Suite
+
+If you are tweaking the runtime test suite generator you can regenerate them using the following command:
+
+```
+mvn -Pgen generate-test-sources
+```
+
+This will generate the runtime test harness classes into the `test` directory where they can be checked in.
diff --git a/runtime-testsuite/pom.xml b/runtime-testsuite/pom.xml
new file mode 100644
index 000000000..e09140dea
--- /dev/null
+++ b/runtime-testsuite/pom.xml
@@ -0,0 +1,145 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+
+  <modelVersion>4.0.0</modelVersion>
+  <parent>
+    <groupId>org.antlr</groupId>
+    <artifactId>antlr4-master</artifactId>
+    <version>4.5.4-SNAPSHOT</version>
+  </parent>
+  <artifactId>antlr4-runtime-testsuite</artifactId>
+  <name>ANTLR 4 Runtime Test Generator</name>
+  <description>A collection of tests for ANTLR 4 Runtime libraries.</description>
+
+  <prerequisites>
+    <maven>3.0</maven>
+  </prerequisites>
+
+  <inceptionYear>2009</inceptionYear>
+
+  <dependencies>
+    <dependency>
+      <groupId>org.antlr</groupId>
+      <artifactId>ST4</artifactId>
+      <version>4.0.8</version>
+    </dependency>
+    <dependency>
+      <groupId>org.antlr</groupId>
+      <artifactId>antlr4</artifactId>
+      <version>${project.version}</version>
+    </dependency>
+    <dependency>
+      <groupId>org.antlr</groupId>
+      <artifactId>antlr4-runtime</artifactId>
+      <version>${project.version}</version>
+    </dependency>
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <version>4.11</version>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.seleniumhq.selenium</groupId>
+      <artifactId>selenium-java</artifactId>
+      <version>2.46.0</version>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.eclipse.jetty</groupId>
+      <artifactId>jetty-server</artifactId>
+      <version>8.1.16.v20140903</version>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
+
+  <build>
+    <sourceDirectory>src</sourceDirectory>
+    <testSourceDirectory>test</testSourceDirectory>
+    <resources>
+      <resource>
+        <directory>resources</directory>
+      </resource>
+      <resource>
+        <directory>../runtime</directory>
+      </resource>
+    </resources>
+    <plugins> 
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-surefire-plugin</artifactId>
+        <version>2.12.4</version>
+        <configuration>
+          <includes>
+            <include>**/csharp/Test*.java</include>
+            <include>**/java/Test*.java</include>
+            <include>**/javascript/node/Test*.java</include>
+            <include>**/python2/Test*.java</include> 
+            <include>**/python3/Test*.java</include>
+          </includes>
+        </configuration>
+      </plugin>    
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-jar-plugin</artifactId>
+        <version>2.4</version>
+        <executions>
+          <execution>
+            <goals>
+              <goal>test-jar</goal>
+            </goals>
+          </execution>
+        </executions>
+      </plugin>      
+    </plugins>
+  </build>
+  
+  <profiles>
+    <profile>
+      <id>gen</id>
+      <build>
+        <plugins>
+          <plugin>
+            <groupId>org.codehaus.mojo</groupId>
+            <artifactId>exec-maven-plugin</artifactId>
+            <version>1.4.0</version>
+            <executions>
+              <execution>
+                <phase>generate-test-sources</phase>
+                <goals>
+                  <goal>java</goal>
+                </goals>
+                <configuration>
+                  <mainClass>org.antlr.v4.testgen.TestGenerator</mainClass>
+                  <arguments>
+                    <argument>-root</argument>
+                    <argument>${basedir}</argument>
+                    <argument>-outdir</argument>
+                    <argument>${basedir}/test</argument>
+                    <argument>-templates</argument>
+                    <argument>${basedir}/resources/org/antlr/v4/test/runtime/templates</argument>
+                  </arguments>
+                </configuration>
+              </execution>
+            </executions>
+          </plugin>        
+        </plugins>
+      </build>
+    </profile>
+    <profile>
+      <id>tests</id>
+      <build>
+        <plugins>
+          <plugin>
+            <groupId>org.apache.maven.plugins</groupId>
+            <artifactId>maven-surefire-plugin</artifactId>
+            <configuration>
+              <includes>
+                <include>**/Test*.java</include>
+              </includes>
+            </configuration>
+          </plugin>            
+        </plugins>
+      </build>
+    </profile>      
+  </profiles>  
+</project>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/csharp/Antlr4.Test.mono.csproj b/runtime-testsuite/resources/org/antlr/v4/test/runtime/csharp/Antlr4.Test.mono.csproj
new file mode 100644
index 000000000..eb4870943
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/csharp/Antlr4.Test.mono.csproj
@@ -0,0 +1,51 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003" DefaultTargets="Build" ToolsVersion="4.0">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{EDC70A11-C4C1-4209-93A6-CCE2B19E8E95}</ProjectGuid>
+    <OutputType>Exe</OutputType>
+    <RootNamespace>Antlr4.Test.mono</RootNamespace>
+    <AssemblyName>Test</AssemblyName>
+    <StartupObject>Test</StartupObject>
+    <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug</OutputPath>
+    <DefineConstants>DEBUG;</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <Externalconsole>true</Externalconsole>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release</OutputPath>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <Externalconsole>true</Externalconsole>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="Antlr4.Runtime.mono.csproj">
+      <Project>{E1A46D9D-66CB-46E8-93B0-7FC87299ABEF}</Project>
+      <Name>Antlr4.Runtime.mono</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="AssemblyInfo.cs" />
+    <Compile Include="Test.cs" />
+    <Compile Include="L.cs" />
+  </ItemGroup>
+  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
+  <ItemGroup>
+    <None Include="App.config">
+      <LogicalName>Test.exe.config</LogicalName>
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
+  </ItemGroup>
+</Project>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/csharp/Antlr4.Test.vs2013.csproj b/runtime-testsuite/resources/org/antlr/v4/test/runtime/csharp/Antlr4.Test.vs2013.csproj
new file mode 100644
index 000000000..bab5315d5
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/csharp/Antlr4.Test.vs2013.csproj
@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="UTF-8"?><Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003" DefaultTargets="Build" ToolsVersion="4.0">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{EDC70A11-C4C1-4209-93A6-CCE2B19E8E95}</ProjectGuid>
+    <OutputType>Exe</OutputType>
+    <RootNamespace>Antlr4.Test.mono</RootNamespace>
+    <AssemblyName>Test</AssemblyName>
+    <StartupObject>Test</StartupObject>
+    <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug</OutputPath>
+    <DefineConstants>DEBUG;</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <Externalconsole>true</Externalconsole>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release</OutputPath>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <Externalconsole>true</Externalconsole>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System"/>
+  </ItemGroup>
+  <ItemGroup>
+<Compile Include="AssemblyInfo.cs"/>
+<Compile Include="Test.cs"/>
+<Compile Include="L.cs"/>
+</ItemGroup>
+  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets"/>
+  <ItemGroup>
+    <ProjectReference Include="Antlr4.Runtime.vs2013.csproj">
+      <Project>{E1A46D9D-66CB-46E8-93B0-7FC87299ABEF}</Project>
+      <Name>Antlr4.Runtime.vs2013</Name>
+    </ProjectReference>
+  </ItemGroup>
+</Project>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/csharp/App.config b/runtime-testsuite/resources/org/antlr/v4/test/runtime/csharp/App.config
new file mode 100644
index 000000000..43157903b
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/csharp/App.config
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<configuration>
+   <startup>
+      <supportedRuntime version="v2.0.50727"/>
+      <supportedRuntime version="v4.0"/>
+   </startup>
+</configuration>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/csharp/AssemblyInfo.cs b/runtime-testsuite/resources/org/antlr/v4/test/runtime/csharp/AssemblyInfo.cs
new file mode 100644
index 000000000..f67408625
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/csharp/AssemblyInfo.cs
@@ -0,0 +1,28 @@
+using System;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+
+// Information about this assembly is defined by the following attributes.
+// Change them to the values specific to your project.
+
+[assembly: AssemblyTitle ("Antlr4.Test.mono")]
+[assembly: AssemblyDescription ("")]
+[assembly: AssemblyConfiguration ("")]
+[assembly: AssemblyCompany ("")]
+[assembly: AssemblyProduct ("")]
+[assembly: AssemblyCopyright ("ericvergnaud")]
+[assembly: AssemblyTrademark ("")]
+[assembly: AssemblyCulture ("")]
+[assembly: CLSCompliant (true)]
+// The assembly version has the format "{Major}.{Minor}.{Build}.{Revision}".
+// The form "{Major}.{Minor}.*" will automatically update the build and revision,
+// and "{Major}.{Minor}.{Build}.*" will update just the revision.
+
+[assembly: AssemblyVersion ("1.0.*")]
+
+// The following attributes are used to specify the signing key for the assembly,
+// if desired. See the Mono documentation for more information about signing.
+
+//[assembly: AssemblyDelaySign(false)]
+//[assembly: AssemblyKeyFile("")]
+
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/csharp/CSharp.test.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/csharp/CSharp.test.stg
new file mode 100644
index 000000000..ca6182b47
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/csharp/CSharp.test.stg
@@ -0,0 +1,423 @@
+IgnoredTests ::= [
+	default: false
+]
+
+TestFile(file) ::= <<
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.csharp;
+
+import org.junit.Test;
+import org.junit.Ignore;
+
+<if(file.Options.("ImportErrorQueue"))>
+import org.antlr.v4.test.runtime.java.ErrorQueue;
+<endif>
+<if(file.Options.("ImportGrammar"))>
+import org.antlr.v4.tool.Grammar;
+<endif>
+
+@SuppressWarnings("unused")
+public class Test<file.name> extends BaseTest {
+
+	<file.tests:{test | <test>}; separator="\n", wrap, anchor>
+
+}<\n>
+>>
+
+LexerTestMethod(test) ::= <<
+/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+<testAnnotations(test)>
+public void test<test.name>() throws Exception {
+	mkdir(tmpdir);
+<test.SlaveGrammars:{grammar |
+	String slave_<grammar> =<writeStringLiteral(test.SlaveGrammars.(grammar))>;
+	writeFile(tmpdir, "<grammar>.g4", slave_<grammar>);
+	}; separator="\n">
+
+<test.Grammar:{grammar |
+	<buildStringLiteral(test.Grammar.(grammar), "grammar")>
+	<test.afterGrammar>
+	String input =<writeStringLiteral(test.Input)>;
+	String found = execLexer("<grammar>.g4", grammar, "<grammar><if(test.Options.("CombinedGrammar"))>Lexer<endif>", input, <writeBoolean(test.Options.("ShowDFA"))>);
+	assertEquals(<writeStringLiteral(test.Output)>, found);
+	<if(!isEmpty.(test.Errors))>
+	assertEquals(<writeStringLiteral(test.Errors)>, this.stderrDuringParse);
+	<else>
+	assertNull(this.stderrDuringParse);
+	<endif>
+    }>
+}
+>>
+
+CompositeLexerTestMethod(test) ::= <<
+<LexerTestMethod(test)>
+>>
+
+ParserTestMethod(test) ::= <<
+/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+<testAnnotations(test)>
+public void test<test.name>() throws Exception {
+	mkdir(tmpdir);
+<test.SlaveGrammars:{grammar |
+	String slave_<grammar> =<writeStringLiteral(test.SlaveGrammars.(grammar))>;
+<if(test.Options.("SlaveIsLexer"))>
+	rawGenerateAndBuildRecognizer("<grammar>.g4", slave_<grammar>, null, "<grammar>");
+<else>
+	writeFile(tmpdir, "<grammar>.g4", slave_<grammar>);
+<endif>
+	}; separator="\n">
+<test.Grammar:{grammar |
+	<buildStringLiteral(test.Grammar.(grammar), "grammar")>
+	<test.afterGrammar>
+	String input =<writeStringLiteral(test.Input)>;
+	String found = execParser("<grammar>.g4", grammar, "<grammar>Parser", "<grammar>Lexer", "<test.Rule>", input, <writeBoolean(test.Options.("Debug"))>);
+	assertEquals(<writeStringLiteral(test.Output)>, found);
+	<if(!isEmpty.(test.Errors))>
+	assertEquals(<writeStringLiteral(test.Errors)>, this.stderrDuringParse);
+	<else>
+	assertNull(this.stderrDuringParse);
+	<endif>
+    }>
+}
+>>
+
+CompositeParserTestMethod(test) ::= <<
+<ParserTestMethod(test)>
+>>
+
+AbstractParserTestMethod(test) ::= <<
+/* this file and method are generated, any edit will be overwritten by the next generation */
+String test<test.name>(String input) throws Exception {
+	String grammar = <test.grammar.lines:{ line | "<line>};separator="\\n\" +\n", wrap, anchor>";
+	return execParser("<test.grammar.grammarName>.g4", grammar, "<test.grammar.grammarName>Parser", "<test.grammar.grammarName>Lexer", "<test.startRule>", input, <test.debug>);
+}
+
+>>
+
+ConcreteParserTestMethod(test) ::= <<
+/* this file and method are generated, any edit will be overwritten by the next generation */
+@Test
+public void test<test.name>() throws Exception {
+	String found = test<test.baseName>("<test.input>");
+	assertEquals("<test.expectedOutput>", found);
+	<if(test.expectedErrors)>
+	assertEquals("<test.expectedErrors>", this.stderrDuringParse);
+	<else>
+	assertNull(this.stderrDuringParse);
+	<endif>
+}
+
+>>
+
+testAnnotations(test) ::= <%
+@Test
+<if(test.Options.("Ignore"))>
+<\n>@Ignore(<writeStringLiteral(test.Options.("Ignore"))>)
+<elseif(IgnoredTests.(({<file.name>.<test.name>})))>
+<\n>@Ignore(<writeStringLiteral(IgnoredTests.(({<file.name>.<test.name>})))>)
+<endif>
+%>
+
+buildStringLiteral(text, variable) ::= <<
+StringBuilder <variable>Builder = new StringBuilder(<strlen.(text)>);
+<lines.(text):{line|<variable>Builder.append("<escape.(line)>");}; separator="\n">
+String <variable> = <variable>Builder.toString();
+>>
+
+writeStringLiteral(text) ::= <%
+<if(isEmpty.(text))>
+""
+<else>
+<writeLines(lines.(text))>
+<endif>
+%>
+
+writeLines(textLines) ::= <%
+<if(rest(textLines))>
+<textLines:{line|
+<\n>		"<escape.(line)>}; separator="\" +">"
+<else>
+"<escape.(first(textLines))>"
+<endif>
+%>
+
+string(text) ::= <<
+"<escape.(text)>"
+>>
+
+writeBoolean(o) ::= "<if(o && !isEmpty.(o))>true<else>false<endif>"
+
+writeln(s) ::= <<Console.WriteLine(<s>);>>
+
+write(s) ::= <<Console.Write(<s>);>>
+
+False() ::= "false"
+
+True() ::= "true"
+
+Not(v) ::= "!<v>"
+
+Assert(s) ::= <<Debug.Assert(<s>);>>
+
+Cast(t,v) ::= "((<t>)<v>)"
+
+Append(a,b) ::= "<a> + <b>"
+
+Concat(a,b) ::= "<a><b>"
+
+DeclareLocal(s,v) ::= "Object <s> = <v>;"
+
+AssertIsList(v) ::= "System.Collections.IList __ttt__ = <v>;" // just use static type system
+
+AssignLocal(s,v) ::= "<s> = <v>;"
+
+InitIntMember(n,v) ::= <%int <n> = <v>;%>
+
+InitBooleanMember(n,v) ::= <%bool <n> = <v>;%>
+
+GetMember(n) ::= <%this.<n>%>
+
+SetMember(n,v) ::= <%this.<n> = <v>;%>
+
+AddMember(n,v) ::= <%this.<n> += <v>;%>
+
+PlusMember(v,n) ::= <%<v> + this.<n>%>
+
+MemberEquals(n,v) ::= <%this.<n> == <v>%>
+
+ModMemberEquals(n,m,v) ::= <%this.<n> % <m> == <v>%>
+
+ModMemberNotEquals(n,m,v) ::= <%this.<n> % <m> != <v>%>
+
+DumpDFA() ::= "this.DumpDFA();"
+
+Pass() ::= ""
+
+StringList() ::= "List\<String>"
+
+BuildParseTrees() ::= "this.BuildParseTree = true;"
+
+BailErrorStrategy() ::= <%ErrorHandler = new BailErrorStrategy();%>
+
+ToStringTree(s) ::= <%<s>.ToStringTree(this)%>
+
+Column() ::= "this.Column"
+
+Text() ::= "this.Text"
+
+ValEquals(a,b) ::= <%<a>==<b>%>
+
+TextEquals(a) ::= <%this.Text.Equals("<a>")%>
+
+PlusText(a) ::= <%"<a>" + this.Text%>
+
+InputText() ::= "this.TokenStream.GetText()"
+
+LTEquals(i, v) ::= <%this.TokenStream.Lt(<i>).Text.Equals(<v>)%>
+
+LANotEquals(i, v) ::= <%this.InputStream.La(<i>)!=<v>%>
+
+TokenStartColumnEquals(i) ::= <%this.TokenStartColumn==<i>%>
+
+ImportListener(X) ::= ""
+
+GetExpectedTokenNames() ::= "this.GetExpectedTokens().ToString(this.Vocabulary)"
+
+RuleInvocationStack() ::= "GetRuleInvocationStackAsString()"
+
+LL_EXACT_AMBIG_DETECTION() ::= <<Interpreter.PredictionMode = PredictionMode.LlExactAmbigDetection;>>
+
+ParserPropertyMember() ::= <<
+@members {
+bool Property() {
+	return true;
+}
+}
+>>
+
+PositionAdjustingLexer() ::= <<
+
+public override IToken NextToken() {
+	if (!(Interpreter is PositionAdjustingLexerATNSimulator)) {
+		Interpreter = new PositionAdjustingLexerATNSimulator(this, _ATN);
+	}
+
+	return base.NextToken();
+}
+
+public override IToken Emit() {
+	switch (Type) {
+	case TOKENS:
+		HandleAcceptPositionForKeyword("tokens");
+		break;
+
+	case LABEL:
+		HandleAcceptPositionForIdentifier();
+		break;
+
+	default:
+		break;
+	}
+
+	return base.Emit();
+}
+
+private bool HandleAcceptPositionForIdentifier() {
+	string tokenText = this.Text;
+	int identifierLength = 0;
+	while (identifierLength \< tokenText.Length && IsIdentifierChar(tokenText[identifierLength])) {
+		identifierLength++;
+	}
+
+	if (InputStream.Index > TokenStartCharIndex + identifierLength) {
+		int offset = identifierLength - 1;
+		getInterpreter().ResetAcceptPosition((ICharStream)InputStream, TokenStartCharIndex + offset, TokenStartLine, TokenStartColumn + offset);
+		return true;
+	}
+
+	return false;
+}
+
+private bool HandleAcceptPositionForKeyword(string keyword) {
+	if (InputStream.Index > TokenStartCharIndex + keyword.Length) {
+		int offset = keyword.Length - 1;
+		getInterpreter().ResetAcceptPosition((ICharStream)InputStream, TokenStartCharIndex + offset, TokenStartLine, TokenStartColumn + offset);
+		return true;
+	}
+
+	return false;
+}
+
+public PositionAdjustingLexerATNSimulator getInterpreter() {
+	return (PositionAdjustingLexerATNSimulator)base.Interpreter;
+}
+
+private static bool IsIdentifierChar(char c) {
+	return Char.IsLetterOrDigit(c) || c == '_';
+}
+
+public class PositionAdjustingLexerATNSimulator : LexerATNSimulator {
+
+	public PositionAdjustingLexerATNSimulator(Lexer recog, ATN atn)
+	: base(recog, atn)
+	{
+	}
+
+	public void ResetAcceptPosition(ICharStream input, int index, int line, int column) {
+		input.Seek(index);
+		this.Line = line;
+		this.Column = column;
+		Consume(input);
+	}
+
+}
+
+>>
+
+BasicListener(X) ::= <<
+public class LeafListener : TBaseListener {
+	public override void VisitTerminal(ITerminalNode node) {
+		Console.WriteLine(node.Symbol.Text);
+	}
+}
+>>
+
+WalkListener(s) ::= <<
+ParseTreeWalker walker = new ParseTreeWalker();
+walker.Walk(new LeafListener(), <s>);
+>>
+
+TreeNodeWithAltNumField(X) ::= <<
+@parser::members {
+public class MyRuleNode : ParserRuleContext {
+	public int altNum;
+	public MyRuleNode(ParserRuleContext parent, int invokingStateNumber): base(parent, invokingStateNumber)
+	{
+	}
+	public override int getAltNumber() { return altNum; }
+	public override void setAltNumber(int altNum) { this.altNum = altNum; }
+}
+}
+>>
+
+TokenGetterListener(X) ::= <<
+public class LeafListener : TBaseListener {
+	public override void ExitA(TParser.AContext ctx) {
+		if (ctx.ChildCount==2)
+		{
+			StringBuilder sb = new StringBuilder ("[");
+			foreach (ITerminalNode node in ctx.INT ()) {
+				sb.Append (node.ToString ());
+				sb.Append (", ");
+			}
+			sb.Length = sb.Length - 2;
+			sb.Append ("]");
+			Console.Write ("{0} {1} {2}", ctx.INT (0).Symbol.Text,
+				ctx.INT (1).Symbol.Text, sb.ToString());
+		}
+		else
+			Console.WriteLine(ctx.ID().Symbol);
+	}
+}
+>>
+
+RuleGetterListener(X) ::= <<
+public class LeafListener : TBaseListener {
+	public override void ExitA(TParser.AContext ctx) {
+		if (ctx.ChildCount==2) {
+			Console.Write("{0} {1} {2}",ctx.b(0).Start.Text,
+				ctx.b(1).Start.Text,ctx.b()[0].Start.Text);
+		} else
+			Console.WriteLine(ctx.b(0).Start.Text);
+	}
+}
+>>
+
+
+LRListener(X) ::= <<
+public class LeafListener : TBaseListener {
+	public override void ExitE(TParser.EContext ctx) {
+		if (ctx.ChildCount==3) {
+			Console.Write("{0} {1} {2}\n",ctx.e(0).Start.Text,
+				ctx.e(1).Start.Text, ctx.e()[0].Start.Text);
+		} else
+			Console.WriteLine(ctx.INT().Symbol.Text);
+	}
+}
+>>
+
+LRWithLabelsListener(X) ::= <<
+public class LeafListener : TBaseListener {
+	public override void ExitCall(TParser.CallContext ctx) {
+		Console.Write("{0} {1}",ctx.e().Start.Text,ctx.eList());
+	}
+	public override void ExitInt(TParser.IntContext ctx) {
+		Console.WriteLine(ctx.INT().Symbol.Text);
+	}
+}
+>>
+
+DeclareContextListGettersFunction() ::= <<
+void foo() {
+	SContext s = null;
+	AContext[] a = s.a();
+	BContext[] b = s.b();
+}
+>>
+
+Declare_foo() ::= <<public void foo() {Console.WriteLine("foo");}>>
+
+Invoke_foo() ::= "this.foo();"
+
+Declare_pred() ::= <<bool pred(bool v) {
+	Console.WriteLine("eval="+v.ToString().ToLower());
+	return v;
+}
+>>
+
+Invoke_pred(v) ::= <<this.pred(<v>)>>
+
+isEmpty ::= [
+	"": true,
+	default: false
+]
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/java/Java.test.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/java/Java.test.stg
new file mode 100644
index 000000000..45c6e1a63
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/java/Java.test.stg
@@ -0,0 +1,428 @@
+TestFile(file) ::= <<
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.java;
+
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+<if(file.Options.("ImportGrammar"))>
+import org.antlr.v4.tool.Grammar;
+<endif>
+
+public class Test<file.name> extends BaseTest {
+
+	<file.tests:{test | <test>}; separator="\n", wrap, anchor>
+
+}<\n>
+>>
+
+LexerTestMethod(test) ::= <<
+/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+<testAnnotations(test)>
+public void test<test.name>() throws Exception {
+	mkdir(tmpdir);
+
+<test.SlaveGrammars:{grammar |
+	String slave_<grammar> =<writeStringLiteral(test.SlaveGrammars.(grammar))>;
+	writeFile(tmpdir, "<grammar>.g4", slave_<grammar>);
+	}; separator="\n">
+<test.Grammar:{grammar |
+	<buildStringLiteral(test.Grammar.(grammar), "grammar")>
+
+<if(test.AfterGrammar)>
+	<test.AfterGrammar>
+<endif>
+	String input =<writeStringLiteral(test.Input)>;
+	String found = execLexer("<grammar>.g4", grammar, "<grammar><if(test.Options.("CombinedGrammar"))>Lexer<endif>", input, <writeBoolean(test.Options.("ShowDFA"))>);
+	assertEquals(<writeStringLiteral(test.Output)>, found);
+	<if(!isEmpty.(test.Errors))>
+	assertEquals(<writeStringLiteral(test.Errors)>, this.stderrDuringParse);
+	<else>
+	assertNull(this.stderrDuringParse);
+	<endif>
+	}>
+}
+
+>>
+
+CompositeLexerTestMethod(test) ::= <<
+<LexerTestMethod(test)>
+>>
+
+ParserTestMethod(test) ::= <<
+/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+<testAnnotations(test)>
+public void test<test.name>() throws Exception {
+	mkdir(tmpdir);
+
+<test.SlaveGrammars:{grammar |
+	String slave_<grammar> =<writeStringLiteral(test.SlaveGrammars.(grammar))>;
+<if(test.Options.("SlaveIsLexer"))>
+	rawGenerateAndBuildRecognizer("<grammar>.g4", slave_<grammar>, null, "<grammar>");
+<else>
+	writeFile(tmpdir, "<grammar>.g4", slave_<grammar>);
+<endif>
+	}; separator="\n">
+<test.Grammar:{grammar |
+	<buildStringLiteral(test.Grammar.(grammar), "grammar")>
+
+	<test.AfterGrammar>
+
+	String input =<writeStringLiteral(test.Input)>;
+	String found = execParser("<grammar>.g4", grammar, "<grammar>Parser", "<grammar>Lexer", "<test.Rule>", input, <writeBoolean(test.Options.("Debug"))>);
+	assertEquals(<writeStringLiteral(test.Output)>, found);
+	<if(!isEmpty.(test.Errors))>
+	assertEquals(<writeStringLiteral(test.Errors)>, this.stderrDuringParse);
+	<else>
+	assertNull(this.stderrDuringParse);
+	<endif>
+	}>
+}
+
+>>
+
+CompositeParserTestMethod(test) ::= <<
+<ParserTestMethod(test)>
+>>
+
+AbstractParserTestMethod(test) ::= <<
+String test<test.name>(String input) throws Exception {
+	String grammar = <test.grammar.lines:{ line | "<line>};separator="\\n\" +\n", wrap, anchor>";
+	return execParser("<test.grammar.grammarName>.g4", grammar, "<test.grammar.grammarName>Parser", "<test.grammar.grammarName>Lexer", "<test.startRule>", input, <test.debug>);
+}
+
+>>
+
+ConcreteParserTestMethod(test) ::= <<
+<testAnnotations(test)>
+public void test<test.name>() throws Exception {
+	String found = test<test.baseName>("<test.input>");
+	assertEquals("<test.expectedOutput>", found);
+	<if(test.expectedErrors)>
+	assertEquals("<test.expectedErrors>", this.stderrDuringParse);
+	<else>
+	assertNull(this.stderrDuringParse);
+	<endif>
+}
+
+>>
+
+testAnnotations(test) ::= <%
+@Test
+<if(test.Options.("Timeout"))>
+(timeout = <test.Options.("Timeout")>)
+<endif>
+<if(test.Options.("Ignore"))>
+<\n>@Ignore(<writeStringLiteral(test.Options.("Ignore"))>)
+<elseif(IgnoredTests.(({<file.name>.<test.name>})))>
+<\n>@Ignore(<writeStringLiteral(IgnoredTests.(({<file.name>.<test.name>})))>)
+<endif>
+%>
+
+buildStringLiteral(text, variable) ::= <<
+StringBuilder <variable>Builder = new StringBuilder(<strlen.(text)>);
+<lines.(text):{line|<variable>Builder.append("<escape.(line)>");}; separator="\n">
+String <variable> = <variable>Builder.toString();
+>>
+
+writeStringLiteral(text) ::= <%
+<if(isEmpty.(text))>
+""
+<else>
+<writeLines(lines.(text))>
+<endif>
+%>
+
+writeLines(textLines) ::= <%
+<if(rest(textLines))>
+<textLines:{line|
+<\n>		"<escape.(line)>}; separator="\" +">"
+<else>
+"<escape.(first(textLines))>"
+<endif>
+%>
+
+string(text) ::= <<
+"<escape.(text)>"
+>>
+
+writeBoolean(o) ::= "<if(o && !isEmpty.(o))>true<else>false<endif>"
+
+writeln(s) ::= <<System.out.println(<s>);>>
+
+write(s) ::= <<System.out.print(<s>);>>
+
+False() ::= "false"
+
+True() ::= "true"
+
+Not(v) ::= "!<v>"
+
+Assert(s) ::= <<assert(<s>);>>
+
+Cast(t,v) ::= "((<t>)<v>)"
+
+Append(a,b) ::= "<a> + <b>"
+
+Concat(a,b) ::= "<a><b>"
+
+DeclareLocal(s,v) ::= "Object <s> = <v>;"
+
+AssertIsList(v) ::= "List\<?> __ttt__ = <v>;" // just use static type system
+
+AssignLocal(s,v) ::= "<s> = <v>;"
+
+InitIntMember(n,v) ::= <%int <n> = <v>;%>
+
+InitBooleanMember(n,v) ::= <%boolean <n> = <v>;%>
+
+GetMember(n) ::= <%this.<n>%>
+
+SetMember(n,v) ::= <%this.<n> = <v>;%>
+
+AddMember(n,v) ::= <%this.<n> += <v>;%>
+
+PlusMember(v,n) ::= <%<v> + this.<n>%>
+
+MemberEquals(n,v) ::= <%this.<n> == <v>%>
+
+ModMemberEquals(n,m,v) ::= <%this.<n> % <m> == <v>%>
+
+ModMemberNotEquals(n,m,v) ::= <%this.<n> % <m> != <v>%>
+
+DumpDFA() ::= "this.dumpDFA();"
+
+Pass() ::= ""
+
+StringList() ::= "List\<String>"
+
+BuildParseTrees() ::= "setBuildParseTree(true);"
+
+BailErrorStrategy() ::= <%setErrorHandler(new BailErrorStrategy());%>
+
+ToStringTree(s) ::= <%<s>.toStringTree(this)%>
+
+Column() ::= "this.getCharPositionInLine()"
+
+Text() ::= "this.getText()"
+
+ValEquals(a,b) ::= <%<a>==<b>%>
+
+TextEquals(a) ::= <%this.getText().equals("<a>")%>
+
+PlusText(a) ::= <%"<a>" + this.getText()%>
+
+InputText() ::= "this._input.getText()"
+
+LTEquals(i, v) ::= <%this._input.LT(<i>).getText().equals(<v>)%>
+
+LANotEquals(i, v) ::= <%this._input.LA(<i>)!=<v>%>
+
+TokenStartColumnEquals(i) ::= <%this._tokenStartCharPositionInLine==<i>%>
+
+ImportListener(X) ::= ""
+
+GetExpectedTokenNames() ::= "this.getExpectedTokens().toString(this.tokenNames)"
+
+RuleInvocationStack() ::= "getRuleInvocationStack()"
+
+LL_EXACT_AMBIG_DETECTION() ::= <<_interp.setPredictionMode(PredictionMode.LL_EXACT_AMBIG_DETECTION);>>
+
+ParserPropertyMember() ::= <<
+@members {
+boolean Property() {
+  return true;
+}
+}
+>>
+
+PositionAdjustingLexer() ::= <<
+
+@Override
+public Token nextToken() {
+	if (!(_interp instanceof PositionAdjustingLexerATNSimulator)) {
+		_interp = new PositionAdjustingLexerATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache);
+	}
+
+	return super.nextToken();
+}
+
+@Override
+public Token emit() {
+	switch (_type) {
+	case TOKENS:
+		handleAcceptPositionForKeyword("tokens");
+		break;
+
+	case LABEL:
+		handleAcceptPositionForIdentifier();
+		break;
+
+	default:
+		break;
+	}
+
+	return super.emit();
+}
+
+private boolean handleAcceptPositionForIdentifier() {
+	String tokenText = getText();
+	int identifierLength = 0;
+	while (identifierLength \< tokenText.length() && isIdentifierChar(tokenText.charAt(identifierLength))) {
+		identifierLength++;
+	}
+
+	if (getInputStream().index() > _tokenStartCharIndex + identifierLength) {
+		int offset = identifierLength - 1;
+		getInterpreter().resetAcceptPosition(getInputStream(), _tokenStartCharIndex + offset, _tokenStartLine, _tokenStartCharPositionInLine + offset);
+		return true;
+	}
+
+	return false;
+}
+
+private boolean handleAcceptPositionForKeyword(String keyword) {
+	if (getInputStream().index() > _tokenStartCharIndex + keyword.length()) {
+		int offset = keyword.length() - 1;
+		getInterpreter().resetAcceptPosition(getInputStream(), _tokenStartCharIndex + offset, _tokenStartLine, _tokenStartCharPositionInLine + offset);
+		return true;
+	}
+
+	return false;
+}
+
+@Override
+public PositionAdjustingLexerATNSimulator getInterpreter() {
+	return (PositionAdjustingLexerATNSimulator)super.getInterpreter();
+}
+
+private static boolean isIdentifierChar(char c) {
+	return Character.isLetterOrDigit(c) || c == '_';
+}
+
+protected static class PositionAdjustingLexerATNSimulator extends LexerATNSimulator {
+
+	public PositionAdjustingLexerATNSimulator(Lexer recog, ATN atn,
+											  DFA[] decisionToDFA,
+											  PredictionContextCache sharedContextCache)
+	{
+		super(recog, atn, decisionToDFA, sharedContextCache);
+	}
+
+	protected void resetAcceptPosition(CharStream input, int index, int line, int charPositionInLine) {
+		input.seek(index);
+		this.line = line;
+		this.charPositionInLine = charPositionInLine;
+		consume(input);
+	}
+
+}
+
+>>
+
+BasicListener(X) ::= <<
+public static class LeafListener extends TBaseListener {
+	public void visitTerminal(TerminalNode node) {
+		System.out.println(node.getSymbol().getText());
+	}
+}
+>>
+
+WalkListener(s) ::= <<
+ParseTreeWalker walker = new ParseTreeWalker();
+walker.walk(new LeafListener(), <s>);
+>>
+
+TreeNodeWithAltNumField(X) ::= <<
+@parser::members {
+public static class MyRuleNode extends ParserRuleContext {
+	public int altNum;
+	public MyRuleNode(ParserRuleContext parent, int invokingStateNumber) {
+		super(parent, invokingStateNumber);
+	}
+	@Override public int getAltNumber() { return altNum; }
+	@Override public void setAltNumber(int altNum) { this.altNum = altNum; }
+}
+}
+>>
+
+TokenGetterListener(X) ::= <<
+public static class LeafListener extends TBaseListener {
+	public void exitA(TParser.AContext ctx) {
+		if (ctx.getChildCount()==2)
+			System.out.printf("%s %s %s",ctx.INT(0).getSymbol().getText(),
+				ctx.INT(1).getSymbol().getText(),ctx.INT());
+		else
+			System.out.println(ctx.ID().getSymbol());
+	}
+}
+>>
+
+RuleGetterListener(X) ::= <<
+public static class LeafListener extends TBaseListener {
+	public void exitA(TParser.AContext ctx) {
+		if (ctx.getChildCount()==2) {
+			System.out.printf("%s %s %s",ctx.b(0).start.getText(),
+				ctx.b(1).start.getText(),ctx.b().get(0).start.getText());
+		} else
+			System.out.println(ctx.b(0).start.getText());
+	}
+}
+>>
+
+
+LRListener(X) ::= <<
+public static class LeafListener extends TBaseListener {
+	public void exitE(TParser.EContext ctx) {
+		if (ctx.getChildCount()==3) {
+			System.out.printf("%s %s %s\n",ctx.e(0).start.getText(),
+				ctx.e(1).start.getText(), ctx.e().get(0).start.getText());
+		} else
+			System.out.println(ctx.INT().getSymbol().getText());
+	}
+}
+>>
+
+LRWithLabelsListener(X) ::= <<
+public static class LeafListener extends TBaseListener {
+	public void exitCall(TParser.CallContext ctx) {
+		System.out.printf("%s %s",ctx.e().start.getText(),ctx.eList());
+	}
+	public void exitInt(TParser.IntContext ctx) {
+		System.out.println(ctx.INT().getSymbol().getText());
+	}
+}
+>>
+
+DeclareContextListGettersFunction() ::= <<
+void foo() {
+	SContext s = null;
+	List\<? extends AContext> a = s.a();
+	List\<? extends BContext> b = s.b();
+}
+>>
+
+Declare_foo() ::= <<
+	public void foo() {System.out.println("foo");}
+>>
+
+Invoke_foo() ::= "foo();"
+
+Declare_pred() ::= <<boolean pred(boolean v) {
+	System.out.println("eval="+v);
+	return v;
+}
+>>
+
+Invoke_pred(v) ::= <<this.pred(<v>)>>
+
+IgnoredTests ::= [
+	default: false
+]
+
+isEmpty ::= [
+	"": true,
+	default: false
+]
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/javascript/chrome/Chrome.test.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/javascript/chrome/Chrome.test.stg
new file mode 100644
index 000000000..649d3a127
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/javascript/chrome/Chrome.test.stg
@@ -0,0 +1,434 @@
+IgnoredTests ::= [
+	default: false
+]
+
+TestFile(file) ::= <<
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.javascript.chrome;
+
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+<if(file.Options.("ImportErrorQueue"))>
+import org.antlr.v4.test.runtime.java.ErrorQueue;
+<endif>
+<if(file.Options.("ImportGrammar"))>
+import org.antlr.v4.tool.Grammar;
+<endif>
+
+@SuppressWarnings("unused")
+public class Test<file.name> extends BaseTest {
+
+	<file.tests:{test | <test>}; separator="\n", wrap, anchor>
+
+}<\n>
+>>
+
+LexerTestMethod(test) ::= <<
+/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+<testAnnotations(test)>
+public void test<test.name>() throws Exception {
+	mkdir(tmpdir);
+<test.SlaveGrammars:{grammar |
+	String slave_<grammar> =<writeStringLiteral(test.SlaveGrammars.(grammar))>;
+	writeFile(tmpdir, "<grammar>.g4", slave_<grammar>);
+	}; separator="\n">
+
+<test.Grammar:{grammar |
+	<buildStringLiteral(test.Grammar.(grammar), "grammar")>
+	<test.afterGrammar>
+	String input =<writeStringLiteral(test.Input)>;
+	String found = execLexer("<grammar>.g4", grammar, "<grammar><if(test.Options.("CombinedGrammar"))>Lexer<endif>", input, <writeBoolean(test.Options.("ShowDFA"))>);
+	assertEquals(<writeStringLiteral(test.Output)>, found);
+	<if(!isEmpty.(test.Errors))>
+	assertEquals(<writeStringLiteral(test.Errors)>, this.stderrDuringParse);
+	<else>
+	assertNull(this.stderrDuringParse);
+	<endif>
+    }>
+}
+>>
+
+CompositeLexerTestMethod(test) ::= <<
+<LexerTestMethod(test)>
+>>
+
+ParserTestMethod(test) ::= <<
+/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+<testAnnotations(test)>
+public void test<test.name>() throws Exception {
+	mkdir(tmpdir);
+<test.SlaveGrammars:{grammar |
+	String slave_<grammar> =<writeStringLiteral(test.SlaveGrammars.(grammar))>;
+<if(test.Options.("SlaveIsLexer"))>
+	rawGenerateAndBuildRecognizer("<grammar>.g4", slave_<grammar>, null, "<grammar>");
+<else>
+	writeFile(tmpdir, "<grammar>.g4", slave_<grammar>);
+<endif>
+	}; separator="\n">
+<test.Grammar:{grammar |
+	<buildStringLiteral(test.Grammar.(grammar), "grammar")>
+	<test.afterGrammar>
+	String input =<writeStringLiteral(test.Input)>;
+	String found = execParser("<grammar>.g4", grammar, "<grammar>Parser", "<grammar>Lexer",
+	                          "<grammar>Listener", "<grammar>Visitor",
+	                          "<test.Rule>", input, <writeBoolean(test.Options.("Debug"))>);
+	assertEquals(<writeStringLiteral(test.Output)>, found);
+	<if(!isEmpty.(test.Errors))>
+	assertEquals(<writeStringLiteral(test.Errors)>, this.stderrDuringParse);
+	<else>
+	assertNull(this.stderrDuringParse);
+	<endif>
+    }>
+}
+>>
+
+CompositeParserTestMethod(test) ::= <<
+<ParserTestMethod(test)>
+>>
+
+AbstractParserTestMethod(test) ::= <<
+/* this file and method are generated, any edit will be overwritten by the next generation */
+String test<test.name>(String input) throws Exception {
+	String grammar = <test.grammar.lines:{ line | "<line>};separator="\\n\" +\n", wrap, anchor>";
+	return execParser("<test.grammar.grammarName>.g4", grammar, "<test.grammar.grammarName>Parser",
+                      "<test.grammar.grammarName>Listener", "<test.grammar.grammarName>Visitor",
+	                  "<test.grammar.grammarName>Lexer", "<test.startRule>", input, <test.debug>);
+}
+
+>>
+
+ConcreteParserTestMethod(test) ::= <<
+/* this file and method are generated, any edit will be overwritten by the next generation */
+@Test
+public void test<test.name>() throws Exception {
+	String found = test<test.baseName>("<test.input>");
+	assertEquals("<test.expectedOutput>", found);
+	<if(test.expectedErrors)>
+	assertEquals("<test.expectedErrors>", this.stderrDuringParse);
+	<else>
+	assertNull(this.stderrDuringParse);
+	<endif>
+}
+
+>>
+
+testAnnotations(test) ::= <%
+@Test
+<if(test.Options.("Ignore"))>
+<\n>@Ignore(<writeStringLiteral(test.Options.("Ignore"))>)
+<elseif(IgnoredTests.(({<file.name>.<test.name>})))>
+<\n>@Ignore(<writeStringLiteral(IgnoredTests.(({<file.name>.<test.name>})))>)
+<endif>
+%>
+
+buildStringLiteral(text, variable) ::= <<
+StringBuilder <variable>Builder = new StringBuilder(<strlen.(text)>);
+<lines.(text):{line|<variable>Builder.append("<escape.(line)>");}; separator="\n">
+String <variable> = <variable>Builder.toString();
+>>
+
+writeStringLiteral(text) ::= <%
+<if(isEmpty.(text))>
+""
+<else>
+<writeLines(lines.(text))>
+<endif>
+%>
+
+writeLines(textLines) ::= <%
+<if(rest(textLines))>
+<textLines:{line|
+<\n>		"<escape.(line)>}; separator="\" +">"
+<else>
+"<escape.(first(textLines))>"
+<endif>
+%>
+
+string(text) ::= <<
+"<escape.(text)>"
+>>
+
+writeBoolean(o) ::= "<if(o && !isEmpty.(o))>true<else>false<endif>"
+
+writeln(s) ::= <<document.getElementById('output').value += <s> + '\\n';>>
+
+write(s) ::= <<document.getElementById('output').value += <s>;>>
+
+False() ::= "false"
+
+True() ::= "true"
+
+Not(v) ::= "!<v>"
+
+Assert(s) ::= ""
+
+Cast(t,v) ::= "<v>"
+
+Append(a,b) ::= "<a> + <b>"
+
+Concat(a,b) ::= "<a><b>"
+
+DeclareLocal(s,v) ::= "var <s> = <v>;"
+
+AssertIsList(v) ::= <<if ( !(v instanceof Array) ) {throw "value is not an array";}>>
+
+AssignLocal(s,v) ::= "<s> = <v>;"
+
+InitIntMember(n,v) ::= <%this.<n> = <v>;%>
+
+InitBooleanMember(n,v) ::= <%this.<n> = <v>;%>
+
+GetMember(n) ::= <%this.<n>%>
+
+SetMember(n,v) ::= <%this.<n> = <v>;%>
+
+AddMember(n,v) ::= <%this.<n> += <v>;%>
+
+PlusMember(v,n) ::= <%<v> + this.<n>%>
+
+MemberEquals(n,v) ::= <%this.<n> === <v>%>
+
+ModMemberEquals(n,m,v) ::= <%this.<n> % <m> === <v>%>
+
+ModMemberNotEquals(n,m,v) ::= <%this.<n> % <m> != <v>%>
+
+DumpDFA() ::= "this.dumpDFA();"
+
+Pass() ::= ""
+
+StringList() ::= "list"
+
+BuildParseTrees() ::= "this.buildParseTrees = true;"
+
+BailErrorStrategy() ::= <%this._errHandler = new antlr4.error.BailErrorStrategy();%>
+
+ToStringTree(s) ::= <%<s>.toStringTree(null, this)%>
+
+Column() ::= "this.column"
+
+Text() ::= "this.text"
+
+ValEquals(a,b) ::= <%<a>===<b>%>
+
+TextEquals(a) ::= <%this.text==="<a>"%>
+
+PlusText(a) ::= <%"<a>" + this.text%>
+
+InputText() ::= "this._input.getText()"
+
+LTEquals(i, v) ::= <%this._input.LT(<i>).text===<v>%>
+
+LANotEquals(i, v) ::= <%this._input.LA(<i>)!=<v>%>
+
+TokenStartColumnEquals(i) ::= <%this._tokenStartColumn===<i>%>
+
+ImportListener(X) ::= <<var <X>Listener = require('./<X>Listener').<X>Listener;>>
+
+GetExpectedTokenNames() ::= "this.getExpectedTokens().toString(this.literalNames)"
+
+RuleInvocationStack() ::= "antlr4.Utils.arrayToString(this.getRuleInvocationStack())"
+
+LL_EXACT_AMBIG_DETECTION() ::= <<this._interp.predictionMode = antlr4.atn.PredictionMode.LL_EXACT_AMBIG_DETECTION;>>
+
+ParserPropertyMember() ::= <<
+@members {
+this.Property = function() {
+    return true;
+}
+}
+>>
+
+PositionAdjustingLexer() ::= <<
+
+PositionAdjustingLexer.prototype.resetAcceptPosition = function(index, line, column) {
+	this._input.seek(index);
+	this.line = line;
+	this.column = column;
+	this._interp.consume(this._input);
+};
+
+PositionAdjustingLexer.prototype.nextToken = function() {
+	if (!("resetAcceptPosition" in this._interp)) {
+		var lexer = this;
+		this._interp.resetAcceptPosition = function(index, line, column) { lexer.resetAcceptPosition(index, line, column); };
+	}
+	return antlr4.Lexer.prototype.nextToken.call(this);
+};
+
+PositionAdjustingLexer.prototype.emit = function() {
+	switch(this._type) {
+	case PositionAdjustingLexer.TOKENS:
+		this.handleAcceptPositionForKeyword("tokens");
+		break;
+	case PositionAdjustingLexer.LABEL:
+		this.handleAcceptPositionForIdentifier();
+		break;
+	}
+	return antlr4.Lexer.prototype.emit.call(this);
+};
+
+PositionAdjustingLexer.prototype.handleAcceptPositionForIdentifier = function() {
+	var tokenText = this.text;
+	var identifierLength = 0;
+	while (identifierLength \< tokenText.length &&
+		PositionAdjustingLexer.isIdentifierChar(tokenText[identifierLength])
+	) {
+		identifierLength += 1;
+	}
+	if (this._input.index > this._tokenStartCharIndex + identifierLength) {
+		var offset = identifierLength - 1;
+		this._interp.resetAcceptPosition(this._tokenStartCharIndex + offset,
+				this._tokenStartLine, this._tokenStartColumn + offset);
+		return true;
+	} else {
+		return false;
+	}
+};
+
+PositionAdjustingLexer.prototype.handleAcceptPositionForKeyword = function(keyword) {
+	if (this._input.index > this._tokenStartCharIndex + keyword.length) {
+		var offset = keyword.length - 1;
+		this._interp.resetAcceptPosition(this._tokenStartCharIndex + offset,
+			this._tokenStartLine, this._tokenStartColumn + offset);
+		return true;
+	} else {
+		return false;
+	}
+};
+
+PositionAdjustingLexer.isIdentifierChar = function(c) {
+	return c.match(/^[0-9a-zA-Z_]+$/);
+}
+
+>>
+
+BasicListener(X) ::= <<
+this.LeafListener = function() {
+    this.visitTerminal = function(node) {
+    	document.getElementById('output').value += node.symbol.text + '\\n';
+    };
+    return this;
+};
+this.LeafListener.prototype = Object.create(<X>Listener.prototype);
+this.LeafListener.prototype.constructor = this.LeafListener;
+
+>>
+
+WalkListener(s) ::= <<
+var walker = new antlr4.tree.ParseTreeWalker();
+walker.walk(new this.LeafListener(), <s>);
+>>
+
+TreeNodeWithAltNumField(X) ::= <<
+
+@parser::header {
+MyRuleNode = function(parent, invokingState) {
+	antlr4.ParserRuleContext.call(this, parent, invokingState);
+	this.altNum = 0;
+	return this;
+};
+
+MyRuleNode.prototype = Object.create(antlr4.ParserRuleContext.prototype);
+MyRuleNode.prototype.constructor = MyRuleNode;
+}
+>>
+
+TokenGetterListener(X) ::= <<
+this.LeafListener = function() {
+    this.exitA = function(ctx) {
+    	var str;
+        if(ctx.getChildCount()===2) {
+            str = ctx.INT(0).symbol.text + ' ' + ctx.INT(1).symbol.text + ' ' + antlr4.Utils.arrayToString(ctx.INT());
+        } else {
+            str = ctx.ID().symbol.toString();
+        }
+    	document.getElementById('output').value += str + '\\n';
+    };
+    return this;
+};
+this.LeafListener.prototype = Object.create(<X>Listener.prototype);
+this.LeafListener.prototype.constructor = this.LeafListener;
+
+>>
+
+RuleGetterListener(X) ::= <<
+this.LeafListener = function() {
+    this.exitA = function(ctx) {
+    	var str;
+        if(ctx.getChildCount()===2) {
+            str = ctx.b(0).start.text + ' ' + ctx.b(1).start.text + ' ' + ctx.b()[0].start.text;
+        } else {
+            str = ctx.b(0).start.text;
+        }
+    	document.getElementById('output').value += str + '\\n';
+    };
+    return this;
+};
+this.LeafListener.prototype = Object.create(<X>Listener.prototype);
+this.LeafListener.prototype.constructor = this.LeafListener;
+
+>>
+
+
+LRListener(X) ::= <<
+this.LeafListener = function() {
+    this.exitE = function(ctx) {
+    	var str;
+        if(ctx.getChildCount()===3) {
+            str = ctx.e(0).start.text + ' ' + ctx.e(1).start.text + ' ' + ctx.e()[0].start.text;
+        } else {
+            str = ctx.INT().symbol.text;
+        }
+    	document.getElementById('output').value += str + '\\n';
+    };
+    return this;
+};
+this.LeafListener.prototype = Object.create(<X>Listener.prototype);
+this.LeafListener.prototype.constructor = this.LeafListener;
+
+>>
+
+LRWithLabelsListener(X) ::= <<
+this.LeafListener = function() {
+    this.exitCall = function(ctx) {
+    	var str = ctx.e().start.text + ' ' + ctx.eList();
+    	document.getElementById('output').value += str + '\\n';
+    };
+    this.exitInt = function(ctx) {
+        var str = ctx.INT().symbol.text;
+    	document.getElementById('output').value += str + '\\n';
+    };
+    return this;
+};
+this.LeafListener.prototype = Object.create(<X>Listener.prototype);
+this.LeafListener.prototype.constructor = this.LeafListener;
+
+>>
+
+DeclareContextListGettersFunction() ::= <<
+	function foo() {
+		var s = new SContext();
+	    var a = s.a();
+	    var b = s.b();
+    };
+>>
+
+Declare_foo() ::= "this.foo = function() {document.getElementById('output').value += 'foo' + '\\n';};"
+
+Invoke_foo() ::= "this.foo();"
+
+Declare_pred() ::= <<this.pred = function(v) {
+	document.getElementById('output').value += 'eval=' + v.toString() + '\\n';
+	return v;
+};
+>>
+
+Invoke_pred(v) ::= <<this.pred(<v>)>>
+
+isEmpty ::= [
+	"": true,
+	default: false
+]
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/javascript/explorer/Explorer.test.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/javascript/explorer/Explorer.test.stg
new file mode 100644
index 000000000..7dba81947
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/javascript/explorer/Explorer.test.stg
@@ -0,0 +1,434 @@
+IgnoredTests ::= [
+	default: false
+]
+
+TestFile(file) ::= <<
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.javascript.explorer;
+
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+<if(file.Options.("ImportErrorQueue"))>
+import org.antlr.v4.test.runtime.java.ErrorQueue;
+<endif>
+<if(file.Options.("ImportGrammar"))>
+import org.antlr.v4.tool.Grammar;
+<endif>
+
+@SuppressWarnings("unused")
+public class Test<file.name> extends BaseTest {
+
+	<file.tests:{test | <test>}; separator="\n", wrap, anchor>
+
+}<\n>
+>>
+
+LexerTestMethod(test) ::= <<
+/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+<testAnnotations(test)>
+public void test<test.name>() throws Exception {
+	mkdir(tmpdir);
+<test.SlaveGrammars:{grammar |
+	String slave_<grammar> =<writeStringLiteral(test.SlaveGrammars.(grammar))>;
+	writeFile(tmpdir, "<grammar>.g4", slave_<grammar>);
+	}; separator="\n">
+
+<test.Grammar:{grammar |
+	<buildStringLiteral(test.Grammar.(grammar), "grammar")>
+	<test.afterGrammar>
+	String input =<writeStringLiteral(test.Input)>;
+	String found = execLexer("<grammar>.g4", grammar, "<grammar><if(test.Options.("CombinedGrammar"))>Lexer<endif>", input, <writeBoolean(test.Options.("ShowDFA"))>);
+	assertEquals(<writeStringLiteral(test.Output)>, found);
+	<if(!isEmpty.(test.Errors))>
+	assertEquals(<writeStringLiteral(test.Errors)>, this.stderrDuringParse);
+	<else>
+	assertNull(this.stderrDuringParse);
+	<endif>
+    }>
+}
+>>
+
+CompositeLexerTestMethod(test) ::= <<
+<LexerTestMethod(test)>
+>>
+
+ParserTestMethod(test) ::= <<
+/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+<testAnnotations(test)>
+public void test<test.name>() throws Exception {
+	mkdir(tmpdir);
+<test.SlaveGrammars:{grammar |
+	String slave_<grammar> =<writeStringLiteral(test.SlaveGrammars.(grammar))>;
+<if(test.Options.("SlaveIsLexer"))>
+	rawGenerateAndBuildRecognizer("<grammar>.g4", slave_<grammar>, null, "<grammar>");
+<else>
+	writeFile(tmpdir, "<grammar>.g4", slave_<grammar>);
+<endif>
+	}; separator="\n">
+<test.Grammar:{grammar |
+	<buildStringLiteral(test.Grammar.(grammar), "grammar")>
+	<test.afterGrammar>
+	String input =<writeStringLiteral(test.Input)>;
+	String found = execParser("<grammar>.g4", grammar, "<grammar>Parser", "<grammar>Lexer",
+	                          "<grammar>Listener", "<grammar>Visitor",
+	                          "<test.Rule>", input, <writeBoolean(test.Options.("Debug"))>);
+	assertEquals(<writeStringLiteral(test.Output)>, found);
+	<if(!isEmpty.(test.Errors))>
+	assertEquals(<writeStringLiteral(test.Errors)>, this.stderrDuringParse);
+	<else>
+	assertNull(this.stderrDuringParse);
+	<endif>
+    }>
+}
+>>
+
+CompositeParserTestMethod(test) ::= <<
+<ParserTestMethod(test)>
+>>
+
+AbstractParserTestMethod(test) ::= <<
+/* this file and method are generated, any edit will be overwritten by the next generation */
+String test<test.name>(String input) throws Exception {
+	String grammar = <test.grammar.lines:{ line | "<line>};separator="\\n\" +\n", wrap, anchor>";
+	return execParser("<test.grammar.grammarName>.g4", grammar, "<test.grammar.grammarName>Parser",
+                      "<test.grammar.grammarName>Listener", "<test.grammar.grammarName>Visitor",
+	                  "<test.grammar.grammarName>Lexer", "<test.startRule>", input, <test.debug>);
+}
+
+>>
+
+ConcreteParserTestMethod(test) ::= <<
+/* this file and method are generated, any edit will be overwritten by the next generation */
+@Test
+public void test<test.name>() throws Exception {
+	String found = test<test.baseName>("<test.input>");
+	assertEquals("<test.expectedOutput>", found);
+	<if(test.expectedErrors)>
+	assertEquals("<test.expectedErrors>", this.stderrDuringParse);
+	<else>
+	assertNull(this.stderrDuringParse);
+	<endif>
+}
+
+>>
+
+testAnnotations(test) ::= <%
+@Test
+<if(test.Options.("Ignore"))>
+<\n>@Ignore(<writeStringLiteral(test.Options.("Ignore"))>)
+<elseif(IgnoredTests.(({<file.name>.<test.name>})))>
+<\n>@Ignore(<writeStringLiteral(IgnoredTests.(({<file.name>.<test.name>})))>)
+<endif>
+%>
+
+buildStringLiteral(text, variable) ::= <<
+StringBuilder <variable>Builder = new StringBuilder(<strlen.(text)>);
+<lines.(text):{line|<variable>Builder.append("<escape.(line)>");}; separator="\n">
+String <variable> = <variable>Builder.toString();
+>>
+
+writeStringLiteral(text) ::= <%
+<if(isEmpty.(text))>
+""
+<else>
+<writeLines(lines.(text))>
+<endif>
+%>
+
+writeLines(textLines) ::= <%
+<if(rest(textLines))>
+<textLines:{line|
+<\n>		"<escape.(line)>}; separator="\" +">"
+<else>
+"<escape.(first(textLines))>"
+<endif>
+%>
+
+string(text) ::= <<
+"<escape.(text)>"
+>>
+
+writeBoolean(o) ::= "<if(o && !isEmpty.(o))>true<else>false<endif>"
+
+writeln(s) ::= <<document.getElementById('output').value += <s> + '\\n';>>
+
+write(s) ::= <<document.getElementById('output').value += <s>;>>
+
+False() ::= "false"
+
+True() ::= "true"
+
+Not(v) ::= "!<v>"
+
+Assert(s) ::= ""
+
+Cast(t,v) ::= "<v>"
+
+Append(a,b) ::= "<a> + <b>"
+
+Concat(a,b) ::= "<a><b>"
+
+DeclareLocal(s,v) ::= "var <s> = <v>;"
+
+AssertIsList(v) ::= <<if ( !(v instanceof Array) ) {throw "value is not an array";}>>
+
+AssignLocal(s,v) ::= "<s> = <v>;"
+
+InitIntMember(n,v) ::= <%this.<n> = <v>;%>
+
+InitBooleanMember(n,v) ::= <%this.<n> = <v>;%>
+
+GetMember(n) ::= <%this.<n>%>
+
+SetMember(n,v) ::= <%this.<n> = <v>;%>
+
+AddMember(n,v) ::= <%this.<n> += <v>;%>
+
+PlusMember(v,n) ::= <%<v> + this.<n>%>
+
+MemberEquals(n,v) ::= <%this.<n> === <v>%>
+
+ModMemberEquals(n,m,v) ::= <%this.<n> % <m> === <v>%>
+
+ModMemberNotEquals(n,m,v) ::= <%this.<n> % <m> != <v>%>
+
+DumpDFA() ::= "this.dumpDFA();"
+
+Pass() ::= ""
+
+StringList() ::= "list"
+
+BuildParseTrees() ::= "this.buildParseTrees = true;"
+
+BailErrorStrategy() ::= <%this._errHandler = new antlr4.error.BailErrorStrategy();%>
+
+ToStringTree(s) ::= <%<s>.toStringTree(null, this)%>
+
+Column() ::= "this.column"
+
+Text() ::= "this.text"
+
+ValEquals(a,b) ::= <%<a>===<b>%>
+
+TextEquals(a) ::= <%this.text==="<a>"%>
+
+PlusText(a) ::= <%"<a>" + this.text%>
+
+InputText() ::= "this._input.getText()"
+
+LTEquals(i, v) ::= <%this._input.LT(<i>).text===<v>%>
+
+LANotEquals(i, v) ::= <%this._input.LA(<i>)!=<v>%>
+
+TokenStartColumnEquals(i) ::= <%this._tokenStartColumn===<i>%>
+
+ImportListener(X) ::= <<var <X>Listener = require('./<X>Listener').<X>Listener;>>
+
+GetExpectedTokenNames() ::= "this.getExpectedTokens().toString(this.literalNames)"
+
+RuleInvocationStack() ::= "antlr4.Utils.arrayToString(this.getRuleInvocationStack())"
+
+LL_EXACT_AMBIG_DETECTION() ::= <<this._interp.predictionMode = antlr4.atn.PredictionMode.LL_EXACT_AMBIG_DETECTION;>>
+
+ParserPropertyMember() ::= <<
+@members {
+this.Property = function() {
+    return true;
+}
+}
+>>
+
+PositionAdjustingLexer() ::= <<
+
+PositionAdjustingLexer.prototype.resetAcceptPosition = function(index, line, column) {
+	this._input.seek(index);
+	this.line = line;
+	this.column = column;
+	this._interp.consume(this._input);
+};
+
+PositionAdjustingLexer.prototype.nextToken = function() {
+	if (!("resetAcceptPosition" in this._interp)) {
+		var lexer = this;
+		this._interp.resetAcceptPosition = function(index, line, column) { lexer.resetAcceptPosition(index, line, column); };
+	}
+	return antlr4.Lexer.prototype.nextToken.call(this);
+};
+
+PositionAdjustingLexer.prototype.emit = function() {
+	switch(this._type) {
+	case PositionAdjustingLexer.TOKENS:
+		this.handleAcceptPositionForKeyword("tokens");
+		break;
+	case PositionAdjustingLexer.LABEL:
+		this.handleAcceptPositionForIdentifier();
+		break;
+	}
+	return antlr4.Lexer.prototype.emit.call(this);
+};
+
+PositionAdjustingLexer.prototype.handleAcceptPositionForIdentifier = function() {
+	var tokenText = this.text;
+	var identifierLength = 0;
+	while (identifierLength \< tokenText.length &&
+		PositionAdjustingLexer.isIdentifierChar(tokenText[identifierLength])
+	) {
+		identifierLength += 1;
+	}
+	if (this._input.index > this._tokenStartCharIndex + identifierLength) {
+		var offset = identifierLength - 1;
+		this._interp.resetAcceptPosition(this._tokenStartCharIndex + offset,
+				this._tokenStartLine, this._tokenStartColumn + offset);
+		return true;
+	} else {
+		return false;
+	}
+};
+
+PositionAdjustingLexer.prototype.handleAcceptPositionForKeyword = function(keyword) {
+	if (this._input.index > this._tokenStartCharIndex + keyword.length) {
+		var offset = keyword.length - 1;
+		this._interp.resetAcceptPosition(this._tokenStartCharIndex + offset,
+			this._tokenStartLine, this._tokenStartColumn + offset);
+		return true;
+	} else {
+		return false;
+	}
+};
+
+PositionAdjustingLexer.isIdentifierChar = function(c) {
+	return c.match(/^[0-9a-zA-Z_]+$/);
+}
+
+>>
+
+BasicListener(X) ::= <<
+this.LeafListener = function() {
+    this.visitTerminal = function(node) {
+    	document.getElementById('output').value += node.symbol.text + '\\n';
+    };
+    return this;
+};
+this.LeafListener.prototype = Object.create(<X>Listener.prototype);
+this.LeafListener.prototype.constructor = this.LeafListener;
+
+>>
+
+WalkListener(s) ::= <<
+var walker = new antlr4.tree.ParseTreeWalker();
+walker.walk(new this.LeafListener(), <s>);
+>>
+
+TreeNodeWithAltNumField(X) ::= <<
+
+@parser::header {
+MyRuleNode = function(parent, invokingState) {
+	antlr4.ParserRuleContext.call(this, parent, invokingState);
+	this.altNum = 0;
+	return this;
+};
+
+MyRuleNode.prototype = Object.create(antlr4.ParserRuleContext.prototype);
+MyRuleNode.prototype.constructor = MyRuleNode;
+}
+>>
+
+TokenGetterListener(X) ::= <<
+this.LeafListener = function() {
+    this.exitA = function(ctx) {
+    	var str;
+        if(ctx.getChildCount()===2) {
+            str = ctx.INT(0).symbol.text + ' ' + ctx.INT(1).symbol.text + ' ' + antlr4.Utils.arrayToString(ctx.INT());
+        } else {
+            str = ctx.ID().symbol.toString();
+        }
+    	document.getElementById('output').value += str + '\\n';
+    };
+    return this;
+};
+this.LeafListener.prototype = Object.create(<X>Listener.prototype);
+this.LeafListener.prototype.constructor = this.LeafListener;
+
+>>
+
+RuleGetterListener(X) ::= <<
+this.LeafListener = function() {
+    this.exitA = function(ctx) {
+    	var str;
+        if(ctx.getChildCount()===2) {
+            str = ctx.b(0).start.text + ' ' + ctx.b(1).start.text + ' ' + ctx.b()[0].start.text;
+        } else {
+            str = ctx.b(0).start.text;
+        }
+    	document.getElementById('output').value += str + '\\n';
+    };
+    return this;
+};
+this.LeafListener.prototype = Object.create(<X>Listener.prototype);
+this.LeafListener.prototype.constructor = this.LeafListener;
+
+>>
+
+
+LRListener(X) ::= <<
+this.LeafListener = function() {
+    this.exitE = function(ctx) {
+    	var str;
+        if(ctx.getChildCount()===3) {
+            str = ctx.e(0).start.text + ' ' + ctx.e(1).start.text + ' ' + ctx.e()[0].start.text;
+        } else {
+            str = ctx.INT().symbol.text;
+        }
+    	document.getElementById('output').value += str + '\\n';
+    };
+    return this;
+};
+this.LeafListener.prototype = Object.create(<X>Listener.prototype);
+this.LeafListener.prototype.constructor = this.LeafListener;
+
+>>
+
+LRWithLabelsListener(X) ::= <<
+this.LeafListener = function() {
+    this.exitCall = function(ctx) {
+    	var str = ctx.e().start.text + ' ' + ctx.eList();
+    	document.getElementById('output').value += str + '\\n';
+    };
+    this.exitInt = function(ctx) {
+        var str = ctx.INT().symbol.text;
+    	document.getElementById('output').value += str + '\\n';
+    };
+    return this;
+};
+this.LeafListener.prototype = Object.create(<X>Listener.prototype);
+this.LeafListener.prototype.constructor = this.LeafListener;
+
+>>
+
+DeclareContextListGettersFunction() ::= <<
+	function foo() {
+		var s = new SContext();
+	    var a = s.a();
+	    var b = s.b();
+    };
+>>
+
+Declare_foo() ::= "this.foo = function() {document.getElementById('output').value += 'foo' + '\\n';};"
+
+Invoke_foo() ::= "this.foo();"
+
+Declare_pred() ::= <<this.pred = function(v) {
+	document.getElementById('output').value += 'eval=' + v.toString() + '\\n';
+	return v;
+};
+>>
+
+Invoke_pred(v) ::= <<this.pred(<v>)>>
+
+isEmpty ::= [
+	"": true,
+	default: false
+]
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/javascript/firefox/Firefox.test.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/javascript/firefox/Firefox.test.stg
new file mode 100644
index 000000000..f1a91fbea
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/javascript/firefox/Firefox.test.stg
@@ -0,0 +1,436 @@
+IgnoredTests ::= [
+	default: false
+]
+
+TestFile(file) ::= <<
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.javascript.firefox;
+
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+<if(file.Options.("ImportErrorQueue"))>
+import org.antlr.v4.test.runtime.java.ErrorQueue;
+<endif>
+<if(file.Options.("ImportGrammar"))>
+import org.antlr.v4.tool.Grammar;
+<endif>
+
+@SuppressWarnings("unused")
+public class Test<file.name> extends BaseTest {
+
+	<file.tests:{test | <test>}; separator="\n", wrap, anchor>
+
+}<\n>
+>>
+
+LexerTestMethod(test) ::= <<
+/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+<testAnnotations(test)>
+public void test<test.name>() throws Exception {
+	mkdir(tmpdir);
+<test.SlaveGrammars:{grammar |
+	String slave_<grammar> =<writeStringLiteral(test.SlaveGrammars.(grammar))>;
+	writeFile(tmpdir, "<grammar>.g4", slave_<grammar>);
+	}; separator="\n">
+
+<test.Grammar:{grammar |
+	<buildStringLiteral(test.Grammar.(grammar), "grammar")>
+	<test.afterGrammar>
+	String input =<writeStringLiteral(test.Input)>;
+	String found = execLexer("<grammar>.g4", grammar, "<grammar><if(test.Options.("CombinedGrammar"))>Lexer<endif>", input, <writeBoolean(test.Options.("ShowDFA"))>);
+	assertEquals(<writeStringLiteral(test.Output)>, found);
+	<if(!isEmpty.(test.Errors))>
+	assertEquals(<writeStringLiteral(test.Errors)>, this.stderrDuringParse);
+	<else>
+	assertNull(this.stderrDuringParse);
+	<endif>
+    }>
+}
+>>
+
+CompositeLexerTestMethod(test) ::= <<
+<LexerTestMethod(test)>
+>>
+
+ParserTestMethod(test) ::= <<
+/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+<testAnnotations(test)>
+public void test<test.name>() throws Exception {
+	mkdir(tmpdir);
+<test.SlaveGrammars:{grammar |
+	String slave_<grammar> =<writeStringLiteral(test.SlaveGrammars.(grammar))>;
+<if(test.Options.("SlaveIsLexer"))>
+	rawGenerateAndBuildRecognizer("<grammar>.g4", slave_<grammar>, null, "<grammar>");
+<else>
+	writeFile(tmpdir, "<grammar>.g4", slave_<grammar>);
+<endif>
+	}; separator="\n">
+<test.Grammar:{grammar |
+	<buildStringLiteral(test.Grammar.(grammar), "grammar")>
+	<test.afterGrammar>
+	String input =<writeStringLiteral(test.Input)>;
+	String found = execParser("<grammar>.g4", grammar, "<grammar>Parser", "<grammar>Lexer",
+	                          "<grammar>Listener", "<grammar>Visitor",
+	                          "<test.Rule>", input, <writeBoolean(test.Options.("Debug"))>);
+	assertEquals(<writeStringLiteral(test.Output)>, found);
+	<if(!isEmpty.(test.Errors))>
+	assertEquals(<writeStringLiteral(test.Errors)>, this.stderrDuringParse);
+	<else>
+	assertNull(this.stderrDuringParse);
+	<endif>
+    }>
+}
+>>
+
+CompositeParserTestMethod(test) ::= <<
+<ParserTestMethod(test)>
+>>
+
+AbstractParserTestMethod(test) ::= <<
+/* this file and method are generated, any edit will be overwritten by the next generation */
+String test<test.name>(String input) throws Exception {
+	String grammar = <test.grammar.lines:{ line | "<line>};separator="\\n\" +\n", wrap, anchor>";
+	return execParser("<test.grammar.grammarName>.g4", grammar, "<test.grammar.grammarName>Parser",
+                      "<test.grammar.grammarName>Listener", "<test.grammar.grammarName>Visitor",
+	                  "<test.grammar.grammarName>Lexer", "<test.startRule>", input, <test.debug>);
+}
+
+>>
+
+ConcreteParserTestMethod(test) ::= <<
+/* this file and method are generated, any edit will be overwritten by the next generation */
+@Test
+public void test<test.name>() throws Exception {
+	String found = test<test.baseName>("<test.input>");
+	assertEquals("<test.expectedOutput>", found);
+	<if(test.expectedErrors)>
+	assertEquals("<test.expectedErrors>", this.stderrDuringParse);
+	<else>
+	assertNull(this.stderrDuringParse);
+	<endif>
+}
+
+>>
+
+testAnnotations(test) ::= <%
+@Test
+<if(test.Options.("Ignore"))>
+<\n>@Ignore(<writeStringLiteral(test.Options.("Ignore"))>)
+<elseif(IgnoredTests.(({<file.name>.<test.name>})))>
+<\n>@Ignore(<writeStringLiteral(IgnoredTests.(({<file.name>.<test.name>})))>)
+<endif>
+%>
+
+buildStringLiteral(text, variable) ::= <<
+StringBuilder <variable>Builder = new StringBuilder(<strlen.(text)>);
+<lines.(text):{line|<variable>Builder.append("<escape.(line)>");}; separator="\n">
+String <variable> = <variable>Builder.toString();
+>>
+
+writeStringLiteral(text) ::= <%
+<if(isEmpty.(text))>
+""
+<else>
+<writeLines(lines.(text))>
+<endif>
+%>
+
+writeLines(textLines) ::= <%
+<if(rest(textLines))>
+<textLines:{line|
+<\n>		"<escape.(line)>}; separator="\" +">"
+<else>
+"<escape.(first(textLines))>"
+<endif>
+%>
+
+string(text) ::= <<
+"<escape.(text)>"
+>>
+
+writeBoolean(o) ::= "<if(o && !isEmpty.(o))>true<else>false<endif>"
+
+writeln(s) ::= <<document.getElementById('output').value += <s> + '\\n';>>
+
+write(s) ::= <<document.getElementById('output').value += <s>;>>
+
+False() ::= "false"
+
+True() ::= "true"
+
+Not(v) ::= "!<v>"
+
+Assert(s) ::= ""
+
+Cast(t,v) ::= "<v>"
+
+Append(a,b) ::= "<a> + <b>"
+
+Concat(a,b) ::= "<a><b>"
+
+DeclareLocal(s,v) ::= "var <s> = <v>;"
+
+AssertIsList(v) ::= <<if ( !(v instanceof Array) ) {throw "value is not an array"}>>
+
+AssignLocal(s,v) ::= "<s> = <v>;"
+
+InitIntMember(n,v) ::= <%this.<n> = <v>;%>
+
+InitBooleanMember(n,v) ::= <%this.<n> = <v>;%>
+
+GetMember(n) ::= <%this.<n>%>
+
+SetMember(n,v) ::= <%this.<n> = <v>;%>
+
+AddMember(n,v) ::= <%this.<n> += <v>;%>
+
+PlusMember(v,n) ::= <%<v> + this.<n>%>
+
+MemberEquals(n,v) ::= <%this.<n> === <v>%>
+
+ModMemberEquals(n,m,v) ::= <%this.<n> % <m> === <v>%>
+
+ModMemberNotEquals(n,m,v) ::= <%this.<n> % <m> != <v>%>
+
+CheckVectorContext(s,v) ::= "<s> = [].concat(<v>);"
+
+DumpDFA() ::= "this.dumpDFA();"
+
+Pass() ::= ""
+
+StringList() ::= "list"
+
+BuildParseTrees() ::= "this.buildParseTrees = true;"
+
+BailErrorStrategy() ::= <%this._errHandler = new antlr4.error.BailErrorStrategy();%>
+
+ToStringTree(s) ::= <%<s>.toStringTree(null, this)%>
+
+Column() ::= "this.column"
+
+Text() ::= "this.text"
+
+ValEquals(a,b) ::= <%<a>===<b>%>
+
+TextEquals(a) ::= <%this.text==="<a>"%>
+
+PlusText(a) ::= <%"<a>" + this.text%>
+
+InputText() ::= "this._input.getText()"
+
+LTEquals(i, v) ::= <%this._input.LT(<i>).text===<v>%>
+
+LANotEquals(i, v) ::= <%this._input.LA(<i>)!=<v>%>
+
+TokenStartColumnEquals(i) ::= <%this._tokenStartColumn===<i>%>
+
+ImportListener(X) ::= <<var <X>Listener = require('./<X>Listener').<X>Listener;>>
+
+GetExpectedTokenNames() ::= "this.getExpectedTokens().toString(this.literalNames)"
+
+RuleInvocationStack() ::= "antlr4.Utils.arrayToString(this.getRuleInvocationStack())"
+
+LL_EXACT_AMBIG_DETECTION() ::= <<this._interp.predictionMode = antlr4.atn.PredictionMode.LL_EXACT_AMBIG_DETECTION;>>
+
+ParserPropertyMember() ::= <<
+@members {
+this.Property = function() {
+    return true;
+}
+}
+>>
+
+PositionAdjustingLexer() ::= <<
+
+PositionAdjustingLexer.prototype.resetAcceptPosition = function(index, line, column) {
+	this._input.seek(index);
+	this.line = line;
+	this.column = column;
+	this._interp.consume(this._input);
+};
+
+PositionAdjustingLexer.prototype.nextToken = function() {
+	if (!("resetAcceptPosition" in this._interp)) {
+		var lexer = this;
+		this._interp.resetAcceptPosition = function(index, line, column) { lexer.resetAcceptPosition(index, line, column); };
+	}
+	return antlr4.Lexer.prototype.nextToken.call(this);
+};
+
+PositionAdjustingLexer.prototype.emit = function() {
+	switch(this._type) {
+	case PositionAdjustingLexer.TOKENS:
+		this.handleAcceptPositionForKeyword("tokens");
+		break;
+	case PositionAdjustingLexer.LABEL:
+		this.handleAcceptPositionForIdentifier();
+		break;
+	}
+	return antlr4.Lexer.prototype.emit.call(this);
+};
+
+PositionAdjustingLexer.prototype.handleAcceptPositionForIdentifier = function() {
+	var tokenText = this.text;
+	var identifierLength = 0;
+	while (identifierLength \< tokenText.length &&
+		PositionAdjustingLexer.isIdentifierChar(tokenText[identifierLength])
+	) {
+		identifierLength += 1;
+	}
+	if (this._input.index > this._tokenStartCharIndex + identifierLength) {
+		var offset = identifierLength - 1;
+		this._interp.resetAcceptPosition(this._tokenStartCharIndex + offset,
+				this._tokenStartLine, this._tokenStartColumn + offset);
+		return true;
+	} else {
+		return false;
+	}
+};
+
+PositionAdjustingLexer.prototype.handleAcceptPositionForKeyword = function(keyword) {
+	if (this._input.index > this._tokenStartCharIndex + keyword.length) {
+		var offset = keyword.length - 1;
+		this._interp.resetAcceptPosition(this._tokenStartCharIndex + offset,
+			this._tokenStartLine, this._tokenStartColumn + offset);
+		return true;
+	} else {
+		return false;
+	}
+};
+
+PositionAdjustingLexer.isIdentifierChar = function(c) {
+	return c.match(/^[0-9a-zA-Z_]+$/);
+}
+
+>>
+
+BasicListener(X) ::= <<
+this.LeafListener = function() {
+    this.visitTerminal = function(node) {
+    	document.getElementById('output').value += node.symbol.text + '\\n';
+    };
+    return this;
+};
+this.LeafListener.prototype = Object.create(<X>Listener.prototype);
+this.LeafListener.prototype.constructor = this.LeafListener;
+
+>>
+
+WalkListener(s) ::= <<
+var walker = new antlr4.tree.ParseTreeWalker();
+walker.walk(new this.LeafListener(), <s>);
+>>
+
+TreeNodeWithAltNumField(X) ::= <<
+
+@parser::header {
+MyRuleNode = function(parent, invokingState) {
+	antlr4.ParserRuleContext.call(this, parent, invokingState);
+	this.altNum = 0;
+	return this;
+};
+
+MyRuleNode.prototype = Object.create(antlr4.ParserRuleContext.prototype);
+MyRuleNode.prototype.constructor = MyRuleNode;
+}
+>>
+
+TokenGetterListener(X) ::= <<
+this.LeafListener = function() {
+    this.exitA = function(ctx) {
+    	var str;
+        if(ctx.getChildCount()===2) {
+            str = ctx.INT(0).symbol.text + ' ' + ctx.INT(1).symbol.text + ' ' + antlr4.Utils.arrayToString(ctx.INT());
+        } else {
+            str = ctx.ID().symbol.toString();
+        }
+    	document.getElementById('output').value += str + '\\n';
+    };
+    return this;
+};
+this.LeafListener.prototype = Object.create(<X>Listener.prototype);
+this.LeafListener.prototype.constructor = this.LeafListener;
+
+>>
+
+RuleGetterListener(X) ::= <<
+this.LeafListener = function() {
+    this.exitA = function(ctx) {
+    	var str;
+        if(ctx.getChildCount()===2) {
+            str = ctx.b(0).start.text + ' ' + ctx.b(1).start.text + ' ' + ctx.b()[0].start.text;
+        } else {
+            str = ctx.b(0).start.text;
+        }
+    	document.getElementById('output').value += str + '\\n';
+    };
+    return this;
+};
+this.LeafListener.prototype = Object.create(<X>Listener.prototype);
+this.LeafListener.prototype.constructor = this.LeafListener;
+
+>>
+
+
+LRListener(X) ::= <<
+this.LeafListener = function() {
+    this.exitE = function(ctx) {
+    	var str;
+        if(ctx.getChildCount()===3) {
+            str = ctx.e(0).start.text + ' ' + ctx.e(1).start.text + ' ' + ctx.e()[0].start.text;
+        } else {
+            str = ctx.INT().symbol.text;
+        }
+    	document.getElementById('output').value += str + '\\n';
+    };
+    return this;
+};
+this.LeafListener.prototype = Object.create(<X>Listener.prototype);
+this.LeafListener.prototype.constructor = this.LeafListener;
+
+>>
+
+LRWithLabelsListener(X) ::= <<
+this.LeafListener = function() {
+    this.exitCall = function(ctx) {
+    	var str = ctx.e().start.text + ' ' + ctx.eList();
+    	document.getElementById('output').value += str + '\\n';
+    };
+    this.exitInt = function(ctx) {
+        var str = ctx.INT().symbol.text;
+    	document.getElementById('output').value += str + '\\n';
+    };
+    return this;
+};
+this.LeafListener.prototype = Object.create(<X>Listener.prototype);
+this.LeafListener.prototype.constructor = this.LeafListener;
+
+>>
+
+DeclareContextListGettersFunction() ::= <<
+	function foo() {
+		var s = new SContext();
+	    var a = s.a();
+	    var b = s.b();
+    };
+>>
+
+Declare_foo() ::= "this.foo = function() {document.getElementById('output').value += 'foo' + '\\n';};"
+
+Invoke_foo() ::= "this.foo();"
+
+Declare_pred() ::= <<this.pred = function(v) {
+	document.getElementById('output').value += 'eval=' + v.toString() + '\\n';
+	return v;
+};
+>>
+
+Invoke_pred(v) ::= <<this.pred(<v>)>>
+
+isEmpty ::= [
+	"": true,
+	default: false
+]
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/javascript/node/Node.test.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/javascript/node/Node.test.stg
new file mode 100644
index 000000000..5bca3c134
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/javascript/node/Node.test.stg
@@ -0,0 +1,438 @@
+IgnoredTests ::= [
+	default: false
+]
+
+TestFile(file) ::= <<
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.javascript.node;
+
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+<if(file.Options.("ImportErrorQueue"))>
+import org.antlr.v4.test.runtime.java.ErrorQueue;
+<endif>
+<if(file.Options.("ImportGrammar"))>
+import org.antlr.v4.tool.Grammar;
+<endif>
+
+@SuppressWarnings("unused")
+public class Test<file.name> extends BaseTest {
+
+	<file.tests:{test | <test>}; separator="\n", wrap, anchor>
+
+}<\n>
+>>
+
+LexerTestMethod(test) ::= <<
+/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+<testAnnotations(test)>
+public void test<test.name>() throws Exception {
+	mkdir(tmpdir);
+<test.SlaveGrammars:{grammar |
+	String slave_<grammar> =<writeStringLiteral(test.SlaveGrammars.(grammar))>;
+	writeFile(tmpdir, "<grammar>.g4", slave_<grammar>);
+	}; separator="\n">
+
+<test.Grammar:{grammar |
+	<buildStringLiteral(test.Grammar.(grammar), "grammar")>
+	<test.afterGrammar>
+	String input =<writeStringLiteral(test.Input)>;
+	String found = execLexer("<grammar>.g4", grammar, "<grammar><if(test.Options.("CombinedGrammar"))>Lexer<endif>", input, <writeBoolean(test.Options.("ShowDFA"))>);
+	assertEquals(<writeStringLiteral(test.Output)>, found);
+	<if(!isEmpty.(test.Errors))>
+	assertEquals(<writeStringLiteral(test.Errors)>, this.stderrDuringParse);
+	<else>
+	assertNull(this.stderrDuringParse);
+	<endif>
+    }>
+}
+>>
+
+CompositeLexerTestMethod(test) ::= <<
+<LexerTestMethod(test)>
+>>
+
+ParserTestMethod(test) ::= <<
+/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+<testAnnotations(test)>
+public void test<test.name>() throws Exception {
+	mkdir(tmpdir);
+<test.SlaveGrammars:{grammar |
+	String slave_<grammar> =<writeStringLiteral(test.SlaveGrammars.(grammar))>;
+<if(test.Options.("SlaveIsLexer"))>
+	rawGenerateAndBuildRecognizer("<grammar>.g4", slave_<grammar>, null, "<grammar>");
+<else>
+	writeFile(tmpdir, "<grammar>.g4", slave_<grammar>);
+<endif>
+	}; separator="\n">
+<test.Grammar:{grammar |
+	<buildStringLiteral(test.Grammar.(grammar), "grammar")>
+	<test.afterGrammar>
+	String input =<writeStringLiteral(test.Input)>;
+	String found = execParser("<grammar>.g4", grammar, "<grammar>Parser", "<grammar>Lexer",
+	                          "<grammar>Listener", "<grammar>Visitor",
+	                          "<test.Rule>", input, <writeBoolean(test.Options.("Debug"))>);
+	assertEquals(<writeStringLiteral(test.Output)>, found);
+	<if(!isEmpty.(test.Errors))>
+	assertEquals(<writeStringLiteral(test.Errors)>, this.stderrDuringParse);
+	<else>
+	assertNull(this.stderrDuringParse);
+	<endif>
+    }>
+}
+>>
+
+CompositeParserTestMethod(test) ::= <<
+<ParserTestMethod(test)>
+>>
+
+AbstractParserTestMethod(test) ::= <<
+/* this file and method are generated, any edit will be overwritten by the next generation */
+String test<test.name>(String input) throws Exception {
+	String grammar = <test.grammar.lines:{ line | "<line>};separator="\\n\" +\n", wrap, anchor>";
+	return execParser("<test.grammar.grammarName>.g4", grammar, "<test.grammar.grammarName>Parser",
+                      "<test.grammar.grammarName>Listener", "<test.grammar.grammarName>Visitor",
+	                  "<test.grammar.grammarName>Lexer", "<test.startRule>", input, <test.debug>);
+}
+
+>>
+
+ConcreteParserTestMethod(test) ::= <<
+/* this file and method are generated, any edit will be overwritten by the next generation */
+@Test
+public void test<test.name>() throws Exception {
+	String found = test<test.baseName>("<test.input>");
+	assertEquals("<test.expectedOutput>", found);
+	<if(test.expectedErrors)>
+	assertEquals("<test.expectedErrors>", this.stderrDuringParse);
+	<else>
+	assertNull(this.stderrDuringParse);
+	<endif>
+}
+
+>>
+
+testAnnotations(test) ::= <%
+@Test
+<if(test.Options.("Ignore"))>
+<\n>@Ignore(<writeStringLiteral(test.Options.("Ignore"))>)
+<elseif(IgnoredTests.(({<file.name>.<test.name>})))>
+<\n>@Ignore(<writeStringLiteral(IgnoredTests.(({<file.name>.<test.name>})))>)
+<endif>
+%>
+
+buildStringLiteral(text, variable) ::= <<
+StringBuilder <variable>Builder = new StringBuilder(<strlen.(text)>);
+<lines.(text):{line|<variable>Builder.append("<escape.(line)>");}; separator="\n">
+String <variable> = <variable>Builder.toString();
+>>
+
+writeStringLiteral(text) ::= <%
+<if(isEmpty.(text))>
+""
+<else>
+<writeLines(lines.(text))>
+<endif>
+%>
+
+writeLines(textLines) ::= <%
+<if(rest(textLines))>
+<textLines:{line|
+<\n>		"<escape.(line)>}; separator="\" +">"
+<else>
+"<escape.(first(textLines))>"
+<endif>
+%>
+
+string(text) ::= <<
+"<escape.(text)>"
+>>
+
+writeBoolean(o) ::= "<if(o && !isEmpty.(o))>true<else>false<endif>"
+
+writeln(s) ::= <<console.log(<s>);>>
+
+write(s) ::= <<process.stdout.write(<s>);>>
+
+False() ::= "false"
+
+True() ::= "true"
+
+Not(v) ::= "!<v>"
+
+Assert(s) ::= <<console.assert(<s>);>>
+
+Cast(t,v) ::= "<v>"
+
+Append(a,b) ::= "<a> + <b>"
+
+Concat(a,b) ::= "<a><b>"
+
+DeclareLocal(s,v) ::= "var <s> = <v>;"
+
+AssertIsList(v) ::= <<if ( !(v instanceof Array) ) {throw "value is not an array";}>>
+
+AssignLocal(s,v) ::= "<s> = <v>;"
+
+InitIntMember(n,v) ::= <%this.<n> = <v>;%>
+
+InitBooleanMember(n,v) ::= <%this.<n> = <v>;%>
+
+GetMember(n) ::= <%this.<n>%>
+
+SetMember(n,v) ::= <%this.<n> = <v>;%>
+
+AddMember(n,v) ::= <%this.<n> += <v>;%>
+
+PlusMember(v,n) ::= <%<v> + this.<n>%>
+
+MemberEquals(n,v) ::= <%this.<n> === <v>%>
+
+ModMemberEquals(n,m,v) ::= <%this.<n> % <m> === <v>%>
+
+ModMemberNotEquals(n,m,v) ::= <%this.<n> % <m> != <v>%>
+
+DumpDFA() ::= "this.dumpDFA();"
+
+Pass() ::= ""
+
+StringList() ::= "list"
+
+BuildParseTrees() ::= "this.buildParseTrees = true;"
+
+BailErrorStrategy() ::= <%this._errHandler = new antlr4.error.BailErrorStrategy();%>
+
+ToStringTree(s) ::= <%<s>.toStringTree(null, this)%>
+
+Column() ::= "this.column"
+
+Text() ::= "this.text"
+
+ValEquals(a,b) ::= <%<a>===<b>%>
+
+TextEquals(a) ::= <%this.text==="<a>"%>
+
+PlusText(a) ::= <%"<a>" + this.text%>
+
+InputText() ::= "this._input.getText()"
+
+LTEquals(i, v) ::= <%this._input.LT(<i>).text===<v>%>
+
+LANotEquals(i, v) ::= <%this._input.LA(<i>)!=<v>%>
+
+TokenStartColumnEquals(i) ::= <%this._tokenStartColumn===<i>%>
+
+ImportListener(X) ::= <<var <X>Listener = require('./<X>Listener').<X>Listener;>>
+
+GetExpectedTokenNames() ::= "this.getExpectedTokens().toString(this.literalNames)"
+
+RuleInvocationStack() ::= "antlr4.Utils.arrayToString(this.getRuleInvocationStack())"
+
+LL_EXACT_AMBIG_DETECTION() ::= <<this._interp.predictionMode = antlr4.atn.PredictionMode.LL_EXACT_AMBIG_DETECTION;>>
+
+ParserPropertyMember() ::= <<
+@members {
+this.Property = function() {
+    return true;
+}
+}
+>>
+
+PositionAdjustingLexer() ::= <<
+
+PositionAdjustingLexer.prototype.resetAcceptPosition = function(index, line, column) {
+	this._input.seek(index);
+	this.line = line;
+	this.column = column;
+	this._interp.consume(this._input);
+};
+
+PositionAdjustingLexer.prototype.nextToken = function() {
+	if (!("resetAcceptPosition" in this._interp)) {
+		var lexer = this;
+		this._interp.resetAcceptPosition = function(index, line, column) { lexer.resetAcceptPosition(index, line, column); };
+	}
+	return antlr4.Lexer.prototype.nextToken.call(this);
+};
+
+PositionAdjustingLexer.prototype.emit = function() {
+	switch(this._type) {
+	case PositionAdjustingLexer.TOKENS:
+		this.handleAcceptPositionForKeyword("tokens");
+		break;
+	case PositionAdjustingLexer.LABEL:
+		this.handleAcceptPositionForIdentifier();
+		break;
+	}
+	return antlr4.Lexer.prototype.emit.call(this);
+};
+
+PositionAdjustingLexer.prototype.handleAcceptPositionForIdentifier = function() {
+	var tokenText = this.text;
+	var identifierLength = 0;
+	while (identifierLength \< tokenText.length &&
+		PositionAdjustingLexer.isIdentifierChar(tokenText[identifierLength])
+	) {
+		identifierLength += 1;
+	}
+	if (this._input.index > this._tokenStartCharIndex + identifierLength) {
+		var offset = identifierLength - 1;
+		this._interp.resetAcceptPosition(this._tokenStartCharIndex + offset,
+				this._tokenStartLine, this._tokenStartColumn + offset);
+		return true;
+	} else {
+		return false;
+	}
+};
+
+PositionAdjustingLexer.prototype.handleAcceptPositionForKeyword = function(keyword) {
+	if (this._input.index > this._tokenStartCharIndex + keyword.length) {
+		var offset = keyword.length - 1;
+		this._interp.resetAcceptPosition(this._tokenStartCharIndex + offset,
+			this._tokenStartLine, this._tokenStartColumn + offset);
+		return true;
+	} else {
+		return false;
+	}
+};
+
+PositionAdjustingLexer.isIdentifierChar = function(c) {
+	return c.match(/^[0-9a-zA-Z_]+$/);
+}
+
+>>
+
+BasicListener(X) ::= <<
+this.LeafListener = function() {
+    this.visitTerminal = function(node) {
+    	console.log(node.symbol.text);
+    };
+    return this;
+};
+this.LeafListener.prototype = Object.create(<X>Listener.prototype);
+this.LeafListener.prototype.constructor = this.LeafListener;
+
+>>
+
+WalkListener(s) ::= <<
+var walker = new antlr4.tree.ParseTreeWalker();
+walker.walk(new this.LeafListener(), <s>);
+>>
+
+TreeNodeWithAltNumField(X) ::= <<
+
+@parser::header {
+MyRuleNode = function(parent, invokingState) {
+	antlr4.ParserRuleContext.call(this, parent, invokingState);
+
+	this.altNum = 0;
+	return this;
+};
+
+MyRuleNode.prototype = Object.create(antlr4.ParserRuleContext.prototype);
+MyRuleNode.prototype.constructor = MyRuleNode;
+MyRuleNode.prototype.getAltNumber = function() { return this.altNum; }
+MyRuleNode.prototype.setAltNumber = function(altNumber) { this.altNum = altNumber; }
+
+}
+>>
+
+TokenGetterListener(X) ::= <<
+this.LeafListener = function() {
+    this.exitA = function(ctx) {
+    	var str;
+        if(ctx.getChildCount()===2) {
+            str = ctx.INT(0).symbol.text + ' ' + ctx.INT(1).symbol.text + ' ' + antlr4.Utils.arrayToString(ctx.INT());
+        } else {
+            str = ctx.ID().symbol.toString();
+        }
+    	console.log(str);
+    };
+    return this;
+};
+this.LeafListener.prototype = Object.create(<X>Listener.prototype);
+this.LeafListener.prototype.constructor = this.LeafListener;
+
+>>
+
+RuleGetterListener(X) ::= <<
+this.LeafListener = function() {
+    this.exitA = function(ctx) {
+    	var str;
+        if(ctx.getChildCount()===2) {
+            str = ctx.b(0).start.text + ' ' + ctx.b(1).start.text + ' ' + ctx.b()[0].start.text;
+        } else {
+            str = ctx.b(0).start.text;
+        }
+    	console.log(str);
+    };
+    return this;
+};
+this.LeafListener.prototype = Object.create(<X>Listener.prototype);
+this.LeafListener.prototype.constructor = this.LeafListener;
+
+>>
+
+
+LRListener(X) ::= <<
+this.LeafListener = function() {
+    this.exitE = function(ctx) {
+    	var str;
+        if(ctx.getChildCount()===3) {
+            str = ctx.e(0).start.text + ' ' + ctx.e(1).start.text + ' ' + ctx.e()[0].start.text;
+        } else {
+            str = ctx.INT().symbol.text;
+        }
+    	console.log(str);
+    };
+    return this;
+};
+this.LeafListener.prototype = Object.create(<X>Listener.prototype);
+this.LeafListener.prototype.constructor = this.LeafListener;
+
+>>
+
+LRWithLabelsListener(X) ::= <<
+this.LeafListener = function() {
+    this.exitCall = function(ctx) {
+    	var str = ctx.e().start.text + ' ' + ctx.eList();
+    	console.log(str);
+    };
+    this.exitInt = function(ctx) {
+        var str = ctx.INT().symbol.text;
+        console.log(str);
+    };
+    return this;
+};
+this.LeafListener.prototype = Object.create(<X>Listener.prototype);
+this.LeafListener.prototype.constructor = this.LeafListener;
+
+>>
+
+DeclareContextListGettersFunction() ::= <<
+	function foo() {
+		var s = new SContext();
+	    var a = s.a();
+	    var b = s.b();
+    };
+>>
+
+Declare_foo() ::= "this.foo = function() {console.log('foo');};"
+
+Invoke_foo() ::= "this.foo();"
+
+Declare_pred() ::= <<this.pred = function(v) {
+	console.log("eval=" + v.toString());
+	return v;
+};
+>>
+
+Invoke_pred(v) ::= <<this.pred(<v>)>>
+
+isEmpty ::= [
+	"": true,
+	default: false
+]
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/javascript/safari/Safari.test.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/javascript/safari/Safari.test.stg
new file mode 100644
index 000000000..c05024066
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/javascript/safari/Safari.test.stg
@@ -0,0 +1,435 @@
+IgnoredTests ::= [
+	default: false
+]
+
+TestFile(file) ::= <<
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.javascript.safari;
+
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+<if(file.Options.("ImportErrorQueue"))>
+import org.antlr.v4.test.runtime.java.ErrorQueue;
+<endif>
+<if(file.Options.("ImportGrammar"))>
+import org.antlr.v4.tool.Grammar;
+<endif>
+
+@SuppressWarnings("unused")
+public class Test<file.name> extends BaseTest {
+
+	<file.tests:{test | <test>}; separator="\n", wrap, anchor>
+
+}<\n>
+>>
+
+LexerTestMethod(test) ::= <<
+/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+<testAnnotations(test)>
+public void test<test.name>() throws Exception {
+	mkdir(tmpdir);
+<test.SlaveGrammars:{grammar |
+	String slave_<grammar> =<writeStringLiteral(test.SlaveGrammars.(grammar))>;
+	writeFile(tmpdir, "<grammar>.g4", slave_<grammar>);
+	}; separator="\n">
+
+<test.Grammar:{grammar |
+	<buildStringLiteral(test.Grammar.(grammar), "grammar")>
+	<test.afterGrammar>
+	String input =<writeStringLiteral(test.Input)>;
+	String found = execLexer("<grammar>.g4", grammar, "<grammar><if(test.Options.("CombinedGrammar"))>Lexer<endif>", input, <writeBoolean(test.Options.("ShowDFA"))>);
+	assertEquals(<writeStringLiteral(test.Output)>, found);
+	<if(!isEmpty.(test.Errors))>
+	assertEquals(<writeStringLiteral(test.Errors)>, this.stderrDuringParse);
+	<else>
+	assertNull(this.stderrDuringParse);
+	<endif>
+    }>
+}
+>>
+
+CompositeLexerTestMethod(test) ::= <<
+<LexerTestMethod(test)>
+>>
+
+ParserTestMethod(test) ::= <<
+/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+<testAnnotations(test)>
+public void test<test.name>() throws Exception {
+	mkdir(tmpdir);
+<test.SlaveGrammars:{grammar |
+	String slave_<grammar> =<writeStringLiteral(test.SlaveGrammars.(grammar))>;
+<if(test.Options.("SlaveIsLexer"))>
+	rawGenerateAndBuildRecognizer("<grammar>.g4", slave_<grammar>, null, "<grammar>");
+<else>
+	writeFile(tmpdir, "<grammar>.g4", slave_<grammar>);
+<endif>
+	}; separator="\n">
+<test.Grammar:{grammar |
+	<buildStringLiteral(test.Grammar.(grammar), "grammar")>
+	<test.afterGrammar>
+	String input =<writeStringLiteral(test.Input)>;
+	String found = execParser("<grammar>.g4", grammar, "<grammar>Parser", "<grammar>Lexer",
+	                          "<grammar>Listener", "<grammar>Visitor",
+	                          "<test.Rule>", input, <writeBoolean(test.Options.("Debug"))>);
+	assertEquals(<writeStringLiteral(test.Output)>, found);
+	<if(!isEmpty.(test.Errors))>
+	assertEquals(<writeStringLiteral(test.Errors)>, this.stderrDuringParse);
+	<else>
+	assertNull(this.stderrDuringParse);
+	<endif>
+    }>
+}
+>>
+
+CompositeParserTestMethod(test) ::= <<
+<ParserTestMethod(test)>
+>>
+
+AbstractParserTestMethod(test) ::= <<
+/* this file and method are generated, any edit will be overwritten by the next generation */
+String test<test.name>(String input) throws Exception {
+	String grammar = <test.grammar.lines:{ line | "<line>};separator="\\n\" +\n", wrap, anchor>";
+	return execParser("<test.grammar.grammarName>.g4", grammar, "<test.grammar.grammarName>Parser",
+                      "<test.grammar.grammarName>Listener", "<test.grammar.grammarName>Visitor",
+	                  "<test.grammar.grammarName>Lexer", "<test.startRule>", input, <test.debug>);
+}
+
+>>
+
+ConcreteParserTestMethod(test) ::= <<
+/* this file and method are generated, any edit will be overwritten by the next generation */
+@Test
+public void test<test.name>() throws Exception {
+	String found = test<test.baseName>("<test.input>");
+	assertEquals("<test.expectedOutput>", found);
+	<if(test.expectedErrors)>
+	assertEquals("<test.expectedErrors>", this.stderrDuringParse);
+	<else>
+	assertNull(this.stderrDuringParse);
+	<endif>
+}
+
+>>
+
+testAnnotations(test) ::= <%
+@Test
+<if(test.Options.("Ignore"))>
+<\n>@Ignore(<writeStringLiteral(test.Options.("Ignore"))>)
+<elseif(IgnoredTests.(({<file.name>.<test.name>})))>
+<\n>@Ignore(<writeStringLiteral(IgnoredTests.(({<file.name>.<test.name>})))>)
+<endif>
+%>
+
+buildStringLiteral(text, variable) ::= <<
+StringBuilder <variable>Builder = new StringBuilder(<strlen.(text)>);
+<lines.(text):{line|<variable>Builder.append("<escape.(line)>");}; separator="\n">
+String <variable> = <variable>Builder.toString();
+>>
+
+writeStringLiteral(text) ::= <%
+<if(isEmpty.(text))>
+""
+<else>
+<writeLines(lines.(text))>
+<endif>
+%>
+
+writeLines(textLines) ::= <%
+<if(rest(textLines))>
+<textLines:{line|
+<\n>		"<escape.(line)>}; separator="\" +">"
+<else>
+"<escape.(first(textLines))>"
+<endif>
+%>
+
+string(text) ::= <<
+"<escape.(text)>"
+>>
+
+writeBoolean(o) ::= "<if(o && !isEmpty.(o))>true<else>false<endif>"
+
+writeln(s) ::= <<document.getElementById('output').value += <s> + '\\n';>>
+
+write(s) ::= <<document.getElementById('output').value += <s>;>>
+
+False() ::= "false"
+
+True() ::= "true"
+
+Not(v) ::= "!<v>"
+
+Assert(s) ::= ""
+
+Cast(t,v) ::= "<v>"
+
+Append(a,b) ::= "<a> + <b>"
+
+Concat(a,b) ::= "<a><b>"
+
+DeclareLocal(s,v) ::= "var <s> = <v>;"
+
+AssertIsList(v) ::= <<if ( !(v instanceof Array) ) {throw "value is not an array";}>>
+
+AssignLocal(s,v) ::= "<s> = <v>;"
+
+InitIntMember(n,v) ::= <%this.<n> = <v>;%>
+
+InitBooleanMember(n,v) ::= <%this.<n> = <v>;%>
+
+GetMember(n) ::= <%this.<n>%>
+
+SetMember(n,v) ::= <%this.<n> = <v>;%>
+
+AddMember(n,v) ::= <%this.<n> += <v>;%>
+
+PlusMember(v,n) ::= <%<v> + this.<n>%>
+
+MemberEquals(n,v) ::= <%this.<n> === <v>%>
+
+ModMemberEquals(n,m,v) ::= <%this.<n> % <m> === <v>%>
+
+ModMemberNotEquals(n,m,v) ::= <%this.<n> % <m> != <v>%>
+
+DumpDFA() ::= "this.dumpDFA();"
+
+Pass() ::= ""
+
+StringList() ::= "list"
+
+BuildParseTrees() ::= "this.buildParseTrees = true;"
+
+BailErrorStrategy() ::= <%this._errHandler = new antlr4.error.BailErrorStrategy();%>
+
+ToStringTree(s) ::= <%<s>.toStringTree(null, this)%>
+
+Column() ::= "this.column"
+
+Text() ::= "this.text"
+
+ValEquals(a,b) ::= <%<a>===<b>%>
+
+TextEquals(a) ::= <%this.text==="<a>"%>
+
+PlusText(a) ::= <%"<a>" + this.text%>
+
+InputText() ::= "this._input.getText()"
+
+LTEquals(i, v) ::= <%this._input.LT(<i>).text===<v>%>
+
+LANotEquals(i, v) ::= <%this._input.LA(<i>)!=<v>%>
+
+TokenStartColumnEquals(i) ::= <%this._tokenStartColumn===<i>%>
+
+ImportListener(X) ::= <<var <X>Listener = require('./<X>Listener').<X>Listener;>>
+
+GetExpectedTokenNames() ::= "this.getExpectedTokens().toString(this.literalNames)"
+
+RuleInvocationStack() ::= "antlr4.Utils.arrayToString(this.getRuleInvocationStack())"
+
+LL_EXACT_AMBIG_DETECTION() ::= <<this._interp.predictionMode = antlr4.atn.PredictionMode.LL_EXACT_AMBIG_DETECTION;>>
+
+ParserPropertyMember() ::= <<
+@members {
+this.Property = function() {
+    return true;
+}
+}
+>>
+
+PositionAdjustingLexer() ::= <<
+
+PositionAdjustingLexer.prototype.resetAcceptPosition = function(index, line, column) {
+	this._input.seek(index);
+	this.line = line;
+	this.column = column;
+	this._interp.consume(this._input);
+};
+
+PositionAdjustingLexer.prototype.nextToken = function() {
+	if (!("resetAcceptPosition" in this._interp)) {
+		var lexer = this;
+		this._interp.resetAcceptPosition = function(index, line, column) { lexer.resetAcceptPosition(index, line, column); };
+	}
+	return antlr4.Lexer.prototype.nextToken.call(this);
+};
+
+PositionAdjustingLexer.prototype.emit = function() {
+	switch(this._type) {
+	case PositionAdjustingLexer.TOKENS:
+		this.handleAcceptPositionForKeyword("tokens");
+		break;
+	case PositionAdjustingLexer.LABEL:
+		this.handleAcceptPositionForIdentifier();
+		break;
+	}
+	return antlr4.Lexer.prototype.emit.call(this);
+};
+
+PositionAdjustingLexer.prototype.handleAcceptPositionForIdentifier = function() {
+	var tokenText = this.text;
+	var identifierLength = 0;
+	while (identifierLength \< tokenText.length &&
+		PositionAdjustingLexer.isIdentifierChar(tokenText[identifierLength])
+	) {
+		identifierLength += 1;
+	}
+	if (this._input.index > this._tokenStartCharIndex + identifierLength) {
+		var offset = identifierLength - 1;
+		this._interp.resetAcceptPosition(this._tokenStartCharIndex + offset,
+				this._tokenStartLine, this._tokenStartColumn + offset);
+		return true;
+	} else {
+		return false;
+	}
+};
+
+PositionAdjustingLexer.prototype.handleAcceptPositionForKeyword = function(keyword) {
+	if (this._input.index > this._tokenStartCharIndex + keyword.length) {
+		var offset = keyword.length - 1;
+		this._interp.resetAcceptPosition(this._tokenStartCharIndex + offset,
+			this._tokenStartLine, this._tokenStartColumn + offset);
+		return true;
+	} else {
+		return false;
+	}
+};
+
+PositionAdjustingLexer.isIdentifierChar = function(c) {
+	return c.match(/^[0-9a-zA-Z_]+$/);
+}
+
+>>
+
+BasicListener(X) ::= <<
+this.LeafListener = function() {
+    this.visitTerminal = function(node) {
+    	document.getElementById('output').value += node.symbol.text + '\\n';
+    };
+    return this;
+};
+this.LeafListener.prototype = Object.create(<X>Listener.prototype);
+this.LeafListener.prototype.constructor = this.LeafListener;
+
+>>
+
+WalkListener(s) ::= <<
+var walker = new antlr4.tree.ParseTreeWalker();
+walker.walk(new this.LeafListener(), <s>);
+>>
+
+TreeNodeWithAltNumField(X) ::= <<
+
+@parser::header {
+MyRuleNode = function(parent, invokingState) {
+	antlr4.ParserRuleContext.call(this, parent, invokingState);
+	this.altNum = 0;
+	return this;
+};
+
+MyRuleNode.prototype = Object.create(antlr4.ParserRuleContext.prototype);
+MyRuleNode.prototype.constructor = MyRuleNode;
+}
+>>
+
+
+TokenGetterListener(X) ::= <<
+this.LeafListener = function() {
+    this.exitA = function(ctx) {
+    	var str;
+        if(ctx.getChildCount()===2) {
+            str = ctx.INT(0).symbol.text + ' ' + ctx.INT(1).symbol.text + ' ' + antlr4.Utils.arrayToString(ctx.INT());
+        } else {
+            str = ctx.ID().symbol.toString();
+        }
+    	document.getElementById('output').value += str + '\\n';
+    };
+    return this;
+};
+this.LeafListener.prototype = Object.create(<X>Listener.prototype);
+this.LeafListener.prototype.constructor = this.LeafListener;
+
+>>
+
+RuleGetterListener(X) ::= <<
+this.LeafListener = function() {
+    this.exitA = function(ctx) {
+    	var str;
+        if(ctx.getChildCount()===2) {
+            str = ctx.b(0).start.text + ' ' + ctx.b(1).start.text + ' ' + ctx.b()[0].start.text;
+        } else {
+            str = ctx.b(0).start.text;
+        }
+    	document.getElementById('output').value += str + '\\n';
+    };
+    return this;
+};
+this.LeafListener.prototype = Object.create(<X>Listener.prototype);
+this.LeafListener.prototype.constructor = this.LeafListener;
+
+>>
+
+
+LRListener(X) ::= <<
+this.LeafListener = function() {
+    this.exitE = function(ctx) {
+    	var str;
+        if(ctx.getChildCount()===3) {
+            str = ctx.e(0).start.text + ' ' + ctx.e(1).start.text + ' ' + ctx.e()[0].start.text;
+        } else {
+            str = ctx.INT().symbol.text;
+        }
+    	document.getElementById('output').value += str + '\\n';
+    };
+    return this;
+};
+this.LeafListener.prototype = Object.create(<X>Listener.prototype);
+this.LeafListener.prototype.constructor = this.LeafListener;
+
+>>
+
+LRWithLabelsListener(X) ::= <<
+this.LeafListener = function() {
+    this.exitCall = function(ctx) {
+    	var str = ctx.e().start.text + ' ' + ctx.eList();
+    	document.getElementById('output').value += str + '\\n';
+    };
+    this.exitInt = function(ctx) {
+        var str = ctx.INT().symbol.text;
+    	document.getElementById('output').value += str + '\\n';
+    };
+    return this;
+};
+this.LeafListener.prototype = Object.create(<X>Listener.prototype);
+this.LeafListener.prototype.constructor = this.LeafListener;
+
+>>
+
+DeclareContextListGettersFunction() ::= <<
+	function foo() {
+		var s = new SContext();
+	    var a = s.a();
+	    var b = s.b();
+    };
+>>
+
+Declare_foo() ::= "this.foo = function() {document.getElementById('output').value += 'foo' + '\\n';};"
+
+Invoke_foo() ::= "this.foo();"
+
+Declare_pred() ::= <<this.pred = function(v) {
+	document.getElementById('output').value += 'eval=' + v.toString() + '\\n';
+	return v;
+};
+>>
+
+Invoke_pred(v) ::= <<this.pred(<v>)>>
+
+isEmpty ::= [
+	"": true,
+	default: false
+]
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/python2/Python2.test.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/python2/Python2.test.stg
new file mode 100644
index 000000000..c86f4a646
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/python2/Python2.test.stg
@@ -0,0 +1,412 @@
+IgnoredTests ::= [
+	default: false
+]
+
+TestFile(file) ::= <<
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.python2;
+
+import org.junit.Ignore;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+<if(file.Options.("ImportErrorQueue"))>
+import org.antlr.v4.test.runtime.java.ErrorQueue;
+<endif>
+<if(file.Options.("ImportGrammar"))>
+import org.antlr.v4.tool.Grammar;
+<endif>
+
+@SuppressWarnings("unused")
+public class Test<file.name> extends BasePython2Test {
+
+	<file.tests:{test | <test>}; separator="\n", wrap, anchor>
+
+}
+>>
+
+LexerTestMethod(test) ::= <<
+/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+<testAnnotations(test)>
+public void test<test.name>() throws Exception {
+	mkdir(tmpdir);
+
+<test.SlaveGrammars:{grammar |
+	String slave_<grammar> =<writeStringLiteral(test.SlaveGrammars.(grammar))>;
+	writeFile(tmpdir, "<grammar>.g4", slave_<grammar>);
+	}; separator="\n">
+<test.Grammar:{grammar |
+	<buildStringLiteral(test.Grammar.(grammar), "grammar")>
+
+<if(test.AfterGrammar)>
+	<test.AfterGrammar>
+<endif>
+	String input =<writeStringLiteral(test.Input)>;
+	String found = execLexer("<grammar>.g4", grammar, "<grammar><if(test.Options.("CombinedGrammar"))>Lexer<endif>", input, <writeBoolean(test.Options.("ShowDFA"))>);
+	assertEquals(<writeStringLiteral(test.Output)>, found);
+	<if(!isEmpty.(test.Errors))>
+	assertEquals(<writeStringLiteral(test.Errors)>, this.stderrDuringParse);
+	<else>
+	assertNull(this.stderrDuringParse);
+	<endif>
+	}>
+}
+
+>>
+
+CompositeLexerTestMethod(test) ::= <<
+<LexerTestMethod(test)>
+>>
+
+ParserTestMethod(test) ::= <<
+/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+<testAnnotations(test)>
+public void test<test.name>() throws Exception {
+	mkdir(tmpdir);
+
+<test.SlaveGrammars:{grammar |
+	String slave_<grammar> =<writeStringLiteral(test.SlaveGrammars.(grammar))>;
+<if(test.Options.("SlaveIsLexer"))>
+	rawGenerateAndBuildRecognizer("<grammar>.g4", slave_<grammar>, null, "<grammar>");
+<else>
+	writeFile(tmpdir, "<grammar>.g4", slave_<grammar>);
+<endif>
+	}; separator="\n">
+<test.Grammar:{grammar |
+	<buildStringLiteral(test.Grammar.(grammar), "grammar")>
+
+	<test.AfterGrammar>
+
+	String input =<writeStringLiteral(test.Input)>;
+	String found = execParser("<grammar>.g4", grammar, "<grammar><if(!test.slaveIsLexer)>Parser<endif>", "<if(test.slaveIsLexer)><first(test.slaveGrammars).grammarName><else><grammar>Lexer<endif>", "<grammar>Listener", "<grammar>Visitor", "<test.Rule>", input, <writeBoolean(test.Options.("Debug"))>);
+
+	assertEquals(<writeStringLiteral(test.Output)>, found);
+	<if(!isEmpty.(test.Errors))>
+	assertEquals(<writeStringLiteral(test.Errors)>, this.stderrDuringParse);
+	<else>
+	assertNull(this.stderrDuringParse);
+	<endif>
+	}>
+}
+
+>>
+
+CompositeParserTestMethod(test) ::= <<
+<ParserTestMethod(test)>
+>>
+
+AbstractParserTestMethod(test) ::= <<
+/* this file and method are generated, any edit will be overwritten by the next generation */
+String test<test.name>(String input) throws Exception {
+	String grammar = <test.grammar.lines:{ line | "<line>};separator="\\n\" +\n", wrap, anchor>";
+	return execParser("<test.grammar.grammarName>.g4", grammar, "<test.grammar.grammarName>Parser", "<test.grammar.grammarName>Lexer", "<test.startRule>", input, <test.debug>);
+}
+
+>>
+
+ConcreteParserTestMethod(test) ::= <<
+/* this file and method are generated, any edit will be overwritten by the next generation */
+@Test
+public void test<test.name>() throws Exception {
+	String found = test<test.baseName>("<test.input>");
+	assertEquals("<test.expectedOutput>", found);
+	<if(test.expectedErrors)>
+	assertEquals("<test.expectedErrors>", this.stderrDuringParse);
+	<else>
+	assertNull(this.stderrDuringParse);
+	<endif>
+}
+
+>>
+
+testAnnotations(test) ::= <%
+@Test
+<if(test.Options.("Ignore"))>
+<\n>@Ignore(<writeStringLiteral(test.Options.("Ignore"))>)
+<elseif(IgnoredTests.(({<file.name>.<test.name>})))>
+<\n>@Ignore(<writeStringLiteral(IgnoredTests.(({<file.name>.<test.name>})))>)
+<endif>
+%>
+
+buildStringLiteral(text, variable) ::= <<
+StringBuilder <variable>Builder = new StringBuilder(<strlen.(text)>);
+<lines.(text):{line|<variable>Builder.append("<escape.(line)>");}; separator="\n">
+String <variable> = <variable>Builder.toString();
+>>
+
+writeStringLiteral(text) ::= <%
+<if(isEmpty.(text))>
+""
+<else>
+<writeLines(lines.(text))>
+<endif>
+%>
+
+writeLines(textLines) ::= <%
+<if(rest(textLines))>
+<textLines:{line|
+<\n>		"<escape.(line)>}; separator="\" +">"
+<else>
+"<escape.(first(textLines))>"
+<endif>
+%>
+
+string(text) ::= <<
+"<escape.(text)>"
+>>
+
+writeBoolean(o) ::= "<if(o && !isEmpty.(o))>true<else>false<endif>"
+
+writeln(s) ::= <<print(<s>)>>
+
+write(s) ::= <<print(<s>,end='')>>
+
+False() ::= "False"
+
+True() ::= "True"
+
+Not(v) ::= "not <v>"
+
+Assert(s) ::= ""
+
+Cast(t,v) ::= "<v>"
+
+Append(a,b) ::= "<a> + str(<b>)"
+
+Concat(a,b) ::= "<a><b>"
+
+DeclareLocal(s,v) ::= "<s> = <v>"
+
+AssertIsList(v) ::= "assert isinstance(v, (list, tuple))"
+
+AssignLocal(s,v) ::= "<s> = <v>"
+
+InitIntMember(n,v) ::= <%<n> = <v>%>
+
+InitBooleanMember(n,v) ::= <%<n> = <v>%>
+
+GetMember(n) ::= <%self.<n>%>
+
+SetMember(n,v) ::= <%self.<n> = <v>%>
+
+AddMember(n,v) ::= <%self.<n> += <v>%>
+
+PlusMember(v,n) ::= <%<v> + str(self.<n>)%>
+
+MemberEquals(n,v) ::= <%self.<n> == <v>%>
+
+ModMemberEquals(n,m,v) ::= <%self.<n> % <m> == <v>%>
+
+ModMemberNotEquals(n,m,v) ::= <%self.<n> % <m> != <v>%>
+
+DumpDFA() ::= "self.dumpDFA()"
+
+Pass() ::= "pass"
+
+StringList() ::= ""
+
+BuildParseTrees() ::= "self._buildParseTrees = True"
+
+BailErrorStrategy() ::= <%self._errHandler = BailErrorStrategy()%>
+
+ToStringTree(s) ::= <%<s>.toStringTree(recog=self)%>
+
+Column() ::= "self.column"
+
+Text() ::= "self.text"
+
+ValEquals(a,b) ::= <%<a>==<b>%>
+
+TextEquals(a) ::= <%self.text=="<a>"%>
+
+PlusText(a) ::= <%"<a>" + self.text%>
+
+InputText() ::= "self._input.getText()"
+
+LTEquals(i, v) ::= <%self._input.LT(<i>).text==<v>%>
+
+LANotEquals(i, v) ::= <%self._input.LA(<i>)!=<v>%>
+
+TokenStartColumnEquals(i) ::= <%self._tokenStartColumn==<i>%>
+
+ImportListener(X) ::= ""
+
+GetExpectedTokenNames() ::= "self.getExpectedTokens().toString(self.literalNames, self.symbolicNames)"
+
+RuleInvocationStack() ::= "str_list(self.getRuleInvocationStack())"
+
+LL_EXACT_AMBIG_DETECTION() ::= <<self._interp.predictionMode =  PredictionMode.LL_EXACT_AMBIG_DETECTION>>
+
+ParserPropertyMember() ::= <<
+@members {
+def Property(self):
+    return True
+
+}
+>>
+
+PositionAdjustingLexer() ::= <<
+
+def resetAcceptPosition(self, index, line, column):
+	self._input.seek(index)
+	self.line = line
+	self.column = column
+	self._interp.consume(self._input)
+
+def nextToken(self):
+	if self._interp.__dict__.get("resetAcceptPosition", None) is None:
+		self._interp.__dict__["resetAcceptPosition"] = self.resetAcceptPosition
+	return super(type(self),self).nextToken()
+
+def emit(self):
+	if self._type==PositionAdjustingLexer.TOKENS:
+		self.handleAcceptPositionForKeyword("tokens")
+	elif self._type==PositionAdjustingLexer.LABEL:
+		self.handleAcceptPositionForIdentifier()
+	return super(type(self),self).emit()
+
+def handleAcceptPositionForIdentifier(self):
+	tokenText = self.text
+	identifierLength = 0
+	while identifierLength \< len(tokenText) and self.isIdentifierChar(tokenText[identifierLength]):
+		identifierLength += 1
+
+	if self._input.index > self._tokenStartCharIndex + identifierLength:
+		offset = identifierLength - 1
+		self._interp.resetAcceptPosition(self._tokenStartCharIndex + offset,
+				self._tokenStartLine, self._tokenStartColumn + offset)
+		return True
+	else:
+		return False
+
+
+def handleAcceptPositionForKeyword(self, keyword):
+	if self._input.index > self._tokenStartCharIndex + len(keyword):
+		offset = len(keyword) - 1
+		self._interp.resetAcceptPosition(self._tokenStartCharIndex + offset,
+			self._tokenStartLine, self._tokenStartColumn + offset)
+		return True
+	else:
+		return False
+
+@staticmethod
+def isIdentifierChar(c):
+	return c.isalnum() or c == '_'
+
+>>
+
+BasicListener(X) ::= <<
+if __name__ is not None and "." in __name__:
+    from .<X>Listener import <X>Listener
+else:
+    from <X>Listener import <X>Listener
+
+class LeafListener(TListener):
+    def visitTerminal(self, node):
+        print(node.symbol.text)
+
+>>
+
+WalkListener(s) ::= <<
+walker = ParseTreeWalker()
+walker.walk(TParser.LeafListener(), <s>)
+>>
+
+TreeNodeWithAltNumField(X) ::= <<
+@parser::members {
+class MyRuleNode(ParserRuleContext):
+    def __init__(self, parent = None, invokingStateNumber = None ):
+        super(<X>Parser.MyRuleNode, self).__init__(parent, invokingStateNumber)
+        self.altNum = 0;
+    def getAltNumber(self):
+        return self.altNum
+    def setAltNumber(self, altNum):
+        self.altNum = altNum
+}
+>>
+
+TokenGetterListener(X) ::= <<
+if __name__ is not None and "." in __name__:
+    from .<X>Listener import <X>Listener
+else:
+    from <X>Listener import <X>Listener
+
+class LeafListener(TListener):
+    def exitA(self, ctx):
+        if ctx.getChildCount()==2:
+            print(ctx.INT(0).symbol.text + ' ' + ctx.INT(1).symbol.text + ' ' + str_list(ctx.INT()))
+        else:
+            print(str(ctx.ID().symbol))
+
+>>
+
+RuleGetterListener(X) ::= <<
+if __name__ is not None and "." in __name__:
+    from .<X>Listener import <X>Listener
+else:
+    from <X>Listener import <X>Listener
+
+class LeafListener(TListener):
+    def exitA(self, ctx):
+        if ctx.getChildCount()==2:
+            print(ctx.b(0).start.text + ' ' + ctx.b(1).start.text + ' ' + ctx.b()[0].start.text)
+        else:
+            print(ctx.b(0).start.text)
+
+>>
+
+
+LRListener(X) ::= <<
+if __name__ is not None and "." in __name__:
+    from .<X>Listener import <X>Listener
+else:
+    from <X>Listener import <X>Listener
+
+class LeafListener(TListener):
+    def exitE(self, ctx):
+        if ctx.getChildCount()==3:
+            print(ctx.e(0).start.text + ' ' + ctx.e(1).start.text + ' ' + ctx.e()[0].start.text)
+        else:
+            print(ctx.INT().symbol.text)
+
+>>
+
+LRWithLabelsListener(X) ::= <<
+if __name__ is not None and "." in __name__:
+    from .<X>Listener import <X>Listener
+else:
+    from <X>Listener import <X>Listener
+
+class LeafListener(TListener):
+    def exitCall(self, ctx):
+        print(ctx.e().start.text + ' ' + str(ctx.eList()))
+    def exitInt(self, ctx):
+        print(ctx.INT().symbol.text)
+
+>>
+
+DeclareContextListGettersFunction() ::= <<
+def foo():
+    s = SContext()
+    a = s.a()
+    b = s.b()
+>>
+
+Declare_foo() ::= <<def foo(self):
+	print('foo')
+>>
+
+Invoke_foo() ::= "self.foo()"
+
+Declare_pred() ::= <<def pred(self, v):
+	print('eval=' + str(v).lower())
+	return v
+
+>>
+
+Invoke_pred(v) ::= <<self.pred(<v>)>>
+
+isEmpty ::= [
+	"": true,
+	default: false
+]
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/python3/Python3.test.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/python3/Python3.test.stg
new file mode 100644
index 000000000..d57f6146e
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/python3/Python3.test.stg
@@ -0,0 +1,394 @@
+IgnoredTests ::= [
+	default: false
+]
+
+TestFile(file) ::= <<
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.python3;
+
+import org.junit.Ignore;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+<if(file.Options.("ImportErrorQueue"))>
+import org.antlr.v4.test.runtime.java.ErrorQueue;
+<endif>
+<if(file.Options.("ImportGrammar"))>
+import org.antlr.v4.tool.Grammar;
+<endif>
+
+@SuppressWarnings("unused")
+public class Test<file.name> extends BasePython3Test {
+
+	<file.tests:{test | <test>}; separator="\n", wrap, anchor>
+
+}
+>>
+
+LexerTestMethod(test) ::= <<
+/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+<testAnnotations(test)>
+public void test<test.name>() throws Exception {
+	mkdir(tmpdir);
+
+<test.SlaveGrammars:{grammar |
+	String slave_<grammar> =<writeStringLiteral(test.SlaveGrammars.(grammar))>;
+	writeFile(tmpdir, "<grammar>.g4", slave_<grammar>);
+	}; separator="\n">
+<test.Grammar:{grammar |
+	<buildStringLiteral(test.Grammar.(grammar), "grammar")>
+
+<if(test.AfterGrammar)>
+	<test.AfterGrammar>
+<endif>
+	String input =<writeStringLiteral(test.Input)>;
+	String found = execLexer("<grammar>.g4", grammar, "<grammar><if(test.Options.("CombinedGrammar"))>Lexer<endif>", input, <writeBoolean(test.Options.("ShowDFA"))>);
+	assertEquals(<writeStringLiteral(test.Output)>, found);
+	<if(!isEmpty.(test.Errors))>
+	assertEquals(<writeStringLiteral(test.Errors)>, this.stderrDuringParse);
+	<else>
+	assertNull(this.stderrDuringParse);
+	<endif>
+	}>
+}
+
+>>
+
+CompositeLexerTestMethod(test) ::= <<
+<LexerTestMethod(test)>
+>>
+
+ParserTestMethod(test) ::= <<
+/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+<testAnnotations(test)>
+public void test<test.name>() throws Exception {
+	mkdir(tmpdir);
+
+<test.SlaveGrammars:{grammar |
+	String slave_<grammar> =<writeStringLiteral(test.SlaveGrammars.(grammar))>;
+<if(test.Options.("SlaveIsLexer"))>
+	rawGenerateAndBuildRecognizer("<grammar>.g4", slave_<grammar>, null, "<grammar>");
+<else>
+	writeFile(tmpdir, "<grammar>.g4", slave_<grammar>);
+<endif>
+	}; separator="\n">
+<test.Grammar:{grammar |
+	<buildStringLiteral(test.Grammar.(grammar), "grammar")>
+
+	<test.AfterGrammar>
+
+	String input =<writeStringLiteral(test.Input)>;
+	String found = execParser("<grammar>.g4", grammar, "<grammar><if(!test.slaveIsLexer)>Parser<endif>", "<if(test.slaveIsLexer)><first(test.slaveGrammars).grammarName><else><grammar>Lexer<endif>", "<grammar>Listener", "<grammar>Visitor", "<test.Rule>", input, <writeBoolean(test.Options.("Debug"))>);
+
+	assertEquals(<writeStringLiteral(test.Output)>, found);
+	<if(!isEmpty.(test.Errors))>
+	assertEquals(<writeStringLiteral(test.Errors)>, this.stderrDuringParse);
+	<else>
+	assertNull(this.stderrDuringParse);
+	<endif>
+	}>
+}
+
+>>
+
+CompositeParserTestMethod(test) ::= <<
+<ParserTestMethod(test)>
+>>
+
+AbstractParserTestMethod(test) ::= <<
+/* this file and method are generated, any edit will be overwritten by the next generation */
+String test<test.name>(String input) throws Exception {
+	String grammar = <test.grammar.lines:{ line | "<line>};separator="\\n\" +\n", wrap, anchor>";
+	return execParser("<test.grammar.grammarName>.g4", grammar, "<test.grammar.grammarName>Parser", "<test.grammar.grammarName>Lexer", "<test.startRule>", input, <test.debug>);
+}
+
+>>
+
+ConcreteParserTestMethod(test) ::= <<
+/* this file and method are generated, any edit will be overwritten by the next generation */
+@Test
+public void test<test.name>() throws Exception {
+	String found = test<test.baseName>("<test.input>");
+	assertEquals("<test.expectedOutput>", found);
+	<if(test.expectedErrors)>
+	assertEquals("<test.expectedErrors>", this.stderrDuringParse);
+	<else>
+	assertNull(this.stderrDuringParse);
+	<endif>
+}
+
+>>
+
+testAnnotations(test) ::= <%
+@Test
+<if(test.Options.("Ignore"))>
+<\n>@Ignore(<writeStringLiteral(test.Options.("Ignore"))>)
+<elseif(IgnoredTests.(({<file.name>.<test.name>})))>
+<\n>@Ignore(<writeStringLiteral(IgnoredTests.(({<file.name>.<test.name>})))>)
+<endif>
+%>
+
+buildStringLiteral(text, variable) ::= <<
+StringBuilder <variable>Builder = new StringBuilder(<strlen.(text)>);
+<lines.(text):{line|<variable>Builder.append("<escape.(line)>");}; separator="\n">
+String <variable> = <variable>Builder.toString();
+>>
+
+writeStringLiteral(text) ::= <%
+<if(isEmpty.(text))>
+""
+<else>
+<writeLines(lines.(text))>
+<endif>
+%>
+
+writeLines(textLines) ::= <%
+<if(rest(textLines))>
+<textLines:{line|
+<\n>		"<escape.(line)>}; separator="\" +">"
+<else>
+"<escape.(first(textLines))>"
+<endif>
+%>
+
+string(text) ::= <<
+"<escape.(text)>"
+>>
+
+writeBoolean(o) ::= "<if(o && !isEmpty.(o))>true<else>false<endif>"
+
+writeln(s) ::= <<print(<s>)>>
+
+write(s) ::= <<print(<s>,end='')>>
+
+False() ::= "False"
+
+True() ::= "True"
+
+Not(v) ::= "not <v>"
+
+Assert(s) ::= ""
+
+Cast(t,v) ::= "<v>"
+
+Append(a,b) ::= "<a> + str(<b>)"
+
+Concat(a,b) ::= "<a><b>"
+
+DeclareLocal(s,v) ::= "<s> = <v>"
+
+AssertIsList(v) ::= "assert isinstance(v, (list, tuple))"
+
+AssignLocal(s,v) ::= "<s> = <v>"
+
+InitIntMember(n,v) ::= <%<n> = <v>%>
+
+InitBooleanMember(n,v) ::= <%<n> = <v>%>
+
+GetMember(n) ::= <%self.<n>%>
+
+SetMember(n,v) ::= <%self.<n> = <v>%>
+
+AddMember(n,v) ::= <%self.<n> += <v>%>
+
+PlusMember(v,n) ::= <%<v> + str(self.<n>)%>
+
+MemberEquals(n,v) ::= <%self.<n> == <v>%>
+
+ModMemberEquals(n,m,v) ::= <%self.<n> % <m> == <v>%>
+
+ModMemberNotEquals(n,m,v) ::= <%self.<n> % <m> != <v>%>
+
+DumpDFA() ::= "self.dumpDFA()"
+
+Pass() ::= "pass"
+
+StringList() ::= ""
+
+BuildParseTrees() ::= "self._buildParseTrees = True"
+
+BailErrorStrategy() ::= <%self._errHandler = BailErrorStrategy()%>
+
+ToStringTree(s) ::= <%<s>.toStringTree(recog=self)%>
+
+Column() ::= "self.column"
+
+Text() ::= "self.text"
+
+ValEquals(a,b) ::= <%<a>==<b>%>
+
+TextEquals(a) ::= <%self.text=="<a>"%>
+
+PlusText(a) ::= <%"<a>" + self.text%>
+
+InputText() ::= "self._input.getText()"
+
+LTEquals(i, v) ::= <%self._input.LT(<i>).text==<v>%>
+
+LANotEquals(i, v) ::= <%self._input.LA(<i>)!=<v>%>
+
+TokenStartColumnEquals(i) ::= <%self._tokenStartColumn==<i>%>
+
+ImportListener(X) ::= <<class MockListener:
+    pass
+>>
+
+GetExpectedTokenNames() ::= "self.getExpectedTokens().toString(self.literalNames, self.symbolicNames)"
+
+RuleInvocationStack() ::= "str_list(self.getRuleInvocationStack())"
+
+LL_EXACT_AMBIG_DETECTION() ::= <<self._interp.predictionMode =  PredictionMode.LL_EXACT_AMBIG_DETECTION>>
+
+ParserPropertyMember() ::= <<
+@members {
+def Property(self):
+    return True
+
+}
+>>
+
+PositionAdjustingLexer() ::= <<
+
+def resetAcceptPosition(self, index, line, column):
+	self._input.seek(index)
+	self.line = line
+	self.column = column
+	self._interp.consume(self._input)
+
+def nextToken(self):
+	if self._interp.__dict__.get("resetAcceptPosition", None) is None:
+		self._interp.__dict__["resetAcceptPosition"] = self.resetAcceptPosition
+	return super(type(self),self).nextToken()
+
+def emit(self):
+	if self._type==PositionAdjustingLexer.TOKENS:
+		self.handleAcceptPositionForKeyword("tokens")
+	elif self._type==PositionAdjustingLexer.LABEL:
+		self.handleAcceptPositionForIdentifier()
+	return super(type(self),self).emit()
+
+def handleAcceptPositionForIdentifier(self):
+	tokenText = self.text
+	identifierLength = 0
+	while identifierLength \< len(tokenText) and self.isIdentifierChar(tokenText[identifierLength]):
+		identifierLength += 1
+
+	if self._input.index > self._tokenStartCharIndex + identifierLength:
+		offset = identifierLength - 1
+		self._interp.resetAcceptPosition(self._tokenStartCharIndex + offset,
+				self._tokenStartLine, self._tokenStartColumn + offset)
+		return True
+	else:
+		return False
+
+
+def handleAcceptPositionForKeyword(self, keyword):
+	if self._input.index > self._tokenStartCharIndex + len(keyword):
+		offset = len(keyword) - 1
+		self._interp.resetAcceptPosition(self._tokenStartCharIndex + offset,
+			self._tokenStartLine, self._tokenStartColumn + offset)
+		return True
+	else:
+		return False
+
+@staticmethod
+def isIdentifierChar(c):
+	return c.isalnum() or c == '_'
+
+>>
+
+BasicListener(X) ::= <<
+class LeafListener(MockListener):
+    def visitTerminal(self, node):
+        print(node.symbol.text)
+
+>>
+
+WalkListener(s) ::= <<
+if __name__ is not None and "." in __name__:
+    from .TListener import TListener
+else:
+    from TListener import TListener
+TParser.LeafListener.__bases__ = (TListener,)
+walker = ParseTreeWalker()
+walker.walk(TParser.LeafListener(), <s>)
+>>
+
+TreeNodeWithAltNumField(X) ::= <<
+@parser::members {
+class MyRuleNode(ParserRuleContext):
+    def __init__(self, parent:ParserRuleContext = None, invokingStateNumber:int = None ):
+        super(<X>Parser.MyRuleNode, self).__init__(parent, invokingStateNumber)
+        self.altNum = 0;
+    def getAltNumber(self):
+        return self.altNum
+    def setAltNumber(self, altNum):
+        self.altNum = altNum
+}
+>>
+
+TokenGetterListener(X) ::= <<
+class LeafListener(MockListener):
+    def exitA(self, ctx):
+        if ctx.getChildCount()==2:
+            print(ctx.INT(0).symbol.text + ' ' + ctx.INT(1).symbol.text + ' ' + str_list(ctx.INT()))
+        else:
+            print(str(ctx.ID().symbol))
+
+>>
+
+RuleGetterListener(X) ::= <<
+class LeafListener(MockListener):
+    def exitA(self, ctx):
+        if ctx.getChildCount()==2:
+            print(ctx.b(0).start.text + ' ' + ctx.b(1).start.text + ' ' + ctx.b()[0].start.text)
+        else:
+            print(ctx.b(0).start.text)
+
+>>
+
+
+LRListener(X) ::= <<
+class LeafListener(MockListener):
+    def exitE(self, ctx):
+        if ctx.getChildCount()==3:
+            print(ctx.e(0).start.text + ' ' + ctx.e(1).start.text + ' ' + ctx.e()[0].start.text)
+        else:
+            print(ctx.INT().symbol.text)
+
+>>
+
+LRWithLabelsListener(X) ::= <<
+class LeafListener(MockListener):
+    def exitCall(self, ctx):
+        print(ctx.e().start.text + ' ' + str(ctx.eList()))
+    def exitInt(self, ctx):
+        print(ctx.INT().symbol.text)
+
+>>
+
+DeclareContextListGettersFunction() ::= <<
+def foo():
+    s = SContext()
+    a = s.a()
+    b = s.b()
+>>
+
+Declare_foo() ::= <<def foo(self):
+	print('foo')
+>>
+
+Invoke_foo() ::= "self.foo()"
+
+Declare_pred() ::= <<def pred(self, v):
+	print('eval=' + str(v).lower())
+	return v
+
+>>
+
+Invoke_pred(v) ::= <<self.pred(<v>)>>
+
+isEmpty ::= [
+	"": true,
+	default: false
+]
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeLexers/Index.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeLexers/Index.stg
new file mode 100644
index 000000000..8ddd3cf74
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeLexers/Index.stg
@@ -0,0 +1,4 @@
+TestTemplates ::= [
+	"LexerDelegatorInvokesDelegateRule": [],
+	"LexerDelegatorRuleOverridesDelegate": []
+]
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeLexers/LexerDelegatorInvokesDelegateRule.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeLexers/LexerDelegatorInvokesDelegateRule.stg
new file mode 100644
index 000000000..c893372e9
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeLexers/LexerDelegatorInvokesDelegateRule.stg
@@ -0,0 +1,34 @@
+TestType() ::= "CompositeLexer"
+
+Grammar ::= [
+	"M": {<masterGrammar("M", "S")>}
+]
+
+SlaveGrammars ::= [
+	"S": {<slaveGrammar("S")>}
+]
+
+Input() ::= "abc"
+
+Output() ::= <<
+S.A
+[@0,0:0='a',\<3>,1:0]
+[@1,1:1='b',\<1>,1:1]
+[@2,2:2='c',\<4>,1:2]
+[@3,3:2='\<EOF>',\<-1>,1:3]<\n>
+>>
+
+Errors() ::= ""
+
+masterGrammar(grammarName, slaveGrammarName) ::= <<
+lexer grammar <grammarName>;
+import <slaveGrammarName>;
+B : 'b';
+WS : (' '|'\n') -> skip ;
+>>
+
+slaveGrammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+A : 'a' {<writeln("\"S.A\"")>};
+C : 'c' ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeLexers/LexerDelegatorRuleOverridesDelegate.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeLexers/LexerDelegatorRuleOverridesDelegate.stg
new file mode 100644
index 000000000..af6b003bc
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeLexers/LexerDelegatorRuleOverridesDelegate.stg
@@ -0,0 +1,32 @@
+TestType() ::= "CompositeLexer"
+
+Grammar ::= [
+	"M": {<masterGrammar("M", "S")>}
+]
+
+SlaveGrammars ::= [
+	"S": {<slaveGrammar("S")>}
+]
+
+Input() ::= "ab"
+
+Output() ::= <<
+M.A
+[@0,0:1='ab',\<1>,1:0]
+[@1,2:1='\<EOF>',\<-1>,1:2]<\n>
+>>
+
+Errors() ::= ""
+
+masterGrammar(grammarName, slaveGrammarName) ::= <<
+lexer grammar <grammarName>;
+import <slaveGrammarName>;
+A : 'a' B {<writeln("\"M.A\"")>} ;
+WS : (' '|'\n') -> skip ;
+>>
+
+slaveGrammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+A : 'a' {<writeln("\"S.A\"")>} ;
+B : 'b' {<writeln("\"S.B\"")>} ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeParsers/BringInLiteralsFromDelegate.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeParsers/BringInLiteralsFromDelegate.stg
new file mode 100644
index 000000000..10b620f59
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeParsers/BringInLiteralsFromDelegate.stg
@@ -0,0 +1,31 @@
+TestType() ::= "CompositeParser"
+
+Grammar ::= [
+	"M": {<masterGrammar("M", "S")>}
+]
+
+SlaveGrammars ::= [
+	"S": {<slaveGrammar("S")>}
+]
+
+Rule() ::= "s"
+
+Input() ::= "=a"
+
+Output() ::= <<
+S.a<\n>
+>>
+
+Errors() ::= ""
+
+masterGrammar(grammarName, slaveGrammarName) ::= <<
+grammar M;
+import S;
+s : a ;
+WS : (' '|'\n') -> skip ;
+>>
+
+slaveGrammar(grammarName) ::= <<
+parser grammar S;
+a : '=' 'a' {<write("\"S.a\"")>};
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeParsers/CombinedImportsCombined.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeParsers/CombinedImportsCombined.stg
new file mode 100644
index 000000000..4a117df31
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeParsers/CombinedImportsCombined.stg
@@ -0,0 +1,40 @@
+TestType() ::= "CompositeParser"
+
+Grammar ::= [
+	"M": {<masterGrammar("M", "S")>}
+]
+
+AfterGrammar() ::= <<
+writeFile(tmpdir, "M.g4", grammar);
+ErrorQueue equeue = new ErrorQueue();
+new Grammar(tmpdir+"/M.g4", grammar, equeue);
+assertEquals("unexpected errors: " + equeue, 0, equeue.errors.size());<\n>
+>>
+
+SlaveGrammars ::= [
+	"S": {<slaveGrammar("S")>}
+]
+
+Rule() ::= "s"
+
+Input() ::= "x 34 9"
+
+Output() ::= <<
+S.x<\n>
+>>
+
+Errors() ::= ""
+
+masterGrammar(grammarName, slaveGrammarName) ::= <<
+grammar M;
+import S;
+s : x INT;
+>>
+
+slaveGrammar(grammarName) ::= <<
+parser grammar S;
+tokens { A, B, C }
+x : 'x' INT {<writeln("\"S.x\"")>};
+INT : '0'..'9'+ ;
+WS : (' '|'\n') -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeParsers/DelegatesSeeSameTokenType.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeParsers/DelegatesSeeSameTokenType.stg
new file mode 100644
index 000000000..9025ca903
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeParsers/DelegatesSeeSameTokenType.stg
@@ -0,0 +1,66 @@
+TestType() ::= "CompositeParser"
+
+Grammar ::= [
+	"M": {<masterGrammar("M", ["S", "T"])>}
+]
+
+AfterGrammar() ::= <<
+writeFile(tmpdir, "M.g4", grammar);
+ErrorQueue equeue = new ErrorQueue();
+Grammar g = new Grammar(tmpdir+"/M.g4", grammar, equeue);
+String expectedTokenIDToTypeMap = "{EOF=-1, B=1, A=2, C=3, WS=4}";
+String expectedStringLiteralToTypeMap = "{'a'=2, 'b'=1, 'c'=3}";
+String expectedTypeToTokenList = "[B, A, C, WS]";
+assertEquals(expectedTokenIDToTypeMap, g.tokenNameToTypeMap.toString());
+assertEquals(expectedStringLiteralToTypeMap, sort(g.stringLiteralToTypeMap).toString());
+assertEquals(expectedTypeToTokenList, realElements(g.typeToTokenList).toString());
+assertEquals("unexpected errors: "+equeue, 0, equeue.errors.size());<\n>
+>>
+
+SlaveGrammars ::= [
+	"S": {<slaveGrammarS("S")>},
+	"T": {<slaveGrammarT("T")>}
+]
+
+Rule() ::= "s"
+
+Input() ::= "aa"
+
+Output() ::= <<
+S.x
+T.y<\n>
+>>
+
+Errors() ::= ""
+
+masterGrammar(grammarName, slaveGrammarName) ::= <<
+// The lexer will create rules to match letters a, b, c.
+// The associated token types A, B, C must have the same value
+// and all import'd parsers.  Since ANTLR regenerates all imports
+// for use with the delegator M, it can generate the same token type
+// mapping in each parser:
+// public static final int C=6;
+// public static final int EOF=-1;
+// public static final int B=5;
+// public static final int WS=7;
+// public static final int A=4;
+grammar M;
+import S,T;
+s : x y ; // matches AA, which should be 'aa'
+B : 'b' ; // another order: B, A, C
+A : 'a' ; 
+C : 'c' ; 
+WS : (' '|'\n') -> skip ;
+>>
+
+slaveGrammarS(grammarName) ::= <<
+parser grammar S;
+tokens { A, B, C }
+x : A {<writeln("\"S.x\"")>};
+>>
+
+slaveGrammarT(grammarName) ::= <<
+parser grammar T;
+tokens { C, B, A } // reverse order
+y : A {<writeln("\"T.y\"")>};
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeParsers/DelegatorAccessesDelegateMembers.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeParsers/DelegatorAccessesDelegateMembers.stg
new file mode 100644
index 000000000..f665e3b83
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeParsers/DelegatorAccessesDelegateMembers.stg
@@ -0,0 +1,34 @@
+TestType() ::= "CompositeParser"
+
+Grammar ::= [
+	"M": {<masterGrammar("M", "S")>}
+]
+
+SlaveGrammars ::= [
+	"S": {<slaveGrammar("S")>}
+]
+
+Rule() ::= "s"
+
+Input() ::= "b"
+
+Output() ::= <<
+foo<\n>
+>>
+
+Errors() ::= ""
+
+masterGrammar(grammarName, slaveGrammarName) ::= <<
+grammar M; // uses no rules from the import
+import S;
+s : 'b' {<Invoke_foo()>} ; // gS is import pointer
+WS : (' '|'\n') -> skip ;
+>>
+
+slaveGrammar(grammarName) ::= <<
+parser grammar S;
+@parser::members {
+<Declare_foo()>
+}
+a : B;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeParsers/DelegatorInvokesDelegateRule.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeParsers/DelegatorInvokesDelegateRule.stg
new file mode 100644
index 000000000..50a46f010
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeParsers/DelegatorInvokesDelegateRule.stg
@@ -0,0 +1,32 @@
+TestType() ::= "CompositeParser"
+
+Grammar ::= [
+	"M": {<masterGrammar("M", "S")>}
+]
+
+SlaveGrammars ::= [
+	"S": {<slaveGrammar("S")>}
+]
+
+Rule() ::= "s"
+
+Input() ::= "b"
+
+Output() ::= <<
+S.a<\n>
+>>
+
+Errors() ::= ""
+
+masterGrammar(grammarName, slaveGrammarName) ::= <<
+grammar M;
+import S;
+s : a ;
+B : 'b' ; // defines B from inherited token space
+WS : (' '|'\n') -> skip ;
+>>
+
+slaveGrammar(grammarName) ::= <<
+parser grammar S;
+a : B {<writeln("\"S.a\"")>};
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeParsers/DelegatorInvokesDelegateRuleWithArgs.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeParsers/DelegatorInvokesDelegateRuleWithArgs.stg
new file mode 100644
index 000000000..395682bcc
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeParsers/DelegatorInvokesDelegateRuleWithArgs.stg
@@ -0,0 +1,32 @@
+TestType() ::= "CompositeParser"
+
+Grammar ::= [
+	"M": {<masterGrammar("M", "S")>}
+]
+
+SlaveGrammars ::= [
+	"S": {<slaveGrammar("S")>}
+]
+
+Rule() ::= "s"
+
+Input() ::= "b"
+
+Output() ::= <<
+S.a1000<\n>
+>>
+
+Errors() ::= ""
+
+masterGrammar(grammarName, slaveGrammarName) ::= <<
+grammar M;
+import S;
+s : label=a[3] {<writeln("$label.y")>} ;
+B : 'b' ; // defines B from inherited token space
+WS : (' '|'\n') -> skip ;
+>>
+
+slaveGrammar(grammarName) ::= <<
+parser grammar S;
+a[int x] returns [int y] : B {<write("\"S.a\"")>} {$y=1000;} ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeParsers/DelegatorInvokesDelegateRuleWithReturnStruct.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeParsers/DelegatorInvokesDelegateRuleWithReturnStruct.stg
new file mode 100644
index 000000000..1c6c13e96
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeParsers/DelegatorInvokesDelegateRuleWithReturnStruct.stg
@@ -0,0 +1,32 @@
+TestType() ::= "CompositeParser"
+
+Grammar ::= [
+	"M": {<masterGrammar("M", "S")>}
+]
+
+SlaveGrammars ::= [
+	"S": {<slaveGrammar("S")>}
+]
+
+Rule() ::= "s"
+
+Input() ::= "b"
+
+Output() ::= <<
+S.ab<\n>
+>>
+
+Errors() ::= ""
+
+masterGrammar(grammarName, slaveGrammarName) ::= <<
+grammar M;
+import S;
+s : a {<write("$a.text")>} ;
+B : 'b' ; // defines B from inherited token space
+WS : (' '|'\n') -> skip ;
+>>
+
+slaveGrammar(grammarName) ::= <<
+parser grammar S;
+a : B {<write("\"S.a\"")>} ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeParsers/DelegatorInvokesFirstVersionOfDelegateRule.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeParsers/DelegatorInvokesFirstVersionOfDelegateRule.stg
new file mode 100644
index 000000000..be10d4fe7
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeParsers/DelegatorInvokesFirstVersionOfDelegateRule.stg
@@ -0,0 +1,39 @@
+TestType() ::= "CompositeParser"
+
+Grammar ::= [
+	"M": {<masterGrammar("M", ["S", "T"])>}
+]
+
+SlaveGrammars ::= [
+	"S": {<slaveGrammarS("S")>},
+	"T": {<slaveGrammarT("T")>}
+]
+
+Rule() ::= "s"
+
+Input() ::= "b"
+
+Output() ::= <<
+S.a<\n>
+>>
+
+Errors() ::= ""
+
+masterGrammar(grammarName, slaveGrammarName) ::= <<
+grammar M;
+import S,T;
+s : a ;
+B : 'b' ; // defines B from inherited token space
+WS : (' '|'\n') -> skip ;
+>>
+
+slaveGrammarS(grammarName) ::= <<
+parser grammar S;
+a : b {<writeln("\"S.a\"")>};
+b : B;
+>>
+
+slaveGrammarT(grammarName) ::= <<
+parser grammar T;
+a : B {<writeln("\"T.a\"")>};<! hidden by S.a !>
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeParsers/DelegatorRuleOverridesDelegate.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeParsers/DelegatorRuleOverridesDelegate.stg
new file mode 100644
index 000000000..23589678b
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeParsers/DelegatorRuleOverridesDelegate.stg
@@ -0,0 +1,32 @@
+TestType() ::= "CompositeParser"
+
+Grammar ::= [
+	"M": {<masterGrammar("M", "S")>}
+]
+
+SlaveGrammars ::= [
+	"S": {<slaveGrammar("S")>}
+]
+
+Rule() ::= "a"
+
+Input() ::= "c"
+
+Output() ::= <<
+S.a<\n>
+>>
+
+Errors() ::= ""
+
+masterGrammar(grammarName, slaveGrammarName) ::= <<
+grammar M;
+import S;
+b : 'b'|'c';
+WS : (' '|'\n') -> skip ;
+>>
+
+slaveGrammar(grammarName) ::= <<
+parser grammar S;
+a : b {<write("\"S.a\"")>};
+b : B ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeParsers/DelegatorRuleOverridesDelegates.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeParsers/DelegatorRuleOverridesDelegates.stg
new file mode 100644
index 000000000..bef4f9a01
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeParsers/DelegatorRuleOverridesDelegates.stg
@@ -0,0 +1,40 @@
+TestType() ::= "CompositeParser"
+
+Grammar ::= [
+	"M": {<masterGrammar("M", "S")>}
+]
+
+SlaveGrammars ::= [
+	"S": {<slaveGrammarS("S")>},
+	"T": {<slaveGrammarT("T")>}
+]
+
+Rule() ::= "a"
+
+Input() ::= "c"
+
+Output() ::= <<
+M.b
+S.a<\n>
+>>
+
+Errors() ::= ""
+
+masterGrammar(grammarName, slaveGrammarName) ::= <<
+grammar M;
+import S, T;
+b : 'b'|'c' {<writeln("\"M.b\"")>}|B|A;
+WS : (' '|'\n') -> skip ;
+>>
+
+slaveGrammarS(grammarName) ::= <<
+parser grammar S;
+a : b {<writeln("\"S.a\"")>};
+b : 'b' ;
+>>
+
+slaveGrammarT(grammarName) ::= <<
+parser grammar T;
+tokens { A }
+b : 'b' {<writeln("\"T.b\"")>};
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeParsers/DelegatorRuleOverridesLookaheadInDelegate.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeParsers/DelegatorRuleOverridesLookaheadInDelegate.stg
new file mode 100644
index 000000000..15781c7f3
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeParsers/DelegatorRuleOverridesLookaheadInDelegate.stg
@@ -0,0 +1,38 @@
+TestType() ::= "CompositeParser"
+
+Grammar ::= [
+	"M": {<masterGrammar("M", "S")>}
+]
+
+SlaveGrammars ::= [
+	"S": {<slaveGrammar("S")>}
+]
+
+Rule() ::= "prog"
+
+Input() ::= "float x = 3;"
+
+Output() ::= <<
+JavaDecl: floatx=3;<\n>
+>>
+
+Errors() ::= ""
+
+// for float to work in decl, type must be overridden
+masterGrammar(grammarName, slaveGrammarName) ::= <<
+grammar M;
+import S;
+prog : decl ;
+type_ : 'int' | 'float' ;
+ID  : 'a'..'z'+ ;
+INT : '0'..'9'+ ;
+WS : (' '|'\n') -> skip;
+>>
+
+slaveGrammar(grammarName) ::= <<
+parser grammar S;
+type_ : 'int' ;
+decl : type_ ID ';'
+	| type_ ID init ';' {<write("\"JavaDecl: \" + $text")>};
+init : '=' INT;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeParsers/ImportLexerWithOnlyFragmentRules.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeParsers/ImportLexerWithOnlyFragmentRules.stg
new file mode 100644
index 000000000..f13656d97
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeParsers/ImportLexerWithOnlyFragmentRules.stg
@@ -0,0 +1,45 @@
+/*
+ * This is a regression test for antlr/antlr4#248 "Including grammar with only
+ * fragments breaks generated lexer".
+ * https://github.com/antlr/antlr4/issues/248
+ */
+
+TestType() ::= "CompositeParser"
+
+Grammar ::= [
+	"Test": {<masterGrammar("Test", "Unicode")>}
+]
+
+SlaveGrammars ::= [
+	"Unicode": {<slaveGrammar("Unicode")>}
+]
+
+Rule() ::= "program"
+
+Input() ::= "test test"
+
+Output() ::= <<
+>>
+
+Errors() ::= ""
+
+masterGrammar(grammarName, slaveGrammarName) ::= <<
+grammar <grammarName>;
+import <slaveGrammarName; separator=", ">;
+
+program : 'test' 'test';
+
+WS : (UNICODE_CLASS_Zs)+ -> skip;
+
+>>
+
+slaveGrammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+
+fragment
+UNICODE_CLASS_Zs    : '\u0020' | '\u00A0' | '\u1680' | '\u180E'
+                    | '\u2000'..'\u200A'
+                    | '\u202F' | '\u205F' | '\u3000'
+                    ;
+
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeParsers/ImportedGrammarWithEmptyOptions.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeParsers/ImportedGrammarWithEmptyOptions.stg
new file mode 100644
index 000000000..7df5b4a1d
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeParsers/ImportedGrammarWithEmptyOptions.stg
@@ -0,0 +1,32 @@
+TestType() ::= "CompositeParser"
+
+Grammar ::= [
+	"M": {<masterGrammar("M", "S")>}
+]
+
+SlaveGrammars ::= [
+	"S": {<slaveGrammar("S")>}
+]
+
+Rule() ::= "s"
+
+Input() ::= "b"
+
+Output() ::= <<
+>>
+
+Errors() ::= ""
+
+masterGrammar(grammarName, slaveGrammarName) ::= <<
+grammar M;
+import S;
+s : a ;
+B : 'b' ;
+WS : (' '|'\n') -> skip ;
+>>
+
+slaveGrammar(grammarName) ::= <<
+parser grammar S;
+options {}
+a : B ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeParsers/ImportedRuleWithAction.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeParsers/ImportedRuleWithAction.stg
new file mode 100644
index 000000000..c84cfda21
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeParsers/ImportedRuleWithAction.stg
@@ -0,0 +1,32 @@
+TestType() ::= "CompositeParser"
+
+Grammar ::= [
+	"M": {<masterGrammar("M", "S")>}
+]
+
+SlaveGrammars ::= [
+	"S": {<slaveGrammar("S")>}
+]
+
+Rule() ::= "s"
+
+Input() ::= "b"
+
+Output() ::= <<
+>>
+
+Errors() ::= ""
+
+masterGrammar(grammarName, slaveGrammarName) ::= <<
+grammar M;
+import S;
+s : a;
+B : 'b';
+WS : (' '|'\n') -> skip ;
+>>
+
+// wasn't terminating. @after was injected into M as if it were @members
+slaveGrammar(grammarName) ::= <<
+parser grammar S;
+a @after {<InitIntMember("x","0")>} : B;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeParsers/Index.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeParsers/Index.stg
new file mode 100644
index 000000000..f098106ca
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeParsers/Index.stg
@@ -0,0 +1,22 @@
+TestTemplates ::= [
+	"DelegatorInvokesDelegateRule": [],
+	"BringInLiteralsFromDelegate": [],
+	"DelegatorInvokesDelegateRuleWithArgs": [],
+	"DelegatorInvokesDelegateRuleWithReturnStruct": [],
+	"DelegatorAccessesDelegateMembers": [],
+	"DelegatorInvokesFirstVersionOfDelegateRule": [],
+	"DelegatesSeeSameTokenType": [],
+	"CombinedImportsCombined": [],
+	"DelegatorRuleOverridesDelegate": [],
+	"DelegatorRuleOverridesLookaheadInDelegate": [],
+	"DelegatorRuleOverridesDelegates": [],
+	"KeywordVSIDOrder": [],
+	"ImportedRuleWithAction": [],
+	"ImportedGrammarWithEmptyOptions": [],
+	"ImportLexerWithOnlyFragmentRules": []
+]
+
+Options ::= [
+	"ImportErrorQueue": true,
+	"ImportGrammar": true
+]
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeParsers/KeywordVSIDOrder.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeParsers/KeywordVSIDOrder.stg
new file mode 100644
index 000000000..614948b29
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/CompositeParsers/KeywordVSIDOrder.stg
@@ -0,0 +1,37 @@
+// rules in lexer are imported at END so rules in master override
+// *and* get priority over imported rules. So importing ID doesn't
+// mess up keywords in master grammar
+
+TestType() ::= "CompositeParser"
+
+Grammar ::= [
+	"M": {<masterGrammar("M", "S")>}
+]
+
+SlaveGrammars ::= [
+	"S": {<slaveGrammar("S")>}
+]
+
+Rule() ::= "a"
+
+Input() ::= "abc"
+
+Output() ::= <<
+M.A
+M.a: [@0,0:2='abc',\<1>,1:0]<\n>
+>>
+
+Errors() ::= ""
+
+masterGrammar(grammarName, slaveGrammarName) ::= <<
+grammar M;
+import S;
+a : A {<Append("\"M.a: \"","$A"):writeln()>};
+A : 'abc' {<writeln("\"M.A\"")>};
+WS : (' '|'\n') -> skip ;
+>>
+
+slaveGrammar(grammarName) ::= <<
+lexer grammar S;
+ID : 'a'..'z'+;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/AmbigYieldsCtxSensitiveDFA.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/AmbigYieldsCtxSensitiveDFA.stg
new file mode 100644
index 000000000..92e14ecca
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/AmbigYieldsCtxSensitiveDFA.stg
@@ -0,0 +1,30 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": true
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "abc"
+
+Rule() ::= "s"
+
+Output() ::= <<
+Decision 0:
+s0-ID->:s1^=>1<\n>
+>>
+
+Errors() ::= <<
+line 1:0 reportAttemptingFullContext d=0 (s), input='abc'<\n>
+>>
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+s @after {<DumpDFA()>}
+	: ID | ID {} ;
+ID : 'a'..'z'+;
+WS : (' '|'\t'|'\n')+ -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/AmbiguityNoLoop.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/AmbiguityNoLoop.stg
new file mode 100644
index 000000000..621937523
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/AmbiguityNoLoop.stg
@@ -0,0 +1,39 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": true
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "a@"
+
+Rule() ::= "prog"
+
+Output() ::= <<
+alt 1<\n>
+>>
+
+Errors() ::= <<
+line 1:2 reportAttemptingFullContext d=0 (prog), input='a@'
+line 1:2 reportAmbiguity d=0 (prog): ambigAlts={1, 2}, input='a@'
+line 1:2 reportAttemptingFullContext d=1 (expr), input='a@'
+line 1:2 reportContextSensitivity d=1 (expr), input='a@'<\n>
+>>
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+prog
+@init {<LL_EXACT_AMBIG_DETECTION()>}
+	: expr expr {<writeln("\"alt 1\"")>}
+	| expr
+	;
+expr: '@'
+	| ID '@'
+	| ID
+	;
+ID  : [a-z]+ ;
+WS  : [ \r\n\t]+ -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/CtxSensitiveDFA.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/CtxSensitiveDFA.stg
new file mode 100644
index 000000000..8a1747d5e
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/CtxSensitiveDFA.stg
@@ -0,0 +1,23 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": true
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Rule() ::= "s"
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+s @after {<DumpDFA()>}
+  : '$' a | '@' b ;
+a : e ID ;
+b : e INT ID ;
+e : INT | ;
+ID : 'a'..'z'+ ;
+INT : '0'..'9'+ ;
+WS : (' '|'\t'|'\n')+ -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/CtxSensitiveDFATwoDiffInput.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/CtxSensitiveDFATwoDiffInput.stg
new file mode 100644
index 000000000..a4701f48e
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/CtxSensitiveDFATwoDiffInput.stg
@@ -0,0 +1,39 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": true
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+
+Input() ::= "$ 34 abc @ 34 abc"
+
+Rule() ::= "s"
+
+Output() ::= <<
+Decision 2:
+s0-INT->s1
+s1-ID->:s2^=>1<\n>
+>>
+
+Errors() ::= <<
+line 1:5 reportAttemptingFullContext d=2 (e), input='34abc'
+line 1:2 reportContextSensitivity d=2 (e), input='34'
+line 1:14 reportAttemptingFullContext d=2 (e), input='34abc'
+line 1:14 reportContextSensitivity d=2 (e), input='34abc'<\n>
+>>
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+s @after {<DumpDFA()>}
+  : ('$' a | '@' b)+ ;
+a : e ID ;
+b : e INT ID ;
+e : INT | ;
+ID : 'a'..'z'+ ;
+INT : '0'..'9'+ ;
+WS : (' '|'\t'|'\n')+ -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/CtxSensitiveDFA_1.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/CtxSensitiveDFA_1.stg
new file mode 100644
index 000000000..0144a7780
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/CtxSensitiveDFA_1.stg
@@ -0,0 +1,14 @@
+import "CtxSensitiveDFA.stg"
+
+Input() ::= "$ 34 abc"
+
+Output() ::= <<
+Decision 1:
+s0-INT->s1
+s1-ID->:s2^=>1<\n>
+>>
+
+Errors() ::= <<
+line 1:5 reportAttemptingFullContext d=1 (e), input='34abc'
+line 1:2 reportContextSensitivity d=1 (e), input='34'<\n>
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/CtxSensitiveDFA_2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/CtxSensitiveDFA_2.stg
new file mode 100644
index 000000000..35ed287bd
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/CtxSensitiveDFA_2.stg
@@ -0,0 +1,14 @@
+import "CtxSensitiveDFA.stg"
+
+Input() ::= "@ 34 abc"
+
+Output() ::= <<
+Decision 1:
+s0-INT->s1
+s1-ID->:s2^=>1<\n>
+>>
+
+Errors() ::= <<
+line 1:5 reportAttemptingFullContext d=1 (e), input='34abc'
+line 1:5 reportContextSensitivity d=1 (e), input='34abc'<\n>
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/ExprAmbiguity.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/ExprAmbiguity.stg
new file mode 100644
index 000000000..0947c4891
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/ExprAmbiguity.stg
@@ -0,0 +1,28 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": true
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Rule() ::= "s"
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+s
+@init {<LL_EXACT_AMBIG_DETECTION()>}
+:   expr[0] {<ToStringTree("$expr.ctx"):writeln()>};
+	expr[int _p]
+		: ID 
+		( 
+			{5 >= $_p}? '*' expr[6]
+			| {4 >= $_p}? '+' expr[5]
+		)*
+		;
+ID  : [a-zA-Z]+ ;
+WS  : [ \r\n\t]+ -> skip ;
+
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/ExprAmbiguity_1.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/ExprAmbiguity_1.stg
new file mode 100644
index 000000000..d56c9b386
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/ExprAmbiguity_1.stg
@@ -0,0 +1,12 @@
+import "ExprAmbiguity.stg"
+
+Input() ::= "a+b"
+
+Output() ::= <<
+(expr a + (expr b))<\n>
+>>
+
+Errors() ::= <<
+line 1:1 reportAttemptingFullContext d=1 (expr), input='+'
+line 1:2 reportContextSensitivity d=1 (expr), input='+b'<\n>
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/ExprAmbiguity_2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/ExprAmbiguity_2.stg
new file mode 100644
index 000000000..d51202efa
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/ExprAmbiguity_2.stg
@@ -0,0 +1,14 @@
+import "ExprAmbiguity.stg"
+
+Input() ::= "a+b*c"
+
+Output() ::= <<
+(expr a + (expr b * (expr c)))<\n>
+>>
+
+Errors() ::= <<
+line 1:1 reportAttemptingFullContext d=1 (expr), input='+'
+line 1:2 reportContextSensitivity d=1 (expr), input='+b'
+line 1:3 reportAttemptingFullContext d=1 (expr), input='*'
+line 1:5 reportAmbiguity d=1 (expr): ambigAlts={1, 2}, input='*c'<\n>
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/FullContextIF_THEN_ELSEParse.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/FullContextIF_THEN_ELSEParse.stg
new file mode 100644
index 000000000..93a668a7b
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/FullContextIF_THEN_ELSEParse.stg
@@ -0,0 +1,24 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": true
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Rule() ::= "s"
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+s 
+@init {<LL_EXACT_AMBIG_DETECTION()>}
+@after {<DumpDFA()>}
+	: '{' stat* '}' ;
+stat: 'if' ID 'then' stat ('else' ID)?
+		| 'return'
+		;
+ID : 'a'..'z'+ ;
+WS : (' '|'\t'|'\n')+ -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/FullContextIF_THEN_ELSEParse_1.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/FullContextIF_THEN_ELSEParse_1.stg
new file mode 100644
index 000000000..f15f25c4b
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/FullContextIF_THEN_ELSEParse_1.stg
@@ -0,0 +1,10 @@
+import "FullContextIF_THEN_ELSEParse.stg"
+
+Input() ::= "{ if x then return }"
+
+Output() ::= <<
+Decision 1:
+s0-'}'->:s1=>2<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/FullContextIF_THEN_ELSEParse_2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/FullContextIF_THEN_ELSEParse_2.stg
new file mode 100644
index 000000000..24ff08fa8
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/FullContextIF_THEN_ELSEParse_2.stg
@@ -0,0 +1,20 @@
+import "FullContextIF_THEN_ELSEParse.stg"
+
+Input() ::= "{ if x then return else foo }"
+
+Output() ::= <<
+Decision 1:
+s0-'else'->:s1^=>1<\n>
+>>
+
+// Technically, this input sequence is not ambiguous because else
+// uniquely predicts going into the optional subrule. else cannot
+// be matched by exiting stat since that would only match '}' or
+// the start of a stat. But, we are using the theory that
+// SLL(1)=LL(1) and so we are avoiding full context parsing
+// by declaring all else clause parsing to be ambiguous.
+
+Errors() ::= <<
+line 1:19 reportAttemptingFullContext d=1 (stat), input='else'
+line 1:19 reportContextSensitivity d=1 (stat), input='else'<\n>
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/FullContextIF_THEN_ELSEParse_3.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/FullContextIF_THEN_ELSEParse_3.stg
new file mode 100644
index 000000000..19cecc12b
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/FullContextIF_THEN_ELSEParse_3.stg
@@ -0,0 +1,14 @@
+import "FullContextIF_THEN_ELSEParse.stg"
+
+Input() ::= "{ if x then if y then return else foo }"
+
+Output() ::= <<
+Decision 1:
+s0-'}'->:s2=>2
+s0-'else'->:s1^=>1<\n>
+>>
+
+Errors() ::= <<
+line 1:29 reportAttemptingFullContext d=1 (stat), input='else'
+line 1:38 reportAmbiguity d=1 (stat): ambigAlts={1, 2}, input='elsefoo}'<\n>
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/FullContextIF_THEN_ELSEParse_4.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/FullContextIF_THEN_ELSEParse_4.stg
new file mode 100644
index 000000000..d87abb2a0
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/FullContextIF_THEN_ELSEParse_4.stg
@@ -0,0 +1,19 @@
+import "FullContextIF_THEN_ELSEParse.stg"
+
+// should not be ambiguous because the second 'else bar' clearly
+// indicates that the first else should match to the innermost if.
+// LL_EXACT_AMBIG_DETECTION makes us keep going to resolve
+
+Input() ::= "{ if x then if y then return else foo else bar }"
+
+Output() ::= <<
+Decision 1:
+s0-'else'->:s1^=>1<\n>
+>>
+
+Errors() ::= <<
+line 1:29 reportAttemptingFullContext d=1 (stat), input='else'
+line 1:38 reportContextSensitivity d=1 (stat), input='elsefooelse'
+line 1:38 reportAttemptingFullContext d=1 (stat), input='else'
+line 1:38 reportContextSensitivity d=1 (stat), input='else'<\n>
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/FullContextIF_THEN_ELSEParse_5.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/FullContextIF_THEN_ELSEParse_5.stg
new file mode 100644
index 000000000..b4ae734bc
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/FullContextIF_THEN_ELSEParse_5.stg
@@ -0,0 +1,19 @@
+import "FullContextIF_THEN_ELSEParse.stg"
+
+Input() ::= <<
+{ if x then return else foo
+if x then if y then return else foo }
+>>
+
+Output() ::= <<
+Decision 1:
+s0-'}'->:s2=>2
+s0-'else'->:s1^=>1<\n>
+>>
+
+Errors() ::= <<
+line 1:19 reportAttemptingFullContext d=1 (stat), input='else'
+line 1:19 reportContextSensitivity d=1 (stat), input='else'
+line 2:27 reportAttemptingFullContext d=1 (stat), input='else'
+line 2:36 reportAmbiguity d=1 (stat): ambigAlts={1, 2}, input='elsefoo}'<\n>
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/FullContextIF_THEN_ELSEParse_6.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/FullContextIF_THEN_ELSEParse_6.stg
new file mode 100644
index 000000000..b4ae734bc
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/FullContextIF_THEN_ELSEParse_6.stg
@@ -0,0 +1,19 @@
+import "FullContextIF_THEN_ELSEParse.stg"
+
+Input() ::= <<
+{ if x then return else foo
+if x then if y then return else foo }
+>>
+
+Output() ::= <<
+Decision 1:
+s0-'}'->:s2=>2
+s0-'else'->:s1^=>1<\n>
+>>
+
+Errors() ::= <<
+line 1:19 reportAttemptingFullContext d=1 (stat), input='else'
+line 1:19 reportContextSensitivity d=1 (stat), input='else'
+line 2:27 reportAttemptingFullContext d=1 (stat), input='else'
+line 2:36 reportAmbiguity d=1 (stat): ambigAlts={1, 2}, input='elsefoo}'<\n>
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/Index.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/Index.stg
new file mode 100644
index 000000000..6e7c43827
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/Index.stg
@@ -0,0 +1,17 @@
+TestTemplates ::= [
+	"AmbigYieldsCtxSensitiveDFA": [],
+	"CtxSensitiveDFA_1": [],
+	"CtxSensitiveDFA_2": [],
+	"CtxSensitiveDFATwoDiffInput": [],
+	"SLLSeesEOFInLLGrammar": [],
+	"FullContextIF_THEN_ELSEParse_1": [],
+	"FullContextIF_THEN_ELSEParse_2": [],
+	"FullContextIF_THEN_ELSEParse_3": [],
+	"FullContextIF_THEN_ELSEParse_4": [],
+	"FullContextIF_THEN_ELSEParse_5": [],
+	"FullContextIF_THEN_ELSEParse_6": [],
+	"LoopsSimulateTailRecursion": [],
+	"AmbiguityNoLoop": [],
+	"ExprAmbiguity_1": [],
+	"ExprAmbiguity_2": []
+]
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/LoopsSimulateTailRecursion.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/LoopsSimulateTailRecursion.stg
new file mode 100644
index 000000000..a84c60e3f
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/LoopsSimulateTailRecursion.stg
@@ -0,0 +1,44 @@
+/*
+ * Tests predictions for the following case involving closures.
+ * http://www.antlr.org/wiki/display/~admin/2011/12/29/Flaw+in+ANTLR+v3+LL(*)+analysis+algorithm
+ */
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": true
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "a(i)\<-x"
+
+Rule() ::= "prog"
+
+Output() ::= <<
+pass: a(i)\<-x<\n>
+>>
+
+Errors() ::= <<
+line 1:3 reportAttemptingFullContext d=3 (expr_primary), input='a(i)'
+line 1:7 reportAmbiguity d=3 (expr_primary): ambigAlts={2, 3}, input='a(i)\<-x'<\n>
+>>
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+prog
+@init {<LL_EXACT_AMBIG_DETECTION()>}
+	: expr_or_assign*;
+expr_or_assign
+	: expr '++' {<writeln("\"fail.\"")>}
+	|  expr {<writeln("\"pass: \"+$expr.text")>}
+	;
+expr: expr_primary ('\<-' ID)?;
+expr_primary
+	: '(' ID ')'
+	| ID '(' ID ')'
+	| ID
+	;
+ID  : [a-z]+ ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/SLLSeesEOFInLLGrammar.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/SLLSeesEOFInLLGrammar.stg
new file mode 100644
index 000000000..c341f80aa
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/FullContextParsing/SLLSeesEOFInLLGrammar.stg
@@ -0,0 +1,36 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": true
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "34 abc"
+
+Rule() ::= "s"
+
+Output() ::= <<
+Decision 0:
+s0-INT->s1
+s1-ID->:s2^=>1<\n>
+>>
+
+Errors() ::= <<
+line 1:3 reportAttemptingFullContext d=0 (e), input='34abc'
+line 1:0 reportContextSensitivity d=0 (e), input='34'<\n>
+>>
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+s @after {<DumpDFA()>}
+  : a;
+a : e ID ;
+b : e INT ID ;
+e : INT | ;
+ID : 'a'..'z'+ ;
+INT : '0'..'9'+ ;
+WS : (' '|'\t'|'\n')+ -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Index.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Index.stg
new file mode 100644
index 000000000..549026694
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Index.stg
@@ -0,0 +1,16 @@
+TestFolders ::= [
+	"CompositeLexers": [],
+	"CompositeParsers": [],
+	"FullContextParsing": [],
+	"LeftRecursion": [],
+	"LexerErrors": [],
+	"LexerExec": [],
+	"Listeners": [],
+	"ParserErrors": [],
+	"ParserExec": [],
+	"ParseTrees": [],
+	"Performance": [],
+	"SemPredEvalLexer": [],
+	"SemPredEvalParser": [],
+	"Sets": []
+]
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/AmbigLR.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/AmbigLR.stg
new file mode 100644
index 000000000..a5a1fc184
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/AmbigLR.stg
@@ -0,0 +1,35 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": true
+]
+
+Grammar ::= [
+	"Expr": {<grammar("Expr")>}
+]
+
+Rule() ::= "prog"
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+prog:   stat ;
+stat:   expr NEWLINE                # printExpr
+    |   ID '=' expr NEWLINE         # assign
+    |   NEWLINE                     # blank
+    ;
+expr:   expr ('*'|'/') expr      # MulDiv
+    |   expr ('+'|'-') expr      # AddSub
+    |   INT                      # int
+    |   ID                       # id
+    |   '(' expr ')'             # parens
+    ;
+
+MUL :   '*' ; // assigns token name to '*' used above in grammar
+DIV :   '/' ;
+ADD :   '+' ;
+SUB :   '-' ;
+ID  :   [a-zA-Z]+ ;      // match identifiers
+INT :   [0-9]+ ;         // match integers
+NEWLINE:'\r'? '\n' ;     // return newlines to parser (is end-statement signal)
+WS  :   [ \t]+ -> skip ; // toss out whitespace
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/AmbigLR_1.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/AmbigLR_1.stg
new file mode 100644
index 000000000..7dc9c3581
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/AmbigLR_1.stg
@@ -0,0 +1,7 @@
+import "AmbigLR.stg"
+
+Input() ::= "1<\n>"
+
+Output() ::= ""
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/AmbigLR_2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/AmbigLR_2.stg
new file mode 100644
index 000000000..3225d0bc5
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/AmbigLR_2.stg
@@ -0,0 +1,7 @@
+import "AmbigLR.stg"
+
+Input() ::= "a = 5<\n>"
+
+Output() ::= ""
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/AmbigLR_3.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/AmbigLR_3.stg
new file mode 100644
index 000000000..19ec911da
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/AmbigLR_3.stg
@@ -0,0 +1,7 @@
+import "AmbigLR.stg"
+
+Input() ::= "b = 6<\n>"
+
+Output() ::= ""
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/AmbigLR_4.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/AmbigLR_4.stg
new file mode 100644
index 000000000..1f85517ab
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/AmbigLR_4.stg
@@ -0,0 +1,7 @@
+import "AmbigLR.stg"
+
+Input() ::= "a+b*2<\n>"
+
+Output() ::= ""
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/AmbigLR_5.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/AmbigLR_5.stg
new file mode 100644
index 000000000..3d717c1da
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/AmbigLR_5.stg
@@ -0,0 +1,7 @@
+import "AmbigLR.stg"
+
+Input() ::= "(1+2)*3<\n>"
+
+Output() ::= ""
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Declarations.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Declarations.stg
new file mode 100644
index 000000000..be1357260
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Declarations.stg
@@ -0,0 +1,28 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Rule() ::= "s"
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+s @after {<ToStringTree("$ctx"):writeln()>} : declarator EOF ; // must indicate EOF can follow
+declarator
+        : declarator '[' e ']'
+        | declarator '[' ']'
+        | declarator '(' ')'
+        | '*' declarator // binds less tight than suffixes
+        | '(' declarator ')'
+        | ID
+        ;
+e : INT ;
+ID : 'a'..'z'+ ;
+INT : '0'..'9'+ ;
+WS : (' '|'\n') -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Declarations_1.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Declarations_1.stg
new file mode 100644
index 000000000..4a766a860
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Declarations_1.stg
@@ -0,0 +1,9 @@
+import "Declarations.stg"
+
+Input() ::= "a"
+
+Output() ::= <<
+(s (declarator a) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Declarations_10.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Declarations_10.stg
new file mode 100644
index 000000000..e523135bd
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Declarations_10.stg
@@ -0,0 +1,9 @@
+import "Declarations.stg"
+
+Input() ::= "(*a)[]"
+
+Output() ::= <<
+(s (declarator (declarator ( (declarator * (declarator a)) )) [ ]) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Declarations_2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Declarations_2.stg
new file mode 100644
index 000000000..405326de7
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Declarations_2.stg
@@ -0,0 +1,9 @@
+import "Declarations.stg"
+
+Input() ::= "*a"
+
+Output() ::= <<
+(s (declarator * (declarator a)) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Declarations_3.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Declarations_3.stg
new file mode 100644
index 000000000..e5401dfa2
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Declarations_3.stg
@@ -0,0 +1,9 @@
+import "Declarations.stg"
+
+Input() ::= "**a"
+
+Output() ::= <<
+(s (declarator * (declarator * (declarator a))) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Declarations_4.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Declarations_4.stg
new file mode 100644
index 000000000..92f91b3bc
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Declarations_4.stg
@@ -0,0 +1,9 @@
+import "Declarations.stg"
+
+Input() ::= "a[3]"
+
+Output() ::= <<
+(s (declarator (declarator a) [ (e 3) ]) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Declarations_5.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Declarations_5.stg
new file mode 100644
index 000000000..7c7234804
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Declarations_5.stg
@@ -0,0 +1,9 @@
+import "Declarations.stg"
+
+Input() ::= "b[]"
+
+Output() ::= <<
+(s (declarator (declarator b) [ ]) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Declarations_6.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Declarations_6.stg
new file mode 100644
index 000000000..e0813ac51
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Declarations_6.stg
@@ -0,0 +1,9 @@
+import "Declarations.stg"
+
+Input() ::= "(a)"
+
+Output() ::= <<
+(s (declarator ( (declarator a) )) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Declarations_7.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Declarations_7.stg
new file mode 100644
index 000000000..49a638191
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Declarations_7.stg
@@ -0,0 +1,9 @@
+import "Declarations.stg"
+
+Input() ::= "a[]()"
+
+Output() ::= <<
+(s (declarator (declarator (declarator a) [ ]) ( )) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Declarations_8.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Declarations_8.stg
new file mode 100644
index 000000000..74152cbd9
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Declarations_8.stg
@@ -0,0 +1,9 @@
+import "Declarations.stg"
+
+Input() ::= "a[][]"
+
+Output() ::= <<
+(s (declarator (declarator (declarator a) [ ]) [ ]) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Declarations_9.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Declarations_9.stg
new file mode 100644
index 000000000..4094e2324
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Declarations_9.stg
@@ -0,0 +1,9 @@
+import "Declarations.stg"
+
+Input() ::= "*a[]"
+
+Output() ::= <<
+(s (declarator * (declarator (declarator a) [ ])) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/DirectCallToLeftRecursiveRule.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/DirectCallToLeftRecursiveRule.stg
new file mode 100644
index 000000000..9065d37eb
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/DirectCallToLeftRecursiveRule.stg
@@ -0,0 +1,26 @@
+/*
+ * This is a regression test for "Support direct calls to left-recursive
+ * rules".
+ * https://github.com/antlr/antlr4/issues/161
+ */
+
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Rule() ::= "a"
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a @after {<ToStringTree("$ctx"):writeln()>} : a ID
+  | ID
+  ;
+ID : 'a'..'z'+ ;
+WS : (' '|'\n') -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/DirectCallToLeftRecursiveRule_1.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/DirectCallToLeftRecursiveRule_1.stg
new file mode 100644
index 000000000..bf9542f86
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/DirectCallToLeftRecursiveRule_1.stg
@@ -0,0 +1,9 @@
+import "DirectCallToLeftRecursiveRule.stg"
+
+Input() ::= "x"
+
+Output() ::= <<
+(a x)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/DirectCallToLeftRecursiveRule_2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/DirectCallToLeftRecursiveRule_2.stg
new file mode 100644
index 000000000..ee6dd1c24
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/DirectCallToLeftRecursiveRule_2.stg
@@ -0,0 +1,9 @@
+import "DirectCallToLeftRecursiveRule.stg"
+
+Input() ::= "x y"
+
+Output() ::= <<
+(a (a x) y)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/DirectCallToLeftRecursiveRule_3.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/DirectCallToLeftRecursiveRule_3.stg
new file mode 100644
index 000000000..79c21033c
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/DirectCallToLeftRecursiveRule_3.stg
@@ -0,0 +1,9 @@
+import "DirectCallToLeftRecursiveRule.stg"
+
+Input() ::= "x y z"
+
+Output() ::= <<
+(a (a (a x) y) z)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Expressions.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Expressions.stg
new file mode 100644
index 000000000..3c3567d9f
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Expressions.stg
@@ -0,0 +1,27 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Rule() ::= "s"
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+s @after {<ToStringTree("$ctx"):writeln()>} : e EOF ; // must indicate EOF can follow
+e : e '.' ID
+  | e '.' 'this'
+  | '-' e
+  | e '*' e
+  | e ('+'|'-') e
+  | INT
+  | ID
+  ;
+ID : 'a'..'z'+ ;
+INT : '0'..'9'+ ;
+WS : (' '|'\n') -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Expressions_1.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Expressions_1.stg
new file mode 100644
index 000000000..48a8ebc6f
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Expressions_1.stg
@@ -0,0 +1,9 @@
+import "Expressions.stg"
+
+Input() ::= "a"
+
+Output() ::= <<
+(s (e a) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Expressions_2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Expressions_2.stg
new file mode 100644
index 000000000..c7c7a8fcb
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Expressions_2.stg
@@ -0,0 +1,9 @@
+import "Expressions.stg"
+
+Input() ::= "1"
+
+Output() ::= <<
+(s (e 1) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Expressions_3.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Expressions_3.stg
new file mode 100644
index 000000000..8d1ec788d
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Expressions_3.stg
@@ -0,0 +1,9 @@
+import "Expressions.stg"
+
+Input() ::= "a-1"
+
+Output() ::= <<
+(s (e (e a) - (e 1)) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Expressions_4.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Expressions_4.stg
new file mode 100644
index 000000000..2d6f42a67
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Expressions_4.stg
@@ -0,0 +1,9 @@
+import "Expressions.stg"
+
+Input() ::= "a.b"
+
+Output() ::= <<
+(s (e (e a) . b) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Expressions_5.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Expressions_5.stg
new file mode 100644
index 000000000..c7ae67194
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Expressions_5.stg
@@ -0,0 +1,9 @@
+import "Expressions.stg"
+
+Input() ::= "a.this"
+
+Output() ::= <<
+(s (e (e a) . this) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Expressions_6.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Expressions_6.stg
new file mode 100644
index 000000000..e49bd3a77
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Expressions_6.stg
@@ -0,0 +1,9 @@
+import "Expressions.stg"
+
+Input() ::= "-a"
+
+Output() ::= <<
+(s (e - (e a)) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Expressions_7.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Expressions_7.stg
new file mode 100644
index 000000000..1b13fdc99
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Expressions_7.stg
@@ -0,0 +1,9 @@
+import "Expressions.stg"
+
+Input() ::= "-a+b"
+
+Output() ::= <<
+(s (e (e - (e a)) + (e b)) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Index.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Index.stg
new file mode 100644
index 000000000..617914d9d
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Index.stg
@@ -0,0 +1,99 @@
+TestTemplates ::= [
+	"Simple_1": [],
+	"Simple_2": [],
+	"Simple_3": [],
+	"DirectCallToLeftRecursiveRule_1": [],
+	"DirectCallToLeftRecursiveRule_2": [],
+	"DirectCallToLeftRecursiveRule_3": [],
+	"SemPred": [],
+	"TernaryExpr_1": [],
+	"TernaryExpr_2": [],
+	"TernaryExpr_3": [],
+	"TernaryExpr_4": [],
+	"TernaryExpr_5": [],
+	"TernaryExpr_6": [],
+	"TernaryExpr_7": [],
+	"TernaryExpr_8": [],
+	"TernaryExpr_9": [],
+	"Expressions_1": [],
+	"Expressions_2": [],
+	"Expressions_3": [],
+	"Expressions_4": [],
+	"Expressions_5": [],
+	"Expressions_6": [],
+	"Expressions_7": [],
+	"JavaExpressions_1": [],
+	"JavaExpressions_2": [],
+	"JavaExpressions_3": [],
+	"JavaExpressions_4": [],
+	"JavaExpressions_5": [],
+	"JavaExpressions_6": [],
+	"JavaExpressions_7": [],
+	"JavaExpressions_8": [],
+	"JavaExpressions_9": [],
+	"JavaExpressions_10": [],
+	"JavaExpressions_11": [],
+	"JavaExpressions_12": [],
+	"Declarations_1": [],
+	"Declarations_2": [],
+	"Declarations_3": [],
+	"Declarations_4": [],
+	"Declarations_5": [],
+	"Declarations_6": [],
+	"Declarations_7": [],
+	"Declarations_8": [],
+	"Declarations_9": [],
+	"Declarations_10": [],
+	"ReturnValueAndActions_1": [],
+	"ReturnValueAndActions_2": [],
+	"ReturnValueAndActions_3": [],
+	"ReturnValueAndActions_4": [],
+	"LabelsOnOpSubrule_1": [],
+	"LabelsOnOpSubrule_2": [],
+	"LabelsOnOpSubrule_3": [],
+	"ReturnValueAndActionsAndLabels_1": [],
+	"ReturnValueAndActionsAndLabels_2": [],
+	"ReturnValueAndActionsAndLabels_3": [],
+	"ReturnValueAndActionsAndLabels_4": [],
+	"MultipleAlternativesWithCommonLabel_1": [],
+	"MultipleAlternativesWithCommonLabel_2": [],
+	"MultipleAlternativesWithCommonLabel_3": [],
+	"MultipleAlternativesWithCommonLabel_4": [],
+	"PrefixAndOtherAlt_1": [],
+	"PrefixAndOtherAlt_2": [],
+	"PrefixOpWithActionAndLabel_1": [],
+	"PrefixOpWithActionAndLabel_2": [],
+	"PrefixOpWithActionAndLabel_3": [],
+	"AmbigLR_1": [],
+	"AmbigLR_2": [],
+	"AmbigLR_3": [],
+	"AmbigLR_4": [],
+	"AmbigLR_5": [],
+	"WhitespaceInfluence_1": [],
+	"WhitespaceInfluence_2": [],
+	"PrecedenceFilterConsidersContext": [],
+	"MultipleActions_1": [],
+	"MultipleActions_2": [],
+	"MultipleActions_3": [],
+	"MultipleActionsPredicatesOptions_1": [],
+	"MultipleActionsPredicatesOptions_2": [],
+	"MultipleActionsPredicatesOptions_3": [],
+	"SemPredFailOption": [],
+	"TernaryExprExplicitAssociativity_1": [],
+	"TernaryExprExplicitAssociativity_2": [],
+	"TernaryExprExplicitAssociativity_3": [],
+	"TernaryExprExplicitAssociativity_4": [],
+	"TernaryExprExplicitAssociativity_5": [],
+	"TernaryExprExplicitAssociativity_6": [],
+	"TernaryExprExplicitAssociativity_7": [],
+	"TernaryExprExplicitAssociativity_8": [],
+	"TernaryExprExplicitAssociativity_9": [],
+	"ReturnValueAndActionsList1_1": [],
+	"ReturnValueAndActionsList1_2": [],
+	"ReturnValueAndActionsList1_3": [],
+	"ReturnValueAndActionsList1_4": [],
+	"ReturnValueAndActionsList2_1": [],
+	"ReturnValueAndActionsList2_2": [],
+	"ReturnValueAndActionsList2_3": [],
+	"ReturnValueAndActionsList2_4": []
+]
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/JavaExpressions.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/JavaExpressions.stg
new file mode 100644
index 000000000..b616292d5
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/JavaExpressions.stg
@@ -0,0 +1,71 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Rule() ::= "s"
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+s @after {<ToStringTree("$ctx"):writeln()>} : e EOF ; // must indicate EOF can follow
+expressionList
+    :   e (',' e)*
+    ;
+e   :   '(' e ')'
+    |   'this'
+    |   'super'
+    |   INT
+    |   ID
+    |   typespec '.' 'class'
+    |   e '.' ID
+    |   e '.' 'this'
+    |   e '.' 'super' '(' expressionList? ')'
+    |   e '.' 'new' ID '(' expressionList? ')'
+	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)
+    |   e '[' e ']'
+    |   '(' typespec ')' e
+    |   e ('++' | '--')
+    |   e '(' expressionList? ')'
+    |   ('+'|'-'|'++'|'--') e
+    |   ('~'|'!') e
+    |   e ('*'|'/'|'%') e
+    |   e ('+'|'-') e
+    |   e ('\<\<' | '>\>>' | '\>>') e
+    |   e ('\<=' | '>=' | '>' | '\<') e
+    |   e 'instanceof' e
+    |   e ('==' | '!=') e
+    |   e '&' e
+    |\<assoc=right> e '^' e
+    |   e '|' e
+    |   e '&&' e
+    |   e '||' e
+    |   e '?' e ':' e
+    |\<assoc=right>
+        e ('='
+          |'+='
+          |'-='
+          |'*='
+          |'/='
+          |'&='
+          |'|='
+          |'^='
+          |'\>>='
+          |'>\>>='
+          |'\<\<='
+          |'%=') e
+    ;
+typespec
+    : ID
+    | ID '[' ']'
+    | 'int'
+	| 'int' '[' ']'
+    ;
+ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;
+INT : '0'..'9'+ ;
+WS : (' '|'\n') -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/JavaExpressions_1.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/JavaExpressions_1.stg
new file mode 100644
index 000000000..64e53ebd5
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/JavaExpressions_1.stg
@@ -0,0 +1,9 @@
+import "JavaExpressions.stg"
+
+Input() ::= "a|b&c"
+
+Output() ::= <<
+(s (e (e a) | (e (e b) & (e c))) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/JavaExpressions_10.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/JavaExpressions_10.stg
new file mode 100644
index 000000000..57ef35197
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/JavaExpressions_10.stg
@@ -0,0 +1,9 @@
+import "JavaExpressions.stg"
+
+Input() ::= "a.f(x)==T.c"
+
+Output() ::= <<
+(s (e (e (e (e a) . f) ( (expressionList (e x)) )) == (e (e T) . c)) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/JavaExpressions_11.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/JavaExpressions_11.stg
new file mode 100644
index 000000000..4c4b05af4
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/JavaExpressions_11.stg
@@ -0,0 +1,9 @@
+import "JavaExpressions.stg"
+
+Input() ::= "a.f().g(x,1)"
+
+Output() ::= <<
+(s (e (e (e (e (e a) . f) ( )) . g) ( (expressionList (e x) , (e 1)) )) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/JavaExpressions_12.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/JavaExpressions_12.stg
new file mode 100644
index 000000000..bf2967a95
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/JavaExpressions_12.stg
@@ -0,0 +1,9 @@
+import "JavaExpressions.stg"
+
+Input() ::= "new T[((n-1) * x) + 1]"
+
+Output() ::= <<
+(s (e new (typespec T) [ (e (e ( (e (e ( (e (e n) - (e 1)) )) * (e x)) )) + (e 1)) ]) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/JavaExpressions_2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/JavaExpressions_2.stg
new file mode 100644
index 000000000..3003e275b
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/JavaExpressions_2.stg
@@ -0,0 +1,9 @@
+import "JavaExpressions.stg"
+
+Input() ::= "(a|b)&c"
+
+Output() ::= <<
+(s (e (e ( (e (e a) | (e b)) )) & (e c)) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/JavaExpressions_3.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/JavaExpressions_3.stg
new file mode 100644
index 000000000..5497a22bc
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/JavaExpressions_3.stg
@@ -0,0 +1,9 @@
+import "JavaExpressions.stg"
+
+Input() ::= "a > b"
+
+Output() ::= <<
+(s (e (e a) > (e b)) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/JavaExpressions_4.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/JavaExpressions_4.stg
new file mode 100644
index 000000000..9af1c628a
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/JavaExpressions_4.stg
@@ -0,0 +1,9 @@
+import "JavaExpressions.stg"
+
+Input() ::= "a >> b"
+
+Output() ::= <<
+(s (e (e a) \>> (e b)) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/JavaExpressions_5.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/JavaExpressions_5.stg
new file mode 100644
index 000000000..5e10ce72d
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/JavaExpressions_5.stg
@@ -0,0 +1,9 @@
+import "JavaExpressions.stg"
+
+Input() ::= "a=b=c"
+
+Output() ::= <<
+(s (e (e a) = (e (e b) = (e c))) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/JavaExpressions_6.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/JavaExpressions_6.stg
new file mode 100644
index 000000000..a6cef295e
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/JavaExpressions_6.stg
@@ -0,0 +1,9 @@
+import "JavaExpressions.stg"
+
+Input() ::= "a^b^c"
+
+Output() ::= <<
+(s (e (e a) ^ (e (e b) ^ (e c))) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/JavaExpressions_7.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/JavaExpressions_7.stg
new file mode 100644
index 000000000..51ef17921
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/JavaExpressions_7.stg
@@ -0,0 +1,9 @@
+import "JavaExpressions.stg"
+
+Input() ::= "(T)x"
+
+Output() ::= <<
+(s (e ( (typespec T) ) (e x)) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/JavaExpressions_8.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/JavaExpressions_8.stg
new file mode 100644
index 000000000..9d5f0ed4b
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/JavaExpressions_8.stg
@@ -0,0 +1,9 @@
+import "JavaExpressions.stg"
+
+Input() ::= "new A().b"
+
+Output() ::= <<
+(s (e (e new (typespec A) ( )) . b) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/JavaExpressions_9.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/JavaExpressions_9.stg
new file mode 100644
index 000000000..1c11b116b
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/JavaExpressions_9.stg
@@ -0,0 +1,9 @@
+import "JavaExpressions.stg"
+
+Input() ::= "(T)t.f()"
+
+Output() ::= <<
+(s (e (e ( (typespec T) ) (e (e t) . f)) ( )) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/LabelsOnOpSubrule.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/LabelsOnOpSubrule.stg
new file mode 100644
index 000000000..3123f09c5
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/LabelsOnOpSubrule.stg
@@ -0,0 +1,22 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Rule() ::= "s"
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+s @after {<ToStringTree("$ctx"):writeln()>} : e;
+e : a=e op=('*'|'/') b=e  {}
+  | INT {}
+  | '(' x=e ')' {}
+  ;
+INT : '0'..'9'+ ;
+WS : (' '|'\n') -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/LabelsOnOpSubrule_1.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/LabelsOnOpSubrule_1.stg
new file mode 100644
index 000000000..d82a5d009
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/LabelsOnOpSubrule_1.stg
@@ -0,0 +1,9 @@
+import "LabelsOnOpSubrule.stg"
+
+Input() ::= "4"
+
+Output() ::= <<
+(s (e 4))<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/LabelsOnOpSubrule_2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/LabelsOnOpSubrule_2.stg
new file mode 100644
index 000000000..86f907680
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/LabelsOnOpSubrule_2.stg
@@ -0,0 +1,9 @@
+import "LabelsOnOpSubrule.stg"
+
+Input() ::= "1*2/3"
+
+Output() ::= <<
+(s (e (e (e 1) * (e 2)) / (e 3)))<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/LabelsOnOpSubrule_3.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/LabelsOnOpSubrule_3.stg
new file mode 100644
index 000000000..81af16431
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/LabelsOnOpSubrule_3.stg
@@ -0,0 +1,9 @@
+import "LabelsOnOpSubrule.stg"
+
+Input() ::= "(1/2)*3"
+
+Output() ::= <<
+(s (e (e ( (e (e 1) / (e 2)) )) * (e 3)))<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/MultipleActions.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/MultipleActions.stg
new file mode 100644
index 000000000..35e666ea5
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/MultipleActions.stg
@@ -0,0 +1,28 @@
+/*
+ * This is a regression test for antlr/antlr4#625 "Duplicate action breaks
+ * operator precedence"
+ * https://github.com/antlr/antlr4/issues/625
+ */
+
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Rule() ::= "s"
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+s @after {<ToStringTree("$ctx"):writeln()>} : e ;
+e : a=e op=('*'|'/') b=e  {}{}
+  | INT {}{}
+  | '(' x=e ')' {}{}
+  ;
+INT : '0'..'9'+ ;
+WS : (' '|'\n') -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/MultipleActionsPredicatesOptions.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/MultipleActionsPredicatesOptions.stg
new file mode 100644
index 000000000..c7e7aa017
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/MultipleActionsPredicatesOptions.stg
@@ -0,0 +1,29 @@
+/*
+ * This is a regression test for antlr/antlr4#625 "Duplicate action breaks
+ * operator precedence"
+ * https://github.com/antlr/antlr4/issues/625
+ */
+
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Rule() ::= "s"
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+s @after {<ToStringTree("$ctx"):writeln()>} : e ;
+e : a=e op=('*'|'/') b=e  {}{<True()>}?
+  | a=e op=('+'|'-') b=e  {}\<p=3>{<True()>}?\<fail='Message'>
+  | INT {}{}
+  | '(' x=e ')' {}{}
+  ;
+INT : '0'..'9'+ ;
+WS : (' '|'\n') -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/MultipleActionsPredicatesOptions_1.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/MultipleActionsPredicatesOptions_1.stg
new file mode 100644
index 000000000..eee78503b
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/MultipleActionsPredicatesOptions_1.stg
@@ -0,0 +1,9 @@
+import "MultipleActionsPredicatesOptions.stg"
+
+Input() ::= "4"
+
+Output() ::= <<
+(s (e 4))<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/MultipleActionsPredicatesOptions_2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/MultipleActionsPredicatesOptions_2.stg
new file mode 100644
index 000000000..8430fd831
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/MultipleActionsPredicatesOptions_2.stg
@@ -0,0 +1,9 @@
+import "MultipleActionsPredicatesOptions.stg"
+
+Input() ::= "1*2/3"
+
+Output() ::= <<
+(s (e (e (e 1) * (e 2)) / (e 3)))<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/MultipleActionsPredicatesOptions_3.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/MultipleActionsPredicatesOptions_3.stg
new file mode 100644
index 000000000..bb5215d14
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/MultipleActionsPredicatesOptions_3.stg
@@ -0,0 +1,9 @@
+import "MultipleActionsPredicatesOptions.stg"
+
+Input() ::= "(1/2)*3"
+
+Output() ::= <<
+(s (e (e ( (e (e 1) / (e 2)) )) * (e 3)))<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/MultipleActions_1.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/MultipleActions_1.stg
new file mode 100644
index 000000000..217356d2d
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/MultipleActions_1.stg
@@ -0,0 +1,9 @@
+import "MultipleActions.stg"
+
+Input() ::= "4"
+
+Output() ::= <<
+(s (e 4))<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/MultipleActions_2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/MultipleActions_2.stg
new file mode 100644
index 000000000..a3aa1ba90
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/MultipleActions_2.stg
@@ -0,0 +1,9 @@
+import "MultipleActions.stg"
+
+Input() ::= "1*2/3"
+
+Output() ::= <<
+(s (e (e (e 1) * (e 2)) / (e 3)))<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/MultipleActions_3.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/MultipleActions_3.stg
new file mode 100644
index 000000000..94957bd89
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/MultipleActions_3.stg
@@ -0,0 +1,9 @@
+import "MultipleActions.stg"
+
+Input() ::= "(1/2)*3"
+
+Output() ::= <<
+(s (e (e ( (e (e 1) / (e 2)) )) * (e 3)))<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/MultipleAlternativesWithCommonLabel.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/MultipleAlternativesWithCommonLabel.stg
new file mode 100644
index 000000000..1fc0c9700
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/MultipleAlternativesWithCommonLabel.stg
@@ -0,0 +1,37 @@
+/*
+ * This is a regression test for antlr/antlr4#433 "Not all context accessor
+ * methods are generated when an alternative rule label is used for multiple
+ * alternatives".
+ * https://github.com/antlr/antlr4/issues/433
+ */
+
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Rule() ::= "s"
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+s : e {<writeln("$e.v")>};
+e returns [int v]
+  : e '*' e     {$v = <Cast("BinaryContext","$ctx")>.e(0).v * <Cast("BinaryContext","$ctx")>.e(1).v;}  # binary
+  | e '+' e     {$v = <Cast("BinaryContext","$ctx")>.e(0).v + <Cast("BinaryContext","$ctx")>.e(1).v;}  # binary
+  | INT         {$v = $INT.int;}                   # anInt
+  | '(' e ')'   {$v = $e.v;}                       # parens
+  | left=e INC  {<Cast("UnaryContext","$ctx"):Concat(".INC() != null"):Assert()>$v = $left.v + 1;}      # unary
+  | left=e DEC  {<Cast("UnaryContext","$ctx"):Concat(".DEC() != null"):Assert()>$v = $left.v - 1;}      # unary
+  | ID          {<AssignLocal("$v","3")>}                                                     # anID
+  ;
+ID : 'a'..'z'+ ;
+INT : '0'..'9'+ ;
+INC : '++' ;
+DEC : '--' ;
+WS : (' '|'\n') -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/MultipleAlternativesWithCommonLabel_1.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/MultipleAlternativesWithCommonLabel_1.stg
new file mode 100644
index 000000000..0ae39e989
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/MultipleAlternativesWithCommonLabel_1.stg
@@ -0,0 +1,9 @@
+import "MultipleAlternativesWithCommonLabel.stg"
+
+Input() ::= "4"
+
+Output() ::= <<
+4<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/MultipleAlternativesWithCommonLabel_2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/MultipleAlternativesWithCommonLabel_2.stg
new file mode 100644
index 000000000..0c7156d3a
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/MultipleAlternativesWithCommonLabel_2.stg
@@ -0,0 +1,9 @@
+import "MultipleAlternativesWithCommonLabel.stg"
+
+Input() ::= "1+2"
+
+Output() ::= <<
+3<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/MultipleAlternativesWithCommonLabel_3.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/MultipleAlternativesWithCommonLabel_3.stg
new file mode 100644
index 000000000..3b87e8756
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/MultipleAlternativesWithCommonLabel_3.stg
@@ -0,0 +1,9 @@
+import "MultipleAlternativesWithCommonLabel.stg"
+
+Input() ::= "1+2*3"
+
+Output() ::= <<
+7<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/MultipleAlternativesWithCommonLabel_4.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/MultipleAlternativesWithCommonLabel_4.stg
new file mode 100644
index 000000000..abb284acc
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/MultipleAlternativesWithCommonLabel_4.stg
@@ -0,0 +1,9 @@
+import "MultipleAlternativesWithCommonLabel.stg"
+
+Input() ::= "i++*3"
+
+Output() ::= <<
+12<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/PrecedenceFilterConsidersContext.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/PrecedenceFilterConsidersContext.stg
new file mode 100644
index 000000000..fb319e1a6
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/PrecedenceFilterConsidersContext.stg
@@ -0,0 +1,34 @@
+/**
+ * This is a regression test for antlr/antlr4#509 "Incorrect rule chosen in
+ * unambiguous grammar".
+ * https://github.com/antlr/antlr4/issues/509
+ */
+
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "aa"
+
+Rule() ::= "prog"
+
+Output() ::= <<
+(prog (statement (letterA a)) (statement (letterA a)) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+prog 
+@after {<ToStringTree("$ctx"):writeln()>}
+: statement* EOF {};
+statement: letterA | statement letterA 'b' ;
+letterA: 'a';
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/PrefixAndOtherAlt.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/PrefixAndOtherAlt.stg
new file mode 100644
index 000000000..37d022826
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/PrefixAndOtherAlt.stg
@@ -0,0 +1,24 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Rule() ::= "s"
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+s @after {<ToStringTree("$ctx"):writeln()>} : expr EOF ; 
+expr : literal
+     | op expr
+     | expr op expr
+     ;
+literal : '-'? Integer ;
+op : '+' | '-' ;
+Integer : [0-9]+ ;
+WS : (' '|'\n') -> skip ;
+>>
\ No newline at end of file
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/PrefixAndOtherAlt_1.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/PrefixAndOtherAlt_1.stg
new file mode 100644
index 000000000..553b557f0
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/PrefixAndOtherAlt_1.stg
@@ -0,0 +1,9 @@
+import "PrefixAndOtherAlt.stg"
+
+Input() ::= "-1"
+
+Output() ::= <<
+(s (expr (literal - 1)) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
\ No newline at end of file
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/PrefixAndOtherAlt_2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/PrefixAndOtherAlt_2.stg
new file mode 100644
index 000000000..de4cea9c5
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/PrefixAndOtherAlt_2.stg
@@ -0,0 +1,9 @@
+import "PrefixAndOtherAlt.stg"
+
+Input() ::= "-1 + -1"
+
+Output() ::= <<
+(s (expr (expr (literal - 1)) (op +) (expr (literal - 1))) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
\ No newline at end of file
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/PrefixOpWithActionAndLabel.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/PrefixOpWithActionAndLabel.stg
new file mode 100644
index 000000000..8905e97f6
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/PrefixOpWithActionAndLabel.stg
@@ -0,0 +1,24 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Rule() ::= "s"
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+s : e {<writeln("$e.result")>} ;
+e returns [String result]
+    :   ID '=' e1=e    {$result = "(" + $ID.text + "=" + $e1.result + ")";}
+    |   ID             {$result = $ID.text;}
+    |   e1=e '+' e2=e  {$result = "(" + $e1.result + "+" + $e2.result + ")";}
+    ;
+ID : 'a'..'z'+ ;
+INT : '0'..'9'+ ;
+WS : (' '|'\n') -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/PrefixOpWithActionAndLabel_1.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/PrefixOpWithActionAndLabel_1.stg
new file mode 100644
index 000000000..904991365
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/PrefixOpWithActionAndLabel_1.stg
@@ -0,0 +1,9 @@
+import "PrefixOpWithActionAndLabel.stg"
+
+Input() ::= "a"
+
+Output() ::= <<
+a<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/PrefixOpWithActionAndLabel_2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/PrefixOpWithActionAndLabel_2.stg
new file mode 100644
index 000000000..cb49e6f24
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/PrefixOpWithActionAndLabel_2.stg
@@ -0,0 +1,9 @@
+import "PrefixOpWithActionAndLabel.stg"
+
+Input() ::= "a+b"
+
+Output() ::= <<
+(a+b)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/PrefixOpWithActionAndLabel_3.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/PrefixOpWithActionAndLabel_3.stg
new file mode 100644
index 000000000..88be5ae7e
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/PrefixOpWithActionAndLabel_3.stg
@@ -0,0 +1,9 @@
+import "PrefixOpWithActionAndLabel.stg"
+
+Input() ::= "a=b+c"
+
+Output() ::= <<
+((a=b)+c)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActions.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActions.stg
new file mode 100644
index 000000000..8ede4dca3
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActions.stg
@@ -0,0 +1,25 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Rule() ::= "s"
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+s : e {<writeln("$e.v")>}; 
+e returns [int v, <StringList()> ignored]
+  : a=e '*' b=e {$v = $a.v * $b.v;}
+  | a=e '+' b=e {$v = $a.v + $b.v;}
+  | INT {$v = $INT.int;}
+  | '(' x=e ')' {$v = $x.v;}
+  ;
+INT : '0'..'9'+ ;
+WS : (' '|'\n') -> skip ;
+
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActionsAndLabels.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActionsAndLabels.stg
new file mode 100644
index 000000000..8c01e6d2e
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActionsAndLabels.stg
@@ -0,0 +1,28 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Rule() ::= "s"
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+s : q=e {<writeln("$e.v")>}; 
+e returns [int v]
+  : a=e op='*' b=e {$v = $a.v * $b.v;}  # mult
+  | a=e '+' b=e {$v = $a.v + $b.v;}     # add
+  | INT         {$v = $INT.int;}        # anInt
+  | '(' x=e ')' {$v = $x.v;}            # parens
+  | x=e '++'    {$v = $x.v+1;}          # inc
+  | e '--'                              # dec
+  | ID          {$v = 3;}               # anID
+  ; 
+ID : 'a'..'z'+ ;
+INT : '0'..'9'+ ;
+WS : (' '|'\n') -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActionsAndLabels_1.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActionsAndLabels_1.stg
new file mode 100644
index 000000000..dbf3eeaa3
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActionsAndLabels_1.stg
@@ -0,0 +1,9 @@
+import "ReturnValueAndActionsAndLabels.stg"
+
+Input() ::= "4"
+
+Output() ::= <<
+4<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActionsAndLabels_2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActionsAndLabels_2.stg
new file mode 100644
index 000000000..df5a2ac08
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActionsAndLabels_2.stg
@@ -0,0 +1,9 @@
+import "ReturnValueAndActionsAndLabels.stg"
+
+Input() ::= "1+2"
+
+Output() ::= <<
+3<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActionsAndLabels_3.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActionsAndLabels_3.stg
new file mode 100644
index 000000000..7b17e0726
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActionsAndLabels_3.stg
@@ -0,0 +1,9 @@
+import "ReturnValueAndActionsAndLabels.stg"
+
+Input() ::= "1+2*3"
+
+Output() ::= <<
+7<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActionsAndLabels_4.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActionsAndLabels_4.stg
new file mode 100644
index 000000000..209399756
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActionsAndLabels_4.stg
@@ -0,0 +1,9 @@
+import "ReturnValueAndActionsAndLabels.stg"
+
+Input() ::= "i++*3"
+
+Output() ::= <<
+12<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActionsList1.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActionsList1.stg
new file mode 100644
index 000000000..4c75d2fda
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActionsList1.stg
@@ -0,0 +1,36 @@
+/*
+ * This is a regression test for antlr/antlr4#677 "labels not working in grammar
+ * file".
+ * https://github.com/antlr/antlr4/issues/677
+ *
+ * This test treats `,` and `>>` as part of a single compound operator (similar
+ * to a ternary operator).
+ */
+
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Rule() ::= "s"
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+s @after {<ToStringTree("$ctx"):writeln()>} : expr EOF;
+expr:
+    a=expr '*' a=expr #Factor
+    | b+=expr (',' b+=expr)* '\>>' c=expr #Send
+    | ID #JustId //semantic check on modifiers
+;
+
+ID  : ('a'..'z'|'A'..'Z'|'_')
+      ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*
+;
+
+WS : [ \t\n]+ -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActionsList1_1.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActionsList1_1.stg
new file mode 100644
index 000000000..df69393fb
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActionsList1_1.stg
@@ -0,0 +1,9 @@
+import "ReturnValueAndActionsList1.stg"
+
+Input() ::= "a*b"
+
+Output() ::= <<
+(s (expr (expr a) * (expr b)) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActionsList1_2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActionsList1_2.stg
new file mode 100644
index 000000000..474ac224f
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActionsList1_2.stg
@@ -0,0 +1,9 @@
+import "ReturnValueAndActionsList1.stg"
+
+Input() ::= "a,c>>x"
+
+Output() ::= <<
+(s (expr (expr a) , (expr c) \>> (expr x)) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActionsList1_3.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActionsList1_3.stg
new file mode 100644
index 000000000..ab421a3d7
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActionsList1_3.stg
@@ -0,0 +1,9 @@
+import "ReturnValueAndActionsList1.stg"
+
+Input() ::= "x"
+
+Output() ::= <<
+(s (expr x) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActionsList1_4.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActionsList1_4.stg
new file mode 100644
index 000000000..8b29d1c81
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActionsList1_4.stg
@@ -0,0 +1,9 @@
+import "ReturnValueAndActionsList1.stg"
+
+Input() ::= "a*b,c,x*y>>r"
+
+Output() ::= <<
+(s (expr (expr (expr a) * (expr b)) , (expr c) , (expr (expr x) * (expr y)) \>> (expr r)) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActionsList2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActionsList2.stg
new file mode 100644
index 000000000..cbd48a36f
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActionsList2.stg
@@ -0,0 +1,34 @@
+/*
+ * This is a regression test for antlr/antlr4#677 "labels not working in grammar
+ * file".
+ * https://github.com/antlr/antlr4/issues/677
+ *
+ * This test treats the `,` and `>>` operators separately.
+ */
+
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Rule() ::= "s"
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+s @after {<ToStringTree("$ctx"):writeln()>} : expr EOF;
+expr:
+    a=expr '*' a=expr #Factor
+    | b+=expr ',' b+=expr #Comma
+    | b+=expr '\>>' c=expr #Send
+    | ID #JustId //semantic check on modifiers
+	;
+ID  : ('a'..'z'|'A'..'Z'|'_')
+      ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*
+;
+WS : [ \t\n]+ -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActionsList2_1.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActionsList2_1.stg
new file mode 100644
index 000000000..a72a865d8
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActionsList2_1.stg
@@ -0,0 +1,9 @@
+import "ReturnValueAndActionsList2.stg"
+
+Input() ::= "a*b"
+
+Output() ::= <<
+(s (expr (expr a) * (expr b)) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActionsList2_2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActionsList2_2.stg
new file mode 100644
index 000000000..cbf017915
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActionsList2_2.stg
@@ -0,0 +1,9 @@
+import "ReturnValueAndActionsList2.stg"
+
+Input() ::= "a,c>>x"
+
+Output() ::= <<
+(s (expr (expr (expr a) , (expr c)) \>> (expr x)) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActionsList2_3.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActionsList2_3.stg
new file mode 100644
index 000000000..14f369a94
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActionsList2_3.stg
@@ -0,0 +1,9 @@
+import "ReturnValueAndActionsList2.stg"
+
+Input() ::= "x"
+
+Output() ::= <<
+(s (expr x) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActionsList2_4.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActionsList2_4.stg
new file mode 100644
index 000000000..b54dc7005
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActionsList2_4.stg
@@ -0,0 +1,9 @@
+import "ReturnValueAndActionsList2.stg"
+
+Input() ::= "a*b,c,x*y>>r"
+
+Output() ::= <<
+(s (expr (expr (expr (expr (expr a) * (expr b)) , (expr c)) , (expr (expr x) * (expr y))) \>> (expr r)) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActions_1.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActions_1.stg
new file mode 100644
index 000000000..bc4bafb0c
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActions_1.stg
@@ -0,0 +1,9 @@
+import "ReturnValueAndActions.stg"
+
+Input() ::= "4"
+
+Output() ::= <<
+4<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActions_2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActions_2.stg
new file mode 100644
index 000000000..000d6ef77
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActions_2.stg
@@ -0,0 +1,9 @@
+import "ReturnValueAndActions.stg"
+
+Input() ::= "1+2"
+
+Output() ::= <<
+3<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActions_3.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActions_3.stg
new file mode 100644
index 000000000..51d8afcb8
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActions_3.stg
@@ -0,0 +1,9 @@
+import "ReturnValueAndActions.stg"
+
+Input() ::= "1+2*3"
+
+Output() ::= <<
+7<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActions_4.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActions_4.stg
new file mode 100644
index 000000000..4d6724825
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/ReturnValueAndActions_4.stg
@@ -0,0 +1,9 @@
+import "ReturnValueAndActions.stg"
+
+Input() ::= "(1+2)*3"
+
+Output() ::= <<
+9<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/SemPred.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/SemPred.stg
new file mode 100644
index 000000000..0ebd6f642
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/SemPred.stg
@@ -0,0 +1,29 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "x y z"
+
+Rule() ::= "s"
+
+Output() ::= <<
+(s (a (a (a x) y) z))<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+s @after {<ToStringTree("$ctx"):writeln()>} : a ;
+a : a {<True()>}? ID
+  | ID
+  ;
+ID : 'a'..'z'+ ;
+WS : (' '|'\n') -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/SemPredFailOption.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/SemPredFailOption.stg
new file mode 100644
index 000000000..d3354fb59
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/SemPredFailOption.stg
@@ -0,0 +1,31 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "x y z"
+
+Rule() ::= "s"
+
+Output() ::= <<
+(s (a (a x) y z))<\n>
+>>
+
+Errors() ::= <<
+line 1:4 rule a custom message<\n>
+>>
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+s @after {<ToStringTree("$ctx"):writeln()>} : a ;
+a : a ID {<False()>}?\<fail='custom message'>
+  | ID
+  ;
+ID : 'a'..'z'+ ;
+WS : (' '|'\n') -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Simple.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Simple.stg
new file mode 100644
index 000000000..1a6e9d89f
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Simple.stg
@@ -0,0 +1,21 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Rule() ::= "s"
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+s @after {<ToStringTree("$ctx"):writeln()>} : a ;
+a : a ID
+  | ID
+  ;
+ID : 'a'..'z'+ ;
+WS : (' '|'\n') -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Simple_1.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Simple_1.stg
new file mode 100644
index 000000000..794d7fc36
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Simple_1.stg
@@ -0,0 +1,9 @@
+import "Simple.stg"
+
+Input() ::= "x"
+
+Output() ::= <<
+(s (a x))<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Simple_2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Simple_2.stg
new file mode 100644
index 000000000..0557855d1
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Simple_2.stg
@@ -0,0 +1,9 @@
+import "Simple.stg"
+
+Input() ::= "x y"
+
+Output() ::= <<
+(s (a (a x) y))<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Simple_3.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Simple_3.stg
new file mode 100644
index 000000000..864cf9125
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/Simple_3.stg
@@ -0,0 +1,9 @@
+import "Simple.stg"
+
+Input() ::= "x y z"
+
+Output() ::= <<
+(s (a (a (a x) y) z))<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExpr.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExpr.stg
new file mode 100644
index 000000000..44e741441
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExpr.stg
@@ -0,0 +1,24 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Rule() ::= "s"
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+s @after {<ToStringTree("$ctx"):writeln()>} : e EOF ; // must indicate EOF can follow or 'a\<EOF>' won't match
+e : e '*' e
+  | e '+' e
+  |\<assoc=right> e '?' e ':' e
+  |\<assoc=right> e '=' e
+  | ID
+  ;
+ID : 'a'..'z'+ ;
+WS : (' '|'\n') -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExprExplicitAssociativity.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExprExplicitAssociativity.stg
new file mode 100644
index 000000000..9c1474c42
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExprExplicitAssociativity.stg
@@ -0,0 +1,30 @@
+/**
+ * This is a regression test for antlr/antlr4#542 "First alternative cannot
+ * be right-associative".
+ * https://github.com/antlr/antlr4/issues/542
+ */
+
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Rule() ::= "s"
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+s @after {<ToStringTree("$ctx"):writeln()>} : e EOF; // must indicate EOF can follow or 'a\<EOF>' won't match
+e :\<assoc=right> e '*' e
+  |\<assoc=right> e '+' e
+  |\<assoc=right> e '?' e ':' e
+  |\<assoc=right> e '=' e
+  | ID
+  ;
+ID : 'a'..'z'+ ;
+WS : (' '|'\n') -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExprExplicitAssociativity_1.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExprExplicitAssociativity_1.stg
new file mode 100644
index 000000000..b413657be
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExprExplicitAssociativity_1.stg
@@ -0,0 +1,9 @@
+import "TernaryExprExplicitAssociativity.stg"
+
+Input() ::= "a"
+
+Output() ::= <<
+(s (e a) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExprExplicitAssociativity_2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExprExplicitAssociativity_2.stg
new file mode 100644
index 000000000..d0177e1cd
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExprExplicitAssociativity_2.stg
@@ -0,0 +1,9 @@
+import "TernaryExprExplicitAssociativity.stg"
+
+Input() ::= "a+b"
+
+Output() ::= <<
+(s (e (e a) + (e b)) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExprExplicitAssociativity_3.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExprExplicitAssociativity_3.stg
new file mode 100644
index 000000000..468829d63
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExprExplicitAssociativity_3.stg
@@ -0,0 +1,9 @@
+import "TernaryExprExplicitAssociativity.stg"
+
+Input() ::= "a*b"
+
+Output() ::= <<
+(s (e (e a) * (e b)) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExprExplicitAssociativity_4.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExprExplicitAssociativity_4.stg
new file mode 100644
index 000000000..17c3ba21d
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExprExplicitAssociativity_4.stg
@@ -0,0 +1,9 @@
+import "TernaryExprExplicitAssociativity.stg"
+
+Input() ::= "a?b:c"
+
+Output() ::= <<
+(s (e (e a) ? (e b) : (e c)) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExprExplicitAssociativity_5.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExprExplicitAssociativity_5.stg
new file mode 100644
index 000000000..8fb3db78d
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExprExplicitAssociativity_5.stg
@@ -0,0 +1,9 @@
+import "TernaryExprExplicitAssociativity.stg"
+
+Input() ::= "a=b=c"
+
+Output() ::= <<
+(s (e (e a) = (e (e b) = (e c))) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExprExplicitAssociativity_6.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExprExplicitAssociativity_6.stg
new file mode 100644
index 000000000..37db32fb1
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExprExplicitAssociativity_6.stg
@@ -0,0 +1,9 @@
+import "TernaryExprExplicitAssociativity.stg"
+
+Input() ::= "a?b+c:d"
+
+Output() ::= <<
+(s (e (e a) ? (e (e b) + (e c)) : (e d)) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExprExplicitAssociativity_7.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExprExplicitAssociativity_7.stg
new file mode 100644
index 000000000..3df3f385f
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExprExplicitAssociativity_7.stg
@@ -0,0 +1,9 @@
+import "TernaryExprExplicitAssociativity.stg"
+
+Input() ::= "a?b=c:d"
+
+Output() ::= <<
+(s (e (e a) ? (e (e b) = (e c)) : (e d)) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExprExplicitAssociativity_8.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExprExplicitAssociativity_8.stg
new file mode 100644
index 000000000..c7341f89d
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExprExplicitAssociativity_8.stg
@@ -0,0 +1,9 @@
+import "TernaryExprExplicitAssociativity.stg"
+
+Input() ::= "a? b?c:d : e"
+
+Output() ::= <<
+(s (e (e a) ? (e (e b) ? (e c) : (e d)) : (e e)) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExprExplicitAssociativity_9.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExprExplicitAssociativity_9.stg
new file mode 100644
index 000000000..ab175e9ef
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExprExplicitAssociativity_9.stg
@@ -0,0 +1,9 @@
+import "TernaryExprExplicitAssociativity.stg"
+
+Input() ::= "a?b: c?d:e"
+
+Output() ::= <<
+(s (e (e a) ? (e b) : (e (e c) ? (e d) : (e e))) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExpr_1.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExpr_1.stg
new file mode 100644
index 000000000..5dc8fa61f
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExpr_1.stg
@@ -0,0 +1,9 @@
+import "TernaryExpr.stg"
+
+Input() ::= "a"
+
+Output() ::= <<
+(s (e a) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExpr_2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExpr_2.stg
new file mode 100644
index 000000000..e5d0d0ecc
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExpr_2.stg
@@ -0,0 +1,9 @@
+import "TernaryExpr.stg"
+
+Input() ::= "a+b"
+
+Output() ::= <<
+(s (e (e a) + (e b)) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExpr_3.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExpr_3.stg
new file mode 100644
index 000000000..c4590db3e
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExpr_3.stg
@@ -0,0 +1,9 @@
+import "TernaryExpr.stg"
+
+Input() ::= "a*b"
+
+Output() ::= <<
+(s (e (e a) * (e b)) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExpr_4.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExpr_4.stg
new file mode 100644
index 000000000..7dcc04a6f
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExpr_4.stg
@@ -0,0 +1,9 @@
+import "TernaryExpr.stg"
+
+Input() ::= "a?b:c"
+
+Output() ::= <<
+(s (e (e a) ? (e b) : (e c)) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExpr_5.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExpr_5.stg
new file mode 100644
index 000000000..fbbe57224
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExpr_5.stg
@@ -0,0 +1,9 @@
+import "TernaryExpr.stg"
+
+Input() ::= "a=b=c"
+
+Output() ::= <<
+(s (e (e a) = (e (e b) = (e c))) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExpr_6.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExpr_6.stg
new file mode 100644
index 000000000..809787d21
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExpr_6.stg
@@ -0,0 +1,9 @@
+import "TernaryExpr.stg"
+
+Input() ::= "a?b+c:d"
+
+Output() ::= <<
+(s (e (e a) ? (e (e b) + (e c)) : (e d)) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExpr_7.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExpr_7.stg
new file mode 100644
index 000000000..c17dbd88f
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExpr_7.stg
@@ -0,0 +1,9 @@
+import "TernaryExpr.stg"
+
+Input() ::= "a?b=c:d"
+
+Output() ::= <<
+(s (e (e a) ? (e (e b) = (e c)) : (e d)) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExpr_8.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExpr_8.stg
new file mode 100644
index 000000000..5bf7b508e
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExpr_8.stg
@@ -0,0 +1,9 @@
+import "TernaryExpr.stg"
+
+Input() ::= "a? b?c:d : e"
+
+Output() ::= <<
+(s (e (e a) ? (e (e b) ? (e c) : (e d)) : (e e)) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExpr_9.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExpr_9.stg
new file mode 100644
index 000000000..e7baecc00
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/TernaryExpr_9.stg
@@ -0,0 +1,9 @@
+import "TernaryExpr.stg"
+
+Input() ::= "a?b: c?d:e"
+
+Output() ::= <<
+(s (e (e a) ? (e b) : (e (e c) ? (e d) : (e e))) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/WhitespaceInfluence.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/WhitespaceInfluence.stg
new file mode 100644
index 000000000..35c824e26
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/WhitespaceInfluence.stg
@@ -0,0 +1,69 @@
+/*
+ * This is a regression test for #239 "recoursive parser using implicit tokens
+ * ignore white space lexer rule".
+ * https://github.com/antlr/antlr4/issues/239
+ */
+
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"Expr": {<grammar("Expr")>}
+]
+
+Rule() ::= "prog"
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+prog : expression EOF;
+expression
+    : ID '(' expression (',' expression)* ')'               # doFunction
+    | '(' expression ')'                                    # doParenthesis
+    | '!' expression                                        # doNot
+    | '-' expression                                        # doNegate
+    | '+' expression                                        # doPositiv
+    | expression '^' expression                             # doPower
+    | expression '*' expression                             # doMultipy
+    | expression '/' expression                             # doDivide
+    | expression '%' expression                             # doModulo
+    | expression '-' expression                             # doMinus
+    | expression '+' expression                             # doPlus
+    | expression '=' expression                             # doEqual
+    | expression '!=' expression                            # doNotEqual
+    | expression '>' expression                             # doGreather
+    | expression '>=' expression                            # doGreatherEqual
+    | expression '\<' expression                             # doLesser
+    | expression '\<=' expression                            # doLesserEqual
+    | expression K_IN '(' expression (',' expression)* ')'  # doIn
+    | expression ( '&' | K_AND) expression                  # doAnd
+    | expression ( '|' | K_OR) expression                   # doOr
+    | '[' expression (',' expression)* ']'                  # newArray
+    | K_TRUE                                                # newTrueBoolean
+    | K_FALSE                                               # newFalseBoolean
+    | NUMBER                                                # newNumber
+    | DATE                                                  # newDateTime
+    | ID                                                    # newIdentifier
+    | SQ_STRING                                             # newString
+    | K_NULL                                                # newNull
+    ;
+
+// Fragments
+fragment DIGIT    : '0' .. '9';  
+fragment UPPER    : 'A' .. 'Z';
+fragment LOWER    : 'a' .. 'z';
+fragment LETTER   : LOWER | UPPER;
+fragment WORD     : LETTER | '_' | '$' | '#' | '.';
+fragment ALPHANUM : WORD | DIGIT;  
+
+// Tokens
+ID              : LETTER ALPHANUM*;
+NUMBER          : DIGIT+ ('.' DIGIT+)? (('e'|'E')('+'|'-')? DIGIT+)?;
+DATE            : '\'' DIGIT DIGIT DIGIT DIGIT '-' DIGIT DIGIT '-' DIGIT DIGIT (' ' DIGIT DIGIT ':' DIGIT DIGIT ':' DIGIT DIGIT ('.' DIGIT+)?)? '\'';
+SQ_STRING       : '\'' ('\'\'' | ~'\'')* '\'';
+DQ_STRING       : '"' ('\\\\"' | ~'"')* '"';
+WS              : [ \t\n\r]+ -> skip ;
+COMMENTS        : ('/*' .*? '*/' | '//' ~'\n'* '\n' ) -> skip;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/WhitespaceInfluence_1.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/WhitespaceInfluence_1.stg
new file mode 100644
index 000000000..2bdd59448
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/WhitespaceInfluence_1.stg
@@ -0,0 +1,7 @@
+import "WhitespaceInfluence.stg"
+
+Input() ::= "Test(1,3)"
+
+Output() ::= ""
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/WhitespaceInfluence_2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/WhitespaceInfluence_2.stg
new file mode 100644
index 000000000..6f16ef2dd
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LeftRecursion/WhitespaceInfluence_2.stg
@@ -0,0 +1,7 @@
+import "WhitespaceInfluence.stg"
+
+Input() ::= "Test(1, 3)"
+
+Output() ::= ""
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerErrors/DFAToATNThatFailsBackToDFA.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerErrors/DFAToATNThatFailsBackToDFA.stg
new file mode 100644
index 000000000..785f0d4d1
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerErrors/DFAToATNThatFailsBackToDFA.stg
@@ -0,0 +1,27 @@
+// The first ab caches the DFA then abx goes through the DFA but
+// into the ATN for the x, which fails. Must go back into DFA
+// and return to previous dfa accept state
+
+TestType() ::= "Lexer"
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+Input() ::= "ababx"
+
+Output() ::= <<
+[@0,0:1='ab',\<1>,1:0]
+[@1,2:3='ab',\<1>,1:2]
+[@2,5:4='\<EOF>',\<-1>,1:5]<\n>
+>>
+
+Errors() ::= <<
+line 1:4 token recognition error at: 'x'<\n>
+>>
+
+grammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+A : 'ab' ;
+B : 'abc' ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerErrors/DFAToATNThatMatchesThenFailsInATN.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerErrors/DFAToATNThatMatchesThenFailsInATN.stg
new file mode 100644
index 000000000..40845baf9
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerErrors/DFAToATNThatMatchesThenFailsInATN.stg
@@ -0,0 +1,29 @@
+// The first ab caches the DFA then abx goes through the DFA but
+// into the ATN for the c.  It marks that hasn't except state
+// and then keeps going in the ATN. It fails on the x, but
+// uses the previous accepted in the ATN not DFA
+
+TestType() ::= "Lexer"
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+Input() ::= "ababcx"
+
+Output() ::= <<
+[@0,0:1='ab',\<1>,1:0]
+[@1,2:4='abc',\<2>,1:2]
+[@2,6:5='\<EOF>',\<-1>,1:6]<\n>
+>>
+
+Errors() ::= <<
+line 1:5 token recognition error at: 'x'<\n>
+>>
+
+grammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+A : 'ab' ;
+B : 'abc' ;
+C : 'abcd' ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerErrors/EnforcedGreedyNestedBrances.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerErrors/EnforcedGreedyNestedBrances.stg
new file mode 100644
index 000000000..298dd7e0c
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerErrors/EnforcedGreedyNestedBrances.stg
@@ -0,0 +1,11 @@
+TestType() ::= "Lexer"
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+grammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+ACTION : '{' (ACTION | ~[{}])* '}';
+WS : [ \r\n\t]+ -> skip;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerErrors/EnforcedGreedyNestedBrances_1.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerErrors/EnforcedGreedyNestedBrances_1.stg
new file mode 100644
index 000000000..c58e28dd8
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerErrors/EnforcedGreedyNestedBrances_1.stg
@@ -0,0 +1,10 @@
+import "EnforcedGreedyNestedBrances.stg"
+
+Input() ::= "{ { } }"
+
+Output() ::= <<
+[@0,0:6='{ { } }',\<1>,1:0]
+[@1,7:6='\<EOF>',\<-1>,1:7]<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerErrors/EnforcedGreedyNestedBrances_2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerErrors/EnforcedGreedyNestedBrances_2.stg
new file mode 100644
index 000000000..71186083d
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerErrors/EnforcedGreedyNestedBrances_2.stg
@@ -0,0 +1,11 @@
+import "EnforcedGreedyNestedBrances.stg"
+
+Input() ::= "{ { }"
+
+Output() ::= <<
+[@0,5:4='\<EOF>',\<-1>,1:5]<\n>
+>>
+
+Errors() ::= <<
+line 1:0 token recognition error at: '{ { }'<\n>
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerErrors/ErrorInMiddle.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerErrors/ErrorInMiddle.stg
new file mode 100644
index 000000000..5e812c792
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerErrors/ErrorInMiddle.stg
@@ -0,0 +1,20 @@
+TestType() ::= "Lexer"
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+Input() ::= "abx"
+
+Output() ::= <<
+[@0,3:2='\<EOF>',\<-1>,1:3]<\n>
+>>
+
+Errors() ::= <<
+line 1:0 token recognition error at: 'abx'<\n>
+>>
+
+grammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+A : 'abc' ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerErrors/Index.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerErrors/Index.stg
new file mode 100644
index 000000000..e4195a38a
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerErrors/Index.stg
@@ -0,0 +1,14 @@
+TestTemplates ::= [
+	"InvalidCharAtStart": [],
+	"StringsEmbeddedInActions_1": [],
+	"StringsEmbeddedInActions_2": [],
+	"EnforcedGreedyNestedBrances_1": [],
+	"EnforcedGreedyNestedBrances_2": [],
+	"InvalidCharAtStartAfterDFACache": [],
+	"InvalidCharInToken": [],
+	"InvalidCharInTokenAfterDFACache": [],
+	"DFAToATNThatFailsBackToDFA": [],
+	"DFAToATNThatMatchesThenFailsInATN": [],
+	"ErrorInMiddle": [],
+	"LexerExecDFA": []
+]
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerErrors/InvalidCharAtStart.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerErrors/InvalidCharAtStart.stg
new file mode 100644
index 000000000..c556955b9
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerErrors/InvalidCharAtStart.stg
@@ -0,0 +1,20 @@
+TestType() ::= "Lexer"
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+Input() ::= "x"
+
+Output() ::= <<
+[@0,1:0='\<EOF>',\<-1>,1:1]<\n>
+>>
+
+Errors() ::= <<
+line 1:0 token recognition error at: 'x'<\n>
+>>
+
+grammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+A : 'a' 'b' ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerErrors/InvalidCharAtStartAfterDFACache.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerErrors/InvalidCharAtStartAfterDFACache.stg
new file mode 100644
index 000000000..d8d6b9b9d
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerErrors/InvalidCharAtStartAfterDFACache.stg
@@ -0,0 +1,21 @@
+TestType() ::= "Lexer"
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+Input() ::= "abx"
+
+Output() ::= <<
+[@0,0:1='ab',\<1>,1:0]
+[@1,3:2='\<EOF>',\<-1>,1:3]<\n>
+>>
+
+Errors() ::= <<
+line 1:2 token recognition error at: 'x'<\n>
+>>
+
+grammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+A : 'a' 'b' ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerErrors/InvalidCharInToken.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerErrors/InvalidCharInToken.stg
new file mode 100644
index 000000000..b41136f8d
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerErrors/InvalidCharInToken.stg
@@ -0,0 +1,20 @@
+TestType() ::= "Lexer"
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+Input() ::= "ax"
+
+Output() ::= <<
+[@0,2:1='\<EOF>',\<-1>,1:2]<\n>
+>>
+
+Errors() ::= <<
+line 1:0 token recognition error at: 'ax'<\n>
+>>
+
+grammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+A : 'a' 'b' ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerErrors/InvalidCharInTokenAfterDFACache.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerErrors/InvalidCharInTokenAfterDFACache.stg
new file mode 100644
index 000000000..f7be6d66f
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerErrors/InvalidCharInTokenAfterDFACache.stg
@@ -0,0 +1,21 @@
+TestType() ::= "Lexer"
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+Input() ::= "abax"
+
+Output() ::= <<
+[@0,0:1='ab',\<1>,1:0]
+[@1,4:3='\<EOF>',\<-1>,1:4]<\n>
+>>
+
+Errors() ::= <<
+line 1:2 token recognition error at: 'ax'<\n>
+>>
+
+grammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+A : 'a' 'b' ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerErrors/LexerExecDFA.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerErrors/LexerExecDFA.stg
new file mode 100644
index 000000000..3f10cffdb
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerErrors/LexerExecDFA.stg
@@ -0,0 +1,36 @@
+/**
+ * This is a regression test for #45 "NullPointerException in LexerATNSimulator.execDFA".
+ * https://github.com/antlr/antlr4/issues/46
+ */
+
+TestType() ::= "Lexer"
+
+Options ::= [
+	"CombinedGrammar": true
+]
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+Input() ::= "x : x"
+
+Output() ::= <<
+[@0,0:0='x',\<3>,1:0]
+[@1,2:2=':',\<1>,1:2]
+[@2,4:4='x',\<3>,1:4]
+[@3,5:4='\<EOF>',\<-1>,1:5]<\n>
+>>
+
+Errors() ::= <<
+line 1:1 token recognition error at: ' '
+line 1:3 token recognition error at: ' '<\n>
+>>
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+start : ID ':' expr;
+expr : primary expr? {} | expr '->' ID;
+primary : ID;
+ID : [a-z]+;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerErrors/StringsEmbeddedInActions.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerErrors/StringsEmbeddedInActions.stg
new file mode 100644
index 000000000..fbc17d44d
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerErrors/StringsEmbeddedInActions.stg
@@ -0,0 +1,12 @@
+TestType() ::= "Lexer"
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+grammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+ACTION2 : '[' (STRING | ~'"')*? ']';
+STRING : '"' ('\\"' | .)*? '"';
+WS : [ \t\r\n]+ -> skip;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerErrors/StringsEmbeddedInActions_1.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerErrors/StringsEmbeddedInActions_1.stg
new file mode 100644
index 000000000..f616d437f
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerErrors/StringsEmbeddedInActions_1.stg
@@ -0,0 +1,12 @@
+import "StringsEmbeddedInActions.stg"
+
+Input() ::= <<
+["foo"]
+>>
+
+Output() ::= <<
+[@0,0:6='["foo"]',\<1>,1:0]
+[@1,7:6='\<EOF>',\<-1>,1:7]<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerErrors/StringsEmbeddedInActions_2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerErrors/StringsEmbeddedInActions_2.stg
new file mode 100644
index 000000000..e6c91c2e0
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerErrors/StringsEmbeddedInActions_2.stg
@@ -0,0 +1,13 @@
+import "StringsEmbeddedInActions.stg"
+
+Input() ::= <<
+["foo]
+>>
+
+Output() ::= <<
+[@0,6:5='\<EOF>',\<-1>,1:6]<\n>
+>>
+
+Errors() ::= <<
+line 1:0 token recognition error at: '["foo]'<\n>
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/ActionPlacement.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/ActionPlacement.stg
new file mode 100644
index 000000000..c79d7cc84
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/ActionPlacement.stg
@@ -0,0 +1,31 @@
+TestType() ::= "Lexer"
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+Input() ::= <%
+ab
+%>
+
+Output() ::= <<
+stuff0: <!required space!>
+stuff1: a
+stuff2: ab
+ab
+[@0,0:1='ab',\<1>,1:0]
+[@1,2:1='\<EOF>',\<-1>,1:2]<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+I : ({<PlusText("stuff fail: "):writeln()>} 'a'
+| {<PlusText("stuff0: "):writeln()>}
+		'a' {<PlusText("stuff1: "):writeln()>}
+		'b' {<PlusText("stuff2: "):writeln()>})
+		{<Text():writeln()>} ;
+WS : (' '|'\n') -> skip ;
+J : .;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/CharSet.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/CharSet.stg
new file mode 100644
index 000000000..dc0b80cf3
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/CharSet.stg
@@ -0,0 +1,23 @@
+TestType() ::= "Lexer"
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+Input() ::= "34<\n> 34"
+
+Output() ::= <<
+I
+I
+[@0,0:1='34',\<1>,1:0]
+[@1,4:5='34',\<1>,2:1]
+[@2,6:5='\<EOF>',\<-1>,2:3]<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+I : '0'..'9'+ {<writeln("\"I\"")>} ;
+WS : [ \n\u000D] -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/CharSetInSet.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/CharSetInSet.stg
new file mode 100644
index 000000000..35f6cb924
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/CharSetInSet.stg
@@ -0,0 +1,25 @@
+TestType() ::= "Lexer"
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+Input() ::= <%
+a x
+%>
+
+Output() ::= <<
+I
+I
+[@0,0:0='a',\<1>,1:0]
+[@1,2:2='x',\<1>,1:2]
+[@2,3:2='\<EOF>',\<-1>,1:3]<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+I : (~[ab \\n]|'a')  {<writeln("\"I\"")>} ;
+WS : [ \n\u000D]+ -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/CharSetNot.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/CharSetNot.stg
new file mode 100644
index 000000000..1609cad52
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/CharSetNot.stg
@@ -0,0 +1,23 @@
+TestType() ::= "Lexer"
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+Input() ::= <%
+xaf
+%>
+
+Output() ::= <<
+I
+[@0,0:2='xaf',\<1>,1:0]
+[@1,3:2='\<EOF>',\<-1>,1:3]<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+I : ~[ab \n] ~[ \ncd]* {<writeln("\"I\"")>} ;
+WS : [ \n\u000D]+ -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/CharSetPlus.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/CharSetPlus.stg
new file mode 100644
index 000000000..c4fc9a80a
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/CharSetPlus.stg
@@ -0,0 +1,23 @@
+TestType() ::= "Lexer"
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+Input() ::= "34<\n> 34"
+
+Output() ::= <<
+I
+I
+[@0,0:1='34',\<1>,1:0]
+[@1,4:5='34',\<1>,2:1]
+[@2,6:5='\<EOF>',\<-1>,2:3]<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+I : '0'..'9'+ {<writeln("\"I\"")>} ;
+WS : [ \n\u000D]+ -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/CharSetRange.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/CharSetRange.stg
new file mode 100644
index 000000000..b5a724921
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/CharSetRange.stg
@@ -0,0 +1,28 @@
+TestType() ::= "Lexer"
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+Input() ::= "34<\n> 34 a2 abc <\n>   "
+
+Output() ::= <<
+I
+I
+ID
+ID
+[@0,0:1='34',\<1>,1:0]
+[@1,4:5='34',\<1>,2:1]
+[@2,7:8='a2',\<2>,2:4]
+[@3,10:12='abc',\<2>,2:7]
+[@4,18:17='\<EOF>',\<-1>,3:3]<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+I : [0-9]+ {<writeln("\"I\"")>} ;
+ID : [a-zA-Z] [a-zA-Z0-9]* {<writeln("\"ID\"")>} ;
+WS : [ \n\u0009\r]+ -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/CharSetWithEscapedChar.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/CharSetWithEscapedChar.stg
new file mode 100644
index 000000000..04dd3c3c5
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/CharSetWithEscapedChar.stg
@@ -0,0 +1,23 @@
+TestType() ::= "Lexer"
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+Input() ::= "- ] "
+
+Output() ::= <<
+DASHBRACK
+DASHBRACK
+[@0,0:0='-',\<1>,1:0]
+[@1,2:2=']',\<1>,1:2]
+[@2,4:3='\<EOF>',\<-1>,1:4]<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+DASHBRACK : [\\-\]]+ {<writeln("\"DASHBRACK\"")>} ;
+WS : [ \u]+ -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/CharSetWithMissingEndRange.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/CharSetWithMissingEndRange.stg
new file mode 100644
index 000000000..3e094898c
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/CharSetWithMissingEndRange.stg
@@ -0,0 +1,21 @@
+TestType() ::= "Lexer"
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+Input() ::= "00<\n>"
+
+Output() ::= <<
+I
+[@0,0:1='00',\<1>,1:0]
+[@1,3:2='\<EOF>',\<-1>,2:0]<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+I : [0-]+ {<writeln("\"I\"")>} ;
+WS : [ \n\u000D]+ -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/CharSetWithMissingEscapeChar.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/CharSetWithMissingEscapeChar.stg
new file mode 100644
index 000000000..61d1cef90
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/CharSetWithMissingEscapeChar.stg
@@ -0,0 +1,21 @@
+TestType() ::= "Lexer"
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+Input() ::= "34 "
+
+Output() ::= <<
+I
+[@0,0:1='34',\<1>,1:0]
+[@1,3:2='\<EOF>',\<-1>,1:3]<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+I : [0-9]+ {<writeln("\"I\"")>} ;
+WS : [ \u]+ -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/CharSetWithQuote1.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/CharSetWithQuote1.stg
new file mode 100644
index 000000000..bd26cd344
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/CharSetWithQuote1.stg
@@ -0,0 +1,23 @@
+TestType() ::= "Lexer"
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+Input() ::= <%
+b"a
+%>
+
+Output() ::= <<
+A
+[@0,0:2='b"a',\<1>,1:0]
+[@1,3:2='\<EOF>',\<-1>,1:3]<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+A : ["a-z]+ {<writeln("\"A\"")>} ;
+WS : [ \n\t]+ -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/CharSetWithQuote2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/CharSetWithQuote2.stg
new file mode 100644
index 000000000..5cb132937
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/CharSetWithQuote2.stg
@@ -0,0 +1,23 @@
+TestType() ::= "Lexer"
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+Input() ::= <%
+b"\a
+%>
+
+Output() ::= <<
+A
+[@0,0:3='b"\a',\<1>,1:0]
+[@1,4:3='\<EOF>',\<-1>,1:4]<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+A : ["\\\\ab]+ {<writeln("\"A\"")>} ;
+WS : [ \n\t]+ -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/CharSetWithReversedRange.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/CharSetWithReversedRange.stg
new file mode 100644
index 000000000..f2028a6c4
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/CharSetWithReversedRange.stg
@@ -0,0 +1,21 @@
+TestType() ::= "Lexer"
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+Input() ::= "9"
+
+Output() ::= <<
+A
+[@0,0:0='9',\<1>,1:0]
+[@1,1:0='\<EOF>',\<-1>,1:1]<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+A : [z-a9]+ {<writeln("\"A\"")>} ;
+WS : [ \u]+ -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/EOFByItself.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/EOFByItself.stg
new file mode 100644
index 000000000..2e2ce2140
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/EOFByItself.stg
@@ -0,0 +1,21 @@
+TestType() ::= "Lexer"
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+Input() ::= ""
+
+// must get DONE EOF
+Output() ::= <<
+[@0,0:-1='\<EOF>',\<1>,1:0]
+[@1,0:-1='\<EOF>',\<-1>,1:0]<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+DONE : EOF ;
+A : 'a';
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/EOFSuffixInFirstRule.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/EOFSuffixInFirstRule.stg
new file mode 100644
index 000000000..0e4804dfa
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/EOFSuffixInFirstRule.stg
@@ -0,0 +1,6 @@
+grammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+A : 'a' EOF ;
+B : 'a';
+C : 'c';
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/EOFSuffixInFirstRule_1.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/EOFSuffixInFirstRule_1.stg
new file mode 100644
index 000000000..c0d034e04
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/EOFSuffixInFirstRule_1.stg
@@ -0,0 +1,15 @@
+import "EOFSuffixInFirstRule.stg"
+
+TestType() ::= "Lexer"
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+Input() ::= ""
+
+Output() ::= <<
+[@0,0:-1='\<EOF>',\<-1>,1:0]<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/EOFSuffixInFirstRule_2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/EOFSuffixInFirstRule_2.stg
new file mode 100644
index 000000000..3fa6ab13e
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/EOFSuffixInFirstRule_2.stg
@@ -0,0 +1,16 @@
+import "EOFSuffixInFirstRule.stg"
+
+TestType() ::= "Lexer"
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+Input() ::= "a"
+
+Output() ::= <<
+[@0,0:0='a',\<1>,1:0]
+[@1,1:0='\<EOF>',\<-1>,1:1]<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/GreedyClosure.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/GreedyClosure.stg
new file mode 100644
index 000000000..a66e591ca
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/GreedyClosure.stg
@@ -0,0 +1,23 @@
+TestType() ::= "Lexer"
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+Input() ::= <<
+//blah
+//blah<\n>
+>>
+
+Output() ::= <<
+[@0,0:13='//blah\n//blah\n',\<1>,1:0]
+[@1,14:13='\<EOF>',\<-1>,3:0]<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+CMT : '//' .*? '\n' CMT*;
+WS : (' '|'\t')+;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/GreedyConfigs.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/GreedyConfigs.stg
new file mode 100644
index 000000000..e8702c723
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/GreedyConfigs.stg
@@ -0,0 +1,24 @@
+TestType() ::= "Lexer"
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+Input() ::= <%
+ab
+%>
+
+Output() ::= <<
+ab
+[@0,0:1='ab',\<1>,1:0]
+[@1,2:1='\<EOF>',\<-1>,1:2]<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+I : ('a' | 'ab') {<Text():writeln()>} ;
+WS : (' '|'\n') -> skip ;
+J : .;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/GreedyOptional.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/GreedyOptional.stg
new file mode 100644
index 000000000..e2db3792a
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/GreedyOptional.stg
@@ -0,0 +1,23 @@
+TestType() ::= "Lexer"
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+Input() ::= <<
+//blah
+//blah<\n>
+>>
+
+Output() ::= <<
+[@0,0:13='//blah\n//blah\n',\<1>,1:0]
+[@1,14:13='\<EOF>',\<-1>,3:0]<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+CMT : '//' .*? '\n' CMT?;
+WS : (' '|'\t')+;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/GreedyPositiveClosure.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/GreedyPositiveClosure.stg
new file mode 100644
index 000000000..2e5b11619
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/GreedyPositiveClosure.stg
@@ -0,0 +1,23 @@
+TestType() ::= "Lexer"
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+Input() ::= <<
+//blah
+//blah<\n>
+>>
+
+Output() ::= <<
+[@0,0:13='//blah\n//blah\n',\<1>,1:0]
+[@1,14:13='\<EOF>',\<-1>,3:0]<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+CMT : ('//' .*? '\n')+;
+WS : (' '|'\t')+;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/HexVsID.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/HexVsID.stg
new file mode 100644
index 000000000..6d3d7e17a
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/HexVsID.stg
@@ -0,0 +1,39 @@
+TestType() ::= "Lexer"
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+Input() ::= <%
+x 0 1 a.b a.l
+%>
+
+Output() ::= <<
+[@0,0:0='x',\<5>,1:0]
+[@1,1:1=' ',\<6>,1:1]
+[@2,2:2='0',\<2>,1:2]
+[@3,3:3=' ',\<6>,1:3]
+[@4,4:4='1',\<2>,1:4]
+[@5,5:5=' ',\<6>,1:5]
+[@6,6:6='a',\<5>,1:6]
+[@7,7:7='.',\<4>,1:7]
+[@8,8:8='b',\<5>,1:8]
+[@9,9:9=' ',\<6>,1:9]
+[@10,10:10='a',\<5>,1:10]
+[@11,11:11='.',\<4>,1:11]
+[@12,12:12='l',\<5>,1:12]
+[@13,13:12='\<EOF>',\<-1>,1:13]<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+HexLiteral : '0' ('x'|'X') HexDigit+ ;
+DecimalLiteral : ('0' | '1'..'9' '0'..'9'*) ;
+FloatingPointLiteral : ('0x' | '0X') HexDigit* ('.' HexDigit*)? ;
+DOT : '.' ;
+ID : 'a'..'z'+ ;
+fragment HexDigit : ('0'..'9'|'a'..'f'|'A'..'F') ;
+WS : (' '|'\n')+;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/Index.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/Index.stg
new file mode 100644
index 000000000..d6477c881
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/Index.stg
@@ -0,0 +1,40 @@
+TestTemplates ::= [
+	"QuoteTranslation": [],
+	"RefToRuleDoesNotSetTokenNorEmitAnother": [],
+	"Slashes": [],
+	"Parentheses": [],
+	"NonGreedyTermination1": [],
+	"NonGreedyTermination2": [],
+	"GreedyOptional": [],
+	"NonGreedyOptional": [],
+	"GreedyClosure": [],
+	"NonGreedyClosure": [],
+	"GreedyPositiveClosure": [],
+	"NonGreedyPositiveClosure": [],
+	"RecursiveLexerRuleRefWithWildcardStar_1": [],
+	"RecursiveLexerRuleRefWithWildcardStar_2": [],
+	"RecursiveLexerRuleRefWithWildcardPlus_1": [],
+	"RecursiveLexerRuleRefWithWildcardPlus_2": [],
+	"ActionPlacement": [],
+	"GreedyConfigs": [],
+	"NonGreedyConfigs": [],
+	"KeywordID": [],
+	"HexVsID": [],
+	"EOFByItself": [],
+	"EOFSuffixInFirstRule_1": [],
+	"EOFSuffixInFirstRule_2": [],
+	"CharSet": [],
+	"CharSetPlus": [],
+	"CharSetNot": [],
+	"CharSetInSet": [],
+	"CharSetRange": [],
+	"CharSetWithMissingEndRange": [],
+	"CharSetWithMissingEscapeChar": [],
+	"CharSetWithEscapedChar": [],
+	"CharSetWithReversedRange": [],
+	"CharSetWithQuote1": [],
+	"CharSetWithQuote2": [],
+	"PositionAdjustingLexer": [],
+	"LargeLexer": [],
+	"ZeroLengthToken": []
+]
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/KeywordID.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/KeywordID.stg
new file mode 100644
index 000000000..6954f9a39
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/KeywordID.stg
@@ -0,0 +1,29 @@
+TestType() ::= "Lexer"
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+Input() ::= <%
+end eend ending a
+%>
+
+Output() ::= <<
+[@0,0:2='end',\<1>,1:0]
+[@1,3:3=' ',\<3>,1:3]
+[@2,4:7='eend',\<2>,1:4]
+[@3,8:8=' ',\<3>,1:8]
+[@4,9:14='ending',\<2>,1:9]
+[@5,15:15=' ',\<3>,1:15]
+[@6,16:16='a',\<2>,1:16]
+[@7,17:16='\<EOF>',\<-1>,1:17]<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+KEND : 'end' ; // has priority
+ID : 'a'..'z'+ ;
+WS : (' '|'\n')+;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/LargeLexer.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/LargeLexer.stg
new file mode 100644
index 000000000..9dbc6d3d0
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/LargeLexer.stg
@@ -0,0 +1,4024 @@
+/*
+ * This is a regression test for antlr/antlr4#76 "Serialized ATN strings
+ * should be split when longer than 2^16 bytes (class file limitation)"
+ * https://github.com/antlr/antlr4/issues/76
+ */
+TestType() ::= "Lexer"
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+Input() ::= "KW400"
+
+Output() ::= <<
+[@0,0:4='KW400',\<402>,1:0]
+[@1,5:4='\<EOF>',\<-1>,1:5]<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+WS : [ \t\r\n]+ -> skip;
+KW0 : 'KW' '0';
+KW1 : 'KW' '1';
+KW2 : 'KW' '2';
+KW3 : 'KW' '3';
+KW4 : 'KW' '4';
+KW5 : 'KW' '5';
+KW6 : 'KW' '6';
+KW7 : 'KW' '7';
+KW8 : 'KW' '8';
+KW9 : 'KW' '9';
+KW10 : 'KW' '10';
+KW11 : 'KW' '11';
+KW12 : 'KW' '12';
+KW13 : 'KW' '13';
+KW14 : 'KW' '14';
+KW15 : 'KW' '15';
+KW16 : 'KW' '16';
+KW17 : 'KW' '17';
+KW18 : 'KW' '18';
+KW19 : 'KW' '19';
+KW20 : 'KW' '20';
+KW21 : 'KW' '21';
+KW22 : 'KW' '22';
+KW23 : 'KW' '23';
+KW24 : 'KW' '24';
+KW25 : 'KW' '25';
+KW26 : 'KW' '26';
+KW27 : 'KW' '27';
+KW28 : 'KW' '28';
+KW29 : 'KW' '29';
+KW30 : 'KW' '30';
+KW31 : 'KW' '31';
+KW32 : 'KW' '32';
+KW33 : 'KW' '33';
+KW34 : 'KW' '34';
+KW35 : 'KW' '35';
+KW36 : 'KW' '36';
+KW37 : 'KW' '37';
+KW38 : 'KW' '38';
+KW39 : 'KW' '39';
+KW40 : 'KW' '40';
+KW41 : 'KW' '41';
+KW42 : 'KW' '42';
+KW43 : 'KW' '43';
+KW44 : 'KW' '44';
+KW45 : 'KW' '45';
+KW46 : 'KW' '46';
+KW47 : 'KW' '47';
+KW48 : 'KW' '48';
+KW49 : 'KW' '49';
+KW50 : 'KW' '50';
+KW51 : 'KW' '51';
+KW52 : 'KW' '52';
+KW53 : 'KW' '53';
+KW54 : 'KW' '54';
+KW55 : 'KW' '55';
+KW56 : 'KW' '56';
+KW57 : 'KW' '57';
+KW58 : 'KW' '58';
+KW59 : 'KW' '59';
+KW60 : 'KW' '60';
+KW61 : 'KW' '61';
+KW62 : 'KW' '62';
+KW63 : 'KW' '63';
+KW64 : 'KW' '64';
+KW65 : 'KW' '65';
+KW66 : 'KW' '66';
+KW67 : 'KW' '67';
+KW68 : 'KW' '68';
+KW69 : 'KW' '69';
+KW70 : 'KW' '70';
+KW71 : 'KW' '71';
+KW72 : 'KW' '72';
+KW73 : 'KW' '73';
+KW74 : 'KW' '74';
+KW75 : 'KW' '75';
+KW76 : 'KW' '76';
+KW77 : 'KW' '77';
+KW78 : 'KW' '78';
+KW79 : 'KW' '79';
+KW80 : 'KW' '80';
+KW81 : 'KW' '81';
+KW82 : 'KW' '82';
+KW83 : 'KW' '83';
+KW84 : 'KW' '84';
+KW85 : 'KW' '85';
+KW86 : 'KW' '86';
+KW87 : 'KW' '87';
+KW88 : 'KW' '88';
+KW89 : 'KW' '89';
+KW90 : 'KW' '90';
+KW91 : 'KW' '91';
+KW92 : 'KW' '92';
+KW93 : 'KW' '93';
+KW94 : 'KW' '94';
+KW95 : 'KW' '95';
+KW96 : 'KW' '96';
+KW97 : 'KW' '97';
+KW98 : 'KW' '98';
+KW99 : 'KW' '99';
+KW100 : 'KW' '100';
+KW101 : 'KW' '101';
+KW102 : 'KW' '102';
+KW103 : 'KW' '103';
+KW104 : 'KW' '104';
+KW105 : 'KW' '105';
+KW106 : 'KW' '106';
+KW107 : 'KW' '107';
+KW108 : 'KW' '108';
+KW109 : 'KW' '109';
+KW110 : 'KW' '110';
+KW111 : 'KW' '111';
+KW112 : 'KW' '112';
+KW113 : 'KW' '113';
+KW114 : 'KW' '114';
+KW115 : 'KW' '115';
+KW116 : 'KW' '116';
+KW117 : 'KW' '117';
+KW118 : 'KW' '118';
+KW119 : 'KW' '119';
+KW120 : 'KW' '120';
+KW121 : 'KW' '121';
+KW122 : 'KW' '122';
+KW123 : 'KW' '123';
+KW124 : 'KW' '124';
+KW125 : 'KW' '125';
+KW126 : 'KW' '126';
+KW127 : 'KW' '127';
+KW128 : 'KW' '128';
+KW129 : 'KW' '129';
+KW130 : 'KW' '130';
+KW131 : 'KW' '131';
+KW132 : 'KW' '132';
+KW133 : 'KW' '133';
+KW134 : 'KW' '134';
+KW135 : 'KW' '135';
+KW136 : 'KW' '136';
+KW137 : 'KW' '137';
+KW138 : 'KW' '138';
+KW139 : 'KW' '139';
+KW140 : 'KW' '140';
+KW141 : 'KW' '141';
+KW142 : 'KW' '142';
+KW143 : 'KW' '143';
+KW144 : 'KW' '144';
+KW145 : 'KW' '145';
+KW146 : 'KW' '146';
+KW147 : 'KW' '147';
+KW148 : 'KW' '148';
+KW149 : 'KW' '149';
+KW150 : 'KW' '150';
+KW151 : 'KW' '151';
+KW152 : 'KW' '152';
+KW153 : 'KW' '153';
+KW154 : 'KW' '154';
+KW155 : 'KW' '155';
+KW156 : 'KW' '156';
+KW157 : 'KW' '157';
+KW158 : 'KW' '158';
+KW159 : 'KW' '159';
+KW160 : 'KW' '160';
+KW161 : 'KW' '161';
+KW162 : 'KW' '162';
+KW163 : 'KW' '163';
+KW164 : 'KW' '164';
+KW165 : 'KW' '165';
+KW166 : 'KW' '166';
+KW167 : 'KW' '167';
+KW168 : 'KW' '168';
+KW169 : 'KW' '169';
+KW170 : 'KW' '170';
+KW171 : 'KW' '171';
+KW172 : 'KW' '172';
+KW173 : 'KW' '173';
+KW174 : 'KW' '174';
+KW175 : 'KW' '175';
+KW176 : 'KW' '176';
+KW177 : 'KW' '177';
+KW178 : 'KW' '178';
+KW179 : 'KW' '179';
+KW180 : 'KW' '180';
+KW181 : 'KW' '181';
+KW182 : 'KW' '182';
+KW183 : 'KW' '183';
+KW184 : 'KW' '184';
+KW185 : 'KW' '185';
+KW186 : 'KW' '186';
+KW187 : 'KW' '187';
+KW188 : 'KW' '188';
+KW189 : 'KW' '189';
+KW190 : 'KW' '190';
+KW191 : 'KW' '191';
+KW192 : 'KW' '192';
+KW193 : 'KW' '193';
+KW194 : 'KW' '194';
+KW195 : 'KW' '195';
+KW196 : 'KW' '196';
+KW197 : 'KW' '197';
+KW198 : 'KW' '198';
+KW199 : 'KW' '199';
+KW200 : 'KW' '200';
+KW201 : 'KW' '201';
+KW202 : 'KW' '202';
+KW203 : 'KW' '203';
+KW204 : 'KW' '204';
+KW205 : 'KW' '205';
+KW206 : 'KW' '206';
+KW207 : 'KW' '207';
+KW208 : 'KW' '208';
+KW209 : 'KW' '209';
+KW210 : 'KW' '210';
+KW211 : 'KW' '211';
+KW212 : 'KW' '212';
+KW213 : 'KW' '213';
+KW214 : 'KW' '214';
+KW215 : 'KW' '215';
+KW216 : 'KW' '216';
+KW217 : 'KW' '217';
+KW218 : 'KW' '218';
+KW219 : 'KW' '219';
+KW220 : 'KW' '220';
+KW221 : 'KW' '221';
+KW222 : 'KW' '222';
+KW223 : 'KW' '223';
+KW224 : 'KW' '224';
+KW225 : 'KW' '225';
+KW226 : 'KW' '226';
+KW227 : 'KW' '227';
+KW228 : 'KW' '228';
+KW229 : 'KW' '229';
+KW230 : 'KW' '230';
+KW231 : 'KW' '231';
+KW232 : 'KW' '232';
+KW233 : 'KW' '233';
+KW234 : 'KW' '234';
+KW235 : 'KW' '235';
+KW236 : 'KW' '236';
+KW237 : 'KW' '237';
+KW238 : 'KW' '238';
+KW239 : 'KW' '239';
+KW240 : 'KW' '240';
+KW241 : 'KW' '241';
+KW242 : 'KW' '242';
+KW243 : 'KW' '243';
+KW244 : 'KW' '244';
+KW245 : 'KW' '245';
+KW246 : 'KW' '246';
+KW247 : 'KW' '247';
+KW248 : 'KW' '248';
+KW249 : 'KW' '249';
+KW250 : 'KW' '250';
+KW251 : 'KW' '251';
+KW252 : 'KW' '252';
+KW253 : 'KW' '253';
+KW254 : 'KW' '254';
+KW255 : 'KW' '255';
+KW256 : 'KW' '256';
+KW257 : 'KW' '257';
+KW258 : 'KW' '258';
+KW259 : 'KW' '259';
+KW260 : 'KW' '260';
+KW261 : 'KW' '261';
+KW262 : 'KW' '262';
+KW263 : 'KW' '263';
+KW264 : 'KW' '264';
+KW265 : 'KW' '265';
+KW266 : 'KW' '266';
+KW267 : 'KW' '267';
+KW268 : 'KW' '268';
+KW269 : 'KW' '269';
+KW270 : 'KW' '270';
+KW271 : 'KW' '271';
+KW272 : 'KW' '272';
+KW273 : 'KW' '273';
+KW274 : 'KW' '274';
+KW275 : 'KW' '275';
+KW276 : 'KW' '276';
+KW277 : 'KW' '277';
+KW278 : 'KW' '278';
+KW279 : 'KW' '279';
+KW280 : 'KW' '280';
+KW281 : 'KW' '281';
+KW282 : 'KW' '282';
+KW283 : 'KW' '283';
+KW284 : 'KW' '284';
+KW285 : 'KW' '285';
+KW286 : 'KW' '286';
+KW287 : 'KW' '287';
+KW288 : 'KW' '288';
+KW289 : 'KW' '289';
+KW290 : 'KW' '290';
+KW291 : 'KW' '291';
+KW292 : 'KW' '292';
+KW293 : 'KW' '293';
+KW294 : 'KW' '294';
+KW295 : 'KW' '295';
+KW296 : 'KW' '296';
+KW297 : 'KW' '297';
+KW298 : 'KW' '298';
+KW299 : 'KW' '299';
+KW300 : 'KW' '300';
+KW301 : 'KW' '301';
+KW302 : 'KW' '302';
+KW303 : 'KW' '303';
+KW304 : 'KW' '304';
+KW305 : 'KW' '305';
+KW306 : 'KW' '306';
+KW307 : 'KW' '307';
+KW308 : 'KW' '308';
+KW309 : 'KW' '309';
+KW310 : 'KW' '310';
+KW311 : 'KW' '311';
+KW312 : 'KW' '312';
+KW313 : 'KW' '313';
+KW314 : 'KW' '314';
+KW315 : 'KW' '315';
+KW316 : 'KW' '316';
+KW317 : 'KW' '317';
+KW318 : 'KW' '318';
+KW319 : 'KW' '319';
+KW320 : 'KW' '320';
+KW321 : 'KW' '321';
+KW322 : 'KW' '322';
+KW323 : 'KW' '323';
+KW324 : 'KW' '324';
+KW325 : 'KW' '325';
+KW326 : 'KW' '326';
+KW327 : 'KW' '327';
+KW328 : 'KW' '328';
+KW329 : 'KW' '329';
+KW330 : 'KW' '330';
+KW331 : 'KW' '331';
+KW332 : 'KW' '332';
+KW333 : 'KW' '333';
+KW334 : 'KW' '334';
+KW335 : 'KW' '335';
+KW336 : 'KW' '336';
+KW337 : 'KW' '337';
+KW338 : 'KW' '338';
+KW339 : 'KW' '339';
+KW340 : 'KW' '340';
+KW341 : 'KW' '341';
+KW342 : 'KW' '342';
+KW343 : 'KW' '343';
+KW344 : 'KW' '344';
+KW345 : 'KW' '345';
+KW346 : 'KW' '346';
+KW347 : 'KW' '347';
+KW348 : 'KW' '348';
+KW349 : 'KW' '349';
+KW350 : 'KW' '350';
+KW351 : 'KW' '351';
+KW352 : 'KW' '352';
+KW353 : 'KW' '353';
+KW354 : 'KW' '354';
+KW355 : 'KW' '355';
+KW356 : 'KW' '356';
+KW357 : 'KW' '357';
+KW358 : 'KW' '358';
+KW359 : 'KW' '359';
+KW360 : 'KW' '360';
+KW361 : 'KW' '361';
+KW362 : 'KW' '362';
+KW363 : 'KW' '363';
+KW364 : 'KW' '364';
+KW365 : 'KW' '365';
+KW366 : 'KW' '366';
+KW367 : 'KW' '367';
+KW368 : 'KW' '368';
+KW369 : 'KW' '369';
+KW370 : 'KW' '370';
+KW371 : 'KW' '371';
+KW372 : 'KW' '372';
+KW373 : 'KW' '373';
+KW374 : 'KW' '374';
+KW375 : 'KW' '375';
+KW376 : 'KW' '376';
+KW377 : 'KW' '377';
+KW378 : 'KW' '378';
+KW379 : 'KW' '379';
+KW380 : 'KW' '380';
+KW381 : 'KW' '381';
+KW382 : 'KW' '382';
+KW383 : 'KW' '383';
+KW384 : 'KW' '384';
+KW385 : 'KW' '385';
+KW386 : 'KW' '386';
+KW387 : 'KW' '387';
+KW388 : 'KW' '388';
+KW389 : 'KW' '389';
+KW390 : 'KW' '390';
+KW391 : 'KW' '391';
+KW392 : 'KW' '392';
+KW393 : 'KW' '393';
+KW394 : 'KW' '394';
+KW395 : 'KW' '395';
+KW396 : 'KW' '396';
+KW397 : 'KW' '397';
+KW398 : 'KW' '398';
+KW399 : 'KW' '399';
+KW400 : 'KW' '400';
+KW401 : 'KW' '401';
+KW402 : 'KW' '402';
+KW403 : 'KW' '403';
+KW404 : 'KW' '404';
+KW405 : 'KW' '405';
+KW406 : 'KW' '406';
+KW407 : 'KW' '407';
+KW408 : 'KW' '408';
+KW409 : 'KW' '409';
+KW410 : 'KW' '410';
+KW411 : 'KW' '411';
+KW412 : 'KW' '412';
+KW413 : 'KW' '413';
+KW414 : 'KW' '414';
+KW415 : 'KW' '415';
+KW416 : 'KW' '416';
+KW417 : 'KW' '417';
+KW418 : 'KW' '418';
+KW419 : 'KW' '419';
+KW420 : 'KW' '420';
+KW421 : 'KW' '421';
+KW422 : 'KW' '422';
+KW423 : 'KW' '423';
+KW424 : 'KW' '424';
+KW425 : 'KW' '425';
+KW426 : 'KW' '426';
+KW427 : 'KW' '427';
+KW428 : 'KW' '428';
+KW429 : 'KW' '429';
+KW430 : 'KW' '430';
+KW431 : 'KW' '431';
+KW432 : 'KW' '432';
+KW433 : 'KW' '433';
+KW434 : 'KW' '434';
+KW435 : 'KW' '435';
+KW436 : 'KW' '436';
+KW437 : 'KW' '437';
+KW438 : 'KW' '438';
+KW439 : 'KW' '439';
+KW440 : 'KW' '440';
+KW441 : 'KW' '441';
+KW442 : 'KW' '442';
+KW443 : 'KW' '443';
+KW444 : 'KW' '444';
+KW445 : 'KW' '445';
+KW446 : 'KW' '446';
+KW447 : 'KW' '447';
+KW448 : 'KW' '448';
+KW449 : 'KW' '449';
+KW450 : 'KW' '450';
+KW451 : 'KW' '451';
+KW452 : 'KW' '452';
+KW453 : 'KW' '453';
+KW454 : 'KW' '454';
+KW455 : 'KW' '455';
+KW456 : 'KW' '456';
+KW457 : 'KW' '457';
+KW458 : 'KW' '458';
+KW459 : 'KW' '459';
+KW460 : 'KW' '460';
+KW461 : 'KW' '461';
+KW462 : 'KW' '462';
+KW463 : 'KW' '463';
+KW464 : 'KW' '464';
+KW465 : 'KW' '465';
+KW466 : 'KW' '466';
+KW467 : 'KW' '467';
+KW468 : 'KW' '468';
+KW469 : 'KW' '469';
+KW470 : 'KW' '470';
+KW471 : 'KW' '471';
+KW472 : 'KW' '472';
+KW473 : 'KW' '473';
+KW474 : 'KW' '474';
+KW475 : 'KW' '475';
+KW476 : 'KW' '476';
+KW477 : 'KW' '477';
+KW478 : 'KW' '478';
+KW479 : 'KW' '479';
+KW480 : 'KW' '480';
+KW481 : 'KW' '481';
+KW482 : 'KW' '482';
+KW483 : 'KW' '483';
+KW484 : 'KW' '484';
+KW485 : 'KW' '485';
+KW486 : 'KW' '486';
+KW487 : 'KW' '487';
+KW488 : 'KW' '488';
+KW489 : 'KW' '489';
+KW490 : 'KW' '490';
+KW491 : 'KW' '491';
+KW492 : 'KW' '492';
+KW493 : 'KW' '493';
+KW494 : 'KW' '494';
+KW495 : 'KW' '495';
+KW496 : 'KW' '496';
+KW497 : 'KW' '497';
+KW498 : 'KW' '498';
+KW499 : 'KW' '499';
+KW500 : 'KW' '500';
+KW501 : 'KW' '501';
+KW502 : 'KW' '502';
+KW503 : 'KW' '503';
+KW504 : 'KW' '504';
+KW505 : 'KW' '505';
+KW506 : 'KW' '506';
+KW507 : 'KW' '507';
+KW508 : 'KW' '508';
+KW509 : 'KW' '509';
+KW510 : 'KW' '510';
+KW511 : 'KW' '511';
+KW512 : 'KW' '512';
+KW513 : 'KW' '513';
+KW514 : 'KW' '514';
+KW515 : 'KW' '515';
+KW516 : 'KW' '516';
+KW517 : 'KW' '517';
+KW518 : 'KW' '518';
+KW519 : 'KW' '519';
+KW520 : 'KW' '520';
+KW521 : 'KW' '521';
+KW522 : 'KW' '522';
+KW523 : 'KW' '523';
+KW524 : 'KW' '524';
+KW525 : 'KW' '525';
+KW526 : 'KW' '526';
+KW527 : 'KW' '527';
+KW528 : 'KW' '528';
+KW529 : 'KW' '529';
+KW530 : 'KW' '530';
+KW531 : 'KW' '531';
+KW532 : 'KW' '532';
+KW533 : 'KW' '533';
+KW534 : 'KW' '534';
+KW535 : 'KW' '535';
+KW536 : 'KW' '536';
+KW537 : 'KW' '537';
+KW538 : 'KW' '538';
+KW539 : 'KW' '539';
+KW540 : 'KW' '540';
+KW541 : 'KW' '541';
+KW542 : 'KW' '542';
+KW543 : 'KW' '543';
+KW544 : 'KW' '544';
+KW545 : 'KW' '545';
+KW546 : 'KW' '546';
+KW547 : 'KW' '547';
+KW548 : 'KW' '548';
+KW549 : 'KW' '549';
+KW550 : 'KW' '550';
+KW551 : 'KW' '551';
+KW552 : 'KW' '552';
+KW553 : 'KW' '553';
+KW554 : 'KW' '554';
+KW555 : 'KW' '555';
+KW556 : 'KW' '556';
+KW557 : 'KW' '557';
+KW558 : 'KW' '558';
+KW559 : 'KW' '559';
+KW560 : 'KW' '560';
+KW561 : 'KW' '561';
+KW562 : 'KW' '562';
+KW563 : 'KW' '563';
+KW564 : 'KW' '564';
+KW565 : 'KW' '565';
+KW566 : 'KW' '566';
+KW567 : 'KW' '567';
+KW568 : 'KW' '568';
+KW569 : 'KW' '569';
+KW570 : 'KW' '570';
+KW571 : 'KW' '571';
+KW572 : 'KW' '572';
+KW573 : 'KW' '573';
+KW574 : 'KW' '574';
+KW575 : 'KW' '575';
+KW576 : 'KW' '576';
+KW577 : 'KW' '577';
+KW578 : 'KW' '578';
+KW579 : 'KW' '579';
+KW580 : 'KW' '580';
+KW581 : 'KW' '581';
+KW582 : 'KW' '582';
+KW583 : 'KW' '583';
+KW584 : 'KW' '584';
+KW585 : 'KW' '585';
+KW586 : 'KW' '586';
+KW587 : 'KW' '587';
+KW588 : 'KW' '588';
+KW589 : 'KW' '589';
+KW590 : 'KW' '590';
+KW591 : 'KW' '591';
+KW592 : 'KW' '592';
+KW593 : 'KW' '593';
+KW594 : 'KW' '594';
+KW595 : 'KW' '595';
+KW596 : 'KW' '596';
+KW597 : 'KW' '597';
+KW598 : 'KW' '598';
+KW599 : 'KW' '599';
+KW600 : 'KW' '600';
+KW601 : 'KW' '601';
+KW602 : 'KW' '602';
+KW603 : 'KW' '603';
+KW604 : 'KW' '604';
+KW605 : 'KW' '605';
+KW606 : 'KW' '606';
+KW607 : 'KW' '607';
+KW608 : 'KW' '608';
+KW609 : 'KW' '609';
+KW610 : 'KW' '610';
+KW611 : 'KW' '611';
+KW612 : 'KW' '612';
+KW613 : 'KW' '613';
+KW614 : 'KW' '614';
+KW615 : 'KW' '615';
+KW616 : 'KW' '616';
+KW617 : 'KW' '617';
+KW618 : 'KW' '618';
+KW619 : 'KW' '619';
+KW620 : 'KW' '620';
+KW621 : 'KW' '621';
+KW622 : 'KW' '622';
+KW623 : 'KW' '623';
+KW624 : 'KW' '624';
+KW625 : 'KW' '625';
+KW626 : 'KW' '626';
+KW627 : 'KW' '627';
+KW628 : 'KW' '628';
+KW629 : 'KW' '629';
+KW630 : 'KW' '630';
+KW631 : 'KW' '631';
+KW632 : 'KW' '632';
+KW633 : 'KW' '633';
+KW634 : 'KW' '634';
+KW635 : 'KW' '635';
+KW636 : 'KW' '636';
+KW637 : 'KW' '637';
+KW638 : 'KW' '638';
+KW639 : 'KW' '639';
+KW640 : 'KW' '640';
+KW641 : 'KW' '641';
+KW642 : 'KW' '642';
+KW643 : 'KW' '643';
+KW644 : 'KW' '644';
+KW645 : 'KW' '645';
+KW646 : 'KW' '646';
+KW647 : 'KW' '647';
+KW648 : 'KW' '648';
+KW649 : 'KW' '649';
+KW650 : 'KW' '650';
+KW651 : 'KW' '651';
+KW652 : 'KW' '652';
+KW653 : 'KW' '653';
+KW654 : 'KW' '654';
+KW655 : 'KW' '655';
+KW656 : 'KW' '656';
+KW657 : 'KW' '657';
+KW658 : 'KW' '658';
+KW659 : 'KW' '659';
+KW660 : 'KW' '660';
+KW661 : 'KW' '661';
+KW662 : 'KW' '662';
+KW663 : 'KW' '663';
+KW664 : 'KW' '664';
+KW665 : 'KW' '665';
+KW666 : 'KW' '666';
+KW667 : 'KW' '667';
+KW668 : 'KW' '668';
+KW669 : 'KW' '669';
+KW670 : 'KW' '670';
+KW671 : 'KW' '671';
+KW672 : 'KW' '672';
+KW673 : 'KW' '673';
+KW674 : 'KW' '674';
+KW675 : 'KW' '675';
+KW676 : 'KW' '676';
+KW677 : 'KW' '677';
+KW678 : 'KW' '678';
+KW679 : 'KW' '679';
+KW680 : 'KW' '680';
+KW681 : 'KW' '681';
+KW682 : 'KW' '682';
+KW683 : 'KW' '683';
+KW684 : 'KW' '684';
+KW685 : 'KW' '685';
+KW686 : 'KW' '686';
+KW687 : 'KW' '687';
+KW688 : 'KW' '688';
+KW689 : 'KW' '689';
+KW690 : 'KW' '690';
+KW691 : 'KW' '691';
+KW692 : 'KW' '692';
+KW693 : 'KW' '693';
+KW694 : 'KW' '694';
+KW695 : 'KW' '695';
+KW696 : 'KW' '696';
+KW697 : 'KW' '697';
+KW698 : 'KW' '698';
+KW699 : 'KW' '699';
+KW700 : 'KW' '700';
+KW701 : 'KW' '701';
+KW702 : 'KW' '702';
+KW703 : 'KW' '703';
+KW704 : 'KW' '704';
+KW705 : 'KW' '705';
+KW706 : 'KW' '706';
+KW707 : 'KW' '707';
+KW708 : 'KW' '708';
+KW709 : 'KW' '709';
+KW710 : 'KW' '710';
+KW711 : 'KW' '711';
+KW712 : 'KW' '712';
+KW713 : 'KW' '713';
+KW714 : 'KW' '714';
+KW715 : 'KW' '715';
+KW716 : 'KW' '716';
+KW717 : 'KW' '717';
+KW718 : 'KW' '718';
+KW719 : 'KW' '719';
+KW720 : 'KW' '720';
+KW721 : 'KW' '721';
+KW722 : 'KW' '722';
+KW723 : 'KW' '723';
+KW724 : 'KW' '724';
+KW725 : 'KW' '725';
+KW726 : 'KW' '726';
+KW727 : 'KW' '727';
+KW728 : 'KW' '728';
+KW729 : 'KW' '729';
+KW730 : 'KW' '730';
+KW731 : 'KW' '731';
+KW732 : 'KW' '732';
+KW733 : 'KW' '733';
+KW734 : 'KW' '734';
+KW735 : 'KW' '735';
+KW736 : 'KW' '736';
+KW737 : 'KW' '737';
+KW738 : 'KW' '738';
+KW739 : 'KW' '739';
+KW740 : 'KW' '740';
+KW741 : 'KW' '741';
+KW742 : 'KW' '742';
+KW743 : 'KW' '743';
+KW744 : 'KW' '744';
+KW745 : 'KW' '745';
+KW746 : 'KW' '746';
+KW747 : 'KW' '747';
+KW748 : 'KW' '748';
+KW749 : 'KW' '749';
+KW750 : 'KW' '750';
+KW751 : 'KW' '751';
+KW752 : 'KW' '752';
+KW753 : 'KW' '753';
+KW754 : 'KW' '754';
+KW755 : 'KW' '755';
+KW756 : 'KW' '756';
+KW757 : 'KW' '757';
+KW758 : 'KW' '758';
+KW759 : 'KW' '759';
+KW760 : 'KW' '760';
+KW761 : 'KW' '761';
+KW762 : 'KW' '762';
+KW763 : 'KW' '763';
+KW764 : 'KW' '764';
+KW765 : 'KW' '765';
+KW766 : 'KW' '766';
+KW767 : 'KW' '767';
+KW768 : 'KW' '768';
+KW769 : 'KW' '769';
+KW770 : 'KW' '770';
+KW771 : 'KW' '771';
+KW772 : 'KW' '772';
+KW773 : 'KW' '773';
+KW774 : 'KW' '774';
+KW775 : 'KW' '775';
+KW776 : 'KW' '776';
+KW777 : 'KW' '777';
+KW778 : 'KW' '778';
+KW779 : 'KW' '779';
+KW780 : 'KW' '780';
+KW781 : 'KW' '781';
+KW782 : 'KW' '782';
+KW783 : 'KW' '783';
+KW784 : 'KW' '784';
+KW785 : 'KW' '785';
+KW786 : 'KW' '786';
+KW787 : 'KW' '787';
+KW788 : 'KW' '788';
+KW789 : 'KW' '789';
+KW790 : 'KW' '790';
+KW791 : 'KW' '791';
+KW792 : 'KW' '792';
+KW793 : 'KW' '793';
+KW794 : 'KW' '794';
+KW795 : 'KW' '795';
+KW796 : 'KW' '796';
+KW797 : 'KW' '797';
+KW798 : 'KW' '798';
+KW799 : 'KW' '799';
+KW800 : 'KW' '800';
+KW801 : 'KW' '801';
+KW802 : 'KW' '802';
+KW803 : 'KW' '803';
+KW804 : 'KW' '804';
+KW805 : 'KW' '805';
+KW806 : 'KW' '806';
+KW807 : 'KW' '807';
+KW808 : 'KW' '808';
+KW809 : 'KW' '809';
+KW810 : 'KW' '810';
+KW811 : 'KW' '811';
+KW812 : 'KW' '812';
+KW813 : 'KW' '813';
+KW814 : 'KW' '814';
+KW815 : 'KW' '815';
+KW816 : 'KW' '816';
+KW817 : 'KW' '817';
+KW818 : 'KW' '818';
+KW819 : 'KW' '819';
+KW820 : 'KW' '820';
+KW821 : 'KW' '821';
+KW822 : 'KW' '822';
+KW823 : 'KW' '823';
+KW824 : 'KW' '824';
+KW825 : 'KW' '825';
+KW826 : 'KW' '826';
+KW827 : 'KW' '827';
+KW828 : 'KW' '828';
+KW829 : 'KW' '829';
+KW830 : 'KW' '830';
+KW831 : 'KW' '831';
+KW832 : 'KW' '832';
+KW833 : 'KW' '833';
+KW834 : 'KW' '834';
+KW835 : 'KW' '835';
+KW836 : 'KW' '836';
+KW837 : 'KW' '837';
+KW838 : 'KW' '838';
+KW839 : 'KW' '839';
+KW840 : 'KW' '840';
+KW841 : 'KW' '841';
+KW842 : 'KW' '842';
+KW843 : 'KW' '843';
+KW844 : 'KW' '844';
+KW845 : 'KW' '845';
+KW846 : 'KW' '846';
+KW847 : 'KW' '847';
+KW848 : 'KW' '848';
+KW849 : 'KW' '849';
+KW850 : 'KW' '850';
+KW851 : 'KW' '851';
+KW852 : 'KW' '852';
+KW853 : 'KW' '853';
+KW854 : 'KW' '854';
+KW855 : 'KW' '855';
+KW856 : 'KW' '856';
+KW857 : 'KW' '857';
+KW858 : 'KW' '858';
+KW859 : 'KW' '859';
+KW860 : 'KW' '860';
+KW861 : 'KW' '861';
+KW862 : 'KW' '862';
+KW863 : 'KW' '863';
+KW864 : 'KW' '864';
+KW865 : 'KW' '865';
+KW866 : 'KW' '866';
+KW867 : 'KW' '867';
+KW868 : 'KW' '868';
+KW869 : 'KW' '869';
+KW870 : 'KW' '870';
+KW871 : 'KW' '871';
+KW872 : 'KW' '872';
+KW873 : 'KW' '873';
+KW874 : 'KW' '874';
+KW875 : 'KW' '875';
+KW876 : 'KW' '876';
+KW877 : 'KW' '877';
+KW878 : 'KW' '878';
+KW879 : 'KW' '879';
+KW880 : 'KW' '880';
+KW881 : 'KW' '881';
+KW882 : 'KW' '882';
+KW883 : 'KW' '883';
+KW884 : 'KW' '884';
+KW885 : 'KW' '885';
+KW886 : 'KW' '886';
+KW887 : 'KW' '887';
+KW888 : 'KW' '888';
+KW889 : 'KW' '889';
+KW890 : 'KW' '890';
+KW891 : 'KW' '891';
+KW892 : 'KW' '892';
+KW893 : 'KW' '893';
+KW894 : 'KW' '894';
+KW895 : 'KW' '895';
+KW896 : 'KW' '896';
+KW897 : 'KW' '897';
+KW898 : 'KW' '898';
+KW899 : 'KW' '899';
+KW900 : 'KW' '900';
+KW901 : 'KW' '901';
+KW902 : 'KW' '902';
+KW903 : 'KW' '903';
+KW904 : 'KW' '904';
+KW905 : 'KW' '905';
+KW906 : 'KW' '906';
+KW907 : 'KW' '907';
+KW908 : 'KW' '908';
+KW909 : 'KW' '909';
+KW910 : 'KW' '910';
+KW911 : 'KW' '911';
+KW912 : 'KW' '912';
+KW913 : 'KW' '913';
+KW914 : 'KW' '914';
+KW915 : 'KW' '915';
+KW916 : 'KW' '916';
+KW917 : 'KW' '917';
+KW918 : 'KW' '918';
+KW919 : 'KW' '919';
+KW920 : 'KW' '920';
+KW921 : 'KW' '921';
+KW922 : 'KW' '922';
+KW923 : 'KW' '923';
+KW924 : 'KW' '924';
+KW925 : 'KW' '925';
+KW926 : 'KW' '926';
+KW927 : 'KW' '927';
+KW928 : 'KW' '928';
+KW929 : 'KW' '929';
+KW930 : 'KW' '930';
+KW931 : 'KW' '931';
+KW932 : 'KW' '932';
+KW933 : 'KW' '933';
+KW934 : 'KW' '934';
+KW935 : 'KW' '935';
+KW936 : 'KW' '936';
+KW937 : 'KW' '937';
+KW938 : 'KW' '938';
+KW939 : 'KW' '939';
+KW940 : 'KW' '940';
+KW941 : 'KW' '941';
+KW942 : 'KW' '942';
+KW943 : 'KW' '943';
+KW944 : 'KW' '944';
+KW945 : 'KW' '945';
+KW946 : 'KW' '946';
+KW947 : 'KW' '947';
+KW948 : 'KW' '948';
+KW949 : 'KW' '949';
+KW950 : 'KW' '950';
+KW951 : 'KW' '951';
+KW952 : 'KW' '952';
+KW953 : 'KW' '953';
+KW954 : 'KW' '954';
+KW955 : 'KW' '955';
+KW956 : 'KW' '956';
+KW957 : 'KW' '957';
+KW958 : 'KW' '958';
+KW959 : 'KW' '959';
+KW960 : 'KW' '960';
+KW961 : 'KW' '961';
+KW962 : 'KW' '962';
+KW963 : 'KW' '963';
+KW964 : 'KW' '964';
+KW965 : 'KW' '965';
+KW966 : 'KW' '966';
+KW967 : 'KW' '967';
+KW968 : 'KW' '968';
+KW969 : 'KW' '969';
+KW970 : 'KW' '970';
+KW971 : 'KW' '971';
+KW972 : 'KW' '972';
+KW973 : 'KW' '973';
+KW974 : 'KW' '974';
+KW975 : 'KW' '975';
+KW976 : 'KW' '976';
+KW977 : 'KW' '977';
+KW978 : 'KW' '978';
+KW979 : 'KW' '979';
+KW980 : 'KW' '980';
+KW981 : 'KW' '981';
+KW982 : 'KW' '982';
+KW983 : 'KW' '983';
+KW984 : 'KW' '984';
+KW985 : 'KW' '985';
+KW986 : 'KW' '986';
+KW987 : 'KW' '987';
+KW988 : 'KW' '988';
+KW989 : 'KW' '989';
+KW990 : 'KW' '990';
+KW991 : 'KW' '991';
+KW992 : 'KW' '992';
+KW993 : 'KW' '993';
+KW994 : 'KW' '994';
+KW995 : 'KW' '995';
+KW996 : 'KW' '996';
+KW997 : 'KW' '997';
+KW998 : 'KW' '998';
+KW999 : 'KW' '999';
+KW1000 : 'KW' '1000';
+KW1001 : 'KW' '1001';
+KW1002 : 'KW' '1002';
+KW1003 : 'KW' '1003';
+KW1004 : 'KW' '1004';
+KW1005 : 'KW' '1005';
+KW1006 : 'KW' '1006';
+KW1007 : 'KW' '1007';
+KW1008 : 'KW' '1008';
+KW1009 : 'KW' '1009';
+KW1010 : 'KW' '1010';
+KW1011 : 'KW' '1011';
+KW1012 : 'KW' '1012';
+KW1013 : 'KW' '1013';
+KW1014 : 'KW' '1014';
+KW1015 : 'KW' '1015';
+KW1016 : 'KW' '1016';
+KW1017 : 'KW' '1017';
+KW1018 : 'KW' '1018';
+KW1019 : 'KW' '1019';
+KW1020 : 'KW' '1020';
+KW1021 : 'KW' '1021';
+KW1022 : 'KW' '1022';
+KW1023 : 'KW' '1023';
+KW1024 : 'KW' '1024';
+KW1025 : 'KW' '1025';
+KW1026 : 'KW' '1026';
+KW1027 : 'KW' '1027';
+KW1028 : 'KW' '1028';
+KW1029 : 'KW' '1029';
+KW1030 : 'KW' '1030';
+KW1031 : 'KW' '1031';
+KW1032 : 'KW' '1032';
+KW1033 : 'KW' '1033';
+KW1034 : 'KW' '1034';
+KW1035 : 'KW' '1035';
+KW1036 : 'KW' '1036';
+KW1037 : 'KW' '1037';
+KW1038 : 'KW' '1038';
+KW1039 : 'KW' '1039';
+KW1040 : 'KW' '1040';
+KW1041 : 'KW' '1041';
+KW1042 : 'KW' '1042';
+KW1043 : 'KW' '1043';
+KW1044 : 'KW' '1044';
+KW1045 : 'KW' '1045';
+KW1046 : 'KW' '1046';
+KW1047 : 'KW' '1047';
+KW1048 : 'KW' '1048';
+KW1049 : 'KW' '1049';
+KW1050 : 'KW' '1050';
+KW1051 : 'KW' '1051';
+KW1052 : 'KW' '1052';
+KW1053 : 'KW' '1053';
+KW1054 : 'KW' '1054';
+KW1055 : 'KW' '1055';
+KW1056 : 'KW' '1056';
+KW1057 : 'KW' '1057';
+KW1058 : 'KW' '1058';
+KW1059 : 'KW' '1059';
+KW1060 : 'KW' '1060';
+KW1061 : 'KW' '1061';
+KW1062 : 'KW' '1062';
+KW1063 : 'KW' '1063';
+KW1064 : 'KW' '1064';
+KW1065 : 'KW' '1065';
+KW1066 : 'KW' '1066';
+KW1067 : 'KW' '1067';
+KW1068 : 'KW' '1068';
+KW1069 : 'KW' '1069';
+KW1070 : 'KW' '1070';
+KW1071 : 'KW' '1071';
+KW1072 : 'KW' '1072';
+KW1073 : 'KW' '1073';
+KW1074 : 'KW' '1074';
+KW1075 : 'KW' '1075';
+KW1076 : 'KW' '1076';
+KW1077 : 'KW' '1077';
+KW1078 : 'KW' '1078';
+KW1079 : 'KW' '1079';
+KW1080 : 'KW' '1080';
+KW1081 : 'KW' '1081';
+KW1082 : 'KW' '1082';
+KW1083 : 'KW' '1083';
+KW1084 : 'KW' '1084';
+KW1085 : 'KW' '1085';
+KW1086 : 'KW' '1086';
+KW1087 : 'KW' '1087';
+KW1088 : 'KW' '1088';
+KW1089 : 'KW' '1089';
+KW1090 : 'KW' '1090';
+KW1091 : 'KW' '1091';
+KW1092 : 'KW' '1092';
+KW1093 : 'KW' '1093';
+KW1094 : 'KW' '1094';
+KW1095 : 'KW' '1095';
+KW1096 : 'KW' '1096';
+KW1097 : 'KW' '1097';
+KW1098 : 'KW' '1098';
+KW1099 : 'KW' '1099';
+KW1100 : 'KW' '1100';
+KW1101 : 'KW' '1101';
+KW1102 : 'KW' '1102';
+KW1103 : 'KW' '1103';
+KW1104 : 'KW' '1104';
+KW1105 : 'KW' '1105';
+KW1106 : 'KW' '1106';
+KW1107 : 'KW' '1107';
+KW1108 : 'KW' '1108';
+KW1109 : 'KW' '1109';
+KW1110 : 'KW' '1110';
+KW1111 : 'KW' '1111';
+KW1112 : 'KW' '1112';
+KW1113 : 'KW' '1113';
+KW1114 : 'KW' '1114';
+KW1115 : 'KW' '1115';
+KW1116 : 'KW' '1116';
+KW1117 : 'KW' '1117';
+KW1118 : 'KW' '1118';
+KW1119 : 'KW' '1119';
+KW1120 : 'KW' '1120';
+KW1121 : 'KW' '1121';
+KW1122 : 'KW' '1122';
+KW1123 : 'KW' '1123';
+KW1124 : 'KW' '1124';
+KW1125 : 'KW' '1125';
+KW1126 : 'KW' '1126';
+KW1127 : 'KW' '1127';
+KW1128 : 'KW' '1128';
+KW1129 : 'KW' '1129';
+KW1130 : 'KW' '1130';
+KW1131 : 'KW' '1131';
+KW1132 : 'KW' '1132';
+KW1133 : 'KW' '1133';
+KW1134 : 'KW' '1134';
+KW1135 : 'KW' '1135';
+KW1136 : 'KW' '1136';
+KW1137 : 'KW' '1137';
+KW1138 : 'KW' '1138';
+KW1139 : 'KW' '1139';
+KW1140 : 'KW' '1140';
+KW1141 : 'KW' '1141';
+KW1142 : 'KW' '1142';
+KW1143 : 'KW' '1143';
+KW1144 : 'KW' '1144';
+KW1145 : 'KW' '1145';
+KW1146 : 'KW' '1146';
+KW1147 : 'KW' '1147';
+KW1148 : 'KW' '1148';
+KW1149 : 'KW' '1149';
+KW1150 : 'KW' '1150';
+KW1151 : 'KW' '1151';
+KW1152 : 'KW' '1152';
+KW1153 : 'KW' '1153';
+KW1154 : 'KW' '1154';
+KW1155 : 'KW' '1155';
+KW1156 : 'KW' '1156';
+KW1157 : 'KW' '1157';
+KW1158 : 'KW' '1158';
+KW1159 : 'KW' '1159';
+KW1160 : 'KW' '1160';
+KW1161 : 'KW' '1161';
+KW1162 : 'KW' '1162';
+KW1163 : 'KW' '1163';
+KW1164 : 'KW' '1164';
+KW1165 : 'KW' '1165';
+KW1166 : 'KW' '1166';
+KW1167 : 'KW' '1167';
+KW1168 : 'KW' '1168';
+KW1169 : 'KW' '1169';
+KW1170 : 'KW' '1170';
+KW1171 : 'KW' '1171';
+KW1172 : 'KW' '1172';
+KW1173 : 'KW' '1173';
+KW1174 : 'KW' '1174';
+KW1175 : 'KW' '1175';
+KW1176 : 'KW' '1176';
+KW1177 : 'KW' '1177';
+KW1178 : 'KW' '1178';
+KW1179 : 'KW' '1179';
+KW1180 : 'KW' '1180';
+KW1181 : 'KW' '1181';
+KW1182 : 'KW' '1182';
+KW1183 : 'KW' '1183';
+KW1184 : 'KW' '1184';
+KW1185 : 'KW' '1185';
+KW1186 : 'KW' '1186';
+KW1187 : 'KW' '1187';
+KW1188 : 'KW' '1188';
+KW1189 : 'KW' '1189';
+KW1190 : 'KW' '1190';
+KW1191 : 'KW' '1191';
+KW1192 : 'KW' '1192';
+KW1193 : 'KW' '1193';
+KW1194 : 'KW' '1194';
+KW1195 : 'KW' '1195';
+KW1196 : 'KW' '1196';
+KW1197 : 'KW' '1197';
+KW1198 : 'KW' '1198';
+KW1199 : 'KW' '1199';
+KW1200 : 'KW' '1200';
+KW1201 : 'KW' '1201';
+KW1202 : 'KW' '1202';
+KW1203 : 'KW' '1203';
+KW1204 : 'KW' '1204';
+KW1205 : 'KW' '1205';
+KW1206 : 'KW' '1206';
+KW1207 : 'KW' '1207';
+KW1208 : 'KW' '1208';
+KW1209 : 'KW' '1209';
+KW1210 : 'KW' '1210';
+KW1211 : 'KW' '1211';
+KW1212 : 'KW' '1212';
+KW1213 : 'KW' '1213';
+KW1214 : 'KW' '1214';
+KW1215 : 'KW' '1215';
+KW1216 : 'KW' '1216';
+KW1217 : 'KW' '1217';
+KW1218 : 'KW' '1218';
+KW1219 : 'KW' '1219';
+KW1220 : 'KW' '1220';
+KW1221 : 'KW' '1221';
+KW1222 : 'KW' '1222';
+KW1223 : 'KW' '1223';
+KW1224 : 'KW' '1224';
+KW1225 : 'KW' '1225';
+KW1226 : 'KW' '1226';
+KW1227 : 'KW' '1227';
+KW1228 : 'KW' '1228';
+KW1229 : 'KW' '1229';
+KW1230 : 'KW' '1230';
+KW1231 : 'KW' '1231';
+KW1232 : 'KW' '1232';
+KW1233 : 'KW' '1233';
+KW1234 : 'KW' '1234';
+KW1235 : 'KW' '1235';
+KW1236 : 'KW' '1236';
+KW1237 : 'KW' '1237';
+KW1238 : 'KW' '1238';
+KW1239 : 'KW' '1239';
+KW1240 : 'KW' '1240';
+KW1241 : 'KW' '1241';
+KW1242 : 'KW' '1242';
+KW1243 : 'KW' '1243';
+KW1244 : 'KW' '1244';
+KW1245 : 'KW' '1245';
+KW1246 : 'KW' '1246';
+KW1247 : 'KW' '1247';
+KW1248 : 'KW' '1248';
+KW1249 : 'KW' '1249';
+KW1250 : 'KW' '1250';
+KW1251 : 'KW' '1251';
+KW1252 : 'KW' '1252';
+KW1253 : 'KW' '1253';
+KW1254 : 'KW' '1254';
+KW1255 : 'KW' '1255';
+KW1256 : 'KW' '1256';
+KW1257 : 'KW' '1257';
+KW1258 : 'KW' '1258';
+KW1259 : 'KW' '1259';
+KW1260 : 'KW' '1260';
+KW1261 : 'KW' '1261';
+KW1262 : 'KW' '1262';
+KW1263 : 'KW' '1263';
+KW1264 : 'KW' '1264';
+KW1265 : 'KW' '1265';
+KW1266 : 'KW' '1266';
+KW1267 : 'KW' '1267';
+KW1268 : 'KW' '1268';
+KW1269 : 'KW' '1269';
+KW1270 : 'KW' '1270';
+KW1271 : 'KW' '1271';
+KW1272 : 'KW' '1272';
+KW1273 : 'KW' '1273';
+KW1274 : 'KW' '1274';
+KW1275 : 'KW' '1275';
+KW1276 : 'KW' '1276';
+KW1277 : 'KW' '1277';
+KW1278 : 'KW' '1278';
+KW1279 : 'KW' '1279';
+KW1280 : 'KW' '1280';
+KW1281 : 'KW' '1281';
+KW1282 : 'KW' '1282';
+KW1283 : 'KW' '1283';
+KW1284 : 'KW' '1284';
+KW1285 : 'KW' '1285';
+KW1286 : 'KW' '1286';
+KW1287 : 'KW' '1287';
+KW1288 : 'KW' '1288';
+KW1289 : 'KW' '1289';
+KW1290 : 'KW' '1290';
+KW1291 : 'KW' '1291';
+KW1292 : 'KW' '1292';
+KW1293 : 'KW' '1293';
+KW1294 : 'KW' '1294';
+KW1295 : 'KW' '1295';
+KW1296 : 'KW' '1296';
+KW1297 : 'KW' '1297';
+KW1298 : 'KW' '1298';
+KW1299 : 'KW' '1299';
+KW1300 : 'KW' '1300';
+KW1301 : 'KW' '1301';
+KW1302 : 'KW' '1302';
+KW1303 : 'KW' '1303';
+KW1304 : 'KW' '1304';
+KW1305 : 'KW' '1305';
+KW1306 : 'KW' '1306';
+KW1307 : 'KW' '1307';
+KW1308 : 'KW' '1308';
+KW1309 : 'KW' '1309';
+KW1310 : 'KW' '1310';
+KW1311 : 'KW' '1311';
+KW1312 : 'KW' '1312';
+KW1313 : 'KW' '1313';
+KW1314 : 'KW' '1314';
+KW1315 : 'KW' '1315';
+KW1316 : 'KW' '1316';
+KW1317 : 'KW' '1317';
+KW1318 : 'KW' '1318';
+KW1319 : 'KW' '1319';
+KW1320 : 'KW' '1320';
+KW1321 : 'KW' '1321';
+KW1322 : 'KW' '1322';
+KW1323 : 'KW' '1323';
+KW1324 : 'KW' '1324';
+KW1325 : 'KW' '1325';
+KW1326 : 'KW' '1326';
+KW1327 : 'KW' '1327';
+KW1328 : 'KW' '1328';
+KW1329 : 'KW' '1329';
+KW1330 : 'KW' '1330';
+KW1331 : 'KW' '1331';
+KW1332 : 'KW' '1332';
+KW1333 : 'KW' '1333';
+KW1334 : 'KW' '1334';
+KW1335 : 'KW' '1335';
+KW1336 : 'KW' '1336';
+KW1337 : 'KW' '1337';
+KW1338 : 'KW' '1338';
+KW1339 : 'KW' '1339';
+KW1340 : 'KW' '1340';
+KW1341 : 'KW' '1341';
+KW1342 : 'KW' '1342';
+KW1343 : 'KW' '1343';
+KW1344 : 'KW' '1344';
+KW1345 : 'KW' '1345';
+KW1346 : 'KW' '1346';
+KW1347 : 'KW' '1347';
+KW1348 : 'KW' '1348';
+KW1349 : 'KW' '1349';
+KW1350 : 'KW' '1350';
+KW1351 : 'KW' '1351';
+KW1352 : 'KW' '1352';
+KW1353 : 'KW' '1353';
+KW1354 : 'KW' '1354';
+KW1355 : 'KW' '1355';
+KW1356 : 'KW' '1356';
+KW1357 : 'KW' '1357';
+KW1358 : 'KW' '1358';
+KW1359 : 'KW' '1359';
+KW1360 : 'KW' '1360';
+KW1361 : 'KW' '1361';
+KW1362 : 'KW' '1362';
+KW1363 : 'KW' '1363';
+KW1364 : 'KW' '1364';
+KW1365 : 'KW' '1365';
+KW1366 : 'KW' '1366';
+KW1367 : 'KW' '1367';
+KW1368 : 'KW' '1368';
+KW1369 : 'KW' '1369';
+KW1370 : 'KW' '1370';
+KW1371 : 'KW' '1371';
+KW1372 : 'KW' '1372';
+KW1373 : 'KW' '1373';
+KW1374 : 'KW' '1374';
+KW1375 : 'KW' '1375';
+KW1376 : 'KW' '1376';
+KW1377 : 'KW' '1377';
+KW1378 : 'KW' '1378';
+KW1379 : 'KW' '1379';
+KW1380 : 'KW' '1380';
+KW1381 : 'KW' '1381';
+KW1382 : 'KW' '1382';
+KW1383 : 'KW' '1383';
+KW1384 : 'KW' '1384';
+KW1385 : 'KW' '1385';
+KW1386 : 'KW' '1386';
+KW1387 : 'KW' '1387';
+KW1388 : 'KW' '1388';
+KW1389 : 'KW' '1389';
+KW1390 : 'KW' '1390';
+KW1391 : 'KW' '1391';
+KW1392 : 'KW' '1392';
+KW1393 : 'KW' '1393';
+KW1394 : 'KW' '1394';
+KW1395 : 'KW' '1395';
+KW1396 : 'KW' '1396';
+KW1397 : 'KW' '1397';
+KW1398 : 'KW' '1398';
+KW1399 : 'KW' '1399';
+KW1400 : 'KW' '1400';
+KW1401 : 'KW' '1401';
+KW1402 : 'KW' '1402';
+KW1403 : 'KW' '1403';
+KW1404 : 'KW' '1404';
+KW1405 : 'KW' '1405';
+KW1406 : 'KW' '1406';
+KW1407 : 'KW' '1407';
+KW1408 : 'KW' '1408';
+KW1409 : 'KW' '1409';
+KW1410 : 'KW' '1410';
+KW1411 : 'KW' '1411';
+KW1412 : 'KW' '1412';
+KW1413 : 'KW' '1413';
+KW1414 : 'KW' '1414';
+KW1415 : 'KW' '1415';
+KW1416 : 'KW' '1416';
+KW1417 : 'KW' '1417';
+KW1418 : 'KW' '1418';
+KW1419 : 'KW' '1419';
+KW1420 : 'KW' '1420';
+KW1421 : 'KW' '1421';
+KW1422 : 'KW' '1422';
+KW1423 : 'KW' '1423';
+KW1424 : 'KW' '1424';
+KW1425 : 'KW' '1425';
+KW1426 : 'KW' '1426';
+KW1427 : 'KW' '1427';
+KW1428 : 'KW' '1428';
+KW1429 : 'KW' '1429';
+KW1430 : 'KW' '1430';
+KW1431 : 'KW' '1431';
+KW1432 : 'KW' '1432';
+KW1433 : 'KW' '1433';
+KW1434 : 'KW' '1434';
+KW1435 : 'KW' '1435';
+KW1436 : 'KW' '1436';
+KW1437 : 'KW' '1437';
+KW1438 : 'KW' '1438';
+KW1439 : 'KW' '1439';
+KW1440 : 'KW' '1440';
+KW1441 : 'KW' '1441';
+KW1442 : 'KW' '1442';
+KW1443 : 'KW' '1443';
+KW1444 : 'KW' '1444';
+KW1445 : 'KW' '1445';
+KW1446 : 'KW' '1446';
+KW1447 : 'KW' '1447';
+KW1448 : 'KW' '1448';
+KW1449 : 'KW' '1449';
+KW1450 : 'KW' '1450';
+KW1451 : 'KW' '1451';
+KW1452 : 'KW' '1452';
+KW1453 : 'KW' '1453';
+KW1454 : 'KW' '1454';
+KW1455 : 'KW' '1455';
+KW1456 : 'KW' '1456';
+KW1457 : 'KW' '1457';
+KW1458 : 'KW' '1458';
+KW1459 : 'KW' '1459';
+KW1460 : 'KW' '1460';
+KW1461 : 'KW' '1461';
+KW1462 : 'KW' '1462';
+KW1463 : 'KW' '1463';
+KW1464 : 'KW' '1464';
+KW1465 : 'KW' '1465';
+KW1466 : 'KW' '1466';
+KW1467 : 'KW' '1467';
+KW1468 : 'KW' '1468';
+KW1469 : 'KW' '1469';
+KW1470 : 'KW' '1470';
+KW1471 : 'KW' '1471';
+KW1472 : 'KW' '1472';
+KW1473 : 'KW' '1473';
+KW1474 : 'KW' '1474';
+KW1475 : 'KW' '1475';
+KW1476 : 'KW' '1476';
+KW1477 : 'KW' '1477';
+KW1478 : 'KW' '1478';
+KW1479 : 'KW' '1479';
+KW1480 : 'KW' '1480';
+KW1481 : 'KW' '1481';
+KW1482 : 'KW' '1482';
+KW1483 : 'KW' '1483';
+KW1484 : 'KW' '1484';
+KW1485 : 'KW' '1485';
+KW1486 : 'KW' '1486';
+KW1487 : 'KW' '1487';
+KW1488 : 'KW' '1488';
+KW1489 : 'KW' '1489';
+KW1490 : 'KW' '1490';
+KW1491 : 'KW' '1491';
+KW1492 : 'KW' '1492';
+KW1493 : 'KW' '1493';
+KW1494 : 'KW' '1494';
+KW1495 : 'KW' '1495';
+KW1496 : 'KW' '1496';
+KW1497 : 'KW' '1497';
+KW1498 : 'KW' '1498';
+KW1499 : 'KW' '1499';
+KW1500 : 'KW' '1500';
+KW1501 : 'KW' '1501';
+KW1502 : 'KW' '1502';
+KW1503 : 'KW' '1503';
+KW1504 : 'KW' '1504';
+KW1505 : 'KW' '1505';
+KW1506 : 'KW' '1506';
+KW1507 : 'KW' '1507';
+KW1508 : 'KW' '1508';
+KW1509 : 'KW' '1509';
+KW1510 : 'KW' '1510';
+KW1511 : 'KW' '1511';
+KW1512 : 'KW' '1512';
+KW1513 : 'KW' '1513';
+KW1514 : 'KW' '1514';
+KW1515 : 'KW' '1515';
+KW1516 : 'KW' '1516';
+KW1517 : 'KW' '1517';
+KW1518 : 'KW' '1518';
+KW1519 : 'KW' '1519';
+KW1520 : 'KW' '1520';
+KW1521 : 'KW' '1521';
+KW1522 : 'KW' '1522';
+KW1523 : 'KW' '1523';
+KW1524 : 'KW' '1524';
+KW1525 : 'KW' '1525';
+KW1526 : 'KW' '1526';
+KW1527 : 'KW' '1527';
+KW1528 : 'KW' '1528';
+KW1529 : 'KW' '1529';
+KW1530 : 'KW' '1530';
+KW1531 : 'KW' '1531';
+KW1532 : 'KW' '1532';
+KW1533 : 'KW' '1533';
+KW1534 : 'KW' '1534';
+KW1535 : 'KW' '1535';
+KW1536 : 'KW' '1536';
+KW1537 : 'KW' '1537';
+KW1538 : 'KW' '1538';
+KW1539 : 'KW' '1539';
+KW1540 : 'KW' '1540';
+KW1541 : 'KW' '1541';
+KW1542 : 'KW' '1542';
+KW1543 : 'KW' '1543';
+KW1544 : 'KW' '1544';
+KW1545 : 'KW' '1545';
+KW1546 : 'KW' '1546';
+KW1547 : 'KW' '1547';
+KW1548 : 'KW' '1548';
+KW1549 : 'KW' '1549';
+KW1550 : 'KW' '1550';
+KW1551 : 'KW' '1551';
+KW1552 : 'KW' '1552';
+KW1553 : 'KW' '1553';
+KW1554 : 'KW' '1554';
+KW1555 : 'KW' '1555';
+KW1556 : 'KW' '1556';
+KW1557 : 'KW' '1557';
+KW1558 : 'KW' '1558';
+KW1559 : 'KW' '1559';
+KW1560 : 'KW' '1560';
+KW1561 : 'KW' '1561';
+KW1562 : 'KW' '1562';
+KW1563 : 'KW' '1563';
+KW1564 : 'KW' '1564';
+KW1565 : 'KW' '1565';
+KW1566 : 'KW' '1566';
+KW1567 : 'KW' '1567';
+KW1568 : 'KW' '1568';
+KW1569 : 'KW' '1569';
+KW1570 : 'KW' '1570';
+KW1571 : 'KW' '1571';
+KW1572 : 'KW' '1572';
+KW1573 : 'KW' '1573';
+KW1574 : 'KW' '1574';
+KW1575 : 'KW' '1575';
+KW1576 : 'KW' '1576';
+KW1577 : 'KW' '1577';
+KW1578 : 'KW' '1578';
+KW1579 : 'KW' '1579';
+KW1580 : 'KW' '1580';
+KW1581 : 'KW' '1581';
+KW1582 : 'KW' '1582';
+KW1583 : 'KW' '1583';
+KW1584 : 'KW' '1584';
+KW1585 : 'KW' '1585';
+KW1586 : 'KW' '1586';
+KW1587 : 'KW' '1587';
+KW1588 : 'KW' '1588';
+KW1589 : 'KW' '1589';
+KW1590 : 'KW' '1590';
+KW1591 : 'KW' '1591';
+KW1592 : 'KW' '1592';
+KW1593 : 'KW' '1593';
+KW1594 : 'KW' '1594';
+KW1595 : 'KW' '1595';
+KW1596 : 'KW' '1596';
+KW1597 : 'KW' '1597';
+KW1598 : 'KW' '1598';
+KW1599 : 'KW' '1599';
+KW1600 : 'KW' '1600';
+KW1601 : 'KW' '1601';
+KW1602 : 'KW' '1602';
+KW1603 : 'KW' '1603';
+KW1604 : 'KW' '1604';
+KW1605 : 'KW' '1605';
+KW1606 : 'KW' '1606';
+KW1607 : 'KW' '1607';
+KW1608 : 'KW' '1608';
+KW1609 : 'KW' '1609';
+KW1610 : 'KW' '1610';
+KW1611 : 'KW' '1611';
+KW1612 : 'KW' '1612';
+KW1613 : 'KW' '1613';
+KW1614 : 'KW' '1614';
+KW1615 : 'KW' '1615';
+KW1616 : 'KW' '1616';
+KW1617 : 'KW' '1617';
+KW1618 : 'KW' '1618';
+KW1619 : 'KW' '1619';
+KW1620 : 'KW' '1620';
+KW1621 : 'KW' '1621';
+KW1622 : 'KW' '1622';
+KW1623 : 'KW' '1623';
+KW1624 : 'KW' '1624';
+KW1625 : 'KW' '1625';
+KW1626 : 'KW' '1626';
+KW1627 : 'KW' '1627';
+KW1628 : 'KW' '1628';
+KW1629 : 'KW' '1629';
+KW1630 : 'KW' '1630';
+KW1631 : 'KW' '1631';
+KW1632 : 'KW' '1632';
+KW1633 : 'KW' '1633';
+KW1634 : 'KW' '1634';
+KW1635 : 'KW' '1635';
+KW1636 : 'KW' '1636';
+KW1637 : 'KW' '1637';
+KW1638 : 'KW' '1638';
+KW1639 : 'KW' '1639';
+KW1640 : 'KW' '1640';
+KW1641 : 'KW' '1641';
+KW1642 : 'KW' '1642';
+KW1643 : 'KW' '1643';
+KW1644 : 'KW' '1644';
+KW1645 : 'KW' '1645';
+KW1646 : 'KW' '1646';
+KW1647 : 'KW' '1647';
+KW1648 : 'KW' '1648';
+KW1649 : 'KW' '1649';
+KW1650 : 'KW' '1650';
+KW1651 : 'KW' '1651';
+KW1652 : 'KW' '1652';
+KW1653 : 'KW' '1653';
+KW1654 : 'KW' '1654';
+KW1655 : 'KW' '1655';
+KW1656 : 'KW' '1656';
+KW1657 : 'KW' '1657';
+KW1658 : 'KW' '1658';
+KW1659 : 'KW' '1659';
+KW1660 : 'KW' '1660';
+KW1661 : 'KW' '1661';
+KW1662 : 'KW' '1662';
+KW1663 : 'KW' '1663';
+KW1664 : 'KW' '1664';
+KW1665 : 'KW' '1665';
+KW1666 : 'KW' '1666';
+KW1667 : 'KW' '1667';
+KW1668 : 'KW' '1668';
+KW1669 : 'KW' '1669';
+KW1670 : 'KW' '1670';
+KW1671 : 'KW' '1671';
+KW1672 : 'KW' '1672';
+KW1673 : 'KW' '1673';
+KW1674 : 'KW' '1674';
+KW1675 : 'KW' '1675';
+KW1676 : 'KW' '1676';
+KW1677 : 'KW' '1677';
+KW1678 : 'KW' '1678';
+KW1679 : 'KW' '1679';
+KW1680 : 'KW' '1680';
+KW1681 : 'KW' '1681';
+KW1682 : 'KW' '1682';
+KW1683 : 'KW' '1683';
+KW1684 : 'KW' '1684';
+KW1685 : 'KW' '1685';
+KW1686 : 'KW' '1686';
+KW1687 : 'KW' '1687';
+KW1688 : 'KW' '1688';
+KW1689 : 'KW' '1689';
+KW1690 : 'KW' '1690';
+KW1691 : 'KW' '1691';
+KW1692 : 'KW' '1692';
+KW1693 : 'KW' '1693';
+KW1694 : 'KW' '1694';
+KW1695 : 'KW' '1695';
+KW1696 : 'KW' '1696';
+KW1697 : 'KW' '1697';
+KW1698 : 'KW' '1698';
+KW1699 : 'KW' '1699';
+KW1700 : 'KW' '1700';
+KW1701 : 'KW' '1701';
+KW1702 : 'KW' '1702';
+KW1703 : 'KW' '1703';
+KW1704 : 'KW' '1704';
+KW1705 : 'KW' '1705';
+KW1706 : 'KW' '1706';
+KW1707 : 'KW' '1707';
+KW1708 : 'KW' '1708';
+KW1709 : 'KW' '1709';
+KW1710 : 'KW' '1710';
+KW1711 : 'KW' '1711';
+KW1712 : 'KW' '1712';
+KW1713 : 'KW' '1713';
+KW1714 : 'KW' '1714';
+KW1715 : 'KW' '1715';
+KW1716 : 'KW' '1716';
+KW1717 : 'KW' '1717';
+KW1718 : 'KW' '1718';
+KW1719 : 'KW' '1719';
+KW1720 : 'KW' '1720';
+KW1721 : 'KW' '1721';
+KW1722 : 'KW' '1722';
+KW1723 : 'KW' '1723';
+KW1724 : 'KW' '1724';
+KW1725 : 'KW' '1725';
+KW1726 : 'KW' '1726';
+KW1727 : 'KW' '1727';
+KW1728 : 'KW' '1728';
+KW1729 : 'KW' '1729';
+KW1730 : 'KW' '1730';
+KW1731 : 'KW' '1731';
+KW1732 : 'KW' '1732';
+KW1733 : 'KW' '1733';
+KW1734 : 'KW' '1734';
+KW1735 : 'KW' '1735';
+KW1736 : 'KW' '1736';
+KW1737 : 'KW' '1737';
+KW1738 : 'KW' '1738';
+KW1739 : 'KW' '1739';
+KW1740 : 'KW' '1740';
+KW1741 : 'KW' '1741';
+KW1742 : 'KW' '1742';
+KW1743 : 'KW' '1743';
+KW1744 : 'KW' '1744';
+KW1745 : 'KW' '1745';
+KW1746 : 'KW' '1746';
+KW1747 : 'KW' '1747';
+KW1748 : 'KW' '1748';
+KW1749 : 'KW' '1749';
+KW1750 : 'KW' '1750';
+KW1751 : 'KW' '1751';
+KW1752 : 'KW' '1752';
+KW1753 : 'KW' '1753';
+KW1754 : 'KW' '1754';
+KW1755 : 'KW' '1755';
+KW1756 : 'KW' '1756';
+KW1757 : 'KW' '1757';
+KW1758 : 'KW' '1758';
+KW1759 : 'KW' '1759';
+KW1760 : 'KW' '1760';
+KW1761 : 'KW' '1761';
+KW1762 : 'KW' '1762';
+KW1763 : 'KW' '1763';
+KW1764 : 'KW' '1764';
+KW1765 : 'KW' '1765';
+KW1766 : 'KW' '1766';
+KW1767 : 'KW' '1767';
+KW1768 : 'KW' '1768';
+KW1769 : 'KW' '1769';
+KW1770 : 'KW' '1770';
+KW1771 : 'KW' '1771';
+KW1772 : 'KW' '1772';
+KW1773 : 'KW' '1773';
+KW1774 : 'KW' '1774';
+KW1775 : 'KW' '1775';
+KW1776 : 'KW' '1776';
+KW1777 : 'KW' '1777';
+KW1778 : 'KW' '1778';
+KW1779 : 'KW' '1779';
+KW1780 : 'KW' '1780';
+KW1781 : 'KW' '1781';
+KW1782 : 'KW' '1782';
+KW1783 : 'KW' '1783';
+KW1784 : 'KW' '1784';
+KW1785 : 'KW' '1785';
+KW1786 : 'KW' '1786';
+KW1787 : 'KW' '1787';
+KW1788 : 'KW' '1788';
+KW1789 : 'KW' '1789';
+KW1790 : 'KW' '1790';
+KW1791 : 'KW' '1791';
+KW1792 : 'KW' '1792';
+KW1793 : 'KW' '1793';
+KW1794 : 'KW' '1794';
+KW1795 : 'KW' '1795';
+KW1796 : 'KW' '1796';
+KW1797 : 'KW' '1797';
+KW1798 : 'KW' '1798';
+KW1799 : 'KW' '1799';
+KW1800 : 'KW' '1800';
+KW1801 : 'KW' '1801';
+KW1802 : 'KW' '1802';
+KW1803 : 'KW' '1803';
+KW1804 : 'KW' '1804';
+KW1805 : 'KW' '1805';
+KW1806 : 'KW' '1806';
+KW1807 : 'KW' '1807';
+KW1808 : 'KW' '1808';
+KW1809 : 'KW' '1809';
+KW1810 : 'KW' '1810';
+KW1811 : 'KW' '1811';
+KW1812 : 'KW' '1812';
+KW1813 : 'KW' '1813';
+KW1814 : 'KW' '1814';
+KW1815 : 'KW' '1815';
+KW1816 : 'KW' '1816';
+KW1817 : 'KW' '1817';
+KW1818 : 'KW' '1818';
+KW1819 : 'KW' '1819';
+KW1820 : 'KW' '1820';
+KW1821 : 'KW' '1821';
+KW1822 : 'KW' '1822';
+KW1823 : 'KW' '1823';
+KW1824 : 'KW' '1824';
+KW1825 : 'KW' '1825';
+KW1826 : 'KW' '1826';
+KW1827 : 'KW' '1827';
+KW1828 : 'KW' '1828';
+KW1829 : 'KW' '1829';
+KW1830 : 'KW' '1830';
+KW1831 : 'KW' '1831';
+KW1832 : 'KW' '1832';
+KW1833 : 'KW' '1833';
+KW1834 : 'KW' '1834';
+KW1835 : 'KW' '1835';
+KW1836 : 'KW' '1836';
+KW1837 : 'KW' '1837';
+KW1838 : 'KW' '1838';
+KW1839 : 'KW' '1839';
+KW1840 : 'KW' '1840';
+KW1841 : 'KW' '1841';
+KW1842 : 'KW' '1842';
+KW1843 : 'KW' '1843';
+KW1844 : 'KW' '1844';
+KW1845 : 'KW' '1845';
+KW1846 : 'KW' '1846';
+KW1847 : 'KW' '1847';
+KW1848 : 'KW' '1848';
+KW1849 : 'KW' '1849';
+KW1850 : 'KW' '1850';
+KW1851 : 'KW' '1851';
+KW1852 : 'KW' '1852';
+KW1853 : 'KW' '1853';
+KW1854 : 'KW' '1854';
+KW1855 : 'KW' '1855';
+KW1856 : 'KW' '1856';
+KW1857 : 'KW' '1857';
+KW1858 : 'KW' '1858';
+KW1859 : 'KW' '1859';
+KW1860 : 'KW' '1860';
+KW1861 : 'KW' '1861';
+KW1862 : 'KW' '1862';
+KW1863 : 'KW' '1863';
+KW1864 : 'KW' '1864';
+KW1865 : 'KW' '1865';
+KW1866 : 'KW' '1866';
+KW1867 : 'KW' '1867';
+KW1868 : 'KW' '1868';
+KW1869 : 'KW' '1869';
+KW1870 : 'KW' '1870';
+KW1871 : 'KW' '1871';
+KW1872 : 'KW' '1872';
+KW1873 : 'KW' '1873';
+KW1874 : 'KW' '1874';
+KW1875 : 'KW' '1875';
+KW1876 : 'KW' '1876';
+KW1877 : 'KW' '1877';
+KW1878 : 'KW' '1878';
+KW1879 : 'KW' '1879';
+KW1880 : 'KW' '1880';
+KW1881 : 'KW' '1881';
+KW1882 : 'KW' '1882';
+KW1883 : 'KW' '1883';
+KW1884 : 'KW' '1884';
+KW1885 : 'KW' '1885';
+KW1886 : 'KW' '1886';
+KW1887 : 'KW' '1887';
+KW1888 : 'KW' '1888';
+KW1889 : 'KW' '1889';
+KW1890 : 'KW' '1890';
+KW1891 : 'KW' '1891';
+KW1892 : 'KW' '1892';
+KW1893 : 'KW' '1893';
+KW1894 : 'KW' '1894';
+KW1895 : 'KW' '1895';
+KW1896 : 'KW' '1896';
+KW1897 : 'KW' '1897';
+KW1898 : 'KW' '1898';
+KW1899 : 'KW' '1899';
+KW1900 : 'KW' '1900';
+KW1901 : 'KW' '1901';
+KW1902 : 'KW' '1902';
+KW1903 : 'KW' '1903';
+KW1904 : 'KW' '1904';
+KW1905 : 'KW' '1905';
+KW1906 : 'KW' '1906';
+KW1907 : 'KW' '1907';
+KW1908 : 'KW' '1908';
+KW1909 : 'KW' '1909';
+KW1910 : 'KW' '1910';
+KW1911 : 'KW' '1911';
+KW1912 : 'KW' '1912';
+KW1913 : 'KW' '1913';
+KW1914 : 'KW' '1914';
+KW1915 : 'KW' '1915';
+KW1916 : 'KW' '1916';
+KW1917 : 'KW' '1917';
+KW1918 : 'KW' '1918';
+KW1919 : 'KW' '1919';
+KW1920 : 'KW' '1920';
+KW1921 : 'KW' '1921';
+KW1922 : 'KW' '1922';
+KW1923 : 'KW' '1923';
+KW1924 : 'KW' '1924';
+KW1925 : 'KW' '1925';
+KW1926 : 'KW' '1926';
+KW1927 : 'KW' '1927';
+KW1928 : 'KW' '1928';
+KW1929 : 'KW' '1929';
+KW1930 : 'KW' '1930';
+KW1931 : 'KW' '1931';
+KW1932 : 'KW' '1932';
+KW1933 : 'KW' '1933';
+KW1934 : 'KW' '1934';
+KW1935 : 'KW' '1935';
+KW1936 : 'KW' '1936';
+KW1937 : 'KW' '1937';
+KW1938 : 'KW' '1938';
+KW1939 : 'KW' '1939';
+KW1940 : 'KW' '1940';
+KW1941 : 'KW' '1941';
+KW1942 : 'KW' '1942';
+KW1943 : 'KW' '1943';
+KW1944 : 'KW' '1944';
+KW1945 : 'KW' '1945';
+KW1946 : 'KW' '1946';
+KW1947 : 'KW' '1947';
+KW1948 : 'KW' '1948';
+KW1949 : 'KW' '1949';
+KW1950 : 'KW' '1950';
+KW1951 : 'KW' '1951';
+KW1952 : 'KW' '1952';
+KW1953 : 'KW' '1953';
+KW1954 : 'KW' '1954';
+KW1955 : 'KW' '1955';
+KW1956 : 'KW' '1956';
+KW1957 : 'KW' '1957';
+KW1958 : 'KW' '1958';
+KW1959 : 'KW' '1959';
+KW1960 : 'KW' '1960';
+KW1961 : 'KW' '1961';
+KW1962 : 'KW' '1962';
+KW1963 : 'KW' '1963';
+KW1964 : 'KW' '1964';
+KW1965 : 'KW' '1965';
+KW1966 : 'KW' '1966';
+KW1967 : 'KW' '1967';
+KW1968 : 'KW' '1968';
+KW1969 : 'KW' '1969';
+KW1970 : 'KW' '1970';
+KW1971 : 'KW' '1971';
+KW1972 : 'KW' '1972';
+KW1973 : 'KW' '1973';
+KW1974 : 'KW' '1974';
+KW1975 : 'KW' '1975';
+KW1976 : 'KW' '1976';
+KW1977 : 'KW' '1977';
+KW1978 : 'KW' '1978';
+KW1979 : 'KW' '1979';
+KW1980 : 'KW' '1980';
+KW1981 : 'KW' '1981';
+KW1982 : 'KW' '1982';
+KW1983 : 'KW' '1983';
+KW1984 : 'KW' '1984';
+KW1985 : 'KW' '1985';
+KW1986 : 'KW' '1986';
+KW1987 : 'KW' '1987';
+KW1988 : 'KW' '1988';
+KW1989 : 'KW' '1989';
+KW1990 : 'KW' '1990';
+KW1991 : 'KW' '1991';
+KW1992 : 'KW' '1992';
+KW1993 : 'KW' '1993';
+KW1994 : 'KW' '1994';
+KW1995 : 'KW' '1995';
+KW1996 : 'KW' '1996';
+KW1997 : 'KW' '1997';
+KW1998 : 'KW' '1998';
+KW1999 : 'KW' '1999';
+KW2000 : 'KW' '2000';
+KW2001 : 'KW' '2001';
+KW2002 : 'KW' '2002';
+KW2003 : 'KW' '2003';
+KW2004 : 'KW' '2004';
+KW2005 : 'KW' '2005';
+KW2006 : 'KW' '2006';
+KW2007 : 'KW' '2007';
+KW2008 : 'KW' '2008';
+KW2009 : 'KW' '2009';
+KW2010 : 'KW' '2010';
+KW2011 : 'KW' '2011';
+KW2012 : 'KW' '2012';
+KW2013 : 'KW' '2013';
+KW2014 : 'KW' '2014';
+KW2015 : 'KW' '2015';
+KW2016 : 'KW' '2016';
+KW2017 : 'KW' '2017';
+KW2018 : 'KW' '2018';
+KW2019 : 'KW' '2019';
+KW2020 : 'KW' '2020';
+KW2021 : 'KW' '2021';
+KW2022 : 'KW' '2022';
+KW2023 : 'KW' '2023';
+KW2024 : 'KW' '2024';
+KW2025 : 'KW' '2025';
+KW2026 : 'KW' '2026';
+KW2027 : 'KW' '2027';
+KW2028 : 'KW' '2028';
+KW2029 : 'KW' '2029';
+KW2030 : 'KW' '2030';
+KW2031 : 'KW' '2031';
+KW2032 : 'KW' '2032';
+KW2033 : 'KW' '2033';
+KW2034 : 'KW' '2034';
+KW2035 : 'KW' '2035';
+KW2036 : 'KW' '2036';
+KW2037 : 'KW' '2037';
+KW2038 : 'KW' '2038';
+KW2039 : 'KW' '2039';
+KW2040 : 'KW' '2040';
+KW2041 : 'KW' '2041';
+KW2042 : 'KW' '2042';
+KW2043 : 'KW' '2043';
+KW2044 : 'KW' '2044';
+KW2045 : 'KW' '2045';
+KW2046 : 'KW' '2046';
+KW2047 : 'KW' '2047';
+KW2048 : 'KW' '2048';
+KW2049 : 'KW' '2049';
+KW2050 : 'KW' '2050';
+KW2051 : 'KW' '2051';
+KW2052 : 'KW' '2052';
+KW2053 : 'KW' '2053';
+KW2054 : 'KW' '2054';
+KW2055 : 'KW' '2055';
+KW2056 : 'KW' '2056';
+KW2057 : 'KW' '2057';
+KW2058 : 'KW' '2058';
+KW2059 : 'KW' '2059';
+KW2060 : 'KW' '2060';
+KW2061 : 'KW' '2061';
+KW2062 : 'KW' '2062';
+KW2063 : 'KW' '2063';
+KW2064 : 'KW' '2064';
+KW2065 : 'KW' '2065';
+KW2066 : 'KW' '2066';
+KW2067 : 'KW' '2067';
+KW2068 : 'KW' '2068';
+KW2069 : 'KW' '2069';
+KW2070 : 'KW' '2070';
+KW2071 : 'KW' '2071';
+KW2072 : 'KW' '2072';
+KW2073 : 'KW' '2073';
+KW2074 : 'KW' '2074';
+KW2075 : 'KW' '2075';
+KW2076 : 'KW' '2076';
+KW2077 : 'KW' '2077';
+KW2078 : 'KW' '2078';
+KW2079 : 'KW' '2079';
+KW2080 : 'KW' '2080';
+KW2081 : 'KW' '2081';
+KW2082 : 'KW' '2082';
+KW2083 : 'KW' '2083';
+KW2084 : 'KW' '2084';
+KW2085 : 'KW' '2085';
+KW2086 : 'KW' '2086';
+KW2087 : 'KW' '2087';
+KW2088 : 'KW' '2088';
+KW2089 : 'KW' '2089';
+KW2090 : 'KW' '2090';
+KW2091 : 'KW' '2091';
+KW2092 : 'KW' '2092';
+KW2093 : 'KW' '2093';
+KW2094 : 'KW' '2094';
+KW2095 : 'KW' '2095';
+KW2096 : 'KW' '2096';
+KW2097 : 'KW' '2097';
+KW2098 : 'KW' '2098';
+KW2099 : 'KW' '2099';
+KW2100 : 'KW' '2100';
+KW2101 : 'KW' '2101';
+KW2102 : 'KW' '2102';
+KW2103 : 'KW' '2103';
+KW2104 : 'KW' '2104';
+KW2105 : 'KW' '2105';
+KW2106 : 'KW' '2106';
+KW2107 : 'KW' '2107';
+KW2108 : 'KW' '2108';
+KW2109 : 'KW' '2109';
+KW2110 : 'KW' '2110';
+KW2111 : 'KW' '2111';
+KW2112 : 'KW' '2112';
+KW2113 : 'KW' '2113';
+KW2114 : 'KW' '2114';
+KW2115 : 'KW' '2115';
+KW2116 : 'KW' '2116';
+KW2117 : 'KW' '2117';
+KW2118 : 'KW' '2118';
+KW2119 : 'KW' '2119';
+KW2120 : 'KW' '2120';
+KW2121 : 'KW' '2121';
+KW2122 : 'KW' '2122';
+KW2123 : 'KW' '2123';
+KW2124 : 'KW' '2124';
+KW2125 : 'KW' '2125';
+KW2126 : 'KW' '2126';
+KW2127 : 'KW' '2127';
+KW2128 : 'KW' '2128';
+KW2129 : 'KW' '2129';
+KW2130 : 'KW' '2130';
+KW2131 : 'KW' '2131';
+KW2132 : 'KW' '2132';
+KW2133 : 'KW' '2133';
+KW2134 : 'KW' '2134';
+KW2135 : 'KW' '2135';
+KW2136 : 'KW' '2136';
+KW2137 : 'KW' '2137';
+KW2138 : 'KW' '2138';
+KW2139 : 'KW' '2139';
+KW2140 : 'KW' '2140';
+KW2141 : 'KW' '2141';
+KW2142 : 'KW' '2142';
+KW2143 : 'KW' '2143';
+KW2144 : 'KW' '2144';
+KW2145 : 'KW' '2145';
+KW2146 : 'KW' '2146';
+KW2147 : 'KW' '2147';
+KW2148 : 'KW' '2148';
+KW2149 : 'KW' '2149';
+KW2150 : 'KW' '2150';
+KW2151 : 'KW' '2151';
+KW2152 : 'KW' '2152';
+KW2153 : 'KW' '2153';
+KW2154 : 'KW' '2154';
+KW2155 : 'KW' '2155';
+KW2156 : 'KW' '2156';
+KW2157 : 'KW' '2157';
+KW2158 : 'KW' '2158';
+KW2159 : 'KW' '2159';
+KW2160 : 'KW' '2160';
+KW2161 : 'KW' '2161';
+KW2162 : 'KW' '2162';
+KW2163 : 'KW' '2163';
+KW2164 : 'KW' '2164';
+KW2165 : 'KW' '2165';
+KW2166 : 'KW' '2166';
+KW2167 : 'KW' '2167';
+KW2168 : 'KW' '2168';
+KW2169 : 'KW' '2169';
+KW2170 : 'KW' '2170';
+KW2171 : 'KW' '2171';
+KW2172 : 'KW' '2172';
+KW2173 : 'KW' '2173';
+KW2174 : 'KW' '2174';
+KW2175 : 'KW' '2175';
+KW2176 : 'KW' '2176';
+KW2177 : 'KW' '2177';
+KW2178 : 'KW' '2178';
+KW2179 : 'KW' '2179';
+KW2180 : 'KW' '2180';
+KW2181 : 'KW' '2181';
+KW2182 : 'KW' '2182';
+KW2183 : 'KW' '2183';
+KW2184 : 'KW' '2184';
+KW2185 : 'KW' '2185';
+KW2186 : 'KW' '2186';
+KW2187 : 'KW' '2187';
+KW2188 : 'KW' '2188';
+KW2189 : 'KW' '2189';
+KW2190 : 'KW' '2190';
+KW2191 : 'KW' '2191';
+KW2192 : 'KW' '2192';
+KW2193 : 'KW' '2193';
+KW2194 : 'KW' '2194';
+KW2195 : 'KW' '2195';
+KW2196 : 'KW' '2196';
+KW2197 : 'KW' '2197';
+KW2198 : 'KW' '2198';
+KW2199 : 'KW' '2199';
+KW2200 : 'KW' '2200';
+KW2201 : 'KW' '2201';
+KW2202 : 'KW' '2202';
+KW2203 : 'KW' '2203';
+KW2204 : 'KW' '2204';
+KW2205 : 'KW' '2205';
+KW2206 : 'KW' '2206';
+KW2207 : 'KW' '2207';
+KW2208 : 'KW' '2208';
+KW2209 : 'KW' '2209';
+KW2210 : 'KW' '2210';
+KW2211 : 'KW' '2211';
+KW2212 : 'KW' '2212';
+KW2213 : 'KW' '2213';
+KW2214 : 'KW' '2214';
+KW2215 : 'KW' '2215';
+KW2216 : 'KW' '2216';
+KW2217 : 'KW' '2217';
+KW2218 : 'KW' '2218';
+KW2219 : 'KW' '2219';
+KW2220 : 'KW' '2220';
+KW2221 : 'KW' '2221';
+KW2222 : 'KW' '2222';
+KW2223 : 'KW' '2223';
+KW2224 : 'KW' '2224';
+KW2225 : 'KW' '2225';
+KW2226 : 'KW' '2226';
+KW2227 : 'KW' '2227';
+KW2228 : 'KW' '2228';
+KW2229 : 'KW' '2229';
+KW2230 : 'KW' '2230';
+KW2231 : 'KW' '2231';
+KW2232 : 'KW' '2232';
+KW2233 : 'KW' '2233';
+KW2234 : 'KW' '2234';
+KW2235 : 'KW' '2235';
+KW2236 : 'KW' '2236';
+KW2237 : 'KW' '2237';
+KW2238 : 'KW' '2238';
+KW2239 : 'KW' '2239';
+KW2240 : 'KW' '2240';
+KW2241 : 'KW' '2241';
+KW2242 : 'KW' '2242';
+KW2243 : 'KW' '2243';
+KW2244 : 'KW' '2244';
+KW2245 : 'KW' '2245';
+KW2246 : 'KW' '2246';
+KW2247 : 'KW' '2247';
+KW2248 : 'KW' '2248';
+KW2249 : 'KW' '2249';
+KW2250 : 'KW' '2250';
+KW2251 : 'KW' '2251';
+KW2252 : 'KW' '2252';
+KW2253 : 'KW' '2253';
+KW2254 : 'KW' '2254';
+KW2255 : 'KW' '2255';
+KW2256 : 'KW' '2256';
+KW2257 : 'KW' '2257';
+KW2258 : 'KW' '2258';
+KW2259 : 'KW' '2259';
+KW2260 : 'KW' '2260';
+KW2261 : 'KW' '2261';
+KW2262 : 'KW' '2262';
+KW2263 : 'KW' '2263';
+KW2264 : 'KW' '2264';
+KW2265 : 'KW' '2265';
+KW2266 : 'KW' '2266';
+KW2267 : 'KW' '2267';
+KW2268 : 'KW' '2268';
+KW2269 : 'KW' '2269';
+KW2270 : 'KW' '2270';
+KW2271 : 'KW' '2271';
+KW2272 : 'KW' '2272';
+KW2273 : 'KW' '2273';
+KW2274 : 'KW' '2274';
+KW2275 : 'KW' '2275';
+KW2276 : 'KW' '2276';
+KW2277 : 'KW' '2277';
+KW2278 : 'KW' '2278';
+KW2279 : 'KW' '2279';
+KW2280 : 'KW' '2280';
+KW2281 : 'KW' '2281';
+KW2282 : 'KW' '2282';
+KW2283 : 'KW' '2283';
+KW2284 : 'KW' '2284';
+KW2285 : 'KW' '2285';
+KW2286 : 'KW' '2286';
+KW2287 : 'KW' '2287';
+KW2288 : 'KW' '2288';
+KW2289 : 'KW' '2289';
+KW2290 : 'KW' '2290';
+KW2291 : 'KW' '2291';
+KW2292 : 'KW' '2292';
+KW2293 : 'KW' '2293';
+KW2294 : 'KW' '2294';
+KW2295 : 'KW' '2295';
+KW2296 : 'KW' '2296';
+KW2297 : 'KW' '2297';
+KW2298 : 'KW' '2298';
+KW2299 : 'KW' '2299';
+KW2300 : 'KW' '2300';
+KW2301 : 'KW' '2301';
+KW2302 : 'KW' '2302';
+KW2303 : 'KW' '2303';
+KW2304 : 'KW' '2304';
+KW2305 : 'KW' '2305';
+KW2306 : 'KW' '2306';
+KW2307 : 'KW' '2307';
+KW2308 : 'KW' '2308';
+KW2309 : 'KW' '2309';
+KW2310 : 'KW' '2310';
+KW2311 : 'KW' '2311';
+KW2312 : 'KW' '2312';
+KW2313 : 'KW' '2313';
+KW2314 : 'KW' '2314';
+KW2315 : 'KW' '2315';
+KW2316 : 'KW' '2316';
+KW2317 : 'KW' '2317';
+KW2318 : 'KW' '2318';
+KW2319 : 'KW' '2319';
+KW2320 : 'KW' '2320';
+KW2321 : 'KW' '2321';
+KW2322 : 'KW' '2322';
+KW2323 : 'KW' '2323';
+KW2324 : 'KW' '2324';
+KW2325 : 'KW' '2325';
+KW2326 : 'KW' '2326';
+KW2327 : 'KW' '2327';
+KW2328 : 'KW' '2328';
+KW2329 : 'KW' '2329';
+KW2330 : 'KW' '2330';
+KW2331 : 'KW' '2331';
+KW2332 : 'KW' '2332';
+KW2333 : 'KW' '2333';
+KW2334 : 'KW' '2334';
+KW2335 : 'KW' '2335';
+KW2336 : 'KW' '2336';
+KW2337 : 'KW' '2337';
+KW2338 : 'KW' '2338';
+KW2339 : 'KW' '2339';
+KW2340 : 'KW' '2340';
+KW2341 : 'KW' '2341';
+KW2342 : 'KW' '2342';
+KW2343 : 'KW' '2343';
+KW2344 : 'KW' '2344';
+KW2345 : 'KW' '2345';
+KW2346 : 'KW' '2346';
+KW2347 : 'KW' '2347';
+KW2348 : 'KW' '2348';
+KW2349 : 'KW' '2349';
+KW2350 : 'KW' '2350';
+KW2351 : 'KW' '2351';
+KW2352 : 'KW' '2352';
+KW2353 : 'KW' '2353';
+KW2354 : 'KW' '2354';
+KW2355 : 'KW' '2355';
+KW2356 : 'KW' '2356';
+KW2357 : 'KW' '2357';
+KW2358 : 'KW' '2358';
+KW2359 : 'KW' '2359';
+KW2360 : 'KW' '2360';
+KW2361 : 'KW' '2361';
+KW2362 : 'KW' '2362';
+KW2363 : 'KW' '2363';
+KW2364 : 'KW' '2364';
+KW2365 : 'KW' '2365';
+KW2366 : 'KW' '2366';
+KW2367 : 'KW' '2367';
+KW2368 : 'KW' '2368';
+KW2369 : 'KW' '2369';
+KW2370 : 'KW' '2370';
+KW2371 : 'KW' '2371';
+KW2372 : 'KW' '2372';
+KW2373 : 'KW' '2373';
+KW2374 : 'KW' '2374';
+KW2375 : 'KW' '2375';
+KW2376 : 'KW' '2376';
+KW2377 : 'KW' '2377';
+KW2378 : 'KW' '2378';
+KW2379 : 'KW' '2379';
+KW2380 : 'KW' '2380';
+KW2381 : 'KW' '2381';
+KW2382 : 'KW' '2382';
+KW2383 : 'KW' '2383';
+KW2384 : 'KW' '2384';
+KW2385 : 'KW' '2385';
+KW2386 : 'KW' '2386';
+KW2387 : 'KW' '2387';
+KW2388 : 'KW' '2388';
+KW2389 : 'KW' '2389';
+KW2390 : 'KW' '2390';
+KW2391 : 'KW' '2391';
+KW2392 : 'KW' '2392';
+KW2393 : 'KW' '2393';
+KW2394 : 'KW' '2394';
+KW2395 : 'KW' '2395';
+KW2396 : 'KW' '2396';
+KW2397 : 'KW' '2397';
+KW2398 : 'KW' '2398';
+KW2399 : 'KW' '2399';
+KW2400 : 'KW' '2400';
+KW2401 : 'KW' '2401';
+KW2402 : 'KW' '2402';
+KW2403 : 'KW' '2403';
+KW2404 : 'KW' '2404';
+KW2405 : 'KW' '2405';
+KW2406 : 'KW' '2406';
+KW2407 : 'KW' '2407';
+KW2408 : 'KW' '2408';
+KW2409 : 'KW' '2409';
+KW2410 : 'KW' '2410';
+KW2411 : 'KW' '2411';
+KW2412 : 'KW' '2412';
+KW2413 : 'KW' '2413';
+KW2414 : 'KW' '2414';
+KW2415 : 'KW' '2415';
+KW2416 : 'KW' '2416';
+KW2417 : 'KW' '2417';
+KW2418 : 'KW' '2418';
+KW2419 : 'KW' '2419';
+KW2420 : 'KW' '2420';
+KW2421 : 'KW' '2421';
+KW2422 : 'KW' '2422';
+KW2423 : 'KW' '2423';
+KW2424 : 'KW' '2424';
+KW2425 : 'KW' '2425';
+KW2426 : 'KW' '2426';
+KW2427 : 'KW' '2427';
+KW2428 : 'KW' '2428';
+KW2429 : 'KW' '2429';
+KW2430 : 'KW' '2430';
+KW2431 : 'KW' '2431';
+KW2432 : 'KW' '2432';
+KW2433 : 'KW' '2433';
+KW2434 : 'KW' '2434';
+KW2435 : 'KW' '2435';
+KW2436 : 'KW' '2436';
+KW2437 : 'KW' '2437';
+KW2438 : 'KW' '2438';
+KW2439 : 'KW' '2439';
+KW2440 : 'KW' '2440';
+KW2441 : 'KW' '2441';
+KW2442 : 'KW' '2442';
+KW2443 : 'KW' '2443';
+KW2444 : 'KW' '2444';
+KW2445 : 'KW' '2445';
+KW2446 : 'KW' '2446';
+KW2447 : 'KW' '2447';
+KW2448 : 'KW' '2448';
+KW2449 : 'KW' '2449';
+KW2450 : 'KW' '2450';
+KW2451 : 'KW' '2451';
+KW2452 : 'KW' '2452';
+KW2453 : 'KW' '2453';
+KW2454 : 'KW' '2454';
+KW2455 : 'KW' '2455';
+KW2456 : 'KW' '2456';
+KW2457 : 'KW' '2457';
+KW2458 : 'KW' '2458';
+KW2459 : 'KW' '2459';
+KW2460 : 'KW' '2460';
+KW2461 : 'KW' '2461';
+KW2462 : 'KW' '2462';
+KW2463 : 'KW' '2463';
+KW2464 : 'KW' '2464';
+KW2465 : 'KW' '2465';
+KW2466 : 'KW' '2466';
+KW2467 : 'KW' '2467';
+KW2468 : 'KW' '2468';
+KW2469 : 'KW' '2469';
+KW2470 : 'KW' '2470';
+KW2471 : 'KW' '2471';
+KW2472 : 'KW' '2472';
+KW2473 : 'KW' '2473';
+KW2474 : 'KW' '2474';
+KW2475 : 'KW' '2475';
+KW2476 : 'KW' '2476';
+KW2477 : 'KW' '2477';
+KW2478 : 'KW' '2478';
+KW2479 : 'KW' '2479';
+KW2480 : 'KW' '2480';
+KW2481 : 'KW' '2481';
+KW2482 : 'KW' '2482';
+KW2483 : 'KW' '2483';
+KW2484 : 'KW' '2484';
+KW2485 : 'KW' '2485';
+KW2486 : 'KW' '2486';
+KW2487 : 'KW' '2487';
+KW2488 : 'KW' '2488';
+KW2489 : 'KW' '2489';
+KW2490 : 'KW' '2490';
+KW2491 : 'KW' '2491';
+KW2492 : 'KW' '2492';
+KW2493 : 'KW' '2493';
+KW2494 : 'KW' '2494';
+KW2495 : 'KW' '2495';
+KW2496 : 'KW' '2496';
+KW2497 : 'KW' '2497';
+KW2498 : 'KW' '2498';
+KW2499 : 'KW' '2499';
+KW2500 : 'KW' '2500';
+KW2501 : 'KW' '2501';
+KW2502 : 'KW' '2502';
+KW2503 : 'KW' '2503';
+KW2504 : 'KW' '2504';
+KW2505 : 'KW' '2505';
+KW2506 : 'KW' '2506';
+KW2507 : 'KW' '2507';
+KW2508 : 'KW' '2508';
+KW2509 : 'KW' '2509';
+KW2510 : 'KW' '2510';
+KW2511 : 'KW' '2511';
+KW2512 : 'KW' '2512';
+KW2513 : 'KW' '2513';
+KW2514 : 'KW' '2514';
+KW2515 : 'KW' '2515';
+KW2516 : 'KW' '2516';
+KW2517 : 'KW' '2517';
+KW2518 : 'KW' '2518';
+KW2519 : 'KW' '2519';
+KW2520 : 'KW' '2520';
+KW2521 : 'KW' '2521';
+KW2522 : 'KW' '2522';
+KW2523 : 'KW' '2523';
+KW2524 : 'KW' '2524';
+KW2525 : 'KW' '2525';
+KW2526 : 'KW' '2526';
+KW2527 : 'KW' '2527';
+KW2528 : 'KW' '2528';
+KW2529 : 'KW' '2529';
+KW2530 : 'KW' '2530';
+KW2531 : 'KW' '2531';
+KW2532 : 'KW' '2532';
+KW2533 : 'KW' '2533';
+KW2534 : 'KW' '2534';
+KW2535 : 'KW' '2535';
+KW2536 : 'KW' '2536';
+KW2537 : 'KW' '2537';
+KW2538 : 'KW' '2538';
+KW2539 : 'KW' '2539';
+KW2540 : 'KW' '2540';
+KW2541 : 'KW' '2541';
+KW2542 : 'KW' '2542';
+KW2543 : 'KW' '2543';
+KW2544 : 'KW' '2544';
+KW2545 : 'KW' '2545';
+KW2546 : 'KW' '2546';
+KW2547 : 'KW' '2547';
+KW2548 : 'KW' '2548';
+KW2549 : 'KW' '2549';
+KW2550 : 'KW' '2550';
+KW2551 : 'KW' '2551';
+KW2552 : 'KW' '2552';
+KW2553 : 'KW' '2553';
+KW2554 : 'KW' '2554';
+KW2555 : 'KW' '2555';
+KW2556 : 'KW' '2556';
+KW2557 : 'KW' '2557';
+KW2558 : 'KW' '2558';
+KW2559 : 'KW' '2559';
+KW2560 : 'KW' '2560';
+KW2561 : 'KW' '2561';
+KW2562 : 'KW' '2562';
+KW2563 : 'KW' '2563';
+KW2564 : 'KW' '2564';
+KW2565 : 'KW' '2565';
+KW2566 : 'KW' '2566';
+KW2567 : 'KW' '2567';
+KW2568 : 'KW' '2568';
+KW2569 : 'KW' '2569';
+KW2570 : 'KW' '2570';
+KW2571 : 'KW' '2571';
+KW2572 : 'KW' '2572';
+KW2573 : 'KW' '2573';
+KW2574 : 'KW' '2574';
+KW2575 : 'KW' '2575';
+KW2576 : 'KW' '2576';
+KW2577 : 'KW' '2577';
+KW2578 : 'KW' '2578';
+KW2579 : 'KW' '2579';
+KW2580 : 'KW' '2580';
+KW2581 : 'KW' '2581';
+KW2582 : 'KW' '2582';
+KW2583 : 'KW' '2583';
+KW2584 : 'KW' '2584';
+KW2585 : 'KW' '2585';
+KW2586 : 'KW' '2586';
+KW2587 : 'KW' '2587';
+KW2588 : 'KW' '2588';
+KW2589 : 'KW' '2589';
+KW2590 : 'KW' '2590';
+KW2591 : 'KW' '2591';
+KW2592 : 'KW' '2592';
+KW2593 : 'KW' '2593';
+KW2594 : 'KW' '2594';
+KW2595 : 'KW' '2595';
+KW2596 : 'KW' '2596';
+KW2597 : 'KW' '2597';
+KW2598 : 'KW' '2598';
+KW2599 : 'KW' '2599';
+KW2600 : 'KW' '2600';
+KW2601 : 'KW' '2601';
+KW2602 : 'KW' '2602';
+KW2603 : 'KW' '2603';
+KW2604 : 'KW' '2604';
+KW2605 : 'KW' '2605';
+KW2606 : 'KW' '2606';
+KW2607 : 'KW' '2607';
+KW2608 : 'KW' '2608';
+KW2609 : 'KW' '2609';
+KW2610 : 'KW' '2610';
+KW2611 : 'KW' '2611';
+KW2612 : 'KW' '2612';
+KW2613 : 'KW' '2613';
+KW2614 : 'KW' '2614';
+KW2615 : 'KW' '2615';
+KW2616 : 'KW' '2616';
+KW2617 : 'KW' '2617';
+KW2618 : 'KW' '2618';
+KW2619 : 'KW' '2619';
+KW2620 : 'KW' '2620';
+KW2621 : 'KW' '2621';
+KW2622 : 'KW' '2622';
+KW2623 : 'KW' '2623';
+KW2624 : 'KW' '2624';
+KW2625 : 'KW' '2625';
+KW2626 : 'KW' '2626';
+KW2627 : 'KW' '2627';
+KW2628 : 'KW' '2628';
+KW2629 : 'KW' '2629';
+KW2630 : 'KW' '2630';
+KW2631 : 'KW' '2631';
+KW2632 : 'KW' '2632';
+KW2633 : 'KW' '2633';
+KW2634 : 'KW' '2634';
+KW2635 : 'KW' '2635';
+KW2636 : 'KW' '2636';
+KW2637 : 'KW' '2637';
+KW2638 : 'KW' '2638';
+KW2639 : 'KW' '2639';
+KW2640 : 'KW' '2640';
+KW2641 : 'KW' '2641';
+KW2642 : 'KW' '2642';
+KW2643 : 'KW' '2643';
+KW2644 : 'KW' '2644';
+KW2645 : 'KW' '2645';
+KW2646 : 'KW' '2646';
+KW2647 : 'KW' '2647';
+KW2648 : 'KW' '2648';
+KW2649 : 'KW' '2649';
+KW2650 : 'KW' '2650';
+KW2651 : 'KW' '2651';
+KW2652 : 'KW' '2652';
+KW2653 : 'KW' '2653';
+KW2654 : 'KW' '2654';
+KW2655 : 'KW' '2655';
+KW2656 : 'KW' '2656';
+KW2657 : 'KW' '2657';
+KW2658 : 'KW' '2658';
+KW2659 : 'KW' '2659';
+KW2660 : 'KW' '2660';
+KW2661 : 'KW' '2661';
+KW2662 : 'KW' '2662';
+KW2663 : 'KW' '2663';
+KW2664 : 'KW' '2664';
+KW2665 : 'KW' '2665';
+KW2666 : 'KW' '2666';
+KW2667 : 'KW' '2667';
+KW2668 : 'KW' '2668';
+KW2669 : 'KW' '2669';
+KW2670 : 'KW' '2670';
+KW2671 : 'KW' '2671';
+KW2672 : 'KW' '2672';
+KW2673 : 'KW' '2673';
+KW2674 : 'KW' '2674';
+KW2675 : 'KW' '2675';
+KW2676 : 'KW' '2676';
+KW2677 : 'KW' '2677';
+KW2678 : 'KW' '2678';
+KW2679 : 'KW' '2679';
+KW2680 : 'KW' '2680';
+KW2681 : 'KW' '2681';
+KW2682 : 'KW' '2682';
+KW2683 : 'KW' '2683';
+KW2684 : 'KW' '2684';
+KW2685 : 'KW' '2685';
+KW2686 : 'KW' '2686';
+KW2687 : 'KW' '2687';
+KW2688 : 'KW' '2688';
+KW2689 : 'KW' '2689';
+KW2690 : 'KW' '2690';
+KW2691 : 'KW' '2691';
+KW2692 : 'KW' '2692';
+KW2693 : 'KW' '2693';
+KW2694 : 'KW' '2694';
+KW2695 : 'KW' '2695';
+KW2696 : 'KW' '2696';
+KW2697 : 'KW' '2697';
+KW2698 : 'KW' '2698';
+KW2699 : 'KW' '2699';
+KW2700 : 'KW' '2700';
+KW2701 : 'KW' '2701';
+KW2702 : 'KW' '2702';
+KW2703 : 'KW' '2703';
+KW2704 : 'KW' '2704';
+KW2705 : 'KW' '2705';
+KW2706 : 'KW' '2706';
+KW2707 : 'KW' '2707';
+KW2708 : 'KW' '2708';
+KW2709 : 'KW' '2709';
+KW2710 : 'KW' '2710';
+KW2711 : 'KW' '2711';
+KW2712 : 'KW' '2712';
+KW2713 : 'KW' '2713';
+KW2714 : 'KW' '2714';
+KW2715 : 'KW' '2715';
+KW2716 : 'KW' '2716';
+KW2717 : 'KW' '2717';
+KW2718 : 'KW' '2718';
+KW2719 : 'KW' '2719';
+KW2720 : 'KW' '2720';
+KW2721 : 'KW' '2721';
+KW2722 : 'KW' '2722';
+KW2723 : 'KW' '2723';
+KW2724 : 'KW' '2724';
+KW2725 : 'KW' '2725';
+KW2726 : 'KW' '2726';
+KW2727 : 'KW' '2727';
+KW2728 : 'KW' '2728';
+KW2729 : 'KW' '2729';
+KW2730 : 'KW' '2730';
+KW2731 : 'KW' '2731';
+KW2732 : 'KW' '2732';
+KW2733 : 'KW' '2733';
+KW2734 : 'KW' '2734';
+KW2735 : 'KW' '2735';
+KW2736 : 'KW' '2736';
+KW2737 : 'KW' '2737';
+KW2738 : 'KW' '2738';
+KW2739 : 'KW' '2739';
+KW2740 : 'KW' '2740';
+KW2741 : 'KW' '2741';
+KW2742 : 'KW' '2742';
+KW2743 : 'KW' '2743';
+KW2744 : 'KW' '2744';
+KW2745 : 'KW' '2745';
+KW2746 : 'KW' '2746';
+KW2747 : 'KW' '2747';
+KW2748 : 'KW' '2748';
+KW2749 : 'KW' '2749';
+KW2750 : 'KW' '2750';
+KW2751 : 'KW' '2751';
+KW2752 : 'KW' '2752';
+KW2753 : 'KW' '2753';
+KW2754 : 'KW' '2754';
+KW2755 : 'KW' '2755';
+KW2756 : 'KW' '2756';
+KW2757 : 'KW' '2757';
+KW2758 : 'KW' '2758';
+KW2759 : 'KW' '2759';
+KW2760 : 'KW' '2760';
+KW2761 : 'KW' '2761';
+KW2762 : 'KW' '2762';
+KW2763 : 'KW' '2763';
+KW2764 : 'KW' '2764';
+KW2765 : 'KW' '2765';
+KW2766 : 'KW' '2766';
+KW2767 : 'KW' '2767';
+KW2768 : 'KW' '2768';
+KW2769 : 'KW' '2769';
+KW2770 : 'KW' '2770';
+KW2771 : 'KW' '2771';
+KW2772 : 'KW' '2772';
+KW2773 : 'KW' '2773';
+KW2774 : 'KW' '2774';
+KW2775 : 'KW' '2775';
+KW2776 : 'KW' '2776';
+KW2777 : 'KW' '2777';
+KW2778 : 'KW' '2778';
+KW2779 : 'KW' '2779';
+KW2780 : 'KW' '2780';
+KW2781 : 'KW' '2781';
+KW2782 : 'KW' '2782';
+KW2783 : 'KW' '2783';
+KW2784 : 'KW' '2784';
+KW2785 : 'KW' '2785';
+KW2786 : 'KW' '2786';
+KW2787 : 'KW' '2787';
+KW2788 : 'KW' '2788';
+KW2789 : 'KW' '2789';
+KW2790 : 'KW' '2790';
+KW2791 : 'KW' '2791';
+KW2792 : 'KW' '2792';
+KW2793 : 'KW' '2793';
+KW2794 : 'KW' '2794';
+KW2795 : 'KW' '2795';
+KW2796 : 'KW' '2796';
+KW2797 : 'KW' '2797';
+KW2798 : 'KW' '2798';
+KW2799 : 'KW' '2799';
+KW2800 : 'KW' '2800';
+KW2801 : 'KW' '2801';
+KW2802 : 'KW' '2802';
+KW2803 : 'KW' '2803';
+KW2804 : 'KW' '2804';
+KW2805 : 'KW' '2805';
+KW2806 : 'KW' '2806';
+KW2807 : 'KW' '2807';
+KW2808 : 'KW' '2808';
+KW2809 : 'KW' '2809';
+KW2810 : 'KW' '2810';
+KW2811 : 'KW' '2811';
+KW2812 : 'KW' '2812';
+KW2813 : 'KW' '2813';
+KW2814 : 'KW' '2814';
+KW2815 : 'KW' '2815';
+KW2816 : 'KW' '2816';
+KW2817 : 'KW' '2817';
+KW2818 : 'KW' '2818';
+KW2819 : 'KW' '2819';
+KW2820 : 'KW' '2820';
+KW2821 : 'KW' '2821';
+KW2822 : 'KW' '2822';
+KW2823 : 'KW' '2823';
+KW2824 : 'KW' '2824';
+KW2825 : 'KW' '2825';
+KW2826 : 'KW' '2826';
+KW2827 : 'KW' '2827';
+KW2828 : 'KW' '2828';
+KW2829 : 'KW' '2829';
+KW2830 : 'KW' '2830';
+KW2831 : 'KW' '2831';
+KW2832 : 'KW' '2832';
+KW2833 : 'KW' '2833';
+KW2834 : 'KW' '2834';
+KW2835 : 'KW' '2835';
+KW2836 : 'KW' '2836';
+KW2837 : 'KW' '2837';
+KW2838 : 'KW' '2838';
+KW2839 : 'KW' '2839';
+KW2840 : 'KW' '2840';
+KW2841 : 'KW' '2841';
+KW2842 : 'KW' '2842';
+KW2843 : 'KW' '2843';
+KW2844 : 'KW' '2844';
+KW2845 : 'KW' '2845';
+KW2846 : 'KW' '2846';
+KW2847 : 'KW' '2847';
+KW2848 : 'KW' '2848';
+KW2849 : 'KW' '2849';
+KW2850 : 'KW' '2850';
+KW2851 : 'KW' '2851';
+KW2852 : 'KW' '2852';
+KW2853 : 'KW' '2853';
+KW2854 : 'KW' '2854';
+KW2855 : 'KW' '2855';
+KW2856 : 'KW' '2856';
+KW2857 : 'KW' '2857';
+KW2858 : 'KW' '2858';
+KW2859 : 'KW' '2859';
+KW2860 : 'KW' '2860';
+KW2861 : 'KW' '2861';
+KW2862 : 'KW' '2862';
+KW2863 : 'KW' '2863';
+KW2864 : 'KW' '2864';
+KW2865 : 'KW' '2865';
+KW2866 : 'KW' '2866';
+KW2867 : 'KW' '2867';
+KW2868 : 'KW' '2868';
+KW2869 : 'KW' '2869';
+KW2870 : 'KW' '2870';
+KW2871 : 'KW' '2871';
+KW2872 : 'KW' '2872';
+KW2873 : 'KW' '2873';
+KW2874 : 'KW' '2874';
+KW2875 : 'KW' '2875';
+KW2876 : 'KW' '2876';
+KW2877 : 'KW' '2877';
+KW2878 : 'KW' '2878';
+KW2879 : 'KW' '2879';
+KW2880 : 'KW' '2880';
+KW2881 : 'KW' '2881';
+KW2882 : 'KW' '2882';
+KW2883 : 'KW' '2883';
+KW2884 : 'KW' '2884';
+KW2885 : 'KW' '2885';
+KW2886 : 'KW' '2886';
+KW2887 : 'KW' '2887';
+KW2888 : 'KW' '2888';
+KW2889 : 'KW' '2889';
+KW2890 : 'KW' '2890';
+KW2891 : 'KW' '2891';
+KW2892 : 'KW' '2892';
+KW2893 : 'KW' '2893';
+KW2894 : 'KW' '2894';
+KW2895 : 'KW' '2895';
+KW2896 : 'KW' '2896';
+KW2897 : 'KW' '2897';
+KW2898 : 'KW' '2898';
+KW2899 : 'KW' '2899';
+KW2900 : 'KW' '2900';
+KW2901 : 'KW' '2901';
+KW2902 : 'KW' '2902';
+KW2903 : 'KW' '2903';
+KW2904 : 'KW' '2904';
+KW2905 : 'KW' '2905';
+KW2906 : 'KW' '2906';
+KW2907 : 'KW' '2907';
+KW2908 : 'KW' '2908';
+KW2909 : 'KW' '2909';
+KW2910 : 'KW' '2910';
+KW2911 : 'KW' '2911';
+KW2912 : 'KW' '2912';
+KW2913 : 'KW' '2913';
+KW2914 : 'KW' '2914';
+KW2915 : 'KW' '2915';
+KW2916 : 'KW' '2916';
+KW2917 : 'KW' '2917';
+KW2918 : 'KW' '2918';
+KW2919 : 'KW' '2919';
+KW2920 : 'KW' '2920';
+KW2921 : 'KW' '2921';
+KW2922 : 'KW' '2922';
+KW2923 : 'KW' '2923';
+KW2924 : 'KW' '2924';
+KW2925 : 'KW' '2925';
+KW2926 : 'KW' '2926';
+KW2927 : 'KW' '2927';
+KW2928 : 'KW' '2928';
+KW2929 : 'KW' '2929';
+KW2930 : 'KW' '2930';
+KW2931 : 'KW' '2931';
+KW2932 : 'KW' '2932';
+KW2933 : 'KW' '2933';
+KW2934 : 'KW' '2934';
+KW2935 : 'KW' '2935';
+KW2936 : 'KW' '2936';
+KW2937 : 'KW' '2937';
+KW2938 : 'KW' '2938';
+KW2939 : 'KW' '2939';
+KW2940 : 'KW' '2940';
+KW2941 : 'KW' '2941';
+KW2942 : 'KW' '2942';
+KW2943 : 'KW' '2943';
+KW2944 : 'KW' '2944';
+KW2945 : 'KW' '2945';
+KW2946 : 'KW' '2946';
+KW2947 : 'KW' '2947';
+KW2948 : 'KW' '2948';
+KW2949 : 'KW' '2949';
+KW2950 : 'KW' '2950';
+KW2951 : 'KW' '2951';
+KW2952 : 'KW' '2952';
+KW2953 : 'KW' '2953';
+KW2954 : 'KW' '2954';
+KW2955 : 'KW' '2955';
+KW2956 : 'KW' '2956';
+KW2957 : 'KW' '2957';
+KW2958 : 'KW' '2958';
+KW2959 : 'KW' '2959';
+KW2960 : 'KW' '2960';
+KW2961 : 'KW' '2961';
+KW2962 : 'KW' '2962';
+KW2963 : 'KW' '2963';
+KW2964 : 'KW' '2964';
+KW2965 : 'KW' '2965';
+KW2966 : 'KW' '2966';
+KW2967 : 'KW' '2967';
+KW2968 : 'KW' '2968';
+KW2969 : 'KW' '2969';
+KW2970 : 'KW' '2970';
+KW2971 : 'KW' '2971';
+KW2972 : 'KW' '2972';
+KW2973 : 'KW' '2973';
+KW2974 : 'KW' '2974';
+KW2975 : 'KW' '2975';
+KW2976 : 'KW' '2976';
+KW2977 : 'KW' '2977';
+KW2978 : 'KW' '2978';
+KW2979 : 'KW' '2979';
+KW2980 : 'KW' '2980';
+KW2981 : 'KW' '2981';
+KW2982 : 'KW' '2982';
+KW2983 : 'KW' '2983';
+KW2984 : 'KW' '2984';
+KW2985 : 'KW' '2985';
+KW2986 : 'KW' '2986';
+KW2987 : 'KW' '2987';
+KW2988 : 'KW' '2988';
+KW2989 : 'KW' '2989';
+KW2990 : 'KW' '2990';
+KW2991 : 'KW' '2991';
+KW2992 : 'KW' '2992';
+KW2993 : 'KW' '2993';
+KW2994 : 'KW' '2994';
+KW2995 : 'KW' '2995';
+KW2996 : 'KW' '2996';
+KW2997 : 'KW' '2997';
+KW2998 : 'KW' '2998';
+KW2999 : 'KW' '2999';
+KW3000 : 'KW' '3000';
+KW3001 : 'KW' '3001';
+KW3002 : 'KW' '3002';
+KW3003 : 'KW' '3003';
+KW3004 : 'KW' '3004';
+KW3005 : 'KW' '3005';
+KW3006 : 'KW' '3006';
+KW3007 : 'KW' '3007';
+KW3008 : 'KW' '3008';
+KW3009 : 'KW' '3009';
+KW3010 : 'KW' '3010';
+KW3011 : 'KW' '3011';
+KW3012 : 'KW' '3012';
+KW3013 : 'KW' '3013';
+KW3014 : 'KW' '3014';
+KW3015 : 'KW' '3015';
+KW3016 : 'KW' '3016';
+KW3017 : 'KW' '3017';
+KW3018 : 'KW' '3018';
+KW3019 : 'KW' '3019';
+KW3020 : 'KW' '3020';
+KW3021 : 'KW' '3021';
+KW3022 : 'KW' '3022';
+KW3023 : 'KW' '3023';
+KW3024 : 'KW' '3024';
+KW3025 : 'KW' '3025';
+KW3026 : 'KW' '3026';
+KW3027 : 'KW' '3027';
+KW3028 : 'KW' '3028';
+KW3029 : 'KW' '3029';
+KW3030 : 'KW' '3030';
+KW3031 : 'KW' '3031';
+KW3032 : 'KW' '3032';
+KW3033 : 'KW' '3033';
+KW3034 : 'KW' '3034';
+KW3035 : 'KW' '3035';
+KW3036 : 'KW' '3036';
+KW3037 : 'KW' '3037';
+KW3038 : 'KW' '3038';
+KW3039 : 'KW' '3039';
+KW3040 : 'KW' '3040';
+KW3041 : 'KW' '3041';
+KW3042 : 'KW' '3042';
+KW3043 : 'KW' '3043';
+KW3044 : 'KW' '3044';
+KW3045 : 'KW' '3045';
+KW3046 : 'KW' '3046';
+KW3047 : 'KW' '3047';
+KW3048 : 'KW' '3048';
+KW3049 : 'KW' '3049';
+KW3050 : 'KW' '3050';
+KW3051 : 'KW' '3051';
+KW3052 : 'KW' '3052';
+KW3053 : 'KW' '3053';
+KW3054 : 'KW' '3054';
+KW3055 : 'KW' '3055';
+KW3056 : 'KW' '3056';
+KW3057 : 'KW' '3057';
+KW3058 : 'KW' '3058';
+KW3059 : 'KW' '3059';
+KW3060 : 'KW' '3060';
+KW3061 : 'KW' '3061';
+KW3062 : 'KW' '3062';
+KW3063 : 'KW' '3063';
+KW3064 : 'KW' '3064';
+KW3065 : 'KW' '3065';
+KW3066 : 'KW' '3066';
+KW3067 : 'KW' '3067';
+KW3068 : 'KW' '3068';
+KW3069 : 'KW' '3069';
+KW3070 : 'KW' '3070';
+KW3071 : 'KW' '3071';
+KW3072 : 'KW' '3072';
+KW3073 : 'KW' '3073';
+KW3074 : 'KW' '3074';
+KW3075 : 'KW' '3075';
+KW3076 : 'KW' '3076';
+KW3077 : 'KW' '3077';
+KW3078 : 'KW' '3078';
+KW3079 : 'KW' '3079';
+KW3080 : 'KW' '3080';
+KW3081 : 'KW' '3081';
+KW3082 : 'KW' '3082';
+KW3083 : 'KW' '3083';
+KW3084 : 'KW' '3084';
+KW3085 : 'KW' '3085';
+KW3086 : 'KW' '3086';
+KW3087 : 'KW' '3087';
+KW3088 : 'KW' '3088';
+KW3089 : 'KW' '3089';
+KW3090 : 'KW' '3090';
+KW3091 : 'KW' '3091';
+KW3092 : 'KW' '3092';
+KW3093 : 'KW' '3093';
+KW3094 : 'KW' '3094';
+KW3095 : 'KW' '3095';
+KW3096 : 'KW' '3096';
+KW3097 : 'KW' '3097';
+KW3098 : 'KW' '3098';
+KW3099 : 'KW' '3099';
+KW3100 : 'KW' '3100';
+KW3101 : 'KW' '3101';
+KW3102 : 'KW' '3102';
+KW3103 : 'KW' '3103';
+KW3104 : 'KW' '3104';
+KW3105 : 'KW' '3105';
+KW3106 : 'KW' '3106';
+KW3107 : 'KW' '3107';
+KW3108 : 'KW' '3108';
+KW3109 : 'KW' '3109';
+KW3110 : 'KW' '3110';
+KW3111 : 'KW' '3111';
+KW3112 : 'KW' '3112';
+KW3113 : 'KW' '3113';
+KW3114 : 'KW' '3114';
+KW3115 : 'KW' '3115';
+KW3116 : 'KW' '3116';
+KW3117 : 'KW' '3117';
+KW3118 : 'KW' '3118';
+KW3119 : 'KW' '3119';
+KW3120 : 'KW' '3120';
+KW3121 : 'KW' '3121';
+KW3122 : 'KW' '3122';
+KW3123 : 'KW' '3123';
+KW3124 : 'KW' '3124';
+KW3125 : 'KW' '3125';
+KW3126 : 'KW' '3126';
+KW3127 : 'KW' '3127';
+KW3128 : 'KW' '3128';
+KW3129 : 'KW' '3129';
+KW3130 : 'KW' '3130';
+KW3131 : 'KW' '3131';
+KW3132 : 'KW' '3132';
+KW3133 : 'KW' '3133';
+KW3134 : 'KW' '3134';
+KW3135 : 'KW' '3135';
+KW3136 : 'KW' '3136';
+KW3137 : 'KW' '3137';
+KW3138 : 'KW' '3138';
+KW3139 : 'KW' '3139';
+KW3140 : 'KW' '3140';
+KW3141 : 'KW' '3141';
+KW3142 : 'KW' '3142';
+KW3143 : 'KW' '3143';
+KW3144 : 'KW' '3144';
+KW3145 : 'KW' '3145';
+KW3146 : 'KW' '3146';
+KW3147 : 'KW' '3147';
+KW3148 : 'KW' '3148';
+KW3149 : 'KW' '3149';
+KW3150 : 'KW' '3150';
+KW3151 : 'KW' '3151';
+KW3152 : 'KW' '3152';
+KW3153 : 'KW' '3153';
+KW3154 : 'KW' '3154';
+KW3155 : 'KW' '3155';
+KW3156 : 'KW' '3156';
+KW3157 : 'KW' '3157';
+KW3158 : 'KW' '3158';
+KW3159 : 'KW' '3159';
+KW3160 : 'KW' '3160';
+KW3161 : 'KW' '3161';
+KW3162 : 'KW' '3162';
+KW3163 : 'KW' '3163';
+KW3164 : 'KW' '3164';
+KW3165 : 'KW' '3165';
+KW3166 : 'KW' '3166';
+KW3167 : 'KW' '3167';
+KW3168 : 'KW' '3168';
+KW3169 : 'KW' '3169';
+KW3170 : 'KW' '3170';
+KW3171 : 'KW' '3171';
+KW3172 : 'KW' '3172';
+KW3173 : 'KW' '3173';
+KW3174 : 'KW' '3174';
+KW3175 : 'KW' '3175';
+KW3176 : 'KW' '3176';
+KW3177 : 'KW' '3177';
+KW3178 : 'KW' '3178';
+KW3179 : 'KW' '3179';
+KW3180 : 'KW' '3180';
+KW3181 : 'KW' '3181';
+KW3182 : 'KW' '3182';
+KW3183 : 'KW' '3183';
+KW3184 : 'KW' '3184';
+KW3185 : 'KW' '3185';
+KW3186 : 'KW' '3186';
+KW3187 : 'KW' '3187';
+KW3188 : 'KW' '3188';
+KW3189 : 'KW' '3189';
+KW3190 : 'KW' '3190';
+KW3191 : 'KW' '3191';
+KW3192 : 'KW' '3192';
+KW3193 : 'KW' '3193';
+KW3194 : 'KW' '3194';
+KW3195 : 'KW' '3195';
+KW3196 : 'KW' '3196';
+KW3197 : 'KW' '3197';
+KW3198 : 'KW' '3198';
+KW3199 : 'KW' '3199';
+KW3200 : 'KW' '3200';
+KW3201 : 'KW' '3201';
+KW3202 : 'KW' '3202';
+KW3203 : 'KW' '3203';
+KW3204 : 'KW' '3204';
+KW3205 : 'KW' '3205';
+KW3206 : 'KW' '3206';
+KW3207 : 'KW' '3207';
+KW3208 : 'KW' '3208';
+KW3209 : 'KW' '3209';
+KW3210 : 'KW' '3210';
+KW3211 : 'KW' '3211';
+KW3212 : 'KW' '3212';
+KW3213 : 'KW' '3213';
+KW3214 : 'KW' '3214';
+KW3215 : 'KW' '3215';
+KW3216 : 'KW' '3216';
+KW3217 : 'KW' '3217';
+KW3218 : 'KW' '3218';
+KW3219 : 'KW' '3219';
+KW3220 : 'KW' '3220';
+KW3221 : 'KW' '3221';
+KW3222 : 'KW' '3222';
+KW3223 : 'KW' '3223';
+KW3224 : 'KW' '3224';
+KW3225 : 'KW' '3225';
+KW3226 : 'KW' '3226';
+KW3227 : 'KW' '3227';
+KW3228 : 'KW' '3228';
+KW3229 : 'KW' '3229';
+KW3230 : 'KW' '3230';
+KW3231 : 'KW' '3231';
+KW3232 : 'KW' '3232';
+KW3233 : 'KW' '3233';
+KW3234 : 'KW' '3234';
+KW3235 : 'KW' '3235';
+KW3236 : 'KW' '3236';
+KW3237 : 'KW' '3237';
+KW3238 : 'KW' '3238';
+KW3239 : 'KW' '3239';
+KW3240 : 'KW' '3240';
+KW3241 : 'KW' '3241';
+KW3242 : 'KW' '3242';
+KW3243 : 'KW' '3243';
+KW3244 : 'KW' '3244';
+KW3245 : 'KW' '3245';
+KW3246 : 'KW' '3246';
+KW3247 : 'KW' '3247';
+KW3248 : 'KW' '3248';
+KW3249 : 'KW' '3249';
+KW3250 : 'KW' '3250';
+KW3251 : 'KW' '3251';
+KW3252 : 'KW' '3252';
+KW3253 : 'KW' '3253';
+KW3254 : 'KW' '3254';
+KW3255 : 'KW' '3255';
+KW3256 : 'KW' '3256';
+KW3257 : 'KW' '3257';
+KW3258 : 'KW' '3258';
+KW3259 : 'KW' '3259';
+KW3260 : 'KW' '3260';
+KW3261 : 'KW' '3261';
+KW3262 : 'KW' '3262';
+KW3263 : 'KW' '3263';
+KW3264 : 'KW' '3264';
+KW3265 : 'KW' '3265';
+KW3266 : 'KW' '3266';
+KW3267 : 'KW' '3267';
+KW3268 : 'KW' '3268';
+KW3269 : 'KW' '3269';
+KW3270 : 'KW' '3270';
+KW3271 : 'KW' '3271';
+KW3272 : 'KW' '3272';
+KW3273 : 'KW' '3273';
+KW3274 : 'KW' '3274';
+KW3275 : 'KW' '3275';
+KW3276 : 'KW' '3276';
+KW3277 : 'KW' '3277';
+KW3278 : 'KW' '3278';
+KW3279 : 'KW' '3279';
+KW3280 : 'KW' '3280';
+KW3281 : 'KW' '3281';
+KW3282 : 'KW' '3282';
+KW3283 : 'KW' '3283';
+KW3284 : 'KW' '3284';
+KW3285 : 'KW' '3285';
+KW3286 : 'KW' '3286';
+KW3287 : 'KW' '3287';
+KW3288 : 'KW' '3288';
+KW3289 : 'KW' '3289';
+KW3290 : 'KW' '3290';
+KW3291 : 'KW' '3291';
+KW3292 : 'KW' '3292';
+KW3293 : 'KW' '3293';
+KW3294 : 'KW' '3294';
+KW3295 : 'KW' '3295';
+KW3296 : 'KW' '3296';
+KW3297 : 'KW' '3297';
+KW3298 : 'KW' '3298';
+KW3299 : 'KW' '3299';
+KW3300 : 'KW' '3300';
+KW3301 : 'KW' '3301';
+KW3302 : 'KW' '3302';
+KW3303 : 'KW' '3303';
+KW3304 : 'KW' '3304';
+KW3305 : 'KW' '3305';
+KW3306 : 'KW' '3306';
+KW3307 : 'KW' '3307';
+KW3308 : 'KW' '3308';
+KW3309 : 'KW' '3309';
+KW3310 : 'KW' '3310';
+KW3311 : 'KW' '3311';
+KW3312 : 'KW' '3312';
+KW3313 : 'KW' '3313';
+KW3314 : 'KW' '3314';
+KW3315 : 'KW' '3315';
+KW3316 : 'KW' '3316';
+KW3317 : 'KW' '3317';
+KW3318 : 'KW' '3318';
+KW3319 : 'KW' '3319';
+KW3320 : 'KW' '3320';
+KW3321 : 'KW' '3321';
+KW3322 : 'KW' '3322';
+KW3323 : 'KW' '3323';
+KW3324 : 'KW' '3324';
+KW3325 : 'KW' '3325';
+KW3326 : 'KW' '3326';
+KW3327 : 'KW' '3327';
+KW3328 : 'KW' '3328';
+KW3329 : 'KW' '3329';
+KW3330 : 'KW' '3330';
+KW3331 : 'KW' '3331';
+KW3332 : 'KW' '3332';
+KW3333 : 'KW' '3333';
+KW3334 : 'KW' '3334';
+KW3335 : 'KW' '3335';
+KW3336 : 'KW' '3336';
+KW3337 : 'KW' '3337';
+KW3338 : 'KW' '3338';
+KW3339 : 'KW' '3339';
+KW3340 : 'KW' '3340';
+KW3341 : 'KW' '3341';
+KW3342 : 'KW' '3342';
+KW3343 : 'KW' '3343';
+KW3344 : 'KW' '3344';
+KW3345 : 'KW' '3345';
+KW3346 : 'KW' '3346';
+KW3347 : 'KW' '3347';
+KW3348 : 'KW' '3348';
+KW3349 : 'KW' '3349';
+KW3350 : 'KW' '3350';
+KW3351 : 'KW' '3351';
+KW3352 : 'KW' '3352';
+KW3353 : 'KW' '3353';
+KW3354 : 'KW' '3354';
+KW3355 : 'KW' '3355';
+KW3356 : 'KW' '3356';
+KW3357 : 'KW' '3357';
+KW3358 : 'KW' '3358';
+KW3359 : 'KW' '3359';
+KW3360 : 'KW' '3360';
+KW3361 : 'KW' '3361';
+KW3362 : 'KW' '3362';
+KW3363 : 'KW' '3363';
+KW3364 : 'KW' '3364';
+KW3365 : 'KW' '3365';
+KW3366 : 'KW' '3366';
+KW3367 : 'KW' '3367';
+KW3368 : 'KW' '3368';
+KW3369 : 'KW' '3369';
+KW3370 : 'KW' '3370';
+KW3371 : 'KW' '3371';
+KW3372 : 'KW' '3372';
+KW3373 : 'KW' '3373';
+KW3374 : 'KW' '3374';
+KW3375 : 'KW' '3375';
+KW3376 : 'KW' '3376';
+KW3377 : 'KW' '3377';
+KW3378 : 'KW' '3378';
+KW3379 : 'KW' '3379';
+KW3380 : 'KW' '3380';
+KW3381 : 'KW' '3381';
+KW3382 : 'KW' '3382';
+KW3383 : 'KW' '3383';
+KW3384 : 'KW' '3384';
+KW3385 : 'KW' '3385';
+KW3386 : 'KW' '3386';
+KW3387 : 'KW' '3387';
+KW3388 : 'KW' '3388';
+KW3389 : 'KW' '3389';
+KW3390 : 'KW' '3390';
+KW3391 : 'KW' '3391';
+KW3392 : 'KW' '3392';
+KW3393 : 'KW' '3393';
+KW3394 : 'KW' '3394';
+KW3395 : 'KW' '3395';
+KW3396 : 'KW' '3396';
+KW3397 : 'KW' '3397';
+KW3398 : 'KW' '3398';
+KW3399 : 'KW' '3399';
+KW3400 : 'KW' '3400';
+KW3401 : 'KW' '3401';
+KW3402 : 'KW' '3402';
+KW3403 : 'KW' '3403';
+KW3404 : 'KW' '3404';
+KW3405 : 'KW' '3405';
+KW3406 : 'KW' '3406';
+KW3407 : 'KW' '3407';
+KW3408 : 'KW' '3408';
+KW3409 : 'KW' '3409';
+KW3410 : 'KW' '3410';
+KW3411 : 'KW' '3411';
+KW3412 : 'KW' '3412';
+KW3413 : 'KW' '3413';
+KW3414 : 'KW' '3414';
+KW3415 : 'KW' '3415';
+KW3416 : 'KW' '3416';
+KW3417 : 'KW' '3417';
+KW3418 : 'KW' '3418';
+KW3419 : 'KW' '3419';
+KW3420 : 'KW' '3420';
+KW3421 : 'KW' '3421';
+KW3422 : 'KW' '3422';
+KW3423 : 'KW' '3423';
+KW3424 : 'KW' '3424';
+KW3425 : 'KW' '3425';
+KW3426 : 'KW' '3426';
+KW3427 : 'KW' '3427';
+KW3428 : 'KW' '3428';
+KW3429 : 'KW' '3429';
+KW3430 : 'KW' '3430';
+KW3431 : 'KW' '3431';
+KW3432 : 'KW' '3432';
+KW3433 : 'KW' '3433';
+KW3434 : 'KW' '3434';
+KW3435 : 'KW' '3435';
+KW3436 : 'KW' '3436';
+KW3437 : 'KW' '3437';
+KW3438 : 'KW' '3438';
+KW3439 : 'KW' '3439';
+KW3440 : 'KW' '3440';
+KW3441 : 'KW' '3441';
+KW3442 : 'KW' '3442';
+KW3443 : 'KW' '3443';
+KW3444 : 'KW' '3444';
+KW3445 : 'KW' '3445';
+KW3446 : 'KW' '3446';
+KW3447 : 'KW' '3447';
+KW3448 : 'KW' '3448';
+KW3449 : 'KW' '3449';
+KW3450 : 'KW' '3450';
+KW3451 : 'KW' '3451';
+KW3452 : 'KW' '3452';
+KW3453 : 'KW' '3453';
+KW3454 : 'KW' '3454';
+KW3455 : 'KW' '3455';
+KW3456 : 'KW' '3456';
+KW3457 : 'KW' '3457';
+KW3458 : 'KW' '3458';
+KW3459 : 'KW' '3459';
+KW3460 : 'KW' '3460';
+KW3461 : 'KW' '3461';
+KW3462 : 'KW' '3462';
+KW3463 : 'KW' '3463';
+KW3464 : 'KW' '3464';
+KW3465 : 'KW' '3465';
+KW3466 : 'KW' '3466';
+KW3467 : 'KW' '3467';
+KW3468 : 'KW' '3468';
+KW3469 : 'KW' '3469';
+KW3470 : 'KW' '3470';
+KW3471 : 'KW' '3471';
+KW3472 : 'KW' '3472';
+KW3473 : 'KW' '3473';
+KW3474 : 'KW' '3474';
+KW3475 : 'KW' '3475';
+KW3476 : 'KW' '3476';
+KW3477 : 'KW' '3477';
+KW3478 : 'KW' '3478';
+KW3479 : 'KW' '3479';
+KW3480 : 'KW' '3480';
+KW3481 : 'KW' '3481';
+KW3482 : 'KW' '3482';
+KW3483 : 'KW' '3483';
+KW3484 : 'KW' '3484';
+KW3485 : 'KW' '3485';
+KW3486 : 'KW' '3486';
+KW3487 : 'KW' '3487';
+KW3488 : 'KW' '3488';
+KW3489 : 'KW' '3489';
+KW3490 : 'KW' '3490';
+KW3491 : 'KW' '3491';
+KW3492 : 'KW' '3492';
+KW3493 : 'KW' '3493';
+KW3494 : 'KW' '3494';
+KW3495 : 'KW' '3495';
+KW3496 : 'KW' '3496';
+KW3497 : 'KW' '3497';
+KW3498 : 'KW' '3498';
+KW3499 : 'KW' '3499';
+KW3500 : 'KW' '3500';
+KW3501 : 'KW' '3501';
+KW3502 : 'KW' '3502';
+KW3503 : 'KW' '3503';
+KW3504 : 'KW' '3504';
+KW3505 : 'KW' '3505';
+KW3506 : 'KW' '3506';
+KW3507 : 'KW' '3507';
+KW3508 : 'KW' '3508';
+KW3509 : 'KW' '3509';
+KW3510 : 'KW' '3510';
+KW3511 : 'KW' '3511';
+KW3512 : 'KW' '3512';
+KW3513 : 'KW' '3513';
+KW3514 : 'KW' '3514';
+KW3515 : 'KW' '3515';
+KW3516 : 'KW' '3516';
+KW3517 : 'KW' '3517';
+KW3518 : 'KW' '3518';
+KW3519 : 'KW' '3519';
+KW3520 : 'KW' '3520';
+KW3521 : 'KW' '3521';
+KW3522 : 'KW' '3522';
+KW3523 : 'KW' '3523';
+KW3524 : 'KW' '3524';
+KW3525 : 'KW' '3525';
+KW3526 : 'KW' '3526';
+KW3527 : 'KW' '3527';
+KW3528 : 'KW' '3528';
+KW3529 : 'KW' '3529';
+KW3530 : 'KW' '3530';
+KW3531 : 'KW' '3531';
+KW3532 : 'KW' '3532';
+KW3533 : 'KW' '3533';
+KW3534 : 'KW' '3534';
+KW3535 : 'KW' '3535';
+KW3536 : 'KW' '3536';
+KW3537 : 'KW' '3537';
+KW3538 : 'KW' '3538';
+KW3539 : 'KW' '3539';
+KW3540 : 'KW' '3540';
+KW3541 : 'KW' '3541';
+KW3542 : 'KW' '3542';
+KW3543 : 'KW' '3543';
+KW3544 : 'KW' '3544';
+KW3545 : 'KW' '3545';
+KW3546 : 'KW' '3546';
+KW3547 : 'KW' '3547';
+KW3548 : 'KW' '3548';
+KW3549 : 'KW' '3549';
+KW3550 : 'KW' '3550';
+KW3551 : 'KW' '3551';
+KW3552 : 'KW' '3552';
+KW3553 : 'KW' '3553';
+KW3554 : 'KW' '3554';
+KW3555 : 'KW' '3555';
+KW3556 : 'KW' '3556';
+KW3557 : 'KW' '3557';
+KW3558 : 'KW' '3558';
+KW3559 : 'KW' '3559';
+KW3560 : 'KW' '3560';
+KW3561 : 'KW' '3561';
+KW3562 : 'KW' '3562';
+KW3563 : 'KW' '3563';
+KW3564 : 'KW' '3564';
+KW3565 : 'KW' '3565';
+KW3566 : 'KW' '3566';
+KW3567 : 'KW' '3567';
+KW3568 : 'KW' '3568';
+KW3569 : 'KW' '3569';
+KW3570 : 'KW' '3570';
+KW3571 : 'KW' '3571';
+KW3572 : 'KW' '3572';
+KW3573 : 'KW' '3573';
+KW3574 : 'KW' '3574';
+KW3575 : 'KW' '3575';
+KW3576 : 'KW' '3576';
+KW3577 : 'KW' '3577';
+KW3578 : 'KW' '3578';
+KW3579 : 'KW' '3579';
+KW3580 : 'KW' '3580';
+KW3581 : 'KW' '3581';
+KW3582 : 'KW' '3582';
+KW3583 : 'KW' '3583';
+KW3584 : 'KW' '3584';
+KW3585 : 'KW' '3585';
+KW3586 : 'KW' '3586';
+KW3587 : 'KW' '3587';
+KW3588 : 'KW' '3588';
+KW3589 : 'KW' '3589';
+KW3590 : 'KW' '3590';
+KW3591 : 'KW' '3591';
+KW3592 : 'KW' '3592';
+KW3593 : 'KW' '3593';
+KW3594 : 'KW' '3594';
+KW3595 : 'KW' '3595';
+KW3596 : 'KW' '3596';
+KW3597 : 'KW' '3597';
+KW3598 : 'KW' '3598';
+KW3599 : 'KW' '3599';
+KW3600 : 'KW' '3600';
+KW3601 : 'KW' '3601';
+KW3602 : 'KW' '3602';
+KW3603 : 'KW' '3603';
+KW3604 : 'KW' '3604';
+KW3605 : 'KW' '3605';
+KW3606 : 'KW' '3606';
+KW3607 : 'KW' '3607';
+KW3608 : 'KW' '3608';
+KW3609 : 'KW' '3609';
+KW3610 : 'KW' '3610';
+KW3611 : 'KW' '3611';
+KW3612 : 'KW' '3612';
+KW3613 : 'KW' '3613';
+KW3614 : 'KW' '3614';
+KW3615 : 'KW' '3615';
+KW3616 : 'KW' '3616';
+KW3617 : 'KW' '3617';
+KW3618 : 'KW' '3618';
+KW3619 : 'KW' '3619';
+KW3620 : 'KW' '3620';
+KW3621 : 'KW' '3621';
+KW3622 : 'KW' '3622';
+KW3623 : 'KW' '3623';
+KW3624 : 'KW' '3624';
+KW3625 : 'KW' '3625';
+KW3626 : 'KW' '3626';
+KW3627 : 'KW' '3627';
+KW3628 : 'KW' '3628';
+KW3629 : 'KW' '3629';
+KW3630 : 'KW' '3630';
+KW3631 : 'KW' '3631';
+KW3632 : 'KW' '3632';
+KW3633 : 'KW' '3633';
+KW3634 : 'KW' '3634';
+KW3635 : 'KW' '3635';
+KW3636 : 'KW' '3636';
+KW3637 : 'KW' '3637';
+KW3638 : 'KW' '3638';
+KW3639 : 'KW' '3639';
+KW3640 : 'KW' '3640';
+KW3641 : 'KW' '3641';
+KW3642 : 'KW' '3642';
+KW3643 : 'KW' '3643';
+KW3644 : 'KW' '3644';
+KW3645 : 'KW' '3645';
+KW3646 : 'KW' '3646';
+KW3647 : 'KW' '3647';
+KW3648 : 'KW' '3648';
+KW3649 : 'KW' '3649';
+KW3650 : 'KW' '3650';
+KW3651 : 'KW' '3651';
+KW3652 : 'KW' '3652';
+KW3653 : 'KW' '3653';
+KW3654 : 'KW' '3654';
+KW3655 : 'KW' '3655';
+KW3656 : 'KW' '3656';
+KW3657 : 'KW' '3657';
+KW3658 : 'KW' '3658';
+KW3659 : 'KW' '3659';
+KW3660 : 'KW' '3660';
+KW3661 : 'KW' '3661';
+KW3662 : 'KW' '3662';
+KW3663 : 'KW' '3663';
+KW3664 : 'KW' '3664';
+KW3665 : 'KW' '3665';
+KW3666 : 'KW' '3666';
+KW3667 : 'KW' '3667';
+KW3668 : 'KW' '3668';
+KW3669 : 'KW' '3669';
+KW3670 : 'KW' '3670';
+KW3671 : 'KW' '3671';
+KW3672 : 'KW' '3672';
+KW3673 : 'KW' '3673';
+KW3674 : 'KW' '3674';
+KW3675 : 'KW' '3675';
+KW3676 : 'KW' '3676';
+KW3677 : 'KW' '3677';
+KW3678 : 'KW' '3678';
+KW3679 : 'KW' '3679';
+KW3680 : 'KW' '3680';
+KW3681 : 'KW' '3681';
+KW3682 : 'KW' '3682';
+KW3683 : 'KW' '3683';
+KW3684 : 'KW' '3684';
+KW3685 : 'KW' '3685';
+KW3686 : 'KW' '3686';
+KW3687 : 'KW' '3687';
+KW3688 : 'KW' '3688';
+KW3689 : 'KW' '3689';
+KW3690 : 'KW' '3690';
+KW3691 : 'KW' '3691';
+KW3692 : 'KW' '3692';
+KW3693 : 'KW' '3693';
+KW3694 : 'KW' '3694';
+KW3695 : 'KW' '3695';
+KW3696 : 'KW' '3696';
+KW3697 : 'KW' '3697';
+KW3698 : 'KW' '3698';
+KW3699 : 'KW' '3699';
+KW3700 : 'KW' '3700';
+KW3701 : 'KW' '3701';
+KW3702 : 'KW' '3702';
+KW3703 : 'KW' '3703';
+KW3704 : 'KW' '3704';
+KW3705 : 'KW' '3705';
+KW3706 : 'KW' '3706';
+KW3707 : 'KW' '3707';
+KW3708 : 'KW' '3708';
+KW3709 : 'KW' '3709';
+KW3710 : 'KW' '3710';
+KW3711 : 'KW' '3711';
+KW3712 : 'KW' '3712';
+KW3713 : 'KW' '3713';
+KW3714 : 'KW' '3714';
+KW3715 : 'KW' '3715';
+KW3716 : 'KW' '3716';
+KW3717 : 'KW' '3717';
+KW3718 : 'KW' '3718';
+KW3719 : 'KW' '3719';
+KW3720 : 'KW' '3720';
+KW3721 : 'KW' '3721';
+KW3722 : 'KW' '3722';
+KW3723 : 'KW' '3723';
+KW3724 : 'KW' '3724';
+KW3725 : 'KW' '3725';
+KW3726 : 'KW' '3726';
+KW3727 : 'KW' '3727';
+KW3728 : 'KW' '3728';
+KW3729 : 'KW' '3729';
+KW3730 : 'KW' '3730';
+KW3731 : 'KW' '3731';
+KW3732 : 'KW' '3732';
+KW3733 : 'KW' '3733';
+KW3734 : 'KW' '3734';
+KW3735 : 'KW' '3735';
+KW3736 : 'KW' '3736';
+KW3737 : 'KW' '3737';
+KW3738 : 'KW' '3738';
+KW3739 : 'KW' '3739';
+KW3740 : 'KW' '3740';
+KW3741 : 'KW' '3741';
+KW3742 : 'KW' '3742';
+KW3743 : 'KW' '3743';
+KW3744 : 'KW' '3744';
+KW3745 : 'KW' '3745';
+KW3746 : 'KW' '3746';
+KW3747 : 'KW' '3747';
+KW3748 : 'KW' '3748';
+KW3749 : 'KW' '3749';
+KW3750 : 'KW' '3750';
+KW3751 : 'KW' '3751';
+KW3752 : 'KW' '3752';
+KW3753 : 'KW' '3753';
+KW3754 : 'KW' '3754';
+KW3755 : 'KW' '3755';
+KW3756 : 'KW' '3756';
+KW3757 : 'KW' '3757';
+KW3758 : 'KW' '3758';
+KW3759 : 'KW' '3759';
+KW3760 : 'KW' '3760';
+KW3761 : 'KW' '3761';
+KW3762 : 'KW' '3762';
+KW3763 : 'KW' '3763';
+KW3764 : 'KW' '3764';
+KW3765 : 'KW' '3765';
+KW3766 : 'KW' '3766';
+KW3767 : 'KW' '3767';
+KW3768 : 'KW' '3768';
+KW3769 : 'KW' '3769';
+KW3770 : 'KW' '3770';
+KW3771 : 'KW' '3771';
+KW3772 : 'KW' '3772';
+KW3773 : 'KW' '3773';
+KW3774 : 'KW' '3774';
+KW3775 : 'KW' '3775';
+KW3776 : 'KW' '3776';
+KW3777 : 'KW' '3777';
+KW3778 : 'KW' '3778';
+KW3779 : 'KW' '3779';
+KW3780 : 'KW' '3780';
+KW3781 : 'KW' '3781';
+KW3782 : 'KW' '3782';
+KW3783 : 'KW' '3783';
+KW3784 : 'KW' '3784';
+KW3785 : 'KW' '3785';
+KW3786 : 'KW' '3786';
+KW3787 : 'KW' '3787';
+KW3788 : 'KW' '3788';
+KW3789 : 'KW' '3789';
+KW3790 : 'KW' '3790';
+KW3791 : 'KW' '3791';
+KW3792 : 'KW' '3792';
+KW3793 : 'KW' '3793';
+KW3794 : 'KW' '3794';
+KW3795 : 'KW' '3795';
+KW3796 : 'KW' '3796';
+KW3797 : 'KW' '3797';
+KW3798 : 'KW' '3798';
+KW3799 : 'KW' '3799';
+KW3800 : 'KW' '3800';
+KW3801 : 'KW' '3801';
+KW3802 : 'KW' '3802';
+KW3803 : 'KW' '3803';
+KW3804 : 'KW' '3804';
+KW3805 : 'KW' '3805';
+KW3806 : 'KW' '3806';
+KW3807 : 'KW' '3807';
+KW3808 : 'KW' '3808';
+KW3809 : 'KW' '3809';
+KW3810 : 'KW' '3810';
+KW3811 : 'KW' '3811';
+KW3812 : 'KW' '3812';
+KW3813 : 'KW' '3813';
+KW3814 : 'KW' '3814';
+KW3815 : 'KW' '3815';
+KW3816 : 'KW' '3816';
+KW3817 : 'KW' '3817';
+KW3818 : 'KW' '3818';
+KW3819 : 'KW' '3819';
+KW3820 : 'KW' '3820';
+KW3821 : 'KW' '3821';
+KW3822 : 'KW' '3822';
+KW3823 : 'KW' '3823';
+KW3824 : 'KW' '3824';
+KW3825 : 'KW' '3825';
+KW3826 : 'KW' '3826';
+KW3827 : 'KW' '3827';
+KW3828 : 'KW' '3828';
+KW3829 : 'KW' '3829';
+KW3830 : 'KW' '3830';
+KW3831 : 'KW' '3831';
+KW3832 : 'KW' '3832';
+KW3833 : 'KW' '3833';
+KW3834 : 'KW' '3834';
+KW3835 : 'KW' '3835';
+KW3836 : 'KW' '3836';
+KW3837 : 'KW' '3837';
+KW3838 : 'KW' '3838';
+KW3839 : 'KW' '3839';
+KW3840 : 'KW' '3840';
+KW3841 : 'KW' '3841';
+KW3842 : 'KW' '3842';
+KW3843 : 'KW' '3843';
+KW3844 : 'KW' '3844';
+KW3845 : 'KW' '3845';
+KW3846 : 'KW' '3846';
+KW3847 : 'KW' '3847';
+KW3848 : 'KW' '3848';
+KW3849 : 'KW' '3849';
+KW3850 : 'KW' '3850';
+KW3851 : 'KW' '3851';
+KW3852 : 'KW' '3852';
+KW3853 : 'KW' '3853';
+KW3854 : 'KW' '3854';
+KW3855 : 'KW' '3855';
+KW3856 : 'KW' '3856';
+KW3857 : 'KW' '3857';
+KW3858 : 'KW' '3858';
+KW3859 : 'KW' '3859';
+KW3860 : 'KW' '3860';
+KW3861 : 'KW' '3861';
+KW3862 : 'KW' '3862';
+KW3863 : 'KW' '3863';
+KW3864 : 'KW' '3864';
+KW3865 : 'KW' '3865';
+KW3866 : 'KW' '3866';
+KW3867 : 'KW' '3867';
+KW3868 : 'KW' '3868';
+KW3869 : 'KW' '3869';
+KW3870 : 'KW' '3870';
+KW3871 : 'KW' '3871';
+KW3872 : 'KW' '3872';
+KW3873 : 'KW' '3873';
+KW3874 : 'KW' '3874';
+KW3875 : 'KW' '3875';
+KW3876 : 'KW' '3876';
+KW3877 : 'KW' '3877';
+KW3878 : 'KW' '3878';
+KW3879 : 'KW' '3879';
+KW3880 : 'KW' '3880';
+KW3881 : 'KW' '3881';
+KW3882 : 'KW' '3882';
+KW3883 : 'KW' '3883';
+KW3884 : 'KW' '3884';
+KW3885 : 'KW' '3885';
+KW3886 : 'KW' '3886';
+KW3887 : 'KW' '3887';
+KW3888 : 'KW' '3888';
+KW3889 : 'KW' '3889';
+KW3890 : 'KW' '3890';
+KW3891 : 'KW' '3891';
+KW3892 : 'KW' '3892';
+KW3893 : 'KW' '3893';
+KW3894 : 'KW' '3894';
+KW3895 : 'KW' '3895';
+KW3896 : 'KW' '3896';
+KW3897 : 'KW' '3897';
+KW3898 : 'KW' '3898';
+KW3899 : 'KW' '3899';
+KW3900 : 'KW' '3900';
+KW3901 : 'KW' '3901';
+KW3902 : 'KW' '3902';
+KW3903 : 'KW' '3903';
+KW3904 : 'KW' '3904';
+KW3905 : 'KW' '3905';
+KW3906 : 'KW' '3906';
+KW3907 : 'KW' '3907';
+KW3908 : 'KW' '3908';
+KW3909 : 'KW' '3909';
+KW3910 : 'KW' '3910';
+KW3911 : 'KW' '3911';
+KW3912 : 'KW' '3912';
+KW3913 : 'KW' '3913';
+KW3914 : 'KW' '3914';
+KW3915 : 'KW' '3915';
+KW3916 : 'KW' '3916';
+KW3917 : 'KW' '3917';
+KW3918 : 'KW' '3918';
+KW3919 : 'KW' '3919';
+KW3920 : 'KW' '3920';
+KW3921 : 'KW' '3921';
+KW3922 : 'KW' '3922';
+KW3923 : 'KW' '3923';
+KW3924 : 'KW' '3924';
+KW3925 : 'KW' '3925';
+KW3926 : 'KW' '3926';
+KW3927 : 'KW' '3927';
+KW3928 : 'KW' '3928';
+KW3929 : 'KW' '3929';
+KW3930 : 'KW' '3930';
+KW3931 : 'KW' '3931';
+KW3932 : 'KW' '3932';
+KW3933 : 'KW' '3933';
+KW3934 : 'KW' '3934';
+KW3935 : 'KW' '3935';
+KW3936 : 'KW' '3936';
+KW3937 : 'KW' '3937';
+KW3938 : 'KW' '3938';
+KW3939 : 'KW' '3939';
+KW3940 : 'KW' '3940';
+KW3941 : 'KW' '3941';
+KW3942 : 'KW' '3942';
+KW3943 : 'KW' '3943';
+KW3944 : 'KW' '3944';
+KW3945 : 'KW' '3945';
+KW3946 : 'KW' '3946';
+KW3947 : 'KW' '3947';
+KW3948 : 'KW' '3948';
+KW3949 : 'KW' '3949';
+KW3950 : 'KW' '3950';
+KW3951 : 'KW' '3951';
+KW3952 : 'KW' '3952';
+KW3953 : 'KW' '3953';
+KW3954 : 'KW' '3954';
+KW3955 : 'KW' '3955';
+KW3956 : 'KW' '3956';
+KW3957 : 'KW' '3957';
+KW3958 : 'KW' '3958';
+KW3959 : 'KW' '3959';
+KW3960 : 'KW' '3960';
+KW3961 : 'KW' '3961';
+KW3962 : 'KW' '3962';
+KW3963 : 'KW' '3963';
+KW3964 : 'KW' '3964';
+KW3965 : 'KW' '3965';
+KW3966 : 'KW' '3966';
+KW3967 : 'KW' '3967';
+KW3968 : 'KW' '3968';
+KW3969 : 'KW' '3969';
+KW3970 : 'KW' '3970';
+KW3971 : 'KW' '3971';
+KW3972 : 'KW' '3972';
+KW3973 : 'KW' '3973';
+KW3974 : 'KW' '3974';
+KW3975 : 'KW' '3975';
+KW3976 : 'KW' '3976';
+KW3977 : 'KW' '3977';
+KW3978 : 'KW' '3978';
+KW3979 : 'KW' '3979';
+KW3980 : 'KW' '3980';
+KW3981 : 'KW' '3981';
+KW3982 : 'KW' '3982';
+KW3983 : 'KW' '3983';
+KW3984 : 'KW' '3984';
+KW3985 : 'KW' '3985';
+KW3986 : 'KW' '3986';
+KW3987 : 'KW' '3987';
+KW3988 : 'KW' '3988';
+KW3989 : 'KW' '3989';
+KW3990 : 'KW' '3990';
+KW3991 : 'KW' '3991';
+KW3992 : 'KW' '3992';
+KW3993 : 'KW' '3993';
+KW3994 : 'KW' '3994';
+KW3995 : 'KW' '3995';
+KW3996 : 'KW' '3996';
+KW3997 : 'KW' '3997';
+KW3998 : 'KW' '3998';
+KW3999 : 'KW' '3999';
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/NonGreedyClosure.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/NonGreedyClosure.stg
new file mode 100644
index 000000000..b1dd5c375
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/NonGreedyClosure.stg
@@ -0,0 +1,24 @@
+TestType() ::= "Lexer"
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+Input() ::= <<
+//blah
+//blah<\n>
+>>
+
+Output() ::= <<
+[@0,0:6='//blah\n',\<1>,1:0]
+[@1,7:13='//blah\n',\<1>,2:0]
+[@2,14:13='\<EOF>',\<-1>,3:0]<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+CMT : '//' .*? '\n' CMT*?;
+WS : (' '|'\t')+;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/NonGreedyConfigs.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/NonGreedyConfigs.stg
new file mode 100644
index 000000000..0c1b87eec
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/NonGreedyConfigs.stg
@@ -0,0 +1,26 @@
+TestType() ::= "Lexer"
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+Input() ::= <%
+ab
+%>
+
+Output() ::= <<
+a
+b
+[@0,0:0='a',\<1>,1:0]
+[@1,1:1='b',\<3>,1:1]
+[@2,2:1='\<EOF>',\<-1>,1:2]<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+I : .*? ('a' | 'ab') {<Text():writeln()>} ;
+WS : (' '|'\n') -> skip ;
+J : . {<Text():writeln()>};
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/NonGreedyOptional.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/NonGreedyOptional.stg
new file mode 100644
index 000000000..8f60f6e5d
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/NonGreedyOptional.stg
@@ -0,0 +1,24 @@
+TestType() ::= "Lexer"
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+Input() ::= <<
+//blah
+//blah<\n>
+>>
+
+Output() ::= <<
+[@0,0:6='//blah\n',\<1>,1:0]
+[@1,7:13='//blah\n',\<1>,2:0]
+[@2,14:13='\<EOF>',\<-1>,3:0]<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+CMT : '//' .*? '\n' CMT??;
+WS : (' '|'\t')+;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/NonGreedyPositiveClosure.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/NonGreedyPositiveClosure.stg
new file mode 100644
index 000000000..c4afd4130
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/NonGreedyPositiveClosure.stg
@@ -0,0 +1,24 @@
+TestType() ::= "Lexer"
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+Input() ::= <<
+//blah
+//blah<\n>
+>>
+
+Output() ::= <<
+[@0,0:6='//blah\n',\<1>,1:0]
+[@1,7:13='//blah\n',\<1>,2:0]
+[@2,14:13='\<EOF>',\<-1>,3:0]<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+CMT : ('//' .*? '\n')+?;
+WS : (' '|'\t')+;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/NonGreedyTermination1.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/NonGreedyTermination1.stg
new file mode 100644
index 000000000..5b21c3cbf
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/NonGreedyTermination1.stg
@@ -0,0 +1,22 @@
+TestType() ::= "Lexer"
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+Input() ::= <%
+"hi""mom"
+%>
+
+Output() ::= <<
+[@0,0:3='"hi"',\<1>,1:0]
+[@1,4:8='"mom"',\<1>,1:4]
+[@2,9:8='\<EOF>',\<-1>,1:9]<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+STRING : '"' ('""' | .)*? '"';
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/NonGreedyTermination2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/NonGreedyTermination2.stg
new file mode 100644
index 000000000..4635fd1cb
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/NonGreedyTermination2.stg
@@ -0,0 +1,21 @@
+TestType() ::= "Lexer"
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+Input() ::= <%
+"""mom"
+%>
+
+Output() ::= <<
+[@0,0:6='"""mom"',\<1>,1:0]
+[@1,7:6='\<EOF>',\<-1>,1:7]<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+STRING : '"' ('""' | .)+? '"';
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/Parentheses.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/Parentheses.stg
new file mode 100644
index 000000000..a211deaf9
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/Parentheses.stg
@@ -0,0 +1,32 @@
+/*
+ * This is a regression test for antlr/antlr4#224: "Parentheses without
+ * quantifier in lexer rules have unclear effect".
+ * https://github.com/antlr/antlr4/issues/224
+ */
+TestType() ::= "Lexer"
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+Input() ::= <%
+-.-.-!
+%>
+
+Output() ::= <<
+[@0,0:4='-.-.-',\<1>,1:0]
+[@1,5:5='!',\<3>,1:5]
+[@2,6:5='\<EOF>',\<-1>,1:6]<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+START_BLOCK: '-.-.-';
+ID : (LETTER SEPARATOR) (LETTER SEPARATOR)+;
+fragment LETTER: L_A|L_K;
+fragment L_A: '.-';
+fragment L_K: '-.-';
+SEPARATOR: '!';
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/PositionAdjustingLexer.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/PositionAdjustingLexer.stg
new file mode 100644
index 000000000..29a0886ab
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/PositionAdjustingLexer.stg
@@ -0,0 +1,70 @@
+TestType() ::= "Lexer"
+
+Grammar ::= [
+	"PositionAdjustingLexer": {<grammar("PositionAdjustingLexer")>}
+]
+
+Input() ::= <<
+tokens
+tokens {
+notLabel
+label1 =
+label2 +=
+notLabel<\n>
+>>
+
+TOKENS() ::= "\<4>"
+LABEL() ::= "\<5>"
+IDENTIFIER() ::= "\<6>"
+
+Output() ::= <<
+[@0,0:5='tokens',<IDENTIFIER()>,1:0]
+[@1,7:12='tokens',<TOKENS()>,2:0]
+[@2,14:14='{',\<3>,2:7]
+[@3,16:23='notLabel',<IDENTIFIER()>,3:0]
+[@4,25:30='label1',<LABEL()>,4:0]
+[@5,32:32='=',\<1>,4:7]
+[@6,34:39='label2',<LABEL()>,5:0]
+[@7,41:42='+=',\<2>,5:7]
+[@8,44:51='notLabel',<IDENTIFIER()>,6:0]
+[@9,53:52='\<EOF>',\<-1>,7:0]<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+lexer grammar PositionAdjustingLexer;
+
+@members {
+<PositionAdjustingLexer()>
+}
+
+ASSIGN : '=' ;
+PLUS_ASSIGN : '+=' ;
+LCURLY:	'{';
+
+// 'tokens' followed by '{'
+TOKENS : 'tokens' IGNORED '{';
+
+// IDENTIFIER followed by '+=' or '='
+LABEL
+	:	IDENTIFIER IGNORED '+'? '='
+	;
+
+IDENTIFIER
+	:	[a-zA-Z_] [a-zA-Z0-9_]*
+	;
+
+fragment
+IGNORED
+	:	[ \t\r\n]*
+	;
+
+NEWLINE
+	:	[\r\n]+ -> skip
+	;
+
+WS
+	:	[ \t]+ -> skip
+	;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/QuoteTranslation.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/QuoteTranslation.stg
new file mode 100644
index 000000000..acb05a9d6
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/QuoteTranslation.stg
@@ -0,0 +1,21 @@
+TestType() ::= "Lexer"
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+Input() ::= <%
+"
+%>
+
+Output() ::= <<
+[@0,0:0='"',\<1>,1:0]
+[@1,1:0='\<EOF>',\<-1>,1:1]<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+QUOTE : '"' ; // make sure this compiles
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/RecursiveLexerRuleRefWithWildcardPlus.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/RecursiveLexerRuleRefWithWildcardPlus.stg
new file mode 100644
index 000000000..32efa2f4a
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/RecursiveLexerRuleRefWithWildcardPlus.stg
@@ -0,0 +1,5 @@
+grammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+CMT : '/*' (CMT | .)+? '*/' ;
+WS : (' '|'\n')+;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/RecursiveLexerRuleRefWithWildcardPlus_1.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/RecursiveLexerRuleRefWithWildcardPlus_1.stg
new file mode 100644
index 000000000..1ac6e0ad9
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/RecursiveLexerRuleRefWithWildcardPlus_1.stg
@@ -0,0 +1,24 @@
+import "RecursiveLexerRuleRefWithWildcardPlus.stg"
+
+TestType() ::= "Lexer"
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+// stuff on end of comment matches another rule
+Input() ::= <<
+/* ick */
+/* /* */
+/* /*nested*/ */<\n>
+>>
+
+Output() ::= <<
+[@0,0:8='/* ick */',\<1>,1:0]
+[@1,9:9='\n',\<2>,1:9]
+[@2,10:34='/* /* */\n/* /*nested*/ */',\<1>,2:0]
+[@3,35:35='\n',\<2>,3:16]
+[@4,36:35='\<EOF>',\<-1>,4:0]<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/RecursiveLexerRuleRefWithWildcardPlus_2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/RecursiveLexerRuleRefWithWildcardPlus_2.stg
new file mode 100644
index 000000000..55c8dec4b
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/RecursiveLexerRuleRefWithWildcardPlus_2.stg
@@ -0,0 +1,27 @@
+import "RecursiveLexerRuleRefWithWildcardPlus.stg"
+
+TestType() ::= "Lexer"
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+// stuff on end of comment doesn't match another rule
+Input() ::= <<
+/* ick */x
+/* /* */x
+/* /*nested*/ */x<\n>
+>>
+
+Output() ::= <<
+[@0,0:8='/* ick */',\<1>,1:0]
+[@1,10:10='\n',\<2>,1:10]
+[@2,11:36='/* /* */x\n/* /*nested*/ */',\<1>,2:0]
+[@3,38:38='\n',\<2>,3:17]
+[@4,39:38='\<EOF>',\<-1>,4:0]<\n>
+>>
+
+Errors() ::= <<
+line 1:9 token recognition error at: 'x'
+line 3:16 token recognition error at: 'x'<\n>
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/RecursiveLexerRuleRefWithWildcardStar.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/RecursiveLexerRuleRefWithWildcardStar.stg
new file mode 100644
index 000000000..51cab0950
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/RecursiveLexerRuleRefWithWildcardStar.stg
@@ -0,0 +1,5 @@
+grammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+CMT : '/*' (CMT | .)*? '*/' ;
+WS : (' '|'\n')+;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/RecursiveLexerRuleRefWithWildcardStar_1.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/RecursiveLexerRuleRefWithWildcardStar_1.stg
new file mode 100644
index 000000000..cf70df78d
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/RecursiveLexerRuleRefWithWildcardStar_1.stg
@@ -0,0 +1,24 @@
+import "RecursiveLexerRuleRefWithWildcardStar.stg"
+
+TestType() ::= "Lexer"
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+// stuff on end of comment matches another rule
+Input() ::= <<
+/* ick */
+/* /* */
+/* /*nested*/ */<\n>
+>>
+
+Output() ::= <<
+[@0,0:8='/* ick */',\<1>,1:0]
+[@1,9:9='\n',\<2>,1:9]
+[@2,10:34='/* /* */\n/* /*nested*/ */',\<1>,2:0]
+[@3,35:35='\n',\<2>,3:16]
+[@4,36:35='\<EOF>',\<-1>,4:0]<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/RecursiveLexerRuleRefWithWildcardStar_2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/RecursiveLexerRuleRefWithWildcardStar_2.stg
new file mode 100644
index 000000000..8d5620a9c
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/RecursiveLexerRuleRefWithWildcardStar_2.stg
@@ -0,0 +1,27 @@
+import "RecursiveLexerRuleRefWithWildcardStar.stg"
+
+TestType() ::= "Lexer"
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+// stuff on end of comment doesn't match another rule
+Input() ::= <<
+/* ick */x
+/* /* */x
+/* /*nested*/ */x<\n>
+>>
+
+Output() ::= <<
+[@0,0:8='/* ick */',\<1>,1:0]
+[@1,10:10='\n',\<2>,1:10]
+[@2,11:36='/* /* */x\n/* /*nested*/ */',\<1>,2:0]
+[@3,38:38='\n',\<2>,3:17]
+[@4,39:38='\<EOF>',\<-1>,4:0]<\n>
+>>
+
+Errors() ::= <<
+line 1:9 token recognition error at: 'x'
+line 3:16 token recognition error at: 'x'<\n>
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/RefToRuleDoesNotSetTokenNorEmitAnother.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/RefToRuleDoesNotSetTokenNorEmitAnother.stg
new file mode 100644
index 000000000..3291f6b5d
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/RefToRuleDoesNotSetTokenNorEmitAnother.stg
@@ -0,0 +1,25 @@
+TestType() ::= "Lexer"
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+Input() ::= <%
+34 -21 3
+%>
+
+Output() ::= <<
+[@0,0:1='34',\<2>,1:0]
+[@1,3:5='-21',\<1>,1:3]
+[@2,7:7='3',\<2>,1:7]
+[@3,8:7='\<EOF>',\<-1>,1:8]<\n><! EOF has no length so range is 8:7 not 8:8 !>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+A : '-' I ;
+I : '0'..'9'+ ;
+WS : (' '|'\n') -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/Slashes.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/Slashes.stg
new file mode 100644
index 000000000..ba2c1b2c6
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/Slashes.stg
@@ -0,0 +1,28 @@
+TestType() ::= "Lexer"
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+Input() ::= <%
+\ / \/ /\
+%>
+
+Output() ::= <<
+[@0,0:0='\',\<1>,1:0]
+[@1,2:2='/',\<2>,1:2]
+[@2,4:5='\/',\<3>,1:4]
+[@3,7:8='/\',\<4>,1:7]
+[@4,9:8='\<EOF>',\<-1>,1:9]<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+Backslash : '\\\\';
+Slash : '/';
+Vee : '\\\\/';
+Wedge : '/\\\\';
+WS : [ \t] -> skip;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/ZeroLengthToken.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/ZeroLengthToken.stg
new file mode 100644
index 000000000..e9c33f2ab
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/LexerExec/ZeroLengthToken.stg
@@ -0,0 +1,36 @@
+/*
+ * This is a regression test for antlr/antlr4#687 "Empty zero-length tokens
+ * cannot have lexer commands" and antlr/antlr4#688 "Lexer cannot match
+ * zero-length tokens"
+ * https://github.com/antlr/antlr4/issues/687
+ * https://github.com/antlr/antlr4/issues/688
+ */
+
+TestType() ::= "Lexer"
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+Input() ::= <%
+'xxx'
+%>
+
+Output() ::= <<
+[@0,0:4=''xxx'',\<1>,1:0]
+[@1,5:4='\<EOF>',\<-1>,1:5]<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+BeginString
+	:	'\'' -> more, pushMode(StringMode)
+	;
+mode StringMode;
+	StringMode_X : 'x' -> more;
+	StringMode_Done : -> more, mode(EndStringMode);
+mode EndStringMode;	
+	EndString : '\'' -> popMode;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Listeners/Basic.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Listeners/Basic.stg
new file mode 100644
index 000000000..5016926c8
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Listeners/Basic.stg
@@ -0,0 +1,47 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "1 2"
+
+Rule() ::= "s"
+
+Output() ::= <<
+(a 1 2)
+1
+2<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+@parser::header {
+<ImportListener(grammarName)>
+}
+
+@parser::members {
+<BasicListener(grammarName)>
+}
+
+s
+@after {
+<ToStringTree("$ctx.r"):writeln()>
+<WalkListener("$ctx.r")>
+}
+  : r=a ;
+a : INT INT
+  | ID
+  ;
+MULT: '*' ;
+ADD : '+' ;
+INT : [0-9]+ ;
+ID  : [a-z]+ ;
+WS : [ \t\n]+ -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Listeners/Index.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Listeners/Index.stg
new file mode 100644
index 000000000..6d405b3ea
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Listeners/Index.stg
@@ -0,0 +1,9 @@
+TestTemplates ::= [
+	"Basic": [],
+	"TokenGetters_1": [],
+	"TokenGetters_2": [],
+	"RuleGetters_1": [],
+	"RuleGetters_2": [],
+	"LR": [],
+	"LRWithLabels": []
+]
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Listeners/LR.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Listeners/LR.stg
new file mode 100644
index 000000000..ee877709d
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Listeners/LR.stg
@@ -0,0 +1,51 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "1+2*3"
+
+Rule() ::= "s"
+
+Output() ::= <<
+(e (e 1) + (e (e 2) * (e 3)))
+1
+2
+3
+2 3 2
+1 2 1<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+@parser::header {
+<ImportListener(grammarName)>
+}
+
+@parser::members {
+<LRListener(grammarName)>
+}
+
+s
+@after {
+<ToStringTree("$ctx.r"):writeln()>
+<WalkListener("$ctx.r")>
+}
+	: r=e ;
+e : e op='*' e
+	| e op='+' e
+	| INT
+	;
+MULT: '*' ;
+ADD : '+' ;
+INT : [0-9]+ ;
+ID  : [a-z]+ ;
+WS : [ \t\n]+ -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Listeners/LRWithLabels.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Listeners/LRWithLabels.stg
new file mode 100644
index 000000000..0800fef9d
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Listeners/LRWithLabels.stg
@@ -0,0 +1,50 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "1(2,3)"
+
+Rule() ::= "s"
+
+Output() ::= <<
+(e (e 1) ( (eList (e 2) , (e 3)) ))
+1
+2
+3
+1 [13 6]<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+@parser::header {
+<ImportListener(grammarName)>
+}
+
+@parser::members {
+<LRWithLabelsListener(grammarName)>
+}
+
+s
+@after {
+<ToStringTree("$ctx.r"):writeln()>
+<WalkListener("$ctx.r")>
+}
+  : r=e ;
+e : e '(' eList ')' # Call
+  | INT             # Int
+  ;
+eList : e (',' e)* ;
+MULT: '*' ;
+ADD : '+' ;
+INT : [0-9]+ ;
+ID  : [a-z]+ ;
+WS : [ \t\n]+ -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Listeners/RuleGetters.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Listeners/RuleGetters.stg
new file mode 100644
index 000000000..4984abf3f
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Listeners/RuleGetters.stg
@@ -0,0 +1,38 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Rule() ::= "s"
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+@parser::header {
+<ImportListener(grammarName)>
+}
+
+@parser::members {
+<RuleGetterListener(grammarName)>
+}
+
+s
+@after {
+<ToStringTree("$ctx.r"):writeln()>
+<WalkListener("$ctx.r")>
+}
+  : r=a ;
+a : b b		// forces list
+  | b		// a list still
+  ;
+b : ID | INT;
+MULT: '*' ;
+ADD : '+' ;
+INT : [0-9]+ ;
+ID  : [a-z]+ ;
+WS : [ \t\n]+ -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Listeners/RuleGetters_1.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Listeners/RuleGetters_1.stg
new file mode 100644
index 000000000..3064fb5dd
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Listeners/RuleGetters_1.stg
@@ -0,0 +1,10 @@
+import "RuleGetters.stg"
+
+Input() ::= "1 2"
+
+Output() ::= <<
+(a (b 1) (b 2))
+1 2 1<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Listeners/RuleGetters_2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Listeners/RuleGetters_2.stg
new file mode 100644
index 000000000..c1ce57406
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Listeners/RuleGetters_2.stg
@@ -0,0 +1,10 @@
+import "RuleGetters.stg"
+
+Input() ::= "abc"
+
+Output() ::= <<
+(a (b abc))
+abc<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Listeners/TokenGetters.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Listeners/TokenGetters.stg
new file mode 100644
index 000000000..a58dcb307
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Listeners/TokenGetters.stg
@@ -0,0 +1,37 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Rule() ::= "s"
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+@parser::header {
+<ImportListener(grammarName)>
+}
+
+@parser::members {
+<TokenGetterListener(grammarName)>
+}
+
+s
+@after {
+<ToStringTree("$ctx.r"):writeln()>
+<WalkListener("$ctx.r")>
+}
+  : r=a ;
+a : INT INT
+  | ID
+  ;
+MULT: '*' ;
+ADD : '+' ;
+INT : [0-9]+ ;
+ID  : [a-z]+ ;
+WS : [ \t\n]+ -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Listeners/TokenGetters_1.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Listeners/TokenGetters_1.stg
new file mode 100644
index 000000000..d8a36e6e2
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Listeners/TokenGetters_1.stg
@@ -0,0 +1,10 @@
+import "TokenGetters.stg"
+
+Input() ::= "1 2"
+
+Output() ::= <<
+(a 1 2)
+1 2 [1, 2]<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Listeners/TokenGetters_2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Listeners/TokenGetters_2.stg
new file mode 100644
index 000000000..e01d01e5f
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Listeners/TokenGetters_2.stg
@@ -0,0 +1,10 @@
+import "TokenGetters.stg"
+
+Input() ::= "abc"
+
+Output() ::= <<
+(a abc)
+[@0,0:2='abc',\<4>,1:0]<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParseTrees/2AltLoop.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParseTrees/2AltLoop.stg
new file mode 100644
index 000000000..cc8640c74
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParseTrees/2AltLoop.stg
@@ -0,0 +1,29 @@
+TestType() ::= "Parser"
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "xyyxyxz"
+
+Rule() ::= "s"
+
+Output() ::= <<
+(a x y y x y x z)<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+s
+@init {
+<BuildParseTrees()>
+}
+@after {
+<ToStringTree("$r.ctx"):writeln()>
+}
+  : r=a ;
+a : ('x' | 'y')* 'z'
+  ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParseTrees/2Alts.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParseTrees/2Alts.stg
new file mode 100644
index 000000000..2f1a40049
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParseTrees/2Alts.stg
@@ -0,0 +1,29 @@
+TestType() ::= "Parser"
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "y"
+
+Rule() ::= "s"
+
+Output() ::= <<
+(a y)<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+s
+@init {
+<BuildParseTrees()>
+}
+@after {
+<ToStringTree("$r.ctx"):writeln()>
+}
+  : r=a ;
+a : 'x' | 'y'
+  ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParseTrees/AltNum.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParseTrees/AltNum.stg
new file mode 100644
index 000000000..124112c1f
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParseTrees/AltNum.stg
@@ -0,0 +1,40 @@
+TestType() ::= "Parser"
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "xyz"
+
+Rule() ::= "s"
+
+Output() ::= <<
+(a:3 x (b:2 y) z)<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+
+options { contextSuperClass=MyRuleNode; }
+
+<TreeNodeWithAltNumField(X=grammarName)>
+
+
+s
+@init {
+<BuildParseTrees()>
+}
+@after {
+<ToStringTree("$r.ctx"):writeln()>
+}
+  : r=a ;
+
+a : 'f'
+  | 'g'
+  | 'x' b 'z'
+  ;
+b : 'e' {} | 'y'
+  ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParseTrees/ExtraToken.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParseTrees/ExtraToken.stg
new file mode 100644
index 000000000..90e85755e
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParseTrees/ExtraToken.stg
@@ -0,0 +1,34 @@
+TestType() ::= "Parser"
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "xzy"
+
+Rule() ::= "s"
+
+Output() ::= <<
+(a x z y)<\n>
+>>
+
+Errors() ::= <<
+line 1:1 extraneous input 'z' expecting 'y'<\n>
+>>
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+s
+@init {
+<BuildParseTrees()>
+}
+@after {
+<ToStringTree("$r.ctx"):writeln()>
+}
+  : r=a ;
+a : 'x' 'y'
+  ;
+Z : 'z' 
+  ;
+ 
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParseTrees/Index.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParseTrees/Index.stg
new file mode 100644
index 000000000..a8bc31d2d
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParseTrees/Index.stg
@@ -0,0 +1,11 @@
+TestTemplates ::= [
+	"TokenAndRuleContextString": [],
+	"Token2": [],
+	"2Alts": [],
+	"2AltLoop": [],
+	"RuleRef": [],
+	"ExtraToken": [],
+	"NoViableAlt": [],
+	"Sync": [],
+	"AltNum": []
+]
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParseTrees/NoViableAlt.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParseTrees/NoViableAlt.stg
new file mode 100644
index 000000000..967c1ff98
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParseTrees/NoViableAlt.stg
@@ -0,0 +1,33 @@
+TestType() ::= "Parser"
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "z"
+
+Rule() ::= "s"
+
+Output() ::= <<
+(a z)<\n>
+>>
+
+Errors() ::= <<
+line 1:0 mismatched input 'z' expecting {'x', 'y'}<\n>
+>>
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+s
+@init {
+<BuildParseTrees()>
+}
+@after {
+<ToStringTree("$r.ctx"):writeln()>
+}
+  : r=a ;
+a : 'x' | 'y'
+  ;
+Z : 'z' 
+  ;
+ >>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParseTrees/RuleRef.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParseTrees/RuleRef.stg
new file mode 100644
index 000000000..b7eeadf12
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParseTrees/RuleRef.stg
@@ -0,0 +1,31 @@
+TestType() ::= "Parser"
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "yx"
+
+Rule() ::= "s"
+
+Output() ::= <<
+(a (b y) x)<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+s
+@init {
+<BuildParseTrees()>
+}
+@after {
+<ToStringTree("$r.ctx"):writeln()>
+}
+  : r=a ;
+a : b 'x'
+  ;
+b : 'y' 
+  ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParseTrees/Sync.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParseTrees/Sync.stg
new file mode 100644
index 000000000..405412dc3
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParseTrees/Sync.stg
@@ -0,0 +1,33 @@
+TestType() ::= "Parser"
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "xzyy!"
+
+Rule() ::= "s"
+
+Output() ::= <<
+(a x z y y !)<\n>
+>>
+
+Errors() ::= <<
+line 1:1 extraneous input 'z' expecting {'y', '!'}<\n>
+>>
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+s
+@init {
+<BuildParseTrees()>
+}
+@after {
+<ToStringTree("$r.ctx"):writeln()>
+}
+  : r=a ;
+a : 'x' 'y'* '!'
+  ;
+Z : 'z' 
+  ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParseTrees/Token2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParseTrees/Token2.stg
new file mode 100644
index 000000000..050412cba
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParseTrees/Token2.stg
@@ -0,0 +1,29 @@
+TestType() ::= "Parser"
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "xy"
+
+Rule() ::= "s"
+
+Output() ::= <<
+(a x y)<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+s
+@init {
+<BuildParseTrees()>
+}
+@after {
+<ToStringTree("$r.ctx"):writeln()>
+}
+  : r=a ;
+a : 'x' 'y'
+  ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParseTrees/TokenAndRuleContextString.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParseTrees/TokenAndRuleContextString.stg
new file mode 100644
index 000000000..ecde00502
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParseTrees/TokenAndRuleContextString.stg
@@ -0,0 +1,31 @@
+TestType() ::= "Parser"
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "x"
+
+Rule() ::= "s"
+
+Output() ::= <<
+[a, s]
+(a x)<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+s
+@init {
+<BuildParseTrees()>
+}
+@after {
+<ToStringTree("$r.ctx"):writeln()>
+}
+  : r=a ;
+a : 'x' { 
+<RuleInvocationStack():writeln()>
+} ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/ConjuringUpToken.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/ConjuringUpToken.stg
new file mode 100644
index 000000000..62928d675
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/ConjuringUpToken.stg
@@ -0,0 +1,26 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "ac"
+
+Rule() ::= "a"
+
+Output() ::= <<
+conjured=[@-1,-1:-1='\<missing 'b'>',\<2>,1:1]<\n>
+>>
+
+Errors() ::= <<
+line 1:1 missing 'b' at 'c'<\n>
+>>
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a : 'a' x='b' {<Append("\"conjured=\"","$x"):writeln()>} 'c' ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/ConjuringUpTokenFromSet.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/ConjuringUpTokenFromSet.stg
new file mode 100644
index 000000000..b0f6ad7d4
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/ConjuringUpTokenFromSet.stg
@@ -0,0 +1,26 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "ad"
+
+Rule() ::= "a"
+
+Output() ::= <<
+conjured=[@-1,-1:-1='\<missing 'b'>',\<2>,1:1]<\n>
+>>
+
+Errors() ::= <<
+line 1:1 missing {'b', 'c'} at 'd'<\n>
+>>
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a : 'a' x=('b'|'c') {<Append("\"conjured=\"","$x"):writeln()>} 'd' ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/ContextListGetters.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/ContextListGetters.stg
new file mode 100644
index 000000000..25ee778f4
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/ContextListGetters.stg
@@ -0,0 +1,34 @@
+/**
+ * Regression test for "Getter for context is not a list when it should be".
+ * https://github.com/antlr/antlr4/issues/19
+ */
+
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": true
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "abab"
+
+Rule() ::= "s"
+
+Output() ::= <<
+abab<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+@parser::members{
+<DeclareContextListGettersFunction()>
+}
+s : (a | b)+;
+a : 'a' {<write("'a'")>};
+b : 'b' {<write("'b'")>};
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/DuplicatedLeftRecursiveCall.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/DuplicatedLeftRecursiveCall.stg
new file mode 100644
index 000000000..eabd78f6b
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/DuplicatedLeftRecursiveCall.stg
@@ -0,0 +1,19 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": true
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Rule() ::= "start"
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+start : expr EOF;
+expr : 'x'
+     | expr expr
+     ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/DuplicatedLeftRecursiveCall_1.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/DuplicatedLeftRecursiveCall_1.stg
new file mode 100644
index 000000000..b139021bc
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/DuplicatedLeftRecursiveCall_1.stg
@@ -0,0 +1,7 @@
+import "DuplicatedLeftRecursiveCall.stg"
+
+Input() ::= "x"
+
+Output() ::= ""
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/DuplicatedLeftRecursiveCall_2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/DuplicatedLeftRecursiveCall_2.stg
new file mode 100644
index 000000000..261f25afe
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/DuplicatedLeftRecursiveCall_2.stg
@@ -0,0 +1,7 @@
+import "DuplicatedLeftRecursiveCall.stg"
+
+Input() ::= "xx"
+
+Output() ::= ""
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/DuplicatedLeftRecursiveCall_3.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/DuplicatedLeftRecursiveCall_3.stg
new file mode 100644
index 000000000..31dfe0c08
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/DuplicatedLeftRecursiveCall_3.stg
@@ -0,0 +1,7 @@
+import "DuplicatedLeftRecursiveCall.stg"
+
+Input() ::= "xxx"
+
+Output() ::= ""
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/DuplicatedLeftRecursiveCall_4.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/DuplicatedLeftRecursiveCall_4.stg
new file mode 100644
index 000000000..cd446a55f
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/DuplicatedLeftRecursiveCall_4.stg
@@ -0,0 +1,7 @@
+import "DuplicatedLeftRecursiveCall.stg"
+
+Input() ::= "xxxx"
+
+Output() ::= ""
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/Index.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/Index.stg
new file mode 100644
index 000000000..537a7e2c1
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/Index.stg
@@ -0,0 +1,34 @@
+TestTemplates ::= [
+	"TokenMismatch": [],
+	"SingleTokenDeletion": [],
+	"SingleTokenDeletionConsumption": [],
+	"SingleTokenDeletionExpectingSet": [],
+	"SingleTokenInsertion": [],
+	"SingleSetInsertionConsumption": [],
+	"ConjuringUpToken": [],
+	"SingleSetInsertion": [],
+	"ConjuringUpTokenFromSet": [],
+	"LL2": [],
+	"LL3": [],
+	"LLStar": [],
+	"SingleTokenDeletionBeforeAlt": [],
+	"SingleTokenDeletionBeforePredict": [],
+	"SingleTokenDeletionBeforeLoop": [],
+	"MultiTokenDeletionBeforeLoop": [],
+	"SingleTokenDeletionDuringLoop": [],
+	"MultiTokenDeletionDuringLoop": [],
+	"SingleTokenDeletionBeforeLoop2": [],
+	"MultiTokenDeletionBeforeLoop2": [],
+	"SingleTokenDeletionDuringLoop2": [],
+	"MultiTokenDeletionDuringLoop2": [],
+	"LL1ErrorInfo": [],
+	"InvalidEmptyInput": [],
+	"ContextListGetters": [],
+	"DuplicatedLeftRecursiveCall_1": [],
+	"DuplicatedLeftRecursiveCall_2": [],
+	"DuplicatedLeftRecursiveCall_3": [],
+	"DuplicatedLeftRecursiveCall_4": [],
+	"InvalidATNStateRemoval": [],
+	"NoViableAltAvoidance": [],
+	"TokenMismatch2": []
+]
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/InvalidATNStateRemoval.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/InvalidATNStateRemoval.stg
new file mode 100644
index 000000000..ab25fed6b
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/InvalidATNStateRemoval.stg
@@ -0,0 +1,34 @@
+/**
+ * This is a regression test for #45 "NullPointerException in ATNConfig.hashCode".
+ * https://github.com/antlr/antlr4/issues/45
+ * <p/>
+ * The original cause of this issue was an error in the tool's ATN state optimization,
+ * which is now detected early in {@link ATNSerializer} by ensuring that all
+ * serialized transitions point to states which were not removed.
+ */
+
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "x:x"
+
+Rule() ::= "start"
+
+Output() ::= ""
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+start : ID ':' expr;
+expr : primary expr? {<Pass()>} | expr '->' ID;
+primary : ID;
+ID : [a-z]+;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/InvalidEmptyInput.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/InvalidEmptyInput.stg
new file mode 100644
index 000000000..6692b4245
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/InvalidEmptyInput.stg
@@ -0,0 +1,30 @@
+/**
+ * This is a regression test for #6 "NullPointerException in getMissingSymbol".
+ * https://github.com/antlr/antlr4/issues/6
+ */
+
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": true
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= ""
+
+Rule() ::= "start"
+
+Output() ::= ""
+
+Errors() ::= <<
+line 1:0 missing ID at '\<EOF>'<\n>
+>>
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+start : ID+;
+ID : [a-z]+;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/LL1ErrorInfo.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/LL1ErrorInfo.stg
new file mode 100644
index 000000000..99327d9c7
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/LL1ErrorInfo.stg
@@ -0,0 +1,36 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "dog and software"
+
+Rule() ::= "start"
+
+Output() ::= <<
+{'hardware', 'software'}<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+start : animal (AND acClass)? service EOF;
+animal : (DOG | CAT );
+service : (HARDWARE | SOFTWARE) ;
+AND : 'and';
+DOG : 'dog';
+CAT : 'cat';
+HARDWARE: 'hardware';
+SOFTWARE: 'software';
+WS : ' ' -> skip ;
+acClass
+@init
+{<GetExpectedTokenNames():writeln()>}
+  : ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/LL2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/LL2.stg
new file mode 100644
index 000000000..8476aa6ed
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/LL2.stg
@@ -0,0 +1,28 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "ae"
+
+Rule() ::= "a"
+
+Output() ::= <<
+>>
+
+Errors() ::= <<
+line 1:1 no viable alternative at input 'ae'<\n>
+>>
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a : 'a' 'b'
+  | 'a' 'c'
+;
+q : 'e' ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/LL3.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/LL3.stg
new file mode 100644
index 000000000..8337754a6
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/LL3.stg
@@ -0,0 +1,28 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "abe"
+
+Rule() ::= "a"
+
+Output() ::= <<
+>>
+
+Errors() ::= <<
+line 1:2 no viable alternative at input 'abe'<\n>
+>>
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a : 'a' 'b'* 'c'
+  | 'a' 'b' 'd'
+;
+q : 'e' ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/LLStar.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/LLStar.stg
new file mode 100644
index 000000000..f11e4de37
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/LLStar.stg
@@ -0,0 +1,28 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "aaae"
+
+Rule() ::= "a"
+
+Output() ::= <<
+>>
+
+Errors() ::= <<
+line 1:3 no viable alternative at input 'aaae'<\n>
+>>
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a : 'a'+ 'b'
+  | 'a'+ 'c'
+;
+q : 'e' ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/MultiTokenDeletionBeforeLoop.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/MultiTokenDeletionBeforeLoop.stg
new file mode 100644
index 000000000..de095891c
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/MultiTokenDeletionBeforeLoop.stg
@@ -0,0 +1,25 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "aacabc"
+
+Rule() ::= "a"
+
+Output() ::= <<
+>>
+
+Errors() ::= <<
+line 1:1 extraneous input 'a' expecting {'b', 'c'}<\n>
+>>
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a : 'a' 'b'* 'c';
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/MultiTokenDeletionBeforeLoop2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/MultiTokenDeletionBeforeLoop2.stg
new file mode 100644
index 000000000..60ab4b695
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/MultiTokenDeletionBeforeLoop2.stg
@@ -0,0 +1,25 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "aacabc"
+
+Rule() ::= "a"
+
+Output() ::= <<
+>>
+
+Errors() ::= <<
+line 1:1 extraneous input 'a' expecting {'b', 'z', 'c'}<\n>
+>>
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a : 'a' ('b'|'z'{<Pass()>})* 'c';
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/MultiTokenDeletionDuringLoop.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/MultiTokenDeletionDuringLoop.stg
new file mode 100644
index 000000000..1ca9c48ae
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/MultiTokenDeletionDuringLoop.stg
@@ -0,0 +1,26 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "abaaababc"
+
+Rule() ::= "a"
+
+Output() ::= <<
+>>
+
+Errors() ::= <<
+line 1:2 extraneous input 'a' expecting {'b', 'c'}
+line 1:6 extraneous input 'a' expecting {'b', 'c'}<\n>
+>>
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a : 'a' 'b'* 'c' ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/MultiTokenDeletionDuringLoop2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/MultiTokenDeletionDuringLoop2.stg
new file mode 100644
index 000000000..861040252
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/MultiTokenDeletionDuringLoop2.stg
@@ -0,0 +1,26 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "abaaababc"
+
+Rule() ::= "a"
+
+Output() ::= <<
+>>
+
+Errors() ::= <<
+line 1:2 extraneous input 'a' expecting {'b', 'z', 'c'}
+line 1:6 extraneous input 'a' expecting {'b', 'z', 'c'}<\n>
+>>
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a : 'a' ('b'|'z'{<Pass()>})* 'c' ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/NoViableAltAvoidance.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/NoViableAltAvoidance.stg
new file mode 100644
index 000000000..3bcf4b7af
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/NoViableAltAvoidance.stg
@@ -0,0 +1,35 @@
+// "a." matches 'a' to rule e but then realizes '.' won't match.
+// previously would cause noviablealt. now prediction pretends to
+// have "a' predict 2nd alt of e. Will get syntax error later so
+// let it get farther.
+
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "a."
+
+Rule() ::= "s"
+
+Output() ::= <<
+>>
+
+Errors() ::= <<
+line 1:1 mismatched input '.' expecting '!'<\n>
+>>
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+s : e '!' ;
+e : 'a' 'b'
+  | 'a'
+  ;
+DOT : '.' ;
+WS : [ \t\r\n]+ -> skip;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/SingleSetInsertion.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/SingleSetInsertion.stg
new file mode 100644
index 000000000..b57901152
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/SingleSetInsertion.stg
@@ -0,0 +1,25 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "ad"
+
+Rule() ::= "a"
+
+Output() ::= <<
+>>
+
+Errors() ::= <<
+line 1:1 missing {'b', 'c'} at 'd'<\n>
+>>
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a : 'a' ('b'|'c') 'd' ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/SingleSetInsertionConsumption.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/SingleSetInsertionConsumption.stg
new file mode 100644
index 000000000..ecca64a96
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/SingleSetInsertionConsumption.stg
@@ -0,0 +1,27 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "ad"
+
+Rule() ::= "a"
+
+Output() ::= <<
+[@0,0:0='a',\<3>,1:0]<\n>
+>>
+
+Errors() ::= <<
+line 1:1 missing {'b', 'c'} at 'd'<\n>
+>>
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+myset: ('b'|'c') ;
+a: 'a' myset 'd' {<writeln(Append("\"\"","$myset.stop"))>} ; <! bit complicated because of the JavaScript target !>
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/SingleTokenDeletion.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/SingleTokenDeletion.stg
new file mode 100644
index 000000000..5a3f9502d
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/SingleTokenDeletion.stg
@@ -0,0 +1,25 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "aab"
+
+Rule() ::= "a"
+
+Output() ::= <<
+>>
+
+Errors() ::= <<
+line 1:1 extraneous input 'a' expecting 'b'<\n>
+>>
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a : 'a' 'b' ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/SingleTokenDeletionBeforeAlt.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/SingleTokenDeletionBeforeAlt.stg
new file mode 100644
index 000000000..5ed5e5879
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/SingleTokenDeletionBeforeAlt.stg
@@ -0,0 +1,28 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "ac"
+
+Rule() ::= "a"
+
+Output() ::= <<
+>>
+
+Errors() ::= <<
+line 1:0 extraneous input 'a' expecting {'b', 'c'}<\n>
+>>
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a : ('b' | 'c')
+;
+q : 'a'
+;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/SingleTokenDeletionBeforeLoop.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/SingleTokenDeletionBeforeLoop.stg
new file mode 100644
index 000000000..a2cebc547
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/SingleTokenDeletionBeforeLoop.stg
@@ -0,0 +1,26 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "aabc"
+
+Rule() ::= "a"
+
+Output() ::= <<
+>>
+
+Errors() ::= <<
+line 1:1 extraneous input 'a' expecting {\<EOF>, 'b'}
+line 1:3 token recognition error at: 'c'<\n>
+>>
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a : 'a' 'b'* ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/SingleTokenDeletionBeforeLoop2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/SingleTokenDeletionBeforeLoop2.stg
new file mode 100644
index 000000000..ee06ab0ce
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/SingleTokenDeletionBeforeLoop2.stg
@@ -0,0 +1,26 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "aabc"
+
+Rule() ::= "a"
+
+Output() ::= <<
+>>
+
+Errors() ::= <<
+line 1:1 extraneous input 'a' expecting {\<EOF>, 'b', 'z'}
+line 1:3 token recognition error at: 'c'<\n>
+>>
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a : 'a' ('b'|'z'{<Pass()>})*;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/SingleTokenDeletionBeforePredict.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/SingleTokenDeletionBeforePredict.stg
new file mode 100644
index 000000000..b353ed032
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/SingleTokenDeletionBeforePredict.stg
@@ -0,0 +1,28 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "caaab"
+
+Rule() ::= "a"
+
+Output() ::= <<
+>>
+
+Errors() ::= <<
+line 1:0 extraneous input 'c' expecting 'a'<\n>
+>>
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a : 'a'+ 'b'
+  | 'a'+ 'c'
+;
+q : 'e' ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/SingleTokenDeletionConsumption.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/SingleTokenDeletionConsumption.stg
new file mode 100644
index 000000000..149a60e55
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/SingleTokenDeletionConsumption.stg
@@ -0,0 +1,27 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "aabd"
+
+Rule() ::= "a"
+
+Output() ::= <<
+[@2,2:2='b',\<1>,1:2]<\n>
+>>
+
+Errors() ::= <<
+line 1:1 extraneous input 'a' expecting {'b', 'c'}<\n>
+>>
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+myset: ('b'|'c') ;
+a: 'a' myset 'd' {<writeln(Append("\"\"","$myset.stop"))>} ; <! bit complicated because of the JavaScript target !>
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/SingleTokenDeletionDuringLoop.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/SingleTokenDeletionDuringLoop.stg
new file mode 100644
index 000000000..5c8dab9cd
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/SingleTokenDeletionDuringLoop.stg
@@ -0,0 +1,25 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "ababbc"
+
+Rule() ::= "a"
+
+Output() ::= <<
+>>
+
+Errors() ::= <<
+line 1:2 extraneous input 'a' expecting {'b', 'c'}<\n>
+>>
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a : 'a' 'b'* 'c' ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/SingleTokenDeletionDuringLoop2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/SingleTokenDeletionDuringLoop2.stg
new file mode 100644
index 000000000..3eb2df438
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/SingleTokenDeletionDuringLoop2.stg
@@ -0,0 +1,25 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "ababbc"
+
+Rule() ::= "a"
+
+Output() ::= <<
+>>
+
+Errors() ::= <<
+line 1:2 extraneous input 'a' expecting {'b', 'z', 'c'}<\n>
+>>
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a : 'a' ('b'|'z'{<Pass()>})* 'c' ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/SingleTokenDeletionExpectingSet.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/SingleTokenDeletionExpectingSet.stg
new file mode 100644
index 000000000..f79b62665
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/SingleTokenDeletionExpectingSet.stg
@@ -0,0 +1,25 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "aab"
+
+Rule() ::= "a"
+
+Output() ::= <<
+>>
+
+Errors() ::= <<
+line 1:1 extraneous input 'a' expecting {'b', 'c'}<\n>
+>>
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a : 'a' ('b'|'c') ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/SingleTokenInsertion.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/SingleTokenInsertion.stg
new file mode 100644
index 000000000..c7338aa3e
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/SingleTokenInsertion.stg
@@ -0,0 +1,25 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "ac"
+
+Rule() ::= "a"
+
+Output() ::= <<
+>>
+
+Errors() ::= <<
+line 1:1 missing 'b' at 'c'<\n>
+>>
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a : 'a' 'b' 'c' ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/TokenMismatch.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/TokenMismatch.stg
new file mode 100644
index 000000000..f56bf8c12
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/TokenMismatch.stg
@@ -0,0 +1,25 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "aa"
+
+Rule() ::= "a"
+
+Output() ::= <<
+>>
+
+Errors() ::= <<
+line 1:1 mismatched input 'a' expecting 'b'<\n>
+>>
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a : 'a' 'b' ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/TokenMismatch2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/TokenMismatch2.stg
new file mode 100644
index 000000000..69fe341b8
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserErrors/TokenMismatch2.stg
@@ -0,0 +1,32 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "( ~FORCE_ERROR~ "
+
+Rule() ::= "stat"
+
+Output() ::= <<
+>>
+
+Errors() ::= <<
+line 1:2 mismatched input '~FORCE_ERROR~' expecting ')'<\n>
+>>
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+
+stat:   ( '(' expr? ')' )? EOF ;
+expr:   ID '=' STR ;
+
+ERR :   '~FORCE_ERROR~' ;
+ID  :   [a-zA-Z]+ ;
+STR :   '"' ~["]* '"' ;
+WS  :   [ \t\r\n]+ -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/APlus.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/APlus.stg
new file mode 100644
index 000000000..d3f47b76d
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/APlus.stg
@@ -0,0 +1,28 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "a b c"
+
+Rule() ::= "a"
+
+Output() ::= <<
+abc<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a : ID+ {
+<writeln("$text")>
+};
+ID : 'a'..'z'+;
+WS : (' '|'\n') -> skip;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/AStar.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/AStar.stg
new file mode 100644
index 000000000..d73b35cc4
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/AStar.stg
@@ -0,0 +1,20 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Rule() ::= "a"
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a : ID* {
+<writeln("$text")>
+};
+ID : 'a'..'z'+;
+WS : (' '|'\n') -> skip;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/AStar_1.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/AStar_1.stg
new file mode 100644
index 000000000..c28e0bd01
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/AStar_1.stg
@@ -0,0 +1,7 @@
+import "AStar.stg"
+
+Input() ::= ""
+
+Output() ::= "<\n>"
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/AStar_2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/AStar_2.stg
new file mode 100644
index 000000000..a465d0299
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/AStar_2.stg
@@ -0,0 +1,9 @@
+import "AStar.stg"
+
+Input() ::= "a b c"
+
+Output() ::= <<
+abc<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/AlternateQuotes.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/AlternateQuotes.stg
new file mode 100644
index 000000000..bb3b24b2a
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/AlternateQuotes.stg
@@ -0,0 +1,42 @@
+TestType() ::= "CompositeParser"
+
+Options ::= [
+	"SlaveIsLexer": true,
+	"Debug": false
+]
+
+Grammar ::= [
+	"ModeTagsParser": {<grammar("ModeTagsParser", "ModeTagsLexer")>}
+]
+
+SlaveGrammars ::= [
+	"ModeTagsLexer": {<slaveGrammar("ModeTagsLexer")>}
+]
+
+Input() ::= ""
+
+Rule() ::= "file_"
+
+Output() ::= ""
+
+Errors() ::= ""
+
+grammar(grammarName, slaveGrammarName) ::= <<
+parser grammar <grammarName>;
+options { tokenVocab=<slaveGrammarName>; } // use tokens from <slaveGrammarName>.g4
+file_: (tag | TEXT)* ;
+tag : '«' ID '»'
+    | '«' '/' ID '»'
+    ;
+>>
+
+slaveGrammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+// Default mode rules (the SEA)
+OPEN  : '«'     -> mode(ISLAND) ;       // switch to ISLAND mode
+TEXT  : ~'«'+ ;                         // clump all text together
+mode ISLAND;
+CLOSE : '»'     -> mode(DEFAULT_MODE) ; // back to SEA mode
+SLASH : '/' ;
+ID    : [a-zA-Z]+ ;                     // match/send ID in tag to parser
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/AorAPlus.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/AorAPlus.stg
new file mode 100644
index 000000000..07a6ba0d6
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/AorAPlus.stg
@@ -0,0 +1,30 @@
+// force complex decision
+
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "a b c"
+
+Rule() ::= "a"
+
+Output() ::= <<
+abc<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a : (ID|ID)+ {
+<writeln("$text")>
+};
+ID : 'a'..'z'+;
+WS : (' '|'\n') -> skip;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/AorAStar.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/AorAStar.stg
new file mode 100644
index 000000000..a00c180cf
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/AorAStar.stg
@@ -0,0 +1,28 @@
+// force complex decision
+
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= ""
+
+Rule() ::= "a"
+
+Output() ::= ""
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a : (ID|ID)* {
+<writeln("$text")>
+};
+ID : 'a'..'z'+;
+WS : (' '|'\n') -> skip;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/AorAStar_1.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/AorAStar_1.stg
new file mode 100644
index 000000000..abafb086b
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/AorAStar_1.stg
@@ -0,0 +1,7 @@
+import "AorAStar.stg"
+
+Input() ::= ""
+
+Output() ::= "<\n>"
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/AorAStar_2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/AorAStar_2.stg
new file mode 100644
index 000000000..3d149e580
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/AorAStar_2.stg
@@ -0,0 +1,9 @@
+import "AorAStar.stg"
+
+Input() ::= "a b c"
+
+Output() ::= <<
+abc<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/AorB.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/AorB.stg
new file mode 100644
index 000000000..f19635431
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/AorB.stg
@@ -0,0 +1,31 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "34"
+
+Rule() ::= "a"
+
+Output() ::= <<
+alt 2<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a : ID {
+<writeln("\"alt 1\"")>
+} | INT {
+<writeln("\"alt 2\"")>
+};
+ID : 'a'..'z'+ ;
+INT : '0'..'9'+;
+WS : (' '|'\\n') -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/AorBPlus.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/AorBPlus.stg
new file mode 100644
index 000000000..ec2a66e58
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/AorBPlus.stg
@@ -0,0 +1,30 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "a 34 c"
+
+Rule() ::= "a"
+
+Output() ::= <<
+a34c<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a : (ID|INT{
+})+ {
+<writeln("$text")>
+};
+ID : 'a'..'z'+ ;
+INT : '0'..'9'+;
+WS : (' '|'\\n') -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/AorBStar.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/AorBStar.stg
new file mode 100644
index 000000000..3f6c92bf6
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/AorBStar.stg
@@ -0,0 +1,22 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Rule() ::= "a"
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a : (ID|INT{
+})* {
+<writeln("$text")>
+};
+ID : 'a'..'z'+ ;
+INT : '0'..'9'+;
+WS : (' '|'\\n') -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/AorBStar_1.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/AorBStar_1.stg
new file mode 100644
index 000000000..02d3461e4
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/AorBStar_1.stg
@@ -0,0 +1,7 @@
+import "AorBStar.stg"
+
+Input() ::= ""
+
+Output() ::= "<\n>"
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/AorBStar_2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/AorBStar_2.stg
new file mode 100644
index 000000000..63709c0bb
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/AorBStar_2.stg
@@ -0,0 +1,9 @@
+import "AorBStar.stg"
+
+Input() ::= "a 34 c"
+
+Output() ::= <<
+a34c<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/Basic.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/Basic.stg
new file mode 100644
index 000000000..b16103e75
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/Basic.stg
@@ -0,0 +1,29 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "abc 34"
+
+Rule() ::= "a"
+
+Output() ::= <<
+abc34<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a : ID INT {
+<writeln("$text")>
+};
+ID : 'a'..'z'+ ;
+INT : '0'..'9'+;
+WS : (' '|'\n') -> skip;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/EOFInClosure.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/EOFInClosure.stg
new file mode 100644
index 000000000..12fa38274
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/EOFInClosure.stg
@@ -0,0 +1,29 @@
+/**
+ * This test ensures that {@link ParserATNSimulator} does not produce a
+ * {@link StackOverflowError} when it encounters an {@code EOF} transition
+ * inside a closure.
+ */
+
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "x"
+
+Rule() ::= "prog"
+
+Output() ::= ""
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+prog : stat EOF;
+stat : 'x' ('y' | EOF)*?;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/IfIfElseGreedyBinding1.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/IfIfElseGreedyBinding1.stg
new file mode 100644
index 000000000..76fb77862
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/IfIfElseGreedyBinding1.stg
@@ -0,0 +1,31 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "if y if y x else x"
+
+Rule() ::= "start"
+
+Output() ::= <<
+if y x else x
+if y if y x else x<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+start : statement+ ;
+statement : 'x' | ifStatement;
+ifStatement : 'if' 'y' statement ('else' statement)? {
+<writeln("$text")>
+};
+ID : 'a'..'z'+ ;
+WS : (' '|'\n') -> channel(HIDDEN);
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/IfIfElseGreedyBinding2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/IfIfElseGreedyBinding2.stg
new file mode 100644
index 000000000..5f65e4c6f
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/IfIfElseGreedyBinding2.stg
@@ -0,0 +1,31 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "if y if y x else x"
+
+Rule() ::= "start"
+
+Output() ::= <<
+if y x else x
+if y if y x else x<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+start : statement+ ;
+statement : 'x' | ifStatement;
+ifStatement : 'if' 'y' statement ('else' statement|) {
+<writeln("$text")>
+};
+ID : 'a'..'z'+ ;
+WS : (' '|'\n') -> channel(HIDDEN);
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/IfIfElseNonGreedyBinding1.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/IfIfElseNonGreedyBinding1.stg
new file mode 100644
index 000000000..7c4b38cce
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/IfIfElseNonGreedyBinding1.stg
@@ -0,0 +1,31 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "if y if y x else x"
+
+Rule() ::= "start"
+
+Output() ::= <<
+if y x
+if y if y x else x<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+start : statement+ ;
+statement : 'x' | ifStatement;
+ifStatement : 'if' 'y' statement ('else' statement)?? {
+<writeln("$text")>
+};
+ID : 'a'..'z'+ ;
+WS : (' '|'\n') -> channel(HIDDEN);
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/IfIfElseNonGreedyBinding2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/IfIfElseNonGreedyBinding2.stg
new file mode 100644
index 000000000..930b01119
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/IfIfElseNonGreedyBinding2.stg
@@ -0,0 +1,31 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "if y if y x else x"
+
+Rule() ::= "start"
+
+Output() ::= <<
+if y x
+if y if y x else x<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+start : statement+ ;
+statement : 'x' | ifStatement;
+ifStatement : 'if' 'y' statement (|'else' statement) {
+<writeln("$text")>
+};
+ID : 'a'..'z'+ ;
+WS : (' '|'\n') -> channel(HIDDEN);
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/Index.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/Index.stg
new file mode 100644
index 000000000..e41b91159
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/Index.stg
@@ -0,0 +1,36 @@
+TestTemplates ::= [
+	"Labels": [],
+	"ListLabelsOnSet": [],
+	"AorB": [],
+	"Basic": [],
+	"APlus": [],
+	"AorAPlus": [],
+	"IfIfElseGreedyBinding1": [],
+	"IfIfElseGreedyBinding2": [],
+	"IfIfElseNonGreedyBinding1": [],
+	"IfIfElseNonGreedyBinding2": [],
+	"AStar_1": [],
+	"AStar_2": [],
+	"LL1OptionalBlock_1": [],
+	"LL1OptionalBlock_2": [],
+	"AorAStar_1": [],
+	"AorAStar_2": [],
+	"AorBPlus": [],
+	"AorBStar_1": [],
+	"AorBStar_2": [],
+	"Optional_1": [],
+	"Optional_2": [],
+	"Optional_3": [],
+	"Optional_4": [],
+	"PredicatedIfIfElse": [],
+	//"StartRuleWithoutEOF": [],
+	"LabelAliasingAcrossLabeledAlternatives": [],
+	"ParserProperty": [],
+	"PredictionIssue334": [],
+	"ListLabelForClosureContext": [],
+	"MultipleEOFHandling": [],
+	"EOFInClosure": [],
+	"ReferenceToATN_1": [],
+	"ReferenceToATN_2": []
+	//"AlternateQuotes": []
+]
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/LL1OptionalBlock.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/LL1OptionalBlock.stg
new file mode 100644
index 000000000..aa5e0fae4
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/LL1OptionalBlock.stg
@@ -0,0 +1,27 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= ""
+
+Rule() ::= "a"
+
+Output() ::= ""
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a : (ID|{}INT)? {
+<writeln("$text")>
+};
+ID : 'a'..'z'+;
+INT : '0'..'9'+ ;
+WS : (' '|'\n') -> skip;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/LL1OptionalBlock_1.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/LL1OptionalBlock_1.stg
new file mode 100644
index 000000000..c3633e683
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/LL1OptionalBlock_1.stg
@@ -0,0 +1,7 @@
+import "LL1OptionalBlock.stg"
+
+Input() ::= ""
+
+Output() ::= "<\n>"
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/LL1OptionalBlock_2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/LL1OptionalBlock_2.stg
new file mode 100644
index 000000000..d57a5b50b
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/LL1OptionalBlock_2.stg
@@ -0,0 +1,9 @@
+import "LL1OptionalBlock.stg"
+
+Input() ::= "a"
+
+Output() ::= <<
+a<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/LabelAliasingAcrossLabeledAlternatives.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/LabelAliasingAcrossLabeledAlternatives.stg
new file mode 100644
index 000000000..c684f4ab5
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/LabelAliasingAcrossLabeledAlternatives.stg
@@ -0,0 +1,37 @@
+/**
+ * This is a regression test for antlr/antlr4#195 "label 'label' type
+ * mismatch with previous definition: TOKEN_LABEL!=RULE_LABEL"
+ * https://github.com/antlr/antlr4/issues/195
+ */
+
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "xy"
+
+Rule() ::= "start"
+
+Output() ::= <<
+x
+y<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+start : a* EOF;
+a
+  : label=subrule {<writeln("$label.text")>} #One
+  | label='y' {<writeln("$label.text")>} #Two
+  ;
+subrule : 'x';
+WS : (' '|'\n') -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/Labels.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/Labels.stg
new file mode 100644
index 000000000..d86a8bbaf
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/Labels.stg
@@ -0,0 +1,26 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "abc 34;"
+
+Rule() ::= "a"
+
+Output() ::= ""
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a : b1=b b2+=b* b3+=';' ;
+b : id_=ID val+=INT*;
+ID : 'a'..'z'+ ;
+INT : '0'..'9'+;
+WS : (' '|'\n') -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/ListLabelForClosureContext.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/ListLabelForClosureContext.stg
new file mode 100644
index 000000000..6466f2a8c
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/ListLabelForClosureContext.stg
@@ -0,0 +1,46 @@
+/**
+ * This is a regression test for antlr/antlr4#299 "Repeating subtree not
+ * accessible in visitor".
+ * https://github.com/antlr/antlr4/issues/299
+ */
+
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "a"
+
+Rule() ::= "expression"
+
+Output() ::= ""
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+ifStatement
+@after {
+<AssertIsList("$ctx.elseIfStatement()")>
+}
+    : 'if' expression
+      ( ( 'then'
+          executableStatement*
+          elseIfStatement*  // \<--- problem is here; should yield a list not node
+          elseStatement?
+          'end' 'if'
+        ) | executableStatement )
+    ;
+
+elseIfStatement
+    : 'else' 'if' expression 'then' executableStatement*
+    ;
+expression : 'a' ;
+executableStatement : 'a' ;
+elseStatement : 'a' ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/ListLabelsOnSet.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/ListLabelsOnSet.stg
new file mode 100644
index 000000000..9547d217a
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/ListLabelsOnSet.stg
@@ -0,0 +1,33 @@
+/**
+ * This is a regression test for #270 "Fix operator += applied to a set of
+ * tokens".
+ * https://github.com/antlr/antlr4/issues/270
+ */
+
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "abc 34;"
+
+Rule() ::= "a"
+
+Output() ::= ""
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a : b b* ';' ;
+b : ID val+=(INT | FLOAT)*;
+ID : 'a'..'z'+ ;
+INT : '0'..'9'+;
+FLOAT : [0-9]+ '.' [0-9]+;
+WS : (' '|'\n') -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/MultipleEOFHandling.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/MultipleEOFHandling.stg
new file mode 100644
index 000000000..bc3e12640
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/MultipleEOFHandling.stg
@@ -0,0 +1,28 @@
+/**
+ * This test ensures that {@link ParserATNSimulator} produces a correct
+ * result when the grammar contains multiple explicit references to
+ * {@code EOF} inside of parser rules.
+ */
+
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "x"
+
+Rule() ::= "prog"
+
+Output() ::= ""
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+prog : ('x' | 'x' 'y') EOF EOF;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/Optional.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/Optional.stg
new file mode 100644
index 000000000..7b77ab6cc
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/Optional.stg
@@ -0,0 +1,23 @@
+/**
+ * This test is meant to detect regressions of bug antlr/antlr4#41.
+ * https://github.com/antlr/antlr4/issues/41
+ */
+
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Rule() ::= "stat"
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+stat : ifstat | 'x';
+ifstat : 'if' stat ('else' stat)?;
+WS : [ \n\t]+ -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/Optional_1.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/Optional_1.stg
new file mode 100644
index 000000000..43c415467
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/Optional_1.stg
@@ -0,0 +1,7 @@
+import "Optional.stg"
+
+Input() ::= "x"
+
+Output() ::= ""
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/Optional_2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/Optional_2.stg
new file mode 100644
index 000000000..63ddac89e
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/Optional_2.stg
@@ -0,0 +1,7 @@
+import "Optional.stg"
+
+Input() ::= "if x"
+
+Output() ::= ""
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/Optional_3.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/Optional_3.stg
new file mode 100644
index 000000000..344cf72a4
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/Optional_3.stg
@@ -0,0 +1,7 @@
+import "Optional.stg"
+
+Input() ::= "if x else x"
+
+Output() ::= ""
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/Optional_4.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/Optional_4.stg
new file mode 100644
index 000000000..6afa85434
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/Optional_4.stg
@@ -0,0 +1,7 @@
+import "Optional.stg"
+
+Input() ::= "if if x else x"
+
+Output() ::= ""
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/ParserProperty.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/ParserProperty.stg
new file mode 100644
index 000000000..c5a9808c1
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/ParserProperty.stg
@@ -0,0 +1,34 @@
+/*
+ * This is a regression test for antlr/antlr4#561 "Issue with parser
+ * generation in 4.2.2"
+ * https://github.com/antlr/antlr4/issues/561
+ */
+
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "abc"
+
+Rule() ::= "a"
+
+Output() ::= <<
+valid<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+<ParserPropertyMember()>
+a : {$parser.Property()}? ID {<writeln("\"valid\"")>}
+  ;
+ID : 'a'..'z'+ ;
+WS : (' '|'\n') -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/PredicatedIfIfElse.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/PredicatedIfIfElse.stg
new file mode 100644
index 000000000..92ba179f0
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/PredicatedIfIfElse.stg
@@ -0,0 +1,32 @@
+/**
+ * This test is meant to test the expected solution to antlr/antlr4#42.
+ * https://github.com/antlr/antlr4/issues/42
+ */
+
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": true
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "if x if x a else b"
+
+Rule() ::= "s"
+
+Output() ::= ""
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+s : stmt EOF ;
+stmt : ifStmt | ID;
+ifStmt : 'if' ID stmt ('else' stmt | { <LANotEquals("1", {<grammarName>Parser.ELSE})> }?);
+ELSE : 'else';
+ID : [a-zA-Z]+;
+WS : [ \\n\\t]+ -> skip;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/PredictionIssue334.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/PredictionIssue334.stg
new file mode 100644
index 000000000..1e9645de5
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/PredictionIssue334.stg
@@ -0,0 +1,41 @@
+/**
+ * This is a regression test for antlr/antlr4#334 "BailErrorStrategy: bails
+ * out on proper input".
+ * https://github.com/antlr/antlr4/issues/334
+ */
+
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "a"
+
+Rule() ::= "file_"
+
+Output() ::= <<
+(file_ (item a) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+file_ @init{
+<BailErrorStrategy()>
+} 
+@after {
+<ToStringTree("$ctx"):writeln()>
+}
+  :   item (SEMICOLON item)* SEMICOLON? EOF ;
+item : A B?;
+SEMICOLON: ';';
+A : 'a'|'A';
+B : 'b'|'B';
+WS      : [ \r\t\n]+ -> skip;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/ReferenceToATN.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/ReferenceToATN.stg
new file mode 100644
index 000000000..ce8b400ee
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/ReferenceToATN.stg
@@ -0,0 +1,25 @@
+/**
+ * This is a regression test for antlr/antlr4#561 "Issue with parser
+ * generation in 4.2.2"
+ * https://github.com/antlr/antlr4/issues/561
+ */
+
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Rule() ::= "a"
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a : (ID|ATN)* ATN? {<writeln("$text")>} ;
+ID : 'a'..'z'+ ;
+ATN : '0'..'9'+;
+WS : (' '|'\n') -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/ReferenceToATN_1.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/ReferenceToATN_1.stg
new file mode 100644
index 000000000..a3e50c8ca
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/ReferenceToATN_1.stg
@@ -0,0 +1,7 @@
+import "ReferenceToATN.stg"
+
+Input() ::= ""
+
+Output() ::= "<\n>"
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/ReferenceToATN_2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/ReferenceToATN_2.stg
new file mode 100644
index 000000000..ce2daabbf
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/ReferenceToATN_2.stg
@@ -0,0 +1,9 @@
+import "ReferenceToATN.stg"
+
+Input() ::= "a 34 c"
+
+Output() ::= <<
+a34c<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/StartRuleWithoutEOF.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/StartRuleWithoutEOF.stg
new file mode 100644
index 000000000..4821cfe79
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/ParserExec/StartRuleWithoutEOF.stg
@@ -0,0 +1,31 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": true
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "abc 34"
+
+Rule() ::= "s"
+
+Output() ::= <<
+Decision 0:
+s0-ID->s1
+s1-INT->s2
+s2-EOF->:s3=>1<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+s @after { <DumpDFA()> }
+  : ID | ID INT ID ;
+ID : 'a'..'z'+ ;
+INT : '0'..'9'+;
+WS : (' '|'\t'|'\n') -> skip;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Performance/ExpressionGrammar.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Performance/ExpressionGrammar.stg
new file mode 100644
index 000000000..22747f3fe
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Performance/ExpressionGrammar.stg
@@ -0,0 +1,54 @@
+/*
+ * This is a regression test for antlr/antlr4#192 "Poor performance of
+ * expression parsing".
+ * https://github.com/antlr/antlr4/issues/192
+ */
+
+TestType() ::= "Parser"
+
+Options ::= [
+	"Timeout": "60000"
+]
+
+Grammar ::= [
+	"Expr": {<grammar("Expr")>}
+]
+
+InputFragment() ::= <<
+not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or
+    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or
+not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or
+not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or
+not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or
+not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or
+not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or
+not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or
+not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or
+not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or
+not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or
+not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or
+not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12
+>>
+
+Rule() ::= "program"
+
+Output() ::= ""
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+
+program: expr EOF;
+
+expr
+	: ID
+	| 'not' expr
+	| expr 'and' expr
+	| expr 'or' expr
+	;
+
+ID: [a-zA-Z_][a-zA-Z_0-9]*;
+WS: [ \t\n\r\f]+ -> skip;
+ERROR: .;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Performance/ExpressionGrammar_1.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Performance/ExpressionGrammar_1.stg
new file mode 100644
index 000000000..b5dc2288e
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Performance/ExpressionGrammar_1.stg
@@ -0,0 +1,5 @@
+import "ExpressionGrammar.stg"
+
+Input() ::= <<
+<InputFragment()>
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Performance/ExpressionGrammar_2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Performance/ExpressionGrammar_2.stg
new file mode 100644
index 000000000..d7dda0b5a
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Performance/ExpressionGrammar_2.stg
@@ -0,0 +1,14 @@
+import "ExpressionGrammar.stg"
+
+Input() ::= <<
+<InputFragment()> or
+<InputFragment()> or
+<InputFragment()> or
+<InputFragment()> or
+<InputFragment()> or
+<InputFragment()> or
+<InputFragment()> or
+<InputFragment()> or
+<InputFragment()> or
+<InputFragment()>
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Performance/Index.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Performance/Index.stg
new file mode 100644
index 000000000..c1cf3d8cf
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Performance/Index.stg
@@ -0,0 +1,4 @@
+TestTemplates ::= [
+	"ExpressionGrammar_1": [],
+	"ExpressionGrammar_2": []
+]
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalLexer/DisableRule.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalLexer/DisableRule.stg
new file mode 100644
index 000000000..919272bbd
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalLexer/DisableRule.stg
@@ -0,0 +1,34 @@
+TestType() ::= "Lexer"
+
+Options ::= [
+	"ShowDFA": true
+]
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+Input() ::= "enum abc"
+
+Output() ::= <<
+[@0,0:3='enum',\<2>,1:0]
+[@1,5:7='abc',\<3>,1:5]
+[@2,8:7='\<EOF>',\<-1>,1:8]
+s0-' '->:s5=>4
+s0-'a'->:s6=>3
+s0-'e'->:s1=>3
+:s1=>3-'n'->:s2=>3
+:s2=>3-'u'->:s3=>3
+:s6=>3-'b'->:s6=>3
+:s6=>3-'c'->:s6=>3<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+E1 : 'enum' { <False()> }? ;
+E2 : 'enum' { <True()> }? ;  // winner not E1 or ID
+ID : 'a'..'z'+ ;
+WS : (' '|'\n') -> skip;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalLexer/EnumNotID.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalLexer/EnumNotID.stg
new file mode 100644
index 000000000..2e5208605
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalLexer/EnumNotID.stg
@@ -0,0 +1,29 @@
+TestType() ::= "Lexer"
+
+Options ::= [
+	"ShowDFA": true
+]
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+Input() ::= "enum abc enum"
+
+Output() ::= <<
+[@0,0:3='enum',\<1>,1:0]
+[@1,5:7='abc',\<2>,1:5]
+[@2,9:12='enum',\<1>,1:9]
+[@3,13:12='\<EOF>',\<-1>,1:13]
+<! no edges in DFA for enum/id. all paths lead to pred. !>
+s0-' '->:s3=>3<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+ENUM : [a-z]+  { <TextEquals("enum")> }? ;
+ID : [a-z]+  ;
+WS : (' '|'\n') -> skip;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalLexer/IDnotEnum.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalLexer/IDnotEnum.stg
new file mode 100644
index 000000000..cfe176309
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalLexer/IDnotEnum.stg
@@ -0,0 +1,29 @@
+TestType() ::= "Lexer"
+
+Options ::= [
+	"ShowDFA": true
+]
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+Input() ::= "enum abc enum"
+
+Output() ::= <<
+[@0,0:3='enum',\<2>,1:0]
+[@1,5:7='abc',\<2>,1:5]
+[@2,9:12='enum',\<2>,1:9]
+[@3,13:12='\<EOF>',\<-1>,1:13]
+<! no edges in DFA for enum/id. all paths lead to pred. !>
+s0-' '->:s2=>3<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+ENUM : [a-z]+  { <False()> }? ;
+ID : [a-z]+  ;
+WS : (' '|'\n') -> skip;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalLexer/IDvsEnum.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalLexer/IDvsEnum.stg
new file mode 100644
index 000000000..5e2b93db1
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalLexer/IDvsEnum.stg
@@ -0,0 +1,35 @@
+TestType() ::= "Lexer"
+
+Options ::= [
+	"ShowDFA": true
+]
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+Input() ::= "enum abc enum"
+
+Output() ::= <<
+[@0,0:3='enum',\<2>,1:0]
+[@1,5:7='abc',\<2>,1:5]
+[@2,9:12='enum',\<2>,1:9]
+[@3,13:12='\<EOF>',\<-1>,1:13]
+<! no 'm'-> transition...conflicts with pred !>
+s0-' '->:s5=>3
+s0-'a'->:s4=>2
+s0-'e'->:s1=>2
+:s1=>2-'n'->:s2=>2
+:s2=>2-'u'->:s3=>2
+:s4=>2-'b'->:s4=>2
+:s4=>2-'c'->:s4=>2<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+ENUM : 'enum' { <False()> }? ;
+ID : 'a'..'z'+ ;
+WS : (' '|'\n') -> skip;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalLexer/Indent.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalLexer/Indent.stg
new file mode 100644
index 000000000..42f3d6c36
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalLexer/Indent.stg
@@ -0,0 +1,48 @@
+TestType() ::= "Lexer"
+
+Options ::= [
+	"ShowDFA": true
+]
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+Input() ::= "abc<\n>  def  <\n>"
+
+ID() ::= "\<1>"
+INDENT() ::= "\<2>"
+NL() ::= "\<3>"
+WS() ::= "\<4>"
+
+Output() ::= <<
+<! action output !>
+INDENT
+<! tokens !>
+[@0,0:2='abc',<ID()>,1:0]
+[@1,3:3='\\n',<NL()>,1:3]
+[@2,4:5='  ',<INDENT()>,2:0]
+[@3,6:8='def',<ID()>,2:2]
+[@4,9:10='  ',<WS()>,2:5]
+[@5,11:11='\\n',<NL()>,2:7]
+[@6,12:11='\<EOF>',\<-1>,3:0]
+s0-'
+'->:s2=>3
+s0-'a'->:s1=>1
+s0-'d'->:s1=>1
+:s1=>1-'b'->:s1=>1
+:s1=>1-'c'->:s1=>1
+:s1=>1-'e'->:s1=>1
+:s1=>1-'f'->:s1=>1<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+ID : [a-z]+  ;
+INDENT : [ \t]+ { <TokenStartColumnEquals("0")> }?
+         { <writeln("\"INDENT\"")> }  ;
+NL : '\n';
+WS : [ \t]+ ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalLexer/Index.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalLexer/Index.stg
new file mode 100644
index 000000000..b6a907d6f
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalLexer/Index.stg
@@ -0,0 +1,9 @@
+TestTemplates ::= [
+	"DisableRule": [],
+	"IDvsEnum": [],
+	"IDnotEnum": [],
+	"EnumNotID": [],
+	"Indent": [],
+	"LexerInputPositionSensitivePredicates": [],
+	"PredicatedKeywords": []
+]
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalLexer/LexerInputPositionSensitivePredicates.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalLexer/LexerInputPositionSensitivePredicates.stg
new file mode 100644
index 000000000..b47d9ee4a
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalLexer/LexerInputPositionSensitivePredicates.stg
@@ -0,0 +1,34 @@
+TestType() ::= "Lexer"
+
+Options ::= [
+	"ShowDFA": true
+]
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+Input() ::= "a cde<\n>abcde<\n>"
+
+Output() ::= <<
+a
+cde
+ab
+cde
+[@0,0:0='a',\<1>,1:0]
+[@1,2:4='cde',\<2>,1:2]
+[@2,6:7='ab',\<1>,2:0]
+[@3,8:10='cde',\<2>,2:2]
+[@4,12:11='\<EOF>',\<-1>,3:0]<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+WORD1 : ID1+ { <Text():writeln()> } ;
+WORD2 : ID2+ { <Text():writeln()> } ;
+fragment ID1 : { <Column()> \< 2 }? [a-zA-Z];
+fragment ID2 : { <Column()> >= 2 }? [a-zA-Z];
+WS : (' '|'\n') -> skip;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalLexer/PredicatedKeywords.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalLexer/PredicatedKeywords.stg
new file mode 100644
index 000000000..79f19cd52
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalLexer/PredicatedKeywords.stg
@@ -0,0 +1,30 @@
+TestType() ::= "Lexer"
+
+Options ::= [
+	"ShowDFA": false
+]
+
+Grammar ::= [
+	"L": {<grammar("L")>}
+]
+
+Input() ::= "enum enu a"
+
+Output() ::= <<
+enum!
+ID enu
+ID a
+[@0,0:3='enum',\<1>,1:0]
+[@1,5:7='enu',\<2>,1:5]
+[@2,9:9='a',\<2>,1:9]
+[@3,10:9='\<EOF>',\<-1>,1:10]<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+lexer grammar <grammarName>;
+ENUM : [a-z]+ { <TextEquals("enum")> }? { <writeln("\"enum!\"")> } ;
+ID   : [a-z]+ { <PlusText("ID "):writeln()> } ;
+WS   : [ \n] -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/2UnpredicatedAlts.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/2UnpredicatedAlts.stg
new file mode 100644
index 000000000..9b635dee6
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/2UnpredicatedAlts.stg
@@ -0,0 +1,39 @@
+// We have n-2 predicates for n alternatives. pick first alt
+
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": true
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "x; y"
+
+Rule() ::= "s"
+
+Output() ::= <<
+alt 1
+alt 1<\n>
+>>
+
+Errors() ::= <<
+line 1:0 reportAttemptingFullContext d=0 (a), input='x'
+line 1:0 reportAmbiguity d=0 (a): ambigAlts={1, 2}, input='x'
+line 1:3 reportAttemptingFullContext d=0 (a), input='y'
+line 1:3 reportAmbiguity d=0 (a): ambigAlts={1, 2}, input='y'<\n>
+>>
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+s : {<LL_EXACT_AMBIG_DETECTION()>} a ';' a; // do 2x: once in ATN, next in DFA
+a : ID {<writeln("\"alt 1\"")>}
+  | ID {<writeln("\"alt 2\"")>}
+  | {<False()>}? ID {<writeln("\"alt 3\"")>}
+  ;
+ID : 'a'..'z'+ ;
+INT : '0'..'9'+;
+WS : (' '|'\n') -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/2UnpredicatedAltsAndOneOrthogonalAlt.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/2UnpredicatedAltsAndOneOrthogonalAlt.stg
new file mode 100644
index 000000000..fe96afe76
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/2UnpredicatedAltsAndOneOrthogonalAlt.stg
@@ -0,0 +1,39 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": true
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "34; x; y"
+
+Rule() ::= "s"
+
+Output() ::= <<
+alt 1
+alt 2
+alt 2<\n>
+>>
+
+Errors() ::= <<
+line 1:4 reportAttemptingFullContext d=0 (a), input='x'
+line 1:4 reportAmbiguity d=0 (a): ambigAlts={2, 3}, input='x'
+line 1:7 reportAttemptingFullContext d=0 (a), input='y'
+line 1:7 reportAmbiguity d=0 (a): ambigAlts={2, 3}, input='y'<\n>
+>>
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+s : {<LL_EXACT_AMBIG_DETECTION()>} a ';' a ';' a;
+a : INT {<writeln("\"alt 1\"")>}
+  | ID {<writeln("\"alt 2\"")>} // must pick this one for ID since pred is false
+  | ID {<writeln("\"alt 3\"")>}
+  | {<False()>}? ID {<writeln("\"alt 4\"")>}
+  ;
+ID : 'a'..'z'+ ;
+INT : '0'..'9'+;
+WS : (' '|'\n') -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/ActionHidesPreds.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/ActionHidesPreds.stg
new file mode 100644
index 000000000..749e6f31d
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/ActionHidesPreds.stg
@@ -0,0 +1,35 @@
+// can't see preds, resolves to first alt found (1 in this case)
+
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "x x y"
+
+Rule() ::= "s"
+
+Output() ::= <<
+alt 1
+alt 1
+alt 1<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+@members {<InitIntMember("i","0")>}
+s : a+ ;
+a : {<SetMember("i","1")>} ID {<MemberEquals("i","1")>}? {<writeln("\"alt 1\"")>}
+  | {<SetMember("i","2")>} ID {<MemberEquals("i","2")>}? {<writeln("\"alt 2\"")>}
+  ;
+ID : 'a'..'z'+ ;
+INT : '0'..'9'+;
+WS : (' '|'\n') -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/ActionsHidePredsInGlobalFOLLOW.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/ActionsHidePredsInGlobalFOLLOW.stg
new file mode 100644
index 000000000..f1ec9bc9f
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/ActionsHidePredsInGlobalFOLLOW.stg
@@ -0,0 +1,39 @@
+/** Regular non-forced actions can create side effects used by semantic
+ *  predicates and so we cannot evaluate any semantic predicate
+ *  encountered after having seen a regular action. This includes
+ *  during global follow operations.
+ */
+
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "a!"
+
+Rule() ::= "s"
+
+Output() ::= <<
+eval=true
+parse<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+@members {
+<Declare_pred()>
+}
+s : e {} {<True():Invoke_pred()>}? {<writeln("\"parse\"")>} '!' ;
+t : e {} {<False():Invoke_pred()>}? ID ;
+e : ID | ; // non-LL(1) so we use ATN
+ID : 'a'..'z'+ ;
+INT : '0'..'9'+;
+WS : (' '|'\n') -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/AtomWithClosureInTranslatedLRRule.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/AtomWithClosureInTranslatedLRRule.stg
new file mode 100644
index 000000000..80d27acf3
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/AtomWithClosureInTranslatedLRRule.stg
@@ -0,0 +1,32 @@
+/**
+ * This is a regression test for antlr/antlr4#196
+ * "element+ in expression grammar doesn't parse properly"
+ * https://github.com/antlr/antlr4/issues/196
+ */
+
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "a+b+a"
+
+Rule() ::= "start"
+
+Output() ::= ""
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+start : e[0] EOF;
+e[int _p]
+    :   ( 'a' | 'b'+ ) ( {3 >= $_p}? '+' e[4] )*
+    ;
+
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/DepedentPredsInGlobalFOLLOW.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/DepedentPredsInGlobalFOLLOW.stg
new file mode 100644
index 000000000..705de777c
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/DepedentPredsInGlobalFOLLOW.stg
@@ -0,0 +1,38 @@
+/** We cannot collect predicates that are dependent on local context if
+ *  we are doing a global follow. They appear as if they were not there at all.
+ */
+
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "a!"
+
+Rule() ::= "s"
+
+Output() ::= <<
+eval=true
+parse<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+@members {
+<Declare_pred()>
+}
+s : a[99] ;
+a[int i] : e {<ValEquals("$i","99"):Invoke_pred()>}? {<writeln("\"parse\"")>} '!' ;
+b[int i] : e {<ValEquals("$i","99"):Invoke_pred()>}? ID ;
+e : ID | ; // non-LL(1) so we use ATN
+ID : 'a'..'z'+ ;
+INT : '0'..'9'+;
+WS : (' '|'\n') -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/DependentPredNotInOuterCtxShouldBeIgnored.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/DependentPredNotInOuterCtxShouldBeIgnored.stg
new file mode 100644
index 000000000..29f2641bc
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/DependentPredNotInOuterCtxShouldBeIgnored.stg
@@ -0,0 +1,35 @@
+// uses ID ';' or ID '.' lookahead to solve s. preds not tested.
+
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "a;"
+
+Rule() ::= "s"
+
+Output() ::= <<
+alt 2<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+s : b[2] ';' |  b[2] '.' ; // decision in s drills down to ctx-dependent pred in a;
+b[int i] : a[i] ;
+a[int i]
+  : {<ValEquals("$i","1")>}? ID {<writeln("\"alt 1\"")>}
+    | {<ValEquals("$i","2")>}? ID {<writeln("\"alt 2\"")>}
+    ;
+ID : 'a'..'z'+ ;
+INT : '0'..'9'+;
+WS : (' '|'\n') -> skip ;
+
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/DisabledAlternative.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/DisabledAlternative.stg
new file mode 100644
index 000000000..d78e9e157
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/DisabledAlternative.stg
@@ -0,0 +1,31 @@
+/**
+ * This is a regression test for antlr/antlr4#218 "ANTLR4 EOF Related Bug".
+ * https://github.com/antlr/antlr4/issues/218
+ */
+
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "hello"
+
+Rule() ::= "cppCompilationUnit"
+
+Output() ::= <<
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+cppCompilationUnit : content+ EOF;
+content: anything | {<False()>}? .;
+anything: ANY_CHAR;
+ANY_CHAR: [_a-zA-Z0-9];
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/IndependentPredNotPassedOuterCtxToAvoidCastException.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/IndependentPredNotPassedOuterCtxToAvoidCastException.stg
new file mode 100644
index 000000000..715b0b754
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/IndependentPredNotPassedOuterCtxToAvoidCastException.stg
@@ -0,0 +1,32 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "a;"
+
+Rule() ::= "s"
+
+Output() ::= <<
+alt 2<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+s : b ';' |  b '.' ;
+b : a ;
+a
+  : {<False()>}? ID {<writeln("\"alt 1\"")>}
+  | {<True()>}? ID {<writeln("\"alt 2\"")>}
+ ;
+ID : 'a'..'z'+ ;
+INT : '0'..'9'+;
+WS : (' '|'\n') -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/Index.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/Index.stg
new file mode 100644
index 000000000..13af0390d
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/Index.stg
@@ -0,0 +1,28 @@
+TestTemplates ::= [
+	"SimpleValidate": [],
+	"SimpleValidate2": [],
+	"AtomWithClosureInTranslatedLRRule": [],
+	"ValidateInDFA": [],
+	"Simple": [],
+	"Order": [],
+	"2UnpredicatedAlts": [],
+	"2UnpredicatedAltsAndOneOrthogonalAlt": [],
+	"RewindBeforePredEval": [],
+	"NoTruePredsThrowsNoViableAlt": [],
+	"ToLeft": [],
+	"UnpredicatedPathsInAlt": [],
+	"ActionHidesPreds": [],
+	"ToLeftWithVaryingPredicate": [],
+	"PredicateDependentOnArg": [],
+	"PredicateDependentOnArg2": [],
+	"DependentPredNotInOuterCtxShouldBeIgnored": [],
+	"IndependentPredNotPassedOuterCtxToAvoidCastException": [],
+	"PredsInGlobalFOLLOW": [],
+	"DepedentPredsInGlobalFOLLOW": [],
+	"ActionsHidePredsInGlobalFOLLOW": [],
+	"PredTestedEvenWhenUnAmbig_1": [],
+	"PredTestedEvenWhenUnAmbig_2": [],
+	"DisabledAlternative": [],
+	"PredFromAltTestedInLoopBack_1": [],
+	"PredFromAltTestedInLoopBack_2": []
+]
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/NoTruePredsThrowsNoViableAlt.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/NoTruePredsThrowsNoViableAlt.stg
new file mode 100644
index 000000000..7114684cf
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/NoTruePredsThrowsNoViableAlt.stg
@@ -0,0 +1,34 @@
+// checks that we throw exception if all alts
+// are covered with a predicate and none succeeds
+
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "y 3 x 4"
+
+Rule() ::= "s"
+
+Output() ::= <<
+>>
+
+Errors() ::= <<
+line 1:0 no viable alternative at input 'y'<\n>
+>>
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+s : a a;
+a : {<False()>}? ID INT {<writeln("\"alt 1\"")>}
+  | {<False()>}? ID INT {<writeln("\"alt 2\"")>}
+  ;
+ID : 'a'..'z'+ ;
+INT : '0'..'9'+;
+WS : (' '|'\n') -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/Order.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/Order.stg
new file mode 100644
index 000000000..4837a3a78
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/Order.stg
@@ -0,0 +1,37 @@
+// Under new predicate ordering rules (see antlr/antlr4#29), the first
+// alt with an acceptable config (unpredicated, or predicated and evaluates
+// to true) is chosen.
+
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "x y"
+
+Rule() ::= "s"
+
+Output() ::= <<
+alt 1
+alt 1<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+s : a {} a; // do 2x: once in ATN, next in DFA;
+// action blocks lookahead from falling off of 'a'
+// and looking into 2nd 'a' ref. !ctx dependent pred
+a : ID {<writeln("\"alt 1\"")>}
+  | {<True()>}?  ID {<writeln("\"alt 2\"")>}
+  ;
+ID : 'a'..'z'+ ;
+INT : '0'..'9'+;
+WS : (' '|'\n') -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/PredFromAltTestedInLoopBack.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/PredFromAltTestedInLoopBack.stg
new file mode 100644
index 000000000..2ce868b63
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/PredFromAltTestedInLoopBack.stg
@@ -0,0 +1,25 @@
+/** Loopback doesn't eval predicate at start of alt */
+
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": true
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Rule() ::= "file_"
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+file_
+@after {<ToStringTree("$ctx"):writeln()>}
+  : para para EOF ;
+para: paraContent NL NL ;
+paraContent : ('s'|'x'|{<LANotEquals("2",{<grammarName>Parser.NL})>}? NL)+ ;
+NL : '\n' ;
+s : 's' ;
+X : 'x' ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/PredFromAltTestedInLoopBack_1.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/PredFromAltTestedInLoopBack_1.stg
new file mode 100644
index 000000000..d28d02c1c
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/PredFromAltTestedInLoopBack_1.stg
@@ -0,0 +1,12 @@
+import "PredFromAltTestedInLoopBack.stg"
+
+Input() ::= "s<\n><\n><\n>x<\n>"
+
+Output() ::= <<
+(file_ (para (paraContent s) \n \n) (para (paraContent \n x \n)) \<EOF>)<\n>
+>>
+
+Errors() ::= <<
+line 5:0 mismatched input '\<EOF>' expecting '
+'<\n>
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/PredFromAltTestedInLoopBack_2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/PredFromAltTestedInLoopBack_2.stg
new file mode 100644
index 000000000..f77ec7080
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/PredFromAltTestedInLoopBack_2.stg
@@ -0,0 +1,9 @@
+import "PredFromAltTestedInLoopBack.stg"
+
+Input() ::= "s<\n><\n><\n>x<\n><\n>"
+
+Output() ::= <<
+(file_ (para (paraContent s) \n \n) (para (paraContent \n x) \n \n) \<EOF>)<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/PredTestedEvenWhenUnAmbig.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/PredTestedEvenWhenUnAmbig.stg
new file mode 100644
index 000000000..13b3f1f2d
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/PredTestedEvenWhenUnAmbig.stg
@@ -0,0 +1,22 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Rule() ::= "primary"
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+@members {<InitBooleanMember("enumKeyword",True())>}
+primary
+    :   ID {<writeln("\"ID \"+$ID.text")>}
+    |   {<GetMember("enumKeyword"):Not()>}? 'enum' {<writeln("\"enum\"")>}
+    ;
+ID : [a-z]+ ;
+WS : [ \t\n\r]+ -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/PredTestedEvenWhenUnAmbig_1.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/PredTestedEvenWhenUnAmbig_1.stg
new file mode 100644
index 000000000..dc0698d38
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/PredTestedEvenWhenUnAmbig_1.stg
@@ -0,0 +1,9 @@
+import "PredTestedEvenWhenUnAmbig.stg"
+
+Input() ::= "abc"
+
+Output() ::= <<
+ID abc<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/PredTestedEvenWhenUnAmbig_2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/PredTestedEvenWhenUnAmbig_2.stg
new file mode 100644
index 000000000..e8c185bad
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/PredTestedEvenWhenUnAmbig_2.stg
@@ -0,0 +1,10 @@
+import "PredTestedEvenWhenUnAmbig.stg"
+
+Input() ::= "enum"
+
+Output() ::= <<
+>>
+
+Errors() ::= <<
+line 1:0 no viable alternative at input 'enum'<\n>
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/PredicateDependentOnArg.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/PredicateDependentOnArg.stg
new file mode 100644
index 000000000..19173ed2d
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/PredicateDependentOnArg.stg
@@ -0,0 +1,40 @@
+/**
+ * In this case, we're passing a parameter into a rule that uses that
+ * information to predict the alternatives. This is the special case
+ * where we know exactly which context we are in. The context stack
+ * is empty and we have not dipped into the outer context to make a decision.
+ */
+
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "a b"
+
+Rule() ::= "s"
+
+Output() ::= <<
+alt 2
+alt 1<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+@members {<InitIntMember("i","0")>}
+s : a[2] a[1];
+a[int i]
+  : {<ValEquals("$i","1")>}? ID {<writeln("\"alt 1\"")>}
+  | {<ValEquals("$i","2")>}? ID {<writeln("\"alt 2\"")>}
+  ;
+ID : 'a'..'z'+ ;
+INT : '0'..'9'+;
+WS : (' '|'\n') -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/PredicateDependentOnArg2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/PredicateDependentOnArg2.stg
new file mode 100644
index 000000000..c092804e5
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/PredicateDependentOnArg2.stg
@@ -0,0 +1,42 @@
+/**
+ * In this case, we have to ensure that the predicates are not tested
+ * during the closure after recognizing the 1st ID. The closure will
+ * fall off the end of 'a' 1st time and reach into the a[1] rule
+ * invocation. It should not execute predicates because it does not know
+ * what the parameter is. The context stack will not be empty and so
+ * they should be ignored. It will not affect recognition, however. We
+ * are really making sure the ATN simulation doesn't crash with context
+ * object issues when it encounters preds during FOLLOW.
+ */
+
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "a b"
+
+Rule() ::= "s"
+
+Output() ::= <<
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+@members {<InitIntMember("i","0")>}
+s : a[2] a[1];
+a[int i]
+  : {<ValEquals("$i","1")>}? ID 
+  | {<ValEquals("$i","2")>}? ID 
+  ;
+ID : 'a'..'z'+ ;
+INT : '0'..'9'+;
+WS : (' '|'\n') -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/PredsInGlobalFOLLOW.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/PredsInGlobalFOLLOW.stg
new file mode 100644
index 000000000..f12acd023
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/PredsInGlobalFOLLOW.stg
@@ -0,0 +1,38 @@
+/** During a global follow operation, we still collect semantic
+ *  predicates as long as they are not dependent on local context
+ */
+
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "a!"
+
+Rule() ::= "s"
+
+Output() ::= <<
+eval=true
+<! now we are parsing !>
+parse<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+@members {
+<Declare_pred()>
+}
+s : e {<True():Invoke_pred()>}? {<writeln("\"parse\"")>} '!' ;
+t : e {<False():Invoke_pred()>}? ID ;
+e : ID | ; // non-LL(1) so we use ATN
+ID : 'a'..'z'+ ;
+INT : '0'..'9'+;
+WS : (' '|'\n') -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/RewindBeforePredEval.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/RewindBeforePredEval.stg
new file mode 100644
index 000000000..f50048962
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/RewindBeforePredEval.stg
@@ -0,0 +1,35 @@
+// The parser consumes ID and moves to the 2nd token INT.
+// To properly evaluate the predicates after matching ID INT,
+// we must correctly see come back to starting index so LT(1) works
+
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "y 3 x 4"
+
+Rule() ::= "s"
+
+Output() ::= <<
+alt 2
+alt 1<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+s : a a;
+a : {<LTEquals("1", "\"x\"")>}? ID INT {<writeln("\"alt 1\"")>}
+  | {<LTEquals("1", "\"y\"")>}? ID INT {<writeln("\"alt 2\"")>}
+  ;
+ID : 'a'..'z'+ ;
+INT : '0'..'9'+;
+WS : (' '|'\n') -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/Simple.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/Simple.stg
new file mode 100644
index 000000000..c2ef0ac30
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/Simple.stg
@@ -0,0 +1,33 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "x y 3"
+
+Rule() ::= "s"
+
+Output() ::= <<
+alt 2
+alt 2
+alt 3<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+s : a a a; // do 3x: once in ATN, next in DFA then INT in ATN
+a : {<False()>}? ID {<writeln("\"alt 1\"")>}
+  | {<True()>}?  ID {<writeln("\"alt 2\"")>}
+  | INT         {<writeln("\"alt 3\"")>}
+  ;
+ID : 'a'..'z'+ ;
+INT : '0'..'9'+;
+WS : (' '|'\n') -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/SimpleValidate.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/SimpleValidate.stg
new file mode 100644
index 000000000..b0d67c9f6
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/SimpleValidate.stg
@@ -0,0 +1,30 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "x"
+
+Rule() ::= "s"
+
+Output() ::= ""
+
+Errors() ::= <<
+line 1:0 no viable alternative at input 'x'<\n>
+>>
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+s : a ;
+a : {<False()>}? ID  {<writeln("\"alt 1\"")>}
+  | {<True()>}?  INT {<writeln("\"alt 2\"")>}
+  ;
+ID : 'a'..'z'+ ;
+INT : '0'..'9'+;
+WS : (' '|'\n') -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/SimpleValidate2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/SimpleValidate2.stg
new file mode 100644
index 000000000..901d344dd
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/SimpleValidate2.stg
@@ -0,0 +1,33 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "3 4 x"
+
+Rule() ::= "s"
+
+Output() ::= <<
+alt 2
+alt 2<\n>
+>>
+
+Errors() ::= <<
+line 1:4 no viable alternative at input 'x'<\n>
+>>
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+s : a a a;
+a : {<False()>}? ID  {<writeln("\"alt 1\"")>}
+  | {<True()>}?  INT {<writeln("\"alt 2\"")>}
+  ;
+ID : 'a'..'z'+ ;
+INT : '0'..'9'+;
+WS : (' '|'\n') -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/ToLeft.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/ToLeft.stg
new file mode 100644
index 000000000..bdf34f315
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/ToLeft.stg
@@ -0,0 +1,32 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "x x y"
+
+Rule() ::= "s"
+
+Output() ::= <<
+alt 2
+alt 2
+alt 2<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+	s : a+ ;
+a : {<False()>}? ID {<writeln("\"alt 1\"")>}
+  | {<True()>}?  ID {<writeln("\"alt 2\"")>}
+  ;
+ID : 'a'..'z'+ ;
+INT : '0'..'9'+;
+WS : (' '|'\n') -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/ToLeftWithVaryingPredicate.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/ToLeftWithVaryingPredicate.stg
new file mode 100644
index 000000000..abc856745
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/ToLeftWithVaryingPredicate.stg
@@ -0,0 +1,43 @@
+/** In this case, we use predicates that depend on global information
+ *  like we would do for a symbol table. We simply execute
+ *  the predicates assuming that all necessary information is available.
+ *  The i++ action is done outside of the prediction and so it is executed.
+ */
+
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "x x y"
+
+Rule() ::= "s"
+
+Output() ::= <<
+i=1
+alt 2
+i=2
+alt 1
+i=3
+alt 2<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+@members {<InitIntMember("i","0")>}
+s : ({<AddMember("i","1")>
+<PlusMember("\"i=\"","i"):writeln()>} a)+ ;
+a : {<ModMemberEquals("i","2","0")>}? ID {<writeln("\"alt 1\"")>}
+  | {<ModMemberNotEquals("i","2","0")>}? ID {<writeln("\"alt 2\"")>}
+  ;
+ID : 'a'..'z'+ ;
+INT : '0'..'9'+;
+WS : (' '|'\n') -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/UnpredicatedPathsInAlt.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/UnpredicatedPathsInAlt.stg
new file mode 100644
index 000000000..baa024f09
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/UnpredicatedPathsInAlt.stg
@@ -0,0 +1,34 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "x 4"
+
+Rule() ::= "s"
+
+Output() ::= <<
+alt 1<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+s : a {<writeln("\"alt 1\"")>}
+  | b {<writeln("\"alt 2\"")>}
+  ;
+a : {<False()>}? ID INT
+  | ID INT
+  ;
+b : ID ID
+  ;
+ID : 'a'..'z'+ ;
+INT : '0'..'9'+;
+WS : (' '|'\n') -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/ValidateInDFA.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/ValidateInDFA.stg
new file mode 100644
index 000000000..e37b031b3
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/SemPredEvalParser/ValidateInDFA.stg
@@ -0,0 +1,35 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "x ; y"
+
+Rule() ::= "s"
+
+Output() ::= <<
+>>
+
+Errors() ::= <<
+line 1:0 no viable alternative at input 'x'
+line 1:4 no viable alternative at input 'y'<\n>
+>>
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+s : a ';' a;
+// ';' helps us to resynchronize without consuming
+// 2nd 'a' reference. We our testing that the DFA also
+// throws an exception if the validating predicate fails
+a : {<False()>}? ID  {<writeln("\"alt 1\"")>}
+  | {<True()>}?  INT {<writeln("\"alt 2\"")>}
+  ;
+ID : 'a'..'z'+ ;
+INT : '0'..'9'+;
+WS : (' '|'\n') -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/CharSetLiteral.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/CharSetLiteral.stg
new file mode 100644
index 000000000..be8fd5251
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/CharSetLiteral.stg
@@ -0,0 +1,29 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "A a B b"
+
+Rule() ::= "a"
+
+Output() ::= <<
+A
+a
+B
+b<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a : (A {<writeln("$A.text")>})+ ;
+A : [AaBb] ;
+WS : (' '|'\n')+ -> skip ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/ComplementSet.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/ComplementSet.stg
new file mode 100644
index 000000000..20e8decf1
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/ComplementSet.stg
@@ -0,0 +1,26 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "a"
+
+Rule() ::= "parse"
+
+Output() ::= ""
+
+Errors() ::= <<
+line 1:0 token recognition error at: 'a'
+line 1:1 missing {} at '\<EOF>'<\n>
+>>
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+parse : ~NEW_LINE;
+NEW_LINE: '\\r'? '\\n';
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/Index.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/Index.stg
new file mode 100644
index 000000000..57bf5008c
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/Index.stg
@@ -0,0 +1,25 @@
+TestTemplates ::= [
+	"SeqDoesNotBecomeSet": [],
+	"ParserSet": [],
+	"ParserNotSet": [],
+	"ParserNotToken": [],
+	"ParserNotTokenWithLabel": [],
+	"RuleAsSet": [],
+	"NotChar": [],
+	"OptionalSingleElement": [],
+	"OptionalLexerSingleElement": [],
+	"StarLexerSingleElement_1": [],
+	"StarLexerSingleElement_2": [],
+	"PlusLexerSingleElement": [],
+	"OptionalSet": [],
+	"StarSet": [],
+	"PlusSet": [],
+	"LexerOptionalSet": [],
+	"LexerStarSet": [],
+	"LexerPlusSet": [],
+	"NotCharSet": [],
+	"NotCharSetWithLabel": [],
+	"NotCharSetWithRuleRef3": [],
+	"CharSetLiteral": [],
+	"ComplementSet": []
+]
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/LexerOptionalSet.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/LexerOptionalSet.stg
new file mode 100644
index 000000000..a8949c5f2
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/LexerOptionalSet.stg
@@ -0,0 +1,25 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "ac"
+
+Rule() ::= "a"
+
+Output() ::= <<
+ac<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a : A {<InputText():writeln()>} ;
+A : ('a'|'b')? 'c' ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/LexerPlusSet.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/LexerPlusSet.stg
new file mode 100644
index 000000000..c29de8848
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/LexerPlusSet.stg
@@ -0,0 +1,25 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "abaac"
+
+Rule() ::= "a"
+
+Output() ::= <<
+abaac<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a : A {<InputText():writeln()>} ;
+A : ('a'|'b')+ 'c' ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/LexerStarSet.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/LexerStarSet.stg
new file mode 100644
index 000000000..df720c8fc
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/LexerStarSet.stg
@@ -0,0 +1,25 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "abaac"
+
+Rule() ::= "a"
+
+Output() ::= <<
+abaac<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a : A {<InputText():writeln()>} ;
+A : ('a'|'b')* 'c' ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/NotChar.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/NotChar.stg
new file mode 100644
index 000000000..af2d766b4
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/NotChar.stg
@@ -0,0 +1,25 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "x"
+
+Rule() ::= "a"
+
+Output() ::= <<
+x<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a : A {<writeln("$A.text")>} ;
+A : ~'b' ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/NotCharSet.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/NotCharSet.stg
new file mode 100644
index 000000000..e34b8513d
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/NotCharSet.stg
@@ -0,0 +1,25 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "x"
+
+Rule() ::= "a"
+
+Output() ::= <<
+x<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a : A {<writeln("$A.text")>} ;
+A : ~('b'|'c') ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/NotCharSetWithLabel.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/NotCharSetWithLabel.stg
new file mode 100644
index 000000000..6eba1c059
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/NotCharSetWithLabel.stg
@@ -0,0 +1,25 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "x"
+
+Rule() ::= "a"
+
+Output() ::= <<
+x<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a : A {<writeln("$A.text")>} ;
+A : h=~('b'|'c') ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/NotCharSetWithRuleRef3.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/NotCharSetWithRuleRef3.stg
new file mode 100644
index 000000000..5cb3e2320
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/NotCharSetWithRuleRef3.stg
@@ -0,0 +1,27 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "x"
+
+Rule() ::= "a"
+
+Output() ::= <<
+x<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a : A {<writeln("$A.text")>} ;
+A : ('a'|B) ;  // this doesn't collapse to set but works
+fragment
+B : ~('a'|'c') ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/OptionalLexerSingleElement.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/OptionalLexerSingleElement.stg
new file mode 100644
index 000000000..07244f1a9
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/OptionalLexerSingleElement.stg
@@ -0,0 +1,25 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "bc"
+
+Rule() ::= "a"
+
+Output() ::= <<
+bc<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a : A {<InputText():writeln()>} ;
+A : 'b'? 'c' ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/OptionalSet.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/OptionalSet.stg
new file mode 100644
index 000000000..05a11faef
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/OptionalSet.stg
@@ -0,0 +1,24 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "ac"
+
+Rule() ::= "a"
+
+Output() ::= <<
+ac<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a : ('a'|'b')? 'c' {<InputText():writeln()>} ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/OptionalSingleElement.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/OptionalSingleElement.stg
new file mode 100644
index 000000000..0ad43557a
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/OptionalSingleElement.stg
@@ -0,0 +1,25 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "bc"
+
+Rule() ::= "a"
+
+Output() ::= <<
+bc<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a : A? 'c' {<InputText():writeln()>} ;
+A : 'b' ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/ParserNotSet.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/ParserNotSet.stg
new file mode 100644
index 000000000..44fd61f9a
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/ParserNotSet.stg
@@ -0,0 +1,24 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "zz"
+
+Rule() ::= "a"
+
+Output() ::= <<
+z<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a : t=~('x'|'y') 'z' {<writeln("$t.text")>} ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/ParserNotToken.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/ParserNotToken.stg
new file mode 100644
index 000000000..05b807cdf
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/ParserNotToken.stg
@@ -0,0 +1,24 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "zz"
+
+Rule() ::= "a"
+
+Output() ::= <<
+zz<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a : ~'x' 'z' {<InputText():writeln()>} ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/ParserNotTokenWithLabel.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/ParserNotTokenWithLabel.stg
new file mode 100644
index 000000000..ff1916d46
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/ParserNotTokenWithLabel.stg
@@ -0,0 +1,24 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "zz"
+
+Rule() ::= "a"
+
+Output() ::= <<
+z<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a : t=~'x' 'z' {<writeln("$t.text")>} ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/ParserSet.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/ParserSet.stg
new file mode 100644
index 000000000..6abc15c48
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/ParserSet.stg
@@ -0,0 +1,24 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "x"
+
+Rule() ::= "a"
+
+Output() ::= <<
+x<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a : t=('x'|'y') {<writeln("$t.text")>} ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/PlusLexerSingleElement.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/PlusLexerSingleElement.stg
new file mode 100644
index 000000000..cf63c60f7
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/PlusLexerSingleElement.stg
@@ -0,0 +1,25 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "bbbbc"
+
+Rule() ::= "a"
+
+Output() ::= <<
+bbbbc<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a : A {<InputText():writeln()>} ;
+A : 'b'+ 'c' ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/PlusSet.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/PlusSet.stg
new file mode 100644
index 000000000..c73ea787c
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/PlusSet.stg
@@ -0,0 +1,24 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "abaac"
+
+Rule() ::= "a"
+
+Output() ::= <<
+abaac<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a : ('a'|'b')+ 'c' {<InputText():writeln()>} ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/RuleAsSet.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/RuleAsSet.stg
new file mode 100644
index 000000000..42e2da2d2
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/RuleAsSet.stg
@@ -0,0 +1,24 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "b"
+
+Rule() ::= "a"
+
+Output() ::= <<
+b<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a @after {<InputText():writeln()>} : 'a' | 'b' |'c' ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/SeqDoesNotBecomeSet.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/SeqDoesNotBecomeSet.stg
new file mode 100644
index 000000000..5acd72f33
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/SeqDoesNotBecomeSet.stg
@@ -0,0 +1,30 @@
+// this must return A not I to the parser; calling a nonfragment rule
+// from a nonfragment rule does not set the overall token.
+
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "34"
+
+Rule() ::= "a"
+
+Output() ::= <<
+34<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a : C {<InputText():writeln()>} ;
+fragment A : '1' | '2';
+fragment B : '3' '4';
+C : A | B;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/StarLexerSingleElement.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/StarLexerSingleElement.stg
new file mode 100644
index 000000000..b8789f04d
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/StarLexerSingleElement.stg
@@ -0,0 +1,17 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Rule() ::= "a"
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a : A {<InputText():writeln()>} ;
+A : 'b'* 'c' ;
+>>
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/StarLexerSingleElement_1.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/StarLexerSingleElement_1.stg
new file mode 100644
index 000000000..341453e4d
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/StarLexerSingleElement_1.stg
@@ -0,0 +1,9 @@
+import "StarLexerSingleElement.stg"
+
+Input() ::= "bbbbc"
+
+Output() ::= <<
+bbbbc<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/StarLexerSingleElement_2.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/StarLexerSingleElement_2.stg
new file mode 100644
index 000000000..3cc52471f
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/StarLexerSingleElement_2.stg
@@ -0,0 +1,9 @@
+import "StarLexerSingleElement.stg"
+
+Input() ::= "c"
+
+Output() ::= <<
+c<\n>
+>>
+
+Errors() ::= ""
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/StarSet.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/StarSet.stg
new file mode 100644
index 000000000..3273c59ab
--- /dev/null
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Sets/StarSet.stg
@@ -0,0 +1,24 @@
+TestType() ::= "Parser"
+
+Options ::= [
+	"Debug": false
+]
+
+Grammar ::= [
+	"T": {<grammar("T")>}
+]
+
+Input() ::= "abaac"
+
+Rule() ::= "a"
+
+Output() ::= <<
+abaac<\n>
+>>
+
+Errors() ::= ""
+
+grammar(grammarName) ::= <<
+grammar <grammarName>;
+a : ('a'|'b')* 'c' {<InputText():writeln()>} ;
+>>
diff --git a/runtime-testsuite/src/org/antlr/v4/testgen/JavaEscapeStringMap.java b/runtime-testsuite/src/org/antlr/v4/testgen/JavaEscapeStringMap.java
new file mode 100644
index 000000000..30ac5f309
--- /dev/null
+++ b/runtime-testsuite/src/org/antlr/v4/testgen/JavaEscapeStringMap.java
@@ -0,0 +1,87 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2015 Terence Parr
+ *  Copyright (c) 2015 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.
+ */
+package org.antlr.v4.testgen;
+
+import java.util.AbstractMap;
+import java.util.Collections;
+import java.util.Set;
+
+/**
+ *
+ * @author Sam Harwell
+ */
+public class JavaEscapeStringMap extends AbstractMap<String, Object> {
+
+	@Override
+	public Object get(Object key) {
+		if (key instanceof String) {
+			String str = (String)key;
+			StringBuilder builder = new StringBuilder(str.length());
+			for (int i = 0; i < str.length(); i++) {
+				switch (str.charAt(i)) {
+				case '\\':
+					builder.append("\\\\");
+					break;
+
+				case '\r':
+					// normalize \r\n to just \n
+					break;
+
+				case '\n':
+					builder.append("\\n");
+					break;
+
+				case '"':
+					builder.append("\\\"");
+					break;
+
+				default:
+					builder.append(str.charAt(i));
+					break;
+				}
+			}
+
+			return builder.toString();
+		}
+
+		return super.get(key);
+	}
+
+	@Override
+	public boolean containsKey(Object key) {
+		return key instanceof String;
+	}
+
+	@Override
+	public Set<Entry<String, Object>> entrySet() {
+		return Collections.emptySet();
+	}
+
+}
diff --git a/runtime-testsuite/src/org/antlr/v4/testgen/LinesStringMap.java b/runtime-testsuite/src/org/antlr/v4/testgen/LinesStringMap.java
new file mode 100644
index 000000000..2dc6d66aa
--- /dev/null
+++ b/runtime-testsuite/src/org/antlr/v4/testgen/LinesStringMap.java
@@ -0,0 +1,80 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2015 Terence Parr
+ *  Copyright (c) 2015 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.
+ */
+package org.antlr.v4.testgen;
+
+import java.util.AbstractMap;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Set;
+
+/**
+ *
+ * @author Sam Harwell
+ */
+public class LinesStringMap extends AbstractMap<String, Object> {
+
+	@Override
+	public Object get(Object key) {
+		if (key instanceof String) {
+			String str = (String)key;
+			if (str.isEmpty()) {
+				return Collections.singletonList(str);
+			}
+
+			ArrayList<String> result = new ArrayList<String>();
+			int startIndex = 0;
+			while (startIndex < str.length()) {
+				int endIndex = str.indexOf('\n', startIndex);
+				if (endIndex < 0) {
+					result.add(str.substring(startIndex));
+					break;
+				}
+
+				result.add(str.substring(startIndex, endIndex + 1));
+				startIndex = endIndex + 1;
+			}
+
+			return result;
+		}
+
+		return super.get(key);
+	}
+
+	@Override
+	public boolean containsKey(Object key) {
+		return key instanceof String;
+	}
+
+	@Override
+	public Set<Entry<String, Object>> entrySet() {
+		return Collections.emptySet();
+	}
+
+}
diff --git a/runtime-testsuite/src/org/antlr/v4/testgen/STGroupModelAdaptor.java b/runtime-testsuite/src/org/antlr/v4/testgen/STGroupModelAdaptor.java
new file mode 100644
index 000000000..5b03792d1
--- /dev/null
+++ b/runtime-testsuite/src/org/antlr/v4/testgen/STGroupModelAdaptor.java
@@ -0,0 +1,70 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2015 Terence Parr
+ *  Copyright (c) 2015 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.
+ */
+package org.antlr.v4.testgen;
+
+import org.stringtemplate.v4.Interpreter;
+import org.stringtemplate.v4.ModelAdaptor;
+import org.stringtemplate.v4.ST;
+import org.stringtemplate.v4.STGroup;
+import org.stringtemplate.v4.misc.STNoSuchPropertyException;
+
+/**
+ *
+ * @author sam
+ */
+public class STGroupModelAdaptor implements ModelAdaptor {
+
+	@Override
+	public Object getProperty(Interpreter interp, ST self, Object o, Object property, String propertyName) throws STNoSuchPropertyException {
+		STGroup group = (STGroup)o;
+		if (group.isDictionary(propertyName)) {
+			return group.rawGetDictionary(propertyName);
+		}
+
+		ST template = group.getInstanceOf(propertyName);
+		if (template != null) {
+			return template;
+		}
+
+		if ("name".equalsIgnoreCase(propertyName)) {
+			return group.getName();
+		}
+
+		for (STGroup importedGroup : group.getImportedGroups()) {
+			Object result = getProperty(interp, self, importedGroup, property, propertyName);
+			if (result != null) {
+				return result;
+			}
+		}
+
+		return null;
+	}
+
+}
diff --git a/runtime-testsuite/src/org/antlr/v4/testgen/StrlenStringMap.java b/runtime-testsuite/src/org/antlr/v4/testgen/StrlenStringMap.java
new file mode 100644
index 000000000..33caa1fba
--- /dev/null
+++ b/runtime-testsuite/src/org/antlr/v4/testgen/StrlenStringMap.java
@@ -0,0 +1,62 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2015 Terence Parr
+ *  Copyright (c) 2015 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.
+ */
+package org.antlr.v4.testgen;
+
+import java.util.AbstractMap;
+import java.util.Collections;
+import java.util.Set;
+
+/**
+ *
+ * @author Sam Harwell
+ */
+public class StrlenStringMap extends AbstractMap<String, Object> {
+
+	@Override
+	public Object get(Object key) {
+		if (key instanceof String) {
+			String str = (String)key;
+			return str.length();
+		}
+
+		return super.get(key);
+	}
+
+	@Override
+	public boolean containsKey(Object key) {
+		return key instanceof String;
+	}
+
+	@Override
+	public Set<Entry<String, Object>> entrySet() {
+		return Collections.emptySet();
+	}
+
+}
diff --git a/runtime-testsuite/src/org/antlr/v4/testgen/TestGenerator.java b/runtime-testsuite/src/org/antlr/v4/testgen/TestGenerator.java
new file mode 100644
index 000000000..84460ca57
--- /dev/null
+++ b/runtime-testsuite/src/org/antlr/v4/testgen/TestGenerator.java
@@ -0,0 +1,303 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2015 Terence Parr
+ *  Copyright (c) 2015 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.
+ */
+package org.antlr.v4.testgen;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStreamWriter;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+import org.stringtemplate.v4.ST;
+import org.stringtemplate.v4.STGroup;
+import org.stringtemplate.v4.STGroupFile;
+import org.stringtemplate.v4.gui.STViz;
+
+public class TestGenerator {
+	
+	public final static String[] targets = {"CSharp", "Java", "Python2", "Python3", "JavaScript/Node", "JavaScript/Safari", "JavaScript/Firefox", "JavaScript/Explorer", "JavaScript/Chrome"};
+
+	/** Execute from antlr4 root dir:
+	 * *
+	 * $ java TestGenerator -o output-root-dir -templates -viz
+	 *
+	 * Example:
+	 *
+	 * $ java org.antlr.v4.testgen.TestGenerator -root /Users/parrt/antlr/code/antlr4
+	 */
+	public static void main(String[] args) {
+		String rootDir = null;
+		String outDir = null;
+		String templatesRoot = null;
+		String target = "ALL";
+		boolean browsers = false;
+		boolean viz = false;
+
+		int i = 0;
+		while (args != null && i < args.length) {
+			String arg = args[i];
+			if (arg.startsWith("-root")) {
+				i++;
+				rootDir = args[i];
+			}
+			else if (arg.startsWith("-outdir")) {
+				i++;
+				outDir = args[i];
+			}
+			else if (arg.startsWith("-templates")) {
+				i++;
+				templatesRoot = args[i];
+			}
+			else if (arg.startsWith("-target")) {
+				i++;
+				target = args[i];
+			}
+			else if (arg.startsWith("-browsers")) {
+				browsers = true;
+			}
+			else if (arg.startsWith("-viz")) {
+				viz = true;
+			}
+			i++;
+		}
+		
+		System.out.println("rootDir = " + rootDir);
+		System.out.println("outputDir = " + outDir);
+		System.out.println("templates = " + templatesRoot);
+		System.out.println("target = " + target);
+		System.out.println("browsers = " + browsers);
+		System.out.println("viz = " + viz);
+		
+		if(rootDir==null) {
+			System.out.println("rootDir is mandatory!" + rootDir);
+			return;
+		}
+		if(outDir==null)
+			outDir = rootDir + "/test";
+			
+		if(templatesRoot==null)
+			templatesRoot = rootDir + "/resources/org/antlr/v4/test/runtime/templates";
+
+		if ( "ALL".equalsIgnoreCase(target)) {
+			genAllTargets(rootDir, outDir, templatesRoot, browsers, viz);
+		} else
+			genTarget(rootDir, outDir, target, templatesRoot, viz);
+	}
+
+	public static void genAllTargets(String rootDir, String outDirRoot, String templatesRoot, boolean browsers, boolean viz) {
+		for(String target : targets) {
+			if(!browsers && "JavaScript/Safari".equals(target))
+				return;
+			genTarget(rootDir, outDirRoot, target, templatesRoot, viz);
+		}
+	}
+	
+	public static void genTarget(final String rootDir, final String outDir, final String fullTarget, final String templatesDir, boolean viz) {
+		String[] parts = fullTarget.split("/");
+		String target = parts[0];
+		String subTarget = parts.length>1 ? parts[1] : target;
+		String targetPackage = rootDir + "/resources/org/antlr/v4/test/runtime/" + fullTarget.toLowerCase();
+		String targetTemplate = targetPackage + "/" + subTarget + ".test.stg";
+		TestGenerator gen = new TestGenerator("UTF-8",
+					fullTarget,
+					rootDir,
+					new File(outDir),
+					new File(templatesDir),
+					new File(targetTemplate),
+					viz);
+		gen.info("Generating target " + gen.getTargetName());
+		gen.execute();
+	}
+
+	// This project uses UTF-8, but the plugin might be used in another project
+	// which is not. Always load templates with UTF-8, but write using the
+	// specified encoding.
+	protected final String encoding;
+	protected final String targetName;
+	protected final String rootDir;
+	protected final File outputDir;
+	protected final File testTemplates;
+	protected final File runtimeTemplate;
+	protected final boolean visualize;
+
+	public TestGenerator(String encoding, String targetName, String rootDir, File outputDir, File testTemplates, File runtimeTemplate, boolean visualize) {
+		this.encoding = encoding;
+		this.targetName = targetName;
+		this.rootDir = rootDir;
+		this.outputDir = outputDir;
+		this.testTemplates = testTemplates;
+		this.runtimeTemplate = runtimeTemplate;
+		this.visualize = visualize;
+	}
+
+	private String getTargetName() {
+		return targetName;
+	}
+
+
+	public void execute() {
+		STGroup targetGroup = new STGroupFile(runtimeTemplate.getPath());
+		targetGroup.registerModelAdaptor(STGroup.class, new STGroupModelAdaptor());
+		targetGroup.defineDictionary("escape", new JavaEscapeStringMap());
+		targetGroup.defineDictionary("lines", new LinesStringMap());
+		targetGroup.defineDictionary("strlen", new StrlenStringMap());
+		generateCodeForFoldersInIndex(targetGroup);
+	}
+
+	protected void generateCodeForFoldersInIndex(STGroup targetGroup) {
+		File targetFolder = getOutputDir(testTemplates+"");
+		STGroup index = new STGroupFile(testTemplates+"/Index.stg");
+		index.load(); // make sure the index group is loaded since we call rawGetDictionary
+		Map<String, Object> folders = index.rawGetDictionary("TestFolders");
+		if (folders != null) {
+			for (String key : folders.keySet()) {
+				final String testDir = testTemplates + "/" + key;
+				STGroup testIndex = new STGroupFile(testDir + "/Index.stg");
+				testIndex.load();
+				Map<String, Object> templateNames = testIndex.rawGetDictionary("TestTemplates");
+				if ( templateNames != null && !templateNames.isEmpty() ) {
+					final ArrayList<String> sortedTemplateNames = new ArrayList<String>(templateNames.keySet());
+					Collections.sort(sortedTemplateNames);
+					generateTestFile(testIndex, targetGroup, testDir, sortedTemplateNames, targetFolder);
+				}
+			}
+		}
+	}
+
+	protected void generateTestFile(STGroup index,
+									STGroup targetGroup,
+									String testDir,
+									Collection<String> testTemplates,
+									File targetFolder)
+	{
+		String testName = testDir.substring(testDir.lastIndexOf('/') + 1);
+		File targetFile = new File(targetFolder, "Test" + testName + ".java");
+		info("Generating file "+targetFile.getAbsolutePath());
+		List<ST> templates = new ArrayList<ST>();
+		for (String template : testTemplates) {
+			STGroup testGroup = new STGroupFile(testDir + "/" + template + STGroup.GROUP_FILE_EXTENSION);
+			importLanguageTemplates(testGroup, targetGroup);
+			ST testType = testGroup.getInstanceOf("TestType");
+			if (testType == null) {
+				warn(String.format("Unable to generate tests for %s: no TestType specified.", template));
+				continue;
+			}
+
+			ST testMethodTemplate = targetGroup.getInstanceOf(testType.render() + "TestMethod");
+			if (testMethodTemplate == null) {
+				warn(String.format("Unable to generate tests for %s: TestType '%s' is not supported by the current runtime.", template, testType.render()));
+				continue;
+			}
+
+			testMethodTemplate.add(testMethodTemplate.impl.formalArguments.keySet().iterator().next(), testGroup);
+			templates.add(testMethodTemplate);
+		}
+
+		ST testFileTemplate = targetGroup.getInstanceOf("TestFile");
+		testFileTemplate.addAggr("file.{Options,name,tests}", index.rawGetDictionary("Options"), testName, templates);
+
+		if (visualize) {
+			STViz viz = testFileTemplate.inspect();
+			try {
+				viz.waitForClose();
+			}
+			catch (InterruptedException ex) { }
+		}
+
+		try {
+			writeFile(targetFile, testFileTemplate.render());
+		}
+		catch (IOException ex) {
+			error(String.format("Failed to write output file: %s", targetFile), ex);
+		}
+	}
+
+	private void importLanguageTemplates(STGroup testGroup, STGroup languageGroup) {
+		// make sure the test group is loaded
+		testGroup.load();
+
+		if (testGroup == languageGroup) {
+			assert false : "Attempted to import the language group into itself.";
+			return;
+		}
+
+		if (testGroup.getImportedGroups().isEmpty()) {
+			testGroup.importTemplates(languageGroup);
+			return;
+		}
+
+		if (testGroup.getImportedGroups().contains(languageGroup)) {
+			return;
+		}
+
+		for (STGroup importedGroup : testGroup.getImportedGroups()) {
+			importLanguageTemplates(importedGroup, languageGroup);
+		}
+	}
+
+	public void writeFile(File file, String content) throws IOException {
+		file.getParentFile().mkdirs();
+
+		FileOutputStream fos = new FileOutputStream(file);
+		OutputStreamWriter osw = new OutputStreamWriter(fos, encoding != null ? encoding : "UTF-8");
+		try {
+			osw.write(content);
+		}
+		finally {
+			osw.close();
+		}
+	}
+
+	public File getOutputDir(String templateFolder) {
+		if(templateFolder.startsWith(rootDir))
+			templateFolder = templateFolder.substring(rootDir.length());
+		if(templateFolder.startsWith("/resources"))
+			templateFolder = templateFolder.substring("/resources".length());
+		templateFolder = templateFolder.substring(0, templateFolder.indexOf("/templates"));
+		templateFolder += "/" + targetName.toLowerCase();
+		return new File(outputDir, templateFolder);
+	}
+
+	protected void info(String message) {
+		// System.out.println("INFO: " + message);
+	}
+
+	protected void warn(String message) {
+		System.err.println("WARNING: " + message);
+	}
+
+	protected void error(String message, Throwable throwable) {
+		System.err.println("ERROR: " + message);
+	}
+}
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/csharp/BaseTest.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/csharp/BaseTest.java
new file mode 100644
index 000000000..23eb6eca4
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/csharp/BaseTest.java
@@ -0,0 +1,910 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2012 Terence Parr
+ *  Copyright (c) 2012 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.
+ */
+package org.antlr.v4.test.runtime.csharp;
+
+import org.antlr.v4.Tool;
+import org.antlr.v4.runtime.CommonTokenStream;
+import org.antlr.v4.runtime.Token;
+import org.antlr.v4.runtime.TokenSource;
+import org.antlr.v4.runtime.WritableToken;
+import org.antlr.v4.runtime.misc.Utils;
+import org.antlr.v4.test.runtime.java.ErrorQueue;
+import org.antlr.v4.tool.ANTLRMessage;
+import org.antlr.v4.tool.DefaultToolListener;
+import org.antlr.v4.tool.GrammarSemanticsMessage;
+import org.junit.Before;
+import org.junit.rules.TestRule;
+import org.junit.rules.TestWatcher;
+import org.junit.runner.Description;
+import org.stringtemplate.v4.ST;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.transform.OutputKeys;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.stream.StreamResult;
+import javax.xml.xpath.XPathConstants;
+import javax.xml.xpath.XPathExpression;
+import javax.xml.xpath.XPathFactory;
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+public abstract class BaseTest {
+	public static final String newline = System.getProperty("line.separator");
+	public static final String pathSep = System.getProperty("path.separator");
+
+	/**
+	 * When the {@code antlr.preserve-test-dir} runtime property is set to
+	 * {@code true}, the temporary directories created by the test run will not
+	 * be removed at the end of the test run, even for tests that completed
+	 * successfully.
+	 *
+	 * <p>
+	 * The default behavior (used in all other cases) is removing the temporary
+	 * directories for all tests which completed successfully, and preserving
+	 * the directories for tests which failed.</p>
+	 */
+	public static final boolean PRESERVE_TEST_DIR = Boolean.parseBoolean(System.getProperty("antlr-preserve-csharp-test-dir"));
+
+	/**
+	 * The base test directory is the directory where generated files get placed
+	 * during unit test execution.
+	 *
+	 * <p>
+	 * The default value for this property is the {@code java.io.tmpdir} system
+	 * property, and can be overridden by setting the
+	 * {@code antlr.java-test-dir} property to a custom location. Note that the
+	 * {@code antlr.java-test-dir} property directly affects the
+	 * {@link #CREATE_PER_TEST_DIRECTORIES} value as well.</p>
+	 */
+	public static final String BASE_TEST_DIR;
+
+	/**
+	 * When {@code true}, a temporary directory will be created for each test
+	 * executed during the test run.
+	 *
+	 * <p>
+	 * This value is {@code true} when the {@code antlr.java-test-dir} system
+	 * property is set, and otherwise {@code false}.</p>
+	 */
+	public static final boolean CREATE_PER_TEST_DIRECTORIES;
+
+	static {
+		String baseTestDir = System.getProperty("antlr-csharp-test-dir");
+		boolean perTestDirectories = false;
+		if (baseTestDir == null || baseTestDir.isEmpty()) {
+			baseTestDir = System.getProperty("java.io.tmpdir");
+			perTestDirectories = true;
+		}
+
+		if (!new File(baseTestDir).isDirectory()) {
+			throw new UnsupportedOperationException("The specified base test directory does not exist: " + baseTestDir);
+		}
+
+		BASE_TEST_DIR = baseTestDir;
+		CREATE_PER_TEST_DIRECTORIES = perTestDirectories;
+	}
+
+	public String tmpdir = null;
+
+	/** If error during parser execution, store stderr here; can't return
+     *  stdout and stderr.  This doesn't trap errors from running antlr.
+     */
+	protected String stderrDuringParse;
+
+	@org.junit.Rule
+	public final TestRule testWatcher = new TestWatcher() {
+
+		@Override
+		protected void succeeded(Description description) {
+			// remove tmpdir if no error.
+			if (!PRESERVE_TEST_DIR) {
+				eraseTempDir();
+			}
+		}
+
+	};
+
+    @Before
+	public void setUp() throws Exception {
+		if (CREATE_PER_TEST_DIRECTORIES) {
+			// new output dir for each test
+			String testDirectory = getClass().getSimpleName() + "-" + System.currentTimeMillis();
+			tmpdir = new File(BASE_TEST_DIR, testDirectory).getAbsolutePath();
+		}
+		else {
+			tmpdir = new File(BASE_TEST_DIR).getAbsolutePath();
+			if (!PRESERVE_TEST_DIR && new File(tmpdir).exists()) {
+				eraseFiles();
+			}
+		}
+    }
+
+    protected org.antlr.v4.Tool newTool(String[] args) {
+		Tool tool = new Tool(args);
+		return tool;
+	}
+
+	protected Tool newTool() {
+		org.antlr.v4.Tool tool = new Tool(new String[] {"-o", tmpdir});
+		return tool;
+	}
+
+	protected String load(String fileName, String encoding)
+		throws IOException
+	{
+		if ( fileName==null ) {
+			return null;
+		}
+
+		String fullFileName = getClass().getPackage().getName().replace('.', '/') + '/' + fileName;
+		int size = 65000;
+		InputStreamReader isr;
+		InputStream fis = getClass().getClassLoader().getResourceAsStream(fullFileName);
+		if ( encoding!=null ) {
+			isr = new InputStreamReader(fis, encoding);
+		}
+		else {
+			isr = new InputStreamReader(fis);
+		}
+		try {
+			char[] data = new char[size];
+			int n = isr.read(data);
+			return new String(data, 0, n);
+		}
+		finally {
+			isr.close();
+		}
+	}
+
+
+	protected ErrorQueue antlr(String grammarFileName, boolean defaultListener, String... extraOptions) {
+		final List<String> options = new ArrayList<String>();
+		Collections.addAll(options, extraOptions);
+		options.add("-Dlanguage=CSharp");
+		if ( !options.contains("-o") ) {
+			options.add("-o");
+			options.add(tmpdir);
+		}
+		if ( !options.contains("-lib") ) {
+			options.add("-lib");
+			options.add(tmpdir);
+		}
+		if ( !options.contains("-encoding") ) {
+			options.add("-encoding");
+			options.add("UTF-8");
+		}
+		options.add(new File(tmpdir,grammarFileName).toString());
+
+		final String[] optionsA = new String[options.size()];
+		options.toArray(optionsA);
+		Tool antlr = newTool(optionsA);
+		ErrorQueue equeue = new ErrorQueue(antlr);
+		antlr.addListener(equeue);
+		if (defaultListener) {
+			antlr.addListener(new DefaultToolListener(antlr));
+		}
+		antlr.processGrammarsOnCommandLine();
+
+		if ( !defaultListener && !equeue.errors.isEmpty() ) {
+			System.err.println("antlr reports errors from "+options);
+			for (int i = 0; i < equeue.errors.size(); i++) {
+				ANTLRMessage msg = equeue.errors.get(i);
+				System.err.println(msg);
+			}
+			System.out.println("!!!\ngrammar:");
+			try {
+				System.out.println(new String(Utils.readFile(tmpdir+"/"+grammarFileName)));
+			}
+			catch (IOException ioe) {
+				System.err.println(ioe.toString());
+			}
+			System.out.println("###");
+		}
+		if ( !defaultListener && !equeue.warnings.isEmpty() ) {
+			System.err.println("antlr reports warnings from "+options);
+			for (int i = 0; i < equeue.warnings.size(); i++) {
+				ANTLRMessage msg = equeue.warnings.get(i);
+				System.err.println(msg);
+			}
+		}
+
+		return equeue;
+	}
+
+	protected ErrorQueue antlr(String grammarFileName, String grammarStr, boolean defaultListener, String... extraOptions) {
+		System.out.println("dir "+tmpdir);
+		mkdir(tmpdir);
+		writeFile(tmpdir, grammarFileName, grammarStr);
+		return antlr(grammarFileName, defaultListener, extraOptions);
+	}
+
+	protected String execLexer(String grammarFileName,
+							   String grammarStr,
+							   String lexerName,
+							   String input)
+	{
+		return execLexer(grammarFileName, grammarStr, lexerName, input, false);
+	}
+
+	protected String execLexer(String grammarFileName,
+							   String grammarStr,
+							   String lexerName,
+							   String input,
+							   boolean showDFA)
+	{
+		boolean success = rawGenerateRecognizer(grammarFileName,
+									  grammarStr,
+									  null,
+									  lexerName);
+		assertTrue(success);
+		writeFile(tmpdir, "input", input);
+		writeLexerTestFile(lexerName, showDFA);
+		addSourceFiles("Test.cs");
+		if(!compile()) {
+			System.err.println("Failed to compile!");
+			return stderrDuringParse;
+		}
+		String output = execTest();
+		if ( stderrDuringParse!=null && stderrDuringParse.length()>0 ) {
+			System.err.println(stderrDuringParse);
+		}
+		return output;
+	}
+
+	Set<String> sourceFiles = new HashSet<String>();
+
+	private void addSourceFiles(String ... files) {
+		for(String file : files)
+			this.sourceFiles.add(file);
+	}
+
+	protected String execParser(String grammarFileName,
+								String grammarStr,
+								String parserName,
+								String lexerName,
+								String startRuleName,
+								String input, boolean debug)
+	{
+		boolean success = rawGenerateRecognizer(grammarFileName,
+														grammarStr,
+														parserName,
+														lexerName,
+														"-visitor");
+		assertTrue(success);
+		writeFile(tmpdir, "input", input);
+		return rawExecRecognizer(parserName,
+								 lexerName,
+								 startRuleName,
+								 debug);
+	}
+
+	/** Return true if all is well */
+	protected boolean rawGenerateRecognizer(String grammarFileName,
+													String grammarStr,
+													String parserName,
+													String lexerName,
+													String... extraOptions)
+	{
+		return rawGenerateRecognizer(grammarFileName, grammarStr, parserName, lexerName, false, extraOptions);
+	}
+
+	/** Return true if all is well */
+	protected boolean rawGenerateRecognizer(String grammarFileName,
+													String grammarStr,
+													String parserName,
+													String lexerName,
+													boolean defaultListener,
+													String... extraOptions)
+	{
+		ErrorQueue equeue = antlr(grammarFileName, grammarStr, defaultListener, extraOptions);
+		if (!equeue.errors.isEmpty()) {
+			return false;
+		}
+
+		List<String> files = new ArrayList<String>();
+		if ( lexerName!=null ) {
+			files.add(lexerName+".cs");
+		}
+		if ( parserName!=null ) {
+			files.add(parserName+".cs");
+			Set<String> optionsSet = new HashSet<String>(Arrays.asList(extraOptions));
+			String grammarName = grammarFileName.substring(0, grammarFileName.lastIndexOf('.'));
+			if (!optionsSet.contains("-no-listener")) {
+				files.add(grammarName+"Listener.cs");
+				files.add(grammarName+"BaseListener.cs");
+			}
+			if (optionsSet.contains("-visitor")) {
+				files.add(grammarName+"Visitor.cs");
+				files.add(grammarName+"BaseVisitor.cs");
+			}
+		}
+		addSourceFiles(files.toArray(new String[files.size()]));
+		return true;
+	}
+
+	protected String rawExecRecognizer(String parserName,
+									   String lexerName,
+									   String parserStartRuleName,
+									   boolean debug)
+	{
+        this.stderrDuringParse = null;
+		if ( parserName==null ) {
+			writeLexerTestFile(lexerName, false);
+		}
+		else {
+			writeParserTestFile(parserName,
+						  lexerName,
+						  parserStartRuleName,
+						  debug);
+		}
+
+		addSourceFiles("Test.cs");
+		return execRecognizer();
+	}
+
+	public String execRecognizer() {
+		compile();
+		return execTest();
+	}
+
+	public boolean compile() {
+		try {
+			if(!createProject())
+				return false;
+			if(!buildProject())
+				return false;
+			return true;
+		} catch(Exception e) {
+			return false;
+		}
+	}
+
+	private File getTestProjectFile() {
+		return new File(tmpdir, "Antlr4.Test.mono.csproj");
+	}
+
+	private boolean buildProject() throws Exception {
+		String msbuild = locateMSBuild();
+		String[] args = {
+				msbuild,
+				"/p:Configuration=Release",
+				getTestProjectFile().getAbsolutePath()
+			};
+		System.err.println("Starting build "+ Utils.join(args, " "));
+		ProcessBuilder pb = new ProcessBuilder(args);
+		pb.directory(new File(tmpdir));
+		Process process = pb.start();
+		StreamVacuum stdoutVacuum = new StreamVacuum(process.getInputStream());
+		StreamVacuum stderrVacuum = new StreamVacuum(process.getErrorStream());
+		stdoutVacuum.start();
+		stderrVacuum.start();
+		process.waitFor();
+		stdoutVacuum.join();
+		stderrVacuum.join();
+		// xbuild sends errors to output, so check exit code
+		boolean success = process.exitValue()==0;
+		if ( !success ) {
+			this.stderrDuringParse = stdoutVacuum.toString();
+			System.err.println("buildProject stderrVacuum: "+ this.stderrDuringParse);
+		}
+		return success;
+	}
+
+	private String locateMSBuild() {
+		if(isWindows())
+			return "\"C:\\Program Files (x86)\\MSBuild\\12.0\\Bin\\MSBuild.exe\"";
+		else
+			return locateTool("xbuild");
+	}
+
+	private boolean isWindows() {
+		return System.getProperty("os.name").toLowerCase().contains("windows");
+	}
+
+	private String locateExec() {
+		return new File(tmpdir, "bin/Release/Test.exe").getAbsolutePath();
+	}
+
+	private String locateTool(String tool) {
+		String[] roots = { "/usr/bin/", "/usr/local/bin/" };
+		for(String root : roots) {
+			if(new File(root + tool).exists())
+				return root + tool;
+		}
+		throw new RuntimeException("Could not locate " + tool);
+	}
+
+	public boolean createProject() {
+		try {
+			String pack = BaseTest.class.getPackage().getName().replace(".", "/") + "/";
+			// save auxiliary files
+			saveResourceAsFile(pack + "AssemblyInfo.cs", new File(tmpdir, "AssemblyInfo.cs"));
+			saveResourceAsFile(pack + "App.config", new File(tmpdir, "App.config"));
+			// update project
+			String projectName = isWindows() ? "Antlr4.Test.vs2013.csproj" : "Antlr4.Test.mono.csproj";
+			final ClassLoader loader = Thread.currentThread().getContextClassLoader();
+			InputStream input = loader.getResourceAsStream(pack + projectName);
+			Document prjXml = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(input);
+			// update runtime project reference
+			// find project file as a resource not relative pathname (now that we've merged repos)
+			String runtimeName = isWindows() ? "Antlr4.Runtime.vs2013.csproj" : "Antlr4.Runtime.mono.csproj";
+			final URL runtimeProj = loader.getResource("CSharp/runtime/CSharp/Antlr4.Runtime/"+runtimeName);
+			if ( runtimeProj==null ) {
+				throw new RuntimeException("C# runtime project file not found!");
+			}
+			String runtimeProjPath = runtimeProj.getPath();
+			XPathExpression exp = XPathFactory.newInstance().newXPath()
+				.compile("/Project/ItemGroup/ProjectReference[@Include='" + runtimeName + "']");
+			Element node = (Element)exp.evaluate(prjXml, XPathConstants.NODE);
+			node.setAttribute("Include", runtimeProjPath.replace("/", "\\"));
+			// update project file list
+			exp = XPathFactory.newInstance().newXPath().compile("/Project/ItemGroup[Compile/@Include='AssemblyInfo.cs']");
+			Element group = (Element)exp.evaluate(prjXml, XPathConstants.NODE);
+			if(group==null)
+				return false;
+			// remove existing children
+			while(group.hasChildNodes())
+				group.removeChild(group.getFirstChild());
+			// add AssemblyInfo.cs, not a generated source
+			sourceFiles.add("AssemblyInfo.cs");
+			// add files to compile
+			for(String file : sourceFiles) {
+				Element elem = group.getOwnerDocument().createElement("Compile");
+				elem.setAttribute("Include", file);
+				group.appendChild(elem);
+			}
+			// save project
+			File prjFile = getTestProjectFile();
+			Transformer transformer = TransformerFactory.newInstance().newTransformer();
+			transformer.setOutputProperty(OutputKeys.INDENT, "yes");
+			transformer.transform(new DOMSource(prjXml), new StreamResult(prjFile));
+			return true;
+		} catch(Exception e) {
+			e.printStackTrace(System.err);
+			return false;
+		}
+	}
+
+	private void saveResourceAsFile(String resourceName, File file) throws IOException {
+		InputStream input = Thread.currentThread().getContextClassLoader().getResourceAsStream(resourceName);
+		if ( input==null ) {
+			System.err.println("Can't find " + resourceName + " as resource");
+			throw new IOException("Missing resource:" + resourceName);
+		}
+		OutputStream output = new FileOutputStream(file.getAbsolutePath());
+		while(input.available()>0) {
+			output.write(input.read());
+		}
+		output.close();
+		input.close();
+	}
+
+	public String execTest() {
+		try {
+			String exec = locateExec();
+			String[] args = isWindows() ?
+					new String[] { exec, new File(tmpdir, "input").getAbsolutePath() } :
+					new String[] { "mono", exec, new File(tmpdir, "input").getAbsolutePath() };
+			ProcessBuilder pb = new ProcessBuilder(args);
+			pb.directory(new File(tmpdir));
+			Process process = pb.start();
+			StreamVacuum stdoutVacuum = new StreamVacuum(process.getInputStream());
+			StreamVacuum stderrVacuum = new StreamVacuum(process.getErrorStream());
+			stdoutVacuum.start();
+			stderrVacuum.start();
+			process.waitFor();
+			stdoutVacuum.join();
+			stderrVacuum.join();
+			String output = stdoutVacuum.toString();
+			if ( stderrVacuum.toString().length()>0 ) {
+				this.stderrDuringParse = stderrVacuum.toString();
+				System.err.println("exec stderrVacuum: "+ stderrVacuum);
+			}
+			return output;
+		}
+		catch (Exception e) {
+			System.err.println("can't exec recognizer");
+			e.printStackTrace(System.err);
+		}
+		return null;
+	}
+
+	public void testErrors(String[] pairs, boolean printTree) {
+        for (int i = 0; i < pairs.length; i+=2) {
+            String input = pairs[i];
+            String expect = pairs[i+1];
+
+			String[] lines = input.split("\n");
+			String fileName = getFilenameFromFirstLineOfGrammar(lines[0]);
+			ErrorQueue equeue = antlr(fileName, input, false);
+
+			String actual = equeue.toString(true);
+			actual = actual.replace(tmpdir + File.separator, "");
+			System.err.println(actual);
+			String msg = input;
+			msg = msg.replace("\n","\\n");
+			msg = msg.replace("\r","\\r");
+			msg = msg.replace("\t","\\t");
+
+			org.junit.Assert.assertEquals("error in: "+msg,expect,actual);
+        }
+    }
+
+	public String getFilenameFromFirstLineOfGrammar(String line) {
+		String fileName = "A" + Tool.GRAMMAR_EXTENSION;
+		int grIndex = line.lastIndexOf("grammar");
+		int semi = line.lastIndexOf(';');
+		if ( grIndex>=0 && semi>=0 ) {
+			int space = line.indexOf(' ', grIndex);
+			fileName = line.substring(space+1, semi)+Tool.GRAMMAR_EXTENSION;
+		}
+		if ( fileName.length()==Tool.GRAMMAR_EXTENSION.length() ) fileName = "A" + Tool.GRAMMAR_EXTENSION;
+		return fileName;
+	}
+
+
+	List<ANTLRMessage> getMessagesOfType(List<ANTLRMessage> msgs, Class<? extends ANTLRMessage> c) {
+		List<ANTLRMessage> filtered = new ArrayList<ANTLRMessage>();
+		for (ANTLRMessage m : msgs) {
+			if ( m.getClass() == c ) filtered.add(m);
+		}
+		return filtered;
+	}
+
+
+	public static class StreamVacuum implements Runnable {
+		StringBuilder buf = new StringBuilder();
+		BufferedReader in;
+		Thread sucker;
+		public StreamVacuum(InputStream in) {
+			this.in = new BufferedReader( new InputStreamReader(in) );
+		}
+		public void start() {
+			sucker = new Thread(this);
+			sucker.start();
+		}
+		@Override
+		public void run() {
+			try {
+				String line = in.readLine();
+				while (line!=null) {
+					buf.append(line);
+					buf.append('\n');
+					line = in.readLine();
+				}
+			}
+			catch (IOException ioe) {
+				System.err.println("can't read output from process");
+			}
+		}
+		/** wait for the thread to finish */
+		public void join() throws InterruptedException {
+			sucker.join();
+		}
+		@Override
+		public String toString() {
+			return buf.toString();
+		}
+	}
+
+	protected void checkGrammarSemanticsError(ErrorQueue equeue,
+											  GrammarSemanticsMessage expectedMessage)
+		throws Exception
+	{
+		ANTLRMessage foundMsg = null;
+		for (int i = 0; i < equeue.errors.size(); i++) {
+			ANTLRMessage m = equeue.errors.get(i);
+			if (m.getErrorType()==expectedMessage.getErrorType() ) {
+				foundMsg = m;
+			}
+		}
+		assertNotNull("no error; "+expectedMessage.getErrorType()+" expected", foundMsg);
+		assertTrue("error is not a GrammarSemanticsMessage",
+				   foundMsg instanceof GrammarSemanticsMessage);
+		assertEquals(Arrays.toString(expectedMessage.getArgs()), Arrays.toString(foundMsg.getArgs()));
+		if ( equeue.size()!=1 ) {
+			System.err.println(equeue);
+		}
+	}
+
+
+    public static class FilteringTokenStream extends CommonTokenStream {
+        public FilteringTokenStream(TokenSource src) { super(src); }
+        Set<Integer> hide = new HashSet<Integer>();
+        @Override
+        protected boolean sync(int i) {
+            if (!super.sync(i)) {
+				return false;
+			}
+
+			Token t = get(i);
+			if ( hide.contains(t.getType()) ) {
+				((WritableToken)t).setChannel(Token.HIDDEN_CHANNEL);
+			}
+
+			return true;
+        }
+        public void setTokenTypeChannel(int ttype, int channel) {
+            hide.add(ttype);
+        }
+    }
+
+	public static void writeFile(String dir, String fileName, String content) {
+		try {
+			Utils.writeFile(dir+"/"+fileName, content, "UTF-8");
+		}
+		catch (IOException ioe) {
+			System.err.println("can't write file");
+			ioe.printStackTrace(System.err);
+		}
+	}
+
+	protected void mkdir(String dir) {
+		File f = new File(dir);
+		f.mkdirs();
+	}
+
+	protected void writeParserTestFile(String parserName,
+								 String lexerName,
+								 String parserStartRuleName,
+								 boolean debug)
+	{
+		ST outputFileST = new ST(
+			"using System;\n" +
+			"using Antlr4.Runtime;\n" +
+			"using Antlr4.Runtime.Tree;\n" +
+			"\n" +
+			"public class Test {\n" +
+			"    public static void Main(string[] args) {\n" +
+			"        ICharStream input = new AntlrFileStream(args[0]);\n" +
+			"        <lexerName> lex = new <lexerName>(input);\n" +
+			"        CommonTokenStream tokens = new CommonTokenStream(lex);\n" +
+			"        <createParser>\n"+
+			"		 parser.BuildParseTree = true;\n" +
+			"        ParserRuleContext tree = parser.<parserStartRuleName>();\n" +
+			"        ParseTreeWalker.Default.Walk(new TreeShapeListener(), tree);\n" +
+			"    }\n" +
+			"}\n" +
+			"\n" +
+			"class TreeShapeListener : IParseTreeListener {\n" +
+			"	public void VisitTerminal(ITerminalNode node) { }\n" +
+			"	public void VisitErrorNode(IErrorNode node) { }\n" +
+			"	public void ExitEveryRule(ParserRuleContext ctx) { }\n" +
+			"\n" +
+			"	public void EnterEveryRule(ParserRuleContext ctx) {\n" +
+			"		for (int i = 0; i \\< ctx.ChildCount; i++) {\n" +
+			"			IParseTree parent = ctx.GetChild(i).Parent;\n" +
+			"			if (!(parent is IRuleNode) || ((IRuleNode)parent).RuleContext != ctx) {\n" +
+			"				throw new Exception(\"Invalid parse tree shape detected.\");\n" +
+			"			}\n" +
+			"		}\n" +
+			"	}\n" +
+			"}"
+			);
+        ST createParserST = new ST("        <parserName> parser = new <parserName>(tokens);\n");
+		if ( debug ) {
+			createParserST =
+				new ST(
+				"        <parserName> parser = new <parserName>(tokens);\n" +
+                "        parser.AddErrorListener(new DiagnosticErrorListener());\n");
+		}
+		outputFileST.add("createParser", createParserST);
+		outputFileST.add("parserName", parserName);
+		outputFileST.add("lexerName", lexerName);
+		outputFileST.add("parserStartRuleName", parserStartRuleName);
+		writeFile(tmpdir, "Test.cs", outputFileST.render());
+	}
+
+	protected void writeLexerTestFile(String lexerName, boolean showDFA) {
+		ST outputFileST = new ST(
+			"using System;\n" +
+			"using Antlr4.Runtime;\n" +
+			"\n" +
+			"public class Test {\n" +
+			"    public static void Main(string[] args) {\n" +
+			"        ICharStream input = new AntlrFileStream(args[0]);\n" +
+			"        <lexerName> lex = new <lexerName>(input);\n" +
+			"        CommonTokenStream tokens = new CommonTokenStream(lex);\n" +
+			"        tokens.Fill();\n" +
+			"        foreach (object t in tokens.GetTokens())\n" +
+			"			Console.WriteLine(t);\n" +
+			(showDFA?"Console.Write(lex.Interpreter.GetDFA(Lexer.DefaultMode).ToLexerString());\n":"")+
+			"    }\n" +
+			"}"
+			);
+
+		outputFileST.add("lexerName", lexerName);
+		writeFile(tmpdir, "Test.cs", outputFileST.render());
+	}
+
+	public void writeRecognizerAndCompile(String parserName, String lexerName,
+										  String parserStartRuleName,
+										  boolean debug) {
+		if ( parserName==null ) {
+			writeLexerTestFile(lexerName, debug);
+		}
+		else {
+			writeParserTestFile(parserName,
+						  lexerName,
+						  parserStartRuleName,
+						  debug);
+		}
+
+		addSourceFiles("Test.cs");
+	}
+
+
+    protected void eraseFiles(final String filesEndingWith) {
+        File tmpdirF = new File(tmpdir);
+        String[] files = tmpdirF.list();
+        for(int i = 0; files!=null && i < files.length; i++) {
+            if ( files[i].endsWith(filesEndingWith) ) {
+                new File(tmpdir+"/"+files[i]).delete();
+            }
+        }
+    }
+
+    protected void eraseFiles() {
+		if (tmpdir == null) {
+			return;
+		}
+
+        File tmpdirF = new File(tmpdir);
+        String[] files = tmpdirF.list();
+        if(files!=null) for(String file : files) {
+        	new File(tmpdir+"/"+file).delete();
+        }
+    }
+
+    protected void eraseTempDir() {
+        File tmpdirF = new File(tmpdir);
+        if ( tmpdirF.exists() ) {
+            eraseFiles();
+            tmpdirF.delete();
+        }
+    }
+
+	public String getFirstLineOfException() {
+		if ( this.stderrDuringParse ==null ) {
+			return null;
+		}
+		String[] lines = this.stderrDuringParse.split("\n");
+		String prefix="Exception in thread \"main\" ";
+		return lines[0].substring(prefix.length(),lines[0].length());
+	}
+
+	public List<String> realElements(List<String> elements) {
+		return elements.subList(Token.MIN_USER_TOKEN_TYPE, elements.size());
+	}
+
+	public void assertNotNullOrEmpty(String message, String text) {
+		assertNotNull(message, text);
+		assertFalse(message, text.isEmpty());
+	}
+
+	public void assertNotNullOrEmpty(String text) {
+		assertNotNull(text);
+		assertFalse(text.isEmpty());
+	}
+
+
+	/** Return map sorted by key */
+	public <K extends Comparable<? super K>,V> LinkedHashMap<K,V> sort(Map<K,V> data) {
+		LinkedHashMap<K,V> dup = new LinkedHashMap<K, V>();
+		List<K> keys = new ArrayList<K>();
+		keys.addAll(data.keySet());
+		Collections.sort(keys);
+		for (K k : keys) {
+			dup.put(k, data.get(k));
+		}
+		return dup;
+	}
+
+	protected static void assertEquals(String msg, int a, int b) {
+		org.junit.Assert.assertEquals(msg, a, b);
+	}
+
+	protected static void assertEquals(String a, String b) {
+		a = absorbExpectedDifferences(a);
+		b = absorbActualDifferences(b);
+		org.junit.Assert.assertEquals(a, b);
+	}
+
+	protected static void assertNull(String a) {
+		a = absorbActualDifferences(a);
+		org.junit.Assert.assertNull(a);
+	}
+
+	private static String absorbExpectedDifferences(String a) {
+		if(a==null)
+			return a;
+		// work around the lack of requiresFullContext field in DFAState
+		if(a.startsWith("Decision"))
+			a = a.replaceAll("\\^", "");
+		// work around the algo difference for full context
+		a = stripOutUnwantedLinesWith(a, "reportAttemptingFullContext","reportContextSensitivity", "reportAmbiguity");
+		if(a.isEmpty())
+			a = null;
+		return a;
+	}
+
+	private static String absorbActualDifferences(String a) {
+		if(a==null)
+			return a;
+		// work around the algo difference for full context
+		// work around the algo difference for semantic predicates
+		a = stripOutUnwantedLinesWith(a, "reportContextSensitivity","eval=false");
+		if(a.isEmpty())
+			a = null;
+		return a;
+	}
+
+	private static String stripOutUnwantedLinesWith(String a, String ... unwanteds) {
+		String[] lines = a.split("\n");
+		StringBuilder sb = new StringBuilder();
+		for(String line : lines) {
+			boolean wanted = true;
+			for(String unwanted : unwanteds) {
+				if(line.contains(unwanted) ) {
+					wanted = false;
+					break;
+				}
+			}
+			if(!wanted)
+				continue;
+			sb.append(line);
+			sb.append("\n");
+		}
+		return sb.toString();
+	}
+
+}
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/csharp/TestCompositeLexers.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/csharp/TestCompositeLexers.java
new file mode 100644
index 000000000..08a074eaf
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/csharp/TestCompositeLexers.java
@@ -0,0 +1,65 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.csharp;
+
+import org.junit.Test;
+import org.junit.Ignore;
+
+@SuppressWarnings("unused")
+public class TestCompositeLexers extends BaseTest {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLexerDelegatorInvokesDelegateRule() throws Exception {
+		mkdir(tmpdir);
+		String slave_S =
+			"lexer grammar S;\n" +
+			"A : 'a' {Console.WriteLine(\"S.A\");};\n" +
+			"C : 'c' ;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+
+		StringBuilder grammarBuilder = new StringBuilder(61);
+		grammarBuilder.append("lexer grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("B : 'b';\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="abc";
+		String found = execLexer("M.g4", grammar, "M", input, false);
+		assertEquals(
+			"S.A\n" +
+			"[@0,0:0='a',<3>,1:0]\n" +
+			"[@1,1:1='b',<1>,1:1]\n" +
+			"[@2,2:2='c',<4>,1:2]\n" +
+			"[@3,3:2='<EOF>',<-1>,1:3]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLexerDelegatorRuleOverridesDelegate() throws Exception {
+		mkdir(tmpdir);
+		String slave_S =
+			"lexer grammar S;\n" +
+			"A : 'a' {Console.WriteLine(\"S.A\");} ;\n" +
+			"B : 'b' {Console.WriteLine(\"S.B\");} ;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+
+		StringBuilder grammarBuilder = new StringBuilder(92);
+		grammarBuilder.append("lexer grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("A : 'a' B {Console.WriteLine(\"M.A\");} ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="ab";
+		String found = execLexer("M.g4", grammar, "M", input, false);
+		assertEquals(
+			"M.A\n" +
+			"[@0,0:1='ab',<1>,1:0]\n" +
+			"[@1,2:1='<EOF>',<-1>,1:2]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+}
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/csharp/TestCompositeParsers.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/csharp/TestCompositeParsers.java
new file mode 100644
index 000000000..a761fc84d
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/csharp/TestCompositeParsers.java
@@ -0,0 +1,395 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.csharp;
+
+import org.junit.Test;
+import org.junit.Ignore;
+
+import org.antlr.v4.test.runtime.java.ErrorQueue;
+import org.antlr.v4.tool.Grammar;
+
+@SuppressWarnings("unused")
+public class TestCompositeParsers extends BaseTest {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testBringInLiteralsFromDelegate() throws Exception {
+		mkdir(tmpdir);
+		String slave_S =
+			"parser grammar S;\n" +
+			"a : '=' 'a' {Console.Write(\"S.a\");};";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(54);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("s : a ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="=a";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "s", input, false);
+		assertEquals("S.a\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCombinedImportsCombined() throws Exception {
+		mkdir(tmpdir);
+		String slave_S =
+			"parser grammar S;\n" +
+			"tokens { A, B, C }\n" +
+			"x : 'x' INT {Console.WriteLine(\"S.x\");};\n" +
+			"INT : '0'..'9'+ ;\n" +
+			"WS : (' '|'\\n') -> skip ;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(31);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("s : x INT;");
+		String grammar = grammarBuilder.toString();
+		String input ="x 34 9";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "s", input, false);
+		assertEquals("S.x\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDelegatesSeeSameTokenType() throws Exception {
+		mkdir(tmpdir);
+		String slave_S =
+			"parser grammar S;\n" +
+			"tokens { A, B, C }\n" +
+			"x : A {Console.WriteLine(\"S.x\");};";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		String slave_T =
+			"parser grammar T;\n" +
+			"tokens { C, B, A } // reverse order\n" +
+			"y : A {Console.WriteLine(\"T.y\");};";
+		writeFile(tmpdir, "T.g4", slave_T);
+
+		StringBuilder grammarBuilder = new StringBuilder(598);
+		grammarBuilder.append("// The lexer will create rules to match letters a, b, c.\n");
+		grammarBuilder.append("// The associated token types A, B, C must have the same value\n");
+		grammarBuilder.append("// and all import'd parsers.  Since ANTLR regenerates all imports\n");
+		grammarBuilder.append("// for use with the delegator M, it can generate the same token type\n");
+		grammarBuilder.append("// mapping in each parser:\n");
+		grammarBuilder.append("// public static final int C=6;\n");
+		grammarBuilder.append("// public static final int EOF=-1;\n");
+		grammarBuilder.append("// public static final int B=5;\n");
+		grammarBuilder.append("// public static final int WS=7;\n");
+		grammarBuilder.append("// public static final int A=4;\n");
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S,T;\n");
+		grammarBuilder.append("s : x y ; // matches AA, which should be 'aa'\n");
+		grammarBuilder.append("B : 'b' ; // another order: B, A, C\n");
+		grammarBuilder.append("A : 'a' ; \n");
+		grammarBuilder.append("C : 'c' ; \n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="aa";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "s", input, false);
+		assertEquals(
+			"S.x\n" +
+			"T.y\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDelegatorAccessesDelegateMembers() throws Exception {
+		mkdir(tmpdir);
+		String slave_S =
+			"parser grammar S;\n" +
+			"@parser::members {\n" +
+			"public void foo() {Console.WriteLine(\"foo\");}\n" +
+			"}\n" +
+			"a : B;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(127);
+		grammarBuilder.append("grammar M; // uses no rules from the import\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("s : 'b' {this.foo();} ; // gS is import pointer\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="b";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "s", input, false);
+		assertEquals("foo\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDelegatorInvokesDelegateRule() throws Exception {
+		mkdir(tmpdir);
+		String slave_S =
+			"parser grammar S;\n" +
+			"a : B {Console.WriteLine(\"S.a\");};";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(104);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("s : a ;\n");
+		grammarBuilder.append("B : 'b' ; // defines B from inherited token space\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="b";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "s", input, false);
+		assertEquals("S.a\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDelegatorInvokesDelegateRuleWithArgs() throws Exception {
+		mkdir(tmpdir);
+		String slave_S =
+			"parser grammar S;\n" +
+			"a[int x] returns [int y] : B {Console.Write(\"S.a\");} {$y=1000;} ;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(144);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("s : label=a[3] {Console.WriteLine($label.y);} ;\n");
+		grammarBuilder.append("B : 'b' ; // defines B from inherited token space\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="b";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "s", input, false);
+		assertEquals("S.a1000\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDelegatorInvokesDelegateRuleWithReturnStruct() throws Exception {
+		mkdir(tmpdir);
+		String slave_S =
+			"parser grammar S;\n" +
+			"a : B {Console.Write(\"S.a\");} ;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(130);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("s : a {Console.Write($a.text);} ;\n");
+		grammarBuilder.append("B : 'b' ; // defines B from inherited token space\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="b";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "s", input, false);
+		assertEquals("S.ab\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDelegatorInvokesFirstVersionOfDelegateRule() throws Exception {
+		mkdir(tmpdir);
+		String slave_S =
+			"parser grammar S;\n" +
+			"a : b {Console.WriteLine(\"S.a\");};\n" +
+			"b : B;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		String slave_T =
+			"parser grammar T;\n" +
+			"a : B {Console.WriteLine(\"T.a\");};";
+		writeFile(tmpdir, "T.g4", slave_T);
+
+		StringBuilder grammarBuilder = new StringBuilder(106);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S,T;\n");
+		grammarBuilder.append("s : a ;\n");
+		grammarBuilder.append("B : 'b' ; // defines B from inherited token space\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="b";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "s", input, false);
+		assertEquals("S.a\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDelegatorRuleOverridesDelegate() throws Exception {
+		mkdir(tmpdir);
+		String slave_S =
+			"parser grammar S;\n" +
+			"a : b {Console.Write(\"S.a\");};\n" +
+			"b : B ;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(59);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("b : 'b'|'c';\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="c";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "a", input, false);
+		assertEquals("S.a\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDelegatorRuleOverridesDelegates() throws Exception {
+		mkdir(tmpdir);
+		String slave_S =
+			"parser grammar S;\n" +
+			"a : b {Console.WriteLine(\"S.a\");};\n" +
+			"b : 'b' ;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		String slave_T =
+			"parser grammar T;\n" +
+			"tokens { A }\n" +
+			"b : 'b' {Console.WriteLine(\"T.b\");};";
+		writeFile(tmpdir, "T.g4", slave_T);
+
+		StringBuilder grammarBuilder = new StringBuilder(94);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S, T;\n");
+		grammarBuilder.append("b : 'b'|'c' {Console.WriteLine(\"M.b\");}|B|A;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="c";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "a", input, false);
+		assertEquals(
+			"M.b\n" +
+			"S.a\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDelegatorRuleOverridesLookaheadInDelegate() throws Exception {
+		mkdir(tmpdir);
+		String slave_S =
+			"parser grammar S;\n" +
+			"type_ : 'int' ;\n" +
+			"decl : type_ ID ';'\n" +
+			"	| type_ ID init ';' {Console.Write(\"JavaDecl: \" + $text);};\n" +
+			"init : '=' INT;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(121);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("prog : decl ;\n");
+		grammarBuilder.append("type_ : 'int' | 'float' ;\n");
+		grammarBuilder.append("ID  : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+		String input ="float x = 3;";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "prog", input, false);
+		assertEquals("JavaDecl: floatx=3;\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testImportLexerWithOnlyFragmentRules() throws Exception {
+		mkdir(tmpdir);
+		String slave_Unicode =
+			"lexer grammar Unicode;\n" +
+			"\n" +
+			"fragment\n" +
+			"UNICODE_CLASS_Zs    : '\\u0020' | '\\u00A0' | '\\u1680' | '\\u180E'\n" +
+			"                    | '\\u2000'..'\\u200A'\n" +
+			"                    | '\\u202F' | '\\u205F' | '\\u3000'\n" +
+			"                    ;\n";
+		writeFile(tmpdir, "Unicode.g4", slave_Unicode);
+
+		StringBuilder grammarBuilder = new StringBuilder(91);
+		grammarBuilder.append("grammar Test;\n");
+		grammarBuilder.append("import Unicode;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("program : 'test' 'test';\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("WS : (UNICODE_CLASS_Zs)+ -> skip;\n");
+		String grammar = grammarBuilder.toString();
+		String input ="test test";
+		String found = execParser("Test.g4", grammar, "TestParser", "TestLexer", "program", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testImportedGrammarWithEmptyOptions() throws Exception {
+		mkdir(tmpdir);
+		String slave_S =
+			"parser grammar S;\n" +
+			"options {}\n" +
+			"a : B ;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(64);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("s : a ;\n");
+		grammarBuilder.append("B : 'b' ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="b";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "s", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testImportedRuleWithAction() throws Exception {
+		mkdir(tmpdir);
+		String slave_S =
+			"parser grammar S;\n" +
+			"a @after {int x = 0;} : B;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(62);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("s : a;\n");
+		grammarBuilder.append("B : 'b';\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="b";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "s", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testKeywordVSIDOrder() throws Exception {
+		mkdir(tmpdir);
+		String slave_S =
+			"lexer grammar S;\n" +
+			"ID : 'a'..'z'+;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(127);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("a : A {Console.WriteLine(\"M.a: \" + $A);};\n");
+		grammarBuilder.append("A : 'abc' {Console.WriteLine(\"M.A\");};\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="abc";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "a", input, false);
+		assertEquals(
+			"M.A\n" +
+			"M.a: [@0,0:2='abc',<1>,1:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+}
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/csharp/TestFullContextParsing.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/csharp/TestFullContextParsing.java
new file mode 100644
index 000000000..4fee2cc78
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/csharp/TestFullContextParsing.java
@@ -0,0 +1,430 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.csharp;
+
+import org.junit.Test;
+import org.junit.Ignore;
+
+@SuppressWarnings("unused")
+public class TestFullContextParsing extends BaseTest {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAmbigYieldsCtxSensitiveDFA() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(101);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {this.DumpDFA();}\n");
+		grammarBuilder.append("	: ID | ID {} ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="abc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, true);
+		assertEquals(
+			"Decision 0:\n" +
+			"s0-ID->:s1^=>1\n", found);
+
+		assertEquals("line 1:0 reportAttemptingFullContext d=0 (s), input='abc'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAmbiguityNoLoop() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(215);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("prog\n");
+		grammarBuilder.append("@init {Interpreter.PredictionMode = PredictionMode.LlExactAmbigDetection;}\n");
+		grammarBuilder.append("	: expr expr {Console.WriteLine(\"alt 1\");}\n");
+		grammarBuilder.append("	| expr\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("expr: '@'\n");
+		grammarBuilder.append("	| ID '@'\n");
+		grammarBuilder.append("	| ID\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("ID  : [a-z]+ ;\n");
+		grammarBuilder.append("WS  : [ \\r\\n\\t]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a@";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "prog", input, true);
+		assertEquals("alt 1\n", found);
+
+		assertEquals(
+			"line 1:2 reportAttemptingFullContext d=0 (prog), input='a@'\n" +
+			"line 1:2 reportAmbiguity d=0 (prog): ambigAlts={1, 2}, input='a@'\n" +
+			"line 1:2 reportAttemptingFullContext d=1 (expr), input='a@'\n" +
+			"line 1:2 reportContextSensitivity d=1 (expr), input='a@'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCtxSensitiveDFATwoDiffInput() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(165);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {this.DumpDFA();}\n");
+		grammarBuilder.append("  : ('$' a | '@' b)+ ;\n");
+		grammarBuilder.append("a : e ID ;\n");
+		grammarBuilder.append("b : e INT ID ;\n");
+		grammarBuilder.append("e : INT | ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="$ 34 abc @ 34 abc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, true);
+		assertEquals(
+			"Decision 2:\n" +
+			"s0-INT->s1\n" +
+			"s1-ID->:s2^=>1\n", found);
+
+		assertEquals(
+			"line 1:5 reportAttemptingFullContext d=2 (e), input='34abc'\n" +
+			"line 1:2 reportContextSensitivity d=2 (e), input='34'\n" +
+			"line 1:14 reportAttemptingFullContext d=2 (e), input='34abc'\n" +
+			"line 1:14 reportContextSensitivity d=2 (e), input='34abc'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCtxSensitiveDFA_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(162);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {this.DumpDFA();}\n");
+		grammarBuilder.append("  : '$' a | '@' b ;\n");
+		grammarBuilder.append("a : e ID ;\n");
+		grammarBuilder.append("b : e INT ID ;\n");
+		grammarBuilder.append("e : INT | ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="$ 34 abc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, true);
+		assertEquals(
+			"Decision 1:\n" +
+			"s0-INT->s1\n" +
+			"s1-ID->:s2^=>1\n", found);
+
+		assertEquals(
+			"line 1:5 reportAttemptingFullContext d=1 (e), input='34abc'\n" +
+			"line 1:2 reportContextSensitivity d=1 (e), input='34'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCtxSensitiveDFA_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(162);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {this.DumpDFA();}\n");
+		grammarBuilder.append("  : '$' a | '@' b ;\n");
+		grammarBuilder.append("a : e ID ;\n");
+		grammarBuilder.append("b : e INT ID ;\n");
+		grammarBuilder.append("e : INT | ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="@ 34 abc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, true);
+		assertEquals(
+			"Decision 1:\n" +
+			"s0-INT->s1\n" +
+			"s1-ID->:s2^=>1\n", found);
+
+		assertEquals(
+			"line 1:5 reportAttemptingFullContext d=1 (e), input='34abc'\n" +
+			"line 1:5 reportContextSensitivity d=1 (e), input='34abc'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExprAmbiguity_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(289);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {Interpreter.PredictionMode = PredictionMode.LlExactAmbigDetection;}\n");
+		grammarBuilder.append(":   expr[0] {Console.WriteLine($expr.ctx.ToStringTree(this));};\n");
+		grammarBuilder.append("	expr[int _p]\n");
+		grammarBuilder.append("		: ID \n");
+		grammarBuilder.append("		( \n");
+		grammarBuilder.append("			{5 >= $_p}? '*' expr[6]\n");
+		grammarBuilder.append("			| {4 >= $_p}? '+' expr[5]\n");
+		grammarBuilder.append("		)*\n");
+		grammarBuilder.append("		;\n");
+		grammarBuilder.append("ID  : [a-zA-Z]+ ;\n");
+		grammarBuilder.append("WS  : [ \\r\\n\\t]+ -> skip ;\n");
+		String grammar = grammarBuilder.toString();
+		String input ="a+b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, true);
+		assertEquals("(expr a + (expr b))\n", found);
+
+		assertEquals(
+			"line 1:1 reportAttemptingFullContext d=1 (expr), input='+'\n" +
+			"line 1:2 reportContextSensitivity d=1 (expr), input='+b'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExprAmbiguity_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(289);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {Interpreter.PredictionMode = PredictionMode.LlExactAmbigDetection;}\n");
+		grammarBuilder.append(":   expr[0] {Console.WriteLine($expr.ctx.ToStringTree(this));};\n");
+		grammarBuilder.append("	expr[int _p]\n");
+		grammarBuilder.append("		: ID \n");
+		grammarBuilder.append("		( \n");
+		grammarBuilder.append("			{5 >= $_p}? '*' expr[6]\n");
+		grammarBuilder.append("			| {4 >= $_p}? '+' expr[5]\n");
+		grammarBuilder.append("		)*\n");
+		grammarBuilder.append("		;\n");
+		grammarBuilder.append("ID  : [a-zA-Z]+ ;\n");
+		grammarBuilder.append("WS  : [ \\r\\n\\t]+ -> skip ;\n");
+		String grammar = grammarBuilder.toString();
+		String input ="a+b*c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, true);
+		assertEquals("(expr a + (expr b * (expr c)))\n", found);
+
+		assertEquals(
+			"line 1:1 reportAttemptingFullContext d=1 (expr), input='+'\n" +
+			"line 1:2 reportContextSensitivity d=1 (expr), input='+b'\n" +
+			"line 1:3 reportAttemptingFullContext d=1 (expr), input='*'\n" +
+			"line 1:5 reportAmbiguity d=1 (expr): ambigAlts={1, 2}, input='*c'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testFullContextIF_THEN_ELSEParse_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(237);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s \n");
+		grammarBuilder.append("@init {Interpreter.PredictionMode = PredictionMode.LlExactAmbigDetection;}\n");
+		grammarBuilder.append("@after {this.DumpDFA();}\n");
+		grammarBuilder.append("	: '{' stat* '}' ;\n");
+		grammarBuilder.append("stat: 'if' ID 'then' stat ('else' ID)?\n");
+		grammarBuilder.append("		| 'return'\n");
+		grammarBuilder.append("		;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="{ if x then return }";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, true);
+		assertEquals(
+			"Decision 1:\n" +
+			"s0-'}'->:s1=>2\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testFullContextIF_THEN_ELSEParse_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(237);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s \n");
+		grammarBuilder.append("@init {Interpreter.PredictionMode = PredictionMode.LlExactAmbigDetection;}\n");
+		grammarBuilder.append("@after {this.DumpDFA();}\n");
+		grammarBuilder.append("	: '{' stat* '}' ;\n");
+		grammarBuilder.append("stat: 'if' ID 'then' stat ('else' ID)?\n");
+		grammarBuilder.append("		| 'return'\n");
+		grammarBuilder.append("		;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="{ if x then return else foo }";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, true);
+		assertEquals(
+			"Decision 1:\n" +
+			"s0-'else'->:s1^=>1\n", found);
+
+		assertEquals(
+			"line 1:19 reportAttemptingFullContext d=1 (stat), input='else'\n" +
+			"line 1:19 reportContextSensitivity d=1 (stat), input='else'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testFullContextIF_THEN_ELSEParse_3() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(237);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s \n");
+		grammarBuilder.append("@init {Interpreter.PredictionMode = PredictionMode.LlExactAmbigDetection;}\n");
+		grammarBuilder.append("@after {this.DumpDFA();}\n");
+		grammarBuilder.append("	: '{' stat* '}' ;\n");
+		grammarBuilder.append("stat: 'if' ID 'then' stat ('else' ID)?\n");
+		grammarBuilder.append("		| 'return'\n");
+		grammarBuilder.append("		;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="{ if x then if y then return else foo }";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, true);
+		assertEquals(
+			"Decision 1:\n" +
+			"s0-'}'->:s2=>2\n" +
+			"s0-'else'->:s1^=>1\n", found);
+
+		assertEquals(
+			"line 1:29 reportAttemptingFullContext d=1 (stat), input='else'\n" +
+			"line 1:38 reportAmbiguity d=1 (stat): ambigAlts={1, 2}, input='elsefoo}'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testFullContextIF_THEN_ELSEParse_4() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(237);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s \n");
+		grammarBuilder.append("@init {Interpreter.PredictionMode = PredictionMode.LlExactAmbigDetection;}\n");
+		grammarBuilder.append("@after {this.DumpDFA();}\n");
+		grammarBuilder.append("	: '{' stat* '}' ;\n");
+		grammarBuilder.append("stat: 'if' ID 'then' stat ('else' ID)?\n");
+		grammarBuilder.append("		| 'return'\n");
+		grammarBuilder.append("		;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="{ if x then if y then return else foo else bar }";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, true);
+		assertEquals(
+			"Decision 1:\n" +
+			"s0-'else'->:s1^=>1\n", found);
+
+		assertEquals(
+			"line 1:29 reportAttemptingFullContext d=1 (stat), input='else'\n" +
+			"line 1:38 reportContextSensitivity d=1 (stat), input='elsefooelse'\n" +
+			"line 1:38 reportAttemptingFullContext d=1 (stat), input='else'\n" +
+			"line 1:38 reportContextSensitivity d=1 (stat), input='else'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testFullContextIF_THEN_ELSEParse_5() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(237);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s \n");
+		grammarBuilder.append("@init {Interpreter.PredictionMode = PredictionMode.LlExactAmbigDetection;}\n");
+		grammarBuilder.append("@after {this.DumpDFA();}\n");
+		grammarBuilder.append("	: '{' stat* '}' ;\n");
+		grammarBuilder.append("stat: 'if' ID 'then' stat ('else' ID)?\n");
+		grammarBuilder.append("		| 'return'\n");
+		grammarBuilder.append("		;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input =
+			"{ if x then return else foo\n" +
+			"if x then if y then return else foo }";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, true);
+		assertEquals(
+			"Decision 1:\n" +
+			"s0-'}'->:s2=>2\n" +
+			"s0-'else'->:s1^=>1\n", found);
+
+		assertEquals(
+			"line 1:19 reportAttemptingFullContext d=1 (stat), input='else'\n" +
+			"line 1:19 reportContextSensitivity d=1 (stat), input='else'\n" +
+			"line 2:27 reportAttemptingFullContext d=1 (stat), input='else'\n" +
+			"line 2:36 reportAmbiguity d=1 (stat): ambigAlts={1, 2}, input='elsefoo}'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testFullContextIF_THEN_ELSEParse_6() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(237);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s \n");
+		grammarBuilder.append("@init {Interpreter.PredictionMode = PredictionMode.LlExactAmbigDetection;}\n");
+		grammarBuilder.append("@after {this.DumpDFA();}\n");
+		grammarBuilder.append("	: '{' stat* '}' ;\n");
+		grammarBuilder.append("stat: 'if' ID 'then' stat ('else' ID)?\n");
+		grammarBuilder.append("		| 'return'\n");
+		grammarBuilder.append("		;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input =
+			"{ if x then return else foo\n" +
+			"if x then if y then return else foo }";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, true);
+		assertEquals(
+			"Decision 1:\n" +
+			"s0-'}'->:s2=>2\n" +
+			"s0-'else'->:s1^=>1\n", found);
+
+		assertEquals(
+			"line 1:19 reportAttemptingFullContext d=1 (stat), input='else'\n" +
+			"line 1:19 reportContextSensitivity d=1 (stat), input='else'\n" +
+			"line 2:27 reportAttemptingFullContext d=1 (stat), input='else'\n" +
+			"line 2:36 reportAmbiguity d=1 (stat): ambigAlts={1, 2}, input='elsefoo}'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLoopsSimulateTailRecursion() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(321);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("prog\n");
+		grammarBuilder.append("@init {Interpreter.PredictionMode = PredictionMode.LlExactAmbigDetection;}\n");
+		grammarBuilder.append("	: expr_or_assign*;\n");
+		grammarBuilder.append("expr_or_assign\n");
+		grammarBuilder.append("	: expr '++' {Console.WriteLine(\"fail.\");}\n");
+		grammarBuilder.append("	|  expr {Console.WriteLine(\"pass: \"+$expr.text);}\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("expr: expr_primary ('<-' ID)?;\n");
+		grammarBuilder.append("expr_primary\n");
+		grammarBuilder.append("	: '(' ID ')'\n");
+		grammarBuilder.append("	| ID '(' ID ')'\n");
+		grammarBuilder.append("	| ID\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("ID  : [a-z]+ ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a(i)<-x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "prog", input, true);
+		assertEquals("pass: a(i)<-x\n", found);
+
+		assertEquals(
+			"line 1:3 reportAttemptingFullContext d=3 (expr_primary), input='a(i)'\n" +
+			"line 1:7 reportAmbiguity d=3 (expr_primary): ambigAlts={2, 3}, input='a(i)<-x'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSLLSeesEOFInLLGrammar() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(149);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {this.DumpDFA();}\n");
+		grammarBuilder.append("  : a;\n");
+		grammarBuilder.append("a : e ID ;\n");
+		grammarBuilder.append("b : e INT ID ;\n");
+		grammarBuilder.append("e : INT | ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="34 abc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, true);
+		assertEquals(
+			"Decision 0:\n" +
+			"s0-INT->s1\n" +
+			"s1-ID->:s2^=>1\n", found);
+
+		assertEquals(
+			"line 1:3 reportAttemptingFullContext d=0 (e), input='34abc'\n" +
+			"line 1:0 reportContextSensitivity d=0 (e), input='34'\n", this.stderrDuringParse);
+
+	}
+
+}
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/csharp/TestLeftRecursion.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/csharp/TestLeftRecursion.java
new file mode 100644
index 000000000..b3b91fdaf
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/csharp/TestLeftRecursion.java
@@ -0,0 +1,2918 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.csharp;
+
+import org.junit.Test;
+import org.junit.Ignore;
+
+@SuppressWarnings("unused")
+public class TestLeftRecursion extends BaseTest {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAmbigLR_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(705);
+		grammarBuilder.append("grammar Expr;\n");
+		grammarBuilder.append("prog:   stat ;\n");
+		grammarBuilder.append("stat:   expr NEWLINE                # printExpr\n");
+		grammarBuilder.append("    |   ID '=' expr NEWLINE         # assign\n");
+		grammarBuilder.append("    |   NEWLINE                     # blank\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("expr:   expr ('*'|'/') expr      # MulDiv\n");
+		grammarBuilder.append("    |   expr ('+'|'-') expr      # AddSub\n");
+		grammarBuilder.append("    |   INT                      # int\n");
+		grammarBuilder.append("    |   ID                       # id\n");
+		grammarBuilder.append("    |   '(' expr ')'             # parens\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("MUL :   '*' ; // assigns token name to '*' used above in grammar\n");
+		grammarBuilder.append("DIV :   '/' ;\n");
+		grammarBuilder.append("ADD :   '+' ;\n");
+		grammarBuilder.append("SUB :   '-' ;\n");
+		grammarBuilder.append("ID  :   [a-zA-Z]+ ;      // match identifiers\n");
+		grammarBuilder.append("INT :   [0-9]+ ;         // match integers\n");
+		grammarBuilder.append("NEWLINE:'\\r'? '\\n' ;     // return newlines to parser (is end-statement signal)\n");
+		grammarBuilder.append("WS  :   [ \\t]+ -> skip ; // toss out whitespace");
+		String grammar = grammarBuilder.toString();
+		String input ="1\n";
+		String found = execParser("Expr.g4", grammar, "ExprParser", "ExprLexer", "prog", input, true);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAmbigLR_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(705);
+		grammarBuilder.append("grammar Expr;\n");
+		grammarBuilder.append("prog:   stat ;\n");
+		grammarBuilder.append("stat:   expr NEWLINE                # printExpr\n");
+		grammarBuilder.append("    |   ID '=' expr NEWLINE         # assign\n");
+		grammarBuilder.append("    |   NEWLINE                     # blank\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("expr:   expr ('*'|'/') expr      # MulDiv\n");
+		grammarBuilder.append("    |   expr ('+'|'-') expr      # AddSub\n");
+		grammarBuilder.append("    |   INT                      # int\n");
+		grammarBuilder.append("    |   ID                       # id\n");
+		grammarBuilder.append("    |   '(' expr ')'             # parens\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("MUL :   '*' ; // assigns token name to '*' used above in grammar\n");
+		grammarBuilder.append("DIV :   '/' ;\n");
+		grammarBuilder.append("ADD :   '+' ;\n");
+		grammarBuilder.append("SUB :   '-' ;\n");
+		grammarBuilder.append("ID  :   [a-zA-Z]+ ;      // match identifiers\n");
+		grammarBuilder.append("INT :   [0-9]+ ;         // match integers\n");
+		grammarBuilder.append("NEWLINE:'\\r'? '\\n' ;     // return newlines to parser (is end-statement signal)\n");
+		grammarBuilder.append("WS  :   [ \\t]+ -> skip ; // toss out whitespace");
+		String grammar = grammarBuilder.toString();
+		String input ="a = 5\n";
+		String found = execParser("Expr.g4", grammar, "ExprParser", "ExprLexer", "prog", input, true);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAmbigLR_3() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(705);
+		grammarBuilder.append("grammar Expr;\n");
+		grammarBuilder.append("prog:   stat ;\n");
+		grammarBuilder.append("stat:   expr NEWLINE                # printExpr\n");
+		grammarBuilder.append("    |   ID '=' expr NEWLINE         # assign\n");
+		grammarBuilder.append("    |   NEWLINE                     # blank\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("expr:   expr ('*'|'/') expr      # MulDiv\n");
+		grammarBuilder.append("    |   expr ('+'|'-') expr      # AddSub\n");
+		grammarBuilder.append("    |   INT                      # int\n");
+		grammarBuilder.append("    |   ID                       # id\n");
+		grammarBuilder.append("    |   '(' expr ')'             # parens\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("MUL :   '*' ; // assigns token name to '*' used above in grammar\n");
+		grammarBuilder.append("DIV :   '/' ;\n");
+		grammarBuilder.append("ADD :   '+' ;\n");
+		grammarBuilder.append("SUB :   '-' ;\n");
+		grammarBuilder.append("ID  :   [a-zA-Z]+ ;      // match identifiers\n");
+		grammarBuilder.append("INT :   [0-9]+ ;         // match integers\n");
+		grammarBuilder.append("NEWLINE:'\\r'? '\\n' ;     // return newlines to parser (is end-statement signal)\n");
+		grammarBuilder.append("WS  :   [ \\t]+ -> skip ; // toss out whitespace");
+		String grammar = grammarBuilder.toString();
+		String input ="b = 6\n";
+		String found = execParser("Expr.g4", grammar, "ExprParser", "ExprLexer", "prog", input, true);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAmbigLR_4() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(705);
+		grammarBuilder.append("grammar Expr;\n");
+		grammarBuilder.append("prog:   stat ;\n");
+		grammarBuilder.append("stat:   expr NEWLINE                # printExpr\n");
+		grammarBuilder.append("    |   ID '=' expr NEWLINE         # assign\n");
+		grammarBuilder.append("    |   NEWLINE                     # blank\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("expr:   expr ('*'|'/') expr      # MulDiv\n");
+		grammarBuilder.append("    |   expr ('+'|'-') expr      # AddSub\n");
+		grammarBuilder.append("    |   INT                      # int\n");
+		grammarBuilder.append("    |   ID                       # id\n");
+		grammarBuilder.append("    |   '(' expr ')'             # parens\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("MUL :   '*' ; // assigns token name to '*' used above in grammar\n");
+		grammarBuilder.append("DIV :   '/' ;\n");
+		grammarBuilder.append("ADD :   '+' ;\n");
+		grammarBuilder.append("SUB :   '-' ;\n");
+		grammarBuilder.append("ID  :   [a-zA-Z]+ ;      // match identifiers\n");
+		grammarBuilder.append("INT :   [0-9]+ ;         // match integers\n");
+		grammarBuilder.append("NEWLINE:'\\r'? '\\n' ;     // return newlines to parser (is end-statement signal)\n");
+		grammarBuilder.append("WS  :   [ \\t]+ -> skip ; // toss out whitespace");
+		String grammar = grammarBuilder.toString();
+		String input ="a+b*2\n";
+		String found = execParser("Expr.g4", grammar, "ExprParser", "ExprLexer", "prog", input, true);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAmbigLR_5() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(705);
+		grammarBuilder.append("grammar Expr;\n");
+		grammarBuilder.append("prog:   stat ;\n");
+		grammarBuilder.append("stat:   expr NEWLINE                # printExpr\n");
+		grammarBuilder.append("    |   ID '=' expr NEWLINE         # assign\n");
+		grammarBuilder.append("    |   NEWLINE                     # blank\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("expr:   expr ('*'|'/') expr      # MulDiv\n");
+		grammarBuilder.append("    |   expr ('+'|'-') expr      # AddSub\n");
+		grammarBuilder.append("    |   INT                      # int\n");
+		grammarBuilder.append("    |   ID                       # id\n");
+		grammarBuilder.append("    |   '(' expr ')'             # parens\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("MUL :   '*' ; // assigns token name to '*' used above in grammar\n");
+		grammarBuilder.append("DIV :   '/' ;\n");
+		grammarBuilder.append("ADD :   '+' ;\n");
+		grammarBuilder.append("SUB :   '-' ;\n");
+		grammarBuilder.append("ID  :   [a-zA-Z]+ ;      // match identifiers\n");
+		grammarBuilder.append("INT :   [0-9]+ ;         // match integers\n");
+		grammarBuilder.append("NEWLINE:'\\r'? '\\n' ;     // return newlines to parser (is end-statement signal)\n");
+		grammarBuilder.append("WS  :   [ \\t]+ -> skip ; // toss out whitespace");
+		String grammar = grammarBuilder.toString();
+		String input ="(1+2)*3\n";
+		String found = execParser("Expr.g4", grammar, "ExprParser", "ExprLexer", "prog", input, true);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDeclarations_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(398);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : declarator EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("declarator\n");
+		grammarBuilder.append("        : declarator '[' e ']'\n");
+		grammarBuilder.append("        | declarator '[' ']'\n");
+		grammarBuilder.append("        | declarator '(' ')'\n");
+		grammarBuilder.append("        | '*' declarator // binds less tight than suffixes\n");
+		grammarBuilder.append("        | '(' declarator ')'\n");
+		grammarBuilder.append("        | ID\n");
+		grammarBuilder.append("        ;\n");
+		grammarBuilder.append("e : INT ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (declarator a) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDeclarations_10() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(398);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : declarator EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("declarator\n");
+		grammarBuilder.append("        : declarator '[' e ']'\n");
+		grammarBuilder.append("        | declarator '[' ']'\n");
+		grammarBuilder.append("        | declarator '(' ')'\n");
+		grammarBuilder.append("        | '*' declarator // binds less tight than suffixes\n");
+		grammarBuilder.append("        | '(' declarator ')'\n");
+		grammarBuilder.append("        | ID\n");
+		grammarBuilder.append("        ;\n");
+		grammarBuilder.append("e : INT ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="(*a)[]";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (declarator (declarator ( (declarator * (declarator a)) )) [ ]) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDeclarations_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(398);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : declarator EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("declarator\n");
+		grammarBuilder.append("        : declarator '[' e ']'\n");
+		grammarBuilder.append("        | declarator '[' ']'\n");
+		grammarBuilder.append("        | declarator '(' ')'\n");
+		grammarBuilder.append("        | '*' declarator // binds less tight than suffixes\n");
+		grammarBuilder.append("        | '(' declarator ')'\n");
+		grammarBuilder.append("        | ID\n");
+		grammarBuilder.append("        ;\n");
+		grammarBuilder.append("e : INT ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="*a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (declarator * (declarator a)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDeclarations_3() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(398);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : declarator EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("declarator\n");
+		grammarBuilder.append("        : declarator '[' e ']'\n");
+		grammarBuilder.append("        | declarator '[' ']'\n");
+		grammarBuilder.append("        | declarator '(' ')'\n");
+		grammarBuilder.append("        | '*' declarator // binds less tight than suffixes\n");
+		grammarBuilder.append("        | '(' declarator ')'\n");
+		grammarBuilder.append("        | ID\n");
+		grammarBuilder.append("        ;\n");
+		grammarBuilder.append("e : INT ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="**a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (declarator * (declarator * (declarator a))) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDeclarations_4() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(398);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : declarator EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("declarator\n");
+		grammarBuilder.append("        : declarator '[' e ']'\n");
+		grammarBuilder.append("        | declarator '[' ']'\n");
+		grammarBuilder.append("        | declarator '(' ')'\n");
+		grammarBuilder.append("        | '*' declarator // binds less tight than suffixes\n");
+		grammarBuilder.append("        | '(' declarator ')'\n");
+		grammarBuilder.append("        | ID\n");
+		grammarBuilder.append("        ;\n");
+		grammarBuilder.append("e : INT ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a[3]";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (declarator (declarator a) [ (e 3) ]) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDeclarations_5() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(398);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : declarator EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("declarator\n");
+		grammarBuilder.append("        : declarator '[' e ']'\n");
+		grammarBuilder.append("        | declarator '[' ']'\n");
+		grammarBuilder.append("        | declarator '(' ')'\n");
+		grammarBuilder.append("        | '*' declarator // binds less tight than suffixes\n");
+		grammarBuilder.append("        | '(' declarator ')'\n");
+		grammarBuilder.append("        | ID\n");
+		grammarBuilder.append("        ;\n");
+		grammarBuilder.append("e : INT ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="b[]";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (declarator (declarator b) [ ]) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDeclarations_6() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(398);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : declarator EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("declarator\n");
+		grammarBuilder.append("        : declarator '[' e ']'\n");
+		grammarBuilder.append("        | declarator '[' ']'\n");
+		grammarBuilder.append("        | declarator '(' ')'\n");
+		grammarBuilder.append("        | '*' declarator // binds less tight than suffixes\n");
+		grammarBuilder.append("        | '(' declarator ')'\n");
+		grammarBuilder.append("        | ID\n");
+		grammarBuilder.append("        ;\n");
+		grammarBuilder.append("e : INT ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="(a)";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (declarator ( (declarator a) )) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDeclarations_7() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(398);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : declarator EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("declarator\n");
+		grammarBuilder.append("        : declarator '[' e ']'\n");
+		grammarBuilder.append("        | declarator '[' ']'\n");
+		grammarBuilder.append("        | declarator '(' ')'\n");
+		grammarBuilder.append("        | '*' declarator // binds less tight than suffixes\n");
+		grammarBuilder.append("        | '(' declarator ')'\n");
+		grammarBuilder.append("        | ID\n");
+		grammarBuilder.append("        ;\n");
+		grammarBuilder.append("e : INT ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a[]()";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (declarator (declarator (declarator a) [ ]) ( )) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDeclarations_8() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(398);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : declarator EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("declarator\n");
+		grammarBuilder.append("        : declarator '[' e ']'\n");
+		grammarBuilder.append("        | declarator '[' ']'\n");
+		grammarBuilder.append("        | declarator '(' ')'\n");
+		grammarBuilder.append("        | '*' declarator // binds less tight than suffixes\n");
+		grammarBuilder.append("        | '(' declarator ')'\n");
+		grammarBuilder.append("        | ID\n");
+		grammarBuilder.append("        ;\n");
+		grammarBuilder.append("e : INT ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a[][]";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (declarator (declarator (declarator a) [ ]) [ ]) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDeclarations_9() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(398);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : declarator EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("declarator\n");
+		grammarBuilder.append("        : declarator '[' e ']'\n");
+		grammarBuilder.append("        | declarator '[' ']'\n");
+		grammarBuilder.append("        | declarator '(' ')'\n");
+		grammarBuilder.append("        | '*' declarator // binds less tight than suffixes\n");
+		grammarBuilder.append("        | '(' declarator ')'\n");
+		grammarBuilder.append("        | ID\n");
+		grammarBuilder.append("        ;\n");
+		grammarBuilder.append("e : INT ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="*a[]";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (declarator * (declarator (declarator a) [ ])) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDirectCallToLeftRecursiveRule_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(126);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a @after {Console.WriteLine($ctx.ToStringTree(this));} : a ID\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("(a x)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDirectCallToLeftRecursiveRule_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(126);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a @after {Console.WriteLine($ctx.ToStringTree(this));} : a ID\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x y";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("(a (a x) y)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDirectCallToLeftRecursiveRule_3() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(126);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a @after {Console.WriteLine($ctx.ToStringTree(this));} : a ID\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x y z";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("(a (a (a x) y) z)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExpressions_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(257);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("e : e '.' ID\n");
+		grammarBuilder.append("  | e '.' 'this'\n");
+		grammarBuilder.append("  | '-' e\n");
+		grammarBuilder.append("  | e '*' e\n");
+		grammarBuilder.append("  | e ('+'|'-') e\n");
+		grammarBuilder.append("  | INT\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e a) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExpressions_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(257);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("e : e '.' ID\n");
+		grammarBuilder.append("  | e '.' 'this'\n");
+		grammarBuilder.append("  | '-' e\n");
+		grammarBuilder.append("  | e '*' e\n");
+		grammarBuilder.append("  | e ('+'|'-') e\n");
+		grammarBuilder.append("  | INT\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="1";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e 1) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExpressions_3() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(257);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("e : e '.' ID\n");
+		grammarBuilder.append("  | e '.' 'this'\n");
+		grammarBuilder.append("  | '-' e\n");
+		grammarBuilder.append("  | e '*' e\n");
+		grammarBuilder.append("  | e ('+'|'-') e\n");
+		grammarBuilder.append("  | INT\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a-1";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e a) - (e 1)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExpressions_4() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(257);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("e : e '.' ID\n");
+		grammarBuilder.append("  | e '.' 'this'\n");
+		grammarBuilder.append("  | '-' e\n");
+		grammarBuilder.append("  | e '*' e\n");
+		grammarBuilder.append("  | e ('+'|'-') e\n");
+		grammarBuilder.append("  | INT\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a.b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e a) . b) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExpressions_5() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(257);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("e : e '.' ID\n");
+		grammarBuilder.append("  | e '.' 'this'\n");
+		grammarBuilder.append("  | '-' e\n");
+		grammarBuilder.append("  | e '*' e\n");
+		grammarBuilder.append("  | e ('+'|'-') e\n");
+		grammarBuilder.append("  | INT\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a.this";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e a) . this) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExpressions_6() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(257);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("e : e '.' ID\n");
+		grammarBuilder.append("  | e '.' 'this'\n");
+		grammarBuilder.append("  | '-' e\n");
+		grammarBuilder.append("  | e '*' e\n");
+		grammarBuilder.append("  | e ('+'|'-') e\n");
+		grammarBuilder.append("  | INT\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="-a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e - (e a)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExpressions_7() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(257);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("e : e '.' ID\n");
+		grammarBuilder.append("  | e '.' 'this'\n");
+		grammarBuilder.append("  | '-' e\n");
+		grammarBuilder.append("  | e '*' e\n");
+		grammarBuilder.append("  | e ('+'|'-') e\n");
+		grammarBuilder.append("  | INT\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="-a+b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e - (e a)) + (e b)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(1254);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a|b&c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e a) | (e (e b) & (e c))) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_10() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(1254);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a.f(x)==T.c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e (e (e a) . f) ( (expressionList (e x)) )) == (e (e T) . c)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_11() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(1254);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a.f().g(x,1)";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e (e (e (e a) . f) ( )) . g) ( (expressionList (e x) , (e 1)) )) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_12() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(1254);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="new T[((n-1) * x) + 1]";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e new (typespec T) [ (e (e ( (e (e ( (e (e n) - (e 1)) )) * (e x)) )) + (e 1)) ]) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(1254);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="(a|b)&c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e ( (e (e a) | (e b)) )) & (e c)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_3() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(1254);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a > b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e a) > (e b)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_4() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(1254);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a >> b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e a) >> (e b)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_5() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(1254);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a=b=c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e a) = (e (e b) = (e c))) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_6() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(1254);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a^b^c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e a) ^ (e (e b) ^ (e c))) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_7() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(1254);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="(T)x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e ( (typespec T) ) (e x)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_8() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(1254);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="new A().b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e new (typespec A) ( )) . b) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_9() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(1254);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="(T)t.f()";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e ( (typespec T) ) (e (e t) . f)) ( )) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLabelsOnOpSubrule_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(177);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : e;\n");
+		grammarBuilder.append("e : a=e op=('*'|'/') b=e  {}\n");
+		grammarBuilder.append("  | INT {}\n");
+		grammarBuilder.append("  | '(' x=e ')' {}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="4";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e 4))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLabelsOnOpSubrule_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(177);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : e;\n");
+		grammarBuilder.append("e : a=e op=('*'|'/') b=e  {}\n");
+		grammarBuilder.append("  | INT {}\n");
+		grammarBuilder.append("  | '(' x=e ')' {}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="1*2/3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e (e 1) * (e 2)) / (e 3)))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLabelsOnOpSubrule_3() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(177);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : e;\n");
+		grammarBuilder.append("e : a=e op=('*'|'/') b=e  {}\n");
+		grammarBuilder.append("  | INT {}\n");
+		grammarBuilder.append("  | '(' x=e ')' {}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="(1/2)*3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e ( (e (e 1) / (e 2)) )) * (e 3)))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleActionsPredicatesOptions_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(246);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : e ;\n");
+		grammarBuilder.append("e : a=e op=('*'|'/') b=e  {}{true}?\n");
+		grammarBuilder.append("  | a=e op=('+'|'-') b=e  {}<p=3>{true}?<fail='Message'>\n");
+		grammarBuilder.append("  | INT {}{}\n");
+		grammarBuilder.append("  | '(' x=e ')' {}{}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="4";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e 4))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleActionsPredicatesOptions_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(246);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : e ;\n");
+		grammarBuilder.append("e : a=e op=('*'|'/') b=e  {}{true}?\n");
+		grammarBuilder.append("  | a=e op=('+'|'-') b=e  {}<p=3>{true}?<fail='Message'>\n");
+		grammarBuilder.append("  | INT {}{}\n");
+		grammarBuilder.append("  | '(' x=e ')' {}{}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="1*2/3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e (e 1) * (e 2)) / (e 3)))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleActionsPredicatesOptions_3() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(246);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : e ;\n");
+		grammarBuilder.append("e : a=e op=('*'|'/') b=e  {}{true}?\n");
+		grammarBuilder.append("  | a=e op=('+'|'-') b=e  {}<p=3>{true}?<fail='Message'>\n");
+		grammarBuilder.append("  | INT {}{}\n");
+		grammarBuilder.append("  | '(' x=e ')' {}{}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="(1/2)*3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e ( (e (e 1) / (e 2)) )) * (e 3)))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleActions_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(184);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : e ;\n");
+		grammarBuilder.append("e : a=e op=('*'|'/') b=e  {}{}\n");
+		grammarBuilder.append("  | INT {}{}\n");
+		grammarBuilder.append("  | '(' x=e ')' {}{}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="4";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e 4))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleActions_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(184);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : e ;\n");
+		grammarBuilder.append("e : a=e op=('*'|'/') b=e  {}{}\n");
+		grammarBuilder.append("  | INT {}{}\n");
+		grammarBuilder.append("  | '(' x=e ')' {}{}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="1*2/3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e (e 1) * (e 2)) / (e 3)))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleActions_3() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(184);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : e ;\n");
+		grammarBuilder.append("e : a=e op=('*'|'/') b=e  {}{}\n");
+		grammarBuilder.append("  | INT {}{}\n");
+		grammarBuilder.append("  | '(' x=e ')' {}{}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="(1/2)*3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e ( (e (e 1) / (e 2)) )) * (e 3)))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleAlternativesWithCommonLabel_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(741);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {Console.WriteLine($e.v);};\n");
+		grammarBuilder.append("e returns [int v]\n");
+		grammarBuilder.append("  : e '*' e     {$v = ((BinaryContext)$ctx).e(0).v * ((BinaryContext)$ctx).e(1).v;}  # binary\n");
+		grammarBuilder.append("  | e '+' e     {$v = ((BinaryContext)$ctx).e(0).v + ((BinaryContext)$ctx).e(1).v;}  # binary\n");
+		grammarBuilder.append("  | INT         {$v = $INT.int;}                   # anInt\n");
+		grammarBuilder.append("  | '(' e ')'   {$v = $e.v;}                       # parens\n");
+		grammarBuilder.append("  | left=e INC  {Debug.Assert(((UnaryContext)$ctx).INC() != null);$v = $left.v + 1;}      # unary\n");
+		grammarBuilder.append("  | left=e DEC  {Debug.Assert(((UnaryContext)$ctx).DEC() != null);$v = $left.v - 1;}      # unary\n");
+		grammarBuilder.append("  | ID          {$v = 3;}                                                     # anID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("INC : '++' ;\n");
+		grammarBuilder.append("DEC : '--' ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="4";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("4\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleAlternativesWithCommonLabel_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(741);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {Console.WriteLine($e.v);};\n");
+		grammarBuilder.append("e returns [int v]\n");
+		grammarBuilder.append("  : e '*' e     {$v = ((BinaryContext)$ctx).e(0).v * ((BinaryContext)$ctx).e(1).v;}  # binary\n");
+		grammarBuilder.append("  | e '+' e     {$v = ((BinaryContext)$ctx).e(0).v + ((BinaryContext)$ctx).e(1).v;}  # binary\n");
+		grammarBuilder.append("  | INT         {$v = $INT.int;}                   # anInt\n");
+		grammarBuilder.append("  | '(' e ')'   {$v = $e.v;}                       # parens\n");
+		grammarBuilder.append("  | left=e INC  {Debug.Assert(((UnaryContext)$ctx).INC() != null);$v = $left.v + 1;}      # unary\n");
+		grammarBuilder.append("  | left=e DEC  {Debug.Assert(((UnaryContext)$ctx).DEC() != null);$v = $left.v - 1;}      # unary\n");
+		grammarBuilder.append("  | ID          {$v = 3;}                                                     # anID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("INC : '++' ;\n");
+		grammarBuilder.append("DEC : '--' ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="1+2";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("3\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleAlternativesWithCommonLabel_3() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(741);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {Console.WriteLine($e.v);};\n");
+		grammarBuilder.append("e returns [int v]\n");
+		grammarBuilder.append("  : e '*' e     {$v = ((BinaryContext)$ctx).e(0).v * ((BinaryContext)$ctx).e(1).v;}  # binary\n");
+		grammarBuilder.append("  | e '+' e     {$v = ((BinaryContext)$ctx).e(0).v + ((BinaryContext)$ctx).e(1).v;}  # binary\n");
+		grammarBuilder.append("  | INT         {$v = $INT.int;}                   # anInt\n");
+		grammarBuilder.append("  | '(' e ')'   {$v = $e.v;}                       # parens\n");
+		grammarBuilder.append("  | left=e INC  {Debug.Assert(((UnaryContext)$ctx).INC() != null);$v = $left.v + 1;}      # unary\n");
+		grammarBuilder.append("  | left=e DEC  {Debug.Assert(((UnaryContext)$ctx).DEC() != null);$v = $left.v - 1;}      # unary\n");
+		grammarBuilder.append("  | ID          {$v = 3;}                                                     # anID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("INC : '++' ;\n");
+		grammarBuilder.append("DEC : '--' ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="1+2*3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("7\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleAlternativesWithCommonLabel_4() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(741);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {Console.WriteLine($e.v);};\n");
+		grammarBuilder.append("e returns [int v]\n");
+		grammarBuilder.append("  : e '*' e     {$v = ((BinaryContext)$ctx).e(0).v * ((BinaryContext)$ctx).e(1).v;}  # binary\n");
+		grammarBuilder.append("  | e '+' e     {$v = ((BinaryContext)$ctx).e(0).v + ((BinaryContext)$ctx).e(1).v;}  # binary\n");
+		grammarBuilder.append("  | INT         {$v = $INT.int;}                   # anInt\n");
+		grammarBuilder.append("  | '(' e ')'   {$v = $e.v;}                       # parens\n");
+		grammarBuilder.append("  | left=e INC  {Debug.Assert(((UnaryContext)$ctx).INC() != null);$v = $left.v + 1;}      # unary\n");
+		grammarBuilder.append("  | left=e DEC  {Debug.Assert(((UnaryContext)$ctx).DEC() != null);$v = $left.v - 1;}      # unary\n");
+		grammarBuilder.append("  | ID          {$v = 3;}                                                     # anID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("INC : '++' ;\n");
+		grammarBuilder.append("DEC : '--' ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="i++*3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("12\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPrecedenceFilterConsidersContext() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(149);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("prog \n");
+		grammarBuilder.append("@after {Console.WriteLine($ctx.ToStringTree(this));}\n");
+		grammarBuilder.append(": statement* EOF {};\n");
+		grammarBuilder.append("statement: letterA | statement letterA 'b' ;\n");
+		grammarBuilder.append("letterA: 'a';");
+		String grammar = grammarBuilder.toString();
+		String input ="aa";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "prog", input, false);
+		assertEquals("(prog (statement (letterA a)) (statement (letterA a)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPrefixAndOtherAlt_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(223);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : expr EOF ; \n");
+		grammarBuilder.append("expr : literal\n");
+		grammarBuilder.append("     | op expr\n");
+		grammarBuilder.append("     | expr op expr\n");
+		grammarBuilder.append("     ;\n");
+		grammarBuilder.append("literal : '-'? Integer ;\n");
+		grammarBuilder.append("op : '+' | '-' ;\n");
+		grammarBuilder.append("Integer : [0-9]+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="-1";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (expr (literal - 1)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPrefixAndOtherAlt_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(223);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : expr EOF ; \n");
+		grammarBuilder.append("expr : literal\n");
+		grammarBuilder.append("     | op expr\n");
+		grammarBuilder.append("     | expr op expr\n");
+		grammarBuilder.append("     ;\n");
+		grammarBuilder.append("literal : '-'? Integer ;\n");
+		grammarBuilder.append("op : '+' | '-' ;\n");
+		grammarBuilder.append("Integer : [0-9]+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="-1 + -1";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (expr (expr (literal - 1)) (op +) (expr (literal - 1))) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPrefixOpWithActionAndLabel_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(342);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {Console.WriteLine($e.result);} ;\n");
+		grammarBuilder.append("e returns [String result]\n");
+		grammarBuilder.append("    :   ID '=' e1=e    {$result = \"(\" + $ID.text + \"=\" + $e1.result + \")\";}\n");
+		grammarBuilder.append("    |   ID             {$result = $ID.text;}\n");
+		grammarBuilder.append("    |   e1=e '+' e2=e  {$result = \"(\" + $e1.result + \"+\" + $e2.result + \")\";}\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("a\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPrefixOpWithActionAndLabel_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(342);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {Console.WriteLine($e.result);} ;\n");
+		grammarBuilder.append("e returns [String result]\n");
+		grammarBuilder.append("    :   ID '=' e1=e    {$result = \"(\" + $ID.text + \"=\" + $e1.result + \")\";}\n");
+		grammarBuilder.append("    |   ID             {$result = $ID.text;}\n");
+		grammarBuilder.append("    |   e1=e '+' e2=e  {$result = \"(\" + $e1.result + \"+\" + $e2.result + \")\";}\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a+b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(a+b)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPrefixOpWithActionAndLabel_3() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(342);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {Console.WriteLine($e.result);} ;\n");
+		grammarBuilder.append("e returns [String result]\n");
+		grammarBuilder.append("    :   ID '=' e1=e    {$result = \"(\" + $ID.text + \"=\" + $e1.result + \")\";}\n");
+		grammarBuilder.append("    |   ID             {$result = $ID.text;}\n");
+		grammarBuilder.append("    |   e1=e '+' e2=e  {$result = \"(\" + $e1.result + \"+\" + $e2.result + \")\";}\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a=b+c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("((a=b)+c)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsAndLabels_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(460);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : q=e {Console.WriteLine($e.v);}; \n");
+		grammarBuilder.append("e returns [int v]\n");
+		grammarBuilder.append("  : a=e op='*' b=e {$v = $a.v * $b.v;}  # mult\n");
+		grammarBuilder.append("  | a=e '+' b=e {$v = $a.v + $b.v;}     # add\n");
+		grammarBuilder.append("  | INT         {$v = $INT.int;}        # anInt\n");
+		grammarBuilder.append("  | '(' x=e ')' {$v = $x.v;}            # parens\n");
+		grammarBuilder.append("  | x=e '++'    {$v = $x.v+1;}          # inc\n");
+		grammarBuilder.append("  | e '--'                              # dec\n");
+		grammarBuilder.append("  | ID          {$v = 3;}               # anID\n");
+		grammarBuilder.append("  ; \n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="4";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("4\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsAndLabels_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(460);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : q=e {Console.WriteLine($e.v);}; \n");
+		grammarBuilder.append("e returns [int v]\n");
+		grammarBuilder.append("  : a=e op='*' b=e {$v = $a.v * $b.v;}  # mult\n");
+		grammarBuilder.append("  | a=e '+' b=e {$v = $a.v + $b.v;}     # add\n");
+		grammarBuilder.append("  | INT         {$v = $INT.int;}        # anInt\n");
+		grammarBuilder.append("  | '(' x=e ')' {$v = $x.v;}            # parens\n");
+		grammarBuilder.append("  | x=e '++'    {$v = $x.v+1;}          # inc\n");
+		grammarBuilder.append("  | e '--'                              # dec\n");
+		grammarBuilder.append("  | ID          {$v = 3;}               # anID\n");
+		grammarBuilder.append("  ; \n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="1+2";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("3\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsAndLabels_3() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(460);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : q=e {Console.WriteLine($e.v);}; \n");
+		grammarBuilder.append("e returns [int v]\n");
+		grammarBuilder.append("  : a=e op='*' b=e {$v = $a.v * $b.v;}  # mult\n");
+		grammarBuilder.append("  | a=e '+' b=e {$v = $a.v + $b.v;}     # add\n");
+		grammarBuilder.append("  | INT         {$v = $INT.int;}        # anInt\n");
+		grammarBuilder.append("  | '(' x=e ')' {$v = $x.v;}            # parens\n");
+		grammarBuilder.append("  | x=e '++'    {$v = $x.v+1;}          # inc\n");
+		grammarBuilder.append("  | e '--'                              # dec\n");
+		grammarBuilder.append("  | ID          {$v = 3;}               # anID\n");
+		grammarBuilder.append("  ; \n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="1+2*3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("7\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsAndLabels_4() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(460);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : q=e {Console.WriteLine($e.v);}; \n");
+		grammarBuilder.append("e returns [int v]\n");
+		grammarBuilder.append("  : a=e op='*' b=e {$v = $a.v * $b.v;}  # mult\n");
+		grammarBuilder.append("  | a=e '+' b=e {$v = $a.v + $b.v;}     # add\n");
+		grammarBuilder.append("  | INT         {$v = $INT.int;}        # anInt\n");
+		grammarBuilder.append("  | '(' x=e ')' {$v = $x.v;}            # parens\n");
+		grammarBuilder.append("  | x=e '++'    {$v = $x.v+1;}          # inc\n");
+		grammarBuilder.append("  | e '--'                              # dec\n");
+		grammarBuilder.append("  | ID          {$v = 3;}               # anID\n");
+		grammarBuilder.append("  ; \n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="i++*3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("12\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsList1_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(307);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : expr EOF;\n");
+		grammarBuilder.append("expr:\n");
+		grammarBuilder.append("    a=expr '*' a=expr #Factor\n");
+		grammarBuilder.append("    | b+=expr (',' b+=expr)* '>>' c=expr #Send\n");
+		grammarBuilder.append("    | ID #JustId //semantic check on modifiers\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("ID  : ('a'..'z'|'A'..'Z'|'_')\n");
+		grammarBuilder.append("      ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a*b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (expr (expr a) * (expr b)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsList1_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(307);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : expr EOF;\n");
+		grammarBuilder.append("expr:\n");
+		grammarBuilder.append("    a=expr '*' a=expr #Factor\n");
+		grammarBuilder.append("    | b+=expr (',' b+=expr)* '>>' c=expr #Send\n");
+		grammarBuilder.append("    | ID #JustId //semantic check on modifiers\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("ID  : ('a'..'z'|'A'..'Z'|'_')\n");
+		grammarBuilder.append("      ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a,c>>x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (expr (expr a) , (expr c) >> (expr x)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsList1_3() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(307);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : expr EOF;\n");
+		grammarBuilder.append("expr:\n");
+		grammarBuilder.append("    a=expr '*' a=expr #Factor\n");
+		grammarBuilder.append("    | b+=expr (',' b+=expr)* '>>' c=expr #Send\n");
+		grammarBuilder.append("    | ID #JustId //semantic check on modifiers\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("ID  : ('a'..'z'|'A'..'Z'|'_')\n");
+		grammarBuilder.append("      ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (expr x) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsList1_4() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(307);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : expr EOF;\n");
+		grammarBuilder.append("expr:\n");
+		grammarBuilder.append("    a=expr '*' a=expr #Factor\n");
+		grammarBuilder.append("    | b+=expr (',' b+=expr)* '>>' c=expr #Send\n");
+		grammarBuilder.append("    | ID #JustId //semantic check on modifiers\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("ID  : ('a'..'z'|'A'..'Z'|'_')\n");
+		grammarBuilder.append("      ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a*b,c,x*y>>r";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (expr (expr (expr a) * (expr b)) , (expr c) , (expr (expr x) * (expr y)) >> (expr r)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsList2_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(324);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : expr EOF;\n");
+		grammarBuilder.append("expr:\n");
+		grammarBuilder.append("    a=expr '*' a=expr #Factor\n");
+		grammarBuilder.append("    | b+=expr ',' b+=expr #Comma\n");
+		grammarBuilder.append("    | b+=expr '>>' c=expr #Send\n");
+		grammarBuilder.append("    | ID #JustId //semantic check on modifiers\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("ID  : ('a'..'z'|'A'..'Z'|'_')\n");
+		grammarBuilder.append("      ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a*b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (expr (expr a) * (expr b)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsList2_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(324);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : expr EOF;\n");
+		grammarBuilder.append("expr:\n");
+		grammarBuilder.append("    a=expr '*' a=expr #Factor\n");
+		grammarBuilder.append("    | b+=expr ',' b+=expr #Comma\n");
+		grammarBuilder.append("    | b+=expr '>>' c=expr #Send\n");
+		grammarBuilder.append("    | ID #JustId //semantic check on modifiers\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("ID  : ('a'..'z'|'A'..'Z'|'_')\n");
+		grammarBuilder.append("      ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a,c>>x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (expr (expr (expr a) , (expr c)) >> (expr x)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsList2_3() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(324);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : expr EOF;\n");
+		grammarBuilder.append("expr:\n");
+		grammarBuilder.append("    a=expr '*' a=expr #Factor\n");
+		grammarBuilder.append("    | b+=expr ',' b+=expr #Comma\n");
+		grammarBuilder.append("    | b+=expr '>>' c=expr #Send\n");
+		grammarBuilder.append("    | ID #JustId //semantic check on modifiers\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("ID  : ('a'..'z'|'A'..'Z'|'_')\n");
+		grammarBuilder.append("      ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (expr x) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsList2_4() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(324);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : expr EOF;\n");
+		grammarBuilder.append("expr:\n");
+		grammarBuilder.append("    a=expr '*' a=expr #Factor\n");
+		grammarBuilder.append("    | b+=expr ',' b+=expr #Comma\n");
+		grammarBuilder.append("    | b+=expr '>>' c=expr #Send\n");
+		grammarBuilder.append("    | ID #JustId //semantic check on modifiers\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("ID  : ('a'..'z'|'A'..'Z'|'_')\n");
+		grammarBuilder.append("      ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a*b,c,x*y>>r";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (expr (expr (expr (expr (expr a) * (expr b)) , (expr c)) , (expr (expr x) * (expr y))) >> (expr r)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActions_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(260);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {Console.WriteLine($e.v);}; \n");
+		grammarBuilder.append("e returns [int v, List<String> ignored]\n");
+		grammarBuilder.append("  : a=e '*' b=e {$v = $a.v * $b.v;}\n");
+		grammarBuilder.append("  | a=e '+' b=e {$v = $a.v + $b.v;}\n");
+		grammarBuilder.append("  | INT {$v = $INT.int;}\n");
+		grammarBuilder.append("  | '(' x=e ')' {$v = $x.v;}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;\n");
+		String grammar = grammarBuilder.toString();
+		String input ="4";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("4\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActions_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(260);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {Console.WriteLine($e.v);}; \n");
+		grammarBuilder.append("e returns [int v, List<String> ignored]\n");
+		grammarBuilder.append("  : a=e '*' b=e {$v = $a.v * $b.v;}\n");
+		grammarBuilder.append("  | a=e '+' b=e {$v = $a.v + $b.v;}\n");
+		grammarBuilder.append("  | INT {$v = $INT.int;}\n");
+		grammarBuilder.append("  | '(' x=e ')' {$v = $x.v;}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;\n");
+		String grammar = grammarBuilder.toString();
+		String input ="1+2";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("3\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActions_3() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(260);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {Console.WriteLine($e.v);}; \n");
+		grammarBuilder.append("e returns [int v, List<String> ignored]\n");
+		grammarBuilder.append("  : a=e '*' b=e {$v = $a.v * $b.v;}\n");
+		grammarBuilder.append("  | a=e '+' b=e {$v = $a.v + $b.v;}\n");
+		grammarBuilder.append("  | INT {$v = $INT.int;}\n");
+		grammarBuilder.append("  | '(' x=e ')' {$v = $x.v;}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;\n");
+		String grammar = grammarBuilder.toString();
+		String input ="1+2*3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("7\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActions_4() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(260);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {Console.WriteLine($e.v);}; \n");
+		grammarBuilder.append("e returns [int v, List<String> ignored]\n");
+		grammarBuilder.append("  : a=e '*' b=e {$v = $a.v * $b.v;}\n");
+		grammarBuilder.append("  | a=e '+' b=e {$v = $a.v + $b.v;}\n");
+		grammarBuilder.append("  | INT {$v = $INT.int;}\n");
+		grammarBuilder.append("  | '(' x=e ')' {$v = $x.v;}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;\n");
+		String grammar = grammarBuilder.toString();
+		String input ="(1+2)*3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("9\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSemPred() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(142);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : a ;\n");
+		grammarBuilder.append("a : a {true}? ID\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x y z";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (a (a (a x) y) z))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSemPredFailOption() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(166);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : a ;\n");
+		grammarBuilder.append("a : a ID {false}?<fail='custom message'>\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x y z";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (a (a x) y z))\n", found);
+
+		assertEquals("line 1:4 rule a custom message\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSimple_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(134);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : a ;\n");
+		grammarBuilder.append("a : a ID\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (a x))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSimple_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(134);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : a ;\n");
+		grammarBuilder.append("a : a ID\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x y";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (a (a x) y))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSimple_3() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(134);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : a ;\n");
+		grammarBuilder.append("a : a ID\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x y z";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (a (a (a x) y) z))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExprExplicitAssociativity_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(290);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : e EOF; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e :<assoc=right> e '*' e\n");
+		grammarBuilder.append("  |<assoc=right> e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e a) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExprExplicitAssociativity_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(290);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : e EOF; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e :<assoc=right> e '*' e\n");
+		grammarBuilder.append("  |<assoc=right> e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a+b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e a) + (e b)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExprExplicitAssociativity_3() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(290);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : e EOF; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e :<assoc=right> e '*' e\n");
+		grammarBuilder.append("  |<assoc=right> e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a*b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e a) * (e b)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExprExplicitAssociativity_4() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(290);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : e EOF; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e :<assoc=right> e '*' e\n");
+		grammarBuilder.append("  |<assoc=right> e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a?b:c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e a) ? (e b) : (e c)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExprExplicitAssociativity_5() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(290);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : e EOF; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e :<assoc=right> e '*' e\n");
+		grammarBuilder.append("  |<assoc=right> e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a=b=c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e a) = (e (e b) = (e c))) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExprExplicitAssociativity_6() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(290);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : e EOF; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e :<assoc=right> e '*' e\n");
+		grammarBuilder.append("  |<assoc=right> e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a?b+c:d";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e a) ? (e (e b) + (e c)) : (e d)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExprExplicitAssociativity_7() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(290);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : e EOF; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e :<assoc=right> e '*' e\n");
+		grammarBuilder.append("  |<assoc=right> e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a?b=c:d";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e a) ? (e (e b) = (e c)) : (e d)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExprExplicitAssociativity_8() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(290);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : e EOF; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e :<assoc=right> e '*' e\n");
+		grammarBuilder.append("  |<assoc=right> e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a? b?c:d : e";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e a) ? (e (e b) ? (e c) : (e d)) : (e e)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExprExplicitAssociativity_9() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(290);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : e EOF; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e :<assoc=right> e '*' e\n");
+		grammarBuilder.append("  |<assoc=right> e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a?b: c?d:e";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e a) ? (e b) : (e (e c) ? (e d) : (e e))) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExpr_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(265);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : e EOF ; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e : e '*' e\n");
+		grammarBuilder.append("  | e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e a) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExpr_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(265);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : e EOF ; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e : e '*' e\n");
+		grammarBuilder.append("  | e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a+b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e a) + (e b)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExpr_3() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(265);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : e EOF ; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e : e '*' e\n");
+		grammarBuilder.append("  | e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a*b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e a) * (e b)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExpr_4() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(265);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : e EOF ; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e : e '*' e\n");
+		grammarBuilder.append("  | e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a?b:c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e a) ? (e b) : (e c)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExpr_5() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(265);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : e EOF ; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e : e '*' e\n");
+		grammarBuilder.append("  | e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a=b=c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e a) = (e (e b) = (e c))) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExpr_6() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(265);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : e EOF ; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e : e '*' e\n");
+		grammarBuilder.append("  | e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a?b+c:d";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e a) ? (e (e b) + (e c)) : (e d)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExpr_7() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(265);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : e EOF ; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e : e '*' e\n");
+		grammarBuilder.append("  | e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a?b=c:d";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e a) ? (e (e b) = (e c)) : (e d)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExpr_8() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(265);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : e EOF ; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e : e '*' e\n");
+		grammarBuilder.append("  | e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a? b?c:d : e";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e a) ? (e (e b) ? (e c) : (e d)) : (e e)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExpr_9() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(265);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {Console.WriteLine($ctx.ToStringTree(this));} : e EOF ; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e : e '*' e\n");
+		grammarBuilder.append("  | e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a?b: c?d:e";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e a) ? (e b) : (e (e c) ? (e d) : (e e))) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testWhitespaceInfluence_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(2763);
+		grammarBuilder.append("grammar Expr;\n");
+		grammarBuilder.append("prog : expression EOF;\n");
+		grammarBuilder.append("expression\n");
+		grammarBuilder.append("    : ID '(' expression (',' expression)* ')'               # doFunction\n");
+		grammarBuilder.append("    | '(' expression ')'                                    # doParenthesis\n");
+		grammarBuilder.append("    | '!' expression                                        # doNot\n");
+		grammarBuilder.append("    | '-' expression                                        # doNegate\n");
+		grammarBuilder.append("    | '+' expression                                        # doPositiv\n");
+		grammarBuilder.append("    | expression '^' expression                             # doPower\n");
+		grammarBuilder.append("    | expression '*' expression                             # doMultipy\n");
+		grammarBuilder.append("    | expression '/' expression                             # doDivide\n");
+		grammarBuilder.append("    | expression '%' expression                             # doModulo\n");
+		grammarBuilder.append("    | expression '-' expression                             # doMinus\n");
+		grammarBuilder.append("    | expression '+' expression                             # doPlus\n");
+		grammarBuilder.append("    | expression '=' expression                             # doEqual\n");
+		grammarBuilder.append("    | expression '!=' expression                            # doNotEqual\n");
+		grammarBuilder.append("    | expression '>' expression                             # doGreather\n");
+		grammarBuilder.append("    | expression '>=' expression                            # doGreatherEqual\n");
+		grammarBuilder.append("    | expression '<' expression                             # doLesser\n");
+		grammarBuilder.append("    | expression '<=' expression                            # doLesserEqual\n");
+		grammarBuilder.append("    | expression K_IN '(' expression (',' expression)* ')'  # doIn\n");
+		grammarBuilder.append("    | expression ( '&' | K_AND) expression                  # doAnd\n");
+		grammarBuilder.append("    | expression ( '|' | K_OR) expression                   # doOr\n");
+		grammarBuilder.append("    | '[' expression (',' expression)* ']'                  # newArray\n");
+		grammarBuilder.append("    | K_TRUE                                                # newTrueBoolean\n");
+		grammarBuilder.append("    | K_FALSE                                               # newFalseBoolean\n");
+		grammarBuilder.append("    | NUMBER                                                # newNumber\n");
+		grammarBuilder.append("    | DATE                                                  # newDateTime\n");
+		grammarBuilder.append("    | ID                                                    # newIdentifier\n");
+		grammarBuilder.append("    | SQ_STRING                                             # newString\n");
+		grammarBuilder.append("    | K_NULL                                                # newNull\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("// Fragments\n");
+		grammarBuilder.append("fragment DIGIT    : '0' .. '9';  \n");
+		grammarBuilder.append("fragment UPPER    : 'A' .. 'Z';\n");
+		grammarBuilder.append("fragment LOWER    : 'a' .. 'z';\n");
+		grammarBuilder.append("fragment LETTER   : LOWER | UPPER;\n");
+		grammarBuilder.append("fragment WORD     : LETTER | '_' | '$' | '#' | '.';\n");
+		grammarBuilder.append("fragment ALPHANUM : WORD | DIGIT;  \n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("// Tokens\n");
+		grammarBuilder.append("ID              : LETTER ALPHANUM*;\n");
+		grammarBuilder.append("NUMBER          : DIGIT+ ('.' DIGIT+)? (('e'|'E')('+'|'-')? DIGIT+)?;\n");
+		grammarBuilder.append("DATE            : '\\'' DIGIT DIGIT DIGIT DIGIT '-' DIGIT DIGIT '-' DIGIT DIGIT (' ' DIGIT DIGIT ':' DIGIT DIGIT ':' DIGIT DIGIT ('.' DIGIT+)?)? '\\'';\n");
+		grammarBuilder.append("SQ_STRING       : '\\'' ('\\'\\'' | ~'\\'')* '\\'';\n");
+		grammarBuilder.append("DQ_STRING       : '\"' ('\\\\\"' | ~'\"')* '\"';\n");
+		grammarBuilder.append("WS              : [ \\t\\n\\r]+ -> skip ;\n");
+		grammarBuilder.append("COMMENTS        : ('/*' .*? '*/' | '//' ~'\\n'* '\\n' ) -> skip;");
+		String grammar = grammarBuilder.toString();
+		String input ="Test(1,3)";
+		String found = execParser("Expr.g4", grammar, "ExprParser", "ExprLexer", "prog", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testWhitespaceInfluence_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(2763);
+		grammarBuilder.append("grammar Expr;\n");
+		grammarBuilder.append("prog : expression EOF;\n");
+		grammarBuilder.append("expression\n");
+		grammarBuilder.append("    : ID '(' expression (',' expression)* ')'               # doFunction\n");
+		grammarBuilder.append("    | '(' expression ')'                                    # doParenthesis\n");
+		grammarBuilder.append("    | '!' expression                                        # doNot\n");
+		grammarBuilder.append("    | '-' expression                                        # doNegate\n");
+		grammarBuilder.append("    | '+' expression                                        # doPositiv\n");
+		grammarBuilder.append("    | expression '^' expression                             # doPower\n");
+		grammarBuilder.append("    | expression '*' expression                             # doMultipy\n");
+		grammarBuilder.append("    | expression '/' expression                             # doDivide\n");
+		grammarBuilder.append("    | expression '%' expression                             # doModulo\n");
+		grammarBuilder.append("    | expression '-' expression                             # doMinus\n");
+		grammarBuilder.append("    | expression '+' expression                             # doPlus\n");
+		grammarBuilder.append("    | expression '=' expression                             # doEqual\n");
+		grammarBuilder.append("    | expression '!=' expression                            # doNotEqual\n");
+		grammarBuilder.append("    | expression '>' expression                             # doGreather\n");
+		grammarBuilder.append("    | expression '>=' expression                            # doGreatherEqual\n");
+		grammarBuilder.append("    | expression '<' expression                             # doLesser\n");
+		grammarBuilder.append("    | expression '<=' expression                            # doLesserEqual\n");
+		grammarBuilder.append("    | expression K_IN '(' expression (',' expression)* ')'  # doIn\n");
+		grammarBuilder.append("    | expression ( '&' | K_AND) expression                  # doAnd\n");
+		grammarBuilder.append("    | expression ( '|' | K_OR) expression                   # doOr\n");
+		grammarBuilder.append("    | '[' expression (',' expression)* ']'                  # newArray\n");
+		grammarBuilder.append("    | K_TRUE                                                # newTrueBoolean\n");
+		grammarBuilder.append("    | K_FALSE                                               # newFalseBoolean\n");
+		grammarBuilder.append("    | NUMBER                                                # newNumber\n");
+		grammarBuilder.append("    | DATE                                                  # newDateTime\n");
+		grammarBuilder.append("    | ID                                                    # newIdentifier\n");
+		grammarBuilder.append("    | SQ_STRING                                             # newString\n");
+		grammarBuilder.append("    | K_NULL                                                # newNull\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("// Fragments\n");
+		grammarBuilder.append("fragment DIGIT    : '0' .. '9';  \n");
+		grammarBuilder.append("fragment UPPER    : 'A' .. 'Z';\n");
+		grammarBuilder.append("fragment LOWER    : 'a' .. 'z';\n");
+		grammarBuilder.append("fragment LETTER   : LOWER | UPPER;\n");
+		grammarBuilder.append("fragment WORD     : LETTER | '_' | '$' | '#' | '.';\n");
+		grammarBuilder.append("fragment ALPHANUM : WORD | DIGIT;  \n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("// Tokens\n");
+		grammarBuilder.append("ID              : LETTER ALPHANUM*;\n");
+		grammarBuilder.append("NUMBER          : DIGIT+ ('.' DIGIT+)? (('e'|'E')('+'|'-')? DIGIT+)?;\n");
+		grammarBuilder.append("DATE            : '\\'' DIGIT DIGIT DIGIT DIGIT '-' DIGIT DIGIT '-' DIGIT DIGIT (' ' DIGIT DIGIT ':' DIGIT DIGIT ':' DIGIT DIGIT ('.' DIGIT+)?)? '\\'';\n");
+		grammarBuilder.append("SQ_STRING       : '\\'' ('\\'\\'' | ~'\\'')* '\\'';\n");
+		grammarBuilder.append("DQ_STRING       : '\"' ('\\\\\"' | ~'\"')* '\"';\n");
+		grammarBuilder.append("WS              : [ \\t\\n\\r]+ -> skip ;\n");
+		grammarBuilder.append("COMMENTS        : ('/*' .*? '*/' | '//' ~'\\n'* '\\n' ) -> skip;");
+		String grammar = grammarBuilder.toString();
+		String input ="Test(1, 3)";
+		String found = execParser("Expr.g4", grammar, "ExprParser", "ExprLexer", "prog", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+}
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/csharp/TestLexerErrors.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/csharp/TestLexerErrors.java
new file mode 100644
index 000000000..3df43f3d7
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/csharp/TestLexerErrors.java
@@ -0,0 +1,233 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.csharp;
+
+import org.junit.Test;
+import org.junit.Ignore;
+
+@SuppressWarnings("unused")
+public class TestLexerErrors extends BaseTest {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDFAToATNThatFailsBackToDFA() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(39);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : 'ab' ;\n");
+		grammarBuilder.append("B : 'abc' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="ababx";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:1='ab',<1>,1:0]\n" +
+			"[@1,2:3='ab',<1>,1:2]\n" +
+			"[@2,5:4='<EOF>',<-1>,1:5]\n", found);
+
+		assertEquals("line 1:4 token recognition error at: 'x'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDFAToATNThatMatchesThenFailsInATN() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(52);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : 'ab' ;\n");
+		grammarBuilder.append("B : 'abc' ;\n");
+		grammarBuilder.append("C : 'abcd' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="ababcx";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:1='ab',<1>,1:0]\n" +
+			"[@1,2:4='abc',<2>,1:2]\n" +
+			"[@2,6:5='<EOF>',<-1>,1:6]\n", found);
+
+		assertEquals("line 1:5 token recognition error at: 'x'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testEnforcedGreedyNestedBrances_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(77);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("ACTION : '{' (ACTION | ~[{}])* '}';\n");
+		grammarBuilder.append("WS : [ \\r\\n\\t]+ -> skip;");
+		String grammar = grammarBuilder.toString();
+		String input ="{ { } }";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:6='{ { } }',<1>,1:0]\n" +
+			"[@1,7:6='<EOF>',<-1>,1:7]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testEnforcedGreedyNestedBrances_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(77);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("ACTION : '{' (ACTION | ~[{}])* '}';\n");
+		grammarBuilder.append("WS : [ \\r\\n\\t]+ -> skip;");
+		String grammar = grammarBuilder.toString();
+		String input ="{ { }";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals("[@0,5:4='<EOF>',<-1>,1:5]\n", found);
+
+		assertEquals("line 1:0 token recognition error at: '{ { }'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testErrorInMiddle() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(28);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : 'abc' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="abx";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals("[@0,3:2='<EOF>',<-1>,1:3]\n", found);
+
+		assertEquals("line 1:0 token recognition error at: 'abx'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testInvalidCharAtStart() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(30);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : 'a' 'b' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals("[@0,1:0='<EOF>',<-1>,1:1]\n", found);
+
+		assertEquals("line 1:0 token recognition error at: 'x'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testInvalidCharAtStartAfterDFACache() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(30);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : 'a' 'b' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="abx";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:1='ab',<1>,1:0]\n" +
+			"[@1,3:2='<EOF>',<-1>,1:3]\n", found);
+
+		assertEquals("line 1:2 token recognition error at: 'x'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testInvalidCharInToken() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(30);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : 'a' 'b' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="ax";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals("[@0,2:1='<EOF>',<-1>,1:2]\n", found);
+
+		assertEquals("line 1:0 token recognition error at: 'ax'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testInvalidCharInTokenAfterDFACache() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(30);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : 'a' 'b' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="abax";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:1='ab',<1>,1:0]\n" +
+			"[@1,4:3='<EOF>',<-1>,1:4]\n", found);
+
+		assertEquals("line 1:2 token recognition error at: 'ax'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLexerExecDFA() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(98);
+		grammarBuilder.append("grammar L;\n");
+		grammarBuilder.append("start : ID ':' expr;\n");
+		grammarBuilder.append("expr : primary expr? {} | expr '->' ID;\n");
+		grammarBuilder.append("primary : ID;\n");
+		grammarBuilder.append("ID : [a-z]+;");
+		String grammar = grammarBuilder.toString();
+		String input ="x : x";
+		String found = execLexer("L.g4", grammar, "LLexer", input, false);
+		assertEquals(
+			"[@0,0:0='x',<3>,1:0]\n" +
+			"[@1,2:2=':',<1>,1:2]\n" +
+			"[@2,4:4='x',<3>,1:4]\n" +
+			"[@3,5:4='<EOF>',<-1>,1:5]\n", found);
+
+		assertEquals(
+			"line 1:1 token recognition error at: ' '\n" +
+			"line 1:3 token recognition error at: ' '\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testStringsEmbeddedInActions_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(109);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("ACTION2 : '[' (STRING | ~'\"')*? ']';\n");
+		grammarBuilder.append("STRING : '\"' ('\\\"' | .)*? '\"';\n");
+		grammarBuilder.append("WS : [ \\t\\r\\n]+ -> skip;");
+		String grammar = grammarBuilder.toString();
+		String input ="[\"foo\"]";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:6='[\"foo\"]',<1>,1:0]\n" +
+			"[@1,7:6='<EOF>',<-1>,1:7]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testStringsEmbeddedInActions_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(109);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("ACTION2 : '[' (STRING | ~'\"')*? ']';\n");
+		grammarBuilder.append("STRING : '\"' ('\\\"' | .)*? '\"';\n");
+		grammarBuilder.append("WS : [ \\t\\r\\n]+ -> skip;");
+		String grammar = grammarBuilder.toString();
+		String input ="[\"foo]";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals("[@0,6:5='<EOF>',<-1>,1:6]\n", found);
+
+		assertEquals("line 1:0 token recognition error at: '[\"foo]'\n", this.stderrDuringParse);
+
+	}
+
+}
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/csharp/TestLexerExec.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/csharp/TestLexerExec.java
new file mode 100644
index 000000000..96b057a2e
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/csharp/TestLexerExec.java
@@ -0,0 +1,4948 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.csharp;
+
+import org.junit.Test;
+import org.junit.Ignore;
+
+@SuppressWarnings("unused")
+public class TestLexerExec extends BaseTest {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testActionPlacement() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(293);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("I : ({Console.WriteLine(\"stuff fail: \" + this.Text);} 'a'\n");
+		grammarBuilder.append("| {Console.WriteLine(\"stuff0: \" + this.Text);}\n");
+		grammarBuilder.append("		'a' {Console.WriteLine(\"stuff1: \" + this.Text);}\n");
+		grammarBuilder.append("		'b' {Console.WriteLine(\"stuff2: \" + this.Text);})\n");
+		grammarBuilder.append("		{Console.WriteLine(this.Text);} ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;\n");
+		grammarBuilder.append("J : .;");
+		String grammar = grammarBuilder.toString();
+		String input ="ab";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"stuff0: \n" +
+			"stuff1: a\n" +
+			"stuff2: ab\n" +
+			"ab\n" +
+			"[@0,0:1='ab',<1>,1:0]\n" +
+			"[@1,2:1='<EOF>',<-1>,1:2]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(85);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("I : '0'..'9'+ {Console.WriteLine(\"I\");} ;\n");
+		grammarBuilder.append("WS : [ \\n\\u000D] -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input =
+			"34\n" +
+			" 34";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"I\n" +
+			"I\n" +
+			"[@0,0:1='34',<1>,1:0]\n" +
+			"[@1,4:5='34',<1>,2:1]\n" +
+			"[@2,6:5='<EOF>',<-1>,2:3]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetInSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(92);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("I : (~[ab \\n]|'a')  {Console.WriteLine(\"I\");} ;\n");
+		grammarBuilder.append("WS : [ \\n\\u000D]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a x";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"I\n" +
+			"I\n" +
+			"[@0,0:0='a',<1>,1:0]\n" +
+			"[@1,2:2='x',<1>,1:2]\n" +
+			"[@2,3:2='<EOF>',<-1>,1:3]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetNot() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(95);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("I : ~[ab \\n] ~[ \\ncd]* {Console.WriteLine(\"I\");} ;\n");
+		grammarBuilder.append("WS : [ \\n\\u000D]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="xaf";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"I\n" +
+			"[@0,0:2='xaf',<1>,1:0]\n" +
+			"[@1,3:2='<EOF>',<-1>,1:3]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetPlus() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(86);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("I : '0'..'9'+ {Console.WriteLine(\"I\");} ;\n");
+		grammarBuilder.append("WS : [ \\n\\u000D]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input =
+			"34\n" +
+			" 34";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"I\n" +
+			"I\n" +
+			"[@0,0:1='34',<1>,1:0]\n" +
+			"[@1,4:5='34',<1>,2:1]\n" +
+			"[@2,6:5='<EOF>',<-1>,2:3]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetRange() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(141);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("I : [0-9]+ {Console.WriteLine(\"I\");} ;\n");
+		grammarBuilder.append("ID : [a-zA-Z] [a-zA-Z0-9]* {Console.WriteLine(\"ID\");} ;\n");
+		grammarBuilder.append("WS : [ \\n\\u0009\\r]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input =
+			"34\n" +
+			" 34 a2 abc \n" +
+			"   ";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"I\n" +
+			"I\n" +
+			"ID\n" +
+			"ID\n" +
+			"[@0,0:1='34',<1>,1:0]\n" +
+			"[@1,4:5='34',<1>,2:1]\n" +
+			"[@2,7:8='a2',<2>,2:4]\n" +
+			"[@3,10:12='abc',<2>,2:7]\n" +
+			"[@4,18:17='<EOF>',<-1>,3:3]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetWithEscapedChar() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(94);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("DASHBRACK : [\\-\\]]+ {Console.WriteLine(\"DASHBRACK\");} ;\n");
+		grammarBuilder.append("WS : [ \\u]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="- ] ";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"DASHBRACK\n" +
+			"DASHBRACK\n" +
+			"[@0,0:0='-',<1>,1:0]\n" +
+			"[@1,2:2=']',<1>,1:2]\n" +
+			"[@2,4:3='<EOF>',<-1>,1:4]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetWithMissingEndRange() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(82);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("I : [0-]+ {Console.WriteLine(\"I\");} ;\n");
+		grammarBuilder.append("WS : [ \\n\\u000D]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="00\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"I\n" +
+			"[@0,0:1='00',<1>,1:0]\n" +
+			"[@1,3:2='<EOF>',<-1>,2:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetWithMissingEscapeChar() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(77);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("I : [0-9]+ {Console.WriteLine(\"I\");} ;\n");
+		grammarBuilder.append("WS : [ \\u]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="34 ";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"I\n" +
+			"[@0,0:1='34',<1>,1:0]\n" +
+			"[@1,3:2='<EOF>',<-1>,1:3]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetWithQuote1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(80);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : [\"a-z]+ {Console.WriteLine(\"A\");} ;\n");
+		grammarBuilder.append("WS : [ \\n\\t]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="b\"a";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"A\n" +
+			"[@0,0:2='b\"a',<1>,1:0]\n" +
+			"[@1,3:2='<EOF>',<-1>,1:3]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetWithQuote2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(81);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : [\"\\\\ab]+ {Console.WriteLine(\"A\");} ;\n");
+		grammarBuilder.append("WS : [ \\n\\t]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="b\"\\a";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"A\n" +
+			"[@0,0:3='b\"\\a',<1>,1:0]\n" +
+			"[@1,4:3='<EOF>',<-1>,1:4]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetWithReversedRange() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(78);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : [z-a9]+ {Console.WriteLine(\"A\");} ;\n");
+		grammarBuilder.append("WS : [ \\u]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="9";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"A\n" +
+			"[@0,0:0='9',<1>,1:0]\n" +
+			"[@1,1:0='<EOF>',<-1>,1:1]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testEOFByItself() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(38);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("DONE : EOF ;\n");
+		grammarBuilder.append("A : 'a';");
+		String grammar = grammarBuilder.toString();
+		String input ="";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:-1='<EOF>',<1>,1:0]\n" +
+			"[@1,0:-1='<EOF>',<-1>,1:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testEOFSuffixInFirstRule_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(48);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : 'a' EOF ;\n");
+		grammarBuilder.append("B : 'a';\n");
+		grammarBuilder.append("C : 'c';");
+		String grammar = grammarBuilder.toString();
+		String input ="";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals("[@0,0:-1='<EOF>',<-1>,1:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testEOFSuffixInFirstRule_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(48);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : 'a' EOF ;\n");
+		grammarBuilder.append("B : 'a';\n");
+		grammarBuilder.append("C : 'c';");
+		String grammar = grammarBuilder.toString();
+		String input ="a";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:0='a',<1>,1:0]\n" +
+			"[@1,1:0='<EOF>',<-1>,1:1]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testGreedyClosure() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(60);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("CMT : '//' .*? '\\n' CMT*;\n");
+		grammarBuilder.append("WS : (' '|'\\t')+;");
+		String grammar = grammarBuilder.toString();
+		String input =
+			"//blah\n" +
+			"//blah\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:13='//blah\\n//blah\\n',<1>,1:0]\n" +
+			"[@1,14:13='<EOF>',<-1>,3:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testGreedyConfigs() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(100);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("I : ('a' | 'ab') {Console.WriteLine(this.Text);} ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;\n");
+		grammarBuilder.append("J : .;");
+		String grammar = grammarBuilder.toString();
+		String input ="ab";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"ab\n" +
+			"[@0,0:1='ab',<1>,1:0]\n" +
+			"[@1,2:1='<EOF>',<-1>,1:2]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testGreedyOptional() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(60);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("CMT : '//' .*? '\\n' CMT?;\n");
+		grammarBuilder.append("WS : (' '|'\\t')+;");
+		String grammar = grammarBuilder.toString();
+		String input =
+			"//blah\n" +
+			"//blah\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:13='//blah\\n//blah\\n',<1>,1:0]\n" +
+			"[@1,14:13='<EOF>',<-1>,3:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testGreedyPositiveClosure() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(58);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("CMT : ('//' .*? '\\n')+;\n");
+		grammarBuilder.append("WS : (' '|'\\t')+;");
+		String grammar = grammarBuilder.toString();
+		String input =
+			"//blah\n" +
+			"//blah\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:13='//blah\\n//blah\\n',<1>,1:0]\n" +
+			"[@1,14:13='<EOF>',<-1>,3:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testHexVsID() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(265);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("HexLiteral : '0' ('x'|'X') HexDigit+ ;\n");
+		grammarBuilder.append("DecimalLiteral : ('0' | '1'..'9' '0'..'9'*) ;\n");
+		grammarBuilder.append("FloatingPointLiteral : ('0x' | '0X') HexDigit* ('.' HexDigit*)? ;\n");
+		grammarBuilder.append("DOT : '.' ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("fragment HexDigit : ('0'..'9'|'a'..'f'|'A'..'F') ;\n");
+		grammarBuilder.append("WS : (' '|'\\n')+;");
+		String grammar = grammarBuilder.toString();
+		String input ="x 0 1 a.b a.l";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:0='x',<5>,1:0]\n" +
+			"[@1,1:1=' ',<6>,1:1]\n" +
+			"[@2,2:2='0',<2>,1:2]\n" +
+			"[@3,3:3=' ',<6>,1:3]\n" +
+			"[@4,4:4='1',<2>,1:4]\n" +
+			"[@5,5:5=' ',<6>,1:5]\n" +
+			"[@6,6:6='a',<5>,1:6]\n" +
+			"[@7,7:7='.',<4>,1:7]\n" +
+			"[@8,8:8='b',<5>,1:8]\n" +
+			"[@9,9:9=' ',<6>,1:9]\n" +
+			"[@10,10:10='a',<5>,1:10]\n" +
+			"[@11,11:11='.',<4>,1:11]\n" +
+			"[@12,12:12='l',<5>,1:12]\n" +
+			"[@13,13:12='<EOF>',<-1>,1:13]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testKeywordID() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(82);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("KEND : 'end' ; // has priority\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n')+;");
+		String grammar = grammarBuilder.toString();
+		String input ="end eend ending a";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:2='end',<1>,1:0]\n" +
+			"[@1,3:3=' ',<3>,1:3]\n" +
+			"[@2,4:7='eend',<2>,1:4]\n" +
+			"[@3,8:8=' ',<3>,1:8]\n" +
+			"[@4,9:14='ending',<2>,1:9]\n" +
+			"[@5,15:15=' ',<3>,1:15]\n" +
+			"[@6,16:16='a',<2>,1:16]\n" +
+			"[@7,17:16='<EOF>',<-1>,1:17]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLargeLexer() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(85821);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("WS : [ \\t\\r\\n]+ -> skip;\n");
+		grammarBuilder.append("KW0 : 'KW' '0';\n");
+		grammarBuilder.append("KW1 : 'KW' '1';\n");
+		grammarBuilder.append("KW2 : 'KW' '2';\n");
+		grammarBuilder.append("KW3 : 'KW' '3';\n");
+		grammarBuilder.append("KW4 : 'KW' '4';\n");
+		grammarBuilder.append("KW5 : 'KW' '5';\n");
+		grammarBuilder.append("KW6 : 'KW' '6';\n");
+		grammarBuilder.append("KW7 : 'KW' '7';\n");
+		grammarBuilder.append("KW8 : 'KW' '8';\n");
+		grammarBuilder.append("KW9 : 'KW' '9';\n");
+		grammarBuilder.append("KW10 : 'KW' '10';\n");
+		grammarBuilder.append("KW11 : 'KW' '11';\n");
+		grammarBuilder.append("KW12 : 'KW' '12';\n");
+		grammarBuilder.append("KW13 : 'KW' '13';\n");
+		grammarBuilder.append("KW14 : 'KW' '14';\n");
+		grammarBuilder.append("KW15 : 'KW' '15';\n");
+		grammarBuilder.append("KW16 : 'KW' '16';\n");
+		grammarBuilder.append("KW17 : 'KW' '17';\n");
+		grammarBuilder.append("KW18 : 'KW' '18';\n");
+		grammarBuilder.append("KW19 : 'KW' '19';\n");
+		grammarBuilder.append("KW20 : 'KW' '20';\n");
+		grammarBuilder.append("KW21 : 'KW' '21';\n");
+		grammarBuilder.append("KW22 : 'KW' '22';\n");
+		grammarBuilder.append("KW23 : 'KW' '23';\n");
+		grammarBuilder.append("KW24 : 'KW' '24';\n");
+		grammarBuilder.append("KW25 : 'KW' '25';\n");
+		grammarBuilder.append("KW26 : 'KW' '26';\n");
+		grammarBuilder.append("KW27 : 'KW' '27';\n");
+		grammarBuilder.append("KW28 : 'KW' '28';\n");
+		grammarBuilder.append("KW29 : 'KW' '29';\n");
+		grammarBuilder.append("KW30 : 'KW' '30';\n");
+		grammarBuilder.append("KW31 : 'KW' '31';\n");
+		grammarBuilder.append("KW32 : 'KW' '32';\n");
+		grammarBuilder.append("KW33 : 'KW' '33';\n");
+		grammarBuilder.append("KW34 : 'KW' '34';\n");
+		grammarBuilder.append("KW35 : 'KW' '35';\n");
+		grammarBuilder.append("KW36 : 'KW' '36';\n");
+		grammarBuilder.append("KW37 : 'KW' '37';\n");
+		grammarBuilder.append("KW38 : 'KW' '38';\n");
+		grammarBuilder.append("KW39 : 'KW' '39';\n");
+		grammarBuilder.append("KW40 : 'KW' '40';\n");
+		grammarBuilder.append("KW41 : 'KW' '41';\n");
+		grammarBuilder.append("KW42 : 'KW' '42';\n");
+		grammarBuilder.append("KW43 : 'KW' '43';\n");
+		grammarBuilder.append("KW44 : 'KW' '44';\n");
+		grammarBuilder.append("KW45 : 'KW' '45';\n");
+		grammarBuilder.append("KW46 : 'KW' '46';\n");
+		grammarBuilder.append("KW47 : 'KW' '47';\n");
+		grammarBuilder.append("KW48 : 'KW' '48';\n");
+		grammarBuilder.append("KW49 : 'KW' '49';\n");
+		grammarBuilder.append("KW50 : 'KW' '50';\n");
+		grammarBuilder.append("KW51 : 'KW' '51';\n");
+		grammarBuilder.append("KW52 : 'KW' '52';\n");
+		grammarBuilder.append("KW53 : 'KW' '53';\n");
+		grammarBuilder.append("KW54 : 'KW' '54';\n");
+		grammarBuilder.append("KW55 : 'KW' '55';\n");
+		grammarBuilder.append("KW56 : 'KW' '56';\n");
+		grammarBuilder.append("KW57 : 'KW' '57';\n");
+		grammarBuilder.append("KW58 : 'KW' '58';\n");
+		grammarBuilder.append("KW59 : 'KW' '59';\n");
+		grammarBuilder.append("KW60 : 'KW' '60';\n");
+		grammarBuilder.append("KW61 : 'KW' '61';\n");
+		grammarBuilder.append("KW62 : 'KW' '62';\n");
+		grammarBuilder.append("KW63 : 'KW' '63';\n");
+		grammarBuilder.append("KW64 : 'KW' '64';\n");
+		grammarBuilder.append("KW65 : 'KW' '65';\n");
+		grammarBuilder.append("KW66 : 'KW' '66';\n");
+		grammarBuilder.append("KW67 : 'KW' '67';\n");
+		grammarBuilder.append("KW68 : 'KW' '68';\n");
+		grammarBuilder.append("KW69 : 'KW' '69';\n");
+		grammarBuilder.append("KW70 : 'KW' '70';\n");
+		grammarBuilder.append("KW71 : 'KW' '71';\n");
+		grammarBuilder.append("KW72 : 'KW' '72';\n");
+		grammarBuilder.append("KW73 : 'KW' '73';\n");
+		grammarBuilder.append("KW74 : 'KW' '74';\n");
+		grammarBuilder.append("KW75 : 'KW' '75';\n");
+		grammarBuilder.append("KW76 : 'KW' '76';\n");
+		grammarBuilder.append("KW77 : 'KW' '77';\n");
+		grammarBuilder.append("KW78 : 'KW' '78';\n");
+		grammarBuilder.append("KW79 : 'KW' '79';\n");
+		grammarBuilder.append("KW80 : 'KW' '80';\n");
+		grammarBuilder.append("KW81 : 'KW' '81';\n");
+		grammarBuilder.append("KW82 : 'KW' '82';\n");
+		grammarBuilder.append("KW83 : 'KW' '83';\n");
+		grammarBuilder.append("KW84 : 'KW' '84';\n");
+		grammarBuilder.append("KW85 : 'KW' '85';\n");
+		grammarBuilder.append("KW86 : 'KW' '86';\n");
+		grammarBuilder.append("KW87 : 'KW' '87';\n");
+		grammarBuilder.append("KW88 : 'KW' '88';\n");
+		grammarBuilder.append("KW89 : 'KW' '89';\n");
+		grammarBuilder.append("KW90 : 'KW' '90';\n");
+		grammarBuilder.append("KW91 : 'KW' '91';\n");
+		grammarBuilder.append("KW92 : 'KW' '92';\n");
+		grammarBuilder.append("KW93 : 'KW' '93';\n");
+		grammarBuilder.append("KW94 : 'KW' '94';\n");
+		grammarBuilder.append("KW95 : 'KW' '95';\n");
+		grammarBuilder.append("KW96 : 'KW' '96';\n");
+		grammarBuilder.append("KW97 : 'KW' '97';\n");
+		grammarBuilder.append("KW98 : 'KW' '98';\n");
+		grammarBuilder.append("KW99 : 'KW' '99';\n");
+		grammarBuilder.append("KW100 : 'KW' '100';\n");
+		grammarBuilder.append("KW101 : 'KW' '101';\n");
+		grammarBuilder.append("KW102 : 'KW' '102';\n");
+		grammarBuilder.append("KW103 : 'KW' '103';\n");
+		grammarBuilder.append("KW104 : 'KW' '104';\n");
+		grammarBuilder.append("KW105 : 'KW' '105';\n");
+		grammarBuilder.append("KW106 : 'KW' '106';\n");
+		grammarBuilder.append("KW107 : 'KW' '107';\n");
+		grammarBuilder.append("KW108 : 'KW' '108';\n");
+		grammarBuilder.append("KW109 : 'KW' '109';\n");
+		grammarBuilder.append("KW110 : 'KW' '110';\n");
+		grammarBuilder.append("KW111 : 'KW' '111';\n");
+		grammarBuilder.append("KW112 : 'KW' '112';\n");
+		grammarBuilder.append("KW113 : 'KW' '113';\n");
+		grammarBuilder.append("KW114 : 'KW' '114';\n");
+		grammarBuilder.append("KW115 : 'KW' '115';\n");
+		grammarBuilder.append("KW116 : 'KW' '116';\n");
+		grammarBuilder.append("KW117 : 'KW' '117';\n");
+		grammarBuilder.append("KW118 : 'KW' '118';\n");
+		grammarBuilder.append("KW119 : 'KW' '119';\n");
+		grammarBuilder.append("KW120 : 'KW' '120';\n");
+		grammarBuilder.append("KW121 : 'KW' '121';\n");
+		grammarBuilder.append("KW122 : 'KW' '122';\n");
+		grammarBuilder.append("KW123 : 'KW' '123';\n");
+		grammarBuilder.append("KW124 : 'KW' '124';\n");
+		grammarBuilder.append("KW125 : 'KW' '125';\n");
+		grammarBuilder.append("KW126 : 'KW' '126';\n");
+		grammarBuilder.append("KW127 : 'KW' '127';\n");
+		grammarBuilder.append("KW128 : 'KW' '128';\n");
+		grammarBuilder.append("KW129 : 'KW' '129';\n");
+		grammarBuilder.append("KW130 : 'KW' '130';\n");
+		grammarBuilder.append("KW131 : 'KW' '131';\n");
+		grammarBuilder.append("KW132 : 'KW' '132';\n");
+		grammarBuilder.append("KW133 : 'KW' '133';\n");
+		grammarBuilder.append("KW134 : 'KW' '134';\n");
+		grammarBuilder.append("KW135 : 'KW' '135';\n");
+		grammarBuilder.append("KW136 : 'KW' '136';\n");
+		grammarBuilder.append("KW137 : 'KW' '137';\n");
+		grammarBuilder.append("KW138 : 'KW' '138';\n");
+		grammarBuilder.append("KW139 : 'KW' '139';\n");
+		grammarBuilder.append("KW140 : 'KW' '140';\n");
+		grammarBuilder.append("KW141 : 'KW' '141';\n");
+		grammarBuilder.append("KW142 : 'KW' '142';\n");
+		grammarBuilder.append("KW143 : 'KW' '143';\n");
+		grammarBuilder.append("KW144 : 'KW' '144';\n");
+		grammarBuilder.append("KW145 : 'KW' '145';\n");
+		grammarBuilder.append("KW146 : 'KW' '146';\n");
+		grammarBuilder.append("KW147 : 'KW' '147';\n");
+		grammarBuilder.append("KW148 : 'KW' '148';\n");
+		grammarBuilder.append("KW149 : 'KW' '149';\n");
+		grammarBuilder.append("KW150 : 'KW' '150';\n");
+		grammarBuilder.append("KW151 : 'KW' '151';\n");
+		grammarBuilder.append("KW152 : 'KW' '152';\n");
+		grammarBuilder.append("KW153 : 'KW' '153';\n");
+		grammarBuilder.append("KW154 : 'KW' '154';\n");
+		grammarBuilder.append("KW155 : 'KW' '155';\n");
+		grammarBuilder.append("KW156 : 'KW' '156';\n");
+		grammarBuilder.append("KW157 : 'KW' '157';\n");
+		grammarBuilder.append("KW158 : 'KW' '158';\n");
+		grammarBuilder.append("KW159 : 'KW' '159';\n");
+		grammarBuilder.append("KW160 : 'KW' '160';\n");
+		grammarBuilder.append("KW161 : 'KW' '161';\n");
+		grammarBuilder.append("KW162 : 'KW' '162';\n");
+		grammarBuilder.append("KW163 : 'KW' '163';\n");
+		grammarBuilder.append("KW164 : 'KW' '164';\n");
+		grammarBuilder.append("KW165 : 'KW' '165';\n");
+		grammarBuilder.append("KW166 : 'KW' '166';\n");
+		grammarBuilder.append("KW167 : 'KW' '167';\n");
+		grammarBuilder.append("KW168 : 'KW' '168';\n");
+		grammarBuilder.append("KW169 : 'KW' '169';\n");
+		grammarBuilder.append("KW170 : 'KW' '170';\n");
+		grammarBuilder.append("KW171 : 'KW' '171';\n");
+		grammarBuilder.append("KW172 : 'KW' '172';\n");
+		grammarBuilder.append("KW173 : 'KW' '173';\n");
+		grammarBuilder.append("KW174 : 'KW' '174';\n");
+		grammarBuilder.append("KW175 : 'KW' '175';\n");
+		grammarBuilder.append("KW176 : 'KW' '176';\n");
+		grammarBuilder.append("KW177 : 'KW' '177';\n");
+		grammarBuilder.append("KW178 : 'KW' '178';\n");
+		grammarBuilder.append("KW179 : 'KW' '179';\n");
+		grammarBuilder.append("KW180 : 'KW' '180';\n");
+		grammarBuilder.append("KW181 : 'KW' '181';\n");
+		grammarBuilder.append("KW182 : 'KW' '182';\n");
+		grammarBuilder.append("KW183 : 'KW' '183';\n");
+		grammarBuilder.append("KW184 : 'KW' '184';\n");
+		grammarBuilder.append("KW185 : 'KW' '185';\n");
+		grammarBuilder.append("KW186 : 'KW' '186';\n");
+		grammarBuilder.append("KW187 : 'KW' '187';\n");
+		grammarBuilder.append("KW188 : 'KW' '188';\n");
+		grammarBuilder.append("KW189 : 'KW' '189';\n");
+		grammarBuilder.append("KW190 : 'KW' '190';\n");
+		grammarBuilder.append("KW191 : 'KW' '191';\n");
+		grammarBuilder.append("KW192 : 'KW' '192';\n");
+		grammarBuilder.append("KW193 : 'KW' '193';\n");
+		grammarBuilder.append("KW194 : 'KW' '194';\n");
+		grammarBuilder.append("KW195 : 'KW' '195';\n");
+		grammarBuilder.append("KW196 : 'KW' '196';\n");
+		grammarBuilder.append("KW197 : 'KW' '197';\n");
+		grammarBuilder.append("KW198 : 'KW' '198';\n");
+		grammarBuilder.append("KW199 : 'KW' '199';\n");
+		grammarBuilder.append("KW200 : 'KW' '200';\n");
+		grammarBuilder.append("KW201 : 'KW' '201';\n");
+		grammarBuilder.append("KW202 : 'KW' '202';\n");
+		grammarBuilder.append("KW203 : 'KW' '203';\n");
+		grammarBuilder.append("KW204 : 'KW' '204';\n");
+		grammarBuilder.append("KW205 : 'KW' '205';\n");
+		grammarBuilder.append("KW206 : 'KW' '206';\n");
+		grammarBuilder.append("KW207 : 'KW' '207';\n");
+		grammarBuilder.append("KW208 : 'KW' '208';\n");
+		grammarBuilder.append("KW209 : 'KW' '209';\n");
+		grammarBuilder.append("KW210 : 'KW' '210';\n");
+		grammarBuilder.append("KW211 : 'KW' '211';\n");
+		grammarBuilder.append("KW212 : 'KW' '212';\n");
+		grammarBuilder.append("KW213 : 'KW' '213';\n");
+		grammarBuilder.append("KW214 : 'KW' '214';\n");
+		grammarBuilder.append("KW215 : 'KW' '215';\n");
+		grammarBuilder.append("KW216 : 'KW' '216';\n");
+		grammarBuilder.append("KW217 : 'KW' '217';\n");
+		grammarBuilder.append("KW218 : 'KW' '218';\n");
+		grammarBuilder.append("KW219 : 'KW' '219';\n");
+		grammarBuilder.append("KW220 : 'KW' '220';\n");
+		grammarBuilder.append("KW221 : 'KW' '221';\n");
+		grammarBuilder.append("KW222 : 'KW' '222';\n");
+		grammarBuilder.append("KW223 : 'KW' '223';\n");
+		grammarBuilder.append("KW224 : 'KW' '224';\n");
+		grammarBuilder.append("KW225 : 'KW' '225';\n");
+		grammarBuilder.append("KW226 : 'KW' '226';\n");
+		grammarBuilder.append("KW227 : 'KW' '227';\n");
+		grammarBuilder.append("KW228 : 'KW' '228';\n");
+		grammarBuilder.append("KW229 : 'KW' '229';\n");
+		grammarBuilder.append("KW230 : 'KW' '230';\n");
+		grammarBuilder.append("KW231 : 'KW' '231';\n");
+		grammarBuilder.append("KW232 : 'KW' '232';\n");
+		grammarBuilder.append("KW233 : 'KW' '233';\n");
+		grammarBuilder.append("KW234 : 'KW' '234';\n");
+		grammarBuilder.append("KW235 : 'KW' '235';\n");
+		grammarBuilder.append("KW236 : 'KW' '236';\n");
+		grammarBuilder.append("KW237 : 'KW' '237';\n");
+		grammarBuilder.append("KW238 : 'KW' '238';\n");
+		grammarBuilder.append("KW239 : 'KW' '239';\n");
+		grammarBuilder.append("KW240 : 'KW' '240';\n");
+		grammarBuilder.append("KW241 : 'KW' '241';\n");
+		grammarBuilder.append("KW242 : 'KW' '242';\n");
+		grammarBuilder.append("KW243 : 'KW' '243';\n");
+		grammarBuilder.append("KW244 : 'KW' '244';\n");
+		grammarBuilder.append("KW245 : 'KW' '245';\n");
+		grammarBuilder.append("KW246 : 'KW' '246';\n");
+		grammarBuilder.append("KW247 : 'KW' '247';\n");
+		grammarBuilder.append("KW248 : 'KW' '248';\n");
+		grammarBuilder.append("KW249 : 'KW' '249';\n");
+		grammarBuilder.append("KW250 : 'KW' '250';\n");
+		grammarBuilder.append("KW251 : 'KW' '251';\n");
+		grammarBuilder.append("KW252 : 'KW' '252';\n");
+		grammarBuilder.append("KW253 : 'KW' '253';\n");
+		grammarBuilder.append("KW254 : 'KW' '254';\n");
+		grammarBuilder.append("KW255 : 'KW' '255';\n");
+		grammarBuilder.append("KW256 : 'KW' '256';\n");
+		grammarBuilder.append("KW257 : 'KW' '257';\n");
+		grammarBuilder.append("KW258 : 'KW' '258';\n");
+		grammarBuilder.append("KW259 : 'KW' '259';\n");
+		grammarBuilder.append("KW260 : 'KW' '260';\n");
+		grammarBuilder.append("KW261 : 'KW' '261';\n");
+		grammarBuilder.append("KW262 : 'KW' '262';\n");
+		grammarBuilder.append("KW263 : 'KW' '263';\n");
+		grammarBuilder.append("KW264 : 'KW' '264';\n");
+		grammarBuilder.append("KW265 : 'KW' '265';\n");
+		grammarBuilder.append("KW266 : 'KW' '266';\n");
+		grammarBuilder.append("KW267 : 'KW' '267';\n");
+		grammarBuilder.append("KW268 : 'KW' '268';\n");
+		grammarBuilder.append("KW269 : 'KW' '269';\n");
+		grammarBuilder.append("KW270 : 'KW' '270';\n");
+		grammarBuilder.append("KW271 : 'KW' '271';\n");
+		grammarBuilder.append("KW272 : 'KW' '272';\n");
+		grammarBuilder.append("KW273 : 'KW' '273';\n");
+		grammarBuilder.append("KW274 : 'KW' '274';\n");
+		grammarBuilder.append("KW275 : 'KW' '275';\n");
+		grammarBuilder.append("KW276 : 'KW' '276';\n");
+		grammarBuilder.append("KW277 : 'KW' '277';\n");
+		grammarBuilder.append("KW278 : 'KW' '278';\n");
+		grammarBuilder.append("KW279 : 'KW' '279';\n");
+		grammarBuilder.append("KW280 : 'KW' '280';\n");
+		grammarBuilder.append("KW281 : 'KW' '281';\n");
+		grammarBuilder.append("KW282 : 'KW' '282';\n");
+		grammarBuilder.append("KW283 : 'KW' '283';\n");
+		grammarBuilder.append("KW284 : 'KW' '284';\n");
+		grammarBuilder.append("KW285 : 'KW' '285';\n");
+		grammarBuilder.append("KW286 : 'KW' '286';\n");
+		grammarBuilder.append("KW287 : 'KW' '287';\n");
+		grammarBuilder.append("KW288 : 'KW' '288';\n");
+		grammarBuilder.append("KW289 : 'KW' '289';\n");
+		grammarBuilder.append("KW290 : 'KW' '290';\n");
+		grammarBuilder.append("KW291 : 'KW' '291';\n");
+		grammarBuilder.append("KW292 : 'KW' '292';\n");
+		grammarBuilder.append("KW293 : 'KW' '293';\n");
+		grammarBuilder.append("KW294 : 'KW' '294';\n");
+		grammarBuilder.append("KW295 : 'KW' '295';\n");
+		grammarBuilder.append("KW296 : 'KW' '296';\n");
+		grammarBuilder.append("KW297 : 'KW' '297';\n");
+		grammarBuilder.append("KW298 : 'KW' '298';\n");
+		grammarBuilder.append("KW299 : 'KW' '299';\n");
+		grammarBuilder.append("KW300 : 'KW' '300';\n");
+		grammarBuilder.append("KW301 : 'KW' '301';\n");
+		grammarBuilder.append("KW302 : 'KW' '302';\n");
+		grammarBuilder.append("KW303 : 'KW' '303';\n");
+		grammarBuilder.append("KW304 : 'KW' '304';\n");
+		grammarBuilder.append("KW305 : 'KW' '305';\n");
+		grammarBuilder.append("KW306 : 'KW' '306';\n");
+		grammarBuilder.append("KW307 : 'KW' '307';\n");
+		grammarBuilder.append("KW308 : 'KW' '308';\n");
+		grammarBuilder.append("KW309 : 'KW' '309';\n");
+		grammarBuilder.append("KW310 : 'KW' '310';\n");
+		grammarBuilder.append("KW311 : 'KW' '311';\n");
+		grammarBuilder.append("KW312 : 'KW' '312';\n");
+		grammarBuilder.append("KW313 : 'KW' '313';\n");
+		grammarBuilder.append("KW314 : 'KW' '314';\n");
+		grammarBuilder.append("KW315 : 'KW' '315';\n");
+		grammarBuilder.append("KW316 : 'KW' '316';\n");
+		grammarBuilder.append("KW317 : 'KW' '317';\n");
+		grammarBuilder.append("KW318 : 'KW' '318';\n");
+		grammarBuilder.append("KW319 : 'KW' '319';\n");
+		grammarBuilder.append("KW320 : 'KW' '320';\n");
+		grammarBuilder.append("KW321 : 'KW' '321';\n");
+		grammarBuilder.append("KW322 : 'KW' '322';\n");
+		grammarBuilder.append("KW323 : 'KW' '323';\n");
+		grammarBuilder.append("KW324 : 'KW' '324';\n");
+		grammarBuilder.append("KW325 : 'KW' '325';\n");
+		grammarBuilder.append("KW326 : 'KW' '326';\n");
+		grammarBuilder.append("KW327 : 'KW' '327';\n");
+		grammarBuilder.append("KW328 : 'KW' '328';\n");
+		grammarBuilder.append("KW329 : 'KW' '329';\n");
+		grammarBuilder.append("KW330 : 'KW' '330';\n");
+		grammarBuilder.append("KW331 : 'KW' '331';\n");
+		grammarBuilder.append("KW332 : 'KW' '332';\n");
+		grammarBuilder.append("KW333 : 'KW' '333';\n");
+		grammarBuilder.append("KW334 : 'KW' '334';\n");
+		grammarBuilder.append("KW335 : 'KW' '335';\n");
+		grammarBuilder.append("KW336 : 'KW' '336';\n");
+		grammarBuilder.append("KW337 : 'KW' '337';\n");
+		grammarBuilder.append("KW338 : 'KW' '338';\n");
+		grammarBuilder.append("KW339 : 'KW' '339';\n");
+		grammarBuilder.append("KW340 : 'KW' '340';\n");
+		grammarBuilder.append("KW341 : 'KW' '341';\n");
+		grammarBuilder.append("KW342 : 'KW' '342';\n");
+		grammarBuilder.append("KW343 : 'KW' '343';\n");
+		grammarBuilder.append("KW344 : 'KW' '344';\n");
+		grammarBuilder.append("KW345 : 'KW' '345';\n");
+		grammarBuilder.append("KW346 : 'KW' '346';\n");
+		grammarBuilder.append("KW347 : 'KW' '347';\n");
+		grammarBuilder.append("KW348 : 'KW' '348';\n");
+		grammarBuilder.append("KW349 : 'KW' '349';\n");
+		grammarBuilder.append("KW350 : 'KW' '350';\n");
+		grammarBuilder.append("KW351 : 'KW' '351';\n");
+		grammarBuilder.append("KW352 : 'KW' '352';\n");
+		grammarBuilder.append("KW353 : 'KW' '353';\n");
+		grammarBuilder.append("KW354 : 'KW' '354';\n");
+		grammarBuilder.append("KW355 : 'KW' '355';\n");
+		grammarBuilder.append("KW356 : 'KW' '356';\n");
+		grammarBuilder.append("KW357 : 'KW' '357';\n");
+		grammarBuilder.append("KW358 : 'KW' '358';\n");
+		grammarBuilder.append("KW359 : 'KW' '359';\n");
+		grammarBuilder.append("KW360 : 'KW' '360';\n");
+		grammarBuilder.append("KW361 : 'KW' '361';\n");
+		grammarBuilder.append("KW362 : 'KW' '362';\n");
+		grammarBuilder.append("KW363 : 'KW' '363';\n");
+		grammarBuilder.append("KW364 : 'KW' '364';\n");
+		grammarBuilder.append("KW365 : 'KW' '365';\n");
+		grammarBuilder.append("KW366 : 'KW' '366';\n");
+		grammarBuilder.append("KW367 : 'KW' '367';\n");
+		grammarBuilder.append("KW368 : 'KW' '368';\n");
+		grammarBuilder.append("KW369 : 'KW' '369';\n");
+		grammarBuilder.append("KW370 : 'KW' '370';\n");
+		grammarBuilder.append("KW371 : 'KW' '371';\n");
+		grammarBuilder.append("KW372 : 'KW' '372';\n");
+		grammarBuilder.append("KW373 : 'KW' '373';\n");
+		grammarBuilder.append("KW374 : 'KW' '374';\n");
+		grammarBuilder.append("KW375 : 'KW' '375';\n");
+		grammarBuilder.append("KW376 : 'KW' '376';\n");
+		grammarBuilder.append("KW377 : 'KW' '377';\n");
+		grammarBuilder.append("KW378 : 'KW' '378';\n");
+		grammarBuilder.append("KW379 : 'KW' '379';\n");
+		grammarBuilder.append("KW380 : 'KW' '380';\n");
+		grammarBuilder.append("KW381 : 'KW' '381';\n");
+		grammarBuilder.append("KW382 : 'KW' '382';\n");
+		grammarBuilder.append("KW383 : 'KW' '383';\n");
+		grammarBuilder.append("KW384 : 'KW' '384';\n");
+		grammarBuilder.append("KW385 : 'KW' '385';\n");
+		grammarBuilder.append("KW386 : 'KW' '386';\n");
+		grammarBuilder.append("KW387 : 'KW' '387';\n");
+		grammarBuilder.append("KW388 : 'KW' '388';\n");
+		grammarBuilder.append("KW389 : 'KW' '389';\n");
+		grammarBuilder.append("KW390 : 'KW' '390';\n");
+		grammarBuilder.append("KW391 : 'KW' '391';\n");
+		grammarBuilder.append("KW392 : 'KW' '392';\n");
+		grammarBuilder.append("KW393 : 'KW' '393';\n");
+		grammarBuilder.append("KW394 : 'KW' '394';\n");
+		grammarBuilder.append("KW395 : 'KW' '395';\n");
+		grammarBuilder.append("KW396 : 'KW' '396';\n");
+		grammarBuilder.append("KW397 : 'KW' '397';\n");
+		grammarBuilder.append("KW398 : 'KW' '398';\n");
+		grammarBuilder.append("KW399 : 'KW' '399';\n");
+		grammarBuilder.append("KW400 : 'KW' '400';\n");
+		grammarBuilder.append("KW401 : 'KW' '401';\n");
+		grammarBuilder.append("KW402 : 'KW' '402';\n");
+		grammarBuilder.append("KW403 : 'KW' '403';\n");
+		grammarBuilder.append("KW404 : 'KW' '404';\n");
+		grammarBuilder.append("KW405 : 'KW' '405';\n");
+		grammarBuilder.append("KW406 : 'KW' '406';\n");
+		grammarBuilder.append("KW407 : 'KW' '407';\n");
+		grammarBuilder.append("KW408 : 'KW' '408';\n");
+		grammarBuilder.append("KW409 : 'KW' '409';\n");
+		grammarBuilder.append("KW410 : 'KW' '410';\n");
+		grammarBuilder.append("KW411 : 'KW' '411';\n");
+		grammarBuilder.append("KW412 : 'KW' '412';\n");
+		grammarBuilder.append("KW413 : 'KW' '413';\n");
+		grammarBuilder.append("KW414 : 'KW' '414';\n");
+		grammarBuilder.append("KW415 : 'KW' '415';\n");
+		grammarBuilder.append("KW416 : 'KW' '416';\n");
+		grammarBuilder.append("KW417 : 'KW' '417';\n");
+		grammarBuilder.append("KW418 : 'KW' '418';\n");
+		grammarBuilder.append("KW419 : 'KW' '419';\n");
+		grammarBuilder.append("KW420 : 'KW' '420';\n");
+		grammarBuilder.append("KW421 : 'KW' '421';\n");
+		grammarBuilder.append("KW422 : 'KW' '422';\n");
+		grammarBuilder.append("KW423 : 'KW' '423';\n");
+		grammarBuilder.append("KW424 : 'KW' '424';\n");
+		grammarBuilder.append("KW425 : 'KW' '425';\n");
+		grammarBuilder.append("KW426 : 'KW' '426';\n");
+		grammarBuilder.append("KW427 : 'KW' '427';\n");
+		grammarBuilder.append("KW428 : 'KW' '428';\n");
+		grammarBuilder.append("KW429 : 'KW' '429';\n");
+		grammarBuilder.append("KW430 : 'KW' '430';\n");
+		grammarBuilder.append("KW431 : 'KW' '431';\n");
+		grammarBuilder.append("KW432 : 'KW' '432';\n");
+		grammarBuilder.append("KW433 : 'KW' '433';\n");
+		grammarBuilder.append("KW434 : 'KW' '434';\n");
+		grammarBuilder.append("KW435 : 'KW' '435';\n");
+		grammarBuilder.append("KW436 : 'KW' '436';\n");
+		grammarBuilder.append("KW437 : 'KW' '437';\n");
+		grammarBuilder.append("KW438 : 'KW' '438';\n");
+		grammarBuilder.append("KW439 : 'KW' '439';\n");
+		grammarBuilder.append("KW440 : 'KW' '440';\n");
+		grammarBuilder.append("KW441 : 'KW' '441';\n");
+		grammarBuilder.append("KW442 : 'KW' '442';\n");
+		grammarBuilder.append("KW443 : 'KW' '443';\n");
+		grammarBuilder.append("KW444 : 'KW' '444';\n");
+		grammarBuilder.append("KW445 : 'KW' '445';\n");
+		grammarBuilder.append("KW446 : 'KW' '446';\n");
+		grammarBuilder.append("KW447 : 'KW' '447';\n");
+		grammarBuilder.append("KW448 : 'KW' '448';\n");
+		grammarBuilder.append("KW449 : 'KW' '449';\n");
+		grammarBuilder.append("KW450 : 'KW' '450';\n");
+		grammarBuilder.append("KW451 : 'KW' '451';\n");
+		grammarBuilder.append("KW452 : 'KW' '452';\n");
+		grammarBuilder.append("KW453 : 'KW' '453';\n");
+		grammarBuilder.append("KW454 : 'KW' '454';\n");
+		grammarBuilder.append("KW455 : 'KW' '455';\n");
+		grammarBuilder.append("KW456 : 'KW' '456';\n");
+		grammarBuilder.append("KW457 : 'KW' '457';\n");
+		grammarBuilder.append("KW458 : 'KW' '458';\n");
+		grammarBuilder.append("KW459 : 'KW' '459';\n");
+		grammarBuilder.append("KW460 : 'KW' '460';\n");
+		grammarBuilder.append("KW461 : 'KW' '461';\n");
+		grammarBuilder.append("KW462 : 'KW' '462';\n");
+		grammarBuilder.append("KW463 : 'KW' '463';\n");
+		grammarBuilder.append("KW464 : 'KW' '464';\n");
+		grammarBuilder.append("KW465 : 'KW' '465';\n");
+		grammarBuilder.append("KW466 : 'KW' '466';\n");
+		grammarBuilder.append("KW467 : 'KW' '467';\n");
+		grammarBuilder.append("KW468 : 'KW' '468';\n");
+		grammarBuilder.append("KW469 : 'KW' '469';\n");
+		grammarBuilder.append("KW470 : 'KW' '470';\n");
+		grammarBuilder.append("KW471 : 'KW' '471';\n");
+		grammarBuilder.append("KW472 : 'KW' '472';\n");
+		grammarBuilder.append("KW473 : 'KW' '473';\n");
+		grammarBuilder.append("KW474 : 'KW' '474';\n");
+		grammarBuilder.append("KW475 : 'KW' '475';\n");
+		grammarBuilder.append("KW476 : 'KW' '476';\n");
+		grammarBuilder.append("KW477 : 'KW' '477';\n");
+		grammarBuilder.append("KW478 : 'KW' '478';\n");
+		grammarBuilder.append("KW479 : 'KW' '479';\n");
+		grammarBuilder.append("KW480 : 'KW' '480';\n");
+		grammarBuilder.append("KW481 : 'KW' '481';\n");
+		grammarBuilder.append("KW482 : 'KW' '482';\n");
+		grammarBuilder.append("KW483 : 'KW' '483';\n");
+		grammarBuilder.append("KW484 : 'KW' '484';\n");
+		grammarBuilder.append("KW485 : 'KW' '485';\n");
+		grammarBuilder.append("KW486 : 'KW' '486';\n");
+		grammarBuilder.append("KW487 : 'KW' '487';\n");
+		grammarBuilder.append("KW488 : 'KW' '488';\n");
+		grammarBuilder.append("KW489 : 'KW' '489';\n");
+		grammarBuilder.append("KW490 : 'KW' '490';\n");
+		grammarBuilder.append("KW491 : 'KW' '491';\n");
+		grammarBuilder.append("KW492 : 'KW' '492';\n");
+		grammarBuilder.append("KW493 : 'KW' '493';\n");
+		grammarBuilder.append("KW494 : 'KW' '494';\n");
+		grammarBuilder.append("KW495 : 'KW' '495';\n");
+		grammarBuilder.append("KW496 : 'KW' '496';\n");
+		grammarBuilder.append("KW497 : 'KW' '497';\n");
+		grammarBuilder.append("KW498 : 'KW' '498';\n");
+		grammarBuilder.append("KW499 : 'KW' '499';\n");
+		grammarBuilder.append("KW500 : 'KW' '500';\n");
+		grammarBuilder.append("KW501 : 'KW' '501';\n");
+		grammarBuilder.append("KW502 : 'KW' '502';\n");
+		grammarBuilder.append("KW503 : 'KW' '503';\n");
+		grammarBuilder.append("KW504 : 'KW' '504';\n");
+		grammarBuilder.append("KW505 : 'KW' '505';\n");
+		grammarBuilder.append("KW506 : 'KW' '506';\n");
+		grammarBuilder.append("KW507 : 'KW' '507';\n");
+		grammarBuilder.append("KW508 : 'KW' '508';\n");
+		grammarBuilder.append("KW509 : 'KW' '509';\n");
+		grammarBuilder.append("KW510 : 'KW' '510';\n");
+		grammarBuilder.append("KW511 : 'KW' '511';\n");
+		grammarBuilder.append("KW512 : 'KW' '512';\n");
+		grammarBuilder.append("KW513 : 'KW' '513';\n");
+		grammarBuilder.append("KW514 : 'KW' '514';\n");
+		grammarBuilder.append("KW515 : 'KW' '515';\n");
+		grammarBuilder.append("KW516 : 'KW' '516';\n");
+		grammarBuilder.append("KW517 : 'KW' '517';\n");
+		grammarBuilder.append("KW518 : 'KW' '518';\n");
+		grammarBuilder.append("KW519 : 'KW' '519';\n");
+		grammarBuilder.append("KW520 : 'KW' '520';\n");
+		grammarBuilder.append("KW521 : 'KW' '521';\n");
+		grammarBuilder.append("KW522 : 'KW' '522';\n");
+		grammarBuilder.append("KW523 : 'KW' '523';\n");
+		grammarBuilder.append("KW524 : 'KW' '524';\n");
+		grammarBuilder.append("KW525 : 'KW' '525';\n");
+		grammarBuilder.append("KW526 : 'KW' '526';\n");
+		grammarBuilder.append("KW527 : 'KW' '527';\n");
+		grammarBuilder.append("KW528 : 'KW' '528';\n");
+		grammarBuilder.append("KW529 : 'KW' '529';\n");
+		grammarBuilder.append("KW530 : 'KW' '530';\n");
+		grammarBuilder.append("KW531 : 'KW' '531';\n");
+		grammarBuilder.append("KW532 : 'KW' '532';\n");
+		grammarBuilder.append("KW533 : 'KW' '533';\n");
+		grammarBuilder.append("KW534 : 'KW' '534';\n");
+		grammarBuilder.append("KW535 : 'KW' '535';\n");
+		grammarBuilder.append("KW536 : 'KW' '536';\n");
+		grammarBuilder.append("KW537 : 'KW' '537';\n");
+		grammarBuilder.append("KW538 : 'KW' '538';\n");
+		grammarBuilder.append("KW539 : 'KW' '539';\n");
+		grammarBuilder.append("KW540 : 'KW' '540';\n");
+		grammarBuilder.append("KW541 : 'KW' '541';\n");
+		grammarBuilder.append("KW542 : 'KW' '542';\n");
+		grammarBuilder.append("KW543 : 'KW' '543';\n");
+		grammarBuilder.append("KW544 : 'KW' '544';\n");
+		grammarBuilder.append("KW545 : 'KW' '545';\n");
+		grammarBuilder.append("KW546 : 'KW' '546';\n");
+		grammarBuilder.append("KW547 : 'KW' '547';\n");
+		grammarBuilder.append("KW548 : 'KW' '548';\n");
+		grammarBuilder.append("KW549 : 'KW' '549';\n");
+		grammarBuilder.append("KW550 : 'KW' '550';\n");
+		grammarBuilder.append("KW551 : 'KW' '551';\n");
+		grammarBuilder.append("KW552 : 'KW' '552';\n");
+		grammarBuilder.append("KW553 : 'KW' '553';\n");
+		grammarBuilder.append("KW554 : 'KW' '554';\n");
+		grammarBuilder.append("KW555 : 'KW' '555';\n");
+		grammarBuilder.append("KW556 : 'KW' '556';\n");
+		grammarBuilder.append("KW557 : 'KW' '557';\n");
+		grammarBuilder.append("KW558 : 'KW' '558';\n");
+		grammarBuilder.append("KW559 : 'KW' '559';\n");
+		grammarBuilder.append("KW560 : 'KW' '560';\n");
+		grammarBuilder.append("KW561 : 'KW' '561';\n");
+		grammarBuilder.append("KW562 : 'KW' '562';\n");
+		grammarBuilder.append("KW563 : 'KW' '563';\n");
+		grammarBuilder.append("KW564 : 'KW' '564';\n");
+		grammarBuilder.append("KW565 : 'KW' '565';\n");
+		grammarBuilder.append("KW566 : 'KW' '566';\n");
+		grammarBuilder.append("KW567 : 'KW' '567';\n");
+		grammarBuilder.append("KW568 : 'KW' '568';\n");
+		grammarBuilder.append("KW569 : 'KW' '569';\n");
+		grammarBuilder.append("KW570 : 'KW' '570';\n");
+		grammarBuilder.append("KW571 : 'KW' '571';\n");
+		grammarBuilder.append("KW572 : 'KW' '572';\n");
+		grammarBuilder.append("KW573 : 'KW' '573';\n");
+		grammarBuilder.append("KW574 : 'KW' '574';\n");
+		grammarBuilder.append("KW575 : 'KW' '575';\n");
+		grammarBuilder.append("KW576 : 'KW' '576';\n");
+		grammarBuilder.append("KW577 : 'KW' '577';\n");
+		grammarBuilder.append("KW578 : 'KW' '578';\n");
+		grammarBuilder.append("KW579 : 'KW' '579';\n");
+		grammarBuilder.append("KW580 : 'KW' '580';\n");
+		grammarBuilder.append("KW581 : 'KW' '581';\n");
+		grammarBuilder.append("KW582 : 'KW' '582';\n");
+		grammarBuilder.append("KW583 : 'KW' '583';\n");
+		grammarBuilder.append("KW584 : 'KW' '584';\n");
+		grammarBuilder.append("KW585 : 'KW' '585';\n");
+		grammarBuilder.append("KW586 : 'KW' '586';\n");
+		grammarBuilder.append("KW587 : 'KW' '587';\n");
+		grammarBuilder.append("KW588 : 'KW' '588';\n");
+		grammarBuilder.append("KW589 : 'KW' '589';\n");
+		grammarBuilder.append("KW590 : 'KW' '590';\n");
+		grammarBuilder.append("KW591 : 'KW' '591';\n");
+		grammarBuilder.append("KW592 : 'KW' '592';\n");
+		grammarBuilder.append("KW593 : 'KW' '593';\n");
+		grammarBuilder.append("KW594 : 'KW' '594';\n");
+		grammarBuilder.append("KW595 : 'KW' '595';\n");
+		grammarBuilder.append("KW596 : 'KW' '596';\n");
+		grammarBuilder.append("KW597 : 'KW' '597';\n");
+		grammarBuilder.append("KW598 : 'KW' '598';\n");
+		grammarBuilder.append("KW599 : 'KW' '599';\n");
+		grammarBuilder.append("KW600 : 'KW' '600';\n");
+		grammarBuilder.append("KW601 : 'KW' '601';\n");
+		grammarBuilder.append("KW602 : 'KW' '602';\n");
+		grammarBuilder.append("KW603 : 'KW' '603';\n");
+		grammarBuilder.append("KW604 : 'KW' '604';\n");
+		grammarBuilder.append("KW605 : 'KW' '605';\n");
+		grammarBuilder.append("KW606 : 'KW' '606';\n");
+		grammarBuilder.append("KW607 : 'KW' '607';\n");
+		grammarBuilder.append("KW608 : 'KW' '608';\n");
+		grammarBuilder.append("KW609 : 'KW' '609';\n");
+		grammarBuilder.append("KW610 : 'KW' '610';\n");
+		grammarBuilder.append("KW611 : 'KW' '611';\n");
+		grammarBuilder.append("KW612 : 'KW' '612';\n");
+		grammarBuilder.append("KW613 : 'KW' '613';\n");
+		grammarBuilder.append("KW614 : 'KW' '614';\n");
+		grammarBuilder.append("KW615 : 'KW' '615';\n");
+		grammarBuilder.append("KW616 : 'KW' '616';\n");
+		grammarBuilder.append("KW617 : 'KW' '617';\n");
+		grammarBuilder.append("KW618 : 'KW' '618';\n");
+		grammarBuilder.append("KW619 : 'KW' '619';\n");
+		grammarBuilder.append("KW620 : 'KW' '620';\n");
+		grammarBuilder.append("KW621 : 'KW' '621';\n");
+		grammarBuilder.append("KW622 : 'KW' '622';\n");
+		grammarBuilder.append("KW623 : 'KW' '623';\n");
+		grammarBuilder.append("KW624 : 'KW' '624';\n");
+		grammarBuilder.append("KW625 : 'KW' '625';\n");
+		grammarBuilder.append("KW626 : 'KW' '626';\n");
+		grammarBuilder.append("KW627 : 'KW' '627';\n");
+		grammarBuilder.append("KW628 : 'KW' '628';\n");
+		grammarBuilder.append("KW629 : 'KW' '629';\n");
+		grammarBuilder.append("KW630 : 'KW' '630';\n");
+		grammarBuilder.append("KW631 : 'KW' '631';\n");
+		grammarBuilder.append("KW632 : 'KW' '632';\n");
+		grammarBuilder.append("KW633 : 'KW' '633';\n");
+		grammarBuilder.append("KW634 : 'KW' '634';\n");
+		grammarBuilder.append("KW635 : 'KW' '635';\n");
+		grammarBuilder.append("KW636 : 'KW' '636';\n");
+		grammarBuilder.append("KW637 : 'KW' '637';\n");
+		grammarBuilder.append("KW638 : 'KW' '638';\n");
+		grammarBuilder.append("KW639 : 'KW' '639';\n");
+		grammarBuilder.append("KW640 : 'KW' '640';\n");
+		grammarBuilder.append("KW641 : 'KW' '641';\n");
+		grammarBuilder.append("KW642 : 'KW' '642';\n");
+		grammarBuilder.append("KW643 : 'KW' '643';\n");
+		grammarBuilder.append("KW644 : 'KW' '644';\n");
+		grammarBuilder.append("KW645 : 'KW' '645';\n");
+		grammarBuilder.append("KW646 : 'KW' '646';\n");
+		grammarBuilder.append("KW647 : 'KW' '647';\n");
+		grammarBuilder.append("KW648 : 'KW' '648';\n");
+		grammarBuilder.append("KW649 : 'KW' '649';\n");
+		grammarBuilder.append("KW650 : 'KW' '650';\n");
+		grammarBuilder.append("KW651 : 'KW' '651';\n");
+		grammarBuilder.append("KW652 : 'KW' '652';\n");
+		grammarBuilder.append("KW653 : 'KW' '653';\n");
+		grammarBuilder.append("KW654 : 'KW' '654';\n");
+		grammarBuilder.append("KW655 : 'KW' '655';\n");
+		grammarBuilder.append("KW656 : 'KW' '656';\n");
+		grammarBuilder.append("KW657 : 'KW' '657';\n");
+		grammarBuilder.append("KW658 : 'KW' '658';\n");
+		grammarBuilder.append("KW659 : 'KW' '659';\n");
+		grammarBuilder.append("KW660 : 'KW' '660';\n");
+		grammarBuilder.append("KW661 : 'KW' '661';\n");
+		grammarBuilder.append("KW662 : 'KW' '662';\n");
+		grammarBuilder.append("KW663 : 'KW' '663';\n");
+		grammarBuilder.append("KW664 : 'KW' '664';\n");
+		grammarBuilder.append("KW665 : 'KW' '665';\n");
+		grammarBuilder.append("KW666 : 'KW' '666';\n");
+		grammarBuilder.append("KW667 : 'KW' '667';\n");
+		grammarBuilder.append("KW668 : 'KW' '668';\n");
+		grammarBuilder.append("KW669 : 'KW' '669';\n");
+		grammarBuilder.append("KW670 : 'KW' '670';\n");
+		grammarBuilder.append("KW671 : 'KW' '671';\n");
+		grammarBuilder.append("KW672 : 'KW' '672';\n");
+		grammarBuilder.append("KW673 : 'KW' '673';\n");
+		grammarBuilder.append("KW674 : 'KW' '674';\n");
+		grammarBuilder.append("KW675 : 'KW' '675';\n");
+		grammarBuilder.append("KW676 : 'KW' '676';\n");
+		grammarBuilder.append("KW677 : 'KW' '677';\n");
+		grammarBuilder.append("KW678 : 'KW' '678';\n");
+		grammarBuilder.append("KW679 : 'KW' '679';\n");
+		grammarBuilder.append("KW680 : 'KW' '680';\n");
+		grammarBuilder.append("KW681 : 'KW' '681';\n");
+		grammarBuilder.append("KW682 : 'KW' '682';\n");
+		grammarBuilder.append("KW683 : 'KW' '683';\n");
+		grammarBuilder.append("KW684 : 'KW' '684';\n");
+		grammarBuilder.append("KW685 : 'KW' '685';\n");
+		grammarBuilder.append("KW686 : 'KW' '686';\n");
+		grammarBuilder.append("KW687 : 'KW' '687';\n");
+		grammarBuilder.append("KW688 : 'KW' '688';\n");
+		grammarBuilder.append("KW689 : 'KW' '689';\n");
+		grammarBuilder.append("KW690 : 'KW' '690';\n");
+		grammarBuilder.append("KW691 : 'KW' '691';\n");
+		grammarBuilder.append("KW692 : 'KW' '692';\n");
+		grammarBuilder.append("KW693 : 'KW' '693';\n");
+		grammarBuilder.append("KW694 : 'KW' '694';\n");
+		grammarBuilder.append("KW695 : 'KW' '695';\n");
+		grammarBuilder.append("KW696 : 'KW' '696';\n");
+		grammarBuilder.append("KW697 : 'KW' '697';\n");
+		grammarBuilder.append("KW698 : 'KW' '698';\n");
+		grammarBuilder.append("KW699 : 'KW' '699';\n");
+		grammarBuilder.append("KW700 : 'KW' '700';\n");
+		grammarBuilder.append("KW701 : 'KW' '701';\n");
+		grammarBuilder.append("KW702 : 'KW' '702';\n");
+		grammarBuilder.append("KW703 : 'KW' '703';\n");
+		grammarBuilder.append("KW704 : 'KW' '704';\n");
+		grammarBuilder.append("KW705 : 'KW' '705';\n");
+		grammarBuilder.append("KW706 : 'KW' '706';\n");
+		grammarBuilder.append("KW707 : 'KW' '707';\n");
+		grammarBuilder.append("KW708 : 'KW' '708';\n");
+		grammarBuilder.append("KW709 : 'KW' '709';\n");
+		grammarBuilder.append("KW710 : 'KW' '710';\n");
+		grammarBuilder.append("KW711 : 'KW' '711';\n");
+		grammarBuilder.append("KW712 : 'KW' '712';\n");
+		grammarBuilder.append("KW713 : 'KW' '713';\n");
+		grammarBuilder.append("KW714 : 'KW' '714';\n");
+		grammarBuilder.append("KW715 : 'KW' '715';\n");
+		grammarBuilder.append("KW716 : 'KW' '716';\n");
+		grammarBuilder.append("KW717 : 'KW' '717';\n");
+		grammarBuilder.append("KW718 : 'KW' '718';\n");
+		grammarBuilder.append("KW719 : 'KW' '719';\n");
+		grammarBuilder.append("KW720 : 'KW' '720';\n");
+		grammarBuilder.append("KW721 : 'KW' '721';\n");
+		grammarBuilder.append("KW722 : 'KW' '722';\n");
+		grammarBuilder.append("KW723 : 'KW' '723';\n");
+		grammarBuilder.append("KW724 : 'KW' '724';\n");
+		grammarBuilder.append("KW725 : 'KW' '725';\n");
+		grammarBuilder.append("KW726 : 'KW' '726';\n");
+		grammarBuilder.append("KW727 : 'KW' '727';\n");
+		grammarBuilder.append("KW728 : 'KW' '728';\n");
+		grammarBuilder.append("KW729 : 'KW' '729';\n");
+		grammarBuilder.append("KW730 : 'KW' '730';\n");
+		grammarBuilder.append("KW731 : 'KW' '731';\n");
+		grammarBuilder.append("KW732 : 'KW' '732';\n");
+		grammarBuilder.append("KW733 : 'KW' '733';\n");
+		grammarBuilder.append("KW734 : 'KW' '734';\n");
+		grammarBuilder.append("KW735 : 'KW' '735';\n");
+		grammarBuilder.append("KW736 : 'KW' '736';\n");
+		grammarBuilder.append("KW737 : 'KW' '737';\n");
+		grammarBuilder.append("KW738 : 'KW' '738';\n");
+		grammarBuilder.append("KW739 : 'KW' '739';\n");
+		grammarBuilder.append("KW740 : 'KW' '740';\n");
+		grammarBuilder.append("KW741 : 'KW' '741';\n");
+		grammarBuilder.append("KW742 : 'KW' '742';\n");
+		grammarBuilder.append("KW743 : 'KW' '743';\n");
+		grammarBuilder.append("KW744 : 'KW' '744';\n");
+		grammarBuilder.append("KW745 : 'KW' '745';\n");
+		grammarBuilder.append("KW746 : 'KW' '746';\n");
+		grammarBuilder.append("KW747 : 'KW' '747';\n");
+		grammarBuilder.append("KW748 : 'KW' '748';\n");
+		grammarBuilder.append("KW749 : 'KW' '749';\n");
+		grammarBuilder.append("KW750 : 'KW' '750';\n");
+		grammarBuilder.append("KW751 : 'KW' '751';\n");
+		grammarBuilder.append("KW752 : 'KW' '752';\n");
+		grammarBuilder.append("KW753 : 'KW' '753';\n");
+		grammarBuilder.append("KW754 : 'KW' '754';\n");
+		grammarBuilder.append("KW755 : 'KW' '755';\n");
+		grammarBuilder.append("KW756 : 'KW' '756';\n");
+		grammarBuilder.append("KW757 : 'KW' '757';\n");
+		grammarBuilder.append("KW758 : 'KW' '758';\n");
+		grammarBuilder.append("KW759 : 'KW' '759';\n");
+		grammarBuilder.append("KW760 : 'KW' '760';\n");
+		grammarBuilder.append("KW761 : 'KW' '761';\n");
+		grammarBuilder.append("KW762 : 'KW' '762';\n");
+		grammarBuilder.append("KW763 : 'KW' '763';\n");
+		grammarBuilder.append("KW764 : 'KW' '764';\n");
+		grammarBuilder.append("KW765 : 'KW' '765';\n");
+		grammarBuilder.append("KW766 : 'KW' '766';\n");
+		grammarBuilder.append("KW767 : 'KW' '767';\n");
+		grammarBuilder.append("KW768 : 'KW' '768';\n");
+		grammarBuilder.append("KW769 : 'KW' '769';\n");
+		grammarBuilder.append("KW770 : 'KW' '770';\n");
+		grammarBuilder.append("KW771 : 'KW' '771';\n");
+		grammarBuilder.append("KW772 : 'KW' '772';\n");
+		grammarBuilder.append("KW773 : 'KW' '773';\n");
+		grammarBuilder.append("KW774 : 'KW' '774';\n");
+		grammarBuilder.append("KW775 : 'KW' '775';\n");
+		grammarBuilder.append("KW776 : 'KW' '776';\n");
+		grammarBuilder.append("KW777 : 'KW' '777';\n");
+		grammarBuilder.append("KW778 : 'KW' '778';\n");
+		grammarBuilder.append("KW779 : 'KW' '779';\n");
+		grammarBuilder.append("KW780 : 'KW' '780';\n");
+		grammarBuilder.append("KW781 : 'KW' '781';\n");
+		grammarBuilder.append("KW782 : 'KW' '782';\n");
+		grammarBuilder.append("KW783 : 'KW' '783';\n");
+		grammarBuilder.append("KW784 : 'KW' '784';\n");
+		grammarBuilder.append("KW785 : 'KW' '785';\n");
+		grammarBuilder.append("KW786 : 'KW' '786';\n");
+		grammarBuilder.append("KW787 : 'KW' '787';\n");
+		grammarBuilder.append("KW788 : 'KW' '788';\n");
+		grammarBuilder.append("KW789 : 'KW' '789';\n");
+		grammarBuilder.append("KW790 : 'KW' '790';\n");
+		grammarBuilder.append("KW791 : 'KW' '791';\n");
+		grammarBuilder.append("KW792 : 'KW' '792';\n");
+		grammarBuilder.append("KW793 : 'KW' '793';\n");
+		grammarBuilder.append("KW794 : 'KW' '794';\n");
+		grammarBuilder.append("KW795 : 'KW' '795';\n");
+		grammarBuilder.append("KW796 : 'KW' '796';\n");
+		grammarBuilder.append("KW797 : 'KW' '797';\n");
+		grammarBuilder.append("KW798 : 'KW' '798';\n");
+		grammarBuilder.append("KW799 : 'KW' '799';\n");
+		grammarBuilder.append("KW800 : 'KW' '800';\n");
+		grammarBuilder.append("KW801 : 'KW' '801';\n");
+		grammarBuilder.append("KW802 : 'KW' '802';\n");
+		grammarBuilder.append("KW803 : 'KW' '803';\n");
+		grammarBuilder.append("KW804 : 'KW' '804';\n");
+		grammarBuilder.append("KW805 : 'KW' '805';\n");
+		grammarBuilder.append("KW806 : 'KW' '806';\n");
+		grammarBuilder.append("KW807 : 'KW' '807';\n");
+		grammarBuilder.append("KW808 : 'KW' '808';\n");
+		grammarBuilder.append("KW809 : 'KW' '809';\n");
+		grammarBuilder.append("KW810 : 'KW' '810';\n");
+		grammarBuilder.append("KW811 : 'KW' '811';\n");
+		grammarBuilder.append("KW812 : 'KW' '812';\n");
+		grammarBuilder.append("KW813 : 'KW' '813';\n");
+		grammarBuilder.append("KW814 : 'KW' '814';\n");
+		grammarBuilder.append("KW815 : 'KW' '815';\n");
+		grammarBuilder.append("KW816 : 'KW' '816';\n");
+		grammarBuilder.append("KW817 : 'KW' '817';\n");
+		grammarBuilder.append("KW818 : 'KW' '818';\n");
+		grammarBuilder.append("KW819 : 'KW' '819';\n");
+		grammarBuilder.append("KW820 : 'KW' '820';\n");
+		grammarBuilder.append("KW821 : 'KW' '821';\n");
+		grammarBuilder.append("KW822 : 'KW' '822';\n");
+		grammarBuilder.append("KW823 : 'KW' '823';\n");
+		grammarBuilder.append("KW824 : 'KW' '824';\n");
+		grammarBuilder.append("KW825 : 'KW' '825';\n");
+		grammarBuilder.append("KW826 : 'KW' '826';\n");
+		grammarBuilder.append("KW827 : 'KW' '827';\n");
+		grammarBuilder.append("KW828 : 'KW' '828';\n");
+		grammarBuilder.append("KW829 : 'KW' '829';\n");
+		grammarBuilder.append("KW830 : 'KW' '830';\n");
+		grammarBuilder.append("KW831 : 'KW' '831';\n");
+		grammarBuilder.append("KW832 : 'KW' '832';\n");
+		grammarBuilder.append("KW833 : 'KW' '833';\n");
+		grammarBuilder.append("KW834 : 'KW' '834';\n");
+		grammarBuilder.append("KW835 : 'KW' '835';\n");
+		grammarBuilder.append("KW836 : 'KW' '836';\n");
+		grammarBuilder.append("KW837 : 'KW' '837';\n");
+		grammarBuilder.append("KW838 : 'KW' '838';\n");
+		grammarBuilder.append("KW839 : 'KW' '839';\n");
+		grammarBuilder.append("KW840 : 'KW' '840';\n");
+		grammarBuilder.append("KW841 : 'KW' '841';\n");
+		grammarBuilder.append("KW842 : 'KW' '842';\n");
+		grammarBuilder.append("KW843 : 'KW' '843';\n");
+		grammarBuilder.append("KW844 : 'KW' '844';\n");
+		grammarBuilder.append("KW845 : 'KW' '845';\n");
+		grammarBuilder.append("KW846 : 'KW' '846';\n");
+		grammarBuilder.append("KW847 : 'KW' '847';\n");
+		grammarBuilder.append("KW848 : 'KW' '848';\n");
+		grammarBuilder.append("KW849 : 'KW' '849';\n");
+		grammarBuilder.append("KW850 : 'KW' '850';\n");
+		grammarBuilder.append("KW851 : 'KW' '851';\n");
+		grammarBuilder.append("KW852 : 'KW' '852';\n");
+		grammarBuilder.append("KW853 : 'KW' '853';\n");
+		grammarBuilder.append("KW854 : 'KW' '854';\n");
+		grammarBuilder.append("KW855 : 'KW' '855';\n");
+		grammarBuilder.append("KW856 : 'KW' '856';\n");
+		grammarBuilder.append("KW857 : 'KW' '857';\n");
+		grammarBuilder.append("KW858 : 'KW' '858';\n");
+		grammarBuilder.append("KW859 : 'KW' '859';\n");
+		grammarBuilder.append("KW860 : 'KW' '860';\n");
+		grammarBuilder.append("KW861 : 'KW' '861';\n");
+		grammarBuilder.append("KW862 : 'KW' '862';\n");
+		grammarBuilder.append("KW863 : 'KW' '863';\n");
+		grammarBuilder.append("KW864 : 'KW' '864';\n");
+		grammarBuilder.append("KW865 : 'KW' '865';\n");
+		grammarBuilder.append("KW866 : 'KW' '866';\n");
+		grammarBuilder.append("KW867 : 'KW' '867';\n");
+		grammarBuilder.append("KW868 : 'KW' '868';\n");
+		grammarBuilder.append("KW869 : 'KW' '869';\n");
+		grammarBuilder.append("KW870 : 'KW' '870';\n");
+		grammarBuilder.append("KW871 : 'KW' '871';\n");
+		grammarBuilder.append("KW872 : 'KW' '872';\n");
+		grammarBuilder.append("KW873 : 'KW' '873';\n");
+		grammarBuilder.append("KW874 : 'KW' '874';\n");
+		grammarBuilder.append("KW875 : 'KW' '875';\n");
+		grammarBuilder.append("KW876 : 'KW' '876';\n");
+		grammarBuilder.append("KW877 : 'KW' '877';\n");
+		grammarBuilder.append("KW878 : 'KW' '878';\n");
+		grammarBuilder.append("KW879 : 'KW' '879';\n");
+		grammarBuilder.append("KW880 : 'KW' '880';\n");
+		grammarBuilder.append("KW881 : 'KW' '881';\n");
+		grammarBuilder.append("KW882 : 'KW' '882';\n");
+		grammarBuilder.append("KW883 : 'KW' '883';\n");
+		grammarBuilder.append("KW884 : 'KW' '884';\n");
+		grammarBuilder.append("KW885 : 'KW' '885';\n");
+		grammarBuilder.append("KW886 : 'KW' '886';\n");
+		grammarBuilder.append("KW887 : 'KW' '887';\n");
+		grammarBuilder.append("KW888 : 'KW' '888';\n");
+		grammarBuilder.append("KW889 : 'KW' '889';\n");
+		grammarBuilder.append("KW890 : 'KW' '890';\n");
+		grammarBuilder.append("KW891 : 'KW' '891';\n");
+		grammarBuilder.append("KW892 : 'KW' '892';\n");
+		grammarBuilder.append("KW893 : 'KW' '893';\n");
+		grammarBuilder.append("KW894 : 'KW' '894';\n");
+		grammarBuilder.append("KW895 : 'KW' '895';\n");
+		grammarBuilder.append("KW896 : 'KW' '896';\n");
+		grammarBuilder.append("KW897 : 'KW' '897';\n");
+		grammarBuilder.append("KW898 : 'KW' '898';\n");
+		grammarBuilder.append("KW899 : 'KW' '899';\n");
+		grammarBuilder.append("KW900 : 'KW' '900';\n");
+		grammarBuilder.append("KW901 : 'KW' '901';\n");
+		grammarBuilder.append("KW902 : 'KW' '902';\n");
+		grammarBuilder.append("KW903 : 'KW' '903';\n");
+		grammarBuilder.append("KW904 : 'KW' '904';\n");
+		grammarBuilder.append("KW905 : 'KW' '905';\n");
+		grammarBuilder.append("KW906 : 'KW' '906';\n");
+		grammarBuilder.append("KW907 : 'KW' '907';\n");
+		grammarBuilder.append("KW908 : 'KW' '908';\n");
+		grammarBuilder.append("KW909 : 'KW' '909';\n");
+		grammarBuilder.append("KW910 : 'KW' '910';\n");
+		grammarBuilder.append("KW911 : 'KW' '911';\n");
+		grammarBuilder.append("KW912 : 'KW' '912';\n");
+		grammarBuilder.append("KW913 : 'KW' '913';\n");
+		grammarBuilder.append("KW914 : 'KW' '914';\n");
+		grammarBuilder.append("KW915 : 'KW' '915';\n");
+		grammarBuilder.append("KW916 : 'KW' '916';\n");
+		grammarBuilder.append("KW917 : 'KW' '917';\n");
+		grammarBuilder.append("KW918 : 'KW' '918';\n");
+		grammarBuilder.append("KW919 : 'KW' '919';\n");
+		grammarBuilder.append("KW920 : 'KW' '920';\n");
+		grammarBuilder.append("KW921 : 'KW' '921';\n");
+		grammarBuilder.append("KW922 : 'KW' '922';\n");
+		grammarBuilder.append("KW923 : 'KW' '923';\n");
+		grammarBuilder.append("KW924 : 'KW' '924';\n");
+		grammarBuilder.append("KW925 : 'KW' '925';\n");
+		grammarBuilder.append("KW926 : 'KW' '926';\n");
+		grammarBuilder.append("KW927 : 'KW' '927';\n");
+		grammarBuilder.append("KW928 : 'KW' '928';\n");
+		grammarBuilder.append("KW929 : 'KW' '929';\n");
+		grammarBuilder.append("KW930 : 'KW' '930';\n");
+		grammarBuilder.append("KW931 : 'KW' '931';\n");
+		grammarBuilder.append("KW932 : 'KW' '932';\n");
+		grammarBuilder.append("KW933 : 'KW' '933';\n");
+		grammarBuilder.append("KW934 : 'KW' '934';\n");
+		grammarBuilder.append("KW935 : 'KW' '935';\n");
+		grammarBuilder.append("KW936 : 'KW' '936';\n");
+		grammarBuilder.append("KW937 : 'KW' '937';\n");
+		grammarBuilder.append("KW938 : 'KW' '938';\n");
+		grammarBuilder.append("KW939 : 'KW' '939';\n");
+		grammarBuilder.append("KW940 : 'KW' '940';\n");
+		grammarBuilder.append("KW941 : 'KW' '941';\n");
+		grammarBuilder.append("KW942 : 'KW' '942';\n");
+		grammarBuilder.append("KW943 : 'KW' '943';\n");
+		grammarBuilder.append("KW944 : 'KW' '944';\n");
+		grammarBuilder.append("KW945 : 'KW' '945';\n");
+		grammarBuilder.append("KW946 : 'KW' '946';\n");
+		grammarBuilder.append("KW947 : 'KW' '947';\n");
+		grammarBuilder.append("KW948 : 'KW' '948';\n");
+		grammarBuilder.append("KW949 : 'KW' '949';\n");
+		grammarBuilder.append("KW950 : 'KW' '950';\n");
+		grammarBuilder.append("KW951 : 'KW' '951';\n");
+		grammarBuilder.append("KW952 : 'KW' '952';\n");
+		grammarBuilder.append("KW953 : 'KW' '953';\n");
+		grammarBuilder.append("KW954 : 'KW' '954';\n");
+		grammarBuilder.append("KW955 : 'KW' '955';\n");
+		grammarBuilder.append("KW956 : 'KW' '956';\n");
+		grammarBuilder.append("KW957 : 'KW' '957';\n");
+		grammarBuilder.append("KW958 : 'KW' '958';\n");
+		grammarBuilder.append("KW959 : 'KW' '959';\n");
+		grammarBuilder.append("KW960 : 'KW' '960';\n");
+		grammarBuilder.append("KW961 : 'KW' '961';\n");
+		grammarBuilder.append("KW962 : 'KW' '962';\n");
+		grammarBuilder.append("KW963 : 'KW' '963';\n");
+		grammarBuilder.append("KW964 : 'KW' '964';\n");
+		grammarBuilder.append("KW965 : 'KW' '965';\n");
+		grammarBuilder.append("KW966 : 'KW' '966';\n");
+		grammarBuilder.append("KW967 : 'KW' '967';\n");
+		grammarBuilder.append("KW968 : 'KW' '968';\n");
+		grammarBuilder.append("KW969 : 'KW' '969';\n");
+		grammarBuilder.append("KW970 : 'KW' '970';\n");
+		grammarBuilder.append("KW971 : 'KW' '971';\n");
+		grammarBuilder.append("KW972 : 'KW' '972';\n");
+		grammarBuilder.append("KW973 : 'KW' '973';\n");
+		grammarBuilder.append("KW974 : 'KW' '974';\n");
+		grammarBuilder.append("KW975 : 'KW' '975';\n");
+		grammarBuilder.append("KW976 : 'KW' '976';\n");
+		grammarBuilder.append("KW977 : 'KW' '977';\n");
+		grammarBuilder.append("KW978 : 'KW' '978';\n");
+		grammarBuilder.append("KW979 : 'KW' '979';\n");
+		grammarBuilder.append("KW980 : 'KW' '980';\n");
+		grammarBuilder.append("KW981 : 'KW' '981';\n");
+		grammarBuilder.append("KW982 : 'KW' '982';\n");
+		grammarBuilder.append("KW983 : 'KW' '983';\n");
+		grammarBuilder.append("KW984 : 'KW' '984';\n");
+		grammarBuilder.append("KW985 : 'KW' '985';\n");
+		grammarBuilder.append("KW986 : 'KW' '986';\n");
+		grammarBuilder.append("KW987 : 'KW' '987';\n");
+		grammarBuilder.append("KW988 : 'KW' '988';\n");
+		grammarBuilder.append("KW989 : 'KW' '989';\n");
+		grammarBuilder.append("KW990 : 'KW' '990';\n");
+		grammarBuilder.append("KW991 : 'KW' '991';\n");
+		grammarBuilder.append("KW992 : 'KW' '992';\n");
+		grammarBuilder.append("KW993 : 'KW' '993';\n");
+		grammarBuilder.append("KW994 : 'KW' '994';\n");
+		grammarBuilder.append("KW995 : 'KW' '995';\n");
+		grammarBuilder.append("KW996 : 'KW' '996';\n");
+		grammarBuilder.append("KW997 : 'KW' '997';\n");
+		grammarBuilder.append("KW998 : 'KW' '998';\n");
+		grammarBuilder.append("KW999 : 'KW' '999';\n");
+		grammarBuilder.append("KW1000 : 'KW' '1000';\n");
+		grammarBuilder.append("KW1001 : 'KW' '1001';\n");
+		grammarBuilder.append("KW1002 : 'KW' '1002';\n");
+		grammarBuilder.append("KW1003 : 'KW' '1003';\n");
+		grammarBuilder.append("KW1004 : 'KW' '1004';\n");
+		grammarBuilder.append("KW1005 : 'KW' '1005';\n");
+		grammarBuilder.append("KW1006 : 'KW' '1006';\n");
+		grammarBuilder.append("KW1007 : 'KW' '1007';\n");
+		grammarBuilder.append("KW1008 : 'KW' '1008';\n");
+		grammarBuilder.append("KW1009 : 'KW' '1009';\n");
+		grammarBuilder.append("KW1010 : 'KW' '1010';\n");
+		grammarBuilder.append("KW1011 : 'KW' '1011';\n");
+		grammarBuilder.append("KW1012 : 'KW' '1012';\n");
+		grammarBuilder.append("KW1013 : 'KW' '1013';\n");
+		grammarBuilder.append("KW1014 : 'KW' '1014';\n");
+		grammarBuilder.append("KW1015 : 'KW' '1015';\n");
+		grammarBuilder.append("KW1016 : 'KW' '1016';\n");
+		grammarBuilder.append("KW1017 : 'KW' '1017';\n");
+		grammarBuilder.append("KW1018 : 'KW' '1018';\n");
+		grammarBuilder.append("KW1019 : 'KW' '1019';\n");
+		grammarBuilder.append("KW1020 : 'KW' '1020';\n");
+		grammarBuilder.append("KW1021 : 'KW' '1021';\n");
+		grammarBuilder.append("KW1022 : 'KW' '1022';\n");
+		grammarBuilder.append("KW1023 : 'KW' '1023';\n");
+		grammarBuilder.append("KW1024 : 'KW' '1024';\n");
+		grammarBuilder.append("KW1025 : 'KW' '1025';\n");
+		grammarBuilder.append("KW1026 : 'KW' '1026';\n");
+		grammarBuilder.append("KW1027 : 'KW' '1027';\n");
+		grammarBuilder.append("KW1028 : 'KW' '1028';\n");
+		grammarBuilder.append("KW1029 : 'KW' '1029';\n");
+		grammarBuilder.append("KW1030 : 'KW' '1030';\n");
+		grammarBuilder.append("KW1031 : 'KW' '1031';\n");
+		grammarBuilder.append("KW1032 : 'KW' '1032';\n");
+		grammarBuilder.append("KW1033 : 'KW' '1033';\n");
+		grammarBuilder.append("KW1034 : 'KW' '1034';\n");
+		grammarBuilder.append("KW1035 : 'KW' '1035';\n");
+		grammarBuilder.append("KW1036 : 'KW' '1036';\n");
+		grammarBuilder.append("KW1037 : 'KW' '1037';\n");
+		grammarBuilder.append("KW1038 : 'KW' '1038';\n");
+		grammarBuilder.append("KW1039 : 'KW' '1039';\n");
+		grammarBuilder.append("KW1040 : 'KW' '1040';\n");
+		grammarBuilder.append("KW1041 : 'KW' '1041';\n");
+		grammarBuilder.append("KW1042 : 'KW' '1042';\n");
+		grammarBuilder.append("KW1043 : 'KW' '1043';\n");
+		grammarBuilder.append("KW1044 : 'KW' '1044';\n");
+		grammarBuilder.append("KW1045 : 'KW' '1045';\n");
+		grammarBuilder.append("KW1046 : 'KW' '1046';\n");
+		grammarBuilder.append("KW1047 : 'KW' '1047';\n");
+		grammarBuilder.append("KW1048 : 'KW' '1048';\n");
+		grammarBuilder.append("KW1049 : 'KW' '1049';\n");
+		grammarBuilder.append("KW1050 : 'KW' '1050';\n");
+		grammarBuilder.append("KW1051 : 'KW' '1051';\n");
+		grammarBuilder.append("KW1052 : 'KW' '1052';\n");
+		grammarBuilder.append("KW1053 : 'KW' '1053';\n");
+		grammarBuilder.append("KW1054 : 'KW' '1054';\n");
+		grammarBuilder.append("KW1055 : 'KW' '1055';\n");
+		grammarBuilder.append("KW1056 : 'KW' '1056';\n");
+		grammarBuilder.append("KW1057 : 'KW' '1057';\n");
+		grammarBuilder.append("KW1058 : 'KW' '1058';\n");
+		grammarBuilder.append("KW1059 : 'KW' '1059';\n");
+		grammarBuilder.append("KW1060 : 'KW' '1060';\n");
+		grammarBuilder.append("KW1061 : 'KW' '1061';\n");
+		grammarBuilder.append("KW1062 : 'KW' '1062';\n");
+		grammarBuilder.append("KW1063 : 'KW' '1063';\n");
+		grammarBuilder.append("KW1064 : 'KW' '1064';\n");
+		grammarBuilder.append("KW1065 : 'KW' '1065';\n");
+		grammarBuilder.append("KW1066 : 'KW' '1066';\n");
+		grammarBuilder.append("KW1067 : 'KW' '1067';\n");
+		grammarBuilder.append("KW1068 : 'KW' '1068';\n");
+		grammarBuilder.append("KW1069 : 'KW' '1069';\n");
+		grammarBuilder.append("KW1070 : 'KW' '1070';\n");
+		grammarBuilder.append("KW1071 : 'KW' '1071';\n");
+		grammarBuilder.append("KW1072 : 'KW' '1072';\n");
+		grammarBuilder.append("KW1073 : 'KW' '1073';\n");
+		grammarBuilder.append("KW1074 : 'KW' '1074';\n");
+		grammarBuilder.append("KW1075 : 'KW' '1075';\n");
+		grammarBuilder.append("KW1076 : 'KW' '1076';\n");
+		grammarBuilder.append("KW1077 : 'KW' '1077';\n");
+		grammarBuilder.append("KW1078 : 'KW' '1078';\n");
+		grammarBuilder.append("KW1079 : 'KW' '1079';\n");
+		grammarBuilder.append("KW1080 : 'KW' '1080';\n");
+		grammarBuilder.append("KW1081 : 'KW' '1081';\n");
+		grammarBuilder.append("KW1082 : 'KW' '1082';\n");
+		grammarBuilder.append("KW1083 : 'KW' '1083';\n");
+		grammarBuilder.append("KW1084 : 'KW' '1084';\n");
+		grammarBuilder.append("KW1085 : 'KW' '1085';\n");
+		grammarBuilder.append("KW1086 : 'KW' '1086';\n");
+		grammarBuilder.append("KW1087 : 'KW' '1087';\n");
+		grammarBuilder.append("KW1088 : 'KW' '1088';\n");
+		grammarBuilder.append("KW1089 : 'KW' '1089';\n");
+		grammarBuilder.append("KW1090 : 'KW' '1090';\n");
+		grammarBuilder.append("KW1091 : 'KW' '1091';\n");
+		grammarBuilder.append("KW1092 : 'KW' '1092';\n");
+		grammarBuilder.append("KW1093 : 'KW' '1093';\n");
+		grammarBuilder.append("KW1094 : 'KW' '1094';\n");
+		grammarBuilder.append("KW1095 : 'KW' '1095';\n");
+		grammarBuilder.append("KW1096 : 'KW' '1096';\n");
+		grammarBuilder.append("KW1097 : 'KW' '1097';\n");
+		grammarBuilder.append("KW1098 : 'KW' '1098';\n");
+		grammarBuilder.append("KW1099 : 'KW' '1099';\n");
+		grammarBuilder.append("KW1100 : 'KW' '1100';\n");
+		grammarBuilder.append("KW1101 : 'KW' '1101';\n");
+		grammarBuilder.append("KW1102 : 'KW' '1102';\n");
+		grammarBuilder.append("KW1103 : 'KW' '1103';\n");
+		grammarBuilder.append("KW1104 : 'KW' '1104';\n");
+		grammarBuilder.append("KW1105 : 'KW' '1105';\n");
+		grammarBuilder.append("KW1106 : 'KW' '1106';\n");
+		grammarBuilder.append("KW1107 : 'KW' '1107';\n");
+		grammarBuilder.append("KW1108 : 'KW' '1108';\n");
+		grammarBuilder.append("KW1109 : 'KW' '1109';\n");
+		grammarBuilder.append("KW1110 : 'KW' '1110';\n");
+		grammarBuilder.append("KW1111 : 'KW' '1111';\n");
+		grammarBuilder.append("KW1112 : 'KW' '1112';\n");
+		grammarBuilder.append("KW1113 : 'KW' '1113';\n");
+		grammarBuilder.append("KW1114 : 'KW' '1114';\n");
+		grammarBuilder.append("KW1115 : 'KW' '1115';\n");
+		grammarBuilder.append("KW1116 : 'KW' '1116';\n");
+		grammarBuilder.append("KW1117 : 'KW' '1117';\n");
+		grammarBuilder.append("KW1118 : 'KW' '1118';\n");
+		grammarBuilder.append("KW1119 : 'KW' '1119';\n");
+		grammarBuilder.append("KW1120 : 'KW' '1120';\n");
+		grammarBuilder.append("KW1121 : 'KW' '1121';\n");
+		grammarBuilder.append("KW1122 : 'KW' '1122';\n");
+		grammarBuilder.append("KW1123 : 'KW' '1123';\n");
+		grammarBuilder.append("KW1124 : 'KW' '1124';\n");
+		grammarBuilder.append("KW1125 : 'KW' '1125';\n");
+		grammarBuilder.append("KW1126 : 'KW' '1126';\n");
+		grammarBuilder.append("KW1127 : 'KW' '1127';\n");
+		grammarBuilder.append("KW1128 : 'KW' '1128';\n");
+		grammarBuilder.append("KW1129 : 'KW' '1129';\n");
+		grammarBuilder.append("KW1130 : 'KW' '1130';\n");
+		grammarBuilder.append("KW1131 : 'KW' '1131';\n");
+		grammarBuilder.append("KW1132 : 'KW' '1132';\n");
+		grammarBuilder.append("KW1133 : 'KW' '1133';\n");
+		grammarBuilder.append("KW1134 : 'KW' '1134';\n");
+		grammarBuilder.append("KW1135 : 'KW' '1135';\n");
+		grammarBuilder.append("KW1136 : 'KW' '1136';\n");
+		grammarBuilder.append("KW1137 : 'KW' '1137';\n");
+		grammarBuilder.append("KW1138 : 'KW' '1138';\n");
+		grammarBuilder.append("KW1139 : 'KW' '1139';\n");
+		grammarBuilder.append("KW1140 : 'KW' '1140';\n");
+		grammarBuilder.append("KW1141 : 'KW' '1141';\n");
+		grammarBuilder.append("KW1142 : 'KW' '1142';\n");
+		grammarBuilder.append("KW1143 : 'KW' '1143';\n");
+		grammarBuilder.append("KW1144 : 'KW' '1144';\n");
+		grammarBuilder.append("KW1145 : 'KW' '1145';\n");
+		grammarBuilder.append("KW1146 : 'KW' '1146';\n");
+		grammarBuilder.append("KW1147 : 'KW' '1147';\n");
+		grammarBuilder.append("KW1148 : 'KW' '1148';\n");
+		grammarBuilder.append("KW1149 : 'KW' '1149';\n");
+		grammarBuilder.append("KW1150 : 'KW' '1150';\n");
+		grammarBuilder.append("KW1151 : 'KW' '1151';\n");
+		grammarBuilder.append("KW1152 : 'KW' '1152';\n");
+		grammarBuilder.append("KW1153 : 'KW' '1153';\n");
+		grammarBuilder.append("KW1154 : 'KW' '1154';\n");
+		grammarBuilder.append("KW1155 : 'KW' '1155';\n");
+		grammarBuilder.append("KW1156 : 'KW' '1156';\n");
+		grammarBuilder.append("KW1157 : 'KW' '1157';\n");
+		grammarBuilder.append("KW1158 : 'KW' '1158';\n");
+		grammarBuilder.append("KW1159 : 'KW' '1159';\n");
+		grammarBuilder.append("KW1160 : 'KW' '1160';\n");
+		grammarBuilder.append("KW1161 : 'KW' '1161';\n");
+		grammarBuilder.append("KW1162 : 'KW' '1162';\n");
+		grammarBuilder.append("KW1163 : 'KW' '1163';\n");
+		grammarBuilder.append("KW1164 : 'KW' '1164';\n");
+		grammarBuilder.append("KW1165 : 'KW' '1165';\n");
+		grammarBuilder.append("KW1166 : 'KW' '1166';\n");
+		grammarBuilder.append("KW1167 : 'KW' '1167';\n");
+		grammarBuilder.append("KW1168 : 'KW' '1168';\n");
+		grammarBuilder.append("KW1169 : 'KW' '1169';\n");
+		grammarBuilder.append("KW1170 : 'KW' '1170';\n");
+		grammarBuilder.append("KW1171 : 'KW' '1171';\n");
+		grammarBuilder.append("KW1172 : 'KW' '1172';\n");
+		grammarBuilder.append("KW1173 : 'KW' '1173';\n");
+		grammarBuilder.append("KW1174 : 'KW' '1174';\n");
+		grammarBuilder.append("KW1175 : 'KW' '1175';\n");
+		grammarBuilder.append("KW1176 : 'KW' '1176';\n");
+		grammarBuilder.append("KW1177 : 'KW' '1177';\n");
+		grammarBuilder.append("KW1178 : 'KW' '1178';\n");
+		grammarBuilder.append("KW1179 : 'KW' '1179';\n");
+		grammarBuilder.append("KW1180 : 'KW' '1180';\n");
+		grammarBuilder.append("KW1181 : 'KW' '1181';\n");
+		grammarBuilder.append("KW1182 : 'KW' '1182';\n");
+		grammarBuilder.append("KW1183 : 'KW' '1183';\n");
+		grammarBuilder.append("KW1184 : 'KW' '1184';\n");
+		grammarBuilder.append("KW1185 : 'KW' '1185';\n");
+		grammarBuilder.append("KW1186 : 'KW' '1186';\n");
+		grammarBuilder.append("KW1187 : 'KW' '1187';\n");
+		grammarBuilder.append("KW1188 : 'KW' '1188';\n");
+		grammarBuilder.append("KW1189 : 'KW' '1189';\n");
+		grammarBuilder.append("KW1190 : 'KW' '1190';\n");
+		grammarBuilder.append("KW1191 : 'KW' '1191';\n");
+		grammarBuilder.append("KW1192 : 'KW' '1192';\n");
+		grammarBuilder.append("KW1193 : 'KW' '1193';\n");
+		grammarBuilder.append("KW1194 : 'KW' '1194';\n");
+		grammarBuilder.append("KW1195 : 'KW' '1195';\n");
+		grammarBuilder.append("KW1196 : 'KW' '1196';\n");
+		grammarBuilder.append("KW1197 : 'KW' '1197';\n");
+		grammarBuilder.append("KW1198 : 'KW' '1198';\n");
+		grammarBuilder.append("KW1199 : 'KW' '1199';\n");
+		grammarBuilder.append("KW1200 : 'KW' '1200';\n");
+		grammarBuilder.append("KW1201 : 'KW' '1201';\n");
+		grammarBuilder.append("KW1202 : 'KW' '1202';\n");
+		grammarBuilder.append("KW1203 : 'KW' '1203';\n");
+		grammarBuilder.append("KW1204 : 'KW' '1204';\n");
+		grammarBuilder.append("KW1205 : 'KW' '1205';\n");
+		grammarBuilder.append("KW1206 : 'KW' '1206';\n");
+		grammarBuilder.append("KW1207 : 'KW' '1207';\n");
+		grammarBuilder.append("KW1208 : 'KW' '1208';\n");
+		grammarBuilder.append("KW1209 : 'KW' '1209';\n");
+		grammarBuilder.append("KW1210 : 'KW' '1210';\n");
+		grammarBuilder.append("KW1211 : 'KW' '1211';\n");
+		grammarBuilder.append("KW1212 : 'KW' '1212';\n");
+		grammarBuilder.append("KW1213 : 'KW' '1213';\n");
+		grammarBuilder.append("KW1214 : 'KW' '1214';\n");
+		grammarBuilder.append("KW1215 : 'KW' '1215';\n");
+		grammarBuilder.append("KW1216 : 'KW' '1216';\n");
+		grammarBuilder.append("KW1217 : 'KW' '1217';\n");
+		grammarBuilder.append("KW1218 : 'KW' '1218';\n");
+		grammarBuilder.append("KW1219 : 'KW' '1219';\n");
+		grammarBuilder.append("KW1220 : 'KW' '1220';\n");
+		grammarBuilder.append("KW1221 : 'KW' '1221';\n");
+		grammarBuilder.append("KW1222 : 'KW' '1222';\n");
+		grammarBuilder.append("KW1223 : 'KW' '1223';\n");
+		grammarBuilder.append("KW1224 : 'KW' '1224';\n");
+		grammarBuilder.append("KW1225 : 'KW' '1225';\n");
+		grammarBuilder.append("KW1226 : 'KW' '1226';\n");
+		grammarBuilder.append("KW1227 : 'KW' '1227';\n");
+		grammarBuilder.append("KW1228 : 'KW' '1228';\n");
+		grammarBuilder.append("KW1229 : 'KW' '1229';\n");
+		grammarBuilder.append("KW1230 : 'KW' '1230';\n");
+		grammarBuilder.append("KW1231 : 'KW' '1231';\n");
+		grammarBuilder.append("KW1232 : 'KW' '1232';\n");
+		grammarBuilder.append("KW1233 : 'KW' '1233';\n");
+		grammarBuilder.append("KW1234 : 'KW' '1234';\n");
+		grammarBuilder.append("KW1235 : 'KW' '1235';\n");
+		grammarBuilder.append("KW1236 : 'KW' '1236';\n");
+		grammarBuilder.append("KW1237 : 'KW' '1237';\n");
+		grammarBuilder.append("KW1238 : 'KW' '1238';\n");
+		grammarBuilder.append("KW1239 : 'KW' '1239';\n");
+		grammarBuilder.append("KW1240 : 'KW' '1240';\n");
+		grammarBuilder.append("KW1241 : 'KW' '1241';\n");
+		grammarBuilder.append("KW1242 : 'KW' '1242';\n");
+		grammarBuilder.append("KW1243 : 'KW' '1243';\n");
+		grammarBuilder.append("KW1244 : 'KW' '1244';\n");
+		grammarBuilder.append("KW1245 : 'KW' '1245';\n");
+		grammarBuilder.append("KW1246 : 'KW' '1246';\n");
+		grammarBuilder.append("KW1247 : 'KW' '1247';\n");
+		grammarBuilder.append("KW1248 : 'KW' '1248';\n");
+		grammarBuilder.append("KW1249 : 'KW' '1249';\n");
+		grammarBuilder.append("KW1250 : 'KW' '1250';\n");
+		grammarBuilder.append("KW1251 : 'KW' '1251';\n");
+		grammarBuilder.append("KW1252 : 'KW' '1252';\n");
+		grammarBuilder.append("KW1253 : 'KW' '1253';\n");
+		grammarBuilder.append("KW1254 : 'KW' '1254';\n");
+		grammarBuilder.append("KW1255 : 'KW' '1255';\n");
+		grammarBuilder.append("KW1256 : 'KW' '1256';\n");
+		grammarBuilder.append("KW1257 : 'KW' '1257';\n");
+		grammarBuilder.append("KW1258 : 'KW' '1258';\n");
+		grammarBuilder.append("KW1259 : 'KW' '1259';\n");
+		grammarBuilder.append("KW1260 : 'KW' '1260';\n");
+		grammarBuilder.append("KW1261 : 'KW' '1261';\n");
+		grammarBuilder.append("KW1262 : 'KW' '1262';\n");
+		grammarBuilder.append("KW1263 : 'KW' '1263';\n");
+		grammarBuilder.append("KW1264 : 'KW' '1264';\n");
+		grammarBuilder.append("KW1265 : 'KW' '1265';\n");
+		grammarBuilder.append("KW1266 : 'KW' '1266';\n");
+		grammarBuilder.append("KW1267 : 'KW' '1267';\n");
+		grammarBuilder.append("KW1268 : 'KW' '1268';\n");
+		grammarBuilder.append("KW1269 : 'KW' '1269';\n");
+		grammarBuilder.append("KW1270 : 'KW' '1270';\n");
+		grammarBuilder.append("KW1271 : 'KW' '1271';\n");
+		grammarBuilder.append("KW1272 : 'KW' '1272';\n");
+		grammarBuilder.append("KW1273 : 'KW' '1273';\n");
+		grammarBuilder.append("KW1274 : 'KW' '1274';\n");
+		grammarBuilder.append("KW1275 : 'KW' '1275';\n");
+		grammarBuilder.append("KW1276 : 'KW' '1276';\n");
+		grammarBuilder.append("KW1277 : 'KW' '1277';\n");
+		grammarBuilder.append("KW1278 : 'KW' '1278';\n");
+		grammarBuilder.append("KW1279 : 'KW' '1279';\n");
+		grammarBuilder.append("KW1280 : 'KW' '1280';\n");
+		grammarBuilder.append("KW1281 : 'KW' '1281';\n");
+		grammarBuilder.append("KW1282 : 'KW' '1282';\n");
+		grammarBuilder.append("KW1283 : 'KW' '1283';\n");
+		grammarBuilder.append("KW1284 : 'KW' '1284';\n");
+		grammarBuilder.append("KW1285 : 'KW' '1285';\n");
+		grammarBuilder.append("KW1286 : 'KW' '1286';\n");
+		grammarBuilder.append("KW1287 : 'KW' '1287';\n");
+		grammarBuilder.append("KW1288 : 'KW' '1288';\n");
+		grammarBuilder.append("KW1289 : 'KW' '1289';\n");
+		grammarBuilder.append("KW1290 : 'KW' '1290';\n");
+		grammarBuilder.append("KW1291 : 'KW' '1291';\n");
+		grammarBuilder.append("KW1292 : 'KW' '1292';\n");
+		grammarBuilder.append("KW1293 : 'KW' '1293';\n");
+		grammarBuilder.append("KW1294 : 'KW' '1294';\n");
+		grammarBuilder.append("KW1295 : 'KW' '1295';\n");
+		grammarBuilder.append("KW1296 : 'KW' '1296';\n");
+		grammarBuilder.append("KW1297 : 'KW' '1297';\n");
+		grammarBuilder.append("KW1298 : 'KW' '1298';\n");
+		grammarBuilder.append("KW1299 : 'KW' '1299';\n");
+		grammarBuilder.append("KW1300 : 'KW' '1300';\n");
+		grammarBuilder.append("KW1301 : 'KW' '1301';\n");
+		grammarBuilder.append("KW1302 : 'KW' '1302';\n");
+		grammarBuilder.append("KW1303 : 'KW' '1303';\n");
+		grammarBuilder.append("KW1304 : 'KW' '1304';\n");
+		grammarBuilder.append("KW1305 : 'KW' '1305';\n");
+		grammarBuilder.append("KW1306 : 'KW' '1306';\n");
+		grammarBuilder.append("KW1307 : 'KW' '1307';\n");
+		grammarBuilder.append("KW1308 : 'KW' '1308';\n");
+		grammarBuilder.append("KW1309 : 'KW' '1309';\n");
+		grammarBuilder.append("KW1310 : 'KW' '1310';\n");
+		grammarBuilder.append("KW1311 : 'KW' '1311';\n");
+		grammarBuilder.append("KW1312 : 'KW' '1312';\n");
+		grammarBuilder.append("KW1313 : 'KW' '1313';\n");
+		grammarBuilder.append("KW1314 : 'KW' '1314';\n");
+		grammarBuilder.append("KW1315 : 'KW' '1315';\n");
+		grammarBuilder.append("KW1316 : 'KW' '1316';\n");
+		grammarBuilder.append("KW1317 : 'KW' '1317';\n");
+		grammarBuilder.append("KW1318 : 'KW' '1318';\n");
+		grammarBuilder.append("KW1319 : 'KW' '1319';\n");
+		grammarBuilder.append("KW1320 : 'KW' '1320';\n");
+		grammarBuilder.append("KW1321 : 'KW' '1321';\n");
+		grammarBuilder.append("KW1322 : 'KW' '1322';\n");
+		grammarBuilder.append("KW1323 : 'KW' '1323';\n");
+		grammarBuilder.append("KW1324 : 'KW' '1324';\n");
+		grammarBuilder.append("KW1325 : 'KW' '1325';\n");
+		grammarBuilder.append("KW1326 : 'KW' '1326';\n");
+		grammarBuilder.append("KW1327 : 'KW' '1327';\n");
+		grammarBuilder.append("KW1328 : 'KW' '1328';\n");
+		grammarBuilder.append("KW1329 : 'KW' '1329';\n");
+		grammarBuilder.append("KW1330 : 'KW' '1330';\n");
+		grammarBuilder.append("KW1331 : 'KW' '1331';\n");
+		grammarBuilder.append("KW1332 : 'KW' '1332';\n");
+		grammarBuilder.append("KW1333 : 'KW' '1333';\n");
+		grammarBuilder.append("KW1334 : 'KW' '1334';\n");
+		grammarBuilder.append("KW1335 : 'KW' '1335';\n");
+		grammarBuilder.append("KW1336 : 'KW' '1336';\n");
+		grammarBuilder.append("KW1337 : 'KW' '1337';\n");
+		grammarBuilder.append("KW1338 : 'KW' '1338';\n");
+		grammarBuilder.append("KW1339 : 'KW' '1339';\n");
+		grammarBuilder.append("KW1340 : 'KW' '1340';\n");
+		grammarBuilder.append("KW1341 : 'KW' '1341';\n");
+		grammarBuilder.append("KW1342 : 'KW' '1342';\n");
+		grammarBuilder.append("KW1343 : 'KW' '1343';\n");
+		grammarBuilder.append("KW1344 : 'KW' '1344';\n");
+		grammarBuilder.append("KW1345 : 'KW' '1345';\n");
+		grammarBuilder.append("KW1346 : 'KW' '1346';\n");
+		grammarBuilder.append("KW1347 : 'KW' '1347';\n");
+		grammarBuilder.append("KW1348 : 'KW' '1348';\n");
+		grammarBuilder.append("KW1349 : 'KW' '1349';\n");
+		grammarBuilder.append("KW1350 : 'KW' '1350';\n");
+		grammarBuilder.append("KW1351 : 'KW' '1351';\n");
+		grammarBuilder.append("KW1352 : 'KW' '1352';\n");
+		grammarBuilder.append("KW1353 : 'KW' '1353';\n");
+		grammarBuilder.append("KW1354 : 'KW' '1354';\n");
+		grammarBuilder.append("KW1355 : 'KW' '1355';\n");
+		grammarBuilder.append("KW1356 : 'KW' '1356';\n");
+		grammarBuilder.append("KW1357 : 'KW' '1357';\n");
+		grammarBuilder.append("KW1358 : 'KW' '1358';\n");
+		grammarBuilder.append("KW1359 : 'KW' '1359';\n");
+		grammarBuilder.append("KW1360 : 'KW' '1360';\n");
+		grammarBuilder.append("KW1361 : 'KW' '1361';\n");
+		grammarBuilder.append("KW1362 : 'KW' '1362';\n");
+		grammarBuilder.append("KW1363 : 'KW' '1363';\n");
+		grammarBuilder.append("KW1364 : 'KW' '1364';\n");
+		grammarBuilder.append("KW1365 : 'KW' '1365';\n");
+		grammarBuilder.append("KW1366 : 'KW' '1366';\n");
+		grammarBuilder.append("KW1367 : 'KW' '1367';\n");
+		grammarBuilder.append("KW1368 : 'KW' '1368';\n");
+		grammarBuilder.append("KW1369 : 'KW' '1369';\n");
+		grammarBuilder.append("KW1370 : 'KW' '1370';\n");
+		grammarBuilder.append("KW1371 : 'KW' '1371';\n");
+		grammarBuilder.append("KW1372 : 'KW' '1372';\n");
+		grammarBuilder.append("KW1373 : 'KW' '1373';\n");
+		grammarBuilder.append("KW1374 : 'KW' '1374';\n");
+		grammarBuilder.append("KW1375 : 'KW' '1375';\n");
+		grammarBuilder.append("KW1376 : 'KW' '1376';\n");
+		grammarBuilder.append("KW1377 : 'KW' '1377';\n");
+		grammarBuilder.append("KW1378 : 'KW' '1378';\n");
+		grammarBuilder.append("KW1379 : 'KW' '1379';\n");
+		grammarBuilder.append("KW1380 : 'KW' '1380';\n");
+		grammarBuilder.append("KW1381 : 'KW' '1381';\n");
+		grammarBuilder.append("KW1382 : 'KW' '1382';\n");
+		grammarBuilder.append("KW1383 : 'KW' '1383';\n");
+		grammarBuilder.append("KW1384 : 'KW' '1384';\n");
+		grammarBuilder.append("KW1385 : 'KW' '1385';\n");
+		grammarBuilder.append("KW1386 : 'KW' '1386';\n");
+		grammarBuilder.append("KW1387 : 'KW' '1387';\n");
+		grammarBuilder.append("KW1388 : 'KW' '1388';\n");
+		grammarBuilder.append("KW1389 : 'KW' '1389';\n");
+		grammarBuilder.append("KW1390 : 'KW' '1390';\n");
+		grammarBuilder.append("KW1391 : 'KW' '1391';\n");
+		grammarBuilder.append("KW1392 : 'KW' '1392';\n");
+		grammarBuilder.append("KW1393 : 'KW' '1393';\n");
+		grammarBuilder.append("KW1394 : 'KW' '1394';\n");
+		grammarBuilder.append("KW1395 : 'KW' '1395';\n");
+		grammarBuilder.append("KW1396 : 'KW' '1396';\n");
+		grammarBuilder.append("KW1397 : 'KW' '1397';\n");
+		grammarBuilder.append("KW1398 : 'KW' '1398';\n");
+		grammarBuilder.append("KW1399 : 'KW' '1399';\n");
+		grammarBuilder.append("KW1400 : 'KW' '1400';\n");
+		grammarBuilder.append("KW1401 : 'KW' '1401';\n");
+		grammarBuilder.append("KW1402 : 'KW' '1402';\n");
+		grammarBuilder.append("KW1403 : 'KW' '1403';\n");
+		grammarBuilder.append("KW1404 : 'KW' '1404';\n");
+		grammarBuilder.append("KW1405 : 'KW' '1405';\n");
+		grammarBuilder.append("KW1406 : 'KW' '1406';\n");
+		grammarBuilder.append("KW1407 : 'KW' '1407';\n");
+		grammarBuilder.append("KW1408 : 'KW' '1408';\n");
+		grammarBuilder.append("KW1409 : 'KW' '1409';\n");
+		grammarBuilder.append("KW1410 : 'KW' '1410';\n");
+		grammarBuilder.append("KW1411 : 'KW' '1411';\n");
+		grammarBuilder.append("KW1412 : 'KW' '1412';\n");
+		grammarBuilder.append("KW1413 : 'KW' '1413';\n");
+		grammarBuilder.append("KW1414 : 'KW' '1414';\n");
+		grammarBuilder.append("KW1415 : 'KW' '1415';\n");
+		grammarBuilder.append("KW1416 : 'KW' '1416';\n");
+		grammarBuilder.append("KW1417 : 'KW' '1417';\n");
+		grammarBuilder.append("KW1418 : 'KW' '1418';\n");
+		grammarBuilder.append("KW1419 : 'KW' '1419';\n");
+		grammarBuilder.append("KW1420 : 'KW' '1420';\n");
+		grammarBuilder.append("KW1421 : 'KW' '1421';\n");
+		grammarBuilder.append("KW1422 : 'KW' '1422';\n");
+		grammarBuilder.append("KW1423 : 'KW' '1423';\n");
+		grammarBuilder.append("KW1424 : 'KW' '1424';\n");
+		grammarBuilder.append("KW1425 : 'KW' '1425';\n");
+		grammarBuilder.append("KW1426 : 'KW' '1426';\n");
+		grammarBuilder.append("KW1427 : 'KW' '1427';\n");
+		grammarBuilder.append("KW1428 : 'KW' '1428';\n");
+		grammarBuilder.append("KW1429 : 'KW' '1429';\n");
+		grammarBuilder.append("KW1430 : 'KW' '1430';\n");
+		grammarBuilder.append("KW1431 : 'KW' '1431';\n");
+		grammarBuilder.append("KW1432 : 'KW' '1432';\n");
+		grammarBuilder.append("KW1433 : 'KW' '1433';\n");
+		grammarBuilder.append("KW1434 : 'KW' '1434';\n");
+		grammarBuilder.append("KW1435 : 'KW' '1435';\n");
+		grammarBuilder.append("KW1436 : 'KW' '1436';\n");
+		grammarBuilder.append("KW1437 : 'KW' '1437';\n");
+		grammarBuilder.append("KW1438 : 'KW' '1438';\n");
+		grammarBuilder.append("KW1439 : 'KW' '1439';\n");
+		grammarBuilder.append("KW1440 : 'KW' '1440';\n");
+		grammarBuilder.append("KW1441 : 'KW' '1441';\n");
+		grammarBuilder.append("KW1442 : 'KW' '1442';\n");
+		grammarBuilder.append("KW1443 : 'KW' '1443';\n");
+		grammarBuilder.append("KW1444 : 'KW' '1444';\n");
+		grammarBuilder.append("KW1445 : 'KW' '1445';\n");
+		grammarBuilder.append("KW1446 : 'KW' '1446';\n");
+		grammarBuilder.append("KW1447 : 'KW' '1447';\n");
+		grammarBuilder.append("KW1448 : 'KW' '1448';\n");
+		grammarBuilder.append("KW1449 : 'KW' '1449';\n");
+		grammarBuilder.append("KW1450 : 'KW' '1450';\n");
+		grammarBuilder.append("KW1451 : 'KW' '1451';\n");
+		grammarBuilder.append("KW1452 : 'KW' '1452';\n");
+		grammarBuilder.append("KW1453 : 'KW' '1453';\n");
+		grammarBuilder.append("KW1454 : 'KW' '1454';\n");
+		grammarBuilder.append("KW1455 : 'KW' '1455';\n");
+		grammarBuilder.append("KW1456 : 'KW' '1456';\n");
+		grammarBuilder.append("KW1457 : 'KW' '1457';\n");
+		grammarBuilder.append("KW1458 : 'KW' '1458';\n");
+		grammarBuilder.append("KW1459 : 'KW' '1459';\n");
+		grammarBuilder.append("KW1460 : 'KW' '1460';\n");
+		grammarBuilder.append("KW1461 : 'KW' '1461';\n");
+		grammarBuilder.append("KW1462 : 'KW' '1462';\n");
+		grammarBuilder.append("KW1463 : 'KW' '1463';\n");
+		grammarBuilder.append("KW1464 : 'KW' '1464';\n");
+		grammarBuilder.append("KW1465 : 'KW' '1465';\n");
+		grammarBuilder.append("KW1466 : 'KW' '1466';\n");
+		grammarBuilder.append("KW1467 : 'KW' '1467';\n");
+		grammarBuilder.append("KW1468 : 'KW' '1468';\n");
+		grammarBuilder.append("KW1469 : 'KW' '1469';\n");
+		grammarBuilder.append("KW1470 : 'KW' '1470';\n");
+		grammarBuilder.append("KW1471 : 'KW' '1471';\n");
+		grammarBuilder.append("KW1472 : 'KW' '1472';\n");
+		grammarBuilder.append("KW1473 : 'KW' '1473';\n");
+		grammarBuilder.append("KW1474 : 'KW' '1474';\n");
+		grammarBuilder.append("KW1475 : 'KW' '1475';\n");
+		grammarBuilder.append("KW1476 : 'KW' '1476';\n");
+		grammarBuilder.append("KW1477 : 'KW' '1477';\n");
+		grammarBuilder.append("KW1478 : 'KW' '1478';\n");
+		grammarBuilder.append("KW1479 : 'KW' '1479';\n");
+		grammarBuilder.append("KW1480 : 'KW' '1480';\n");
+		grammarBuilder.append("KW1481 : 'KW' '1481';\n");
+		grammarBuilder.append("KW1482 : 'KW' '1482';\n");
+		grammarBuilder.append("KW1483 : 'KW' '1483';\n");
+		grammarBuilder.append("KW1484 : 'KW' '1484';\n");
+		grammarBuilder.append("KW1485 : 'KW' '1485';\n");
+		grammarBuilder.append("KW1486 : 'KW' '1486';\n");
+		grammarBuilder.append("KW1487 : 'KW' '1487';\n");
+		grammarBuilder.append("KW1488 : 'KW' '1488';\n");
+		grammarBuilder.append("KW1489 : 'KW' '1489';\n");
+		grammarBuilder.append("KW1490 : 'KW' '1490';\n");
+		grammarBuilder.append("KW1491 : 'KW' '1491';\n");
+		grammarBuilder.append("KW1492 : 'KW' '1492';\n");
+		grammarBuilder.append("KW1493 : 'KW' '1493';\n");
+		grammarBuilder.append("KW1494 : 'KW' '1494';\n");
+		grammarBuilder.append("KW1495 : 'KW' '1495';\n");
+		grammarBuilder.append("KW1496 : 'KW' '1496';\n");
+		grammarBuilder.append("KW1497 : 'KW' '1497';\n");
+		grammarBuilder.append("KW1498 : 'KW' '1498';\n");
+		grammarBuilder.append("KW1499 : 'KW' '1499';\n");
+		grammarBuilder.append("KW1500 : 'KW' '1500';\n");
+		grammarBuilder.append("KW1501 : 'KW' '1501';\n");
+		grammarBuilder.append("KW1502 : 'KW' '1502';\n");
+		grammarBuilder.append("KW1503 : 'KW' '1503';\n");
+		grammarBuilder.append("KW1504 : 'KW' '1504';\n");
+		grammarBuilder.append("KW1505 : 'KW' '1505';\n");
+		grammarBuilder.append("KW1506 : 'KW' '1506';\n");
+		grammarBuilder.append("KW1507 : 'KW' '1507';\n");
+		grammarBuilder.append("KW1508 : 'KW' '1508';\n");
+		grammarBuilder.append("KW1509 : 'KW' '1509';\n");
+		grammarBuilder.append("KW1510 : 'KW' '1510';\n");
+		grammarBuilder.append("KW1511 : 'KW' '1511';\n");
+		grammarBuilder.append("KW1512 : 'KW' '1512';\n");
+		grammarBuilder.append("KW1513 : 'KW' '1513';\n");
+		grammarBuilder.append("KW1514 : 'KW' '1514';\n");
+		grammarBuilder.append("KW1515 : 'KW' '1515';\n");
+		grammarBuilder.append("KW1516 : 'KW' '1516';\n");
+		grammarBuilder.append("KW1517 : 'KW' '1517';\n");
+		grammarBuilder.append("KW1518 : 'KW' '1518';\n");
+		grammarBuilder.append("KW1519 : 'KW' '1519';\n");
+		grammarBuilder.append("KW1520 : 'KW' '1520';\n");
+		grammarBuilder.append("KW1521 : 'KW' '1521';\n");
+		grammarBuilder.append("KW1522 : 'KW' '1522';\n");
+		grammarBuilder.append("KW1523 : 'KW' '1523';\n");
+		grammarBuilder.append("KW1524 : 'KW' '1524';\n");
+		grammarBuilder.append("KW1525 : 'KW' '1525';\n");
+		grammarBuilder.append("KW1526 : 'KW' '1526';\n");
+		grammarBuilder.append("KW1527 : 'KW' '1527';\n");
+		grammarBuilder.append("KW1528 : 'KW' '1528';\n");
+		grammarBuilder.append("KW1529 : 'KW' '1529';\n");
+		grammarBuilder.append("KW1530 : 'KW' '1530';\n");
+		grammarBuilder.append("KW1531 : 'KW' '1531';\n");
+		grammarBuilder.append("KW1532 : 'KW' '1532';\n");
+		grammarBuilder.append("KW1533 : 'KW' '1533';\n");
+		grammarBuilder.append("KW1534 : 'KW' '1534';\n");
+		grammarBuilder.append("KW1535 : 'KW' '1535';\n");
+		grammarBuilder.append("KW1536 : 'KW' '1536';\n");
+		grammarBuilder.append("KW1537 : 'KW' '1537';\n");
+		grammarBuilder.append("KW1538 : 'KW' '1538';\n");
+		grammarBuilder.append("KW1539 : 'KW' '1539';\n");
+		grammarBuilder.append("KW1540 : 'KW' '1540';\n");
+		grammarBuilder.append("KW1541 : 'KW' '1541';\n");
+		grammarBuilder.append("KW1542 : 'KW' '1542';\n");
+		grammarBuilder.append("KW1543 : 'KW' '1543';\n");
+		grammarBuilder.append("KW1544 : 'KW' '1544';\n");
+		grammarBuilder.append("KW1545 : 'KW' '1545';\n");
+		grammarBuilder.append("KW1546 : 'KW' '1546';\n");
+		grammarBuilder.append("KW1547 : 'KW' '1547';\n");
+		grammarBuilder.append("KW1548 : 'KW' '1548';\n");
+		grammarBuilder.append("KW1549 : 'KW' '1549';\n");
+		grammarBuilder.append("KW1550 : 'KW' '1550';\n");
+		grammarBuilder.append("KW1551 : 'KW' '1551';\n");
+		grammarBuilder.append("KW1552 : 'KW' '1552';\n");
+		grammarBuilder.append("KW1553 : 'KW' '1553';\n");
+		grammarBuilder.append("KW1554 : 'KW' '1554';\n");
+		grammarBuilder.append("KW1555 : 'KW' '1555';\n");
+		grammarBuilder.append("KW1556 : 'KW' '1556';\n");
+		grammarBuilder.append("KW1557 : 'KW' '1557';\n");
+		grammarBuilder.append("KW1558 : 'KW' '1558';\n");
+		grammarBuilder.append("KW1559 : 'KW' '1559';\n");
+		grammarBuilder.append("KW1560 : 'KW' '1560';\n");
+		grammarBuilder.append("KW1561 : 'KW' '1561';\n");
+		grammarBuilder.append("KW1562 : 'KW' '1562';\n");
+		grammarBuilder.append("KW1563 : 'KW' '1563';\n");
+		grammarBuilder.append("KW1564 : 'KW' '1564';\n");
+		grammarBuilder.append("KW1565 : 'KW' '1565';\n");
+		grammarBuilder.append("KW1566 : 'KW' '1566';\n");
+		grammarBuilder.append("KW1567 : 'KW' '1567';\n");
+		grammarBuilder.append("KW1568 : 'KW' '1568';\n");
+		grammarBuilder.append("KW1569 : 'KW' '1569';\n");
+		grammarBuilder.append("KW1570 : 'KW' '1570';\n");
+		grammarBuilder.append("KW1571 : 'KW' '1571';\n");
+		grammarBuilder.append("KW1572 : 'KW' '1572';\n");
+		grammarBuilder.append("KW1573 : 'KW' '1573';\n");
+		grammarBuilder.append("KW1574 : 'KW' '1574';\n");
+		grammarBuilder.append("KW1575 : 'KW' '1575';\n");
+		grammarBuilder.append("KW1576 : 'KW' '1576';\n");
+		grammarBuilder.append("KW1577 : 'KW' '1577';\n");
+		grammarBuilder.append("KW1578 : 'KW' '1578';\n");
+		grammarBuilder.append("KW1579 : 'KW' '1579';\n");
+		grammarBuilder.append("KW1580 : 'KW' '1580';\n");
+		grammarBuilder.append("KW1581 : 'KW' '1581';\n");
+		grammarBuilder.append("KW1582 : 'KW' '1582';\n");
+		grammarBuilder.append("KW1583 : 'KW' '1583';\n");
+		grammarBuilder.append("KW1584 : 'KW' '1584';\n");
+		grammarBuilder.append("KW1585 : 'KW' '1585';\n");
+		grammarBuilder.append("KW1586 : 'KW' '1586';\n");
+		grammarBuilder.append("KW1587 : 'KW' '1587';\n");
+		grammarBuilder.append("KW1588 : 'KW' '1588';\n");
+		grammarBuilder.append("KW1589 : 'KW' '1589';\n");
+		grammarBuilder.append("KW1590 : 'KW' '1590';\n");
+		grammarBuilder.append("KW1591 : 'KW' '1591';\n");
+		grammarBuilder.append("KW1592 : 'KW' '1592';\n");
+		grammarBuilder.append("KW1593 : 'KW' '1593';\n");
+		grammarBuilder.append("KW1594 : 'KW' '1594';\n");
+		grammarBuilder.append("KW1595 : 'KW' '1595';\n");
+		grammarBuilder.append("KW1596 : 'KW' '1596';\n");
+		grammarBuilder.append("KW1597 : 'KW' '1597';\n");
+		grammarBuilder.append("KW1598 : 'KW' '1598';\n");
+		grammarBuilder.append("KW1599 : 'KW' '1599';\n");
+		grammarBuilder.append("KW1600 : 'KW' '1600';\n");
+		grammarBuilder.append("KW1601 : 'KW' '1601';\n");
+		grammarBuilder.append("KW1602 : 'KW' '1602';\n");
+		grammarBuilder.append("KW1603 : 'KW' '1603';\n");
+		grammarBuilder.append("KW1604 : 'KW' '1604';\n");
+		grammarBuilder.append("KW1605 : 'KW' '1605';\n");
+		grammarBuilder.append("KW1606 : 'KW' '1606';\n");
+		grammarBuilder.append("KW1607 : 'KW' '1607';\n");
+		grammarBuilder.append("KW1608 : 'KW' '1608';\n");
+		grammarBuilder.append("KW1609 : 'KW' '1609';\n");
+		grammarBuilder.append("KW1610 : 'KW' '1610';\n");
+		grammarBuilder.append("KW1611 : 'KW' '1611';\n");
+		grammarBuilder.append("KW1612 : 'KW' '1612';\n");
+		grammarBuilder.append("KW1613 : 'KW' '1613';\n");
+		grammarBuilder.append("KW1614 : 'KW' '1614';\n");
+		grammarBuilder.append("KW1615 : 'KW' '1615';\n");
+		grammarBuilder.append("KW1616 : 'KW' '1616';\n");
+		grammarBuilder.append("KW1617 : 'KW' '1617';\n");
+		grammarBuilder.append("KW1618 : 'KW' '1618';\n");
+		grammarBuilder.append("KW1619 : 'KW' '1619';\n");
+		grammarBuilder.append("KW1620 : 'KW' '1620';\n");
+		grammarBuilder.append("KW1621 : 'KW' '1621';\n");
+		grammarBuilder.append("KW1622 : 'KW' '1622';\n");
+		grammarBuilder.append("KW1623 : 'KW' '1623';\n");
+		grammarBuilder.append("KW1624 : 'KW' '1624';\n");
+		grammarBuilder.append("KW1625 : 'KW' '1625';\n");
+		grammarBuilder.append("KW1626 : 'KW' '1626';\n");
+		grammarBuilder.append("KW1627 : 'KW' '1627';\n");
+		grammarBuilder.append("KW1628 : 'KW' '1628';\n");
+		grammarBuilder.append("KW1629 : 'KW' '1629';\n");
+		grammarBuilder.append("KW1630 : 'KW' '1630';\n");
+		grammarBuilder.append("KW1631 : 'KW' '1631';\n");
+		grammarBuilder.append("KW1632 : 'KW' '1632';\n");
+		grammarBuilder.append("KW1633 : 'KW' '1633';\n");
+		grammarBuilder.append("KW1634 : 'KW' '1634';\n");
+		grammarBuilder.append("KW1635 : 'KW' '1635';\n");
+		grammarBuilder.append("KW1636 : 'KW' '1636';\n");
+		grammarBuilder.append("KW1637 : 'KW' '1637';\n");
+		grammarBuilder.append("KW1638 : 'KW' '1638';\n");
+		grammarBuilder.append("KW1639 : 'KW' '1639';\n");
+		grammarBuilder.append("KW1640 : 'KW' '1640';\n");
+		grammarBuilder.append("KW1641 : 'KW' '1641';\n");
+		grammarBuilder.append("KW1642 : 'KW' '1642';\n");
+		grammarBuilder.append("KW1643 : 'KW' '1643';\n");
+		grammarBuilder.append("KW1644 : 'KW' '1644';\n");
+		grammarBuilder.append("KW1645 : 'KW' '1645';\n");
+		grammarBuilder.append("KW1646 : 'KW' '1646';\n");
+		grammarBuilder.append("KW1647 : 'KW' '1647';\n");
+		grammarBuilder.append("KW1648 : 'KW' '1648';\n");
+		grammarBuilder.append("KW1649 : 'KW' '1649';\n");
+		grammarBuilder.append("KW1650 : 'KW' '1650';\n");
+		grammarBuilder.append("KW1651 : 'KW' '1651';\n");
+		grammarBuilder.append("KW1652 : 'KW' '1652';\n");
+		grammarBuilder.append("KW1653 : 'KW' '1653';\n");
+		grammarBuilder.append("KW1654 : 'KW' '1654';\n");
+		grammarBuilder.append("KW1655 : 'KW' '1655';\n");
+		grammarBuilder.append("KW1656 : 'KW' '1656';\n");
+		grammarBuilder.append("KW1657 : 'KW' '1657';\n");
+		grammarBuilder.append("KW1658 : 'KW' '1658';\n");
+		grammarBuilder.append("KW1659 : 'KW' '1659';\n");
+		grammarBuilder.append("KW1660 : 'KW' '1660';\n");
+		grammarBuilder.append("KW1661 : 'KW' '1661';\n");
+		grammarBuilder.append("KW1662 : 'KW' '1662';\n");
+		grammarBuilder.append("KW1663 : 'KW' '1663';\n");
+		grammarBuilder.append("KW1664 : 'KW' '1664';\n");
+		grammarBuilder.append("KW1665 : 'KW' '1665';\n");
+		grammarBuilder.append("KW1666 : 'KW' '1666';\n");
+		grammarBuilder.append("KW1667 : 'KW' '1667';\n");
+		grammarBuilder.append("KW1668 : 'KW' '1668';\n");
+		grammarBuilder.append("KW1669 : 'KW' '1669';\n");
+		grammarBuilder.append("KW1670 : 'KW' '1670';\n");
+		grammarBuilder.append("KW1671 : 'KW' '1671';\n");
+		grammarBuilder.append("KW1672 : 'KW' '1672';\n");
+		grammarBuilder.append("KW1673 : 'KW' '1673';\n");
+		grammarBuilder.append("KW1674 : 'KW' '1674';\n");
+		grammarBuilder.append("KW1675 : 'KW' '1675';\n");
+		grammarBuilder.append("KW1676 : 'KW' '1676';\n");
+		grammarBuilder.append("KW1677 : 'KW' '1677';\n");
+		grammarBuilder.append("KW1678 : 'KW' '1678';\n");
+		grammarBuilder.append("KW1679 : 'KW' '1679';\n");
+		grammarBuilder.append("KW1680 : 'KW' '1680';\n");
+		grammarBuilder.append("KW1681 : 'KW' '1681';\n");
+		grammarBuilder.append("KW1682 : 'KW' '1682';\n");
+		grammarBuilder.append("KW1683 : 'KW' '1683';\n");
+		grammarBuilder.append("KW1684 : 'KW' '1684';\n");
+		grammarBuilder.append("KW1685 : 'KW' '1685';\n");
+		grammarBuilder.append("KW1686 : 'KW' '1686';\n");
+		grammarBuilder.append("KW1687 : 'KW' '1687';\n");
+		grammarBuilder.append("KW1688 : 'KW' '1688';\n");
+		grammarBuilder.append("KW1689 : 'KW' '1689';\n");
+		grammarBuilder.append("KW1690 : 'KW' '1690';\n");
+		grammarBuilder.append("KW1691 : 'KW' '1691';\n");
+		grammarBuilder.append("KW1692 : 'KW' '1692';\n");
+		grammarBuilder.append("KW1693 : 'KW' '1693';\n");
+		grammarBuilder.append("KW1694 : 'KW' '1694';\n");
+		grammarBuilder.append("KW1695 : 'KW' '1695';\n");
+		grammarBuilder.append("KW1696 : 'KW' '1696';\n");
+		grammarBuilder.append("KW1697 : 'KW' '1697';\n");
+		grammarBuilder.append("KW1698 : 'KW' '1698';\n");
+		grammarBuilder.append("KW1699 : 'KW' '1699';\n");
+		grammarBuilder.append("KW1700 : 'KW' '1700';\n");
+		grammarBuilder.append("KW1701 : 'KW' '1701';\n");
+		grammarBuilder.append("KW1702 : 'KW' '1702';\n");
+		grammarBuilder.append("KW1703 : 'KW' '1703';\n");
+		grammarBuilder.append("KW1704 : 'KW' '1704';\n");
+		grammarBuilder.append("KW1705 : 'KW' '1705';\n");
+		grammarBuilder.append("KW1706 : 'KW' '1706';\n");
+		grammarBuilder.append("KW1707 : 'KW' '1707';\n");
+		grammarBuilder.append("KW1708 : 'KW' '1708';\n");
+		grammarBuilder.append("KW1709 : 'KW' '1709';\n");
+		grammarBuilder.append("KW1710 : 'KW' '1710';\n");
+		grammarBuilder.append("KW1711 : 'KW' '1711';\n");
+		grammarBuilder.append("KW1712 : 'KW' '1712';\n");
+		grammarBuilder.append("KW1713 : 'KW' '1713';\n");
+		grammarBuilder.append("KW1714 : 'KW' '1714';\n");
+		grammarBuilder.append("KW1715 : 'KW' '1715';\n");
+		grammarBuilder.append("KW1716 : 'KW' '1716';\n");
+		grammarBuilder.append("KW1717 : 'KW' '1717';\n");
+		grammarBuilder.append("KW1718 : 'KW' '1718';\n");
+		grammarBuilder.append("KW1719 : 'KW' '1719';\n");
+		grammarBuilder.append("KW1720 : 'KW' '1720';\n");
+		grammarBuilder.append("KW1721 : 'KW' '1721';\n");
+		grammarBuilder.append("KW1722 : 'KW' '1722';\n");
+		grammarBuilder.append("KW1723 : 'KW' '1723';\n");
+		grammarBuilder.append("KW1724 : 'KW' '1724';\n");
+		grammarBuilder.append("KW1725 : 'KW' '1725';\n");
+		grammarBuilder.append("KW1726 : 'KW' '1726';\n");
+		grammarBuilder.append("KW1727 : 'KW' '1727';\n");
+		grammarBuilder.append("KW1728 : 'KW' '1728';\n");
+		grammarBuilder.append("KW1729 : 'KW' '1729';\n");
+		grammarBuilder.append("KW1730 : 'KW' '1730';\n");
+		grammarBuilder.append("KW1731 : 'KW' '1731';\n");
+		grammarBuilder.append("KW1732 : 'KW' '1732';\n");
+		grammarBuilder.append("KW1733 : 'KW' '1733';\n");
+		grammarBuilder.append("KW1734 : 'KW' '1734';\n");
+		grammarBuilder.append("KW1735 : 'KW' '1735';\n");
+		grammarBuilder.append("KW1736 : 'KW' '1736';\n");
+		grammarBuilder.append("KW1737 : 'KW' '1737';\n");
+		grammarBuilder.append("KW1738 : 'KW' '1738';\n");
+		grammarBuilder.append("KW1739 : 'KW' '1739';\n");
+		grammarBuilder.append("KW1740 : 'KW' '1740';\n");
+		grammarBuilder.append("KW1741 : 'KW' '1741';\n");
+		grammarBuilder.append("KW1742 : 'KW' '1742';\n");
+		grammarBuilder.append("KW1743 : 'KW' '1743';\n");
+		grammarBuilder.append("KW1744 : 'KW' '1744';\n");
+		grammarBuilder.append("KW1745 : 'KW' '1745';\n");
+		grammarBuilder.append("KW1746 : 'KW' '1746';\n");
+		grammarBuilder.append("KW1747 : 'KW' '1747';\n");
+		grammarBuilder.append("KW1748 : 'KW' '1748';\n");
+		grammarBuilder.append("KW1749 : 'KW' '1749';\n");
+		grammarBuilder.append("KW1750 : 'KW' '1750';\n");
+		grammarBuilder.append("KW1751 : 'KW' '1751';\n");
+		grammarBuilder.append("KW1752 : 'KW' '1752';\n");
+		grammarBuilder.append("KW1753 : 'KW' '1753';\n");
+		grammarBuilder.append("KW1754 : 'KW' '1754';\n");
+		grammarBuilder.append("KW1755 : 'KW' '1755';\n");
+		grammarBuilder.append("KW1756 : 'KW' '1756';\n");
+		grammarBuilder.append("KW1757 : 'KW' '1757';\n");
+		grammarBuilder.append("KW1758 : 'KW' '1758';\n");
+		grammarBuilder.append("KW1759 : 'KW' '1759';\n");
+		grammarBuilder.append("KW1760 : 'KW' '1760';\n");
+		grammarBuilder.append("KW1761 : 'KW' '1761';\n");
+		grammarBuilder.append("KW1762 : 'KW' '1762';\n");
+		grammarBuilder.append("KW1763 : 'KW' '1763';\n");
+		grammarBuilder.append("KW1764 : 'KW' '1764';\n");
+		grammarBuilder.append("KW1765 : 'KW' '1765';\n");
+		grammarBuilder.append("KW1766 : 'KW' '1766';\n");
+		grammarBuilder.append("KW1767 : 'KW' '1767';\n");
+		grammarBuilder.append("KW1768 : 'KW' '1768';\n");
+		grammarBuilder.append("KW1769 : 'KW' '1769';\n");
+		grammarBuilder.append("KW1770 : 'KW' '1770';\n");
+		grammarBuilder.append("KW1771 : 'KW' '1771';\n");
+		grammarBuilder.append("KW1772 : 'KW' '1772';\n");
+		grammarBuilder.append("KW1773 : 'KW' '1773';\n");
+		grammarBuilder.append("KW1774 : 'KW' '1774';\n");
+		grammarBuilder.append("KW1775 : 'KW' '1775';\n");
+		grammarBuilder.append("KW1776 : 'KW' '1776';\n");
+		grammarBuilder.append("KW1777 : 'KW' '1777';\n");
+		grammarBuilder.append("KW1778 : 'KW' '1778';\n");
+		grammarBuilder.append("KW1779 : 'KW' '1779';\n");
+		grammarBuilder.append("KW1780 : 'KW' '1780';\n");
+		grammarBuilder.append("KW1781 : 'KW' '1781';\n");
+		grammarBuilder.append("KW1782 : 'KW' '1782';\n");
+		grammarBuilder.append("KW1783 : 'KW' '1783';\n");
+		grammarBuilder.append("KW1784 : 'KW' '1784';\n");
+		grammarBuilder.append("KW1785 : 'KW' '1785';\n");
+		grammarBuilder.append("KW1786 : 'KW' '1786';\n");
+		grammarBuilder.append("KW1787 : 'KW' '1787';\n");
+		grammarBuilder.append("KW1788 : 'KW' '1788';\n");
+		grammarBuilder.append("KW1789 : 'KW' '1789';\n");
+		grammarBuilder.append("KW1790 : 'KW' '1790';\n");
+		grammarBuilder.append("KW1791 : 'KW' '1791';\n");
+		grammarBuilder.append("KW1792 : 'KW' '1792';\n");
+		grammarBuilder.append("KW1793 : 'KW' '1793';\n");
+		grammarBuilder.append("KW1794 : 'KW' '1794';\n");
+		grammarBuilder.append("KW1795 : 'KW' '1795';\n");
+		grammarBuilder.append("KW1796 : 'KW' '1796';\n");
+		grammarBuilder.append("KW1797 : 'KW' '1797';\n");
+		grammarBuilder.append("KW1798 : 'KW' '1798';\n");
+		grammarBuilder.append("KW1799 : 'KW' '1799';\n");
+		grammarBuilder.append("KW1800 : 'KW' '1800';\n");
+		grammarBuilder.append("KW1801 : 'KW' '1801';\n");
+		grammarBuilder.append("KW1802 : 'KW' '1802';\n");
+		grammarBuilder.append("KW1803 : 'KW' '1803';\n");
+		grammarBuilder.append("KW1804 : 'KW' '1804';\n");
+		grammarBuilder.append("KW1805 : 'KW' '1805';\n");
+		grammarBuilder.append("KW1806 : 'KW' '1806';\n");
+		grammarBuilder.append("KW1807 : 'KW' '1807';\n");
+		grammarBuilder.append("KW1808 : 'KW' '1808';\n");
+		grammarBuilder.append("KW1809 : 'KW' '1809';\n");
+		grammarBuilder.append("KW1810 : 'KW' '1810';\n");
+		grammarBuilder.append("KW1811 : 'KW' '1811';\n");
+		grammarBuilder.append("KW1812 : 'KW' '1812';\n");
+		grammarBuilder.append("KW1813 : 'KW' '1813';\n");
+		grammarBuilder.append("KW1814 : 'KW' '1814';\n");
+		grammarBuilder.append("KW1815 : 'KW' '1815';\n");
+		grammarBuilder.append("KW1816 : 'KW' '1816';\n");
+		grammarBuilder.append("KW1817 : 'KW' '1817';\n");
+		grammarBuilder.append("KW1818 : 'KW' '1818';\n");
+		grammarBuilder.append("KW1819 : 'KW' '1819';\n");
+		grammarBuilder.append("KW1820 : 'KW' '1820';\n");
+		grammarBuilder.append("KW1821 : 'KW' '1821';\n");
+		grammarBuilder.append("KW1822 : 'KW' '1822';\n");
+		grammarBuilder.append("KW1823 : 'KW' '1823';\n");
+		grammarBuilder.append("KW1824 : 'KW' '1824';\n");
+		grammarBuilder.append("KW1825 : 'KW' '1825';\n");
+		grammarBuilder.append("KW1826 : 'KW' '1826';\n");
+		grammarBuilder.append("KW1827 : 'KW' '1827';\n");
+		grammarBuilder.append("KW1828 : 'KW' '1828';\n");
+		grammarBuilder.append("KW1829 : 'KW' '1829';\n");
+		grammarBuilder.append("KW1830 : 'KW' '1830';\n");
+		grammarBuilder.append("KW1831 : 'KW' '1831';\n");
+		grammarBuilder.append("KW1832 : 'KW' '1832';\n");
+		grammarBuilder.append("KW1833 : 'KW' '1833';\n");
+		grammarBuilder.append("KW1834 : 'KW' '1834';\n");
+		grammarBuilder.append("KW1835 : 'KW' '1835';\n");
+		grammarBuilder.append("KW1836 : 'KW' '1836';\n");
+		grammarBuilder.append("KW1837 : 'KW' '1837';\n");
+		grammarBuilder.append("KW1838 : 'KW' '1838';\n");
+		grammarBuilder.append("KW1839 : 'KW' '1839';\n");
+		grammarBuilder.append("KW1840 : 'KW' '1840';\n");
+		grammarBuilder.append("KW1841 : 'KW' '1841';\n");
+		grammarBuilder.append("KW1842 : 'KW' '1842';\n");
+		grammarBuilder.append("KW1843 : 'KW' '1843';\n");
+		grammarBuilder.append("KW1844 : 'KW' '1844';\n");
+		grammarBuilder.append("KW1845 : 'KW' '1845';\n");
+		grammarBuilder.append("KW1846 : 'KW' '1846';\n");
+		grammarBuilder.append("KW1847 : 'KW' '1847';\n");
+		grammarBuilder.append("KW1848 : 'KW' '1848';\n");
+		grammarBuilder.append("KW1849 : 'KW' '1849';\n");
+		grammarBuilder.append("KW1850 : 'KW' '1850';\n");
+		grammarBuilder.append("KW1851 : 'KW' '1851';\n");
+		grammarBuilder.append("KW1852 : 'KW' '1852';\n");
+		grammarBuilder.append("KW1853 : 'KW' '1853';\n");
+		grammarBuilder.append("KW1854 : 'KW' '1854';\n");
+		grammarBuilder.append("KW1855 : 'KW' '1855';\n");
+		grammarBuilder.append("KW1856 : 'KW' '1856';\n");
+		grammarBuilder.append("KW1857 : 'KW' '1857';\n");
+		grammarBuilder.append("KW1858 : 'KW' '1858';\n");
+		grammarBuilder.append("KW1859 : 'KW' '1859';\n");
+		grammarBuilder.append("KW1860 : 'KW' '1860';\n");
+		grammarBuilder.append("KW1861 : 'KW' '1861';\n");
+		grammarBuilder.append("KW1862 : 'KW' '1862';\n");
+		grammarBuilder.append("KW1863 : 'KW' '1863';\n");
+		grammarBuilder.append("KW1864 : 'KW' '1864';\n");
+		grammarBuilder.append("KW1865 : 'KW' '1865';\n");
+		grammarBuilder.append("KW1866 : 'KW' '1866';\n");
+		grammarBuilder.append("KW1867 : 'KW' '1867';\n");
+		grammarBuilder.append("KW1868 : 'KW' '1868';\n");
+		grammarBuilder.append("KW1869 : 'KW' '1869';\n");
+		grammarBuilder.append("KW1870 : 'KW' '1870';\n");
+		grammarBuilder.append("KW1871 : 'KW' '1871';\n");
+		grammarBuilder.append("KW1872 : 'KW' '1872';\n");
+		grammarBuilder.append("KW1873 : 'KW' '1873';\n");
+		grammarBuilder.append("KW1874 : 'KW' '1874';\n");
+		grammarBuilder.append("KW1875 : 'KW' '1875';\n");
+		grammarBuilder.append("KW1876 : 'KW' '1876';\n");
+		grammarBuilder.append("KW1877 : 'KW' '1877';\n");
+		grammarBuilder.append("KW1878 : 'KW' '1878';\n");
+		grammarBuilder.append("KW1879 : 'KW' '1879';\n");
+		grammarBuilder.append("KW1880 : 'KW' '1880';\n");
+		grammarBuilder.append("KW1881 : 'KW' '1881';\n");
+		grammarBuilder.append("KW1882 : 'KW' '1882';\n");
+		grammarBuilder.append("KW1883 : 'KW' '1883';\n");
+		grammarBuilder.append("KW1884 : 'KW' '1884';\n");
+		grammarBuilder.append("KW1885 : 'KW' '1885';\n");
+		grammarBuilder.append("KW1886 : 'KW' '1886';\n");
+		grammarBuilder.append("KW1887 : 'KW' '1887';\n");
+		grammarBuilder.append("KW1888 : 'KW' '1888';\n");
+		grammarBuilder.append("KW1889 : 'KW' '1889';\n");
+		grammarBuilder.append("KW1890 : 'KW' '1890';\n");
+		grammarBuilder.append("KW1891 : 'KW' '1891';\n");
+		grammarBuilder.append("KW1892 : 'KW' '1892';\n");
+		grammarBuilder.append("KW1893 : 'KW' '1893';\n");
+		grammarBuilder.append("KW1894 : 'KW' '1894';\n");
+		grammarBuilder.append("KW1895 : 'KW' '1895';\n");
+		grammarBuilder.append("KW1896 : 'KW' '1896';\n");
+		grammarBuilder.append("KW1897 : 'KW' '1897';\n");
+		grammarBuilder.append("KW1898 : 'KW' '1898';\n");
+		grammarBuilder.append("KW1899 : 'KW' '1899';\n");
+		grammarBuilder.append("KW1900 : 'KW' '1900';\n");
+		grammarBuilder.append("KW1901 : 'KW' '1901';\n");
+		grammarBuilder.append("KW1902 : 'KW' '1902';\n");
+		grammarBuilder.append("KW1903 : 'KW' '1903';\n");
+		grammarBuilder.append("KW1904 : 'KW' '1904';\n");
+		grammarBuilder.append("KW1905 : 'KW' '1905';\n");
+		grammarBuilder.append("KW1906 : 'KW' '1906';\n");
+		grammarBuilder.append("KW1907 : 'KW' '1907';\n");
+		grammarBuilder.append("KW1908 : 'KW' '1908';\n");
+		grammarBuilder.append("KW1909 : 'KW' '1909';\n");
+		grammarBuilder.append("KW1910 : 'KW' '1910';\n");
+		grammarBuilder.append("KW1911 : 'KW' '1911';\n");
+		grammarBuilder.append("KW1912 : 'KW' '1912';\n");
+		grammarBuilder.append("KW1913 : 'KW' '1913';\n");
+		grammarBuilder.append("KW1914 : 'KW' '1914';\n");
+		grammarBuilder.append("KW1915 : 'KW' '1915';\n");
+		grammarBuilder.append("KW1916 : 'KW' '1916';\n");
+		grammarBuilder.append("KW1917 : 'KW' '1917';\n");
+		grammarBuilder.append("KW1918 : 'KW' '1918';\n");
+		grammarBuilder.append("KW1919 : 'KW' '1919';\n");
+		grammarBuilder.append("KW1920 : 'KW' '1920';\n");
+		grammarBuilder.append("KW1921 : 'KW' '1921';\n");
+		grammarBuilder.append("KW1922 : 'KW' '1922';\n");
+		grammarBuilder.append("KW1923 : 'KW' '1923';\n");
+		grammarBuilder.append("KW1924 : 'KW' '1924';\n");
+		grammarBuilder.append("KW1925 : 'KW' '1925';\n");
+		grammarBuilder.append("KW1926 : 'KW' '1926';\n");
+		grammarBuilder.append("KW1927 : 'KW' '1927';\n");
+		grammarBuilder.append("KW1928 : 'KW' '1928';\n");
+		grammarBuilder.append("KW1929 : 'KW' '1929';\n");
+		grammarBuilder.append("KW1930 : 'KW' '1930';\n");
+		grammarBuilder.append("KW1931 : 'KW' '1931';\n");
+		grammarBuilder.append("KW1932 : 'KW' '1932';\n");
+		grammarBuilder.append("KW1933 : 'KW' '1933';\n");
+		grammarBuilder.append("KW1934 : 'KW' '1934';\n");
+		grammarBuilder.append("KW1935 : 'KW' '1935';\n");
+		grammarBuilder.append("KW1936 : 'KW' '1936';\n");
+		grammarBuilder.append("KW1937 : 'KW' '1937';\n");
+		grammarBuilder.append("KW1938 : 'KW' '1938';\n");
+		grammarBuilder.append("KW1939 : 'KW' '1939';\n");
+		grammarBuilder.append("KW1940 : 'KW' '1940';\n");
+		grammarBuilder.append("KW1941 : 'KW' '1941';\n");
+		grammarBuilder.append("KW1942 : 'KW' '1942';\n");
+		grammarBuilder.append("KW1943 : 'KW' '1943';\n");
+		grammarBuilder.append("KW1944 : 'KW' '1944';\n");
+		grammarBuilder.append("KW1945 : 'KW' '1945';\n");
+		grammarBuilder.append("KW1946 : 'KW' '1946';\n");
+		grammarBuilder.append("KW1947 : 'KW' '1947';\n");
+		grammarBuilder.append("KW1948 : 'KW' '1948';\n");
+		grammarBuilder.append("KW1949 : 'KW' '1949';\n");
+		grammarBuilder.append("KW1950 : 'KW' '1950';\n");
+		grammarBuilder.append("KW1951 : 'KW' '1951';\n");
+		grammarBuilder.append("KW1952 : 'KW' '1952';\n");
+		grammarBuilder.append("KW1953 : 'KW' '1953';\n");
+		grammarBuilder.append("KW1954 : 'KW' '1954';\n");
+		grammarBuilder.append("KW1955 : 'KW' '1955';\n");
+		grammarBuilder.append("KW1956 : 'KW' '1956';\n");
+		grammarBuilder.append("KW1957 : 'KW' '1957';\n");
+		grammarBuilder.append("KW1958 : 'KW' '1958';\n");
+		grammarBuilder.append("KW1959 : 'KW' '1959';\n");
+		grammarBuilder.append("KW1960 : 'KW' '1960';\n");
+		grammarBuilder.append("KW1961 : 'KW' '1961';\n");
+		grammarBuilder.append("KW1962 : 'KW' '1962';\n");
+		grammarBuilder.append("KW1963 : 'KW' '1963';\n");
+		grammarBuilder.append("KW1964 : 'KW' '1964';\n");
+		grammarBuilder.append("KW1965 : 'KW' '1965';\n");
+		grammarBuilder.append("KW1966 : 'KW' '1966';\n");
+		grammarBuilder.append("KW1967 : 'KW' '1967';\n");
+		grammarBuilder.append("KW1968 : 'KW' '1968';\n");
+		grammarBuilder.append("KW1969 : 'KW' '1969';\n");
+		grammarBuilder.append("KW1970 : 'KW' '1970';\n");
+		grammarBuilder.append("KW1971 : 'KW' '1971';\n");
+		grammarBuilder.append("KW1972 : 'KW' '1972';\n");
+		grammarBuilder.append("KW1973 : 'KW' '1973';\n");
+		grammarBuilder.append("KW1974 : 'KW' '1974';\n");
+		grammarBuilder.append("KW1975 : 'KW' '1975';\n");
+		grammarBuilder.append("KW1976 : 'KW' '1976';\n");
+		grammarBuilder.append("KW1977 : 'KW' '1977';\n");
+		grammarBuilder.append("KW1978 : 'KW' '1978';\n");
+		grammarBuilder.append("KW1979 : 'KW' '1979';\n");
+		grammarBuilder.append("KW1980 : 'KW' '1980';\n");
+		grammarBuilder.append("KW1981 : 'KW' '1981';\n");
+		grammarBuilder.append("KW1982 : 'KW' '1982';\n");
+		grammarBuilder.append("KW1983 : 'KW' '1983';\n");
+		grammarBuilder.append("KW1984 : 'KW' '1984';\n");
+		grammarBuilder.append("KW1985 : 'KW' '1985';\n");
+		grammarBuilder.append("KW1986 : 'KW' '1986';\n");
+		grammarBuilder.append("KW1987 : 'KW' '1987';\n");
+		grammarBuilder.append("KW1988 : 'KW' '1988';\n");
+		grammarBuilder.append("KW1989 : 'KW' '1989';\n");
+		grammarBuilder.append("KW1990 : 'KW' '1990';\n");
+		grammarBuilder.append("KW1991 : 'KW' '1991';\n");
+		grammarBuilder.append("KW1992 : 'KW' '1992';\n");
+		grammarBuilder.append("KW1993 : 'KW' '1993';\n");
+		grammarBuilder.append("KW1994 : 'KW' '1994';\n");
+		grammarBuilder.append("KW1995 : 'KW' '1995';\n");
+		grammarBuilder.append("KW1996 : 'KW' '1996';\n");
+		grammarBuilder.append("KW1997 : 'KW' '1997';\n");
+		grammarBuilder.append("KW1998 : 'KW' '1998';\n");
+		grammarBuilder.append("KW1999 : 'KW' '1999';\n");
+		grammarBuilder.append("KW2000 : 'KW' '2000';\n");
+		grammarBuilder.append("KW2001 : 'KW' '2001';\n");
+		grammarBuilder.append("KW2002 : 'KW' '2002';\n");
+		grammarBuilder.append("KW2003 : 'KW' '2003';\n");
+		grammarBuilder.append("KW2004 : 'KW' '2004';\n");
+		grammarBuilder.append("KW2005 : 'KW' '2005';\n");
+		grammarBuilder.append("KW2006 : 'KW' '2006';\n");
+		grammarBuilder.append("KW2007 : 'KW' '2007';\n");
+		grammarBuilder.append("KW2008 : 'KW' '2008';\n");
+		grammarBuilder.append("KW2009 : 'KW' '2009';\n");
+		grammarBuilder.append("KW2010 : 'KW' '2010';\n");
+		grammarBuilder.append("KW2011 : 'KW' '2011';\n");
+		grammarBuilder.append("KW2012 : 'KW' '2012';\n");
+		grammarBuilder.append("KW2013 : 'KW' '2013';\n");
+		grammarBuilder.append("KW2014 : 'KW' '2014';\n");
+		grammarBuilder.append("KW2015 : 'KW' '2015';\n");
+		grammarBuilder.append("KW2016 : 'KW' '2016';\n");
+		grammarBuilder.append("KW2017 : 'KW' '2017';\n");
+		grammarBuilder.append("KW2018 : 'KW' '2018';\n");
+		grammarBuilder.append("KW2019 : 'KW' '2019';\n");
+		grammarBuilder.append("KW2020 : 'KW' '2020';\n");
+		grammarBuilder.append("KW2021 : 'KW' '2021';\n");
+		grammarBuilder.append("KW2022 : 'KW' '2022';\n");
+		grammarBuilder.append("KW2023 : 'KW' '2023';\n");
+		grammarBuilder.append("KW2024 : 'KW' '2024';\n");
+		grammarBuilder.append("KW2025 : 'KW' '2025';\n");
+		grammarBuilder.append("KW2026 : 'KW' '2026';\n");
+		grammarBuilder.append("KW2027 : 'KW' '2027';\n");
+		grammarBuilder.append("KW2028 : 'KW' '2028';\n");
+		grammarBuilder.append("KW2029 : 'KW' '2029';\n");
+		grammarBuilder.append("KW2030 : 'KW' '2030';\n");
+		grammarBuilder.append("KW2031 : 'KW' '2031';\n");
+		grammarBuilder.append("KW2032 : 'KW' '2032';\n");
+		grammarBuilder.append("KW2033 : 'KW' '2033';\n");
+		grammarBuilder.append("KW2034 : 'KW' '2034';\n");
+		grammarBuilder.append("KW2035 : 'KW' '2035';\n");
+		grammarBuilder.append("KW2036 : 'KW' '2036';\n");
+		grammarBuilder.append("KW2037 : 'KW' '2037';\n");
+		grammarBuilder.append("KW2038 : 'KW' '2038';\n");
+		grammarBuilder.append("KW2039 : 'KW' '2039';\n");
+		grammarBuilder.append("KW2040 : 'KW' '2040';\n");
+		grammarBuilder.append("KW2041 : 'KW' '2041';\n");
+		grammarBuilder.append("KW2042 : 'KW' '2042';\n");
+		grammarBuilder.append("KW2043 : 'KW' '2043';\n");
+		grammarBuilder.append("KW2044 : 'KW' '2044';\n");
+		grammarBuilder.append("KW2045 : 'KW' '2045';\n");
+		grammarBuilder.append("KW2046 : 'KW' '2046';\n");
+		grammarBuilder.append("KW2047 : 'KW' '2047';\n");
+		grammarBuilder.append("KW2048 : 'KW' '2048';\n");
+		grammarBuilder.append("KW2049 : 'KW' '2049';\n");
+		grammarBuilder.append("KW2050 : 'KW' '2050';\n");
+		grammarBuilder.append("KW2051 : 'KW' '2051';\n");
+		grammarBuilder.append("KW2052 : 'KW' '2052';\n");
+		grammarBuilder.append("KW2053 : 'KW' '2053';\n");
+		grammarBuilder.append("KW2054 : 'KW' '2054';\n");
+		grammarBuilder.append("KW2055 : 'KW' '2055';\n");
+		grammarBuilder.append("KW2056 : 'KW' '2056';\n");
+		grammarBuilder.append("KW2057 : 'KW' '2057';\n");
+		grammarBuilder.append("KW2058 : 'KW' '2058';\n");
+		grammarBuilder.append("KW2059 : 'KW' '2059';\n");
+		grammarBuilder.append("KW2060 : 'KW' '2060';\n");
+		grammarBuilder.append("KW2061 : 'KW' '2061';\n");
+		grammarBuilder.append("KW2062 : 'KW' '2062';\n");
+		grammarBuilder.append("KW2063 : 'KW' '2063';\n");
+		grammarBuilder.append("KW2064 : 'KW' '2064';\n");
+		grammarBuilder.append("KW2065 : 'KW' '2065';\n");
+		grammarBuilder.append("KW2066 : 'KW' '2066';\n");
+		grammarBuilder.append("KW2067 : 'KW' '2067';\n");
+		grammarBuilder.append("KW2068 : 'KW' '2068';\n");
+		grammarBuilder.append("KW2069 : 'KW' '2069';\n");
+		grammarBuilder.append("KW2070 : 'KW' '2070';\n");
+		grammarBuilder.append("KW2071 : 'KW' '2071';\n");
+		grammarBuilder.append("KW2072 : 'KW' '2072';\n");
+		grammarBuilder.append("KW2073 : 'KW' '2073';\n");
+		grammarBuilder.append("KW2074 : 'KW' '2074';\n");
+		grammarBuilder.append("KW2075 : 'KW' '2075';\n");
+		grammarBuilder.append("KW2076 : 'KW' '2076';\n");
+		grammarBuilder.append("KW2077 : 'KW' '2077';\n");
+		grammarBuilder.append("KW2078 : 'KW' '2078';\n");
+		grammarBuilder.append("KW2079 : 'KW' '2079';\n");
+		grammarBuilder.append("KW2080 : 'KW' '2080';\n");
+		grammarBuilder.append("KW2081 : 'KW' '2081';\n");
+		grammarBuilder.append("KW2082 : 'KW' '2082';\n");
+		grammarBuilder.append("KW2083 : 'KW' '2083';\n");
+		grammarBuilder.append("KW2084 : 'KW' '2084';\n");
+		grammarBuilder.append("KW2085 : 'KW' '2085';\n");
+		grammarBuilder.append("KW2086 : 'KW' '2086';\n");
+		grammarBuilder.append("KW2087 : 'KW' '2087';\n");
+		grammarBuilder.append("KW2088 : 'KW' '2088';\n");
+		grammarBuilder.append("KW2089 : 'KW' '2089';\n");
+		grammarBuilder.append("KW2090 : 'KW' '2090';\n");
+		grammarBuilder.append("KW2091 : 'KW' '2091';\n");
+		grammarBuilder.append("KW2092 : 'KW' '2092';\n");
+		grammarBuilder.append("KW2093 : 'KW' '2093';\n");
+		grammarBuilder.append("KW2094 : 'KW' '2094';\n");
+		grammarBuilder.append("KW2095 : 'KW' '2095';\n");
+		grammarBuilder.append("KW2096 : 'KW' '2096';\n");
+		grammarBuilder.append("KW2097 : 'KW' '2097';\n");
+		grammarBuilder.append("KW2098 : 'KW' '2098';\n");
+		grammarBuilder.append("KW2099 : 'KW' '2099';\n");
+		grammarBuilder.append("KW2100 : 'KW' '2100';\n");
+		grammarBuilder.append("KW2101 : 'KW' '2101';\n");
+		grammarBuilder.append("KW2102 : 'KW' '2102';\n");
+		grammarBuilder.append("KW2103 : 'KW' '2103';\n");
+		grammarBuilder.append("KW2104 : 'KW' '2104';\n");
+		grammarBuilder.append("KW2105 : 'KW' '2105';\n");
+		grammarBuilder.append("KW2106 : 'KW' '2106';\n");
+		grammarBuilder.append("KW2107 : 'KW' '2107';\n");
+		grammarBuilder.append("KW2108 : 'KW' '2108';\n");
+		grammarBuilder.append("KW2109 : 'KW' '2109';\n");
+		grammarBuilder.append("KW2110 : 'KW' '2110';\n");
+		grammarBuilder.append("KW2111 : 'KW' '2111';\n");
+		grammarBuilder.append("KW2112 : 'KW' '2112';\n");
+		grammarBuilder.append("KW2113 : 'KW' '2113';\n");
+		grammarBuilder.append("KW2114 : 'KW' '2114';\n");
+		grammarBuilder.append("KW2115 : 'KW' '2115';\n");
+		grammarBuilder.append("KW2116 : 'KW' '2116';\n");
+		grammarBuilder.append("KW2117 : 'KW' '2117';\n");
+		grammarBuilder.append("KW2118 : 'KW' '2118';\n");
+		grammarBuilder.append("KW2119 : 'KW' '2119';\n");
+		grammarBuilder.append("KW2120 : 'KW' '2120';\n");
+		grammarBuilder.append("KW2121 : 'KW' '2121';\n");
+		grammarBuilder.append("KW2122 : 'KW' '2122';\n");
+		grammarBuilder.append("KW2123 : 'KW' '2123';\n");
+		grammarBuilder.append("KW2124 : 'KW' '2124';\n");
+		grammarBuilder.append("KW2125 : 'KW' '2125';\n");
+		grammarBuilder.append("KW2126 : 'KW' '2126';\n");
+		grammarBuilder.append("KW2127 : 'KW' '2127';\n");
+		grammarBuilder.append("KW2128 : 'KW' '2128';\n");
+		grammarBuilder.append("KW2129 : 'KW' '2129';\n");
+		grammarBuilder.append("KW2130 : 'KW' '2130';\n");
+		grammarBuilder.append("KW2131 : 'KW' '2131';\n");
+		grammarBuilder.append("KW2132 : 'KW' '2132';\n");
+		grammarBuilder.append("KW2133 : 'KW' '2133';\n");
+		grammarBuilder.append("KW2134 : 'KW' '2134';\n");
+		grammarBuilder.append("KW2135 : 'KW' '2135';\n");
+		grammarBuilder.append("KW2136 : 'KW' '2136';\n");
+		grammarBuilder.append("KW2137 : 'KW' '2137';\n");
+		grammarBuilder.append("KW2138 : 'KW' '2138';\n");
+		grammarBuilder.append("KW2139 : 'KW' '2139';\n");
+		grammarBuilder.append("KW2140 : 'KW' '2140';\n");
+		grammarBuilder.append("KW2141 : 'KW' '2141';\n");
+		grammarBuilder.append("KW2142 : 'KW' '2142';\n");
+		grammarBuilder.append("KW2143 : 'KW' '2143';\n");
+		grammarBuilder.append("KW2144 : 'KW' '2144';\n");
+		grammarBuilder.append("KW2145 : 'KW' '2145';\n");
+		grammarBuilder.append("KW2146 : 'KW' '2146';\n");
+		grammarBuilder.append("KW2147 : 'KW' '2147';\n");
+		grammarBuilder.append("KW2148 : 'KW' '2148';\n");
+		grammarBuilder.append("KW2149 : 'KW' '2149';\n");
+		grammarBuilder.append("KW2150 : 'KW' '2150';\n");
+		grammarBuilder.append("KW2151 : 'KW' '2151';\n");
+		grammarBuilder.append("KW2152 : 'KW' '2152';\n");
+		grammarBuilder.append("KW2153 : 'KW' '2153';\n");
+		grammarBuilder.append("KW2154 : 'KW' '2154';\n");
+		grammarBuilder.append("KW2155 : 'KW' '2155';\n");
+		grammarBuilder.append("KW2156 : 'KW' '2156';\n");
+		grammarBuilder.append("KW2157 : 'KW' '2157';\n");
+		grammarBuilder.append("KW2158 : 'KW' '2158';\n");
+		grammarBuilder.append("KW2159 : 'KW' '2159';\n");
+		grammarBuilder.append("KW2160 : 'KW' '2160';\n");
+		grammarBuilder.append("KW2161 : 'KW' '2161';\n");
+		grammarBuilder.append("KW2162 : 'KW' '2162';\n");
+		grammarBuilder.append("KW2163 : 'KW' '2163';\n");
+		grammarBuilder.append("KW2164 : 'KW' '2164';\n");
+		grammarBuilder.append("KW2165 : 'KW' '2165';\n");
+		grammarBuilder.append("KW2166 : 'KW' '2166';\n");
+		grammarBuilder.append("KW2167 : 'KW' '2167';\n");
+		grammarBuilder.append("KW2168 : 'KW' '2168';\n");
+		grammarBuilder.append("KW2169 : 'KW' '2169';\n");
+		grammarBuilder.append("KW2170 : 'KW' '2170';\n");
+		grammarBuilder.append("KW2171 : 'KW' '2171';\n");
+		grammarBuilder.append("KW2172 : 'KW' '2172';\n");
+		grammarBuilder.append("KW2173 : 'KW' '2173';\n");
+		grammarBuilder.append("KW2174 : 'KW' '2174';\n");
+		grammarBuilder.append("KW2175 : 'KW' '2175';\n");
+		grammarBuilder.append("KW2176 : 'KW' '2176';\n");
+		grammarBuilder.append("KW2177 : 'KW' '2177';\n");
+		grammarBuilder.append("KW2178 : 'KW' '2178';\n");
+		grammarBuilder.append("KW2179 : 'KW' '2179';\n");
+		grammarBuilder.append("KW2180 : 'KW' '2180';\n");
+		grammarBuilder.append("KW2181 : 'KW' '2181';\n");
+		grammarBuilder.append("KW2182 : 'KW' '2182';\n");
+		grammarBuilder.append("KW2183 : 'KW' '2183';\n");
+		grammarBuilder.append("KW2184 : 'KW' '2184';\n");
+		grammarBuilder.append("KW2185 : 'KW' '2185';\n");
+		grammarBuilder.append("KW2186 : 'KW' '2186';\n");
+		grammarBuilder.append("KW2187 : 'KW' '2187';\n");
+		grammarBuilder.append("KW2188 : 'KW' '2188';\n");
+		grammarBuilder.append("KW2189 : 'KW' '2189';\n");
+		grammarBuilder.append("KW2190 : 'KW' '2190';\n");
+		grammarBuilder.append("KW2191 : 'KW' '2191';\n");
+		grammarBuilder.append("KW2192 : 'KW' '2192';\n");
+		grammarBuilder.append("KW2193 : 'KW' '2193';\n");
+		grammarBuilder.append("KW2194 : 'KW' '2194';\n");
+		grammarBuilder.append("KW2195 : 'KW' '2195';\n");
+		grammarBuilder.append("KW2196 : 'KW' '2196';\n");
+		grammarBuilder.append("KW2197 : 'KW' '2197';\n");
+		grammarBuilder.append("KW2198 : 'KW' '2198';\n");
+		grammarBuilder.append("KW2199 : 'KW' '2199';\n");
+		grammarBuilder.append("KW2200 : 'KW' '2200';\n");
+		grammarBuilder.append("KW2201 : 'KW' '2201';\n");
+		grammarBuilder.append("KW2202 : 'KW' '2202';\n");
+		grammarBuilder.append("KW2203 : 'KW' '2203';\n");
+		grammarBuilder.append("KW2204 : 'KW' '2204';\n");
+		grammarBuilder.append("KW2205 : 'KW' '2205';\n");
+		grammarBuilder.append("KW2206 : 'KW' '2206';\n");
+		grammarBuilder.append("KW2207 : 'KW' '2207';\n");
+		grammarBuilder.append("KW2208 : 'KW' '2208';\n");
+		grammarBuilder.append("KW2209 : 'KW' '2209';\n");
+		grammarBuilder.append("KW2210 : 'KW' '2210';\n");
+		grammarBuilder.append("KW2211 : 'KW' '2211';\n");
+		grammarBuilder.append("KW2212 : 'KW' '2212';\n");
+		grammarBuilder.append("KW2213 : 'KW' '2213';\n");
+		grammarBuilder.append("KW2214 : 'KW' '2214';\n");
+		grammarBuilder.append("KW2215 : 'KW' '2215';\n");
+		grammarBuilder.append("KW2216 : 'KW' '2216';\n");
+		grammarBuilder.append("KW2217 : 'KW' '2217';\n");
+		grammarBuilder.append("KW2218 : 'KW' '2218';\n");
+		grammarBuilder.append("KW2219 : 'KW' '2219';\n");
+		grammarBuilder.append("KW2220 : 'KW' '2220';\n");
+		grammarBuilder.append("KW2221 : 'KW' '2221';\n");
+		grammarBuilder.append("KW2222 : 'KW' '2222';\n");
+		grammarBuilder.append("KW2223 : 'KW' '2223';\n");
+		grammarBuilder.append("KW2224 : 'KW' '2224';\n");
+		grammarBuilder.append("KW2225 : 'KW' '2225';\n");
+		grammarBuilder.append("KW2226 : 'KW' '2226';\n");
+		grammarBuilder.append("KW2227 : 'KW' '2227';\n");
+		grammarBuilder.append("KW2228 : 'KW' '2228';\n");
+		grammarBuilder.append("KW2229 : 'KW' '2229';\n");
+		grammarBuilder.append("KW2230 : 'KW' '2230';\n");
+		grammarBuilder.append("KW2231 : 'KW' '2231';\n");
+		grammarBuilder.append("KW2232 : 'KW' '2232';\n");
+		grammarBuilder.append("KW2233 : 'KW' '2233';\n");
+		grammarBuilder.append("KW2234 : 'KW' '2234';\n");
+		grammarBuilder.append("KW2235 : 'KW' '2235';\n");
+		grammarBuilder.append("KW2236 : 'KW' '2236';\n");
+		grammarBuilder.append("KW2237 : 'KW' '2237';\n");
+		grammarBuilder.append("KW2238 : 'KW' '2238';\n");
+		grammarBuilder.append("KW2239 : 'KW' '2239';\n");
+		grammarBuilder.append("KW2240 : 'KW' '2240';\n");
+		grammarBuilder.append("KW2241 : 'KW' '2241';\n");
+		grammarBuilder.append("KW2242 : 'KW' '2242';\n");
+		grammarBuilder.append("KW2243 : 'KW' '2243';\n");
+		grammarBuilder.append("KW2244 : 'KW' '2244';\n");
+		grammarBuilder.append("KW2245 : 'KW' '2245';\n");
+		grammarBuilder.append("KW2246 : 'KW' '2246';\n");
+		grammarBuilder.append("KW2247 : 'KW' '2247';\n");
+		grammarBuilder.append("KW2248 : 'KW' '2248';\n");
+		grammarBuilder.append("KW2249 : 'KW' '2249';\n");
+		grammarBuilder.append("KW2250 : 'KW' '2250';\n");
+		grammarBuilder.append("KW2251 : 'KW' '2251';\n");
+		grammarBuilder.append("KW2252 : 'KW' '2252';\n");
+		grammarBuilder.append("KW2253 : 'KW' '2253';\n");
+		grammarBuilder.append("KW2254 : 'KW' '2254';\n");
+		grammarBuilder.append("KW2255 : 'KW' '2255';\n");
+		grammarBuilder.append("KW2256 : 'KW' '2256';\n");
+		grammarBuilder.append("KW2257 : 'KW' '2257';\n");
+		grammarBuilder.append("KW2258 : 'KW' '2258';\n");
+		grammarBuilder.append("KW2259 : 'KW' '2259';\n");
+		grammarBuilder.append("KW2260 : 'KW' '2260';\n");
+		grammarBuilder.append("KW2261 : 'KW' '2261';\n");
+		grammarBuilder.append("KW2262 : 'KW' '2262';\n");
+		grammarBuilder.append("KW2263 : 'KW' '2263';\n");
+		grammarBuilder.append("KW2264 : 'KW' '2264';\n");
+		grammarBuilder.append("KW2265 : 'KW' '2265';\n");
+		grammarBuilder.append("KW2266 : 'KW' '2266';\n");
+		grammarBuilder.append("KW2267 : 'KW' '2267';\n");
+		grammarBuilder.append("KW2268 : 'KW' '2268';\n");
+		grammarBuilder.append("KW2269 : 'KW' '2269';\n");
+		grammarBuilder.append("KW2270 : 'KW' '2270';\n");
+		grammarBuilder.append("KW2271 : 'KW' '2271';\n");
+		grammarBuilder.append("KW2272 : 'KW' '2272';\n");
+		grammarBuilder.append("KW2273 : 'KW' '2273';\n");
+		grammarBuilder.append("KW2274 : 'KW' '2274';\n");
+		grammarBuilder.append("KW2275 : 'KW' '2275';\n");
+		grammarBuilder.append("KW2276 : 'KW' '2276';\n");
+		grammarBuilder.append("KW2277 : 'KW' '2277';\n");
+		grammarBuilder.append("KW2278 : 'KW' '2278';\n");
+		grammarBuilder.append("KW2279 : 'KW' '2279';\n");
+		grammarBuilder.append("KW2280 : 'KW' '2280';\n");
+		grammarBuilder.append("KW2281 : 'KW' '2281';\n");
+		grammarBuilder.append("KW2282 : 'KW' '2282';\n");
+		grammarBuilder.append("KW2283 : 'KW' '2283';\n");
+		grammarBuilder.append("KW2284 : 'KW' '2284';\n");
+		grammarBuilder.append("KW2285 : 'KW' '2285';\n");
+		grammarBuilder.append("KW2286 : 'KW' '2286';\n");
+		grammarBuilder.append("KW2287 : 'KW' '2287';\n");
+		grammarBuilder.append("KW2288 : 'KW' '2288';\n");
+		grammarBuilder.append("KW2289 : 'KW' '2289';\n");
+		grammarBuilder.append("KW2290 : 'KW' '2290';\n");
+		grammarBuilder.append("KW2291 : 'KW' '2291';\n");
+		grammarBuilder.append("KW2292 : 'KW' '2292';\n");
+		grammarBuilder.append("KW2293 : 'KW' '2293';\n");
+		grammarBuilder.append("KW2294 : 'KW' '2294';\n");
+		grammarBuilder.append("KW2295 : 'KW' '2295';\n");
+		grammarBuilder.append("KW2296 : 'KW' '2296';\n");
+		grammarBuilder.append("KW2297 : 'KW' '2297';\n");
+		grammarBuilder.append("KW2298 : 'KW' '2298';\n");
+		grammarBuilder.append("KW2299 : 'KW' '2299';\n");
+		grammarBuilder.append("KW2300 : 'KW' '2300';\n");
+		grammarBuilder.append("KW2301 : 'KW' '2301';\n");
+		grammarBuilder.append("KW2302 : 'KW' '2302';\n");
+		grammarBuilder.append("KW2303 : 'KW' '2303';\n");
+		grammarBuilder.append("KW2304 : 'KW' '2304';\n");
+		grammarBuilder.append("KW2305 : 'KW' '2305';\n");
+		grammarBuilder.append("KW2306 : 'KW' '2306';\n");
+		grammarBuilder.append("KW2307 : 'KW' '2307';\n");
+		grammarBuilder.append("KW2308 : 'KW' '2308';\n");
+		grammarBuilder.append("KW2309 : 'KW' '2309';\n");
+		grammarBuilder.append("KW2310 : 'KW' '2310';\n");
+		grammarBuilder.append("KW2311 : 'KW' '2311';\n");
+		grammarBuilder.append("KW2312 : 'KW' '2312';\n");
+		grammarBuilder.append("KW2313 : 'KW' '2313';\n");
+		grammarBuilder.append("KW2314 : 'KW' '2314';\n");
+		grammarBuilder.append("KW2315 : 'KW' '2315';\n");
+		grammarBuilder.append("KW2316 : 'KW' '2316';\n");
+		grammarBuilder.append("KW2317 : 'KW' '2317';\n");
+		grammarBuilder.append("KW2318 : 'KW' '2318';\n");
+		grammarBuilder.append("KW2319 : 'KW' '2319';\n");
+		grammarBuilder.append("KW2320 : 'KW' '2320';\n");
+		grammarBuilder.append("KW2321 : 'KW' '2321';\n");
+		grammarBuilder.append("KW2322 : 'KW' '2322';\n");
+		grammarBuilder.append("KW2323 : 'KW' '2323';\n");
+		grammarBuilder.append("KW2324 : 'KW' '2324';\n");
+		grammarBuilder.append("KW2325 : 'KW' '2325';\n");
+		grammarBuilder.append("KW2326 : 'KW' '2326';\n");
+		grammarBuilder.append("KW2327 : 'KW' '2327';\n");
+		grammarBuilder.append("KW2328 : 'KW' '2328';\n");
+		grammarBuilder.append("KW2329 : 'KW' '2329';\n");
+		grammarBuilder.append("KW2330 : 'KW' '2330';\n");
+		grammarBuilder.append("KW2331 : 'KW' '2331';\n");
+		grammarBuilder.append("KW2332 : 'KW' '2332';\n");
+		grammarBuilder.append("KW2333 : 'KW' '2333';\n");
+		grammarBuilder.append("KW2334 : 'KW' '2334';\n");
+		grammarBuilder.append("KW2335 : 'KW' '2335';\n");
+		grammarBuilder.append("KW2336 : 'KW' '2336';\n");
+		grammarBuilder.append("KW2337 : 'KW' '2337';\n");
+		grammarBuilder.append("KW2338 : 'KW' '2338';\n");
+		grammarBuilder.append("KW2339 : 'KW' '2339';\n");
+		grammarBuilder.append("KW2340 : 'KW' '2340';\n");
+		grammarBuilder.append("KW2341 : 'KW' '2341';\n");
+		grammarBuilder.append("KW2342 : 'KW' '2342';\n");
+		grammarBuilder.append("KW2343 : 'KW' '2343';\n");
+		grammarBuilder.append("KW2344 : 'KW' '2344';\n");
+		grammarBuilder.append("KW2345 : 'KW' '2345';\n");
+		grammarBuilder.append("KW2346 : 'KW' '2346';\n");
+		grammarBuilder.append("KW2347 : 'KW' '2347';\n");
+		grammarBuilder.append("KW2348 : 'KW' '2348';\n");
+		grammarBuilder.append("KW2349 : 'KW' '2349';\n");
+		grammarBuilder.append("KW2350 : 'KW' '2350';\n");
+		grammarBuilder.append("KW2351 : 'KW' '2351';\n");
+		grammarBuilder.append("KW2352 : 'KW' '2352';\n");
+		grammarBuilder.append("KW2353 : 'KW' '2353';\n");
+		grammarBuilder.append("KW2354 : 'KW' '2354';\n");
+		grammarBuilder.append("KW2355 : 'KW' '2355';\n");
+		grammarBuilder.append("KW2356 : 'KW' '2356';\n");
+		grammarBuilder.append("KW2357 : 'KW' '2357';\n");
+		grammarBuilder.append("KW2358 : 'KW' '2358';\n");
+		grammarBuilder.append("KW2359 : 'KW' '2359';\n");
+		grammarBuilder.append("KW2360 : 'KW' '2360';\n");
+		grammarBuilder.append("KW2361 : 'KW' '2361';\n");
+		grammarBuilder.append("KW2362 : 'KW' '2362';\n");
+		grammarBuilder.append("KW2363 : 'KW' '2363';\n");
+		grammarBuilder.append("KW2364 : 'KW' '2364';\n");
+		grammarBuilder.append("KW2365 : 'KW' '2365';\n");
+		grammarBuilder.append("KW2366 : 'KW' '2366';\n");
+		grammarBuilder.append("KW2367 : 'KW' '2367';\n");
+		grammarBuilder.append("KW2368 : 'KW' '2368';\n");
+		grammarBuilder.append("KW2369 : 'KW' '2369';\n");
+		grammarBuilder.append("KW2370 : 'KW' '2370';\n");
+		grammarBuilder.append("KW2371 : 'KW' '2371';\n");
+		grammarBuilder.append("KW2372 : 'KW' '2372';\n");
+		grammarBuilder.append("KW2373 : 'KW' '2373';\n");
+		grammarBuilder.append("KW2374 : 'KW' '2374';\n");
+		grammarBuilder.append("KW2375 : 'KW' '2375';\n");
+		grammarBuilder.append("KW2376 : 'KW' '2376';\n");
+		grammarBuilder.append("KW2377 : 'KW' '2377';\n");
+		grammarBuilder.append("KW2378 : 'KW' '2378';\n");
+		grammarBuilder.append("KW2379 : 'KW' '2379';\n");
+		grammarBuilder.append("KW2380 : 'KW' '2380';\n");
+		grammarBuilder.append("KW2381 : 'KW' '2381';\n");
+		grammarBuilder.append("KW2382 : 'KW' '2382';\n");
+		grammarBuilder.append("KW2383 : 'KW' '2383';\n");
+		grammarBuilder.append("KW2384 : 'KW' '2384';\n");
+		grammarBuilder.append("KW2385 : 'KW' '2385';\n");
+		grammarBuilder.append("KW2386 : 'KW' '2386';\n");
+		grammarBuilder.append("KW2387 : 'KW' '2387';\n");
+		grammarBuilder.append("KW2388 : 'KW' '2388';\n");
+		grammarBuilder.append("KW2389 : 'KW' '2389';\n");
+		grammarBuilder.append("KW2390 : 'KW' '2390';\n");
+		grammarBuilder.append("KW2391 : 'KW' '2391';\n");
+		grammarBuilder.append("KW2392 : 'KW' '2392';\n");
+		grammarBuilder.append("KW2393 : 'KW' '2393';\n");
+		grammarBuilder.append("KW2394 : 'KW' '2394';\n");
+		grammarBuilder.append("KW2395 : 'KW' '2395';\n");
+		grammarBuilder.append("KW2396 : 'KW' '2396';\n");
+		grammarBuilder.append("KW2397 : 'KW' '2397';\n");
+		grammarBuilder.append("KW2398 : 'KW' '2398';\n");
+		grammarBuilder.append("KW2399 : 'KW' '2399';\n");
+		grammarBuilder.append("KW2400 : 'KW' '2400';\n");
+		grammarBuilder.append("KW2401 : 'KW' '2401';\n");
+		grammarBuilder.append("KW2402 : 'KW' '2402';\n");
+		grammarBuilder.append("KW2403 : 'KW' '2403';\n");
+		grammarBuilder.append("KW2404 : 'KW' '2404';\n");
+		grammarBuilder.append("KW2405 : 'KW' '2405';\n");
+		grammarBuilder.append("KW2406 : 'KW' '2406';\n");
+		grammarBuilder.append("KW2407 : 'KW' '2407';\n");
+		grammarBuilder.append("KW2408 : 'KW' '2408';\n");
+		grammarBuilder.append("KW2409 : 'KW' '2409';\n");
+		grammarBuilder.append("KW2410 : 'KW' '2410';\n");
+		grammarBuilder.append("KW2411 : 'KW' '2411';\n");
+		grammarBuilder.append("KW2412 : 'KW' '2412';\n");
+		grammarBuilder.append("KW2413 : 'KW' '2413';\n");
+		grammarBuilder.append("KW2414 : 'KW' '2414';\n");
+		grammarBuilder.append("KW2415 : 'KW' '2415';\n");
+		grammarBuilder.append("KW2416 : 'KW' '2416';\n");
+		grammarBuilder.append("KW2417 : 'KW' '2417';\n");
+		grammarBuilder.append("KW2418 : 'KW' '2418';\n");
+		grammarBuilder.append("KW2419 : 'KW' '2419';\n");
+		grammarBuilder.append("KW2420 : 'KW' '2420';\n");
+		grammarBuilder.append("KW2421 : 'KW' '2421';\n");
+		grammarBuilder.append("KW2422 : 'KW' '2422';\n");
+		grammarBuilder.append("KW2423 : 'KW' '2423';\n");
+		grammarBuilder.append("KW2424 : 'KW' '2424';\n");
+		grammarBuilder.append("KW2425 : 'KW' '2425';\n");
+		grammarBuilder.append("KW2426 : 'KW' '2426';\n");
+		grammarBuilder.append("KW2427 : 'KW' '2427';\n");
+		grammarBuilder.append("KW2428 : 'KW' '2428';\n");
+		grammarBuilder.append("KW2429 : 'KW' '2429';\n");
+		grammarBuilder.append("KW2430 : 'KW' '2430';\n");
+		grammarBuilder.append("KW2431 : 'KW' '2431';\n");
+		grammarBuilder.append("KW2432 : 'KW' '2432';\n");
+		grammarBuilder.append("KW2433 : 'KW' '2433';\n");
+		grammarBuilder.append("KW2434 : 'KW' '2434';\n");
+		grammarBuilder.append("KW2435 : 'KW' '2435';\n");
+		grammarBuilder.append("KW2436 : 'KW' '2436';\n");
+		grammarBuilder.append("KW2437 : 'KW' '2437';\n");
+		grammarBuilder.append("KW2438 : 'KW' '2438';\n");
+		grammarBuilder.append("KW2439 : 'KW' '2439';\n");
+		grammarBuilder.append("KW2440 : 'KW' '2440';\n");
+		grammarBuilder.append("KW2441 : 'KW' '2441';\n");
+		grammarBuilder.append("KW2442 : 'KW' '2442';\n");
+		grammarBuilder.append("KW2443 : 'KW' '2443';\n");
+		grammarBuilder.append("KW2444 : 'KW' '2444';\n");
+		grammarBuilder.append("KW2445 : 'KW' '2445';\n");
+		grammarBuilder.append("KW2446 : 'KW' '2446';\n");
+		grammarBuilder.append("KW2447 : 'KW' '2447';\n");
+		grammarBuilder.append("KW2448 : 'KW' '2448';\n");
+		grammarBuilder.append("KW2449 : 'KW' '2449';\n");
+		grammarBuilder.append("KW2450 : 'KW' '2450';\n");
+		grammarBuilder.append("KW2451 : 'KW' '2451';\n");
+		grammarBuilder.append("KW2452 : 'KW' '2452';\n");
+		grammarBuilder.append("KW2453 : 'KW' '2453';\n");
+		grammarBuilder.append("KW2454 : 'KW' '2454';\n");
+		grammarBuilder.append("KW2455 : 'KW' '2455';\n");
+		grammarBuilder.append("KW2456 : 'KW' '2456';\n");
+		grammarBuilder.append("KW2457 : 'KW' '2457';\n");
+		grammarBuilder.append("KW2458 : 'KW' '2458';\n");
+		grammarBuilder.append("KW2459 : 'KW' '2459';\n");
+		grammarBuilder.append("KW2460 : 'KW' '2460';\n");
+		grammarBuilder.append("KW2461 : 'KW' '2461';\n");
+		grammarBuilder.append("KW2462 : 'KW' '2462';\n");
+		grammarBuilder.append("KW2463 : 'KW' '2463';\n");
+		grammarBuilder.append("KW2464 : 'KW' '2464';\n");
+		grammarBuilder.append("KW2465 : 'KW' '2465';\n");
+		grammarBuilder.append("KW2466 : 'KW' '2466';\n");
+		grammarBuilder.append("KW2467 : 'KW' '2467';\n");
+		grammarBuilder.append("KW2468 : 'KW' '2468';\n");
+		grammarBuilder.append("KW2469 : 'KW' '2469';\n");
+		grammarBuilder.append("KW2470 : 'KW' '2470';\n");
+		grammarBuilder.append("KW2471 : 'KW' '2471';\n");
+		grammarBuilder.append("KW2472 : 'KW' '2472';\n");
+		grammarBuilder.append("KW2473 : 'KW' '2473';\n");
+		grammarBuilder.append("KW2474 : 'KW' '2474';\n");
+		grammarBuilder.append("KW2475 : 'KW' '2475';\n");
+		grammarBuilder.append("KW2476 : 'KW' '2476';\n");
+		grammarBuilder.append("KW2477 : 'KW' '2477';\n");
+		grammarBuilder.append("KW2478 : 'KW' '2478';\n");
+		grammarBuilder.append("KW2479 : 'KW' '2479';\n");
+		grammarBuilder.append("KW2480 : 'KW' '2480';\n");
+		grammarBuilder.append("KW2481 : 'KW' '2481';\n");
+		grammarBuilder.append("KW2482 : 'KW' '2482';\n");
+		grammarBuilder.append("KW2483 : 'KW' '2483';\n");
+		grammarBuilder.append("KW2484 : 'KW' '2484';\n");
+		grammarBuilder.append("KW2485 : 'KW' '2485';\n");
+		grammarBuilder.append("KW2486 : 'KW' '2486';\n");
+		grammarBuilder.append("KW2487 : 'KW' '2487';\n");
+		grammarBuilder.append("KW2488 : 'KW' '2488';\n");
+		grammarBuilder.append("KW2489 : 'KW' '2489';\n");
+		grammarBuilder.append("KW2490 : 'KW' '2490';\n");
+		grammarBuilder.append("KW2491 : 'KW' '2491';\n");
+		grammarBuilder.append("KW2492 : 'KW' '2492';\n");
+		grammarBuilder.append("KW2493 : 'KW' '2493';\n");
+		grammarBuilder.append("KW2494 : 'KW' '2494';\n");
+		grammarBuilder.append("KW2495 : 'KW' '2495';\n");
+		grammarBuilder.append("KW2496 : 'KW' '2496';\n");
+		grammarBuilder.append("KW2497 : 'KW' '2497';\n");
+		grammarBuilder.append("KW2498 : 'KW' '2498';\n");
+		grammarBuilder.append("KW2499 : 'KW' '2499';\n");
+		grammarBuilder.append("KW2500 : 'KW' '2500';\n");
+		grammarBuilder.append("KW2501 : 'KW' '2501';\n");
+		grammarBuilder.append("KW2502 : 'KW' '2502';\n");
+		grammarBuilder.append("KW2503 : 'KW' '2503';\n");
+		grammarBuilder.append("KW2504 : 'KW' '2504';\n");
+		grammarBuilder.append("KW2505 : 'KW' '2505';\n");
+		grammarBuilder.append("KW2506 : 'KW' '2506';\n");
+		grammarBuilder.append("KW2507 : 'KW' '2507';\n");
+		grammarBuilder.append("KW2508 : 'KW' '2508';\n");
+		grammarBuilder.append("KW2509 : 'KW' '2509';\n");
+		grammarBuilder.append("KW2510 : 'KW' '2510';\n");
+		grammarBuilder.append("KW2511 : 'KW' '2511';\n");
+		grammarBuilder.append("KW2512 : 'KW' '2512';\n");
+		grammarBuilder.append("KW2513 : 'KW' '2513';\n");
+		grammarBuilder.append("KW2514 : 'KW' '2514';\n");
+		grammarBuilder.append("KW2515 : 'KW' '2515';\n");
+		grammarBuilder.append("KW2516 : 'KW' '2516';\n");
+		grammarBuilder.append("KW2517 : 'KW' '2517';\n");
+		grammarBuilder.append("KW2518 : 'KW' '2518';\n");
+		grammarBuilder.append("KW2519 : 'KW' '2519';\n");
+		grammarBuilder.append("KW2520 : 'KW' '2520';\n");
+		grammarBuilder.append("KW2521 : 'KW' '2521';\n");
+		grammarBuilder.append("KW2522 : 'KW' '2522';\n");
+		grammarBuilder.append("KW2523 : 'KW' '2523';\n");
+		grammarBuilder.append("KW2524 : 'KW' '2524';\n");
+		grammarBuilder.append("KW2525 : 'KW' '2525';\n");
+		grammarBuilder.append("KW2526 : 'KW' '2526';\n");
+		grammarBuilder.append("KW2527 : 'KW' '2527';\n");
+		grammarBuilder.append("KW2528 : 'KW' '2528';\n");
+		grammarBuilder.append("KW2529 : 'KW' '2529';\n");
+		grammarBuilder.append("KW2530 : 'KW' '2530';\n");
+		grammarBuilder.append("KW2531 : 'KW' '2531';\n");
+		grammarBuilder.append("KW2532 : 'KW' '2532';\n");
+		grammarBuilder.append("KW2533 : 'KW' '2533';\n");
+		grammarBuilder.append("KW2534 : 'KW' '2534';\n");
+		grammarBuilder.append("KW2535 : 'KW' '2535';\n");
+		grammarBuilder.append("KW2536 : 'KW' '2536';\n");
+		grammarBuilder.append("KW2537 : 'KW' '2537';\n");
+		grammarBuilder.append("KW2538 : 'KW' '2538';\n");
+		grammarBuilder.append("KW2539 : 'KW' '2539';\n");
+		grammarBuilder.append("KW2540 : 'KW' '2540';\n");
+		grammarBuilder.append("KW2541 : 'KW' '2541';\n");
+		grammarBuilder.append("KW2542 : 'KW' '2542';\n");
+		grammarBuilder.append("KW2543 : 'KW' '2543';\n");
+		grammarBuilder.append("KW2544 : 'KW' '2544';\n");
+		grammarBuilder.append("KW2545 : 'KW' '2545';\n");
+		grammarBuilder.append("KW2546 : 'KW' '2546';\n");
+		grammarBuilder.append("KW2547 : 'KW' '2547';\n");
+		grammarBuilder.append("KW2548 : 'KW' '2548';\n");
+		grammarBuilder.append("KW2549 : 'KW' '2549';\n");
+		grammarBuilder.append("KW2550 : 'KW' '2550';\n");
+		grammarBuilder.append("KW2551 : 'KW' '2551';\n");
+		grammarBuilder.append("KW2552 : 'KW' '2552';\n");
+		grammarBuilder.append("KW2553 : 'KW' '2553';\n");
+		grammarBuilder.append("KW2554 : 'KW' '2554';\n");
+		grammarBuilder.append("KW2555 : 'KW' '2555';\n");
+		grammarBuilder.append("KW2556 : 'KW' '2556';\n");
+		grammarBuilder.append("KW2557 : 'KW' '2557';\n");
+		grammarBuilder.append("KW2558 : 'KW' '2558';\n");
+		grammarBuilder.append("KW2559 : 'KW' '2559';\n");
+		grammarBuilder.append("KW2560 : 'KW' '2560';\n");
+		grammarBuilder.append("KW2561 : 'KW' '2561';\n");
+		grammarBuilder.append("KW2562 : 'KW' '2562';\n");
+		grammarBuilder.append("KW2563 : 'KW' '2563';\n");
+		grammarBuilder.append("KW2564 : 'KW' '2564';\n");
+		grammarBuilder.append("KW2565 : 'KW' '2565';\n");
+		grammarBuilder.append("KW2566 : 'KW' '2566';\n");
+		grammarBuilder.append("KW2567 : 'KW' '2567';\n");
+		grammarBuilder.append("KW2568 : 'KW' '2568';\n");
+		grammarBuilder.append("KW2569 : 'KW' '2569';\n");
+		grammarBuilder.append("KW2570 : 'KW' '2570';\n");
+		grammarBuilder.append("KW2571 : 'KW' '2571';\n");
+		grammarBuilder.append("KW2572 : 'KW' '2572';\n");
+		grammarBuilder.append("KW2573 : 'KW' '2573';\n");
+		grammarBuilder.append("KW2574 : 'KW' '2574';\n");
+		grammarBuilder.append("KW2575 : 'KW' '2575';\n");
+		grammarBuilder.append("KW2576 : 'KW' '2576';\n");
+		grammarBuilder.append("KW2577 : 'KW' '2577';\n");
+		grammarBuilder.append("KW2578 : 'KW' '2578';\n");
+		grammarBuilder.append("KW2579 : 'KW' '2579';\n");
+		grammarBuilder.append("KW2580 : 'KW' '2580';\n");
+		grammarBuilder.append("KW2581 : 'KW' '2581';\n");
+		grammarBuilder.append("KW2582 : 'KW' '2582';\n");
+		grammarBuilder.append("KW2583 : 'KW' '2583';\n");
+		grammarBuilder.append("KW2584 : 'KW' '2584';\n");
+		grammarBuilder.append("KW2585 : 'KW' '2585';\n");
+		grammarBuilder.append("KW2586 : 'KW' '2586';\n");
+		grammarBuilder.append("KW2587 : 'KW' '2587';\n");
+		grammarBuilder.append("KW2588 : 'KW' '2588';\n");
+		grammarBuilder.append("KW2589 : 'KW' '2589';\n");
+		grammarBuilder.append("KW2590 : 'KW' '2590';\n");
+		grammarBuilder.append("KW2591 : 'KW' '2591';\n");
+		grammarBuilder.append("KW2592 : 'KW' '2592';\n");
+		grammarBuilder.append("KW2593 : 'KW' '2593';\n");
+		grammarBuilder.append("KW2594 : 'KW' '2594';\n");
+		grammarBuilder.append("KW2595 : 'KW' '2595';\n");
+		grammarBuilder.append("KW2596 : 'KW' '2596';\n");
+		grammarBuilder.append("KW2597 : 'KW' '2597';\n");
+		grammarBuilder.append("KW2598 : 'KW' '2598';\n");
+		grammarBuilder.append("KW2599 : 'KW' '2599';\n");
+		grammarBuilder.append("KW2600 : 'KW' '2600';\n");
+		grammarBuilder.append("KW2601 : 'KW' '2601';\n");
+		grammarBuilder.append("KW2602 : 'KW' '2602';\n");
+		grammarBuilder.append("KW2603 : 'KW' '2603';\n");
+		grammarBuilder.append("KW2604 : 'KW' '2604';\n");
+		grammarBuilder.append("KW2605 : 'KW' '2605';\n");
+		grammarBuilder.append("KW2606 : 'KW' '2606';\n");
+		grammarBuilder.append("KW2607 : 'KW' '2607';\n");
+		grammarBuilder.append("KW2608 : 'KW' '2608';\n");
+		grammarBuilder.append("KW2609 : 'KW' '2609';\n");
+		grammarBuilder.append("KW2610 : 'KW' '2610';\n");
+		grammarBuilder.append("KW2611 : 'KW' '2611';\n");
+		grammarBuilder.append("KW2612 : 'KW' '2612';\n");
+		grammarBuilder.append("KW2613 : 'KW' '2613';\n");
+		grammarBuilder.append("KW2614 : 'KW' '2614';\n");
+		grammarBuilder.append("KW2615 : 'KW' '2615';\n");
+		grammarBuilder.append("KW2616 : 'KW' '2616';\n");
+		grammarBuilder.append("KW2617 : 'KW' '2617';\n");
+		grammarBuilder.append("KW2618 : 'KW' '2618';\n");
+		grammarBuilder.append("KW2619 : 'KW' '2619';\n");
+		grammarBuilder.append("KW2620 : 'KW' '2620';\n");
+		grammarBuilder.append("KW2621 : 'KW' '2621';\n");
+		grammarBuilder.append("KW2622 : 'KW' '2622';\n");
+		grammarBuilder.append("KW2623 : 'KW' '2623';\n");
+		grammarBuilder.append("KW2624 : 'KW' '2624';\n");
+		grammarBuilder.append("KW2625 : 'KW' '2625';\n");
+		grammarBuilder.append("KW2626 : 'KW' '2626';\n");
+		grammarBuilder.append("KW2627 : 'KW' '2627';\n");
+		grammarBuilder.append("KW2628 : 'KW' '2628';\n");
+		grammarBuilder.append("KW2629 : 'KW' '2629';\n");
+		grammarBuilder.append("KW2630 : 'KW' '2630';\n");
+		grammarBuilder.append("KW2631 : 'KW' '2631';\n");
+		grammarBuilder.append("KW2632 : 'KW' '2632';\n");
+		grammarBuilder.append("KW2633 : 'KW' '2633';\n");
+		grammarBuilder.append("KW2634 : 'KW' '2634';\n");
+		grammarBuilder.append("KW2635 : 'KW' '2635';\n");
+		grammarBuilder.append("KW2636 : 'KW' '2636';\n");
+		grammarBuilder.append("KW2637 : 'KW' '2637';\n");
+		grammarBuilder.append("KW2638 : 'KW' '2638';\n");
+		grammarBuilder.append("KW2639 : 'KW' '2639';\n");
+		grammarBuilder.append("KW2640 : 'KW' '2640';\n");
+		grammarBuilder.append("KW2641 : 'KW' '2641';\n");
+		grammarBuilder.append("KW2642 : 'KW' '2642';\n");
+		grammarBuilder.append("KW2643 : 'KW' '2643';\n");
+		grammarBuilder.append("KW2644 : 'KW' '2644';\n");
+		grammarBuilder.append("KW2645 : 'KW' '2645';\n");
+		grammarBuilder.append("KW2646 : 'KW' '2646';\n");
+		grammarBuilder.append("KW2647 : 'KW' '2647';\n");
+		grammarBuilder.append("KW2648 : 'KW' '2648';\n");
+		grammarBuilder.append("KW2649 : 'KW' '2649';\n");
+		grammarBuilder.append("KW2650 : 'KW' '2650';\n");
+		grammarBuilder.append("KW2651 : 'KW' '2651';\n");
+		grammarBuilder.append("KW2652 : 'KW' '2652';\n");
+		grammarBuilder.append("KW2653 : 'KW' '2653';\n");
+		grammarBuilder.append("KW2654 : 'KW' '2654';\n");
+		grammarBuilder.append("KW2655 : 'KW' '2655';\n");
+		grammarBuilder.append("KW2656 : 'KW' '2656';\n");
+		grammarBuilder.append("KW2657 : 'KW' '2657';\n");
+		grammarBuilder.append("KW2658 : 'KW' '2658';\n");
+		grammarBuilder.append("KW2659 : 'KW' '2659';\n");
+		grammarBuilder.append("KW2660 : 'KW' '2660';\n");
+		grammarBuilder.append("KW2661 : 'KW' '2661';\n");
+		grammarBuilder.append("KW2662 : 'KW' '2662';\n");
+		grammarBuilder.append("KW2663 : 'KW' '2663';\n");
+		grammarBuilder.append("KW2664 : 'KW' '2664';\n");
+		grammarBuilder.append("KW2665 : 'KW' '2665';\n");
+		grammarBuilder.append("KW2666 : 'KW' '2666';\n");
+		grammarBuilder.append("KW2667 : 'KW' '2667';\n");
+		grammarBuilder.append("KW2668 : 'KW' '2668';\n");
+		grammarBuilder.append("KW2669 : 'KW' '2669';\n");
+		grammarBuilder.append("KW2670 : 'KW' '2670';\n");
+		grammarBuilder.append("KW2671 : 'KW' '2671';\n");
+		grammarBuilder.append("KW2672 : 'KW' '2672';\n");
+		grammarBuilder.append("KW2673 : 'KW' '2673';\n");
+		grammarBuilder.append("KW2674 : 'KW' '2674';\n");
+		grammarBuilder.append("KW2675 : 'KW' '2675';\n");
+		grammarBuilder.append("KW2676 : 'KW' '2676';\n");
+		grammarBuilder.append("KW2677 : 'KW' '2677';\n");
+		grammarBuilder.append("KW2678 : 'KW' '2678';\n");
+		grammarBuilder.append("KW2679 : 'KW' '2679';\n");
+		grammarBuilder.append("KW2680 : 'KW' '2680';\n");
+		grammarBuilder.append("KW2681 : 'KW' '2681';\n");
+		grammarBuilder.append("KW2682 : 'KW' '2682';\n");
+		grammarBuilder.append("KW2683 : 'KW' '2683';\n");
+		grammarBuilder.append("KW2684 : 'KW' '2684';\n");
+		grammarBuilder.append("KW2685 : 'KW' '2685';\n");
+		grammarBuilder.append("KW2686 : 'KW' '2686';\n");
+		grammarBuilder.append("KW2687 : 'KW' '2687';\n");
+		grammarBuilder.append("KW2688 : 'KW' '2688';\n");
+		grammarBuilder.append("KW2689 : 'KW' '2689';\n");
+		grammarBuilder.append("KW2690 : 'KW' '2690';\n");
+		grammarBuilder.append("KW2691 : 'KW' '2691';\n");
+		grammarBuilder.append("KW2692 : 'KW' '2692';\n");
+		grammarBuilder.append("KW2693 : 'KW' '2693';\n");
+		grammarBuilder.append("KW2694 : 'KW' '2694';\n");
+		grammarBuilder.append("KW2695 : 'KW' '2695';\n");
+		grammarBuilder.append("KW2696 : 'KW' '2696';\n");
+		grammarBuilder.append("KW2697 : 'KW' '2697';\n");
+		grammarBuilder.append("KW2698 : 'KW' '2698';\n");
+		grammarBuilder.append("KW2699 : 'KW' '2699';\n");
+		grammarBuilder.append("KW2700 : 'KW' '2700';\n");
+		grammarBuilder.append("KW2701 : 'KW' '2701';\n");
+		grammarBuilder.append("KW2702 : 'KW' '2702';\n");
+		grammarBuilder.append("KW2703 : 'KW' '2703';\n");
+		grammarBuilder.append("KW2704 : 'KW' '2704';\n");
+		grammarBuilder.append("KW2705 : 'KW' '2705';\n");
+		grammarBuilder.append("KW2706 : 'KW' '2706';\n");
+		grammarBuilder.append("KW2707 : 'KW' '2707';\n");
+		grammarBuilder.append("KW2708 : 'KW' '2708';\n");
+		grammarBuilder.append("KW2709 : 'KW' '2709';\n");
+		grammarBuilder.append("KW2710 : 'KW' '2710';\n");
+		grammarBuilder.append("KW2711 : 'KW' '2711';\n");
+		grammarBuilder.append("KW2712 : 'KW' '2712';\n");
+		grammarBuilder.append("KW2713 : 'KW' '2713';\n");
+		grammarBuilder.append("KW2714 : 'KW' '2714';\n");
+		grammarBuilder.append("KW2715 : 'KW' '2715';\n");
+		grammarBuilder.append("KW2716 : 'KW' '2716';\n");
+		grammarBuilder.append("KW2717 : 'KW' '2717';\n");
+		grammarBuilder.append("KW2718 : 'KW' '2718';\n");
+		grammarBuilder.append("KW2719 : 'KW' '2719';\n");
+		grammarBuilder.append("KW2720 : 'KW' '2720';\n");
+		grammarBuilder.append("KW2721 : 'KW' '2721';\n");
+		grammarBuilder.append("KW2722 : 'KW' '2722';\n");
+		grammarBuilder.append("KW2723 : 'KW' '2723';\n");
+		grammarBuilder.append("KW2724 : 'KW' '2724';\n");
+		grammarBuilder.append("KW2725 : 'KW' '2725';\n");
+		grammarBuilder.append("KW2726 : 'KW' '2726';\n");
+		grammarBuilder.append("KW2727 : 'KW' '2727';\n");
+		grammarBuilder.append("KW2728 : 'KW' '2728';\n");
+		grammarBuilder.append("KW2729 : 'KW' '2729';\n");
+		grammarBuilder.append("KW2730 : 'KW' '2730';\n");
+		grammarBuilder.append("KW2731 : 'KW' '2731';\n");
+		grammarBuilder.append("KW2732 : 'KW' '2732';\n");
+		grammarBuilder.append("KW2733 : 'KW' '2733';\n");
+		grammarBuilder.append("KW2734 : 'KW' '2734';\n");
+		grammarBuilder.append("KW2735 : 'KW' '2735';\n");
+		grammarBuilder.append("KW2736 : 'KW' '2736';\n");
+		grammarBuilder.append("KW2737 : 'KW' '2737';\n");
+		grammarBuilder.append("KW2738 : 'KW' '2738';\n");
+		grammarBuilder.append("KW2739 : 'KW' '2739';\n");
+		grammarBuilder.append("KW2740 : 'KW' '2740';\n");
+		grammarBuilder.append("KW2741 : 'KW' '2741';\n");
+		grammarBuilder.append("KW2742 : 'KW' '2742';\n");
+		grammarBuilder.append("KW2743 : 'KW' '2743';\n");
+		grammarBuilder.append("KW2744 : 'KW' '2744';\n");
+		grammarBuilder.append("KW2745 : 'KW' '2745';\n");
+		grammarBuilder.append("KW2746 : 'KW' '2746';\n");
+		grammarBuilder.append("KW2747 : 'KW' '2747';\n");
+		grammarBuilder.append("KW2748 : 'KW' '2748';\n");
+		grammarBuilder.append("KW2749 : 'KW' '2749';\n");
+		grammarBuilder.append("KW2750 : 'KW' '2750';\n");
+		grammarBuilder.append("KW2751 : 'KW' '2751';\n");
+		grammarBuilder.append("KW2752 : 'KW' '2752';\n");
+		grammarBuilder.append("KW2753 : 'KW' '2753';\n");
+		grammarBuilder.append("KW2754 : 'KW' '2754';\n");
+		grammarBuilder.append("KW2755 : 'KW' '2755';\n");
+		grammarBuilder.append("KW2756 : 'KW' '2756';\n");
+		grammarBuilder.append("KW2757 : 'KW' '2757';\n");
+		grammarBuilder.append("KW2758 : 'KW' '2758';\n");
+		grammarBuilder.append("KW2759 : 'KW' '2759';\n");
+		grammarBuilder.append("KW2760 : 'KW' '2760';\n");
+		grammarBuilder.append("KW2761 : 'KW' '2761';\n");
+		grammarBuilder.append("KW2762 : 'KW' '2762';\n");
+		grammarBuilder.append("KW2763 : 'KW' '2763';\n");
+		grammarBuilder.append("KW2764 : 'KW' '2764';\n");
+		grammarBuilder.append("KW2765 : 'KW' '2765';\n");
+		grammarBuilder.append("KW2766 : 'KW' '2766';\n");
+		grammarBuilder.append("KW2767 : 'KW' '2767';\n");
+		grammarBuilder.append("KW2768 : 'KW' '2768';\n");
+		grammarBuilder.append("KW2769 : 'KW' '2769';\n");
+		grammarBuilder.append("KW2770 : 'KW' '2770';\n");
+		grammarBuilder.append("KW2771 : 'KW' '2771';\n");
+		grammarBuilder.append("KW2772 : 'KW' '2772';\n");
+		grammarBuilder.append("KW2773 : 'KW' '2773';\n");
+		grammarBuilder.append("KW2774 : 'KW' '2774';\n");
+		grammarBuilder.append("KW2775 : 'KW' '2775';\n");
+		grammarBuilder.append("KW2776 : 'KW' '2776';\n");
+		grammarBuilder.append("KW2777 : 'KW' '2777';\n");
+		grammarBuilder.append("KW2778 : 'KW' '2778';\n");
+		grammarBuilder.append("KW2779 : 'KW' '2779';\n");
+		grammarBuilder.append("KW2780 : 'KW' '2780';\n");
+		grammarBuilder.append("KW2781 : 'KW' '2781';\n");
+		grammarBuilder.append("KW2782 : 'KW' '2782';\n");
+		grammarBuilder.append("KW2783 : 'KW' '2783';\n");
+		grammarBuilder.append("KW2784 : 'KW' '2784';\n");
+		grammarBuilder.append("KW2785 : 'KW' '2785';\n");
+		grammarBuilder.append("KW2786 : 'KW' '2786';\n");
+		grammarBuilder.append("KW2787 : 'KW' '2787';\n");
+		grammarBuilder.append("KW2788 : 'KW' '2788';\n");
+		grammarBuilder.append("KW2789 : 'KW' '2789';\n");
+		grammarBuilder.append("KW2790 : 'KW' '2790';\n");
+		grammarBuilder.append("KW2791 : 'KW' '2791';\n");
+		grammarBuilder.append("KW2792 : 'KW' '2792';\n");
+		grammarBuilder.append("KW2793 : 'KW' '2793';\n");
+		grammarBuilder.append("KW2794 : 'KW' '2794';\n");
+		grammarBuilder.append("KW2795 : 'KW' '2795';\n");
+		grammarBuilder.append("KW2796 : 'KW' '2796';\n");
+		grammarBuilder.append("KW2797 : 'KW' '2797';\n");
+		grammarBuilder.append("KW2798 : 'KW' '2798';\n");
+		grammarBuilder.append("KW2799 : 'KW' '2799';\n");
+		grammarBuilder.append("KW2800 : 'KW' '2800';\n");
+		grammarBuilder.append("KW2801 : 'KW' '2801';\n");
+		grammarBuilder.append("KW2802 : 'KW' '2802';\n");
+		grammarBuilder.append("KW2803 : 'KW' '2803';\n");
+		grammarBuilder.append("KW2804 : 'KW' '2804';\n");
+		grammarBuilder.append("KW2805 : 'KW' '2805';\n");
+		grammarBuilder.append("KW2806 : 'KW' '2806';\n");
+		grammarBuilder.append("KW2807 : 'KW' '2807';\n");
+		grammarBuilder.append("KW2808 : 'KW' '2808';\n");
+		grammarBuilder.append("KW2809 : 'KW' '2809';\n");
+		grammarBuilder.append("KW2810 : 'KW' '2810';\n");
+		grammarBuilder.append("KW2811 : 'KW' '2811';\n");
+		grammarBuilder.append("KW2812 : 'KW' '2812';\n");
+		grammarBuilder.append("KW2813 : 'KW' '2813';\n");
+		grammarBuilder.append("KW2814 : 'KW' '2814';\n");
+		grammarBuilder.append("KW2815 : 'KW' '2815';\n");
+		grammarBuilder.append("KW2816 : 'KW' '2816';\n");
+		grammarBuilder.append("KW2817 : 'KW' '2817';\n");
+		grammarBuilder.append("KW2818 : 'KW' '2818';\n");
+		grammarBuilder.append("KW2819 : 'KW' '2819';\n");
+		grammarBuilder.append("KW2820 : 'KW' '2820';\n");
+		grammarBuilder.append("KW2821 : 'KW' '2821';\n");
+		grammarBuilder.append("KW2822 : 'KW' '2822';\n");
+		grammarBuilder.append("KW2823 : 'KW' '2823';\n");
+		grammarBuilder.append("KW2824 : 'KW' '2824';\n");
+		grammarBuilder.append("KW2825 : 'KW' '2825';\n");
+		grammarBuilder.append("KW2826 : 'KW' '2826';\n");
+		grammarBuilder.append("KW2827 : 'KW' '2827';\n");
+		grammarBuilder.append("KW2828 : 'KW' '2828';\n");
+		grammarBuilder.append("KW2829 : 'KW' '2829';\n");
+		grammarBuilder.append("KW2830 : 'KW' '2830';\n");
+		grammarBuilder.append("KW2831 : 'KW' '2831';\n");
+		grammarBuilder.append("KW2832 : 'KW' '2832';\n");
+		grammarBuilder.append("KW2833 : 'KW' '2833';\n");
+		grammarBuilder.append("KW2834 : 'KW' '2834';\n");
+		grammarBuilder.append("KW2835 : 'KW' '2835';\n");
+		grammarBuilder.append("KW2836 : 'KW' '2836';\n");
+		grammarBuilder.append("KW2837 : 'KW' '2837';\n");
+		grammarBuilder.append("KW2838 : 'KW' '2838';\n");
+		grammarBuilder.append("KW2839 : 'KW' '2839';\n");
+		grammarBuilder.append("KW2840 : 'KW' '2840';\n");
+		grammarBuilder.append("KW2841 : 'KW' '2841';\n");
+		grammarBuilder.append("KW2842 : 'KW' '2842';\n");
+		grammarBuilder.append("KW2843 : 'KW' '2843';\n");
+		grammarBuilder.append("KW2844 : 'KW' '2844';\n");
+		grammarBuilder.append("KW2845 : 'KW' '2845';\n");
+		grammarBuilder.append("KW2846 : 'KW' '2846';\n");
+		grammarBuilder.append("KW2847 : 'KW' '2847';\n");
+		grammarBuilder.append("KW2848 : 'KW' '2848';\n");
+		grammarBuilder.append("KW2849 : 'KW' '2849';\n");
+		grammarBuilder.append("KW2850 : 'KW' '2850';\n");
+		grammarBuilder.append("KW2851 : 'KW' '2851';\n");
+		grammarBuilder.append("KW2852 : 'KW' '2852';\n");
+		grammarBuilder.append("KW2853 : 'KW' '2853';\n");
+		grammarBuilder.append("KW2854 : 'KW' '2854';\n");
+		grammarBuilder.append("KW2855 : 'KW' '2855';\n");
+		grammarBuilder.append("KW2856 : 'KW' '2856';\n");
+		grammarBuilder.append("KW2857 : 'KW' '2857';\n");
+		grammarBuilder.append("KW2858 : 'KW' '2858';\n");
+		grammarBuilder.append("KW2859 : 'KW' '2859';\n");
+		grammarBuilder.append("KW2860 : 'KW' '2860';\n");
+		grammarBuilder.append("KW2861 : 'KW' '2861';\n");
+		grammarBuilder.append("KW2862 : 'KW' '2862';\n");
+		grammarBuilder.append("KW2863 : 'KW' '2863';\n");
+		grammarBuilder.append("KW2864 : 'KW' '2864';\n");
+		grammarBuilder.append("KW2865 : 'KW' '2865';\n");
+		grammarBuilder.append("KW2866 : 'KW' '2866';\n");
+		grammarBuilder.append("KW2867 : 'KW' '2867';\n");
+		grammarBuilder.append("KW2868 : 'KW' '2868';\n");
+		grammarBuilder.append("KW2869 : 'KW' '2869';\n");
+		grammarBuilder.append("KW2870 : 'KW' '2870';\n");
+		grammarBuilder.append("KW2871 : 'KW' '2871';\n");
+		grammarBuilder.append("KW2872 : 'KW' '2872';\n");
+		grammarBuilder.append("KW2873 : 'KW' '2873';\n");
+		grammarBuilder.append("KW2874 : 'KW' '2874';\n");
+		grammarBuilder.append("KW2875 : 'KW' '2875';\n");
+		grammarBuilder.append("KW2876 : 'KW' '2876';\n");
+		grammarBuilder.append("KW2877 : 'KW' '2877';\n");
+		grammarBuilder.append("KW2878 : 'KW' '2878';\n");
+		grammarBuilder.append("KW2879 : 'KW' '2879';\n");
+		grammarBuilder.append("KW2880 : 'KW' '2880';\n");
+		grammarBuilder.append("KW2881 : 'KW' '2881';\n");
+		grammarBuilder.append("KW2882 : 'KW' '2882';\n");
+		grammarBuilder.append("KW2883 : 'KW' '2883';\n");
+		grammarBuilder.append("KW2884 : 'KW' '2884';\n");
+		grammarBuilder.append("KW2885 : 'KW' '2885';\n");
+		grammarBuilder.append("KW2886 : 'KW' '2886';\n");
+		grammarBuilder.append("KW2887 : 'KW' '2887';\n");
+		grammarBuilder.append("KW2888 : 'KW' '2888';\n");
+		grammarBuilder.append("KW2889 : 'KW' '2889';\n");
+		grammarBuilder.append("KW2890 : 'KW' '2890';\n");
+		grammarBuilder.append("KW2891 : 'KW' '2891';\n");
+		grammarBuilder.append("KW2892 : 'KW' '2892';\n");
+		grammarBuilder.append("KW2893 : 'KW' '2893';\n");
+		grammarBuilder.append("KW2894 : 'KW' '2894';\n");
+		grammarBuilder.append("KW2895 : 'KW' '2895';\n");
+		grammarBuilder.append("KW2896 : 'KW' '2896';\n");
+		grammarBuilder.append("KW2897 : 'KW' '2897';\n");
+		grammarBuilder.append("KW2898 : 'KW' '2898';\n");
+		grammarBuilder.append("KW2899 : 'KW' '2899';\n");
+		grammarBuilder.append("KW2900 : 'KW' '2900';\n");
+		grammarBuilder.append("KW2901 : 'KW' '2901';\n");
+		grammarBuilder.append("KW2902 : 'KW' '2902';\n");
+		grammarBuilder.append("KW2903 : 'KW' '2903';\n");
+		grammarBuilder.append("KW2904 : 'KW' '2904';\n");
+		grammarBuilder.append("KW2905 : 'KW' '2905';\n");
+		grammarBuilder.append("KW2906 : 'KW' '2906';\n");
+		grammarBuilder.append("KW2907 : 'KW' '2907';\n");
+		grammarBuilder.append("KW2908 : 'KW' '2908';\n");
+		grammarBuilder.append("KW2909 : 'KW' '2909';\n");
+		grammarBuilder.append("KW2910 : 'KW' '2910';\n");
+		grammarBuilder.append("KW2911 : 'KW' '2911';\n");
+		grammarBuilder.append("KW2912 : 'KW' '2912';\n");
+		grammarBuilder.append("KW2913 : 'KW' '2913';\n");
+		grammarBuilder.append("KW2914 : 'KW' '2914';\n");
+		grammarBuilder.append("KW2915 : 'KW' '2915';\n");
+		grammarBuilder.append("KW2916 : 'KW' '2916';\n");
+		grammarBuilder.append("KW2917 : 'KW' '2917';\n");
+		grammarBuilder.append("KW2918 : 'KW' '2918';\n");
+		grammarBuilder.append("KW2919 : 'KW' '2919';\n");
+		grammarBuilder.append("KW2920 : 'KW' '2920';\n");
+		grammarBuilder.append("KW2921 : 'KW' '2921';\n");
+		grammarBuilder.append("KW2922 : 'KW' '2922';\n");
+		grammarBuilder.append("KW2923 : 'KW' '2923';\n");
+		grammarBuilder.append("KW2924 : 'KW' '2924';\n");
+		grammarBuilder.append("KW2925 : 'KW' '2925';\n");
+		grammarBuilder.append("KW2926 : 'KW' '2926';\n");
+		grammarBuilder.append("KW2927 : 'KW' '2927';\n");
+		grammarBuilder.append("KW2928 : 'KW' '2928';\n");
+		grammarBuilder.append("KW2929 : 'KW' '2929';\n");
+		grammarBuilder.append("KW2930 : 'KW' '2930';\n");
+		grammarBuilder.append("KW2931 : 'KW' '2931';\n");
+		grammarBuilder.append("KW2932 : 'KW' '2932';\n");
+		grammarBuilder.append("KW2933 : 'KW' '2933';\n");
+		grammarBuilder.append("KW2934 : 'KW' '2934';\n");
+		grammarBuilder.append("KW2935 : 'KW' '2935';\n");
+		grammarBuilder.append("KW2936 : 'KW' '2936';\n");
+		grammarBuilder.append("KW2937 : 'KW' '2937';\n");
+		grammarBuilder.append("KW2938 : 'KW' '2938';\n");
+		grammarBuilder.append("KW2939 : 'KW' '2939';\n");
+		grammarBuilder.append("KW2940 : 'KW' '2940';\n");
+		grammarBuilder.append("KW2941 : 'KW' '2941';\n");
+		grammarBuilder.append("KW2942 : 'KW' '2942';\n");
+		grammarBuilder.append("KW2943 : 'KW' '2943';\n");
+		grammarBuilder.append("KW2944 : 'KW' '2944';\n");
+		grammarBuilder.append("KW2945 : 'KW' '2945';\n");
+		grammarBuilder.append("KW2946 : 'KW' '2946';\n");
+		grammarBuilder.append("KW2947 : 'KW' '2947';\n");
+		grammarBuilder.append("KW2948 : 'KW' '2948';\n");
+		grammarBuilder.append("KW2949 : 'KW' '2949';\n");
+		grammarBuilder.append("KW2950 : 'KW' '2950';\n");
+		grammarBuilder.append("KW2951 : 'KW' '2951';\n");
+		grammarBuilder.append("KW2952 : 'KW' '2952';\n");
+		grammarBuilder.append("KW2953 : 'KW' '2953';\n");
+		grammarBuilder.append("KW2954 : 'KW' '2954';\n");
+		grammarBuilder.append("KW2955 : 'KW' '2955';\n");
+		grammarBuilder.append("KW2956 : 'KW' '2956';\n");
+		grammarBuilder.append("KW2957 : 'KW' '2957';\n");
+		grammarBuilder.append("KW2958 : 'KW' '2958';\n");
+		grammarBuilder.append("KW2959 : 'KW' '2959';\n");
+		grammarBuilder.append("KW2960 : 'KW' '2960';\n");
+		grammarBuilder.append("KW2961 : 'KW' '2961';\n");
+		grammarBuilder.append("KW2962 : 'KW' '2962';\n");
+		grammarBuilder.append("KW2963 : 'KW' '2963';\n");
+		grammarBuilder.append("KW2964 : 'KW' '2964';\n");
+		grammarBuilder.append("KW2965 : 'KW' '2965';\n");
+		grammarBuilder.append("KW2966 : 'KW' '2966';\n");
+		grammarBuilder.append("KW2967 : 'KW' '2967';\n");
+		grammarBuilder.append("KW2968 : 'KW' '2968';\n");
+		grammarBuilder.append("KW2969 : 'KW' '2969';\n");
+		grammarBuilder.append("KW2970 : 'KW' '2970';\n");
+		grammarBuilder.append("KW2971 : 'KW' '2971';\n");
+		grammarBuilder.append("KW2972 : 'KW' '2972';\n");
+		grammarBuilder.append("KW2973 : 'KW' '2973';\n");
+		grammarBuilder.append("KW2974 : 'KW' '2974';\n");
+		grammarBuilder.append("KW2975 : 'KW' '2975';\n");
+		grammarBuilder.append("KW2976 : 'KW' '2976';\n");
+		grammarBuilder.append("KW2977 : 'KW' '2977';\n");
+		grammarBuilder.append("KW2978 : 'KW' '2978';\n");
+		grammarBuilder.append("KW2979 : 'KW' '2979';\n");
+		grammarBuilder.append("KW2980 : 'KW' '2980';\n");
+		grammarBuilder.append("KW2981 : 'KW' '2981';\n");
+		grammarBuilder.append("KW2982 : 'KW' '2982';\n");
+		grammarBuilder.append("KW2983 : 'KW' '2983';\n");
+		grammarBuilder.append("KW2984 : 'KW' '2984';\n");
+		grammarBuilder.append("KW2985 : 'KW' '2985';\n");
+		grammarBuilder.append("KW2986 : 'KW' '2986';\n");
+		grammarBuilder.append("KW2987 : 'KW' '2987';\n");
+		grammarBuilder.append("KW2988 : 'KW' '2988';\n");
+		grammarBuilder.append("KW2989 : 'KW' '2989';\n");
+		grammarBuilder.append("KW2990 : 'KW' '2990';\n");
+		grammarBuilder.append("KW2991 : 'KW' '2991';\n");
+		grammarBuilder.append("KW2992 : 'KW' '2992';\n");
+		grammarBuilder.append("KW2993 : 'KW' '2993';\n");
+		grammarBuilder.append("KW2994 : 'KW' '2994';\n");
+		grammarBuilder.append("KW2995 : 'KW' '2995';\n");
+		grammarBuilder.append("KW2996 : 'KW' '2996';\n");
+		grammarBuilder.append("KW2997 : 'KW' '2997';\n");
+		grammarBuilder.append("KW2998 : 'KW' '2998';\n");
+		grammarBuilder.append("KW2999 : 'KW' '2999';\n");
+		grammarBuilder.append("KW3000 : 'KW' '3000';\n");
+		grammarBuilder.append("KW3001 : 'KW' '3001';\n");
+		grammarBuilder.append("KW3002 : 'KW' '3002';\n");
+		grammarBuilder.append("KW3003 : 'KW' '3003';\n");
+		grammarBuilder.append("KW3004 : 'KW' '3004';\n");
+		grammarBuilder.append("KW3005 : 'KW' '3005';\n");
+		grammarBuilder.append("KW3006 : 'KW' '3006';\n");
+		grammarBuilder.append("KW3007 : 'KW' '3007';\n");
+		grammarBuilder.append("KW3008 : 'KW' '3008';\n");
+		grammarBuilder.append("KW3009 : 'KW' '3009';\n");
+		grammarBuilder.append("KW3010 : 'KW' '3010';\n");
+		grammarBuilder.append("KW3011 : 'KW' '3011';\n");
+		grammarBuilder.append("KW3012 : 'KW' '3012';\n");
+		grammarBuilder.append("KW3013 : 'KW' '3013';\n");
+		grammarBuilder.append("KW3014 : 'KW' '3014';\n");
+		grammarBuilder.append("KW3015 : 'KW' '3015';\n");
+		grammarBuilder.append("KW3016 : 'KW' '3016';\n");
+		grammarBuilder.append("KW3017 : 'KW' '3017';\n");
+		grammarBuilder.append("KW3018 : 'KW' '3018';\n");
+		grammarBuilder.append("KW3019 : 'KW' '3019';\n");
+		grammarBuilder.append("KW3020 : 'KW' '3020';\n");
+		grammarBuilder.append("KW3021 : 'KW' '3021';\n");
+		grammarBuilder.append("KW3022 : 'KW' '3022';\n");
+		grammarBuilder.append("KW3023 : 'KW' '3023';\n");
+		grammarBuilder.append("KW3024 : 'KW' '3024';\n");
+		grammarBuilder.append("KW3025 : 'KW' '3025';\n");
+		grammarBuilder.append("KW3026 : 'KW' '3026';\n");
+		grammarBuilder.append("KW3027 : 'KW' '3027';\n");
+		grammarBuilder.append("KW3028 : 'KW' '3028';\n");
+		grammarBuilder.append("KW3029 : 'KW' '3029';\n");
+		grammarBuilder.append("KW3030 : 'KW' '3030';\n");
+		grammarBuilder.append("KW3031 : 'KW' '3031';\n");
+		grammarBuilder.append("KW3032 : 'KW' '3032';\n");
+		grammarBuilder.append("KW3033 : 'KW' '3033';\n");
+		grammarBuilder.append("KW3034 : 'KW' '3034';\n");
+		grammarBuilder.append("KW3035 : 'KW' '3035';\n");
+		grammarBuilder.append("KW3036 : 'KW' '3036';\n");
+		grammarBuilder.append("KW3037 : 'KW' '3037';\n");
+		grammarBuilder.append("KW3038 : 'KW' '3038';\n");
+		grammarBuilder.append("KW3039 : 'KW' '3039';\n");
+		grammarBuilder.append("KW3040 : 'KW' '3040';\n");
+		grammarBuilder.append("KW3041 : 'KW' '3041';\n");
+		grammarBuilder.append("KW3042 : 'KW' '3042';\n");
+		grammarBuilder.append("KW3043 : 'KW' '3043';\n");
+		grammarBuilder.append("KW3044 : 'KW' '3044';\n");
+		grammarBuilder.append("KW3045 : 'KW' '3045';\n");
+		grammarBuilder.append("KW3046 : 'KW' '3046';\n");
+		grammarBuilder.append("KW3047 : 'KW' '3047';\n");
+		grammarBuilder.append("KW3048 : 'KW' '3048';\n");
+		grammarBuilder.append("KW3049 : 'KW' '3049';\n");
+		grammarBuilder.append("KW3050 : 'KW' '3050';\n");
+		grammarBuilder.append("KW3051 : 'KW' '3051';\n");
+		grammarBuilder.append("KW3052 : 'KW' '3052';\n");
+		grammarBuilder.append("KW3053 : 'KW' '3053';\n");
+		grammarBuilder.append("KW3054 : 'KW' '3054';\n");
+		grammarBuilder.append("KW3055 : 'KW' '3055';\n");
+		grammarBuilder.append("KW3056 : 'KW' '3056';\n");
+		grammarBuilder.append("KW3057 : 'KW' '3057';\n");
+		grammarBuilder.append("KW3058 : 'KW' '3058';\n");
+		grammarBuilder.append("KW3059 : 'KW' '3059';\n");
+		grammarBuilder.append("KW3060 : 'KW' '3060';\n");
+		grammarBuilder.append("KW3061 : 'KW' '3061';\n");
+		grammarBuilder.append("KW3062 : 'KW' '3062';\n");
+		grammarBuilder.append("KW3063 : 'KW' '3063';\n");
+		grammarBuilder.append("KW3064 : 'KW' '3064';\n");
+		grammarBuilder.append("KW3065 : 'KW' '3065';\n");
+		grammarBuilder.append("KW3066 : 'KW' '3066';\n");
+		grammarBuilder.append("KW3067 : 'KW' '3067';\n");
+		grammarBuilder.append("KW3068 : 'KW' '3068';\n");
+		grammarBuilder.append("KW3069 : 'KW' '3069';\n");
+		grammarBuilder.append("KW3070 : 'KW' '3070';\n");
+		grammarBuilder.append("KW3071 : 'KW' '3071';\n");
+		grammarBuilder.append("KW3072 : 'KW' '3072';\n");
+		grammarBuilder.append("KW3073 : 'KW' '3073';\n");
+		grammarBuilder.append("KW3074 : 'KW' '3074';\n");
+		grammarBuilder.append("KW3075 : 'KW' '3075';\n");
+		grammarBuilder.append("KW3076 : 'KW' '3076';\n");
+		grammarBuilder.append("KW3077 : 'KW' '3077';\n");
+		grammarBuilder.append("KW3078 : 'KW' '3078';\n");
+		grammarBuilder.append("KW3079 : 'KW' '3079';\n");
+		grammarBuilder.append("KW3080 : 'KW' '3080';\n");
+		grammarBuilder.append("KW3081 : 'KW' '3081';\n");
+		grammarBuilder.append("KW3082 : 'KW' '3082';\n");
+		grammarBuilder.append("KW3083 : 'KW' '3083';\n");
+		grammarBuilder.append("KW3084 : 'KW' '3084';\n");
+		grammarBuilder.append("KW3085 : 'KW' '3085';\n");
+		grammarBuilder.append("KW3086 : 'KW' '3086';\n");
+		grammarBuilder.append("KW3087 : 'KW' '3087';\n");
+		grammarBuilder.append("KW3088 : 'KW' '3088';\n");
+		grammarBuilder.append("KW3089 : 'KW' '3089';\n");
+		grammarBuilder.append("KW3090 : 'KW' '3090';\n");
+		grammarBuilder.append("KW3091 : 'KW' '3091';\n");
+		grammarBuilder.append("KW3092 : 'KW' '3092';\n");
+		grammarBuilder.append("KW3093 : 'KW' '3093';\n");
+		grammarBuilder.append("KW3094 : 'KW' '3094';\n");
+		grammarBuilder.append("KW3095 : 'KW' '3095';\n");
+		grammarBuilder.append("KW3096 : 'KW' '3096';\n");
+		grammarBuilder.append("KW3097 : 'KW' '3097';\n");
+		grammarBuilder.append("KW3098 : 'KW' '3098';\n");
+		grammarBuilder.append("KW3099 : 'KW' '3099';\n");
+		grammarBuilder.append("KW3100 : 'KW' '3100';\n");
+		grammarBuilder.append("KW3101 : 'KW' '3101';\n");
+		grammarBuilder.append("KW3102 : 'KW' '3102';\n");
+		grammarBuilder.append("KW3103 : 'KW' '3103';\n");
+		grammarBuilder.append("KW3104 : 'KW' '3104';\n");
+		grammarBuilder.append("KW3105 : 'KW' '3105';\n");
+		grammarBuilder.append("KW3106 : 'KW' '3106';\n");
+		grammarBuilder.append("KW3107 : 'KW' '3107';\n");
+		grammarBuilder.append("KW3108 : 'KW' '3108';\n");
+		grammarBuilder.append("KW3109 : 'KW' '3109';\n");
+		grammarBuilder.append("KW3110 : 'KW' '3110';\n");
+		grammarBuilder.append("KW3111 : 'KW' '3111';\n");
+		grammarBuilder.append("KW3112 : 'KW' '3112';\n");
+		grammarBuilder.append("KW3113 : 'KW' '3113';\n");
+		grammarBuilder.append("KW3114 : 'KW' '3114';\n");
+		grammarBuilder.append("KW3115 : 'KW' '3115';\n");
+		grammarBuilder.append("KW3116 : 'KW' '3116';\n");
+		grammarBuilder.append("KW3117 : 'KW' '3117';\n");
+		grammarBuilder.append("KW3118 : 'KW' '3118';\n");
+		grammarBuilder.append("KW3119 : 'KW' '3119';\n");
+		grammarBuilder.append("KW3120 : 'KW' '3120';\n");
+		grammarBuilder.append("KW3121 : 'KW' '3121';\n");
+		grammarBuilder.append("KW3122 : 'KW' '3122';\n");
+		grammarBuilder.append("KW3123 : 'KW' '3123';\n");
+		grammarBuilder.append("KW3124 : 'KW' '3124';\n");
+		grammarBuilder.append("KW3125 : 'KW' '3125';\n");
+		grammarBuilder.append("KW3126 : 'KW' '3126';\n");
+		grammarBuilder.append("KW3127 : 'KW' '3127';\n");
+		grammarBuilder.append("KW3128 : 'KW' '3128';\n");
+		grammarBuilder.append("KW3129 : 'KW' '3129';\n");
+		grammarBuilder.append("KW3130 : 'KW' '3130';\n");
+		grammarBuilder.append("KW3131 : 'KW' '3131';\n");
+		grammarBuilder.append("KW3132 : 'KW' '3132';\n");
+		grammarBuilder.append("KW3133 : 'KW' '3133';\n");
+		grammarBuilder.append("KW3134 : 'KW' '3134';\n");
+		grammarBuilder.append("KW3135 : 'KW' '3135';\n");
+		grammarBuilder.append("KW3136 : 'KW' '3136';\n");
+		grammarBuilder.append("KW3137 : 'KW' '3137';\n");
+		grammarBuilder.append("KW3138 : 'KW' '3138';\n");
+		grammarBuilder.append("KW3139 : 'KW' '3139';\n");
+		grammarBuilder.append("KW3140 : 'KW' '3140';\n");
+		grammarBuilder.append("KW3141 : 'KW' '3141';\n");
+		grammarBuilder.append("KW3142 : 'KW' '3142';\n");
+		grammarBuilder.append("KW3143 : 'KW' '3143';\n");
+		grammarBuilder.append("KW3144 : 'KW' '3144';\n");
+		grammarBuilder.append("KW3145 : 'KW' '3145';\n");
+		grammarBuilder.append("KW3146 : 'KW' '3146';\n");
+		grammarBuilder.append("KW3147 : 'KW' '3147';\n");
+		grammarBuilder.append("KW3148 : 'KW' '3148';\n");
+		grammarBuilder.append("KW3149 : 'KW' '3149';\n");
+		grammarBuilder.append("KW3150 : 'KW' '3150';\n");
+		grammarBuilder.append("KW3151 : 'KW' '3151';\n");
+		grammarBuilder.append("KW3152 : 'KW' '3152';\n");
+		grammarBuilder.append("KW3153 : 'KW' '3153';\n");
+		grammarBuilder.append("KW3154 : 'KW' '3154';\n");
+		grammarBuilder.append("KW3155 : 'KW' '3155';\n");
+		grammarBuilder.append("KW3156 : 'KW' '3156';\n");
+		grammarBuilder.append("KW3157 : 'KW' '3157';\n");
+		grammarBuilder.append("KW3158 : 'KW' '3158';\n");
+		grammarBuilder.append("KW3159 : 'KW' '3159';\n");
+		grammarBuilder.append("KW3160 : 'KW' '3160';\n");
+		grammarBuilder.append("KW3161 : 'KW' '3161';\n");
+		grammarBuilder.append("KW3162 : 'KW' '3162';\n");
+		grammarBuilder.append("KW3163 : 'KW' '3163';\n");
+		grammarBuilder.append("KW3164 : 'KW' '3164';\n");
+		grammarBuilder.append("KW3165 : 'KW' '3165';\n");
+		grammarBuilder.append("KW3166 : 'KW' '3166';\n");
+		grammarBuilder.append("KW3167 : 'KW' '3167';\n");
+		grammarBuilder.append("KW3168 : 'KW' '3168';\n");
+		grammarBuilder.append("KW3169 : 'KW' '3169';\n");
+		grammarBuilder.append("KW3170 : 'KW' '3170';\n");
+		grammarBuilder.append("KW3171 : 'KW' '3171';\n");
+		grammarBuilder.append("KW3172 : 'KW' '3172';\n");
+		grammarBuilder.append("KW3173 : 'KW' '3173';\n");
+		grammarBuilder.append("KW3174 : 'KW' '3174';\n");
+		grammarBuilder.append("KW3175 : 'KW' '3175';\n");
+		grammarBuilder.append("KW3176 : 'KW' '3176';\n");
+		grammarBuilder.append("KW3177 : 'KW' '3177';\n");
+		grammarBuilder.append("KW3178 : 'KW' '3178';\n");
+		grammarBuilder.append("KW3179 : 'KW' '3179';\n");
+		grammarBuilder.append("KW3180 : 'KW' '3180';\n");
+		grammarBuilder.append("KW3181 : 'KW' '3181';\n");
+		grammarBuilder.append("KW3182 : 'KW' '3182';\n");
+		grammarBuilder.append("KW3183 : 'KW' '3183';\n");
+		grammarBuilder.append("KW3184 : 'KW' '3184';\n");
+		grammarBuilder.append("KW3185 : 'KW' '3185';\n");
+		grammarBuilder.append("KW3186 : 'KW' '3186';\n");
+		grammarBuilder.append("KW3187 : 'KW' '3187';\n");
+		grammarBuilder.append("KW3188 : 'KW' '3188';\n");
+		grammarBuilder.append("KW3189 : 'KW' '3189';\n");
+		grammarBuilder.append("KW3190 : 'KW' '3190';\n");
+		grammarBuilder.append("KW3191 : 'KW' '3191';\n");
+		grammarBuilder.append("KW3192 : 'KW' '3192';\n");
+		grammarBuilder.append("KW3193 : 'KW' '3193';\n");
+		grammarBuilder.append("KW3194 : 'KW' '3194';\n");
+		grammarBuilder.append("KW3195 : 'KW' '3195';\n");
+		grammarBuilder.append("KW3196 : 'KW' '3196';\n");
+		grammarBuilder.append("KW3197 : 'KW' '3197';\n");
+		grammarBuilder.append("KW3198 : 'KW' '3198';\n");
+		grammarBuilder.append("KW3199 : 'KW' '3199';\n");
+		grammarBuilder.append("KW3200 : 'KW' '3200';\n");
+		grammarBuilder.append("KW3201 : 'KW' '3201';\n");
+		grammarBuilder.append("KW3202 : 'KW' '3202';\n");
+		grammarBuilder.append("KW3203 : 'KW' '3203';\n");
+		grammarBuilder.append("KW3204 : 'KW' '3204';\n");
+		grammarBuilder.append("KW3205 : 'KW' '3205';\n");
+		grammarBuilder.append("KW3206 : 'KW' '3206';\n");
+		grammarBuilder.append("KW3207 : 'KW' '3207';\n");
+		grammarBuilder.append("KW3208 : 'KW' '3208';\n");
+		grammarBuilder.append("KW3209 : 'KW' '3209';\n");
+		grammarBuilder.append("KW3210 : 'KW' '3210';\n");
+		grammarBuilder.append("KW3211 : 'KW' '3211';\n");
+		grammarBuilder.append("KW3212 : 'KW' '3212';\n");
+		grammarBuilder.append("KW3213 : 'KW' '3213';\n");
+		grammarBuilder.append("KW3214 : 'KW' '3214';\n");
+		grammarBuilder.append("KW3215 : 'KW' '3215';\n");
+		grammarBuilder.append("KW3216 : 'KW' '3216';\n");
+		grammarBuilder.append("KW3217 : 'KW' '3217';\n");
+		grammarBuilder.append("KW3218 : 'KW' '3218';\n");
+		grammarBuilder.append("KW3219 : 'KW' '3219';\n");
+		grammarBuilder.append("KW3220 : 'KW' '3220';\n");
+		grammarBuilder.append("KW3221 : 'KW' '3221';\n");
+		grammarBuilder.append("KW3222 : 'KW' '3222';\n");
+		grammarBuilder.append("KW3223 : 'KW' '3223';\n");
+		grammarBuilder.append("KW3224 : 'KW' '3224';\n");
+		grammarBuilder.append("KW3225 : 'KW' '3225';\n");
+		grammarBuilder.append("KW3226 : 'KW' '3226';\n");
+		grammarBuilder.append("KW3227 : 'KW' '3227';\n");
+		grammarBuilder.append("KW3228 : 'KW' '3228';\n");
+		grammarBuilder.append("KW3229 : 'KW' '3229';\n");
+		grammarBuilder.append("KW3230 : 'KW' '3230';\n");
+		grammarBuilder.append("KW3231 : 'KW' '3231';\n");
+		grammarBuilder.append("KW3232 : 'KW' '3232';\n");
+		grammarBuilder.append("KW3233 : 'KW' '3233';\n");
+		grammarBuilder.append("KW3234 : 'KW' '3234';\n");
+		grammarBuilder.append("KW3235 : 'KW' '3235';\n");
+		grammarBuilder.append("KW3236 : 'KW' '3236';\n");
+		grammarBuilder.append("KW3237 : 'KW' '3237';\n");
+		grammarBuilder.append("KW3238 : 'KW' '3238';\n");
+		grammarBuilder.append("KW3239 : 'KW' '3239';\n");
+		grammarBuilder.append("KW3240 : 'KW' '3240';\n");
+		grammarBuilder.append("KW3241 : 'KW' '3241';\n");
+		grammarBuilder.append("KW3242 : 'KW' '3242';\n");
+		grammarBuilder.append("KW3243 : 'KW' '3243';\n");
+		grammarBuilder.append("KW3244 : 'KW' '3244';\n");
+		grammarBuilder.append("KW3245 : 'KW' '3245';\n");
+		grammarBuilder.append("KW3246 : 'KW' '3246';\n");
+		grammarBuilder.append("KW3247 : 'KW' '3247';\n");
+		grammarBuilder.append("KW3248 : 'KW' '3248';\n");
+		grammarBuilder.append("KW3249 : 'KW' '3249';\n");
+		grammarBuilder.append("KW3250 : 'KW' '3250';\n");
+		grammarBuilder.append("KW3251 : 'KW' '3251';\n");
+		grammarBuilder.append("KW3252 : 'KW' '3252';\n");
+		grammarBuilder.append("KW3253 : 'KW' '3253';\n");
+		grammarBuilder.append("KW3254 : 'KW' '3254';\n");
+		grammarBuilder.append("KW3255 : 'KW' '3255';\n");
+		grammarBuilder.append("KW3256 : 'KW' '3256';\n");
+		grammarBuilder.append("KW3257 : 'KW' '3257';\n");
+		grammarBuilder.append("KW3258 : 'KW' '3258';\n");
+		grammarBuilder.append("KW3259 : 'KW' '3259';\n");
+		grammarBuilder.append("KW3260 : 'KW' '3260';\n");
+		grammarBuilder.append("KW3261 : 'KW' '3261';\n");
+		grammarBuilder.append("KW3262 : 'KW' '3262';\n");
+		grammarBuilder.append("KW3263 : 'KW' '3263';\n");
+		grammarBuilder.append("KW3264 : 'KW' '3264';\n");
+		grammarBuilder.append("KW3265 : 'KW' '3265';\n");
+		grammarBuilder.append("KW3266 : 'KW' '3266';\n");
+		grammarBuilder.append("KW3267 : 'KW' '3267';\n");
+		grammarBuilder.append("KW3268 : 'KW' '3268';\n");
+		grammarBuilder.append("KW3269 : 'KW' '3269';\n");
+		grammarBuilder.append("KW3270 : 'KW' '3270';\n");
+		grammarBuilder.append("KW3271 : 'KW' '3271';\n");
+		grammarBuilder.append("KW3272 : 'KW' '3272';\n");
+		grammarBuilder.append("KW3273 : 'KW' '3273';\n");
+		grammarBuilder.append("KW3274 : 'KW' '3274';\n");
+		grammarBuilder.append("KW3275 : 'KW' '3275';\n");
+		grammarBuilder.append("KW3276 : 'KW' '3276';\n");
+		grammarBuilder.append("KW3277 : 'KW' '3277';\n");
+		grammarBuilder.append("KW3278 : 'KW' '3278';\n");
+		grammarBuilder.append("KW3279 : 'KW' '3279';\n");
+		grammarBuilder.append("KW3280 : 'KW' '3280';\n");
+		grammarBuilder.append("KW3281 : 'KW' '3281';\n");
+		grammarBuilder.append("KW3282 : 'KW' '3282';\n");
+		grammarBuilder.append("KW3283 : 'KW' '3283';\n");
+		grammarBuilder.append("KW3284 : 'KW' '3284';\n");
+		grammarBuilder.append("KW3285 : 'KW' '3285';\n");
+		grammarBuilder.append("KW3286 : 'KW' '3286';\n");
+		grammarBuilder.append("KW3287 : 'KW' '3287';\n");
+		grammarBuilder.append("KW3288 : 'KW' '3288';\n");
+		grammarBuilder.append("KW3289 : 'KW' '3289';\n");
+		grammarBuilder.append("KW3290 : 'KW' '3290';\n");
+		grammarBuilder.append("KW3291 : 'KW' '3291';\n");
+		grammarBuilder.append("KW3292 : 'KW' '3292';\n");
+		grammarBuilder.append("KW3293 : 'KW' '3293';\n");
+		grammarBuilder.append("KW3294 : 'KW' '3294';\n");
+		grammarBuilder.append("KW3295 : 'KW' '3295';\n");
+		grammarBuilder.append("KW3296 : 'KW' '3296';\n");
+		grammarBuilder.append("KW3297 : 'KW' '3297';\n");
+		grammarBuilder.append("KW3298 : 'KW' '3298';\n");
+		grammarBuilder.append("KW3299 : 'KW' '3299';\n");
+		grammarBuilder.append("KW3300 : 'KW' '3300';\n");
+		grammarBuilder.append("KW3301 : 'KW' '3301';\n");
+		grammarBuilder.append("KW3302 : 'KW' '3302';\n");
+		grammarBuilder.append("KW3303 : 'KW' '3303';\n");
+		grammarBuilder.append("KW3304 : 'KW' '3304';\n");
+		grammarBuilder.append("KW3305 : 'KW' '3305';\n");
+		grammarBuilder.append("KW3306 : 'KW' '3306';\n");
+		grammarBuilder.append("KW3307 : 'KW' '3307';\n");
+		grammarBuilder.append("KW3308 : 'KW' '3308';\n");
+		grammarBuilder.append("KW3309 : 'KW' '3309';\n");
+		grammarBuilder.append("KW3310 : 'KW' '3310';\n");
+		grammarBuilder.append("KW3311 : 'KW' '3311';\n");
+		grammarBuilder.append("KW3312 : 'KW' '3312';\n");
+		grammarBuilder.append("KW3313 : 'KW' '3313';\n");
+		grammarBuilder.append("KW3314 : 'KW' '3314';\n");
+		grammarBuilder.append("KW3315 : 'KW' '3315';\n");
+		grammarBuilder.append("KW3316 : 'KW' '3316';\n");
+		grammarBuilder.append("KW3317 : 'KW' '3317';\n");
+		grammarBuilder.append("KW3318 : 'KW' '3318';\n");
+		grammarBuilder.append("KW3319 : 'KW' '3319';\n");
+		grammarBuilder.append("KW3320 : 'KW' '3320';\n");
+		grammarBuilder.append("KW3321 : 'KW' '3321';\n");
+		grammarBuilder.append("KW3322 : 'KW' '3322';\n");
+		grammarBuilder.append("KW3323 : 'KW' '3323';\n");
+		grammarBuilder.append("KW3324 : 'KW' '3324';\n");
+		grammarBuilder.append("KW3325 : 'KW' '3325';\n");
+		grammarBuilder.append("KW3326 : 'KW' '3326';\n");
+		grammarBuilder.append("KW3327 : 'KW' '3327';\n");
+		grammarBuilder.append("KW3328 : 'KW' '3328';\n");
+		grammarBuilder.append("KW3329 : 'KW' '3329';\n");
+		grammarBuilder.append("KW3330 : 'KW' '3330';\n");
+		grammarBuilder.append("KW3331 : 'KW' '3331';\n");
+		grammarBuilder.append("KW3332 : 'KW' '3332';\n");
+		grammarBuilder.append("KW3333 : 'KW' '3333';\n");
+		grammarBuilder.append("KW3334 : 'KW' '3334';\n");
+		grammarBuilder.append("KW3335 : 'KW' '3335';\n");
+		grammarBuilder.append("KW3336 : 'KW' '3336';\n");
+		grammarBuilder.append("KW3337 : 'KW' '3337';\n");
+		grammarBuilder.append("KW3338 : 'KW' '3338';\n");
+		grammarBuilder.append("KW3339 : 'KW' '3339';\n");
+		grammarBuilder.append("KW3340 : 'KW' '3340';\n");
+		grammarBuilder.append("KW3341 : 'KW' '3341';\n");
+		grammarBuilder.append("KW3342 : 'KW' '3342';\n");
+		grammarBuilder.append("KW3343 : 'KW' '3343';\n");
+		grammarBuilder.append("KW3344 : 'KW' '3344';\n");
+		grammarBuilder.append("KW3345 : 'KW' '3345';\n");
+		grammarBuilder.append("KW3346 : 'KW' '3346';\n");
+		grammarBuilder.append("KW3347 : 'KW' '3347';\n");
+		grammarBuilder.append("KW3348 : 'KW' '3348';\n");
+		grammarBuilder.append("KW3349 : 'KW' '3349';\n");
+		grammarBuilder.append("KW3350 : 'KW' '3350';\n");
+		grammarBuilder.append("KW3351 : 'KW' '3351';\n");
+		grammarBuilder.append("KW3352 : 'KW' '3352';\n");
+		grammarBuilder.append("KW3353 : 'KW' '3353';\n");
+		grammarBuilder.append("KW3354 : 'KW' '3354';\n");
+		grammarBuilder.append("KW3355 : 'KW' '3355';\n");
+		grammarBuilder.append("KW3356 : 'KW' '3356';\n");
+		grammarBuilder.append("KW3357 : 'KW' '3357';\n");
+		grammarBuilder.append("KW3358 : 'KW' '3358';\n");
+		grammarBuilder.append("KW3359 : 'KW' '3359';\n");
+		grammarBuilder.append("KW3360 : 'KW' '3360';\n");
+		grammarBuilder.append("KW3361 : 'KW' '3361';\n");
+		grammarBuilder.append("KW3362 : 'KW' '3362';\n");
+		grammarBuilder.append("KW3363 : 'KW' '3363';\n");
+		grammarBuilder.append("KW3364 : 'KW' '3364';\n");
+		grammarBuilder.append("KW3365 : 'KW' '3365';\n");
+		grammarBuilder.append("KW3366 : 'KW' '3366';\n");
+		grammarBuilder.append("KW3367 : 'KW' '3367';\n");
+		grammarBuilder.append("KW3368 : 'KW' '3368';\n");
+		grammarBuilder.append("KW3369 : 'KW' '3369';\n");
+		grammarBuilder.append("KW3370 : 'KW' '3370';\n");
+		grammarBuilder.append("KW3371 : 'KW' '3371';\n");
+		grammarBuilder.append("KW3372 : 'KW' '3372';\n");
+		grammarBuilder.append("KW3373 : 'KW' '3373';\n");
+		grammarBuilder.append("KW3374 : 'KW' '3374';\n");
+		grammarBuilder.append("KW3375 : 'KW' '3375';\n");
+		grammarBuilder.append("KW3376 : 'KW' '3376';\n");
+		grammarBuilder.append("KW3377 : 'KW' '3377';\n");
+		grammarBuilder.append("KW3378 : 'KW' '3378';\n");
+		grammarBuilder.append("KW3379 : 'KW' '3379';\n");
+		grammarBuilder.append("KW3380 : 'KW' '3380';\n");
+		grammarBuilder.append("KW3381 : 'KW' '3381';\n");
+		grammarBuilder.append("KW3382 : 'KW' '3382';\n");
+		grammarBuilder.append("KW3383 : 'KW' '3383';\n");
+		grammarBuilder.append("KW3384 : 'KW' '3384';\n");
+		grammarBuilder.append("KW3385 : 'KW' '3385';\n");
+		grammarBuilder.append("KW3386 : 'KW' '3386';\n");
+		grammarBuilder.append("KW3387 : 'KW' '3387';\n");
+		grammarBuilder.append("KW3388 : 'KW' '3388';\n");
+		grammarBuilder.append("KW3389 : 'KW' '3389';\n");
+		grammarBuilder.append("KW3390 : 'KW' '3390';\n");
+		grammarBuilder.append("KW3391 : 'KW' '3391';\n");
+		grammarBuilder.append("KW3392 : 'KW' '3392';\n");
+		grammarBuilder.append("KW3393 : 'KW' '3393';\n");
+		grammarBuilder.append("KW3394 : 'KW' '3394';\n");
+		grammarBuilder.append("KW3395 : 'KW' '3395';\n");
+		grammarBuilder.append("KW3396 : 'KW' '3396';\n");
+		grammarBuilder.append("KW3397 : 'KW' '3397';\n");
+		grammarBuilder.append("KW3398 : 'KW' '3398';\n");
+		grammarBuilder.append("KW3399 : 'KW' '3399';\n");
+		grammarBuilder.append("KW3400 : 'KW' '3400';\n");
+		grammarBuilder.append("KW3401 : 'KW' '3401';\n");
+		grammarBuilder.append("KW3402 : 'KW' '3402';\n");
+		grammarBuilder.append("KW3403 : 'KW' '3403';\n");
+		grammarBuilder.append("KW3404 : 'KW' '3404';\n");
+		grammarBuilder.append("KW3405 : 'KW' '3405';\n");
+		grammarBuilder.append("KW3406 : 'KW' '3406';\n");
+		grammarBuilder.append("KW3407 : 'KW' '3407';\n");
+		grammarBuilder.append("KW3408 : 'KW' '3408';\n");
+		grammarBuilder.append("KW3409 : 'KW' '3409';\n");
+		grammarBuilder.append("KW3410 : 'KW' '3410';\n");
+		grammarBuilder.append("KW3411 : 'KW' '3411';\n");
+		grammarBuilder.append("KW3412 : 'KW' '3412';\n");
+		grammarBuilder.append("KW3413 : 'KW' '3413';\n");
+		grammarBuilder.append("KW3414 : 'KW' '3414';\n");
+		grammarBuilder.append("KW3415 : 'KW' '3415';\n");
+		grammarBuilder.append("KW3416 : 'KW' '3416';\n");
+		grammarBuilder.append("KW3417 : 'KW' '3417';\n");
+		grammarBuilder.append("KW3418 : 'KW' '3418';\n");
+		grammarBuilder.append("KW3419 : 'KW' '3419';\n");
+		grammarBuilder.append("KW3420 : 'KW' '3420';\n");
+		grammarBuilder.append("KW3421 : 'KW' '3421';\n");
+		grammarBuilder.append("KW3422 : 'KW' '3422';\n");
+		grammarBuilder.append("KW3423 : 'KW' '3423';\n");
+		grammarBuilder.append("KW3424 : 'KW' '3424';\n");
+		grammarBuilder.append("KW3425 : 'KW' '3425';\n");
+		grammarBuilder.append("KW3426 : 'KW' '3426';\n");
+		grammarBuilder.append("KW3427 : 'KW' '3427';\n");
+		grammarBuilder.append("KW3428 : 'KW' '3428';\n");
+		grammarBuilder.append("KW3429 : 'KW' '3429';\n");
+		grammarBuilder.append("KW3430 : 'KW' '3430';\n");
+		grammarBuilder.append("KW3431 : 'KW' '3431';\n");
+		grammarBuilder.append("KW3432 : 'KW' '3432';\n");
+		grammarBuilder.append("KW3433 : 'KW' '3433';\n");
+		grammarBuilder.append("KW3434 : 'KW' '3434';\n");
+		grammarBuilder.append("KW3435 : 'KW' '3435';\n");
+		grammarBuilder.append("KW3436 : 'KW' '3436';\n");
+		grammarBuilder.append("KW3437 : 'KW' '3437';\n");
+		grammarBuilder.append("KW3438 : 'KW' '3438';\n");
+		grammarBuilder.append("KW3439 : 'KW' '3439';\n");
+		grammarBuilder.append("KW3440 : 'KW' '3440';\n");
+		grammarBuilder.append("KW3441 : 'KW' '3441';\n");
+		grammarBuilder.append("KW3442 : 'KW' '3442';\n");
+		grammarBuilder.append("KW3443 : 'KW' '3443';\n");
+		grammarBuilder.append("KW3444 : 'KW' '3444';\n");
+		grammarBuilder.append("KW3445 : 'KW' '3445';\n");
+		grammarBuilder.append("KW3446 : 'KW' '3446';\n");
+		grammarBuilder.append("KW3447 : 'KW' '3447';\n");
+		grammarBuilder.append("KW3448 : 'KW' '3448';\n");
+		grammarBuilder.append("KW3449 : 'KW' '3449';\n");
+		grammarBuilder.append("KW3450 : 'KW' '3450';\n");
+		grammarBuilder.append("KW3451 : 'KW' '3451';\n");
+		grammarBuilder.append("KW3452 : 'KW' '3452';\n");
+		grammarBuilder.append("KW3453 : 'KW' '3453';\n");
+		grammarBuilder.append("KW3454 : 'KW' '3454';\n");
+		grammarBuilder.append("KW3455 : 'KW' '3455';\n");
+		grammarBuilder.append("KW3456 : 'KW' '3456';\n");
+		grammarBuilder.append("KW3457 : 'KW' '3457';\n");
+		grammarBuilder.append("KW3458 : 'KW' '3458';\n");
+		grammarBuilder.append("KW3459 : 'KW' '3459';\n");
+		grammarBuilder.append("KW3460 : 'KW' '3460';\n");
+		grammarBuilder.append("KW3461 : 'KW' '3461';\n");
+		grammarBuilder.append("KW3462 : 'KW' '3462';\n");
+		grammarBuilder.append("KW3463 : 'KW' '3463';\n");
+		grammarBuilder.append("KW3464 : 'KW' '3464';\n");
+		grammarBuilder.append("KW3465 : 'KW' '3465';\n");
+		grammarBuilder.append("KW3466 : 'KW' '3466';\n");
+		grammarBuilder.append("KW3467 : 'KW' '3467';\n");
+		grammarBuilder.append("KW3468 : 'KW' '3468';\n");
+		grammarBuilder.append("KW3469 : 'KW' '3469';\n");
+		grammarBuilder.append("KW3470 : 'KW' '3470';\n");
+		grammarBuilder.append("KW3471 : 'KW' '3471';\n");
+		grammarBuilder.append("KW3472 : 'KW' '3472';\n");
+		grammarBuilder.append("KW3473 : 'KW' '3473';\n");
+		grammarBuilder.append("KW3474 : 'KW' '3474';\n");
+		grammarBuilder.append("KW3475 : 'KW' '3475';\n");
+		grammarBuilder.append("KW3476 : 'KW' '3476';\n");
+		grammarBuilder.append("KW3477 : 'KW' '3477';\n");
+		grammarBuilder.append("KW3478 : 'KW' '3478';\n");
+		grammarBuilder.append("KW3479 : 'KW' '3479';\n");
+		grammarBuilder.append("KW3480 : 'KW' '3480';\n");
+		grammarBuilder.append("KW3481 : 'KW' '3481';\n");
+		grammarBuilder.append("KW3482 : 'KW' '3482';\n");
+		grammarBuilder.append("KW3483 : 'KW' '3483';\n");
+		grammarBuilder.append("KW3484 : 'KW' '3484';\n");
+		grammarBuilder.append("KW3485 : 'KW' '3485';\n");
+		grammarBuilder.append("KW3486 : 'KW' '3486';\n");
+		grammarBuilder.append("KW3487 : 'KW' '3487';\n");
+		grammarBuilder.append("KW3488 : 'KW' '3488';\n");
+		grammarBuilder.append("KW3489 : 'KW' '3489';\n");
+		grammarBuilder.append("KW3490 : 'KW' '3490';\n");
+		grammarBuilder.append("KW3491 : 'KW' '3491';\n");
+		grammarBuilder.append("KW3492 : 'KW' '3492';\n");
+		grammarBuilder.append("KW3493 : 'KW' '3493';\n");
+		grammarBuilder.append("KW3494 : 'KW' '3494';\n");
+		grammarBuilder.append("KW3495 : 'KW' '3495';\n");
+		grammarBuilder.append("KW3496 : 'KW' '3496';\n");
+		grammarBuilder.append("KW3497 : 'KW' '3497';\n");
+		grammarBuilder.append("KW3498 : 'KW' '3498';\n");
+		grammarBuilder.append("KW3499 : 'KW' '3499';\n");
+		grammarBuilder.append("KW3500 : 'KW' '3500';\n");
+		grammarBuilder.append("KW3501 : 'KW' '3501';\n");
+		grammarBuilder.append("KW3502 : 'KW' '3502';\n");
+		grammarBuilder.append("KW3503 : 'KW' '3503';\n");
+		grammarBuilder.append("KW3504 : 'KW' '3504';\n");
+		grammarBuilder.append("KW3505 : 'KW' '3505';\n");
+		grammarBuilder.append("KW3506 : 'KW' '3506';\n");
+		grammarBuilder.append("KW3507 : 'KW' '3507';\n");
+		grammarBuilder.append("KW3508 : 'KW' '3508';\n");
+		grammarBuilder.append("KW3509 : 'KW' '3509';\n");
+		grammarBuilder.append("KW3510 : 'KW' '3510';\n");
+		grammarBuilder.append("KW3511 : 'KW' '3511';\n");
+		grammarBuilder.append("KW3512 : 'KW' '3512';\n");
+		grammarBuilder.append("KW3513 : 'KW' '3513';\n");
+		grammarBuilder.append("KW3514 : 'KW' '3514';\n");
+		grammarBuilder.append("KW3515 : 'KW' '3515';\n");
+		grammarBuilder.append("KW3516 : 'KW' '3516';\n");
+		grammarBuilder.append("KW3517 : 'KW' '3517';\n");
+		grammarBuilder.append("KW3518 : 'KW' '3518';\n");
+		grammarBuilder.append("KW3519 : 'KW' '3519';\n");
+		grammarBuilder.append("KW3520 : 'KW' '3520';\n");
+		grammarBuilder.append("KW3521 : 'KW' '3521';\n");
+		grammarBuilder.append("KW3522 : 'KW' '3522';\n");
+		grammarBuilder.append("KW3523 : 'KW' '3523';\n");
+		grammarBuilder.append("KW3524 : 'KW' '3524';\n");
+		grammarBuilder.append("KW3525 : 'KW' '3525';\n");
+		grammarBuilder.append("KW3526 : 'KW' '3526';\n");
+		grammarBuilder.append("KW3527 : 'KW' '3527';\n");
+		grammarBuilder.append("KW3528 : 'KW' '3528';\n");
+		grammarBuilder.append("KW3529 : 'KW' '3529';\n");
+		grammarBuilder.append("KW3530 : 'KW' '3530';\n");
+		grammarBuilder.append("KW3531 : 'KW' '3531';\n");
+		grammarBuilder.append("KW3532 : 'KW' '3532';\n");
+		grammarBuilder.append("KW3533 : 'KW' '3533';\n");
+		grammarBuilder.append("KW3534 : 'KW' '3534';\n");
+		grammarBuilder.append("KW3535 : 'KW' '3535';\n");
+		grammarBuilder.append("KW3536 : 'KW' '3536';\n");
+		grammarBuilder.append("KW3537 : 'KW' '3537';\n");
+		grammarBuilder.append("KW3538 : 'KW' '3538';\n");
+		grammarBuilder.append("KW3539 : 'KW' '3539';\n");
+		grammarBuilder.append("KW3540 : 'KW' '3540';\n");
+		grammarBuilder.append("KW3541 : 'KW' '3541';\n");
+		grammarBuilder.append("KW3542 : 'KW' '3542';\n");
+		grammarBuilder.append("KW3543 : 'KW' '3543';\n");
+		grammarBuilder.append("KW3544 : 'KW' '3544';\n");
+		grammarBuilder.append("KW3545 : 'KW' '3545';\n");
+		grammarBuilder.append("KW3546 : 'KW' '3546';\n");
+		grammarBuilder.append("KW3547 : 'KW' '3547';\n");
+		grammarBuilder.append("KW3548 : 'KW' '3548';\n");
+		grammarBuilder.append("KW3549 : 'KW' '3549';\n");
+		grammarBuilder.append("KW3550 : 'KW' '3550';\n");
+		grammarBuilder.append("KW3551 : 'KW' '3551';\n");
+		grammarBuilder.append("KW3552 : 'KW' '3552';\n");
+		grammarBuilder.append("KW3553 : 'KW' '3553';\n");
+		grammarBuilder.append("KW3554 : 'KW' '3554';\n");
+		grammarBuilder.append("KW3555 : 'KW' '3555';\n");
+		grammarBuilder.append("KW3556 : 'KW' '3556';\n");
+		grammarBuilder.append("KW3557 : 'KW' '3557';\n");
+		grammarBuilder.append("KW3558 : 'KW' '3558';\n");
+		grammarBuilder.append("KW3559 : 'KW' '3559';\n");
+		grammarBuilder.append("KW3560 : 'KW' '3560';\n");
+		grammarBuilder.append("KW3561 : 'KW' '3561';\n");
+		grammarBuilder.append("KW3562 : 'KW' '3562';\n");
+		grammarBuilder.append("KW3563 : 'KW' '3563';\n");
+		grammarBuilder.append("KW3564 : 'KW' '3564';\n");
+		grammarBuilder.append("KW3565 : 'KW' '3565';\n");
+		grammarBuilder.append("KW3566 : 'KW' '3566';\n");
+		grammarBuilder.append("KW3567 : 'KW' '3567';\n");
+		grammarBuilder.append("KW3568 : 'KW' '3568';\n");
+		grammarBuilder.append("KW3569 : 'KW' '3569';\n");
+		grammarBuilder.append("KW3570 : 'KW' '3570';\n");
+		grammarBuilder.append("KW3571 : 'KW' '3571';\n");
+		grammarBuilder.append("KW3572 : 'KW' '3572';\n");
+		grammarBuilder.append("KW3573 : 'KW' '3573';\n");
+		grammarBuilder.append("KW3574 : 'KW' '3574';\n");
+		grammarBuilder.append("KW3575 : 'KW' '3575';\n");
+		grammarBuilder.append("KW3576 : 'KW' '3576';\n");
+		grammarBuilder.append("KW3577 : 'KW' '3577';\n");
+		grammarBuilder.append("KW3578 : 'KW' '3578';\n");
+		grammarBuilder.append("KW3579 : 'KW' '3579';\n");
+		grammarBuilder.append("KW3580 : 'KW' '3580';\n");
+		grammarBuilder.append("KW3581 : 'KW' '3581';\n");
+		grammarBuilder.append("KW3582 : 'KW' '3582';\n");
+		grammarBuilder.append("KW3583 : 'KW' '3583';\n");
+		grammarBuilder.append("KW3584 : 'KW' '3584';\n");
+		grammarBuilder.append("KW3585 : 'KW' '3585';\n");
+		grammarBuilder.append("KW3586 : 'KW' '3586';\n");
+		grammarBuilder.append("KW3587 : 'KW' '3587';\n");
+		grammarBuilder.append("KW3588 : 'KW' '3588';\n");
+		grammarBuilder.append("KW3589 : 'KW' '3589';\n");
+		grammarBuilder.append("KW3590 : 'KW' '3590';\n");
+		grammarBuilder.append("KW3591 : 'KW' '3591';\n");
+		grammarBuilder.append("KW3592 : 'KW' '3592';\n");
+		grammarBuilder.append("KW3593 : 'KW' '3593';\n");
+		grammarBuilder.append("KW3594 : 'KW' '3594';\n");
+		grammarBuilder.append("KW3595 : 'KW' '3595';\n");
+		grammarBuilder.append("KW3596 : 'KW' '3596';\n");
+		grammarBuilder.append("KW3597 : 'KW' '3597';\n");
+		grammarBuilder.append("KW3598 : 'KW' '3598';\n");
+		grammarBuilder.append("KW3599 : 'KW' '3599';\n");
+		grammarBuilder.append("KW3600 : 'KW' '3600';\n");
+		grammarBuilder.append("KW3601 : 'KW' '3601';\n");
+		grammarBuilder.append("KW3602 : 'KW' '3602';\n");
+		grammarBuilder.append("KW3603 : 'KW' '3603';\n");
+		grammarBuilder.append("KW3604 : 'KW' '3604';\n");
+		grammarBuilder.append("KW3605 : 'KW' '3605';\n");
+		grammarBuilder.append("KW3606 : 'KW' '3606';\n");
+		grammarBuilder.append("KW3607 : 'KW' '3607';\n");
+		grammarBuilder.append("KW3608 : 'KW' '3608';\n");
+		grammarBuilder.append("KW3609 : 'KW' '3609';\n");
+		grammarBuilder.append("KW3610 : 'KW' '3610';\n");
+		grammarBuilder.append("KW3611 : 'KW' '3611';\n");
+		grammarBuilder.append("KW3612 : 'KW' '3612';\n");
+		grammarBuilder.append("KW3613 : 'KW' '3613';\n");
+		grammarBuilder.append("KW3614 : 'KW' '3614';\n");
+		grammarBuilder.append("KW3615 : 'KW' '3615';\n");
+		grammarBuilder.append("KW3616 : 'KW' '3616';\n");
+		grammarBuilder.append("KW3617 : 'KW' '3617';\n");
+		grammarBuilder.append("KW3618 : 'KW' '3618';\n");
+		grammarBuilder.append("KW3619 : 'KW' '3619';\n");
+		grammarBuilder.append("KW3620 : 'KW' '3620';\n");
+		grammarBuilder.append("KW3621 : 'KW' '3621';\n");
+		grammarBuilder.append("KW3622 : 'KW' '3622';\n");
+		grammarBuilder.append("KW3623 : 'KW' '3623';\n");
+		grammarBuilder.append("KW3624 : 'KW' '3624';\n");
+		grammarBuilder.append("KW3625 : 'KW' '3625';\n");
+		grammarBuilder.append("KW3626 : 'KW' '3626';\n");
+		grammarBuilder.append("KW3627 : 'KW' '3627';\n");
+		grammarBuilder.append("KW3628 : 'KW' '3628';\n");
+		grammarBuilder.append("KW3629 : 'KW' '3629';\n");
+		grammarBuilder.append("KW3630 : 'KW' '3630';\n");
+		grammarBuilder.append("KW3631 : 'KW' '3631';\n");
+		grammarBuilder.append("KW3632 : 'KW' '3632';\n");
+		grammarBuilder.append("KW3633 : 'KW' '3633';\n");
+		grammarBuilder.append("KW3634 : 'KW' '3634';\n");
+		grammarBuilder.append("KW3635 : 'KW' '3635';\n");
+		grammarBuilder.append("KW3636 : 'KW' '3636';\n");
+		grammarBuilder.append("KW3637 : 'KW' '3637';\n");
+		grammarBuilder.append("KW3638 : 'KW' '3638';\n");
+		grammarBuilder.append("KW3639 : 'KW' '3639';\n");
+		grammarBuilder.append("KW3640 : 'KW' '3640';\n");
+		grammarBuilder.append("KW3641 : 'KW' '3641';\n");
+		grammarBuilder.append("KW3642 : 'KW' '3642';\n");
+		grammarBuilder.append("KW3643 : 'KW' '3643';\n");
+		grammarBuilder.append("KW3644 : 'KW' '3644';\n");
+		grammarBuilder.append("KW3645 : 'KW' '3645';\n");
+		grammarBuilder.append("KW3646 : 'KW' '3646';\n");
+		grammarBuilder.append("KW3647 : 'KW' '3647';\n");
+		grammarBuilder.append("KW3648 : 'KW' '3648';\n");
+		grammarBuilder.append("KW3649 : 'KW' '3649';\n");
+		grammarBuilder.append("KW3650 : 'KW' '3650';\n");
+		grammarBuilder.append("KW3651 : 'KW' '3651';\n");
+		grammarBuilder.append("KW3652 : 'KW' '3652';\n");
+		grammarBuilder.append("KW3653 : 'KW' '3653';\n");
+		grammarBuilder.append("KW3654 : 'KW' '3654';\n");
+		grammarBuilder.append("KW3655 : 'KW' '3655';\n");
+		grammarBuilder.append("KW3656 : 'KW' '3656';\n");
+		grammarBuilder.append("KW3657 : 'KW' '3657';\n");
+		grammarBuilder.append("KW3658 : 'KW' '3658';\n");
+		grammarBuilder.append("KW3659 : 'KW' '3659';\n");
+		grammarBuilder.append("KW3660 : 'KW' '3660';\n");
+		grammarBuilder.append("KW3661 : 'KW' '3661';\n");
+		grammarBuilder.append("KW3662 : 'KW' '3662';\n");
+		grammarBuilder.append("KW3663 : 'KW' '3663';\n");
+		grammarBuilder.append("KW3664 : 'KW' '3664';\n");
+		grammarBuilder.append("KW3665 : 'KW' '3665';\n");
+		grammarBuilder.append("KW3666 : 'KW' '3666';\n");
+		grammarBuilder.append("KW3667 : 'KW' '3667';\n");
+		grammarBuilder.append("KW3668 : 'KW' '3668';\n");
+		grammarBuilder.append("KW3669 : 'KW' '3669';\n");
+		grammarBuilder.append("KW3670 : 'KW' '3670';\n");
+		grammarBuilder.append("KW3671 : 'KW' '3671';\n");
+		grammarBuilder.append("KW3672 : 'KW' '3672';\n");
+		grammarBuilder.append("KW3673 : 'KW' '3673';\n");
+		grammarBuilder.append("KW3674 : 'KW' '3674';\n");
+		grammarBuilder.append("KW3675 : 'KW' '3675';\n");
+		grammarBuilder.append("KW3676 : 'KW' '3676';\n");
+		grammarBuilder.append("KW3677 : 'KW' '3677';\n");
+		grammarBuilder.append("KW3678 : 'KW' '3678';\n");
+		grammarBuilder.append("KW3679 : 'KW' '3679';\n");
+		grammarBuilder.append("KW3680 : 'KW' '3680';\n");
+		grammarBuilder.append("KW3681 : 'KW' '3681';\n");
+		grammarBuilder.append("KW3682 : 'KW' '3682';\n");
+		grammarBuilder.append("KW3683 : 'KW' '3683';\n");
+		grammarBuilder.append("KW3684 : 'KW' '3684';\n");
+		grammarBuilder.append("KW3685 : 'KW' '3685';\n");
+		grammarBuilder.append("KW3686 : 'KW' '3686';\n");
+		grammarBuilder.append("KW3687 : 'KW' '3687';\n");
+		grammarBuilder.append("KW3688 : 'KW' '3688';\n");
+		grammarBuilder.append("KW3689 : 'KW' '3689';\n");
+		grammarBuilder.append("KW3690 : 'KW' '3690';\n");
+		grammarBuilder.append("KW3691 : 'KW' '3691';\n");
+		grammarBuilder.append("KW3692 : 'KW' '3692';\n");
+		grammarBuilder.append("KW3693 : 'KW' '3693';\n");
+		grammarBuilder.append("KW3694 : 'KW' '3694';\n");
+		grammarBuilder.append("KW3695 : 'KW' '3695';\n");
+		grammarBuilder.append("KW3696 : 'KW' '3696';\n");
+		grammarBuilder.append("KW3697 : 'KW' '3697';\n");
+		grammarBuilder.append("KW3698 : 'KW' '3698';\n");
+		grammarBuilder.append("KW3699 : 'KW' '3699';\n");
+		grammarBuilder.append("KW3700 : 'KW' '3700';\n");
+		grammarBuilder.append("KW3701 : 'KW' '3701';\n");
+		grammarBuilder.append("KW3702 : 'KW' '3702';\n");
+		grammarBuilder.append("KW3703 : 'KW' '3703';\n");
+		grammarBuilder.append("KW3704 : 'KW' '3704';\n");
+		grammarBuilder.append("KW3705 : 'KW' '3705';\n");
+		grammarBuilder.append("KW3706 : 'KW' '3706';\n");
+		grammarBuilder.append("KW3707 : 'KW' '3707';\n");
+		grammarBuilder.append("KW3708 : 'KW' '3708';\n");
+		grammarBuilder.append("KW3709 : 'KW' '3709';\n");
+		grammarBuilder.append("KW3710 : 'KW' '3710';\n");
+		grammarBuilder.append("KW3711 : 'KW' '3711';\n");
+		grammarBuilder.append("KW3712 : 'KW' '3712';\n");
+		grammarBuilder.append("KW3713 : 'KW' '3713';\n");
+		grammarBuilder.append("KW3714 : 'KW' '3714';\n");
+		grammarBuilder.append("KW3715 : 'KW' '3715';\n");
+		grammarBuilder.append("KW3716 : 'KW' '3716';\n");
+		grammarBuilder.append("KW3717 : 'KW' '3717';\n");
+		grammarBuilder.append("KW3718 : 'KW' '3718';\n");
+		grammarBuilder.append("KW3719 : 'KW' '3719';\n");
+		grammarBuilder.append("KW3720 : 'KW' '3720';\n");
+		grammarBuilder.append("KW3721 : 'KW' '3721';\n");
+		grammarBuilder.append("KW3722 : 'KW' '3722';\n");
+		grammarBuilder.append("KW3723 : 'KW' '3723';\n");
+		grammarBuilder.append("KW3724 : 'KW' '3724';\n");
+		grammarBuilder.append("KW3725 : 'KW' '3725';\n");
+		grammarBuilder.append("KW3726 : 'KW' '3726';\n");
+		grammarBuilder.append("KW3727 : 'KW' '3727';\n");
+		grammarBuilder.append("KW3728 : 'KW' '3728';\n");
+		grammarBuilder.append("KW3729 : 'KW' '3729';\n");
+		grammarBuilder.append("KW3730 : 'KW' '3730';\n");
+		grammarBuilder.append("KW3731 : 'KW' '3731';\n");
+		grammarBuilder.append("KW3732 : 'KW' '3732';\n");
+		grammarBuilder.append("KW3733 : 'KW' '3733';\n");
+		grammarBuilder.append("KW3734 : 'KW' '3734';\n");
+		grammarBuilder.append("KW3735 : 'KW' '3735';\n");
+		grammarBuilder.append("KW3736 : 'KW' '3736';\n");
+		grammarBuilder.append("KW3737 : 'KW' '3737';\n");
+		grammarBuilder.append("KW3738 : 'KW' '3738';\n");
+		grammarBuilder.append("KW3739 : 'KW' '3739';\n");
+		grammarBuilder.append("KW3740 : 'KW' '3740';\n");
+		grammarBuilder.append("KW3741 : 'KW' '3741';\n");
+		grammarBuilder.append("KW3742 : 'KW' '3742';\n");
+		grammarBuilder.append("KW3743 : 'KW' '3743';\n");
+		grammarBuilder.append("KW3744 : 'KW' '3744';\n");
+		grammarBuilder.append("KW3745 : 'KW' '3745';\n");
+		grammarBuilder.append("KW3746 : 'KW' '3746';\n");
+		grammarBuilder.append("KW3747 : 'KW' '3747';\n");
+		grammarBuilder.append("KW3748 : 'KW' '3748';\n");
+		grammarBuilder.append("KW3749 : 'KW' '3749';\n");
+		grammarBuilder.append("KW3750 : 'KW' '3750';\n");
+		grammarBuilder.append("KW3751 : 'KW' '3751';\n");
+		grammarBuilder.append("KW3752 : 'KW' '3752';\n");
+		grammarBuilder.append("KW3753 : 'KW' '3753';\n");
+		grammarBuilder.append("KW3754 : 'KW' '3754';\n");
+		grammarBuilder.append("KW3755 : 'KW' '3755';\n");
+		grammarBuilder.append("KW3756 : 'KW' '3756';\n");
+		grammarBuilder.append("KW3757 : 'KW' '3757';\n");
+		grammarBuilder.append("KW3758 : 'KW' '3758';\n");
+		grammarBuilder.append("KW3759 : 'KW' '3759';\n");
+		grammarBuilder.append("KW3760 : 'KW' '3760';\n");
+		grammarBuilder.append("KW3761 : 'KW' '3761';\n");
+		grammarBuilder.append("KW3762 : 'KW' '3762';\n");
+		grammarBuilder.append("KW3763 : 'KW' '3763';\n");
+		grammarBuilder.append("KW3764 : 'KW' '3764';\n");
+		grammarBuilder.append("KW3765 : 'KW' '3765';\n");
+		grammarBuilder.append("KW3766 : 'KW' '3766';\n");
+		grammarBuilder.append("KW3767 : 'KW' '3767';\n");
+		grammarBuilder.append("KW3768 : 'KW' '3768';\n");
+		grammarBuilder.append("KW3769 : 'KW' '3769';\n");
+		grammarBuilder.append("KW3770 : 'KW' '3770';\n");
+		grammarBuilder.append("KW3771 : 'KW' '3771';\n");
+		grammarBuilder.append("KW3772 : 'KW' '3772';\n");
+		grammarBuilder.append("KW3773 : 'KW' '3773';\n");
+		grammarBuilder.append("KW3774 : 'KW' '3774';\n");
+		grammarBuilder.append("KW3775 : 'KW' '3775';\n");
+		grammarBuilder.append("KW3776 : 'KW' '3776';\n");
+		grammarBuilder.append("KW3777 : 'KW' '3777';\n");
+		grammarBuilder.append("KW3778 : 'KW' '3778';\n");
+		grammarBuilder.append("KW3779 : 'KW' '3779';\n");
+		grammarBuilder.append("KW3780 : 'KW' '3780';\n");
+		grammarBuilder.append("KW3781 : 'KW' '3781';\n");
+		grammarBuilder.append("KW3782 : 'KW' '3782';\n");
+		grammarBuilder.append("KW3783 : 'KW' '3783';\n");
+		grammarBuilder.append("KW3784 : 'KW' '3784';\n");
+		grammarBuilder.append("KW3785 : 'KW' '3785';\n");
+		grammarBuilder.append("KW3786 : 'KW' '3786';\n");
+		grammarBuilder.append("KW3787 : 'KW' '3787';\n");
+		grammarBuilder.append("KW3788 : 'KW' '3788';\n");
+		grammarBuilder.append("KW3789 : 'KW' '3789';\n");
+		grammarBuilder.append("KW3790 : 'KW' '3790';\n");
+		grammarBuilder.append("KW3791 : 'KW' '3791';\n");
+		grammarBuilder.append("KW3792 : 'KW' '3792';\n");
+		grammarBuilder.append("KW3793 : 'KW' '3793';\n");
+		grammarBuilder.append("KW3794 : 'KW' '3794';\n");
+		grammarBuilder.append("KW3795 : 'KW' '3795';\n");
+		grammarBuilder.append("KW3796 : 'KW' '3796';\n");
+		grammarBuilder.append("KW3797 : 'KW' '3797';\n");
+		grammarBuilder.append("KW3798 : 'KW' '3798';\n");
+		grammarBuilder.append("KW3799 : 'KW' '3799';\n");
+		grammarBuilder.append("KW3800 : 'KW' '3800';\n");
+		grammarBuilder.append("KW3801 : 'KW' '3801';\n");
+		grammarBuilder.append("KW3802 : 'KW' '3802';\n");
+		grammarBuilder.append("KW3803 : 'KW' '3803';\n");
+		grammarBuilder.append("KW3804 : 'KW' '3804';\n");
+		grammarBuilder.append("KW3805 : 'KW' '3805';\n");
+		grammarBuilder.append("KW3806 : 'KW' '3806';\n");
+		grammarBuilder.append("KW3807 : 'KW' '3807';\n");
+		grammarBuilder.append("KW3808 : 'KW' '3808';\n");
+		grammarBuilder.append("KW3809 : 'KW' '3809';\n");
+		grammarBuilder.append("KW3810 : 'KW' '3810';\n");
+		grammarBuilder.append("KW3811 : 'KW' '3811';\n");
+		grammarBuilder.append("KW3812 : 'KW' '3812';\n");
+		grammarBuilder.append("KW3813 : 'KW' '3813';\n");
+		grammarBuilder.append("KW3814 : 'KW' '3814';\n");
+		grammarBuilder.append("KW3815 : 'KW' '3815';\n");
+		grammarBuilder.append("KW3816 : 'KW' '3816';\n");
+		grammarBuilder.append("KW3817 : 'KW' '3817';\n");
+		grammarBuilder.append("KW3818 : 'KW' '3818';\n");
+		grammarBuilder.append("KW3819 : 'KW' '3819';\n");
+		grammarBuilder.append("KW3820 : 'KW' '3820';\n");
+		grammarBuilder.append("KW3821 : 'KW' '3821';\n");
+		grammarBuilder.append("KW3822 : 'KW' '3822';\n");
+		grammarBuilder.append("KW3823 : 'KW' '3823';\n");
+		grammarBuilder.append("KW3824 : 'KW' '3824';\n");
+		grammarBuilder.append("KW3825 : 'KW' '3825';\n");
+		grammarBuilder.append("KW3826 : 'KW' '3826';\n");
+		grammarBuilder.append("KW3827 : 'KW' '3827';\n");
+		grammarBuilder.append("KW3828 : 'KW' '3828';\n");
+		grammarBuilder.append("KW3829 : 'KW' '3829';\n");
+		grammarBuilder.append("KW3830 : 'KW' '3830';\n");
+		grammarBuilder.append("KW3831 : 'KW' '3831';\n");
+		grammarBuilder.append("KW3832 : 'KW' '3832';\n");
+		grammarBuilder.append("KW3833 : 'KW' '3833';\n");
+		grammarBuilder.append("KW3834 : 'KW' '3834';\n");
+		grammarBuilder.append("KW3835 : 'KW' '3835';\n");
+		grammarBuilder.append("KW3836 : 'KW' '3836';\n");
+		grammarBuilder.append("KW3837 : 'KW' '3837';\n");
+		grammarBuilder.append("KW3838 : 'KW' '3838';\n");
+		grammarBuilder.append("KW3839 : 'KW' '3839';\n");
+		grammarBuilder.append("KW3840 : 'KW' '3840';\n");
+		grammarBuilder.append("KW3841 : 'KW' '3841';\n");
+		grammarBuilder.append("KW3842 : 'KW' '3842';\n");
+		grammarBuilder.append("KW3843 : 'KW' '3843';\n");
+		grammarBuilder.append("KW3844 : 'KW' '3844';\n");
+		grammarBuilder.append("KW3845 : 'KW' '3845';\n");
+		grammarBuilder.append("KW3846 : 'KW' '3846';\n");
+		grammarBuilder.append("KW3847 : 'KW' '3847';\n");
+		grammarBuilder.append("KW3848 : 'KW' '3848';\n");
+		grammarBuilder.append("KW3849 : 'KW' '3849';\n");
+		grammarBuilder.append("KW3850 : 'KW' '3850';\n");
+		grammarBuilder.append("KW3851 : 'KW' '3851';\n");
+		grammarBuilder.append("KW3852 : 'KW' '3852';\n");
+		grammarBuilder.append("KW3853 : 'KW' '3853';\n");
+		grammarBuilder.append("KW3854 : 'KW' '3854';\n");
+		grammarBuilder.append("KW3855 : 'KW' '3855';\n");
+		grammarBuilder.append("KW3856 : 'KW' '3856';\n");
+		grammarBuilder.append("KW3857 : 'KW' '3857';\n");
+		grammarBuilder.append("KW3858 : 'KW' '3858';\n");
+		grammarBuilder.append("KW3859 : 'KW' '3859';\n");
+		grammarBuilder.append("KW3860 : 'KW' '3860';\n");
+		grammarBuilder.append("KW3861 : 'KW' '3861';\n");
+		grammarBuilder.append("KW3862 : 'KW' '3862';\n");
+		grammarBuilder.append("KW3863 : 'KW' '3863';\n");
+		grammarBuilder.append("KW3864 : 'KW' '3864';\n");
+		grammarBuilder.append("KW3865 : 'KW' '3865';\n");
+		grammarBuilder.append("KW3866 : 'KW' '3866';\n");
+		grammarBuilder.append("KW3867 : 'KW' '3867';\n");
+		grammarBuilder.append("KW3868 : 'KW' '3868';\n");
+		grammarBuilder.append("KW3869 : 'KW' '3869';\n");
+		grammarBuilder.append("KW3870 : 'KW' '3870';\n");
+		grammarBuilder.append("KW3871 : 'KW' '3871';\n");
+		grammarBuilder.append("KW3872 : 'KW' '3872';\n");
+		grammarBuilder.append("KW3873 : 'KW' '3873';\n");
+		grammarBuilder.append("KW3874 : 'KW' '3874';\n");
+		grammarBuilder.append("KW3875 : 'KW' '3875';\n");
+		grammarBuilder.append("KW3876 : 'KW' '3876';\n");
+		grammarBuilder.append("KW3877 : 'KW' '3877';\n");
+		grammarBuilder.append("KW3878 : 'KW' '3878';\n");
+		grammarBuilder.append("KW3879 : 'KW' '3879';\n");
+		grammarBuilder.append("KW3880 : 'KW' '3880';\n");
+		grammarBuilder.append("KW3881 : 'KW' '3881';\n");
+		grammarBuilder.append("KW3882 : 'KW' '3882';\n");
+		grammarBuilder.append("KW3883 : 'KW' '3883';\n");
+		grammarBuilder.append("KW3884 : 'KW' '3884';\n");
+		grammarBuilder.append("KW3885 : 'KW' '3885';\n");
+		grammarBuilder.append("KW3886 : 'KW' '3886';\n");
+		grammarBuilder.append("KW3887 : 'KW' '3887';\n");
+		grammarBuilder.append("KW3888 : 'KW' '3888';\n");
+		grammarBuilder.append("KW3889 : 'KW' '3889';\n");
+		grammarBuilder.append("KW3890 : 'KW' '3890';\n");
+		grammarBuilder.append("KW3891 : 'KW' '3891';\n");
+		grammarBuilder.append("KW3892 : 'KW' '3892';\n");
+		grammarBuilder.append("KW3893 : 'KW' '3893';\n");
+		grammarBuilder.append("KW3894 : 'KW' '3894';\n");
+		grammarBuilder.append("KW3895 : 'KW' '3895';\n");
+		grammarBuilder.append("KW3896 : 'KW' '3896';\n");
+		grammarBuilder.append("KW3897 : 'KW' '3897';\n");
+		grammarBuilder.append("KW3898 : 'KW' '3898';\n");
+		grammarBuilder.append("KW3899 : 'KW' '3899';\n");
+		grammarBuilder.append("KW3900 : 'KW' '3900';\n");
+		grammarBuilder.append("KW3901 : 'KW' '3901';\n");
+		grammarBuilder.append("KW3902 : 'KW' '3902';\n");
+		grammarBuilder.append("KW3903 : 'KW' '3903';\n");
+		grammarBuilder.append("KW3904 : 'KW' '3904';\n");
+		grammarBuilder.append("KW3905 : 'KW' '3905';\n");
+		grammarBuilder.append("KW3906 : 'KW' '3906';\n");
+		grammarBuilder.append("KW3907 : 'KW' '3907';\n");
+		grammarBuilder.append("KW3908 : 'KW' '3908';\n");
+		grammarBuilder.append("KW3909 : 'KW' '3909';\n");
+		grammarBuilder.append("KW3910 : 'KW' '3910';\n");
+		grammarBuilder.append("KW3911 : 'KW' '3911';\n");
+		grammarBuilder.append("KW3912 : 'KW' '3912';\n");
+		grammarBuilder.append("KW3913 : 'KW' '3913';\n");
+		grammarBuilder.append("KW3914 : 'KW' '3914';\n");
+		grammarBuilder.append("KW3915 : 'KW' '3915';\n");
+		grammarBuilder.append("KW3916 : 'KW' '3916';\n");
+		grammarBuilder.append("KW3917 : 'KW' '3917';\n");
+		grammarBuilder.append("KW3918 : 'KW' '3918';\n");
+		grammarBuilder.append("KW3919 : 'KW' '3919';\n");
+		grammarBuilder.append("KW3920 : 'KW' '3920';\n");
+		grammarBuilder.append("KW3921 : 'KW' '3921';\n");
+		grammarBuilder.append("KW3922 : 'KW' '3922';\n");
+		grammarBuilder.append("KW3923 : 'KW' '3923';\n");
+		grammarBuilder.append("KW3924 : 'KW' '3924';\n");
+		grammarBuilder.append("KW3925 : 'KW' '3925';\n");
+		grammarBuilder.append("KW3926 : 'KW' '3926';\n");
+		grammarBuilder.append("KW3927 : 'KW' '3927';\n");
+		grammarBuilder.append("KW3928 : 'KW' '3928';\n");
+		grammarBuilder.append("KW3929 : 'KW' '3929';\n");
+		grammarBuilder.append("KW3930 : 'KW' '3930';\n");
+		grammarBuilder.append("KW3931 : 'KW' '3931';\n");
+		grammarBuilder.append("KW3932 : 'KW' '3932';\n");
+		grammarBuilder.append("KW3933 : 'KW' '3933';\n");
+		grammarBuilder.append("KW3934 : 'KW' '3934';\n");
+		grammarBuilder.append("KW3935 : 'KW' '3935';\n");
+		grammarBuilder.append("KW3936 : 'KW' '3936';\n");
+		grammarBuilder.append("KW3937 : 'KW' '3937';\n");
+		grammarBuilder.append("KW3938 : 'KW' '3938';\n");
+		grammarBuilder.append("KW3939 : 'KW' '3939';\n");
+		grammarBuilder.append("KW3940 : 'KW' '3940';\n");
+		grammarBuilder.append("KW3941 : 'KW' '3941';\n");
+		grammarBuilder.append("KW3942 : 'KW' '3942';\n");
+		grammarBuilder.append("KW3943 : 'KW' '3943';\n");
+		grammarBuilder.append("KW3944 : 'KW' '3944';\n");
+		grammarBuilder.append("KW3945 : 'KW' '3945';\n");
+		grammarBuilder.append("KW3946 : 'KW' '3946';\n");
+		grammarBuilder.append("KW3947 : 'KW' '3947';\n");
+		grammarBuilder.append("KW3948 : 'KW' '3948';\n");
+		grammarBuilder.append("KW3949 : 'KW' '3949';\n");
+		grammarBuilder.append("KW3950 : 'KW' '3950';\n");
+		grammarBuilder.append("KW3951 : 'KW' '3951';\n");
+		grammarBuilder.append("KW3952 : 'KW' '3952';\n");
+		grammarBuilder.append("KW3953 : 'KW' '3953';\n");
+		grammarBuilder.append("KW3954 : 'KW' '3954';\n");
+		grammarBuilder.append("KW3955 : 'KW' '3955';\n");
+		grammarBuilder.append("KW3956 : 'KW' '3956';\n");
+		grammarBuilder.append("KW3957 : 'KW' '3957';\n");
+		grammarBuilder.append("KW3958 : 'KW' '3958';\n");
+		grammarBuilder.append("KW3959 : 'KW' '3959';\n");
+		grammarBuilder.append("KW3960 : 'KW' '3960';\n");
+		grammarBuilder.append("KW3961 : 'KW' '3961';\n");
+		grammarBuilder.append("KW3962 : 'KW' '3962';\n");
+		grammarBuilder.append("KW3963 : 'KW' '3963';\n");
+		grammarBuilder.append("KW3964 : 'KW' '3964';\n");
+		grammarBuilder.append("KW3965 : 'KW' '3965';\n");
+		grammarBuilder.append("KW3966 : 'KW' '3966';\n");
+		grammarBuilder.append("KW3967 : 'KW' '3967';\n");
+		grammarBuilder.append("KW3968 : 'KW' '3968';\n");
+		grammarBuilder.append("KW3969 : 'KW' '3969';\n");
+		grammarBuilder.append("KW3970 : 'KW' '3970';\n");
+		grammarBuilder.append("KW3971 : 'KW' '3971';\n");
+		grammarBuilder.append("KW3972 : 'KW' '3972';\n");
+		grammarBuilder.append("KW3973 : 'KW' '3973';\n");
+		grammarBuilder.append("KW3974 : 'KW' '3974';\n");
+		grammarBuilder.append("KW3975 : 'KW' '3975';\n");
+		grammarBuilder.append("KW3976 : 'KW' '3976';\n");
+		grammarBuilder.append("KW3977 : 'KW' '3977';\n");
+		grammarBuilder.append("KW3978 : 'KW' '3978';\n");
+		grammarBuilder.append("KW3979 : 'KW' '3979';\n");
+		grammarBuilder.append("KW3980 : 'KW' '3980';\n");
+		grammarBuilder.append("KW3981 : 'KW' '3981';\n");
+		grammarBuilder.append("KW3982 : 'KW' '3982';\n");
+		grammarBuilder.append("KW3983 : 'KW' '3983';\n");
+		grammarBuilder.append("KW3984 : 'KW' '3984';\n");
+		grammarBuilder.append("KW3985 : 'KW' '3985';\n");
+		grammarBuilder.append("KW3986 : 'KW' '3986';\n");
+		grammarBuilder.append("KW3987 : 'KW' '3987';\n");
+		grammarBuilder.append("KW3988 : 'KW' '3988';\n");
+		grammarBuilder.append("KW3989 : 'KW' '3989';\n");
+		grammarBuilder.append("KW3990 : 'KW' '3990';\n");
+		grammarBuilder.append("KW3991 : 'KW' '3991';\n");
+		grammarBuilder.append("KW3992 : 'KW' '3992';\n");
+		grammarBuilder.append("KW3993 : 'KW' '3993';\n");
+		grammarBuilder.append("KW3994 : 'KW' '3994';\n");
+		grammarBuilder.append("KW3995 : 'KW' '3995';\n");
+		grammarBuilder.append("KW3996 : 'KW' '3996';\n");
+		grammarBuilder.append("KW3997 : 'KW' '3997';\n");
+		grammarBuilder.append("KW3998 : 'KW' '3998';\n");
+		grammarBuilder.append("KW3999 : 'KW' '3999';");
+		String grammar = grammarBuilder.toString();
+		String input ="KW400";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:4='KW400',<402>,1:0]\n" +
+			"[@1,5:4='<EOF>',<-1>,1:5]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNonGreedyClosure() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(61);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("CMT : '//' .*? '\\n' CMT*?;\n");
+		grammarBuilder.append("WS : (' '|'\\t')+;");
+		String grammar = grammarBuilder.toString();
+		String input =
+			"//blah\n" +
+			"//blah\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:6='//blah\\n',<1>,1:0]\n" +
+			"[@1,7:13='//blah\\n',<1>,2:0]\n" +
+			"[@2,14:13='<EOF>',<-1>,3:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNonGreedyConfigs() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(136);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("I : .*? ('a' | 'ab') {Console.WriteLine(this.Text);} ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;\n");
+		grammarBuilder.append("J : . {Console.WriteLine(this.Text);};");
+		String grammar = grammarBuilder.toString();
+		String input ="ab";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"a\n" +
+			"b\n" +
+			"[@0,0:0='a',<1>,1:0]\n" +
+			"[@1,1:1='b',<3>,1:1]\n" +
+			"[@2,2:1='<EOF>',<-1>,1:2]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNonGreedyOptional() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(61);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("CMT : '//' .*? '\\n' CMT??;\n");
+		grammarBuilder.append("WS : (' '|'\\t')+;");
+		String grammar = grammarBuilder.toString();
+		String input =
+			"//blah\n" +
+			"//blah\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:6='//blah\\n',<1>,1:0]\n" +
+			"[@1,7:13='//blah\\n',<1>,2:0]\n" +
+			"[@2,14:13='<EOF>',<-1>,3:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNonGreedyPositiveClosure() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(59);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("CMT : ('//' .*? '\\n')+?;\n");
+		grammarBuilder.append("WS : (' '|'\\t')+;");
+		String grammar = grammarBuilder.toString();
+		String input =
+			"//blah\n" +
+			"//blah\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:6='//blah\\n',<1>,1:0]\n" +
+			"[@1,7:13='//blah\\n',<1>,2:0]\n" +
+			"[@2,14:13='<EOF>',<-1>,3:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNonGreedyTermination1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(47);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("STRING : '\"' ('\"\"' | .)*? '\"';");
+		String grammar = grammarBuilder.toString();
+		String input ="\"hi\"\"mom\"";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:3='\"hi\"',<1>,1:0]\n" +
+			"[@1,4:8='\"mom\"',<1>,1:4]\n" +
+			"[@2,9:8='<EOF>',<-1>,1:9]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNonGreedyTermination2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(47);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("STRING : '\"' ('\"\"' | .)+? '\"';");
+		String grammar = grammarBuilder.toString();
+		String input ="\"\"\"mom\"";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:6='\"\"\"mom\"',<1>,1:0]\n" +
+			"[@1,7:6='<EOF>',<-1>,1:7]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testParentheses() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(166);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("START_BLOCK: '-.-.-';\n");
+		grammarBuilder.append("ID : (LETTER SEPARATOR) (LETTER SEPARATOR)+;\n");
+		grammarBuilder.append("fragment LETTER: L_A|L_K;\n");
+		grammarBuilder.append("fragment L_A: '.-';\n");
+		grammarBuilder.append("fragment L_K: '-.-';\n");
+		grammarBuilder.append("SEPARATOR: '!';");
+		String grammar = grammarBuilder.toString();
+		String input ="-.-.-!";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:4='-.-.-',<1>,1:0]\n" +
+			"[@1,5:5='!',<3>,1:5]\n" +
+			"[@2,6:5='<EOF>',<-1>,1:6]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPositionAdjustingLexer() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(2208);
+		grammarBuilder.append("lexer grammar PositionAdjustingLexer;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("@members {\n");
+		grammarBuilder.append("public override IToken NextToken() {\n");
+		grammarBuilder.append("	if (!(Interpreter is PositionAdjustingLexerATNSimulator)) {\n");
+		grammarBuilder.append("		Interpreter = new PositionAdjustingLexerATNSimulator(this, _ATN);\n");
+		grammarBuilder.append("	}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("	return base.NextToken();\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("public override IToken Emit() {\n");
+		grammarBuilder.append("	switch (Type) {\n");
+		grammarBuilder.append("	case TOKENS:\n");
+		grammarBuilder.append("		HandleAcceptPositionForKeyword(\"tokens\");\n");
+		grammarBuilder.append("		break;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("	case LABEL:\n");
+		grammarBuilder.append("		HandleAcceptPositionForIdentifier();\n");
+		grammarBuilder.append("		break;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("	default:\n");
+		grammarBuilder.append("		break;\n");
+		grammarBuilder.append("	}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("	return base.Emit();\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("private bool HandleAcceptPositionForIdentifier() {\n");
+		grammarBuilder.append("	string tokenText = this.Text;\n");
+		grammarBuilder.append("	int identifierLength = 0;\n");
+		grammarBuilder.append("	while (identifierLength < tokenText.Length && IsIdentifierChar(tokenText[identifierLength])) {\n");
+		grammarBuilder.append("		identifierLength++;\n");
+		grammarBuilder.append("	}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("	if (InputStream.Index > TokenStartCharIndex + identifierLength) {\n");
+		grammarBuilder.append("		int offset = identifierLength - 1;\n");
+		grammarBuilder.append("		getInterpreter().ResetAcceptPosition((ICharStream)InputStream, TokenStartCharIndex + offset, TokenStartLine, TokenStartColumn + offset);\n");
+		grammarBuilder.append("		return true;\n");
+		grammarBuilder.append("	}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("	return false;\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("private bool HandleAcceptPositionForKeyword(string keyword) {\n");
+		grammarBuilder.append("	if (InputStream.Index > TokenStartCharIndex + keyword.Length) {\n");
+		grammarBuilder.append("		int offset = keyword.Length - 1;\n");
+		grammarBuilder.append("		getInterpreter().ResetAcceptPosition((ICharStream)InputStream, TokenStartCharIndex + offset, TokenStartLine, TokenStartColumn + offset);\n");
+		grammarBuilder.append("		return true;\n");
+		grammarBuilder.append("	}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("	return false;\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("public PositionAdjustingLexerATNSimulator getInterpreter() {\n");
+		grammarBuilder.append("	return (PositionAdjustingLexerATNSimulator)base.Interpreter;\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("private static bool IsIdentifierChar(char c) {\n");
+		grammarBuilder.append("	return Char.IsLetterOrDigit(c) || c == '_';\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("public class PositionAdjustingLexerATNSimulator : LexerATNSimulator {\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("	public PositionAdjustingLexerATNSimulator(Lexer recog, ATN atn)\n");
+		grammarBuilder.append("	: base(recog, atn)\n");
+		grammarBuilder.append("	{\n");
+		grammarBuilder.append("	}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("	public void ResetAcceptPosition(ICharStream input, int index, int line, int column) {\n");
+		grammarBuilder.append("		input.Seek(index);\n");
+		grammarBuilder.append("		this.Line = line;\n");
+		grammarBuilder.append("		this.Column = column;\n");
+		grammarBuilder.append("		Consume(input);\n");
+		grammarBuilder.append("	}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("ASSIGN : '=' ;\n");
+		grammarBuilder.append("PLUS_ASSIGN : '+=' ;\n");
+		grammarBuilder.append("LCURLY:	'{';\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("// 'tokens' followed by '{'\n");
+		grammarBuilder.append("TOKENS : 'tokens' IGNORED '{';\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("// IDENTIFIER followed by '+=' or '='\n");
+		grammarBuilder.append("LABEL\n");
+		grammarBuilder.append("	:	IDENTIFIER IGNORED '+'? '='\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("IDENTIFIER\n");
+		grammarBuilder.append("	:	[a-zA-Z_] [a-zA-Z0-9_]*\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("fragment\n");
+		grammarBuilder.append("IGNORED\n");
+		grammarBuilder.append("	:	[ \\t\\r\\n]*\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("NEWLINE\n");
+		grammarBuilder.append("	:	[\\r\\n]+ -> skip\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("WS\n");
+		grammarBuilder.append("	:	[ \\t]+ -> skip\n");
+		grammarBuilder.append("	;");
+		String grammar = grammarBuilder.toString();
+		String input =
+			"tokens\n" +
+			"tokens {\n" +
+			"notLabel\n" +
+			"label1 =\n" +
+			"label2 +=\n" +
+			"notLabel\n";
+		String found = execLexer("PositionAdjustingLexer.g4", grammar, "PositionAdjustingLexer", input, false);
+		assertEquals(
+			"[@0,0:5='tokens',<6>,1:0]\n" +
+			"[@1,7:12='tokens',<4>,2:0]\n" +
+			"[@2,14:14='{',<3>,2:7]\n" +
+			"[@3,16:23='notLabel',<6>,3:0]\n" +
+			"[@4,25:30='label1',<5>,4:0]\n" +
+			"[@5,32:32='=',<1>,4:7]\n" +
+			"[@6,34:39='label2',<5>,5:0]\n" +
+			"[@7,41:42='+=',<2>,5:7]\n" +
+			"[@8,44:51='notLabel',<6>,6:0]\n" +
+			"[@9,53:52='<EOF>',<-1>,7:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testQuoteTranslation() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(57);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("QUOTE : '\"' ; // make sure this compiles");
+		String grammar = grammarBuilder.toString();
+		String input ="\"";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:0='\"',<1>,1:0]\n" +
+			"[@1,1:0='<EOF>',<-1>,1:1]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testRecursiveLexerRuleRefWithWildcardPlus_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(64);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("CMT : '/*' (CMT | .)+? '*/' ;\n");
+		grammarBuilder.append("WS : (' '|'\\n')+;");
+		String grammar = grammarBuilder.toString();
+		String input =
+			"/* ick */\n" +
+			"/* /* */\n" +
+			"/* /*nested*/ */\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:8='/* ick */',<1>,1:0]\n" +
+			"[@1,9:9='\\n',<2>,1:9]\n" +
+			"[@2,10:34='/* /* */\\n/* /*nested*/ */',<1>,2:0]\n" +
+			"[@3,35:35='\\n',<2>,3:16]\n" +
+			"[@4,36:35='<EOF>',<-1>,4:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testRecursiveLexerRuleRefWithWildcardPlus_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(64);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("CMT : '/*' (CMT | .)+? '*/' ;\n");
+		grammarBuilder.append("WS : (' '|'\\n')+;");
+		String grammar = grammarBuilder.toString();
+		String input =
+			"/* ick */x\n" +
+			"/* /* */x\n" +
+			"/* /*nested*/ */x\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:8='/* ick */',<1>,1:0]\n" +
+			"[@1,10:10='\\n',<2>,1:10]\n" +
+			"[@2,11:36='/* /* */x\\n/* /*nested*/ */',<1>,2:0]\n" +
+			"[@3,38:38='\\n',<2>,3:17]\n" +
+			"[@4,39:38='<EOF>',<-1>,4:0]\n", found);
+
+		assertEquals(
+			"line 1:9 token recognition error at: 'x'\n" +
+			"line 3:16 token recognition error at: 'x'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testRecursiveLexerRuleRefWithWildcardStar_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(64);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("CMT : '/*' (CMT | .)*? '*/' ;\n");
+		grammarBuilder.append("WS : (' '|'\\n')+;");
+		String grammar = grammarBuilder.toString();
+		String input =
+			"/* ick */\n" +
+			"/* /* */\n" +
+			"/* /*nested*/ */\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:8='/* ick */',<1>,1:0]\n" +
+			"[@1,9:9='\\n',<2>,1:9]\n" +
+			"[@2,10:34='/* /* */\\n/* /*nested*/ */',<1>,2:0]\n" +
+			"[@3,35:35='\\n',<2>,3:16]\n" +
+			"[@4,36:35='<EOF>',<-1>,4:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testRecursiveLexerRuleRefWithWildcardStar_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(64);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("CMT : '/*' (CMT | .)*? '*/' ;\n");
+		grammarBuilder.append("WS : (' '|'\\n')+;");
+		String grammar = grammarBuilder.toString();
+		String input =
+			"/* ick */x\n" +
+			"/* /* */x\n" +
+			"/* /*nested*/ */x\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:8='/* ick */',<1>,1:0]\n" +
+			"[@1,10:10='\\n',<2>,1:10]\n" +
+			"[@2,11:36='/* /* */x\\n/* /*nested*/ */',<1>,2:0]\n" +
+			"[@3,38:38='\\n',<2>,3:17]\n" +
+			"[@4,39:38='<EOF>',<-1>,4:0]\n", found);
+
+		assertEquals(
+			"line 1:9 token recognition error at: 'x'\n" +
+			"line 3:16 token recognition error at: 'x'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testRefToRuleDoesNotSetTokenNorEmitAnother() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(70);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : '-' I ;\n");
+		grammarBuilder.append("I : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="34 -21 3";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:1='34',<2>,1:0]\n" +
+			"[@1,3:5='-21',<1>,1:3]\n" +
+			"[@2,7:7='3',<2>,1:7]\n" +
+			"[@3,8:7='<EOF>',<-1>,1:8]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSlashes() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(95);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("Backslash : '\\\\';\n");
+		grammarBuilder.append("Slash : '/';\n");
+		grammarBuilder.append("Vee : '\\\\/';\n");
+		grammarBuilder.append("Wedge : '/\\\\';\n");
+		grammarBuilder.append("WS : [ \\t] -> skip;");
+		String grammar = grammarBuilder.toString();
+		String input ="\\ / \\/ /\\";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:0='\\',<1>,1:0]\n" +
+			"[@1,2:2='/',<2>,1:2]\n" +
+			"[@2,4:5='\\/',<3>,1:4]\n" +
+			"[@3,7:8='/\\',<4>,1:7]\n" +
+			"[@4,9:8='<EOF>',<-1>,1:9]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testZeroLengthToken() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(215);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("BeginString\n");
+		grammarBuilder.append("	:	'\\'' -> more, pushMode(StringMode)\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("mode StringMode;\n");
+		grammarBuilder.append("	StringMode_X : 'x' -> more;\n");
+		grammarBuilder.append("	StringMode_Done : -> more, mode(EndStringMode);\n");
+		grammarBuilder.append("mode EndStringMode;	\n");
+		grammarBuilder.append("	EndString : '\\'' -> popMode;");
+		String grammar = grammarBuilder.toString();
+		String input ="'xxx'";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:4=''xxx'',<1>,1:0]\n" +
+			"[@1,5:4='<EOF>',<-1>,1:5]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+}
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/csharp/TestListeners.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/csharp/TestListeners.java
new file mode 100644
index 000000000..7f5d4d829
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/csharp/TestListeners.java
@@ -0,0 +1,351 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.csharp;
+
+import org.junit.Test;
+import org.junit.Ignore;
+
+@SuppressWarnings("unused")
+public class TestListeners extends BaseTest {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testBasic() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(458);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@parser::header {\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("@parser::members {\n");
+		grammarBuilder.append("public class LeafListener : TBaseListener {\n");
+		grammarBuilder.append("	public override void VisitTerminal(ITerminalNode node) {\n");
+		grammarBuilder.append("		Console.WriteLine(node.Symbol.Text);\n");
+		grammarBuilder.append("	}\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("Console.WriteLine($ctx.r.ToStringTree(this));\n");
+		grammarBuilder.append("ParseTreeWalker walker = new ParseTreeWalker();\n");
+		grammarBuilder.append("walker.Walk(new LeafListener(), $ctx.r);\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : INT INT\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("MULT: '*' ;\n");
+		grammarBuilder.append("ADD : '+' ;\n");
+		grammarBuilder.append("INT : [0-9]+ ;\n");
+		grammarBuilder.append("ID  : [a-z]+ ;\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="1 2";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals(
+			"(a 1 2)\n" +
+			"1\n" +
+			"2\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLR() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(612);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@parser::header {\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("@parser::members {\n");
+		grammarBuilder.append("public class LeafListener : TBaseListener {\n");
+		grammarBuilder.append("	public override void ExitE(TParser.EContext ctx) {\n");
+		grammarBuilder.append("		if (ctx.ChildCount==3) {\n");
+		grammarBuilder.append("			Console.Write(\"{0} {1} {2}\\n\",ctx.e(0).Start.Text,\n");
+		grammarBuilder.append("				ctx.e(1).Start.Text, ctx.e()[0].Start.Text);\n");
+		grammarBuilder.append("		} else\n");
+		grammarBuilder.append("			Console.WriteLine(ctx.INT().Symbol.Text);\n");
+		grammarBuilder.append("	}\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("Console.WriteLine($ctx.r.ToStringTree(this));\n");
+		grammarBuilder.append("ParseTreeWalker walker = new ParseTreeWalker();\n");
+		grammarBuilder.append("walker.Walk(new LeafListener(), $ctx.r);\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("	: r=e ;\n");
+		grammarBuilder.append("e : e op='*' e\n");
+		grammarBuilder.append("	| e op='+' e\n");
+		grammarBuilder.append("	| INT\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("MULT: '*' ;\n");
+		grammarBuilder.append("ADD : '+' ;\n");
+		grammarBuilder.append("INT : [0-9]+ ;\n");
+		grammarBuilder.append("ID  : [a-z]+ ;\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="1+2*3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals(
+			"(e (e 1) + (e (e 2) * (e 3)))\n" +
+			"1\n" +
+			"2\n" +
+			"3\n" +
+			"2 3 2\n" +
+			"1 2 1\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLRWithLabels() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(636);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@parser::header {\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("@parser::members {\n");
+		grammarBuilder.append("public class LeafListener : TBaseListener {\n");
+		grammarBuilder.append("	public override void ExitCall(TParser.CallContext ctx) {\n");
+		grammarBuilder.append("		Console.Write(\"{0} {1}\",ctx.e().Start.Text,ctx.eList());\n");
+		grammarBuilder.append("	}\n");
+		grammarBuilder.append("	public override void ExitInt(TParser.IntContext ctx) {\n");
+		grammarBuilder.append("		Console.WriteLine(ctx.INT().Symbol.Text);\n");
+		grammarBuilder.append("	}\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("Console.WriteLine($ctx.r.ToStringTree(this));\n");
+		grammarBuilder.append("ParseTreeWalker walker = new ParseTreeWalker();\n");
+		grammarBuilder.append("walker.Walk(new LeafListener(), $ctx.r);\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=e ;\n");
+		grammarBuilder.append("e : e '(' eList ')' # Call\n");
+		grammarBuilder.append("  | INT             # Int\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("eList : e (',' e)* ;\n");
+		grammarBuilder.append("MULT: '*' ;\n");
+		grammarBuilder.append("ADD : '+' ;\n");
+		grammarBuilder.append("INT : [0-9]+ ;\n");
+		grammarBuilder.append("ID  : [a-z]+ ;\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="1(2,3)";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals(
+			"(e (e 1) ( (eList (e 2) , (e 3)) ))\n" +
+			"1\n" +
+			"2\n" +
+			"3\n" +
+			"1 [13 6]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testRuleGetters_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(634);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@parser::header {\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("@parser::members {\n");
+		grammarBuilder.append("public class LeafListener : TBaseListener {\n");
+		grammarBuilder.append("	public override void ExitA(TParser.AContext ctx) {\n");
+		grammarBuilder.append("		if (ctx.ChildCount==2) {\n");
+		grammarBuilder.append("			Console.Write(\"{0} {1} {2}\",ctx.b(0).Start.Text,\n");
+		grammarBuilder.append("				ctx.b(1).Start.Text,ctx.b()[0].Start.Text);\n");
+		grammarBuilder.append("		} else\n");
+		grammarBuilder.append("			Console.WriteLine(ctx.b(0).Start.Text);\n");
+		grammarBuilder.append("	}\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("Console.WriteLine($ctx.r.ToStringTree(this));\n");
+		grammarBuilder.append("ParseTreeWalker walker = new ParseTreeWalker();\n");
+		grammarBuilder.append("walker.Walk(new LeafListener(), $ctx.r);\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : b b		// forces list\n");
+		grammarBuilder.append("  | b		// a list still\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("b : ID | INT;\n");
+		grammarBuilder.append("MULT: '*' ;\n");
+		grammarBuilder.append("ADD : '+' ;\n");
+		grammarBuilder.append("INT : [0-9]+ ;\n");
+		grammarBuilder.append("ID  : [a-z]+ ;\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="1 2";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals(
+			"(a (b 1) (b 2))\n" +
+			"1 2 1\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testRuleGetters_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(634);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@parser::header {\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("@parser::members {\n");
+		grammarBuilder.append("public class LeafListener : TBaseListener {\n");
+		grammarBuilder.append("	public override void ExitA(TParser.AContext ctx) {\n");
+		grammarBuilder.append("		if (ctx.ChildCount==2) {\n");
+		grammarBuilder.append("			Console.Write(\"{0} {1} {2}\",ctx.b(0).Start.Text,\n");
+		grammarBuilder.append("				ctx.b(1).Start.Text,ctx.b()[0].Start.Text);\n");
+		grammarBuilder.append("		} else\n");
+		grammarBuilder.append("			Console.WriteLine(ctx.b(0).Start.Text);\n");
+		grammarBuilder.append("	}\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("Console.WriteLine($ctx.r.ToStringTree(this));\n");
+		grammarBuilder.append("ParseTreeWalker walker = new ParseTreeWalker();\n");
+		grammarBuilder.append("walker.Walk(new LeafListener(), $ctx.r);\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : b b		// forces list\n");
+		grammarBuilder.append("  | b		// a list still\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("b : ID | INT;\n");
+		grammarBuilder.append("MULT: '*' ;\n");
+		grammarBuilder.append("ADD : '+' ;\n");
+		grammarBuilder.append("INT : [0-9]+ ;\n");
+		grammarBuilder.append("ID  : [a-z]+ ;\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="abc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals(
+			"(a (b abc))\n" +
+			"abc\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTokenGetters_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(801);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@parser::header {\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("@parser::members {\n");
+		grammarBuilder.append("public class LeafListener : TBaseListener {\n");
+		grammarBuilder.append("	public override void ExitA(TParser.AContext ctx) {\n");
+		grammarBuilder.append("		if (ctx.ChildCount==2)\n");
+		grammarBuilder.append("		{\n");
+		grammarBuilder.append("			StringBuilder sb = new StringBuilder (\"[\");\n");
+		grammarBuilder.append("			foreach (ITerminalNode node in ctx.INT ()) {\n");
+		grammarBuilder.append("				sb.Append (node.ToString ());\n");
+		grammarBuilder.append("				sb.Append (\", \");\n");
+		grammarBuilder.append("			}\n");
+		grammarBuilder.append("			sb.Length = sb.Length - 2;\n");
+		grammarBuilder.append("			sb.Append (\"]\");\n");
+		grammarBuilder.append("			Console.Write (\"{0} {1} {2}\", ctx.INT (0).Symbol.Text,\n");
+		grammarBuilder.append("				ctx.INT (1).Symbol.Text, sb.ToString());\n");
+		grammarBuilder.append("		}\n");
+		grammarBuilder.append("		else\n");
+		grammarBuilder.append("			Console.WriteLine(ctx.ID().Symbol);\n");
+		grammarBuilder.append("	}\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("Console.WriteLine($ctx.r.ToStringTree(this));\n");
+		grammarBuilder.append("ParseTreeWalker walker = new ParseTreeWalker();\n");
+		grammarBuilder.append("walker.Walk(new LeafListener(), $ctx.r);\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : INT INT\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("MULT: '*' ;\n");
+		grammarBuilder.append("ADD : '+' ;\n");
+		grammarBuilder.append("INT : [0-9]+ ;\n");
+		grammarBuilder.append("ID  : [a-z]+ ;\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="1 2";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals(
+			"(a 1 2)\n" +
+			"1 2 [1, 2]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTokenGetters_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(801);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@parser::header {\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("@parser::members {\n");
+		grammarBuilder.append("public class LeafListener : TBaseListener {\n");
+		grammarBuilder.append("	public override void ExitA(TParser.AContext ctx) {\n");
+		grammarBuilder.append("		if (ctx.ChildCount==2)\n");
+		grammarBuilder.append("		{\n");
+		grammarBuilder.append("			StringBuilder sb = new StringBuilder (\"[\");\n");
+		grammarBuilder.append("			foreach (ITerminalNode node in ctx.INT ()) {\n");
+		grammarBuilder.append("				sb.Append (node.ToString ());\n");
+		grammarBuilder.append("				sb.Append (\", \");\n");
+		grammarBuilder.append("			}\n");
+		grammarBuilder.append("			sb.Length = sb.Length - 2;\n");
+		grammarBuilder.append("			sb.Append (\"]\");\n");
+		grammarBuilder.append("			Console.Write (\"{0} {1} {2}\", ctx.INT (0).Symbol.Text,\n");
+		grammarBuilder.append("				ctx.INT (1).Symbol.Text, sb.ToString());\n");
+		grammarBuilder.append("		}\n");
+		grammarBuilder.append("		else\n");
+		grammarBuilder.append("			Console.WriteLine(ctx.ID().Symbol);\n");
+		grammarBuilder.append("	}\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("Console.WriteLine($ctx.r.ToStringTree(this));\n");
+		grammarBuilder.append("ParseTreeWalker walker = new ParseTreeWalker();\n");
+		grammarBuilder.append("walker.Walk(new LeafListener(), $ctx.r);\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : INT INT\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("MULT: '*' ;\n");
+		grammarBuilder.append("ADD : '+' ;\n");
+		grammarBuilder.append("INT : [0-9]+ ;\n");
+		grammarBuilder.append("ID  : [a-z]+ ;\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="abc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals(
+			"(a abc)\n" +
+			"[@0,0:2='abc',<4>,1:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+}
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/csharp/TestParseTrees.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/csharp/TestParseTrees.java
new file mode 100644
index 000000000..3ff7bb4e1
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/csharp/TestParseTrees.java
@@ -0,0 +1,253 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.csharp;
+
+import org.junit.Test;
+
+@SuppressWarnings("unused")
+public class TestParseTrees extends BaseTest {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void test2AltLoop() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(142);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {\n");
+		grammarBuilder.append("this.BuildParseTree = true;\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("Console.WriteLine($r.ctx.ToStringTree(this));\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : ('x' | 'y')* 'z'\n");
+		grammarBuilder.append("  ;");
+		String grammar = grammarBuilder.toString();
+		String input ="xyyxyxz";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(a x y y x y x z)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void test2Alts() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(135);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {\n");
+		grammarBuilder.append("this.BuildParseTree = true;\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("Console.WriteLine($r.ctx.ToStringTree(this));\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : 'x' | 'y'\n");
+		grammarBuilder.append("  ;");
+		String grammar = grammarBuilder.toString();
+		String input ="y";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(a y)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAltNum() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(547);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("options { contextSuperClass=MyRuleNode; }\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("@parser::members {\n");
+		grammarBuilder.append("public class MyRuleNode : ParserRuleContext {\n");
+		grammarBuilder.append("	public int altNum;\n");
+		grammarBuilder.append("	public MyRuleNode(ParserRuleContext parent, int invokingStateNumber): base(parent, invokingStateNumber)\n");
+		grammarBuilder.append("	{\n");
+		grammarBuilder.append("	}\n");
+		grammarBuilder.append("	public override int getAltNumber() { return altNum; }\n");
+		grammarBuilder.append("	public override void setAltNumber(int altNum) { this.altNum = altNum; }\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {\n");
+		grammarBuilder.append("this.BuildParseTree = true;\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("Console.WriteLine($r.ctx.ToStringTree(this));\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("a : 'f'\n");
+		grammarBuilder.append("  | 'g'\n");
+		grammarBuilder.append("  | 'x' b 'z'\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("b : 'e' {} | 'y'\n");
+		grammarBuilder.append("  ;");
+		String grammar = grammarBuilder.toString();
+		String input ="xyz";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(a:3 x (b:2 y) z)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExtraToken() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(148);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {\n");
+		grammarBuilder.append("this.BuildParseTree = true;\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("Console.WriteLine($r.ctx.ToStringTree(this));\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : 'x' 'y'\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("Z : 'z' \n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append(" ");
+		String grammar = grammarBuilder.toString();
+		String input ="xzy";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(a x z y)\n", found);
+
+		assertEquals("line 1:1 extraneous input 'z' expecting 'y'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNoViableAlt() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(150);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {\n");
+		grammarBuilder.append("this.BuildParseTree = true;\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("Console.WriteLine($r.ctx.ToStringTree(this));\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : 'x' | 'y'\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("Z : 'z' \n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append(" ");
+		String grammar = grammarBuilder.toString();
+		String input ="z";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(a z)\n", found);
+
+		assertEquals("line 1:0 mismatched input 'z' expecting {'x', 'y'}\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testRuleRef() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(144);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {\n");
+		grammarBuilder.append("this.BuildParseTree = true;\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("Console.WriteLine($r.ctx.ToStringTree(this));\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : b 'x'\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("b : 'y' \n");
+		grammarBuilder.append("  ;");
+		String grammar = grammarBuilder.toString();
+		String input ="yx";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(a (b y) x)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSync() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(151);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {\n");
+		grammarBuilder.append("this.BuildParseTree = true;\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("Console.WriteLine($r.ctx.ToStringTree(this));\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : 'x' 'y'* '!'\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("Z : 'z' \n");
+		grammarBuilder.append("  ;");
+		String grammar = grammarBuilder.toString();
+		String input ="xzyy!";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(a x z y y !)\n", found);
+
+		assertEquals("line 1:1 extraneous input 'z' expecting {'y', '!'}\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testToken2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(133);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {\n");
+		grammarBuilder.append("this.BuildParseTree = true;\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("Console.WriteLine($r.ctx.ToStringTree(this));\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : 'x' 'y'\n");
+		grammarBuilder.append("  ;");
+		String grammar = grammarBuilder.toString();
+		String input ="xy";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(a x y)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTokenAndRuleContextString() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(185);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {\n");
+		grammarBuilder.append("this.BuildParseTree = true;\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("Console.WriteLine($r.ctx.ToStringTree(this));\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : 'x' { \n");
+		grammarBuilder.append("Console.WriteLine(GetRuleInvocationStackAsString());\n");
+		grammarBuilder.append("} ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals(
+			"[a, s]\n" +
+			"(a x)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+}
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/csharp/TestParserErrors.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/csharp/TestParserErrors.java
new file mode 100644
index 000000000..6abff096b
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/csharp/TestParserErrors.java
@@ -0,0 +1,558 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.csharp;
+
+import org.junit.Test;
+import org.junit.Ignore;
+
+@SuppressWarnings("unused")
+public class TestParserErrors extends BaseTest {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testConjuringUpToken() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(69);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' x='b' {Console.WriteLine(\"conjured=\" + $x);} 'c' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="ac";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("conjured=[@-1,-1:-1='<missing 'b'>',<2>,1:1]\n", found);
+
+		assertEquals("line 1:1 missing 'b' at 'c'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testConjuringUpTokenFromSet() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(75);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' x=('b'|'c') {Console.WriteLine(\"conjured=\" + $x);} 'd' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="ad";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("conjured=[@-1,-1:-1='<missing 'b'>',<2>,1:1]\n", found);
+
+		assertEquals("line 1:1 missing {'b', 'c'} at 'd'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testContextListGetters() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(187);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@parser::members{\n");
+		grammarBuilder.append("void foo() {\n");
+		grammarBuilder.append("	SContext s = null;\n");
+		grammarBuilder.append("	AContext[] a = s.a();\n");
+		grammarBuilder.append("	BContext[] b = s.b();\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("s : (a | b)+;\n");
+		grammarBuilder.append("a : 'a' {Console.Write('a');};\n");
+		grammarBuilder.append("b : 'b' {Console.Write('b');};");
+		String grammar = grammarBuilder.toString();
+		String input ="abab";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, true);
+		assertEquals("abab\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDuplicatedLeftRecursiveCall_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(63);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : expr EOF;\n");
+		grammarBuilder.append("expr : 'x'\n");
+		grammarBuilder.append("     | expr expr\n");
+		grammarBuilder.append("     ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "start", input, true);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDuplicatedLeftRecursiveCall_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(63);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : expr EOF;\n");
+		grammarBuilder.append("expr : 'x'\n");
+		grammarBuilder.append("     | expr expr\n");
+		grammarBuilder.append("     ;");
+		String grammar = grammarBuilder.toString();
+		String input ="xx";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "start", input, true);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDuplicatedLeftRecursiveCall_3() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(63);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : expr EOF;\n");
+		grammarBuilder.append("expr : 'x'\n");
+		grammarBuilder.append("     | expr expr\n");
+		grammarBuilder.append("     ;");
+		String grammar = grammarBuilder.toString();
+		String input ="xxx";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "start", input, true);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDuplicatedLeftRecursiveCall_4() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(63);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : expr EOF;\n");
+		grammarBuilder.append("expr : 'x'\n");
+		grammarBuilder.append("     | expr expr\n");
+		grammarBuilder.append("     ;");
+		String grammar = grammarBuilder.toString();
+		String input ="xxxx";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "start", input, true);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testInvalidATNStateRemoval() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(98);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : ID ':' expr;\n");
+		grammarBuilder.append("expr : primary expr? {} | expr '->' ID;\n");
+		grammarBuilder.append("primary : ID;\n");
+		grammarBuilder.append("ID : [a-z]+;");
+		String grammar = grammarBuilder.toString();
+		String input ="x:x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "start", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testInvalidEmptyInput() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(36);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : ID+;\n");
+		grammarBuilder.append("ID : [a-z]+;");
+		String grammar = grammarBuilder.toString();
+		String input ="";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "start", input, true);
+		assertEquals("", found);
+
+		assertEquals("line 1:0 missing ID at '<EOF>'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLL1ErrorInfo() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(305);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : animal (AND acClass)? service EOF;\n");
+		grammarBuilder.append("animal : (DOG | CAT );\n");
+		grammarBuilder.append("service : (HARDWARE | SOFTWARE) ;\n");
+		grammarBuilder.append("AND : 'and';\n");
+		grammarBuilder.append("DOG : 'dog';\n");
+		grammarBuilder.append("CAT : 'cat';\n");
+		grammarBuilder.append("HARDWARE: 'hardware';\n");
+		grammarBuilder.append("SOFTWARE: 'software';\n");
+		grammarBuilder.append("WS : ' ' -> skip ;\n");
+		grammarBuilder.append("acClass\n");
+		grammarBuilder.append("@init\n");
+		grammarBuilder.append("{Console.WriteLine(this.GetExpectedTokens().ToString(this.Vocabulary));}\n");
+		grammarBuilder.append("  : ;");
+		String grammar = grammarBuilder.toString();
+		String input ="dog and software";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "start", input, false);
+		assertEquals("{'hardware', 'software'}\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLL2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(46);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' 'b'\n");
+		grammarBuilder.append("  | 'a' 'c'\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("q : 'e' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="ae";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:1 no viable alternative at input 'ae'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLL3() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(55);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' 'b'* 'c'\n");
+		grammarBuilder.append("  | 'a' 'b' 'd'\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("q : 'e' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="abe";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:2 no viable alternative at input 'abe'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLLStar() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(48);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a'+ 'b'\n");
+		grammarBuilder.append("  | 'a'+ 'c'\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("q : 'e' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="aaae";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:3 no viable alternative at input 'aaae'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultiTokenDeletionBeforeLoop() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(28);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' 'b'* 'c';");
+		String grammar = grammarBuilder.toString();
+		String input ="aacabc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:1 extraneous input 'a' expecting {'b', 'c'}\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultiTokenDeletionBeforeLoop2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(36);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' ('b'|'z'{})* 'c';");
+		String grammar = grammarBuilder.toString();
+		String input ="aacabc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:1 extraneous input 'a' expecting {'b', 'z', 'c'}\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultiTokenDeletionDuringLoop() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(29);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' 'b'* 'c' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="abaaababc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("", found);
+
+		assertEquals(
+			"line 1:2 extraneous input 'a' expecting {'b', 'c'}\n" +
+			"line 1:6 extraneous input 'a' expecting {'b', 'c'}\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultiTokenDeletionDuringLoop2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(37);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' ('b'|'z'{})* 'c' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="abaaababc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("", found);
+
+		assertEquals(
+			"line 1:2 extraneous input 'a' expecting {'b', 'z', 'c'}\n" +
+			"line 1:6 extraneous input 'a' expecting {'b', 'z', 'c'}\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNoViableAltAvoidance() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(83);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e '!' ;\n");
+		grammarBuilder.append("e : 'a' 'b'\n");
+		grammarBuilder.append("  | 'a'\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("DOT : '.' ;\n");
+		grammarBuilder.append("WS : [ \\t\\r\\n]+ -> skip;");
+		String grammar = grammarBuilder.toString();
+		String input ="a.";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:1 mismatched input '.' expecting '!'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleSetInsertion() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(34);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' ('b'|'c') 'd' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="ad";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:1 missing {'b', 'c'} at 'd'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleSetInsertionConsumption() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(88);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("myset: ('b'|'c') ;\n");
+		grammarBuilder.append("a: 'a' myset 'd' {Console.WriteLine(\"\" + $myset.stop);} ; ");
+		String grammar = grammarBuilder.toString();
+		String input ="ad";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("[@0,0:0='a',<3>,1:0]\n", found);
+
+		assertEquals("line 1:1 missing {'b', 'c'} at 'd'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleTokenDeletion() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(24);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' 'b' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="aab";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:1 extraneous input 'a' expecting 'b'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleTokenDeletionBeforeAlt() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(38);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : ('b' | 'c')\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("q : 'a'\n");
+		grammarBuilder.append(";");
+		String grammar = grammarBuilder.toString();
+		String input ="ac";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:0 extraneous input 'a' expecting {'b', 'c'}\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleTokenDeletionBeforeLoop() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(25);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' 'b'* ;");
+		String grammar = grammarBuilder.toString();
+		String input ="aabc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("", found);
+
+		assertEquals(
+			"line 1:1 extraneous input 'a' expecting {<EOF>, 'b'}\n" +
+			"line 1:3 token recognition error at: 'c'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleTokenDeletionBeforeLoop2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(32);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' ('b'|'z'{})*;");
+		String grammar = grammarBuilder.toString();
+		String input ="aabc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("", found);
+
+		assertEquals(
+			"line 1:1 extraneous input 'a' expecting {<EOF>, 'b', 'z'}\n" +
+			"line 1:3 token recognition error at: 'c'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleTokenDeletionBeforePredict() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(48);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a'+ 'b'\n");
+		grammarBuilder.append("  | 'a'+ 'c'\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("q : 'e' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="caaab";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:0 extraneous input 'c' expecting 'a'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleTokenDeletionConsumption() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(88);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("myset: ('b'|'c') ;\n");
+		grammarBuilder.append("a: 'a' myset 'd' {Console.WriteLine(\"\" + $myset.stop);} ; ");
+		String grammar = grammarBuilder.toString();
+		String input ="aabd";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("[@2,2:2='b',<1>,1:2]\n", found);
+
+		assertEquals("line 1:1 extraneous input 'a' expecting {'b', 'c'}\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleTokenDeletionDuringLoop() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(29);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' 'b'* 'c' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="ababbc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:2 extraneous input 'a' expecting {'b', 'c'}\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleTokenDeletionDuringLoop2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(37);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' ('b'|'z'{})* 'c' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="ababbc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:2 extraneous input 'a' expecting {'b', 'z', 'c'}\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleTokenDeletionExpectingSet() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(30);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' ('b'|'c') ;");
+		String grammar = grammarBuilder.toString();
+		String input ="aab";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:1 extraneous input 'a' expecting {'b', 'c'}\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleTokenInsertion() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(28);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' 'b' 'c' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="ac";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:1 missing 'b' at 'c'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTokenMismatch() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(24);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' 'b' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="aa";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:1 mismatched input 'a' expecting 'b'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTokenMismatch2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(165);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("stat:   ( '(' expr? ')' )? EOF ;\n");
+		grammarBuilder.append("expr:   ID '=' STR ;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("ERR :   '~FORCE_ERROR~' ;\n");
+		grammarBuilder.append("ID  :   [a-zA-Z]+ ;\n");
+		grammarBuilder.append("STR :   '\"' ~[\"]* '\"' ;\n");
+		grammarBuilder.append("WS  :   [ \\t\\r\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="( ~FORCE_ERROR~ ";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "stat", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:2 mismatched input '~FORCE_ERROR~' expecting ')'\n", this.stderrDuringParse);
+
+	}
+
+}
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/csharp/TestParserExec.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/csharp/TestParserExec.java
new file mode 100644
index 000000000..6747cb2c8
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/csharp/TestParserExec.java
@@ -0,0 +1,629 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.csharp;
+
+import org.junit.Test;
+import org.junit.Ignore;
+
+@SuppressWarnings("unused")
+public class TestParserExec extends BaseTest {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAPlus() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(90);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : ID+ {\n");
+		grammarBuilder.append("Console.WriteLine($text);\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+		String input ="a b c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("abc\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAStar_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(90);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : ID* {\n");
+		grammarBuilder.append("Console.WriteLine($text);\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+		String input ="";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAStar_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(90);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : ID* {\n");
+		grammarBuilder.append("Console.WriteLine($text);\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+		String input ="a b c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("abc\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAorAPlus() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(95);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (ID|ID)+ {\n");
+		grammarBuilder.append("Console.WriteLine($text);\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+		String input ="a b c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("abc\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAorAStar_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(95);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (ID|ID)* {\n");
+		grammarBuilder.append("Console.WriteLine($text);\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+		String input ="";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAorAStar_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(95);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (ID|ID)* {\n");
+		grammarBuilder.append("Console.WriteLine($text);\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+		String input ="a b c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("abc\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAorB() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(148);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : ID {\n");
+		grammarBuilder.append("Console.WriteLine(\"alt 1\");\n");
+		grammarBuilder.append("} | INT {\n");
+		grammarBuilder.append("Console.WriteLine(\"alt 2\");\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="34";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("alt 2\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAorBPlus() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(118);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (ID|INT{\n");
+		grammarBuilder.append("})+ {\n");
+		grammarBuilder.append("Console.WriteLine($text);\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a 34 c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("a34c\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAorBStar_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(118);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (ID|INT{\n");
+		grammarBuilder.append("})* {\n");
+		grammarBuilder.append("Console.WriteLine($text);\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAorBStar_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(118);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (ID|INT{\n");
+		grammarBuilder.append("})* {\n");
+		grammarBuilder.append("Console.WriteLine($text);\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a 34 c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("a34c\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testBasic() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(111);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : ID INT {\n");
+		grammarBuilder.append("Console.WriteLine($text);\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+		String input ="abc 34";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("abc34\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testEOFInClosure() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(53);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("prog : stat EOF;\n");
+		grammarBuilder.append("stat : 'x' ('y' | EOF)*?;");
+		String grammar = grammarBuilder.toString();
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "prog", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testIfIfElseGreedyBinding1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(199);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : statement+ ;\n");
+		grammarBuilder.append("statement : 'x' | ifStatement;\n");
+		grammarBuilder.append("ifStatement : 'if' 'y' statement ('else' statement)? {\n");
+		grammarBuilder.append("Console.WriteLine($text);\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> channel(HIDDEN);");
+		String grammar = grammarBuilder.toString();
+		String input ="if y if y x else x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "start", input, false);
+		assertEquals(
+			"if y x else x\n" +
+			"if y if y x else x\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testIfIfElseGreedyBinding2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(199);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : statement+ ;\n");
+		grammarBuilder.append("statement : 'x' | ifStatement;\n");
+		grammarBuilder.append("ifStatement : 'if' 'y' statement ('else' statement|) {\n");
+		grammarBuilder.append("Console.WriteLine($text);\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> channel(HIDDEN);");
+		String grammar = grammarBuilder.toString();
+		String input ="if y if y x else x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "start", input, false);
+		assertEquals(
+			"if y x else x\n" +
+			"if y if y x else x\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testIfIfElseNonGreedyBinding1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(200);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : statement+ ;\n");
+		grammarBuilder.append("statement : 'x' | ifStatement;\n");
+		grammarBuilder.append("ifStatement : 'if' 'y' statement ('else' statement)?? {\n");
+		grammarBuilder.append("Console.WriteLine($text);\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> channel(HIDDEN);");
+		String grammar = grammarBuilder.toString();
+		String input ="if y if y x else x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "start", input, false);
+		assertEquals(
+			"if y x\n" +
+			"if y if y x else x\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testIfIfElseNonGreedyBinding2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(199);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : statement+ ;\n");
+		grammarBuilder.append("statement : 'x' | ifStatement;\n");
+		grammarBuilder.append("ifStatement : 'if' 'y' statement (|'else' statement) {\n");
+		grammarBuilder.append("Console.WriteLine($text);\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> channel(HIDDEN);");
+		String grammar = grammarBuilder.toString();
+		String input ="if y if y x else x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "start", input, false);
+		assertEquals(
+			"if y x\n" +
+			"if y if y x else x\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLL1OptionalBlock_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(116);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (ID|{}INT)? {\n");
+		grammarBuilder.append("Console.WriteLine($text);\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+		String input ="";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLL1OptionalBlock_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(116);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (ID|{}INT)? {\n");
+		grammarBuilder.append("Console.WriteLine($text);\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+		String input ="a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("a\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLabelAliasingAcrossLabeledAlternatives() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(183);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : a* EOF;\n");
+		grammarBuilder.append("a\n");
+		grammarBuilder.append("  : label=subrule {Console.WriteLine($label.text);} #One\n");
+		grammarBuilder.append("  | label='y' {Console.WriteLine($label.text);} #Two\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("subrule : 'x';\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="xy";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "start", input, false);
+		assertEquals(
+			"x\n" +
+			"y\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLabels() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(118);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : b1=b b2+=b* b3+=';' ;\n");
+		grammarBuilder.append("b : id_=ID val+=INT*;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="abc 34;";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testListLabelForClosureContext() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(479);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("ifStatement\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("System.Collections.IList __ttt__ = $ctx.elseIfStatement();\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("    : 'if' expression\n");
+		grammarBuilder.append("      ( ( 'then'\n");
+		grammarBuilder.append("          executableStatement*\n");
+		grammarBuilder.append("          elseIfStatement*  // <--- problem is here; should yield a list not node\n");
+		grammarBuilder.append("          elseStatement?\n");
+		grammarBuilder.append("          'end' 'if'\n");
+		grammarBuilder.append("        ) | executableStatement )\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("elseIfStatement\n");
+		grammarBuilder.append("    : 'else' 'if' expression 'then' executableStatement*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("expression : 'a' ;\n");
+		grammarBuilder.append("executableStatement : 'a' ;\n");
+		grammarBuilder.append("elseStatement : 'a' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "expression", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testListLabelsOnSet() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(140);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : b b* ';' ;\n");
+		grammarBuilder.append("b : ID val+=(INT | FLOAT)*;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("FLOAT : [0-9]+ '.' [0-9]+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="abc 34;";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleEOFHandling() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(42);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("prog : ('x' | 'x' 'y') EOF EOF;");
+		String grammar = grammarBuilder.toString();
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "prog", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testOptional_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(90);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("stat : ifstat | 'x';\n");
+		grammarBuilder.append("ifstat : 'if' stat ('else' stat)?;\n");
+		grammarBuilder.append("WS : [ \\n\\t]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "stat", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testOptional_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(90);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("stat : ifstat | 'x';\n");
+		grammarBuilder.append("ifstat : 'if' stat ('else' stat)?;\n");
+		grammarBuilder.append("WS : [ \\n\\t]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="if x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "stat", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testOptional_3() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(90);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("stat : ifstat | 'x';\n");
+		grammarBuilder.append("ifstat : 'if' stat ('else' stat)?;\n");
+		grammarBuilder.append("WS : [ \\n\\t]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="if x else x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "stat", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testOptional_4() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(90);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("stat : ifstat | 'x';\n");
+		grammarBuilder.append("ifstat : 'if' stat ('else' stat)?;\n");
+		grammarBuilder.append("WS : [ \\n\\t]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="if if x else x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "stat", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testParserProperty() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(163);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@members {\n");
+		grammarBuilder.append("bool Property() {\n");
+		grammarBuilder.append("	return true;\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("a : {$parser.Property()}? ID {Console.WriteLine(\"valid\");}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="abc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("valid\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPredicatedIfIfElse() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(180);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : stmt EOF ;\n");
+		grammarBuilder.append("stmt : ifStmt | ID;\n");
+		grammarBuilder.append("ifStmt : 'if' ID stmt ('else' stmt | { this.InputStream.La(1)!=TParser.ELSE }?);\n");
+		grammarBuilder.append("ELSE : 'else';\n");
+		grammarBuilder.append("ID : [a-zA-Z]+;\n");
+		grammarBuilder.append("WS : [ \\n\\t]+ -> skip;");
+		String grammar = grammarBuilder.toString();
+		String input ="if x if x a else b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, true);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPredictionIssue334() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(252);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("file_ @init{\n");
+		grammarBuilder.append("ErrorHandler = new BailErrorStrategy();\n");
+		grammarBuilder.append("} \n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("Console.WriteLine($ctx.ToStringTree(this));\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  :   item (SEMICOLON item)* SEMICOLON? EOF ;\n");
+		grammarBuilder.append("item : A B?;\n");
+		grammarBuilder.append("SEMICOLON: ';';\n");
+		grammarBuilder.append("A : 'a'|'A';\n");
+		grammarBuilder.append("B : 'b'|'B';\n");
+		grammarBuilder.append("WS      : [ \\r\\t\\n]+ -> skip;");
+		String grammar = grammarBuilder.toString();
+		String input ="a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "file_", input, false);
+		assertEquals("(file_ (item a) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReferenceToATN_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(119);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (ID|ATN)* ATN? {Console.WriteLine($text);} ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("ATN : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReferenceToATN_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(119);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (ID|ATN)* ATN? {Console.WriteLine($text);} ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("ATN : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a 34 c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("a34c\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+}
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/csharp/TestPerformance.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/csharp/TestPerformance.java
new file mode 100644
index 000000000..5cc7634e1
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/csharp/TestPerformance.java
@@ -0,0 +1,206 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.csharp;
+
+import org.junit.Test;
+import org.junit.Ignore;
+
+@SuppressWarnings("unused")
+public class TestPerformance extends BaseTest {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExpressionGrammar_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(164);
+		grammarBuilder.append("grammar Expr;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("program: expr EOF;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("expr\n");
+		grammarBuilder.append("	: ID\n");
+		grammarBuilder.append("	| 'not' expr\n");
+		grammarBuilder.append("	| expr 'and' expr\n");
+		grammarBuilder.append("	| expr 'or' expr\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("ID: [a-zA-Z_][a-zA-Z_0-9]*;\n");
+		grammarBuilder.append("WS: [ \\t\\n\\r\\f]+ -> skip;\n");
+		grammarBuilder.append("ERROR: .;");
+		String grammar = grammarBuilder.toString();
+		String input =
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12";
+		String found = execParser("Expr.g4", grammar, "ExprParser", "ExprLexer", "program", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExpressionGrammar_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(164);
+		grammarBuilder.append("grammar Expr;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("program: expr EOF;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("expr\n");
+		grammarBuilder.append("	: ID\n");
+		grammarBuilder.append("	| 'not' expr\n");
+		grammarBuilder.append("	| expr 'and' expr\n");
+		grammarBuilder.append("	| expr 'or' expr\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("ID: [a-zA-Z_][a-zA-Z_0-9]*;\n");
+		grammarBuilder.append("WS: [ \\t\\n\\r\\f]+ -> skip;\n");
+		grammarBuilder.append("ERROR: .;");
+		String grammar = grammarBuilder.toString();
+		String input =
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12";
+		String found = execParser("Expr.g4", grammar, "ExprParser", "ExprLexer", "program", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+}
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/csharp/TestSemPredEvalLexer.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/csharp/TestSemPredEvalLexer.java
new file mode 100644
index 000000000..b9d2d7ae7
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/csharp/TestSemPredEvalLexer.java
@@ -0,0 +1,202 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.csharp;
+
+import org.junit.Test;
+import org.junit.Ignore;
+
+@SuppressWarnings("unused")
+public class TestSemPredEvalLexer extends BaseTest {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDisableRule() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(131);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("E1 : 'enum' { false }? ;\n");
+		grammarBuilder.append("E2 : 'enum' { true }? ;  // winner not E1 or ID\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+		String input ="enum abc";
+		String found = execLexer("L.g4", grammar, "L", input, true);
+		assertEquals(
+			"[@0,0:3='enum',<2>,1:0]\n" +
+			"[@1,5:7='abc',<3>,1:5]\n" +
+			"[@2,8:7='<EOF>',<-1>,1:8]\n" +
+			"s0-' '->:s5=>4\n" +
+			"s0-'a'->:s6=>3\n" +
+			"s0-'e'->:s1=>3\n" +
+			":s1=>3-'n'->:s2=>3\n" +
+			":s2=>3-'u'->:s3=>3\n" +
+			":s6=>3-'b'->:s6=>3\n" +
+			":s6=>3-'c'->:s6=>3\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testEnumNotID() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(103);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("ENUM : [a-z]+  { this.Text.Equals(\"enum\") }? ;\n");
+		grammarBuilder.append("ID : [a-z]+  ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+		String input ="enum abc enum";
+		String found = execLexer("L.g4", grammar, "L", input, true);
+		assertEquals(
+			"[@0,0:3='enum',<1>,1:0]\n" +
+			"[@1,5:7='abc',<2>,1:5]\n" +
+			"[@2,9:12='enum',<1>,1:9]\n" +
+			"[@3,13:12='<EOF>',<-1>,1:13]\n" +
+			"s0-' '->:s3=>3\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testIDnotEnum() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(84);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("ENUM : [a-z]+  { false }? ;\n");
+		grammarBuilder.append("ID : [a-z]+  ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+		String input ="enum abc enum";
+		String found = execLexer("L.g4", grammar, "L", input, true);
+		assertEquals(
+			"[@0,0:3='enum',<2>,1:0]\n" +
+			"[@1,5:7='abc',<2>,1:5]\n" +
+			"[@2,9:12='enum',<2>,1:9]\n" +
+			"[@3,13:12='<EOF>',<-1>,1:13]\n" +
+			"s0-' '->:s2=>3\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testIDvsEnum() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(85);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("ENUM : 'enum' { false }? ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+		String input ="enum abc enum";
+		String found = execLexer("L.g4", grammar, "L", input, true);
+		assertEquals(
+			"[@0,0:3='enum',<2>,1:0]\n" +
+			"[@1,5:7='abc',<2>,1:5]\n" +
+			"[@2,9:12='enum',<2>,1:9]\n" +
+			"[@3,13:12='<EOF>',<-1>,1:13]\n" +
+			"s0-' '->:s5=>3\n" +
+			"s0-'a'->:s4=>2\n" +
+			"s0-'e'->:s1=>2\n" +
+			":s1=>2-'n'->:s2=>2\n" +
+			":s2=>2-'u'->:s3=>2\n" +
+			":s4=>2-'b'->:s4=>2\n" +
+			":s4=>2-'c'->:s4=>2\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testIndent() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(147);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("ID : [a-z]+  ;\n");
+		grammarBuilder.append("INDENT : [ \\t]+ { this.TokenStartColumn==0 }?\n");
+		grammarBuilder.append("         { Console.WriteLine(\"INDENT\"); }  ;\n");
+		grammarBuilder.append("NL : '\\n';\n");
+		grammarBuilder.append("WS : [ \\t]+ ;");
+		String grammar = grammarBuilder.toString();
+		String input =
+			"abc\n" +
+			"  def  \n";
+		String found = execLexer("L.g4", grammar, "L", input, true);
+		assertEquals(
+			"INDENT\n" +
+			"[@0,0:2='abc',<1>,1:0]\n" +
+			"[@1,3:3='\\n',<3>,1:3]\n" +
+			"[@2,4:5='  ',<2>,2:0]\n" +
+			"[@3,6:8='def',<1>,2:2]\n" +
+			"[@4,9:10='  ',<4>,2:5]\n" +
+			"[@5,11:11='\\n',<3>,2:7]\n" +
+			"[@6,12:11='<EOF>',<-1>,3:0]\n" +
+			"s0-'\n" +
+			"'->:s2=>3\n" +
+			"s0-'a'->:s1=>1\n" +
+			"s0-'d'->:s1=>1\n" +
+			":s1=>1-'b'->:s1=>1\n" +
+			":s1=>1-'c'->:s1=>1\n" +
+			":s1=>1-'e'->:s1=>1\n" +
+			":s1=>1-'f'->:s1=>1\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLexerInputPositionSensitivePredicates() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(232);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("WORD1 : ID1+ { Console.WriteLine(this.Text); } ;\n");
+		grammarBuilder.append("WORD2 : ID2+ { Console.WriteLine(this.Text); } ;\n");
+		grammarBuilder.append("fragment ID1 : { this.Column < 2 }? [a-zA-Z];\n");
+		grammarBuilder.append("fragment ID2 : { this.Column >= 2 }? [a-zA-Z];\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+		String input =
+			"a cde\n" +
+			"abcde\n";
+		String found = execLexer("L.g4", grammar, "L", input, true);
+		assertEquals(
+			"a\n" +
+			"cde\n" +
+			"ab\n" +
+			"cde\n" +
+			"[@0,0:0='a',<1>,1:0]\n" +
+			"[@1,2:4='cde',<2>,1:2]\n" +
+			"[@2,6:7='ab',<1>,2:0]\n" +
+			"[@3,8:10='cde',<2>,2:2]\n" +
+			"[@4,12:11='<EOF>',<-1>,3:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPredicatedKeywords() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(175);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("ENUM : [a-z]+ { this.Text.Equals(\"enum\") }? { Console.WriteLine(\"enum!\"); } ;\n");
+		grammarBuilder.append("ID   : [a-z]+ { Console.WriteLine(\"ID \" + this.Text); } ;\n");
+		grammarBuilder.append("WS   : [ \\n] -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="enum enu a";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"enum!\n" +
+			"ID enu\n" +
+			"ID a\n" +
+			"[@0,0:3='enum',<1>,1:0]\n" +
+			"[@1,5:7='enu',<2>,1:5]\n" +
+			"[@2,9:9='a',<2>,1:9]\n" +
+			"[@3,10:9='<EOF>',<-1>,1:10]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+}
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/csharp/TestSemPredEvalParser.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/csharp/TestSemPredEvalParser.java
new file mode 100644
index 000000000..445cce200
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/csharp/TestSemPredEvalParser.java
@@ -0,0 +1,630 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.csharp;
+
+import org.junit.Test;
+import org.junit.Ignore;
+
+@SuppressWarnings("unused")
+public class TestSemPredEvalParser extends BaseTest {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void test2UnpredicatedAlts() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(311);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : {Interpreter.PredictionMode = PredictionMode.LlExactAmbigDetection;} a ';' a; // do 2x: once in ATN, next in DFA\n");
+		grammarBuilder.append("a : ID {Console.WriteLine(\"alt 1\");}\n");
+		grammarBuilder.append("  | ID {Console.WriteLine(\"alt 2\");}\n");
+		grammarBuilder.append("  | {false}? ID {Console.WriteLine(\"alt 3\");}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x; y";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, true);
+		assertEquals(
+			"alt 1\n" +
+			"alt 1\n", found);
+
+		assertEquals(
+			"line 1:0 reportAttemptingFullContext d=0 (a), input='x'\n" +
+			"line 1:0 reportAmbiguity d=0 (a): ambigAlts={1, 2}, input='x'\n" +
+			"line 1:3 reportAttemptingFullContext d=0 (a), input='y'\n" +
+			"line 1:3 reportAmbiguity d=0 (a): ambigAlts={1, 2}, input='y'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void test2UnpredicatedAltsAndOneOrthogonalAlt() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(369);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : {Interpreter.PredictionMode = PredictionMode.LlExactAmbigDetection;} a ';' a ';' a;\n");
+		grammarBuilder.append("a : INT {Console.WriteLine(\"alt 1\");}\n");
+		grammarBuilder.append("  | ID {Console.WriteLine(\"alt 2\");} // must pick this one for ID since pred is false\n");
+		grammarBuilder.append("  | ID {Console.WriteLine(\"alt 3\");}\n");
+		grammarBuilder.append("  | {false}? ID {Console.WriteLine(\"alt 4\");}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="34; x; y";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, true);
+		assertEquals(
+			"alt 1\n" +
+			"alt 2\n" +
+			"alt 2\n", found);
+
+		assertEquals(
+			"line 1:4 reportAttemptingFullContext d=0 (a), input='x'\n" +
+			"line 1:4 reportAmbiguity d=0 (a): ambigAlts={2, 3}, input='x'\n" +
+			"line 1:7 reportAttemptingFullContext d=0 (a), input='y'\n" +
+			"line 1:7 reportAmbiguity d=0 (a): ambigAlts={2, 3}, input='y'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testActionHidesPreds() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(237);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@members {int i = 0;}\n");
+		grammarBuilder.append("s : a+ ;\n");
+		grammarBuilder.append("a : {this.i = 1;} ID {this.i == 1}? {Console.WriteLine(\"alt 1\");}\n");
+		grammarBuilder.append("  | {this.i = 2;} ID {this.i == 2}? {Console.WriteLine(\"alt 2\");}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x x y";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals(
+			"alt 1\n" +
+			"alt 1\n" +
+			"alt 1\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testActionsHidePredsInGlobalFOLLOW() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(304);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@members {\n");
+		grammarBuilder.append("bool pred(bool v) {\n");
+		grammarBuilder.append("	Console.WriteLine(\"eval=\"+v.ToString().ToLower());\n");
+		grammarBuilder.append("	return v;\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("s : e {} {this.pred(true)}? {Console.WriteLine(\"parse\");} '!' ;\n");
+		grammarBuilder.append("t : e {} {this.pred(false)}? ID ;\n");
+		grammarBuilder.append("e : ID | ; // non-LL(1) so we use ATN\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a!";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals(
+			"eval=true\n" +
+			"parse\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAtomWithClosureInTranslatedLRRule() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(94);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : e[0] EOF;\n");
+		grammarBuilder.append("e[int _p]\n");
+		grammarBuilder.append("    :   ( 'a' | 'b'+ ) ( {3 >= $_p}? '+' e[4] )*\n");
+		grammarBuilder.append("    ;\n");
+		String grammar = grammarBuilder.toString();
+		String input ="a+b+a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "start", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDepedentPredsInGlobalFOLLOW() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(327);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@members {\n");
+		grammarBuilder.append("bool pred(bool v) {\n");
+		grammarBuilder.append("	Console.WriteLine(\"eval=\"+v.ToString().ToLower());\n");
+		grammarBuilder.append("	return v;\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("s : a[99] ;\n");
+		grammarBuilder.append("a[int i] : e {this.pred($i==99)}? {Console.WriteLine(\"parse\");} '!' ;\n");
+		grammarBuilder.append("b[int i] : e {this.pred($i==99)}? ID ;\n");
+		grammarBuilder.append("e : ID | ; // non-LL(1) so we use ATN\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a!";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals(
+			"eval=true\n" +
+			"parse\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDependentPredNotInOuterCtxShouldBeIgnored() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(282);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : b[2] ';' |  b[2] '.' ; // decision in s drills down to ctx-dependent pred in a;\n");
+		grammarBuilder.append("b[int i] : a[i] ;\n");
+		grammarBuilder.append("a[int i]\n");
+		grammarBuilder.append("  : {$i==1}? ID {Console.WriteLine(\"alt 1\");}\n");
+		grammarBuilder.append("    | {$i==2}? ID {Console.WriteLine(\"alt 2\");}\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;\n");
+		String grammar = grammarBuilder.toString();
+		String input ="a;";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("alt 2\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDisabledAlternative() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(121);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("cppCompilationUnit : content+ EOF;\n");
+		grammarBuilder.append("content: anything | {false}? .;\n");
+		grammarBuilder.append("anything: ANY_CHAR;\n");
+		grammarBuilder.append("ANY_CHAR: [_a-zA-Z0-9];");
+		String grammar = grammarBuilder.toString();
+		String input ="hello";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "cppCompilationUnit", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testIndependentPredNotPassedOuterCtxToAvoidCastException() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(195);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : b ';' |  b '.' ;\n");
+		grammarBuilder.append("b : a ;\n");
+		grammarBuilder.append("a\n");
+		grammarBuilder.append("  : {false}? ID {Console.WriteLine(\"alt 1\");}\n");
+		grammarBuilder.append("  | {true}? ID {Console.WriteLine(\"alt 2\");}\n");
+		grammarBuilder.append(" ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a;";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("alt 2\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNoTruePredsThrowsNoViableAlt() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(183);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : a a;\n");
+		grammarBuilder.append("a : {false}? ID INT {Console.WriteLine(\"alt 1\");}\n");
+		grammarBuilder.append("  | {false}? ID INT {Console.WriteLine(\"alt 2\");}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="y 3 x 4";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:0 no viable alternative at input 'y'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testOrder() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(309);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : a {} a; // do 2x: once in ATN, next in DFA;\n");
+		grammarBuilder.append("// action blocks lookahead from falling off of 'a'\n");
+		grammarBuilder.append("// and looking into 2nd 'a' ref. !ctx dependent pred\n");
+		grammarBuilder.append("a : ID {Console.WriteLine(\"alt 1\");}\n");
+		grammarBuilder.append("  | {true}?  ID {Console.WriteLine(\"alt 2\");}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x y";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals(
+			"alt 1\n" +
+			"alt 1\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPredFromAltTestedInLoopBack_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(215);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("file_\n");
+		grammarBuilder.append("@after {Console.WriteLine($ctx.ToStringTree(this));}\n");
+		grammarBuilder.append("  : para para EOF ;\n");
+		grammarBuilder.append("para: paraContent NL NL ;\n");
+		grammarBuilder.append("paraContent : ('s'|'x'|{this.InputStream.La(2)!=TParser.NL}? NL)+ ;\n");
+		grammarBuilder.append("NL : '\\n' ;\n");
+		grammarBuilder.append("s : 's' ;\n");
+		grammarBuilder.append("X : 'x' ;");
+		String grammar = grammarBuilder.toString();
+		String input =
+			"s\n" +
+			"\n" +
+			"\n" +
+			"x\n";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "file_", input, true);
+		assertEquals("(file_ (para (paraContent s) \\n \\n) (para (paraContent \\n x \\n)) <EOF>)\n", found);
+
+		assertEquals(
+			"line 5:0 mismatched input '<EOF>' expecting '\n" +
+			"'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPredFromAltTestedInLoopBack_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(215);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("file_\n");
+		grammarBuilder.append("@after {Console.WriteLine($ctx.ToStringTree(this));}\n");
+		grammarBuilder.append("  : para para EOF ;\n");
+		grammarBuilder.append("para: paraContent NL NL ;\n");
+		grammarBuilder.append("paraContent : ('s'|'x'|{this.InputStream.La(2)!=TParser.NL}? NL)+ ;\n");
+		grammarBuilder.append("NL : '\\n' ;\n");
+		grammarBuilder.append("s : 's' ;\n");
+		grammarBuilder.append("X : 'x' ;");
+		String grammar = grammarBuilder.toString();
+		String input =
+			"s\n" +
+			"\n" +
+			"\n" +
+			"x\n" +
+			"\n";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "file_", input, true);
+		assertEquals("(file_ (para (paraContent s) \\n \\n) (para (paraContent \\n x) \\n \\n) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPredTestedEvenWhenUnAmbig_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(213);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@members {bool enumKeyword = true;}\n");
+		grammarBuilder.append("primary\n");
+		grammarBuilder.append("    :   ID {Console.WriteLine(\"ID \"+$ID.text);}\n");
+		grammarBuilder.append("    |   {!this.enumKeyword}? 'enum' {Console.WriteLine(\"enum\");}\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : [a-z]+ ;\n");
+		grammarBuilder.append("WS : [ \\t\\n\\r]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="abc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "primary", input, false);
+		assertEquals("ID abc\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPredTestedEvenWhenUnAmbig_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(213);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@members {bool enumKeyword = true;}\n");
+		grammarBuilder.append("primary\n");
+		grammarBuilder.append("    :   ID {Console.WriteLine(\"ID \"+$ID.text);}\n");
+		grammarBuilder.append("    |   {!this.enumKeyword}? 'enum' {Console.WriteLine(\"enum\");}\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : [a-z]+ ;\n");
+		grammarBuilder.append("WS : [ \\t\\n\\r]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="enum";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "primary", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:0 no viable alternative at input 'enum'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPredicateDependentOnArg() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(212);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@members {int i = 0;}\n");
+		grammarBuilder.append("s : a[2] a[1];\n");
+		grammarBuilder.append("a[int i]\n");
+		grammarBuilder.append("  : {$i==1}? ID {Console.WriteLine(\"alt 1\");}\n");
+		grammarBuilder.append("  | {$i==2}? ID {Console.WriteLine(\"alt 2\");}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals(
+			"alt 2\n" +
+			"alt 1\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPredicateDependentOnArg2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(154);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@members {int i = 0;}\n");
+		grammarBuilder.append("s : a[2] a[1];\n");
+		grammarBuilder.append("a[int i]\n");
+		grammarBuilder.append("  : {$i==1}? ID \n");
+		grammarBuilder.append("  | {$i==2}? ID \n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPredsInGlobalFOLLOW() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(298);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@members {\n");
+		grammarBuilder.append("bool pred(bool v) {\n");
+		grammarBuilder.append("	Console.WriteLine(\"eval=\"+v.ToString().ToLower());\n");
+		grammarBuilder.append("	return v;\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("s : e {this.pred(true)}? {Console.WriteLine(\"parse\");} '!' ;\n");
+		grammarBuilder.append("t : e {this.pred(false)}? ID ;\n");
+		grammarBuilder.append("e : ID | ; // non-LL(1) so we use ATN\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a!";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals(
+			"eval=true\n" +
+			"parse\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testRewindBeforePredEval() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(251);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : a a;\n");
+		grammarBuilder.append("a : {this.TokenStream.Lt(1).Text.Equals(\"x\")}? ID INT {Console.WriteLine(\"alt 1\");}\n");
+		grammarBuilder.append("  | {this.TokenStream.Lt(1).Text.Equals(\"y\")}? ID INT {Console.WriteLine(\"alt 2\");}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="y 3 x 4";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals(
+			"alt 2\n" +
+			"alt 1\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSimple() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(274);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : a a a; // do 3x: once in ATN, next in DFA then INT in ATN\n");
+		grammarBuilder.append("a : {false}? ID {Console.WriteLine(\"alt 1\");}\n");
+		grammarBuilder.append("  | {true}?  ID {Console.WriteLine(\"alt 2\");}\n");
+		grammarBuilder.append("  | INT         {Console.WriteLine(\"alt 3\");}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x y 3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals(
+			"alt 2\n" +
+			"alt 2\n" +
+			"alt 3\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSimpleValidate() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(176);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : a ;\n");
+		grammarBuilder.append("a : {false}? ID  {Console.WriteLine(\"alt 1\");}\n");
+		grammarBuilder.append("  | {true}?  INT {Console.WriteLine(\"alt 2\");}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:0 no viable alternative at input 'x'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSimpleValidate2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(179);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : a a a;\n");
+		grammarBuilder.append("a : {false}? ID  {Console.WriteLine(\"alt 1\");}\n");
+		grammarBuilder.append("  | {true}?  INT {Console.WriteLine(\"alt 2\");}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="3 4 x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals(
+			"alt 2\n" +
+			"alt 2\n", found);
+
+		assertEquals("line 1:4 no viable alternative at input 'x'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testToLeft() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(176);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("	s : a+ ;\n");
+		grammarBuilder.append("a : {false}? ID {Console.WriteLine(\"alt 1\");}\n");
+		grammarBuilder.append("  | {true}?  ID {Console.WriteLine(\"alt 2\");}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x x y";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals(
+			"alt 2\n" +
+			"alt 2\n" +
+			"alt 2\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testToLeftWithVaryingPredicate() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(268);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@members {int i = 0;}\n");
+		grammarBuilder.append("s : ({this.i += 1;\n");
+		grammarBuilder.append("Console.WriteLine(\"i=\" + this.i);} a)+ ;\n");
+		grammarBuilder.append("a : {this.i % 2 == 0}? ID {Console.WriteLine(\"alt 1\");}\n");
+		grammarBuilder.append("  | {this.i % 2 != 0}? ID {Console.WriteLine(\"alt 2\");}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x x y";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals(
+			"i=1\n" +
+			"alt 2\n" +
+			"i=2\n" +
+			"alt 1\n" +
+			"i=3\n" +
+			"alt 2\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testUnpredicatedPathsInAlt() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(195);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : a {Console.WriteLine(\"alt 1\");}\n");
+		grammarBuilder.append("  | b {Console.WriteLine(\"alt 2\");}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("a : {false}? ID INT\n");
+		grammarBuilder.append("  | ID INT\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("b : ID ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x 4";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("alt 1\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testValidateInDFA() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(344);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : a ';' a;\n");
+		grammarBuilder.append("// ';' helps us to resynchronize without consuming\n");
+		grammarBuilder.append("// 2nd 'a' reference. We our testing that the DFA also\n");
+		grammarBuilder.append("// throws an exception if the validating predicate fails\n");
+		grammarBuilder.append("a : {false}? ID  {Console.WriteLine(\"alt 1\");}\n");
+		grammarBuilder.append("  | {true}?  INT {Console.WriteLine(\"alt 2\");}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x ; y";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("", found);
+
+		assertEquals(
+			"line 1:0 no viable alternative at input 'x'\n" +
+			"line 1:4 no viable alternative at input 'y'\n", this.stderrDuringParse);
+
+	}
+
+}
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/csharp/TestSets.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/csharp/TestSets.java
new file mode 100644
index 000000000..d2830abd6
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/csharp/TestSets.java
@@ -0,0 +1,360 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.csharp;
+
+import org.junit.Test;
+import org.junit.Ignore;
+
+@SuppressWarnings("unused")
+public class TestSets extends BaseTest {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetLiteral() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(91);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (A {Console.WriteLine($A.text);})+ ;\n");
+		grammarBuilder.append("A : [AaBb] ;\n");
+		grammarBuilder.append("WS : (' '|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="A a B b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals(
+			"A\n" +
+			"a\n" +
+			"B\n" +
+			"b\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testComplementSet() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(51);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("parse : ~NEW_LINE;\n");
+		grammarBuilder.append("NEW_LINE: '\\r'? '\\n';");
+		String grammar = grammarBuilder.toString();
+		String input ="a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "parse", input, false);
+		assertEquals("", found);
+
+		assertEquals(
+			"line 1:0 token recognition error at: 'a'\n" +
+			"line 1:1 missing {} at '<EOF>'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLexerOptionalSet() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(88);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {Console.WriteLine(this.TokenStream.GetText());} ;\n");
+		grammarBuilder.append("A : ('a'|'b')? 'c' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="ac";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("ac\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLexerPlusSet() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(88);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {Console.WriteLine(this.TokenStream.GetText());} ;\n");
+		grammarBuilder.append("A : ('a'|'b')+ 'c' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="abaac";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("abaac\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLexerStarSet() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(88);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {Console.WriteLine(this.TokenStream.GetText());} ;\n");
+		grammarBuilder.append("A : ('a'|'b')* 'c' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="abaac";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("abaac\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNotChar() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(59);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {Console.WriteLine($A.text);} ;\n");
+		grammarBuilder.append("A : ~'b' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("x\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNotCharSet() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(65);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {Console.WriteLine($A.text);} ;\n");
+		grammarBuilder.append("A : ~('b'|'c') ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("x\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNotCharSetWithLabel() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(67);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {Console.WriteLine($A.text);} ;\n");
+		grammarBuilder.append("A : h=~('b'|'c') ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("x\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNotCharSetWithRuleRef3() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(131);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {Console.WriteLine($A.text);} ;\n");
+		grammarBuilder.append("A : ('a'|B) ;  // this doesn't collapse to set but works\n");
+		grammarBuilder.append("fragment\n");
+		grammarBuilder.append("B : ~('a'|'c') ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("x\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testOptionalLexerSingleElement() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(82);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {Console.WriteLine(this.TokenStream.GetText());} ;\n");
+		grammarBuilder.append("A : 'b'? 'c' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="bc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("bc\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testOptionalSet() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(80);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : ('a'|'b')? 'c' {Console.WriteLine(this.TokenStream.GetText());} ;");
+		String grammar = grammarBuilder.toString();
+		String input ="ac";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("ac\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testOptionalSingleElement() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(82);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A? 'c' {Console.WriteLine(this.TokenStream.GetText());} ;\n");
+		grammarBuilder.append("A : 'b' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="bc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("bc\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testParserNotSet() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(63);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : t=~('x'|'y') 'z' {Console.WriteLine($t.text);} ;");
+		String grammar = grammarBuilder.toString();
+		String input ="zz";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("z\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testParserNotToken() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(74);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : ~'x' 'z' {Console.WriteLine(this.TokenStream.GetText());} ;");
+		String grammar = grammarBuilder.toString();
+		String input ="zz";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("zz\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testParserNotTokenWithLabel() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(57);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : t=~'x' 'z' {Console.WriteLine($t.text);} ;");
+		String grammar = grammarBuilder.toString();
+		String input ="zz";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("z\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testParserSet() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(58);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : t=('x'|'y') {Console.WriteLine($t.text);} ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("x\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPlusLexerSingleElement() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(82);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {Console.WriteLine(this.TokenStream.GetText());} ;\n");
+		grammarBuilder.append("A : 'b'+ 'c' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="bbbbc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("bbbbc\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPlusSet() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(80);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : ('a'|'b')+ 'c' {Console.WriteLine(this.TokenStream.GetText());} ;");
+		String grammar = grammarBuilder.toString();
+		String input ="abaac";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("abaac\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testRuleAsSet() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(87);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a @after {Console.WriteLine(this.TokenStream.GetText());} : 'a' | 'b' |'c' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("b\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSeqDoesNotBecomeSet() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(124);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : C {Console.WriteLine(this.TokenStream.GetText());} ;\n");
+		grammarBuilder.append("fragment A : '1' | '2';\n");
+		grammarBuilder.append("fragment B : '3' '4';\n");
+		grammarBuilder.append("C : A | B;");
+		String grammar = grammarBuilder.toString();
+		String input ="34";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("34\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testStarLexerSingleElement_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(82);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {Console.WriteLine(this.TokenStream.GetText());} ;\n");
+		grammarBuilder.append("A : 'b'* 'c' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="bbbbc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("bbbbc\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testStarLexerSingleElement_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(82);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {Console.WriteLine(this.TokenStream.GetText());} ;\n");
+		grammarBuilder.append("A : 'b'* 'c' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("c\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testStarSet() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(80);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : ('a'|'b')* 'c' {Console.WriteLine(this.TokenStream.GetText());} ;");
+		String grammar = grammarBuilder.toString();
+		String input ="abaac";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("abaac\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+}
diff --git a/tool/test/org/antlr/v4/test/BaseTest.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/java/BaseTest.java
similarity index 85%
rename from tool/test/org/antlr/v4/test/BaseTest.java
rename to runtime-testsuite/test/org/antlr/v4/test/runtime/java/BaseTest.java
index c5b750169..271555eef 100644
--- a/tool/test/org/antlr/v4/test/BaseTest.java
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/java/BaseTest.java
@@ -27,7 +27,7 @@
  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-package org.antlr.v4.test;
+package org.antlr.v4.test.runtime.java;
 
 import org.antlr.v4.Tool;
 import org.antlr.v4.automata.ATNFactory;
@@ -56,9 +56,8 @@ import org.antlr.v4.runtime.atn.LexerATNSimulator;
 import org.antlr.v4.runtime.dfa.DFA;
 import org.antlr.v4.runtime.misc.IntegerList;
 import org.antlr.v4.runtime.misc.Interval;
-import org.antlr.v4.runtime.misc.NotNull;
-import org.antlr.v4.runtime.misc.Nullable;
 import org.antlr.v4.runtime.misc.Pair;
+import org.antlr.v4.runtime.misc.Utils;
 import org.antlr.v4.runtime.tree.ParseTree;
 import org.antlr.v4.semantics.SemanticPipeline;
 import org.antlr.v4.tool.ANTLRMessage;
@@ -81,9 +80,7 @@ import javax.tools.JavaFileObject;
 import javax.tools.StandardJavaFileManager;
 import javax.tools.ToolProvider;
 import java.io.BufferedReader;
-import java.io.BufferedWriter;
 import java.io.File;
-import java.io.FileWriter;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
@@ -122,8 +119,74 @@ public abstract class BaseTest {
 	public static final String newline = System.getProperty("line.separator");
 	public static final String pathSep = System.getProperty("path.separator");
 
+	/**
+	 * When the {@code antlr.testinprocess} runtime property is set to
+	 * {@code true}, the test suite will attempt to load generated classes into
+	 * the test process for direct execution rather than invoking the JVM in a
+	 * new process for testing.
+	 *
+	 * <p>
+	 * In-process testing results in a substantial performance improvement, but
+	 * some test environments created by IDEs do not support the mechanisms
+	 * currently used by the tests to dynamically load compiled code. Therefore,
+	 * the default behavior (used in all other cases) favors reliable
+	 * cross-system test execution by executing generated test code in a
+	 * separate process.</p>
+	 */
 	public static final boolean TEST_IN_SAME_PROCESS = Boolean.parseBoolean(System.getProperty("antlr.testinprocess"));
 
+	/**
+	 * When the {@code antlr.preserve-test-dir} runtime property is set to
+	 * {@code true}, the temporary directories created by the test run will not
+	 * be removed at the end of the test run, even for tests that completed
+	 * successfully.
+	 *
+	 * <p>
+	 * The default behavior (used in all other cases) is removing the temporary
+	 * directories for all tests which completed successfully, and preserving
+	 * the directories for tests which failed.</p>
+	 */
+	public static final boolean PRESERVE_TEST_DIR = Boolean.parseBoolean(System.getProperty("antlr.preserve-test-dir"));
+
+	/**
+	 * The base test directory is the directory where generated files get placed
+	 * during unit test execution.
+	 *
+	 * <p>
+	 * The default value for this property is the {@code java.io.tmpdir} system
+	 * property, and can be overridden by setting the
+	 * {@code antlr.java-test-dir} property to a custom location. Note that the
+	 * {@code antlr.java-test-dir} property directly affects the
+	 * {@link #CREATE_PER_TEST_DIRECTORIES} value as well.</p>
+	 */
+	public static final String BASE_TEST_DIR;
+
+	/**
+	 * When {@code true}, a temporary directory will be created for each test
+	 * executed during the test run.
+	 *
+	 * <p>
+	 * This value is {@code true} when the {@code antlr.java-test-dir} system
+	 * property is set, and otherwise {@code false}.</p>
+	 */
+	public static final boolean CREATE_PER_TEST_DIRECTORIES;
+
+	static {
+		String baseTestDir = System.getProperty("antlr.java-test-dir");
+		boolean perTestDirectories = false;
+		if (baseTestDir == null || baseTestDir.isEmpty()) {
+			baseTestDir = System.getProperty("java.io.tmpdir");
+			perTestDirectories = true;
+		}
+
+		if (!new File(baseTestDir).isDirectory()) {
+			throw new UnsupportedOperationException("The specified base test directory does not exist: " + baseTestDir);
+		}
+
+		BASE_TEST_DIR = baseTestDir;
+		CREATE_PER_TEST_DIRECTORIES = perTestDirectories;
+	}
+
     /**
      * Build up the full classpath we need, including the surefire path (if present)
      */
@@ -142,17 +205,26 @@ public abstract class BaseTest {
 		@Override
 		protected void succeeded(Description description) {
 			// remove tmpdir if no error.
-			eraseTempDir();
+			if (!PRESERVE_TEST_DIR) {
+				eraseTempDir();
+			}
 		}
 
 	};
 
     @Before
 	public void setUp() throws Exception {
-        // new output dir for each test
-        tmpdir = new File(System.getProperty("java.io.tmpdir"),
-						  getClass().getSimpleName()+"-"+System.currentTimeMillis()).getAbsolutePath();
-//		tmpdir = "/tmp";
+		if (CREATE_PER_TEST_DIRECTORIES) {
+			// new output dir for each test
+			String testDirectory = getClass().getSimpleName() + "-" + System.currentTimeMillis();
+			tmpdir = new File(BASE_TEST_DIR, testDirectory).getAbsolutePath();
+		}
+		else {
+			tmpdir = new File(BASE_TEST_DIR).getAbsolutePath();
+			if (!PRESERVE_TEST_DIR && new File(tmpdir).exists()) {
+				eraseFiles();
+			}
+		}
     }
 
     protected org.antlr.v4.Tool newTool(String[] args) {
@@ -335,6 +407,33 @@ public abstract class BaseTest {
 		return null;
 	}
 
+	protected String load(String fileName, String encoding)
+		throws IOException
+	{
+		if ( fileName==null ) {
+			return null;
+		}
+
+		String fullFileName = getClass().getPackage().getName().replace('.', '/') + '/' + fileName;
+		int size = 65000;
+		InputStreamReader isr;
+		InputStream fis = getClass().getClassLoader().getResourceAsStream(fullFileName);
+		if ( encoding!=null ) {
+			isr = new InputStreamReader(fis, encoding);
+		}
+		else {
+			isr = new InputStreamReader(fis);
+		}
+		try {
+			char[] data = new char[size];
+			int n = isr.read(data);
+			return new String(data, 0, n);
+		}
+		finally {
+			isr.close();
+		}
+	}
+
 	/** Wow! much faster than compiling outside of VM. Finicky though.
 	 *  Had rules called r and modulo. Wouldn't compile til I changed to 'a'.
 	 */
@@ -356,7 +455,7 @@ public abstract class BaseTest {
 			fileManager.getJavaFileObjectsFromFiles(files);
 
 		Iterable<String> compileOptions =
-			Arrays.asList("-g", "-d", tmpdir, "-cp", tmpdir+pathSep+CLASSPATH);
+			Arrays.asList("-g", "-source", "1.6", "-target", "1.6", "-implicit:class", "-Xlint:-options", "-d", tmpdir, "-cp", tmpdir+pathSep+CLASSPATH);
 
 		JavaCompiler.CompilationTask task =
 			compiler.getTask(null, fileManager, null, compileOptions, null,
@@ -370,61 +469,24 @@ public abstract class BaseTest {
 			ioe.printStackTrace(System.err);
 		}
 
-//		List<String> errors = new ArrayList<String>();
-//		for (Diagnostic diagnostic : diagnostics.getDiagnostics()) {
-//			errors.add(
-//				String.valueOf(diagnostic.getLineNumber())+
-//				": " + diagnostic.getMessage(null));
-//		}
-//		if ( errors.size()>0 ) {
-//			System.err.println("compile stderr from: "+cmdLine);
-//			System.err.println(errors);
-//			return false;
-//		}
 		return ok;
-
-		/*
-		File outputDir = new File(tmpdir);
-		try {
-			Process process =
-				Runtime.getRuntime().exec(args, null, outputDir);
-			StreamVacuum stdout = new StreamVacuum(process.getInputStream());
-			StreamVacuum stderr = new StreamVacuum(process.getErrorStream());
-			stdout.start();
-			stderr.start();
-			process.waitFor();
-            stdout.join();
-            stderr.join();
-			if ( stdout.toString().length()>0 ) {
-				System.err.println("compile stdout from: "+cmdLine);
-				System.err.println(stdout);
-			}
-			if ( stderr.toString().length()>0 ) {
-				System.err.println("compile stderr from: "+cmdLine);
-				System.err.println(stderr);
-			}
-			int ret = process.exitValue();
-			return ret==0;
-		}
-		catch (Exception e) {
-			System.err.println("can't exec compilation");
-			e.printStackTrace(System.err);
-			return false;
-		}
-		*/
 	}
 
-	/** Return true if all is ok, no errors */
-	protected ErrorQueue antlr(String fileName, String grammarFileName, String grammarStr, boolean defaultListener, String... extraOptions) {
-		System.out.println("dir "+tmpdir);
-		mkdir(tmpdir);
-		writeFile(tmpdir, fileName, grammarStr);
+	protected ErrorQueue antlr(String grammarFileName, boolean defaultListener, String... extraOptions) {
 		final List<String> options = new ArrayList<String>();
 		Collections.addAll(options, extraOptions);
-		options.add("-o");
-		options.add(tmpdir);
-		options.add("-lib");
-		options.add(tmpdir);
+		if ( !options.contains("-o") ) {
+			options.add("-o");
+			options.add(tmpdir);
+		}
+		if ( !options.contains("-lib") ) {
+			options.add("-lib");
+			options.add(tmpdir);
+		}
+		if ( !options.contains("-encoding") ) {
+			options.add("-encoding");
+			options.add("UTF-8");
+		}
 		options.add(new File(tmpdir,grammarFileName).toString());
 
 		final String[] optionsA = new String[options.size()];
@@ -444,7 +506,12 @@ public abstract class BaseTest {
 				System.err.println(msg);
 			}
 			System.out.println("!!!\ngrammar:");
-			System.out.println(grammarStr);
+			try {
+				System.out.println(new String(Utils.readFile(tmpdir+"/"+grammarFileName)));
+			}
+			catch (IOException ioe) {
+				System.err.println(ioe.toString());
+			}
 			System.out.println("###");
 		}
 		if ( !defaultListener && !equeue.warnings.isEmpty() ) {
@@ -458,6 +525,13 @@ public abstract class BaseTest {
 		return equeue;
 	}
 
+	protected ErrorQueue antlr(String grammarFileName, String grammarStr, boolean defaultListener, String... extraOptions) {
+		System.out.println("dir "+tmpdir);
+		mkdir(tmpdir);
+		writeFile(tmpdir, grammarFileName, grammarStr);
+		return antlr(grammarFileName, defaultListener, extraOptions);
+	}
+
 	protected String execLexer(String grammarFileName,
 							   String grammarStr,
 							   String lexerName,
@@ -556,6 +630,18 @@ public abstract class BaseTest {
 								String lexerName,
 								String startRuleName,
 								String input, boolean debug)
+	{
+		return execParser(grammarFileName, grammarStr, parserName,
+				   lexerName, startRuleName, input, debug, false);
+	}
+
+	protected String execParser(String grammarFileName,
+								String grammarStr,
+								String parserName,
+								String lexerName,
+								String startRuleName,
+								String input, boolean debug,
+								boolean profile)
 	{
 		boolean success = rawGenerateAndBuildRecognizer(grammarFileName,
 														grammarStr,
@@ -567,13 +653,14 @@ public abstract class BaseTest {
 		return rawExecRecognizer(parserName,
 								 lexerName,
 								 startRuleName,
-								 debug);
+								 debug,
+								 profile);
 	}
 
 	/** Return true if all is well */
 	protected boolean rawGenerateAndBuildRecognizer(String grammarFileName,
 													String grammarStr,
-													@Nullable String parserName,
+													String parserName,
 													String lexerName,
 													String... extraOptions)
 	{
@@ -583,13 +670,13 @@ public abstract class BaseTest {
 	/** Return true if all is well */
 	protected boolean rawGenerateAndBuildRecognizer(String grammarFileName,
 													String grammarStr,
-													@Nullable String parserName,
+													String parserName,
 													String lexerName,
 													boolean defaultListener,
 													String... extraOptions)
 	{
 		ErrorQueue equeue =
-			antlr(grammarFileName, grammarFileName, grammarStr, defaultListener, extraOptions);
+			antlr(grammarFileName, grammarStr, defaultListener, extraOptions);
 		if (!equeue.errors.isEmpty()) {
 			return false;
 		}
@@ -615,7 +702,8 @@ public abstract class BaseTest {
 	protected String rawExecRecognizer(String parserName,
 									   String lexerName,
 									   String parserStartRuleName,
-									   boolean debug)
+									   boolean debug,
+									   boolean profile)
 	{
         this.stderrDuringParse = null;
 		if ( parserName==null ) {
@@ -625,7 +713,8 @@ public abstract class BaseTest {
 			writeTestFile(parserName,
 						  lexerName,
 						  parserStartRuleName,
-						  debug);
+						  debug,
+						  profile);
 		}
 
 		compile("Test.java");
@@ -712,8 +801,8 @@ public abstract class BaseTest {
 				"java", "-classpath", tmpdir+pathSep+CLASSPATH,
 				className, new File(tmpdir, "input").getAbsolutePath()
 			};
-			//String cmdLine = "java -classpath "+CLASSPATH+pathSep+tmpdir+" Test " + new File(tmpdir, "input").getAbsolutePath();
-			//System.out.println("execParser: "+cmdLine);
+//			String cmdLine = Utils.join(args, " ");
+//			System.err.println("execParser: "+cmdLine);
 			Process process =
 				Runtime.getRuntime().exec(args, null, new File(tmpdir));
 			StreamVacuum stdoutVacuum = new StreamVacuum(process.getInputStream());
@@ -744,7 +833,7 @@ public abstract class BaseTest {
 
 			String[] lines = input.split("\n");
 			String fileName = getFilenameFromFirstLineOfGrammar(lines[0]);
-			ErrorQueue equeue = antlr(fileName, fileName, input, false);
+			ErrorQueue equeue = antlr(fileName, input, false);
 
 			String actual = equeue.toString(true);
 			actual = actual.replace(tmpdir + File.separator, "");
@@ -813,15 +902,12 @@ public abstract class BaseTest {
 		return filtered;
 	}
 
-	void checkRuleATN(Grammar g, String ruleName, String expecting) {
-		ParserATNFactory f = new ParserATNFactory(g);
-		ATN atn = f.createATN();
-
+	public void checkRuleATN(Grammar g, String ruleName, String expecting) {
 		DOTGenerator dot = new DOTGenerator(g);
-		System.out.println(dot.getDOT(atn.ruleToStartState[g.getRule(ruleName).index]));
+		System.out.println(dot.getDOT(g.atn.ruleToStartState[g.getRule(ruleName).index]));
 
 		Rule r = g.getRule(ruleName);
-		ATNState startState = atn.ruleToStartState[r.index];
+		ATNState startState = g.atn.ruleToStartState[r.index];
 		ATNPrinter serializer = new ATNPrinter(g, startState);
 		String result = serializer.asString();
 
@@ -982,12 +1068,7 @@ public abstract class BaseTest {
 
 	public static void writeFile(String dir, String fileName, String content) {
 		try {
-			File f = new File(dir, fileName);
-			FileWriter w = new FileWriter(f);
-			BufferedWriter bw = new BufferedWriter(w);
-			bw.write(content);
-			bw.close();
-			w.close();
+			Utils.writeFile(dir+"/"+fileName, content, "UTF-8");
 		}
 		catch (IOException ioe) {
 			System.err.println("can't write file");
@@ -1003,11 +1084,14 @@ public abstract class BaseTest {
 	protected void writeTestFile(String parserName,
 								 String lexerName,
 								 String parserStartRuleName,
-								 boolean debug)
+								 boolean debug,
+								 boolean profile)
 	{
 		ST outputFileST = new ST(
 			"import org.antlr.v4.runtime.*;\n" +
 			"import org.antlr.v4.runtime.tree.*;\n" +
+			"import org.antlr.v4.runtime.atn.*;\n" +
+			"import java.util.Arrays;\n"+
 			"\n" +
 			"public class Test {\n" +
 			"    public static void main(String[] args) throws Exception {\n" +
@@ -1016,7 +1100,9 @@ public abstract class BaseTest {
 			"        CommonTokenStream tokens = new CommonTokenStream(lex);\n" +
 			"        <createParser>\n"+
 			"		 parser.setBuildParseTree(true);\n" +
+			"		 <profile>\n"+
 			"        ParserRuleContext tree = parser.<parserStartRuleName>();\n" +
+			"		 <if(profile)>System.out.println(Arrays.toString(profiler.getDecisionInfo()));<endif>\n" +
 			"        ParseTreeWalker.DEFAULT.walk(new TreeShapeListener(), tree);\n" +
 			"    }\n" +
 			"\n" +
@@ -1044,6 +1130,14 @@ public abstract class BaseTest {
 				"        <parserName> parser = new <parserName>(tokens);\n" +
                 "        parser.addErrorListener(new DiagnosticErrorListener());\n");
 		}
+		if ( profile ) {
+			outputFileST.add("profile",
+							 "ProfilingATNSimulator profiler = new ProfilingATNSimulator(parser);\n" +
+							 "parser.setInterpreter(profiler);");
+		}
+		else {
+			outputFileST.add("profile", new ArrayList<Object>());
+		}
 		outputFileST.add("createParser", createParserST);
 		outputFileST.add("parserName", parserName);
 		outputFileST.add("lexerName", lexerName);
@@ -1073,7 +1167,8 @@ public abstract class BaseTest {
 
 	public void writeRecognizerAndCompile(String parserName, String lexerName,
 										  String parserStartRuleName,
-										  boolean debug) {
+										  boolean debug,
+										  boolean profile) {
 		if ( parserName==null ) {
 			writeLexerTestFile(lexerName, debug);
 		}
@@ -1081,7 +1176,8 @@ public abstract class BaseTest {
 			writeTestFile(parserName,
 						  lexerName,
 						  parserStartRuleName,
-						  debug);
+						  debug,
+						  profile);
 		}
 
 		compile("Test.java");
@@ -1170,7 +1266,7 @@ public abstract class BaseTest {
 	}
 
 	public static class IntTokenStream implements TokenStream {
-		IntegerList types;
+		public IntegerList types;
 		int p=0;
 		public IntTokenStream(IntegerList types) { this.types = types; }
 
@@ -1205,7 +1301,7 @@ public abstract class BaseTest {
 
 		@Override
 		public String getSourceName() {
-			return null;
+			return UNKNOWN_SOURCE_NAME;
 		}
 
 		@Override
@@ -1228,25 +1324,25 @@ public abstract class BaseTest {
 			return null;
 		}
 
-		@NotNull
+
 		@Override
 		public String getText() {
 			throw new UnsupportedOperationException("can't give strings");
 		}
 
-		@NotNull
+
 		@Override
 		public String getText(Interval interval) {
 			throw new UnsupportedOperationException("can't give strings");
 		}
 
-		@NotNull
+
 		@Override
 		public String getText(RuleContext ctx) {
 			throw new UnsupportedOperationException("can't give strings");
 		}
 
-		@NotNull
+
 		@Override
 		public String getText(Token start, Token stop) {
 			throw new UnsupportedOperationException("can't give strings");
diff --git a/tool/test/org/antlr/v4/test/ErrorQueue.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/java/ErrorQueue.java
similarity index 98%
rename from tool/test/org/antlr/v4/test/ErrorQueue.java
rename to runtime-testsuite/test/org/antlr/v4/test/runtime/java/ErrorQueue.java
index 91295bace..3736c6bde 100644
--- a/tool/test/org/antlr/v4/test/ErrorQueue.java
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/java/ErrorQueue.java
@@ -27,7 +27,7 @@
  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-package org.antlr.v4.test;
+package org.antlr.v4.test.runtime.java;
 
 import org.antlr.v4.Tool;
 import org.antlr.v4.runtime.misc.Utils;
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/java/TestCompositeLexers.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/java/TestCompositeLexers.java
new file mode 100644
index 000000000..16a037b82
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/java/TestCompositeLexers.java
@@ -0,0 +1,70 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.java;
+
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class TestCompositeLexers extends BaseTest {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLexerDelegatorInvokesDelegateRule() throws Exception {
+		mkdir(tmpdir);
+
+		String slave_S =
+			"lexer grammar S;\n" +
+			"A : 'a' {System.out.println(\"S.A\");};\n" +
+			"C : 'c' ;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(61);
+		grammarBuilder.append("lexer grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("B : 'b';\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="abc";
+		String found = execLexer("M.g4", grammar, "M", input, false);
+		assertEquals(
+			"S.A\n" +
+			"[@0,0:0='a',<3>,1:0]\n" +
+			"[@1,1:1='b',<1>,1:1]\n" +
+			"[@2,2:2='c',<4>,1:2]\n" +
+			"[@3,3:2='<EOF>',<-1>,1:3]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLexerDelegatorRuleOverridesDelegate() throws Exception {
+		mkdir(tmpdir);
+
+		String slave_S =
+			"lexer grammar S;\n" +
+			"A : 'a' {System.out.println(\"S.A\");} ;\n" +
+			"B : 'b' {System.out.println(\"S.B\");} ;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(93);
+		grammarBuilder.append("lexer grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("A : 'a' B {System.out.println(\"M.A\");} ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="ab";
+		String found = execLexer("M.g4", grammar, "M", input, false);
+		assertEquals(
+			"M.A\n" +
+			"[@0,0:1='ab',<1>,1:0]\n" +
+			"[@1,2:1='<EOF>',<-1>,1:2]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+
+}
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/java/TestCompositeParsers.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/java/TestCompositeParsers.java
new file mode 100644
index 000000000..9d86fef99
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/java/TestCompositeParsers.java
@@ -0,0 +1,471 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.java;
+
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+import org.antlr.v4.tool.Grammar;
+
+public class TestCompositeParsers extends BaseTest {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testBringInLiteralsFromDelegate() throws Exception {
+		mkdir(tmpdir);
+
+		String slave_S =
+			"parser grammar S;\n" +
+			"a : '=' 'a' {System.out.print(\"S.a\");};";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(54);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("s : a ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="=a";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "s", input, false);
+		assertEquals("S.a\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCombinedImportsCombined() throws Exception {
+		mkdir(tmpdir);
+
+		String slave_S =
+			"parser grammar S;\n" +
+			"tokens { A, B, C }\n" +
+			"x : 'x' INT {System.out.println(\"S.x\");};\n" +
+			"INT : '0'..'9'+ ;\n" +
+			"WS : (' '|'\\n') -> skip ;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(31);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("s : x INT;");
+		String grammar = grammarBuilder.toString();
+
+		writeFile(tmpdir, "M.g4", grammar);
+		ErrorQueue equeue = new ErrorQueue();
+		new Grammar(tmpdir+"/M.g4", grammar, equeue);
+		assertEquals("unexpected errors: " + equeue, 0, equeue.errors.size());
+
+
+		String input ="x 34 9";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "s", input, false);
+		assertEquals("S.x\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDelegatesSeeSameTokenType() throws Exception {
+		mkdir(tmpdir);
+
+		String slave_S =
+			"parser grammar S;\n" +
+			"tokens { A, B, C }\n" +
+			"x : A {System.out.println(\"S.x\");};";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		String slave_T =
+			"parser grammar T;\n" +
+			"tokens { C, B, A } // reverse order\n" +
+			"y : A {System.out.println(\"T.y\");};";
+		writeFile(tmpdir, "T.g4", slave_T);
+
+		StringBuilder grammarBuilder = new StringBuilder(598);
+		grammarBuilder.append("// The lexer will create rules to match letters a, b, c.\n");
+		grammarBuilder.append("// The associated token types A, B, C must have the same value\n");
+		grammarBuilder.append("// and all import'd parsers.  Since ANTLR regenerates all imports\n");
+		grammarBuilder.append("// for use with the delegator M, it can generate the same token type\n");
+		grammarBuilder.append("// mapping in each parser:\n");
+		grammarBuilder.append("// public static final int C=6;\n");
+		grammarBuilder.append("// public static final int EOF=-1;\n");
+		grammarBuilder.append("// public static final int B=5;\n");
+		grammarBuilder.append("// public static final int WS=7;\n");
+		grammarBuilder.append("// public static final int A=4;\n");
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S,T;\n");
+		grammarBuilder.append("s : x y ; // matches AA, which should be 'aa'\n");
+		grammarBuilder.append("B : 'b' ; // another order: B, A, C\n");
+		grammarBuilder.append("A : 'a' ; \n");
+		grammarBuilder.append("C : 'c' ; \n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+		writeFile(tmpdir, "M.g4", grammar);
+		ErrorQueue equeue = new ErrorQueue();
+		Grammar g = new Grammar(tmpdir+"/M.g4", grammar, equeue);
+		String expectedTokenIDToTypeMap = "{EOF=-1, B=1, A=2, C=3, WS=4}";
+		String expectedStringLiteralToTypeMap = "{'a'=2, 'b'=1, 'c'=3}";
+		String expectedTypeToTokenList = "[B, A, C, WS]";
+		assertEquals(expectedTokenIDToTypeMap, g.tokenNameToTypeMap.toString());
+		assertEquals(expectedStringLiteralToTypeMap, sort(g.stringLiteralToTypeMap).toString());
+		assertEquals(expectedTypeToTokenList, realElements(g.typeToTokenList).toString());
+		assertEquals("unexpected errors: "+equeue, 0, equeue.errors.size());
+
+
+		String input ="aa";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "s", input, false);
+		assertEquals(
+			"S.x\n" +
+			"T.y\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDelegatorAccessesDelegateMembers() throws Exception {
+		mkdir(tmpdir);
+
+		String slave_S =
+			"parser grammar S;\n" +
+			"@parser::members {\n" +
+			"	public void foo() {System.out.println(\"foo\");}\n" +
+			"}\n" +
+			"a : B;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(122);
+		grammarBuilder.append("grammar M; // uses no rules from the import\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("s : 'b' {foo();} ; // gS is import pointer\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="b";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "s", input, false);
+		assertEquals("foo\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDelegatorInvokesDelegateRule() throws Exception {
+		mkdir(tmpdir);
+
+		String slave_S =
+			"parser grammar S;\n" +
+			"a : B {System.out.println(\"S.a\");};";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(104);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("s : a ;\n");
+		grammarBuilder.append("B : 'b' ; // defines B from inherited token space\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="b";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "s", input, false);
+		assertEquals("S.a\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDelegatorInvokesDelegateRuleWithArgs() throws Exception {
+		mkdir(tmpdir);
+
+		String slave_S =
+			"parser grammar S;\n" +
+			"a[int x] returns [int y] : B {System.out.print(\"S.a\");} {$y=1000;} ;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(145);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("s : label=a[3] {System.out.println($label.y);} ;\n");
+		grammarBuilder.append("B : 'b' ; // defines B from inherited token space\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="b";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "s", input, false);
+		assertEquals("S.a1000\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDelegatorInvokesDelegateRuleWithReturnStruct() throws Exception {
+		mkdir(tmpdir);
+
+		String slave_S =
+			"parser grammar S;\n" +
+			"a : B {System.out.print(\"S.a\");} ;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(133);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("s : a {System.out.print($a.text);} ;\n");
+		grammarBuilder.append("B : 'b' ; // defines B from inherited token space\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="b";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "s", input, false);
+		assertEquals("S.ab\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDelegatorInvokesFirstVersionOfDelegateRule() throws Exception {
+		mkdir(tmpdir);
+
+		String slave_S =
+			"parser grammar S;\n" +
+			"a : b {System.out.println(\"S.a\");};\n" +
+			"b : B;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		String slave_T =
+			"parser grammar T;\n" +
+			"a : B {System.out.println(\"T.a\");};";
+		writeFile(tmpdir, "T.g4", slave_T);
+
+		StringBuilder grammarBuilder = new StringBuilder(106);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S,T;\n");
+		grammarBuilder.append("s : a ;\n");
+		grammarBuilder.append("B : 'b' ; // defines B from inherited token space\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="b";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "s", input, false);
+		assertEquals("S.a\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDelegatorRuleOverridesDelegate() throws Exception {
+		mkdir(tmpdir);
+
+		String slave_S =
+			"parser grammar S;\n" +
+			"a : b {System.out.print(\"S.a\");};\n" +
+			"b : B ;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(59);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("b : 'b'|'c';\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="c";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "a", input, false);
+		assertEquals("S.a\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDelegatorRuleOverridesDelegates() throws Exception {
+		mkdir(tmpdir);
+
+		String slave_S =
+			"parser grammar S;\n" +
+			"a : b {System.out.println(\"S.a\");};\n" +
+			"b : 'b' ;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		String slave_T =
+			"parser grammar T;\n" +
+			"tokens { A }\n" +
+			"b : 'b' {System.out.println(\"T.b\");};";
+		writeFile(tmpdir, "T.g4", slave_T);
+
+		StringBuilder grammarBuilder = new StringBuilder(95);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S, T;\n");
+		grammarBuilder.append("b : 'b'|'c' {System.out.println(\"M.b\");}|B|A;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="c";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "a", input, false);
+		assertEquals(
+			"M.b\n" +
+			"S.a\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDelegatorRuleOverridesLookaheadInDelegate() throws Exception {
+		mkdir(tmpdir);
+
+		String slave_S =
+			"parser grammar S;\n" +
+			"type_ : 'int' ;\n" +
+			"decl : type_ ID ';'\n" +
+			"	| type_ ID init ';' {System.out.print(\"JavaDecl: \" + $text);};\n" +
+			"init : '=' INT;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(121);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("prog : decl ;\n");
+		grammarBuilder.append("type_ : 'int' | 'float' ;\n");
+		grammarBuilder.append("ID  : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="float x = 3;";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "prog", input, false);
+		assertEquals("JavaDecl: floatx=3;\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testImportLexerWithOnlyFragmentRules() throws Exception {
+		mkdir(tmpdir);
+
+		String slave_Unicode =
+			"lexer grammar Unicode;\n" +
+			"\n" +
+			"fragment\n" +
+			"UNICODE_CLASS_Zs    : '\\u0020' | '\\u00A0' | '\\u1680' | '\\u180E'\n" +
+			"                    | '\\u2000'..'\\u200A'\n" +
+			"                    | '\\u202F' | '\\u205F' | '\\u3000'\n" +
+			"                    ;\n";
+		writeFile(tmpdir, "Unicode.g4", slave_Unicode);
+
+		StringBuilder grammarBuilder = new StringBuilder(91);
+		grammarBuilder.append("grammar Test;\n");
+		grammarBuilder.append("import Unicode;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("program : 'test' 'test';\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("WS : (UNICODE_CLASS_Zs)+ -> skip;\n");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="test test";
+		String found = execParser("Test.g4", grammar, "TestParser", "TestLexer", "program", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testImportedGrammarWithEmptyOptions() throws Exception {
+		mkdir(tmpdir);
+
+		String slave_S =
+			"parser grammar S;\n" +
+			"options {}\n" +
+			"a : B ;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(64);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("s : a ;\n");
+		grammarBuilder.append("B : 'b' ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="b";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "s", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testImportedRuleWithAction() throws Exception {
+		mkdir(tmpdir);
+
+		String slave_S =
+			"parser grammar S;\n" +
+			"a @after {int x = 0;} : B;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(62);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("s : a;\n");
+		grammarBuilder.append("B : 'b';\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="b";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "s", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testKeywordVSIDOrder() throws Exception {
+		mkdir(tmpdir);
+
+		String slave_S =
+			"lexer grammar S;\n" +
+			"ID : 'a'..'z'+;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(129);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("a : A {System.out.println(\"M.a: \" + $A);};\n");
+		grammarBuilder.append("A : 'abc' {System.out.println(\"M.A\");};\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="abc";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "a", input, false);
+		assertEquals(
+			"M.A\n" +
+			"M.a: [@0,0:2='abc',<1>,1:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+
+}
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/java/TestFullContextParsing.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/java/TestFullContextParsing.java
new file mode 100644
index 000000000..f17b69347
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/java/TestFullContextParsing.java
@@ -0,0 +1,491 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.java;
+
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class TestFullContextParsing extends BaseTest {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAmbigYieldsCtxSensitiveDFA() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(101);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {this.dumpDFA();}\n");
+		grammarBuilder.append("	: ID | ID {} ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="abc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, true);
+		assertEquals(
+			"Decision 0:\n" +
+			"s0-ID->:s1^=>1\n", found);
+
+		assertEquals("line 1:0 reportAttemptingFullContext d=0 (s), input='abc'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAmbiguityNoLoop() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(217);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("prog\n");
+		grammarBuilder.append("@init {_interp.setPredictionMode(PredictionMode.LL_EXACT_AMBIG_DETECTION);}\n");
+		grammarBuilder.append("	: expr expr {System.out.println(\"alt 1\");}\n");
+		grammarBuilder.append("	| expr\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("expr: '@'\n");
+		grammarBuilder.append("	| ID '@'\n");
+		grammarBuilder.append("	| ID\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("ID  : [a-z]+ ;\n");
+		grammarBuilder.append("WS  : [ \\r\\n\\t]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a@";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "prog", input, true);
+		assertEquals("alt 1\n", found);
+
+		assertEquals(
+			"line 1:2 reportAttemptingFullContext d=0 (prog), input='a@'\n" +
+			"line 1:2 reportAmbiguity d=0 (prog): ambigAlts={1, 2}, input='a@'\n" +
+			"line 1:2 reportAttemptingFullContext d=1 (expr), input='a@'\n" +
+			"line 1:2 reportContextSensitivity d=1 (expr), input='a@'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCtxSensitiveDFATwoDiffInput() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(165);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {this.dumpDFA();}\n");
+		grammarBuilder.append("  : ('$' a | '@' b)+ ;\n");
+		grammarBuilder.append("a : e ID ;\n");
+		grammarBuilder.append("b : e INT ID ;\n");
+		grammarBuilder.append("e : INT | ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="$ 34 abc @ 34 abc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, true);
+		assertEquals(
+			"Decision 2:\n" +
+			"s0-INT->s1\n" +
+			"s1-ID->:s2^=>1\n", found);
+
+		assertEquals(
+			"line 1:5 reportAttemptingFullContext d=2 (e), input='34abc'\n" +
+			"line 1:2 reportContextSensitivity d=2 (e), input='34'\n" +
+			"line 1:14 reportAttemptingFullContext d=2 (e), input='34abc'\n" +
+			"line 1:14 reportContextSensitivity d=2 (e), input='34abc'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCtxSensitiveDFA_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(162);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {this.dumpDFA();}\n");
+		grammarBuilder.append("  : '$' a | '@' b ;\n");
+		grammarBuilder.append("a : e ID ;\n");
+		grammarBuilder.append("b : e INT ID ;\n");
+		grammarBuilder.append("e : INT | ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="$ 34 abc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, true);
+		assertEquals(
+			"Decision 1:\n" +
+			"s0-INT->s1\n" +
+			"s1-ID->:s2^=>1\n", found);
+
+		assertEquals(
+			"line 1:5 reportAttemptingFullContext d=1 (e), input='34abc'\n" +
+			"line 1:2 reportContextSensitivity d=1 (e), input='34'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCtxSensitiveDFA_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(162);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {this.dumpDFA();}\n");
+		grammarBuilder.append("  : '$' a | '@' b ;\n");
+		grammarBuilder.append("a : e ID ;\n");
+		grammarBuilder.append("b : e INT ID ;\n");
+		grammarBuilder.append("e : INT | ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="@ 34 abc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, true);
+		assertEquals(
+			"Decision 1:\n" +
+			"s0-INT->s1\n" +
+			"s1-ID->:s2^=>1\n", found);
+
+		assertEquals(
+			"line 1:5 reportAttemptingFullContext d=1 (e), input='34abc'\n" +
+			"line 1:5 reportContextSensitivity d=1 (e), input='34abc'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExprAmbiguity_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(291);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {_interp.setPredictionMode(PredictionMode.LL_EXACT_AMBIG_DETECTION);}\n");
+		grammarBuilder.append(":   expr[0] {System.out.println($expr.ctx.toStringTree(this));};\n");
+		grammarBuilder.append("	expr[int _p]\n");
+		grammarBuilder.append("		: ID \n");
+		grammarBuilder.append("		( \n");
+		grammarBuilder.append("			{5 >= $_p}? '*' expr[6]\n");
+		grammarBuilder.append("			| {4 >= $_p}? '+' expr[5]\n");
+		grammarBuilder.append("		)*\n");
+		grammarBuilder.append("		;\n");
+		grammarBuilder.append("ID  : [a-zA-Z]+ ;\n");
+		grammarBuilder.append("WS  : [ \\r\\n\\t]+ -> skip ;\n");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a+b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, true);
+		assertEquals("(expr a + (expr b))\n", found);
+
+		assertEquals(
+			"line 1:1 reportAttemptingFullContext d=1 (expr), input='+'\n" +
+			"line 1:2 reportContextSensitivity d=1 (expr), input='+b'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExprAmbiguity_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(291);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {_interp.setPredictionMode(PredictionMode.LL_EXACT_AMBIG_DETECTION);}\n");
+		grammarBuilder.append(":   expr[0] {System.out.println($expr.ctx.toStringTree(this));};\n");
+		grammarBuilder.append("	expr[int _p]\n");
+		grammarBuilder.append("		: ID \n");
+		grammarBuilder.append("		( \n");
+		grammarBuilder.append("			{5 >= $_p}? '*' expr[6]\n");
+		grammarBuilder.append("			| {4 >= $_p}? '+' expr[5]\n");
+		grammarBuilder.append("		)*\n");
+		grammarBuilder.append("		;\n");
+		grammarBuilder.append("ID  : [a-zA-Z]+ ;\n");
+		grammarBuilder.append("WS  : [ \\r\\n\\t]+ -> skip ;\n");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a+b*c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, true);
+		assertEquals("(expr a + (expr b * (expr c)))\n", found);
+
+		assertEquals(
+			"line 1:1 reportAttemptingFullContext d=1 (expr), input='+'\n" +
+			"line 1:2 reportContextSensitivity d=1 (expr), input='+b'\n" +
+			"line 1:3 reportAttemptingFullContext d=1 (expr), input='*'\n" +
+			"line 1:5 reportAmbiguity d=1 (expr): ambigAlts={1, 2}, input='*c'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testFullContextIF_THEN_ELSEParse_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(238);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s \n");
+		grammarBuilder.append("@init {_interp.setPredictionMode(PredictionMode.LL_EXACT_AMBIG_DETECTION);}\n");
+		grammarBuilder.append("@after {this.dumpDFA();}\n");
+		grammarBuilder.append("	: '{' stat* '}' ;\n");
+		grammarBuilder.append("stat: 'if' ID 'then' stat ('else' ID)?\n");
+		grammarBuilder.append("		| 'return'\n");
+		grammarBuilder.append("		;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="{ if x then return }";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, true);
+		assertEquals(
+			"Decision 1:\n" +
+			"s0-'}'->:s1=>2\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testFullContextIF_THEN_ELSEParse_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(238);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s \n");
+		grammarBuilder.append("@init {_interp.setPredictionMode(PredictionMode.LL_EXACT_AMBIG_DETECTION);}\n");
+		grammarBuilder.append("@after {this.dumpDFA();}\n");
+		grammarBuilder.append("	: '{' stat* '}' ;\n");
+		grammarBuilder.append("stat: 'if' ID 'then' stat ('else' ID)?\n");
+		grammarBuilder.append("		| 'return'\n");
+		grammarBuilder.append("		;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="{ if x then return else foo }";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, true);
+		assertEquals(
+			"Decision 1:\n" +
+			"s0-'else'->:s1^=>1\n", found);
+
+		assertEquals(
+			"line 1:19 reportAttemptingFullContext d=1 (stat), input='else'\n" +
+			"line 1:19 reportContextSensitivity d=1 (stat), input='else'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testFullContextIF_THEN_ELSEParse_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(238);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s \n");
+		grammarBuilder.append("@init {_interp.setPredictionMode(PredictionMode.LL_EXACT_AMBIG_DETECTION);}\n");
+		grammarBuilder.append("@after {this.dumpDFA();}\n");
+		grammarBuilder.append("	: '{' stat* '}' ;\n");
+		grammarBuilder.append("stat: 'if' ID 'then' stat ('else' ID)?\n");
+		grammarBuilder.append("		| 'return'\n");
+		grammarBuilder.append("		;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="{ if x then if y then return else foo }";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, true);
+		assertEquals(
+			"Decision 1:\n" +
+			"s0-'}'->:s2=>2\n" +
+			"s0-'else'->:s1^=>1\n", found);
+
+		assertEquals(
+			"line 1:29 reportAttemptingFullContext d=1 (stat), input='else'\n" +
+			"line 1:38 reportAmbiguity d=1 (stat): ambigAlts={1, 2}, input='elsefoo}'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testFullContextIF_THEN_ELSEParse_4() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(238);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s \n");
+		grammarBuilder.append("@init {_interp.setPredictionMode(PredictionMode.LL_EXACT_AMBIG_DETECTION);}\n");
+		grammarBuilder.append("@after {this.dumpDFA();}\n");
+		grammarBuilder.append("	: '{' stat* '}' ;\n");
+		grammarBuilder.append("stat: 'if' ID 'then' stat ('else' ID)?\n");
+		grammarBuilder.append("		| 'return'\n");
+		grammarBuilder.append("		;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="{ if x then if y then return else foo else bar }";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, true);
+		assertEquals(
+			"Decision 1:\n" +
+			"s0-'else'->:s1^=>1\n", found);
+
+		assertEquals(
+			"line 1:29 reportAttemptingFullContext d=1 (stat), input='else'\n" +
+			"line 1:38 reportContextSensitivity d=1 (stat), input='elsefooelse'\n" +
+			"line 1:38 reportAttemptingFullContext d=1 (stat), input='else'\n" +
+			"line 1:38 reportContextSensitivity d=1 (stat), input='else'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testFullContextIF_THEN_ELSEParse_5() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(238);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s \n");
+		grammarBuilder.append("@init {_interp.setPredictionMode(PredictionMode.LL_EXACT_AMBIG_DETECTION);}\n");
+		grammarBuilder.append("@after {this.dumpDFA();}\n");
+		grammarBuilder.append("	: '{' stat* '}' ;\n");
+		grammarBuilder.append("stat: 'if' ID 'then' stat ('else' ID)?\n");
+		grammarBuilder.append("		| 'return'\n");
+		grammarBuilder.append("		;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input =
+			"{ if x then return else foo\n" +
+			"if x then if y then return else foo }";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, true);
+		assertEquals(
+			"Decision 1:\n" +
+			"s0-'}'->:s2=>2\n" +
+			"s0-'else'->:s1^=>1\n", found);
+
+		assertEquals(
+			"line 1:19 reportAttemptingFullContext d=1 (stat), input='else'\n" +
+			"line 1:19 reportContextSensitivity d=1 (stat), input='else'\n" +
+			"line 2:27 reportAttemptingFullContext d=1 (stat), input='else'\n" +
+			"line 2:36 reportAmbiguity d=1 (stat): ambigAlts={1, 2}, input='elsefoo}'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testFullContextIF_THEN_ELSEParse_6() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(238);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s \n");
+		grammarBuilder.append("@init {_interp.setPredictionMode(PredictionMode.LL_EXACT_AMBIG_DETECTION);}\n");
+		grammarBuilder.append("@after {this.dumpDFA();}\n");
+		grammarBuilder.append("	: '{' stat* '}' ;\n");
+		grammarBuilder.append("stat: 'if' ID 'then' stat ('else' ID)?\n");
+		grammarBuilder.append("		| 'return'\n");
+		grammarBuilder.append("		;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input =
+			"{ if x then return else foo\n" +
+			"if x then if y then return else foo }";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, true);
+		assertEquals(
+			"Decision 1:\n" +
+			"s0-'}'->:s2=>2\n" +
+			"s0-'else'->:s1^=>1\n", found);
+
+		assertEquals(
+			"line 1:19 reportAttemptingFullContext d=1 (stat), input='else'\n" +
+			"line 1:19 reportContextSensitivity d=1 (stat), input='else'\n" +
+			"line 2:27 reportAttemptingFullContext d=1 (stat), input='else'\n" +
+			"line 2:36 reportAmbiguity d=1 (stat): ambigAlts={1, 2}, input='elsefoo}'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLoopsSimulateTailRecursion() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(324);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("prog\n");
+		grammarBuilder.append("@init {_interp.setPredictionMode(PredictionMode.LL_EXACT_AMBIG_DETECTION);}\n");
+		grammarBuilder.append("	: expr_or_assign*;\n");
+		grammarBuilder.append("expr_or_assign\n");
+		grammarBuilder.append("	: expr '++' {System.out.println(\"fail.\");}\n");
+		grammarBuilder.append("	|  expr {System.out.println(\"pass: \"+$expr.text);}\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("expr: expr_primary ('<-' ID)?;\n");
+		grammarBuilder.append("expr_primary\n");
+		grammarBuilder.append("	: '(' ID ')'\n");
+		grammarBuilder.append("	| ID '(' ID ')'\n");
+		grammarBuilder.append("	| ID\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("ID  : [a-z]+ ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a(i)<-x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "prog", input, true);
+		assertEquals("pass: a(i)<-x\n", found);
+
+		assertEquals(
+			"line 1:3 reportAttemptingFullContext d=3 (expr_primary), input='a(i)'\n" +
+			"line 1:7 reportAmbiguity d=3 (expr_primary): ambigAlts={2, 3}, input='a(i)<-x'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSLLSeesEOFInLLGrammar() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(149);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {this.dumpDFA();}\n");
+		grammarBuilder.append("  : a;\n");
+		grammarBuilder.append("a : e ID ;\n");
+		grammarBuilder.append("b : e INT ID ;\n");
+		grammarBuilder.append("e : INT | ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="34 abc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, true);
+		assertEquals(
+			"Decision 0:\n" +
+			"s0-INT->s1\n" +
+			"s1-ID->:s2^=>1\n", found);
+
+		assertEquals(
+			"line 1:3 reportAttemptingFullContext d=0 (e), input='34abc'\n" +
+			"line 1:0 reportContextSensitivity d=0 (e), input='34'\n", this.stderrDuringParse);
+
+	}
+
+
+}
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/java/TestLeftRecursion.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/java/TestLeftRecursion.java
new file mode 100644
index 000000000..2f72610f3
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/java/TestLeftRecursion.java
@@ -0,0 +1,3307 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.java;
+
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class TestLeftRecursion extends BaseTest {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAmbigLR_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(705);
+		grammarBuilder.append("grammar Expr;\n");
+		grammarBuilder.append("prog:   stat ;\n");
+		grammarBuilder.append("stat:   expr NEWLINE                # printExpr\n");
+		grammarBuilder.append("    |   ID '=' expr NEWLINE         # assign\n");
+		grammarBuilder.append("    |   NEWLINE                     # blank\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("expr:   expr ('*'|'/') expr      # MulDiv\n");
+		grammarBuilder.append("    |   expr ('+'|'-') expr      # AddSub\n");
+		grammarBuilder.append("    |   INT                      # int\n");
+		grammarBuilder.append("    |   ID                       # id\n");
+		grammarBuilder.append("    |   '(' expr ')'             # parens\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("MUL :   '*' ; // assigns token name to '*' used above in grammar\n");
+		grammarBuilder.append("DIV :   '/' ;\n");
+		grammarBuilder.append("ADD :   '+' ;\n");
+		grammarBuilder.append("SUB :   '-' ;\n");
+		grammarBuilder.append("ID  :   [a-zA-Z]+ ;      // match identifiers\n");
+		grammarBuilder.append("INT :   [0-9]+ ;         // match integers\n");
+		grammarBuilder.append("NEWLINE:'\\r'? '\\n' ;     // return newlines to parser (is end-statement signal)\n");
+		grammarBuilder.append("WS  :   [ \\t]+ -> skip ; // toss out whitespace");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="1\n";
+		String found = execParser("Expr.g4", grammar, "ExprParser", "ExprLexer", "prog", input, true);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAmbigLR_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(705);
+		grammarBuilder.append("grammar Expr;\n");
+		grammarBuilder.append("prog:   stat ;\n");
+		grammarBuilder.append("stat:   expr NEWLINE                # printExpr\n");
+		grammarBuilder.append("    |   ID '=' expr NEWLINE         # assign\n");
+		grammarBuilder.append("    |   NEWLINE                     # blank\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("expr:   expr ('*'|'/') expr      # MulDiv\n");
+		grammarBuilder.append("    |   expr ('+'|'-') expr      # AddSub\n");
+		grammarBuilder.append("    |   INT                      # int\n");
+		grammarBuilder.append("    |   ID                       # id\n");
+		grammarBuilder.append("    |   '(' expr ')'             # parens\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("MUL :   '*' ; // assigns token name to '*' used above in grammar\n");
+		grammarBuilder.append("DIV :   '/' ;\n");
+		grammarBuilder.append("ADD :   '+' ;\n");
+		grammarBuilder.append("SUB :   '-' ;\n");
+		grammarBuilder.append("ID  :   [a-zA-Z]+ ;      // match identifiers\n");
+		grammarBuilder.append("INT :   [0-9]+ ;         // match integers\n");
+		grammarBuilder.append("NEWLINE:'\\r'? '\\n' ;     // return newlines to parser (is end-statement signal)\n");
+		grammarBuilder.append("WS  :   [ \\t]+ -> skip ; // toss out whitespace");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a = 5\n";
+		String found = execParser("Expr.g4", grammar, "ExprParser", "ExprLexer", "prog", input, true);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAmbigLR_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(705);
+		grammarBuilder.append("grammar Expr;\n");
+		grammarBuilder.append("prog:   stat ;\n");
+		grammarBuilder.append("stat:   expr NEWLINE                # printExpr\n");
+		grammarBuilder.append("    |   ID '=' expr NEWLINE         # assign\n");
+		grammarBuilder.append("    |   NEWLINE                     # blank\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("expr:   expr ('*'|'/') expr      # MulDiv\n");
+		grammarBuilder.append("    |   expr ('+'|'-') expr      # AddSub\n");
+		grammarBuilder.append("    |   INT                      # int\n");
+		grammarBuilder.append("    |   ID                       # id\n");
+		grammarBuilder.append("    |   '(' expr ')'             # parens\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("MUL :   '*' ; // assigns token name to '*' used above in grammar\n");
+		grammarBuilder.append("DIV :   '/' ;\n");
+		grammarBuilder.append("ADD :   '+' ;\n");
+		grammarBuilder.append("SUB :   '-' ;\n");
+		grammarBuilder.append("ID  :   [a-zA-Z]+ ;      // match identifiers\n");
+		grammarBuilder.append("INT :   [0-9]+ ;         // match integers\n");
+		grammarBuilder.append("NEWLINE:'\\r'? '\\n' ;     // return newlines to parser (is end-statement signal)\n");
+		grammarBuilder.append("WS  :   [ \\t]+ -> skip ; // toss out whitespace");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="b = 6\n";
+		String found = execParser("Expr.g4", grammar, "ExprParser", "ExprLexer", "prog", input, true);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAmbigLR_4() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(705);
+		grammarBuilder.append("grammar Expr;\n");
+		grammarBuilder.append("prog:   stat ;\n");
+		grammarBuilder.append("stat:   expr NEWLINE                # printExpr\n");
+		grammarBuilder.append("    |   ID '=' expr NEWLINE         # assign\n");
+		grammarBuilder.append("    |   NEWLINE                     # blank\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("expr:   expr ('*'|'/') expr      # MulDiv\n");
+		grammarBuilder.append("    |   expr ('+'|'-') expr      # AddSub\n");
+		grammarBuilder.append("    |   INT                      # int\n");
+		grammarBuilder.append("    |   ID                       # id\n");
+		grammarBuilder.append("    |   '(' expr ')'             # parens\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("MUL :   '*' ; // assigns token name to '*' used above in grammar\n");
+		grammarBuilder.append("DIV :   '/' ;\n");
+		grammarBuilder.append("ADD :   '+' ;\n");
+		grammarBuilder.append("SUB :   '-' ;\n");
+		grammarBuilder.append("ID  :   [a-zA-Z]+ ;      // match identifiers\n");
+		grammarBuilder.append("INT :   [0-9]+ ;         // match integers\n");
+		grammarBuilder.append("NEWLINE:'\\r'? '\\n' ;     // return newlines to parser (is end-statement signal)\n");
+		grammarBuilder.append("WS  :   [ \\t]+ -> skip ; // toss out whitespace");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a+b*2\n";
+		String found = execParser("Expr.g4", grammar, "ExprParser", "ExprLexer", "prog", input, true);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAmbigLR_5() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(705);
+		grammarBuilder.append("grammar Expr;\n");
+		grammarBuilder.append("prog:   stat ;\n");
+		grammarBuilder.append("stat:   expr NEWLINE                # printExpr\n");
+		grammarBuilder.append("    |   ID '=' expr NEWLINE         # assign\n");
+		grammarBuilder.append("    |   NEWLINE                     # blank\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("expr:   expr ('*'|'/') expr      # MulDiv\n");
+		grammarBuilder.append("    |   expr ('+'|'-') expr      # AddSub\n");
+		grammarBuilder.append("    |   INT                      # int\n");
+		grammarBuilder.append("    |   ID                       # id\n");
+		grammarBuilder.append("    |   '(' expr ')'             # parens\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("MUL :   '*' ; // assigns token name to '*' used above in grammar\n");
+		grammarBuilder.append("DIV :   '/' ;\n");
+		grammarBuilder.append("ADD :   '+' ;\n");
+		grammarBuilder.append("SUB :   '-' ;\n");
+		grammarBuilder.append("ID  :   [a-zA-Z]+ ;      // match identifiers\n");
+		grammarBuilder.append("INT :   [0-9]+ ;         // match integers\n");
+		grammarBuilder.append("NEWLINE:'\\r'? '\\n' ;     // return newlines to parser (is end-statement signal)\n");
+		grammarBuilder.append("WS  :   [ \\t]+ -> skip ; // toss out whitespace");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="(1+2)*3\n";
+		String found = execParser("Expr.g4", grammar, "ExprParser", "ExprLexer", "prog", input, true);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDeclarations_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(399);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : declarator EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("declarator\n");
+		grammarBuilder.append("        : declarator '[' e ']'\n");
+		grammarBuilder.append("        | declarator '[' ']'\n");
+		grammarBuilder.append("        | declarator '(' ')'\n");
+		grammarBuilder.append("        | '*' declarator // binds less tight than suffixes\n");
+		grammarBuilder.append("        | '(' declarator ')'\n");
+		grammarBuilder.append("        | ID\n");
+		grammarBuilder.append("        ;\n");
+		grammarBuilder.append("e : INT ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (declarator a) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDeclarations_10() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(399);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : declarator EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("declarator\n");
+		grammarBuilder.append("        : declarator '[' e ']'\n");
+		grammarBuilder.append("        | declarator '[' ']'\n");
+		grammarBuilder.append("        | declarator '(' ')'\n");
+		grammarBuilder.append("        | '*' declarator // binds less tight than suffixes\n");
+		grammarBuilder.append("        | '(' declarator ')'\n");
+		grammarBuilder.append("        | ID\n");
+		grammarBuilder.append("        ;\n");
+		grammarBuilder.append("e : INT ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="(*a)[]";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (declarator (declarator ( (declarator * (declarator a)) )) [ ]) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDeclarations_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(399);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : declarator EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("declarator\n");
+		grammarBuilder.append("        : declarator '[' e ']'\n");
+		grammarBuilder.append("        | declarator '[' ']'\n");
+		grammarBuilder.append("        | declarator '(' ')'\n");
+		grammarBuilder.append("        | '*' declarator // binds less tight than suffixes\n");
+		grammarBuilder.append("        | '(' declarator ')'\n");
+		grammarBuilder.append("        | ID\n");
+		grammarBuilder.append("        ;\n");
+		grammarBuilder.append("e : INT ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="*a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (declarator * (declarator a)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDeclarations_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(399);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : declarator EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("declarator\n");
+		grammarBuilder.append("        : declarator '[' e ']'\n");
+		grammarBuilder.append("        | declarator '[' ']'\n");
+		grammarBuilder.append("        | declarator '(' ')'\n");
+		grammarBuilder.append("        | '*' declarator // binds less tight than suffixes\n");
+		grammarBuilder.append("        | '(' declarator ')'\n");
+		grammarBuilder.append("        | ID\n");
+		grammarBuilder.append("        ;\n");
+		grammarBuilder.append("e : INT ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="**a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (declarator * (declarator * (declarator a))) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDeclarations_4() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(399);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : declarator EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("declarator\n");
+		grammarBuilder.append("        : declarator '[' e ']'\n");
+		grammarBuilder.append("        | declarator '[' ']'\n");
+		grammarBuilder.append("        | declarator '(' ')'\n");
+		grammarBuilder.append("        | '*' declarator // binds less tight than suffixes\n");
+		grammarBuilder.append("        | '(' declarator ')'\n");
+		grammarBuilder.append("        | ID\n");
+		grammarBuilder.append("        ;\n");
+		grammarBuilder.append("e : INT ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a[3]";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (declarator (declarator a) [ (e 3) ]) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDeclarations_5() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(399);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : declarator EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("declarator\n");
+		grammarBuilder.append("        : declarator '[' e ']'\n");
+		grammarBuilder.append("        | declarator '[' ']'\n");
+		grammarBuilder.append("        | declarator '(' ')'\n");
+		grammarBuilder.append("        | '*' declarator // binds less tight than suffixes\n");
+		grammarBuilder.append("        | '(' declarator ')'\n");
+		grammarBuilder.append("        | ID\n");
+		grammarBuilder.append("        ;\n");
+		grammarBuilder.append("e : INT ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="b[]";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (declarator (declarator b) [ ]) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDeclarations_6() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(399);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : declarator EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("declarator\n");
+		grammarBuilder.append("        : declarator '[' e ']'\n");
+		grammarBuilder.append("        | declarator '[' ']'\n");
+		grammarBuilder.append("        | declarator '(' ')'\n");
+		grammarBuilder.append("        | '*' declarator // binds less tight than suffixes\n");
+		grammarBuilder.append("        | '(' declarator ')'\n");
+		grammarBuilder.append("        | ID\n");
+		grammarBuilder.append("        ;\n");
+		grammarBuilder.append("e : INT ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="(a)";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (declarator ( (declarator a) )) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDeclarations_7() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(399);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : declarator EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("declarator\n");
+		grammarBuilder.append("        : declarator '[' e ']'\n");
+		grammarBuilder.append("        | declarator '[' ']'\n");
+		grammarBuilder.append("        | declarator '(' ')'\n");
+		grammarBuilder.append("        | '*' declarator // binds less tight than suffixes\n");
+		grammarBuilder.append("        | '(' declarator ')'\n");
+		grammarBuilder.append("        | ID\n");
+		grammarBuilder.append("        ;\n");
+		grammarBuilder.append("e : INT ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a[]()";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (declarator (declarator (declarator a) [ ]) ( )) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDeclarations_8() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(399);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : declarator EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("declarator\n");
+		grammarBuilder.append("        : declarator '[' e ']'\n");
+		grammarBuilder.append("        | declarator '[' ']'\n");
+		grammarBuilder.append("        | declarator '(' ')'\n");
+		grammarBuilder.append("        | '*' declarator // binds less tight than suffixes\n");
+		grammarBuilder.append("        | '(' declarator ')'\n");
+		grammarBuilder.append("        | ID\n");
+		grammarBuilder.append("        ;\n");
+		grammarBuilder.append("e : INT ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a[][]";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (declarator (declarator (declarator a) [ ]) [ ]) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDeclarations_9() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(399);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : declarator EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("declarator\n");
+		grammarBuilder.append("        : declarator '[' e ']'\n");
+		grammarBuilder.append("        | declarator '[' ']'\n");
+		grammarBuilder.append("        | declarator '(' ')'\n");
+		grammarBuilder.append("        | '*' declarator // binds less tight than suffixes\n");
+		grammarBuilder.append("        | '(' declarator ')'\n");
+		grammarBuilder.append("        | ID\n");
+		grammarBuilder.append("        ;\n");
+		grammarBuilder.append("e : INT ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="*a[]";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (declarator * (declarator (declarator a) [ ])) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDirectCallToLeftRecursiveRule_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(127);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a @after {System.out.println($ctx.toStringTree(this));} : a ID\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("(a x)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDirectCallToLeftRecursiveRule_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(127);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a @after {System.out.println($ctx.toStringTree(this));} : a ID\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x y";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("(a (a x) y)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDirectCallToLeftRecursiveRule_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(127);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a @after {System.out.println($ctx.toStringTree(this));} : a ID\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x y z";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("(a (a (a x) y) z)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExpressions_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(258);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("e : e '.' ID\n");
+		grammarBuilder.append("  | e '.' 'this'\n");
+		grammarBuilder.append("  | '-' e\n");
+		grammarBuilder.append("  | e '*' e\n");
+		grammarBuilder.append("  | e ('+'|'-') e\n");
+		grammarBuilder.append("  | INT\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e a) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExpressions_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(258);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("e : e '.' ID\n");
+		grammarBuilder.append("  | e '.' 'this'\n");
+		grammarBuilder.append("  | '-' e\n");
+		grammarBuilder.append("  | e '*' e\n");
+		grammarBuilder.append("  | e ('+'|'-') e\n");
+		grammarBuilder.append("  | INT\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="1";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e 1) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExpressions_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(258);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("e : e '.' ID\n");
+		grammarBuilder.append("  | e '.' 'this'\n");
+		grammarBuilder.append("  | '-' e\n");
+		grammarBuilder.append("  | e '*' e\n");
+		grammarBuilder.append("  | e ('+'|'-') e\n");
+		grammarBuilder.append("  | INT\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a-1";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e a) - (e 1)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExpressions_4() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(258);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("e : e '.' ID\n");
+		grammarBuilder.append("  | e '.' 'this'\n");
+		grammarBuilder.append("  | '-' e\n");
+		grammarBuilder.append("  | e '*' e\n");
+		grammarBuilder.append("  | e ('+'|'-') e\n");
+		grammarBuilder.append("  | INT\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a.b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e a) . b) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExpressions_5() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(258);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("e : e '.' ID\n");
+		grammarBuilder.append("  | e '.' 'this'\n");
+		grammarBuilder.append("  | '-' e\n");
+		grammarBuilder.append("  | e '*' e\n");
+		grammarBuilder.append("  | e ('+'|'-') e\n");
+		grammarBuilder.append("  | INT\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a.this";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e a) . this) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExpressions_6() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(258);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("e : e '.' ID\n");
+		grammarBuilder.append("  | e '.' 'this'\n");
+		grammarBuilder.append("  | '-' e\n");
+		grammarBuilder.append("  | e '*' e\n");
+		grammarBuilder.append("  | e ('+'|'-') e\n");
+		grammarBuilder.append("  | INT\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="-a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e - (e a)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExpressions_7() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(258);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("e : e '.' ID\n");
+		grammarBuilder.append("  | e '.' 'this'\n");
+		grammarBuilder.append("  | '-' e\n");
+		grammarBuilder.append("  | e '*' e\n");
+		grammarBuilder.append("  | e ('+'|'-') e\n");
+		grammarBuilder.append("  | INT\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="-a+b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e - (e a)) + (e b)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(1255);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a|b&c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e a) | (e (e b) & (e c))) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_10() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(1255);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a.f(x)==T.c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e (e (e a) . f) ( (expressionList (e x)) )) == (e (e T) . c)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_11() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(1255);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a.f().g(x,1)";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e (e (e (e a) . f) ( )) . g) ( (expressionList (e x) , (e 1)) )) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_12() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(1255);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="new T[((n-1) * x) + 1]";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e new (typespec T) [ (e (e ( (e (e ( (e (e n) - (e 1)) )) * (e x)) )) + (e 1)) ]) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(1255);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="(a|b)&c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e ( (e (e a) | (e b)) )) & (e c)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(1255);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a > b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e a) > (e b)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_4() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(1255);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a >> b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e a) >> (e b)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_5() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(1255);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a=b=c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e a) = (e (e b) = (e c))) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_6() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(1255);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a^b^c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e a) ^ (e (e b) ^ (e c))) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_7() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(1255);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="(T)x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e ( (typespec T) ) (e x)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_8() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(1255);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="new A().b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e new (typespec A) ( )) . b) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_9() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(1255);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="(T)t.f()";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e ( (typespec T) ) (e (e t) . f)) ( )) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLabelsOnOpSubrule_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(178);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : e;\n");
+		grammarBuilder.append("e : a=e op=('*'|'/') b=e  {}\n");
+		grammarBuilder.append("  | INT {}\n");
+		grammarBuilder.append("  | '(' x=e ')' {}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="4";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e 4))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLabelsOnOpSubrule_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(178);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : e;\n");
+		grammarBuilder.append("e : a=e op=('*'|'/') b=e  {}\n");
+		grammarBuilder.append("  | INT {}\n");
+		grammarBuilder.append("  | '(' x=e ')' {}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="1*2/3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e (e 1) * (e 2)) / (e 3)))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLabelsOnOpSubrule_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(178);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : e;\n");
+		grammarBuilder.append("e : a=e op=('*'|'/') b=e  {}\n");
+		grammarBuilder.append("  | INT {}\n");
+		grammarBuilder.append("  | '(' x=e ')' {}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="(1/2)*3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e ( (e (e 1) / (e 2)) )) * (e 3)))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleActionsPredicatesOptions_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(247);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : e ;\n");
+		grammarBuilder.append("e : a=e op=('*'|'/') b=e  {}{true}?\n");
+		grammarBuilder.append("  | a=e op=('+'|'-') b=e  {}<p=3>{true}?<fail='Message'>\n");
+		grammarBuilder.append("  | INT {}{}\n");
+		grammarBuilder.append("  | '(' x=e ')' {}{}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="4";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e 4))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleActionsPredicatesOptions_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(247);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : e ;\n");
+		grammarBuilder.append("e : a=e op=('*'|'/') b=e  {}{true}?\n");
+		grammarBuilder.append("  | a=e op=('+'|'-') b=e  {}<p=3>{true}?<fail='Message'>\n");
+		grammarBuilder.append("  | INT {}{}\n");
+		grammarBuilder.append("  | '(' x=e ')' {}{}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="1*2/3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e (e 1) * (e 2)) / (e 3)))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleActionsPredicatesOptions_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(247);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : e ;\n");
+		grammarBuilder.append("e : a=e op=('*'|'/') b=e  {}{true}?\n");
+		grammarBuilder.append("  | a=e op=('+'|'-') b=e  {}<p=3>{true}?<fail='Message'>\n");
+		grammarBuilder.append("  | INT {}{}\n");
+		grammarBuilder.append("  | '(' x=e ')' {}{}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="(1/2)*3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e ( (e (e 1) / (e 2)) )) * (e 3)))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleActions_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(185);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : e ;\n");
+		grammarBuilder.append("e : a=e op=('*'|'/') b=e  {}{}\n");
+		grammarBuilder.append("  | INT {}{}\n");
+		grammarBuilder.append("  | '(' x=e ')' {}{}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="4";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e 4))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleActions_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(185);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : e ;\n");
+		grammarBuilder.append("e : a=e op=('*'|'/') b=e  {}{}\n");
+		grammarBuilder.append("  | INT {}{}\n");
+		grammarBuilder.append("  | '(' x=e ')' {}{}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="1*2/3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e (e 1) * (e 2)) / (e 3)))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleActions_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(185);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : e ;\n");
+		grammarBuilder.append("e : a=e op=('*'|'/') b=e  {}{}\n");
+		grammarBuilder.append("  | INT {}{}\n");
+		grammarBuilder.append("  | '(' x=e ')' {}{}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="(1/2)*3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e ( (e (e 1) / (e 2)) )) * (e 3)))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleAlternativesWithCommonLabel_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(730);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {System.out.println($e.v);};\n");
+		grammarBuilder.append("e returns [int v]\n");
+		grammarBuilder.append("  : e '*' e     {$v = ((BinaryContext)$ctx).e(0).v * ((BinaryContext)$ctx).e(1).v;}  # binary\n");
+		grammarBuilder.append("  | e '+' e     {$v = ((BinaryContext)$ctx).e(0).v + ((BinaryContext)$ctx).e(1).v;}  # binary\n");
+		grammarBuilder.append("  | INT         {$v = $INT.int;}                   # anInt\n");
+		grammarBuilder.append("  | '(' e ')'   {$v = $e.v;}                       # parens\n");
+		grammarBuilder.append("  | left=e INC  {assert(((UnaryContext)$ctx).INC() != null);$v = $left.v + 1;}      # unary\n");
+		grammarBuilder.append("  | left=e DEC  {assert(((UnaryContext)$ctx).DEC() != null);$v = $left.v - 1;}      # unary\n");
+		grammarBuilder.append("  | ID          {$v = 3;}                                                     # anID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("INC : '++' ;\n");
+		grammarBuilder.append("DEC : '--' ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="4";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("4\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleAlternativesWithCommonLabel_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(730);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {System.out.println($e.v);};\n");
+		grammarBuilder.append("e returns [int v]\n");
+		grammarBuilder.append("  : e '*' e     {$v = ((BinaryContext)$ctx).e(0).v * ((BinaryContext)$ctx).e(1).v;}  # binary\n");
+		grammarBuilder.append("  | e '+' e     {$v = ((BinaryContext)$ctx).e(0).v + ((BinaryContext)$ctx).e(1).v;}  # binary\n");
+		grammarBuilder.append("  | INT         {$v = $INT.int;}                   # anInt\n");
+		grammarBuilder.append("  | '(' e ')'   {$v = $e.v;}                       # parens\n");
+		grammarBuilder.append("  | left=e INC  {assert(((UnaryContext)$ctx).INC() != null);$v = $left.v + 1;}      # unary\n");
+		grammarBuilder.append("  | left=e DEC  {assert(((UnaryContext)$ctx).DEC() != null);$v = $left.v - 1;}      # unary\n");
+		grammarBuilder.append("  | ID          {$v = 3;}                                                     # anID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("INC : '++' ;\n");
+		grammarBuilder.append("DEC : '--' ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="1+2";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("3\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleAlternativesWithCommonLabel_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(730);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {System.out.println($e.v);};\n");
+		grammarBuilder.append("e returns [int v]\n");
+		grammarBuilder.append("  : e '*' e     {$v = ((BinaryContext)$ctx).e(0).v * ((BinaryContext)$ctx).e(1).v;}  # binary\n");
+		grammarBuilder.append("  | e '+' e     {$v = ((BinaryContext)$ctx).e(0).v + ((BinaryContext)$ctx).e(1).v;}  # binary\n");
+		grammarBuilder.append("  | INT         {$v = $INT.int;}                   # anInt\n");
+		grammarBuilder.append("  | '(' e ')'   {$v = $e.v;}                       # parens\n");
+		grammarBuilder.append("  | left=e INC  {assert(((UnaryContext)$ctx).INC() != null);$v = $left.v + 1;}      # unary\n");
+		grammarBuilder.append("  | left=e DEC  {assert(((UnaryContext)$ctx).DEC() != null);$v = $left.v - 1;}      # unary\n");
+		grammarBuilder.append("  | ID          {$v = 3;}                                                     # anID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("INC : '++' ;\n");
+		grammarBuilder.append("DEC : '--' ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="1+2*3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("7\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleAlternativesWithCommonLabel_4() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(730);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {System.out.println($e.v);};\n");
+		grammarBuilder.append("e returns [int v]\n");
+		grammarBuilder.append("  : e '*' e     {$v = ((BinaryContext)$ctx).e(0).v * ((BinaryContext)$ctx).e(1).v;}  # binary\n");
+		grammarBuilder.append("  | e '+' e     {$v = ((BinaryContext)$ctx).e(0).v + ((BinaryContext)$ctx).e(1).v;}  # binary\n");
+		grammarBuilder.append("  | INT         {$v = $INT.int;}                   # anInt\n");
+		grammarBuilder.append("  | '(' e ')'   {$v = $e.v;}                       # parens\n");
+		grammarBuilder.append("  | left=e INC  {assert(((UnaryContext)$ctx).INC() != null);$v = $left.v + 1;}      # unary\n");
+		grammarBuilder.append("  | left=e DEC  {assert(((UnaryContext)$ctx).DEC() != null);$v = $left.v - 1;}      # unary\n");
+		grammarBuilder.append("  | ID          {$v = 3;}                                                     # anID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("INC : '++' ;\n");
+		grammarBuilder.append("DEC : '--' ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="i++*3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("12\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPrecedenceFilterConsidersContext() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(150);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("prog \n");
+		grammarBuilder.append("@after {System.out.println($ctx.toStringTree(this));}\n");
+		grammarBuilder.append(": statement* EOF {};\n");
+		grammarBuilder.append("statement: letterA | statement letterA 'b' ;\n");
+		grammarBuilder.append("letterA: 'a';");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="aa";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "prog", input, false);
+		assertEquals("(prog (statement (letterA a)) (statement (letterA a)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPrefixAndOtherAlt_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(224);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : expr EOF ; \n");
+		grammarBuilder.append("expr : literal\n");
+		grammarBuilder.append("     | op expr\n");
+		grammarBuilder.append("     | expr op expr\n");
+		grammarBuilder.append("     ;\n");
+		grammarBuilder.append("literal : '-'? Integer ;\n");
+		grammarBuilder.append("op : '+' | '-' ;\n");
+		grammarBuilder.append("Integer : [0-9]+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="-1";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (expr (literal - 1)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPrefixAndOtherAlt_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(224);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : expr EOF ; \n");
+		grammarBuilder.append("expr : literal\n");
+		grammarBuilder.append("     | op expr\n");
+		grammarBuilder.append("     | expr op expr\n");
+		grammarBuilder.append("     ;\n");
+		grammarBuilder.append("literal : '-'? Integer ;\n");
+		grammarBuilder.append("op : '+' | '-' ;\n");
+		grammarBuilder.append("Integer : [0-9]+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="-1 + -1";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (expr (expr (literal - 1)) (op +) (expr (literal - 1))) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPrefixOpWithActionAndLabel_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(343);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {System.out.println($e.result);} ;\n");
+		grammarBuilder.append("e returns [String result]\n");
+		grammarBuilder.append("    :   ID '=' e1=e    {$result = \"(\" + $ID.text + \"=\" + $e1.result + \")\";}\n");
+		grammarBuilder.append("    |   ID             {$result = $ID.text;}\n");
+		grammarBuilder.append("    |   e1=e '+' e2=e  {$result = \"(\" + $e1.result + \"+\" + $e2.result + \")\";}\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("a\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPrefixOpWithActionAndLabel_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(343);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {System.out.println($e.result);} ;\n");
+		grammarBuilder.append("e returns [String result]\n");
+		grammarBuilder.append("    :   ID '=' e1=e    {$result = \"(\" + $ID.text + \"=\" + $e1.result + \")\";}\n");
+		grammarBuilder.append("    |   ID             {$result = $ID.text;}\n");
+		grammarBuilder.append("    |   e1=e '+' e2=e  {$result = \"(\" + $e1.result + \"+\" + $e2.result + \")\";}\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a+b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(a+b)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPrefixOpWithActionAndLabel_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(343);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {System.out.println($e.result);} ;\n");
+		grammarBuilder.append("e returns [String result]\n");
+		grammarBuilder.append("    :   ID '=' e1=e    {$result = \"(\" + $ID.text + \"=\" + $e1.result + \")\";}\n");
+		grammarBuilder.append("    |   ID             {$result = $ID.text;}\n");
+		grammarBuilder.append("    |   e1=e '+' e2=e  {$result = \"(\" + $e1.result + \"+\" + $e2.result + \")\";}\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a=b+c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("((a=b)+c)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsAndLabels_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(461);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : q=e {System.out.println($e.v);}; \n");
+		grammarBuilder.append("e returns [int v]\n");
+		grammarBuilder.append("  : a=e op='*' b=e {$v = $a.v * $b.v;}  # mult\n");
+		grammarBuilder.append("  | a=e '+' b=e {$v = $a.v + $b.v;}     # add\n");
+		grammarBuilder.append("  | INT         {$v = $INT.int;}        # anInt\n");
+		grammarBuilder.append("  | '(' x=e ')' {$v = $x.v;}            # parens\n");
+		grammarBuilder.append("  | x=e '++'    {$v = $x.v+1;}          # inc\n");
+		grammarBuilder.append("  | e '--'                              # dec\n");
+		grammarBuilder.append("  | ID          {$v = 3;}               # anID\n");
+		grammarBuilder.append("  ; \n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="4";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("4\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsAndLabels_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(461);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : q=e {System.out.println($e.v);}; \n");
+		grammarBuilder.append("e returns [int v]\n");
+		grammarBuilder.append("  : a=e op='*' b=e {$v = $a.v * $b.v;}  # mult\n");
+		grammarBuilder.append("  | a=e '+' b=e {$v = $a.v + $b.v;}     # add\n");
+		grammarBuilder.append("  | INT         {$v = $INT.int;}        # anInt\n");
+		grammarBuilder.append("  | '(' x=e ')' {$v = $x.v;}            # parens\n");
+		grammarBuilder.append("  | x=e '++'    {$v = $x.v+1;}          # inc\n");
+		grammarBuilder.append("  | e '--'                              # dec\n");
+		grammarBuilder.append("  | ID          {$v = 3;}               # anID\n");
+		grammarBuilder.append("  ; \n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="1+2";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("3\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsAndLabels_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(461);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : q=e {System.out.println($e.v);}; \n");
+		grammarBuilder.append("e returns [int v]\n");
+		grammarBuilder.append("  : a=e op='*' b=e {$v = $a.v * $b.v;}  # mult\n");
+		grammarBuilder.append("  | a=e '+' b=e {$v = $a.v + $b.v;}     # add\n");
+		grammarBuilder.append("  | INT         {$v = $INT.int;}        # anInt\n");
+		grammarBuilder.append("  | '(' x=e ')' {$v = $x.v;}            # parens\n");
+		grammarBuilder.append("  | x=e '++'    {$v = $x.v+1;}          # inc\n");
+		grammarBuilder.append("  | e '--'                              # dec\n");
+		grammarBuilder.append("  | ID          {$v = 3;}               # anID\n");
+		grammarBuilder.append("  ; \n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="1+2*3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("7\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsAndLabels_4() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(461);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : q=e {System.out.println($e.v);}; \n");
+		grammarBuilder.append("e returns [int v]\n");
+		grammarBuilder.append("  : a=e op='*' b=e {$v = $a.v * $b.v;}  # mult\n");
+		grammarBuilder.append("  | a=e '+' b=e {$v = $a.v + $b.v;}     # add\n");
+		grammarBuilder.append("  | INT         {$v = $INT.int;}        # anInt\n");
+		grammarBuilder.append("  | '(' x=e ')' {$v = $x.v;}            # parens\n");
+		grammarBuilder.append("  | x=e '++'    {$v = $x.v+1;}          # inc\n");
+		grammarBuilder.append("  | e '--'                              # dec\n");
+		grammarBuilder.append("  | ID          {$v = 3;}               # anID\n");
+		grammarBuilder.append("  ; \n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="i++*3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("12\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsList1_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(308);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : expr EOF;\n");
+		grammarBuilder.append("expr:\n");
+		grammarBuilder.append("    a=expr '*' a=expr #Factor\n");
+		grammarBuilder.append("    | b+=expr (',' b+=expr)* '>>' c=expr #Send\n");
+		grammarBuilder.append("    | ID #JustId //semantic check on modifiers\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("ID  : ('a'..'z'|'A'..'Z'|'_')\n");
+		grammarBuilder.append("      ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a*b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (expr (expr a) * (expr b)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsList1_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(308);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : expr EOF;\n");
+		grammarBuilder.append("expr:\n");
+		grammarBuilder.append("    a=expr '*' a=expr #Factor\n");
+		grammarBuilder.append("    | b+=expr (',' b+=expr)* '>>' c=expr #Send\n");
+		grammarBuilder.append("    | ID #JustId //semantic check on modifiers\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("ID  : ('a'..'z'|'A'..'Z'|'_')\n");
+		grammarBuilder.append("      ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a,c>>x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (expr (expr a) , (expr c) >> (expr x)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsList1_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(308);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : expr EOF;\n");
+		grammarBuilder.append("expr:\n");
+		grammarBuilder.append("    a=expr '*' a=expr #Factor\n");
+		grammarBuilder.append("    | b+=expr (',' b+=expr)* '>>' c=expr #Send\n");
+		grammarBuilder.append("    | ID #JustId //semantic check on modifiers\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("ID  : ('a'..'z'|'A'..'Z'|'_')\n");
+		grammarBuilder.append("      ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (expr x) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsList1_4() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(308);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : expr EOF;\n");
+		grammarBuilder.append("expr:\n");
+		grammarBuilder.append("    a=expr '*' a=expr #Factor\n");
+		grammarBuilder.append("    | b+=expr (',' b+=expr)* '>>' c=expr #Send\n");
+		grammarBuilder.append("    | ID #JustId //semantic check on modifiers\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("ID  : ('a'..'z'|'A'..'Z'|'_')\n");
+		grammarBuilder.append("      ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a*b,c,x*y>>r";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (expr (expr (expr a) * (expr b)) , (expr c) , (expr (expr x) * (expr y)) >> (expr r)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsList2_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(325);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : expr EOF;\n");
+		grammarBuilder.append("expr:\n");
+		grammarBuilder.append("    a=expr '*' a=expr #Factor\n");
+		grammarBuilder.append("    | b+=expr ',' b+=expr #Comma\n");
+		grammarBuilder.append("    | b+=expr '>>' c=expr #Send\n");
+		grammarBuilder.append("    | ID #JustId //semantic check on modifiers\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("ID  : ('a'..'z'|'A'..'Z'|'_')\n");
+		grammarBuilder.append("      ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a*b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (expr (expr a) * (expr b)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsList2_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(325);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : expr EOF;\n");
+		grammarBuilder.append("expr:\n");
+		grammarBuilder.append("    a=expr '*' a=expr #Factor\n");
+		grammarBuilder.append("    | b+=expr ',' b+=expr #Comma\n");
+		grammarBuilder.append("    | b+=expr '>>' c=expr #Send\n");
+		grammarBuilder.append("    | ID #JustId //semantic check on modifiers\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("ID  : ('a'..'z'|'A'..'Z'|'_')\n");
+		grammarBuilder.append("      ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a,c>>x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (expr (expr (expr a) , (expr c)) >> (expr x)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsList2_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(325);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : expr EOF;\n");
+		grammarBuilder.append("expr:\n");
+		grammarBuilder.append("    a=expr '*' a=expr #Factor\n");
+		grammarBuilder.append("    | b+=expr ',' b+=expr #Comma\n");
+		grammarBuilder.append("    | b+=expr '>>' c=expr #Send\n");
+		grammarBuilder.append("    | ID #JustId //semantic check on modifiers\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("ID  : ('a'..'z'|'A'..'Z'|'_')\n");
+		grammarBuilder.append("      ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (expr x) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsList2_4() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(325);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : expr EOF;\n");
+		grammarBuilder.append("expr:\n");
+		grammarBuilder.append("    a=expr '*' a=expr #Factor\n");
+		grammarBuilder.append("    | b+=expr ',' b+=expr #Comma\n");
+		grammarBuilder.append("    | b+=expr '>>' c=expr #Send\n");
+		grammarBuilder.append("    | ID #JustId //semantic check on modifiers\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("ID  : ('a'..'z'|'A'..'Z'|'_')\n");
+		grammarBuilder.append("      ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a*b,c,x*y>>r";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (expr (expr (expr (expr (expr a) * (expr b)) , (expr c)) , (expr (expr x) * (expr y))) >> (expr r)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActions_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(261);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {System.out.println($e.v);}; \n");
+		grammarBuilder.append("e returns [int v, List<String> ignored]\n");
+		grammarBuilder.append("  : a=e '*' b=e {$v = $a.v * $b.v;}\n");
+		grammarBuilder.append("  | a=e '+' b=e {$v = $a.v + $b.v;}\n");
+		grammarBuilder.append("  | INT {$v = $INT.int;}\n");
+		grammarBuilder.append("  | '(' x=e ')' {$v = $x.v;}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;\n");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="4";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("4\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActions_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(261);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {System.out.println($e.v);}; \n");
+		grammarBuilder.append("e returns [int v, List<String> ignored]\n");
+		grammarBuilder.append("  : a=e '*' b=e {$v = $a.v * $b.v;}\n");
+		grammarBuilder.append("  | a=e '+' b=e {$v = $a.v + $b.v;}\n");
+		grammarBuilder.append("  | INT {$v = $INT.int;}\n");
+		grammarBuilder.append("  | '(' x=e ')' {$v = $x.v;}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;\n");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="1+2";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("3\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActions_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(261);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {System.out.println($e.v);}; \n");
+		grammarBuilder.append("e returns [int v, List<String> ignored]\n");
+		grammarBuilder.append("  : a=e '*' b=e {$v = $a.v * $b.v;}\n");
+		grammarBuilder.append("  | a=e '+' b=e {$v = $a.v + $b.v;}\n");
+		grammarBuilder.append("  | INT {$v = $INT.int;}\n");
+		grammarBuilder.append("  | '(' x=e ')' {$v = $x.v;}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;\n");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="1+2*3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("7\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActions_4() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(261);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {System.out.println($e.v);}; \n");
+		grammarBuilder.append("e returns [int v, List<String> ignored]\n");
+		grammarBuilder.append("  : a=e '*' b=e {$v = $a.v * $b.v;}\n");
+		grammarBuilder.append("  | a=e '+' b=e {$v = $a.v + $b.v;}\n");
+		grammarBuilder.append("  | INT {$v = $INT.int;}\n");
+		grammarBuilder.append("  | '(' x=e ')' {$v = $x.v;}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;\n");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="(1+2)*3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("9\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSemPred() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(143);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : a ;\n");
+		grammarBuilder.append("a : a {true}? ID\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x y z";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (a (a (a x) y) z))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSemPredFailOption() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(167);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : a ;\n");
+		grammarBuilder.append("a : a ID {false}?<fail='custom message'>\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x y z";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (a (a x) y z))\n", found);
+
+		assertEquals("line 1:4 rule a custom message\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSimple_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(135);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : a ;\n");
+		grammarBuilder.append("a : a ID\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (a x))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSimple_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(135);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : a ;\n");
+		grammarBuilder.append("a : a ID\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x y";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (a (a x) y))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSimple_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(135);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : a ;\n");
+		grammarBuilder.append("a : a ID\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x y z";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (a (a (a x) y) z))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExprExplicitAssociativity_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(291);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : e EOF; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e :<assoc=right> e '*' e\n");
+		grammarBuilder.append("  |<assoc=right> e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e a) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExprExplicitAssociativity_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(291);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : e EOF; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e :<assoc=right> e '*' e\n");
+		grammarBuilder.append("  |<assoc=right> e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a+b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e a) + (e b)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExprExplicitAssociativity_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(291);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : e EOF; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e :<assoc=right> e '*' e\n");
+		grammarBuilder.append("  |<assoc=right> e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a*b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e a) * (e b)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExprExplicitAssociativity_4() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(291);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : e EOF; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e :<assoc=right> e '*' e\n");
+		grammarBuilder.append("  |<assoc=right> e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a?b:c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e a) ? (e b) : (e c)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExprExplicitAssociativity_5() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(291);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : e EOF; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e :<assoc=right> e '*' e\n");
+		grammarBuilder.append("  |<assoc=right> e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a=b=c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e a) = (e (e b) = (e c))) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExprExplicitAssociativity_6() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(291);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : e EOF; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e :<assoc=right> e '*' e\n");
+		grammarBuilder.append("  |<assoc=right> e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a?b+c:d";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e a) ? (e (e b) + (e c)) : (e d)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExprExplicitAssociativity_7() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(291);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : e EOF; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e :<assoc=right> e '*' e\n");
+		grammarBuilder.append("  |<assoc=right> e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a?b=c:d";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e a) ? (e (e b) = (e c)) : (e d)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExprExplicitAssociativity_8() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(291);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : e EOF; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e :<assoc=right> e '*' e\n");
+		grammarBuilder.append("  |<assoc=right> e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a? b?c:d : e";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e a) ? (e (e b) ? (e c) : (e d)) : (e e)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExprExplicitAssociativity_9() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(291);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : e EOF; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e :<assoc=right> e '*' e\n");
+		grammarBuilder.append("  |<assoc=right> e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a?b: c?d:e";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e a) ? (e b) : (e (e c) ? (e d) : (e e))) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExpr_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(266);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : e EOF ; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e : e '*' e\n");
+		grammarBuilder.append("  | e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e a) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExpr_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(266);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : e EOF ; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e : e '*' e\n");
+		grammarBuilder.append("  | e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a+b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e a) + (e b)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExpr_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(266);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : e EOF ; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e : e '*' e\n");
+		grammarBuilder.append("  | e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a*b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e a) * (e b)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExpr_4() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(266);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : e EOF ; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e : e '*' e\n");
+		grammarBuilder.append("  | e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a?b:c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e a) ? (e b) : (e c)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExpr_5() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(266);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : e EOF ; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e : e '*' e\n");
+		grammarBuilder.append("  | e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a=b=c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e a) = (e (e b) = (e c))) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExpr_6() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(266);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : e EOF ; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e : e '*' e\n");
+		grammarBuilder.append("  | e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a?b+c:d";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e a) ? (e (e b) + (e c)) : (e d)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExpr_7() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(266);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : e EOF ; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e : e '*' e\n");
+		grammarBuilder.append("  | e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a?b=c:d";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e a) ? (e (e b) = (e c)) : (e d)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExpr_8() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(266);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : e EOF ; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e : e '*' e\n");
+		grammarBuilder.append("  | e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a? b?c:d : e";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e a) ? (e (e b) ? (e c) : (e d)) : (e e)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExpr_9() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(266);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {System.out.println($ctx.toStringTree(this));} : e EOF ; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e : e '*' e\n");
+		grammarBuilder.append("  | e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a?b: c?d:e";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(s (e (e a) ? (e b) : (e (e c) ? (e d) : (e e))) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testWhitespaceInfluence_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(2763);
+		grammarBuilder.append("grammar Expr;\n");
+		grammarBuilder.append("prog : expression EOF;\n");
+		grammarBuilder.append("expression\n");
+		grammarBuilder.append("    : ID '(' expression (',' expression)* ')'               # doFunction\n");
+		grammarBuilder.append("    | '(' expression ')'                                    # doParenthesis\n");
+		grammarBuilder.append("    | '!' expression                                        # doNot\n");
+		grammarBuilder.append("    | '-' expression                                        # doNegate\n");
+		grammarBuilder.append("    | '+' expression                                        # doPositiv\n");
+		grammarBuilder.append("    | expression '^' expression                             # doPower\n");
+		grammarBuilder.append("    | expression '*' expression                             # doMultipy\n");
+		grammarBuilder.append("    | expression '/' expression                             # doDivide\n");
+		grammarBuilder.append("    | expression '%' expression                             # doModulo\n");
+		grammarBuilder.append("    | expression '-' expression                             # doMinus\n");
+		grammarBuilder.append("    | expression '+' expression                             # doPlus\n");
+		grammarBuilder.append("    | expression '=' expression                             # doEqual\n");
+		grammarBuilder.append("    | expression '!=' expression                            # doNotEqual\n");
+		grammarBuilder.append("    | expression '>' expression                             # doGreather\n");
+		grammarBuilder.append("    | expression '>=' expression                            # doGreatherEqual\n");
+		grammarBuilder.append("    | expression '<' expression                             # doLesser\n");
+		grammarBuilder.append("    | expression '<=' expression                            # doLesserEqual\n");
+		grammarBuilder.append("    | expression K_IN '(' expression (',' expression)* ')'  # doIn\n");
+		grammarBuilder.append("    | expression ( '&' | K_AND) expression                  # doAnd\n");
+		grammarBuilder.append("    | expression ( '|' | K_OR) expression                   # doOr\n");
+		grammarBuilder.append("    | '[' expression (',' expression)* ']'                  # newArray\n");
+		grammarBuilder.append("    | K_TRUE                                                # newTrueBoolean\n");
+		grammarBuilder.append("    | K_FALSE                                               # newFalseBoolean\n");
+		grammarBuilder.append("    | NUMBER                                                # newNumber\n");
+		grammarBuilder.append("    | DATE                                                  # newDateTime\n");
+		grammarBuilder.append("    | ID                                                    # newIdentifier\n");
+		grammarBuilder.append("    | SQ_STRING                                             # newString\n");
+		grammarBuilder.append("    | K_NULL                                                # newNull\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("// Fragments\n");
+		grammarBuilder.append("fragment DIGIT    : '0' .. '9';  \n");
+		grammarBuilder.append("fragment UPPER    : 'A' .. 'Z';\n");
+		grammarBuilder.append("fragment LOWER    : 'a' .. 'z';\n");
+		grammarBuilder.append("fragment LETTER   : LOWER | UPPER;\n");
+		grammarBuilder.append("fragment WORD     : LETTER | '_' | '$' | '#' | '.';\n");
+		grammarBuilder.append("fragment ALPHANUM : WORD | DIGIT;  \n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("// Tokens\n");
+		grammarBuilder.append("ID              : LETTER ALPHANUM*;\n");
+		grammarBuilder.append("NUMBER          : DIGIT+ ('.' DIGIT+)? (('e'|'E')('+'|'-')? DIGIT+)?;\n");
+		grammarBuilder.append("DATE            : '\\'' DIGIT DIGIT DIGIT DIGIT '-' DIGIT DIGIT '-' DIGIT DIGIT (' ' DIGIT DIGIT ':' DIGIT DIGIT ':' DIGIT DIGIT ('.' DIGIT+)?)? '\\'';\n");
+		grammarBuilder.append("SQ_STRING       : '\\'' ('\\'\\'' | ~'\\'')* '\\'';\n");
+		grammarBuilder.append("DQ_STRING       : '\"' ('\\\\\"' | ~'\"')* '\"';\n");
+		grammarBuilder.append("WS              : [ \\t\\n\\r]+ -> skip ;\n");
+		grammarBuilder.append("COMMENTS        : ('/*' .*? '*/' | '//' ~'\\n'* '\\n' ) -> skip;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="Test(1,3)";
+		String found = execParser("Expr.g4", grammar, "ExprParser", "ExprLexer", "prog", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testWhitespaceInfluence_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(2763);
+		grammarBuilder.append("grammar Expr;\n");
+		grammarBuilder.append("prog : expression EOF;\n");
+		grammarBuilder.append("expression\n");
+		grammarBuilder.append("    : ID '(' expression (',' expression)* ')'               # doFunction\n");
+		grammarBuilder.append("    | '(' expression ')'                                    # doParenthesis\n");
+		grammarBuilder.append("    | '!' expression                                        # doNot\n");
+		grammarBuilder.append("    | '-' expression                                        # doNegate\n");
+		grammarBuilder.append("    | '+' expression                                        # doPositiv\n");
+		grammarBuilder.append("    | expression '^' expression                             # doPower\n");
+		grammarBuilder.append("    | expression '*' expression                             # doMultipy\n");
+		grammarBuilder.append("    | expression '/' expression                             # doDivide\n");
+		grammarBuilder.append("    | expression '%' expression                             # doModulo\n");
+		grammarBuilder.append("    | expression '-' expression                             # doMinus\n");
+		grammarBuilder.append("    | expression '+' expression                             # doPlus\n");
+		grammarBuilder.append("    | expression '=' expression                             # doEqual\n");
+		grammarBuilder.append("    | expression '!=' expression                            # doNotEqual\n");
+		grammarBuilder.append("    | expression '>' expression                             # doGreather\n");
+		grammarBuilder.append("    | expression '>=' expression                            # doGreatherEqual\n");
+		grammarBuilder.append("    | expression '<' expression                             # doLesser\n");
+		grammarBuilder.append("    | expression '<=' expression                            # doLesserEqual\n");
+		grammarBuilder.append("    | expression K_IN '(' expression (',' expression)* ')'  # doIn\n");
+		grammarBuilder.append("    | expression ( '&' | K_AND) expression                  # doAnd\n");
+		grammarBuilder.append("    | expression ( '|' | K_OR) expression                   # doOr\n");
+		grammarBuilder.append("    | '[' expression (',' expression)* ']'                  # newArray\n");
+		grammarBuilder.append("    | K_TRUE                                                # newTrueBoolean\n");
+		grammarBuilder.append("    | K_FALSE                                               # newFalseBoolean\n");
+		grammarBuilder.append("    | NUMBER                                                # newNumber\n");
+		grammarBuilder.append("    | DATE                                                  # newDateTime\n");
+		grammarBuilder.append("    | ID                                                    # newIdentifier\n");
+		grammarBuilder.append("    | SQ_STRING                                             # newString\n");
+		grammarBuilder.append("    | K_NULL                                                # newNull\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("// Fragments\n");
+		grammarBuilder.append("fragment DIGIT    : '0' .. '9';  \n");
+		grammarBuilder.append("fragment UPPER    : 'A' .. 'Z';\n");
+		grammarBuilder.append("fragment LOWER    : 'a' .. 'z';\n");
+		grammarBuilder.append("fragment LETTER   : LOWER | UPPER;\n");
+		grammarBuilder.append("fragment WORD     : LETTER | '_' | '$' | '#' | '.';\n");
+		grammarBuilder.append("fragment ALPHANUM : WORD | DIGIT;  \n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("// Tokens\n");
+		grammarBuilder.append("ID              : LETTER ALPHANUM*;\n");
+		grammarBuilder.append("NUMBER          : DIGIT+ ('.' DIGIT+)? (('e'|'E')('+'|'-')? DIGIT+)?;\n");
+		grammarBuilder.append("DATE            : '\\'' DIGIT DIGIT DIGIT DIGIT '-' DIGIT DIGIT '-' DIGIT DIGIT (' ' DIGIT DIGIT ':' DIGIT DIGIT ':' DIGIT DIGIT ('.' DIGIT+)?)? '\\'';\n");
+		grammarBuilder.append("SQ_STRING       : '\\'' ('\\'\\'' | ~'\\'')* '\\'';\n");
+		grammarBuilder.append("DQ_STRING       : '\"' ('\\\\\"' | ~'\"')* '\"';\n");
+		grammarBuilder.append("WS              : [ \\t\\n\\r]+ -> skip ;\n");
+		grammarBuilder.append("COMMENTS        : ('/*' .*? '*/' | '//' ~'\\n'* '\\n' ) -> skip;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="Test(1, 3)";
+		String found = execParser("Expr.g4", grammar, "ExprParser", "ExprLexer", "prog", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+
+}
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/java/TestLexerErrors.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/java/TestLexerErrors.java
new file mode 100644
index 000000000..672e631f0
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/java/TestLexerErrors.java
@@ -0,0 +1,258 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.java;
+
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class TestLexerErrors extends BaseTest {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDFAToATNThatFailsBackToDFA() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(39);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : 'ab' ;\n");
+		grammarBuilder.append("B : 'abc' ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="ababx";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:1='ab',<1>,1:0]\n" +
+			"[@1,2:3='ab',<1>,1:2]\n" +
+			"[@2,5:4='<EOF>',<-1>,1:5]\n", found);
+
+		assertEquals("line 1:4 token recognition error at: 'x'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDFAToATNThatMatchesThenFailsInATN() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(52);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : 'ab' ;\n");
+		grammarBuilder.append("B : 'abc' ;\n");
+		grammarBuilder.append("C : 'abcd' ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="ababcx";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:1='ab',<1>,1:0]\n" +
+			"[@1,2:4='abc',<2>,1:2]\n" +
+			"[@2,6:5='<EOF>',<-1>,1:6]\n", found);
+
+		assertEquals("line 1:5 token recognition error at: 'x'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testEnforcedGreedyNestedBrances_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(77);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("ACTION : '{' (ACTION | ~[{}])* '}';\n");
+		grammarBuilder.append("WS : [ \\r\\n\\t]+ -> skip;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="{ { } }";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:6='{ { } }',<1>,1:0]\n" +
+			"[@1,7:6='<EOF>',<-1>,1:7]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testEnforcedGreedyNestedBrances_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(77);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("ACTION : '{' (ACTION | ~[{}])* '}';\n");
+		grammarBuilder.append("WS : [ \\r\\n\\t]+ -> skip;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="{ { }";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals("[@0,5:4='<EOF>',<-1>,1:5]\n", found);
+
+		assertEquals("line 1:0 token recognition error at: '{ { }'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testErrorInMiddle() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(28);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : 'abc' ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="abx";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals("[@0,3:2='<EOF>',<-1>,1:3]\n", found);
+
+		assertEquals("line 1:0 token recognition error at: 'abx'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testInvalidCharAtStart() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(30);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : 'a' 'b' ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="x";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals("[@0,1:0='<EOF>',<-1>,1:1]\n", found);
+
+		assertEquals("line 1:0 token recognition error at: 'x'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testInvalidCharAtStartAfterDFACache() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(30);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : 'a' 'b' ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="abx";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:1='ab',<1>,1:0]\n" +
+			"[@1,3:2='<EOF>',<-1>,1:3]\n", found);
+
+		assertEquals("line 1:2 token recognition error at: 'x'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testInvalidCharInToken() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(30);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : 'a' 'b' ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="ax";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals("[@0,2:1='<EOF>',<-1>,1:2]\n", found);
+
+		assertEquals("line 1:0 token recognition error at: 'ax'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testInvalidCharInTokenAfterDFACache() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(30);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : 'a' 'b' ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="abax";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:1='ab',<1>,1:0]\n" +
+			"[@1,4:3='<EOF>',<-1>,1:4]\n", found);
+
+		assertEquals("line 1:2 token recognition error at: 'ax'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLexerExecDFA() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(98);
+		grammarBuilder.append("grammar L;\n");
+		grammarBuilder.append("start : ID ':' expr;\n");
+		grammarBuilder.append("expr : primary expr? {} | expr '->' ID;\n");
+		grammarBuilder.append("primary : ID;\n");
+		grammarBuilder.append("ID : [a-z]+;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="x : x";
+		String found = execLexer("L.g4", grammar, "LLexer", input, false);
+		assertEquals(
+			"[@0,0:0='x',<3>,1:0]\n" +
+			"[@1,2:2=':',<1>,1:2]\n" +
+			"[@2,4:4='x',<3>,1:4]\n" +
+			"[@3,5:4='<EOF>',<-1>,1:5]\n", found);
+
+		assertEquals(
+			"line 1:1 token recognition error at: ' '\n" +
+			"line 1:3 token recognition error at: ' '\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testStringsEmbeddedInActions_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(109);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("ACTION2 : '[' (STRING | ~'\"')*? ']';\n");
+		grammarBuilder.append("STRING : '\"' ('\\\"' | .)*? '\"';\n");
+		grammarBuilder.append("WS : [ \\t\\r\\n]+ -> skip;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="[\"foo\"]";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:6='[\"foo\"]',<1>,1:0]\n" +
+			"[@1,7:6='<EOF>',<-1>,1:7]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testStringsEmbeddedInActions_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(109);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("ACTION2 : '[' (STRING | ~'\"')*? ']';\n");
+		grammarBuilder.append("STRING : '\"' ('\\\"' | .)*? '\"';\n");
+		grammarBuilder.append("WS : [ \\t\\r\\n]+ -> skip;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="[\"foo]";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals("[@0,6:5='<EOF>',<-1>,1:6]\n", found);
+
+		assertEquals("line 1:0 token recognition error at: '[\"foo]'\n", this.stderrDuringParse);
+
+	}
+
+
+}
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/java/TestLexerExec.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/java/TestLexerExec.java
new file mode 100644
index 000000000..ed74b1eda
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/java/TestLexerExec.java
@@ -0,0 +1,5030 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.java;
+
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class TestLexerExec extends BaseTest {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testActionPlacement() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(323);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("I : ({System.out.println(\"stuff fail: \" + this.getText());} 'a'\n");
+		grammarBuilder.append("| {System.out.println(\"stuff0: \" + this.getText());}\n");
+		grammarBuilder.append("		'a' {System.out.println(\"stuff1: \" + this.getText());}\n");
+		grammarBuilder.append("		'b' {System.out.println(\"stuff2: \" + this.getText());})\n");
+		grammarBuilder.append("		{System.out.println(this.getText());} ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;\n");
+		grammarBuilder.append("J : .;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="ab";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"stuff0: \n" +
+			"stuff1: a\n" +
+			"stuff2: ab\n" +
+			"ab\n" +
+			"[@0,0:1='ab',<1>,1:0]\n" +
+			"[@1,2:1='<EOF>',<-1>,1:2]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(86);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("I : '0'..'9'+ {System.out.println(\"I\");} ;\n");
+		grammarBuilder.append("WS : [ \\n\\u000D] -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+		String input =
+			"34\n" +
+			" 34";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"I\n" +
+			"I\n" +
+			"[@0,0:1='34',<1>,1:0]\n" +
+			"[@1,4:5='34',<1>,2:1]\n" +
+			"[@2,6:5='<EOF>',<-1>,2:3]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetInSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(93);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("I : (~[ab \\n]|'a')  {System.out.println(\"I\");} ;\n");
+		grammarBuilder.append("WS : [ \\n\\u000D]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="a x";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"I\n" +
+			"I\n" +
+			"[@0,0:0='a',<1>,1:0]\n" +
+			"[@1,2:2='x',<1>,1:2]\n" +
+			"[@2,3:2='<EOF>',<-1>,1:3]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetNot() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(96);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("I : ~[ab \\n] ~[ \\ncd]* {System.out.println(\"I\");} ;\n");
+		grammarBuilder.append("WS : [ \\n\\u000D]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="xaf";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"I\n" +
+			"[@0,0:2='xaf',<1>,1:0]\n" +
+			"[@1,3:2='<EOF>',<-1>,1:3]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetPlus() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(87);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("I : '0'..'9'+ {System.out.println(\"I\");} ;\n");
+		grammarBuilder.append("WS : [ \\n\\u000D]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+		String input =
+			"34\n" +
+			" 34";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"I\n" +
+			"I\n" +
+			"[@0,0:1='34',<1>,1:0]\n" +
+			"[@1,4:5='34',<1>,2:1]\n" +
+			"[@2,6:5='<EOF>',<-1>,2:3]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetRange() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(143);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("I : [0-9]+ {System.out.println(\"I\");} ;\n");
+		grammarBuilder.append("ID : [a-zA-Z] [a-zA-Z0-9]* {System.out.println(\"ID\");} ;\n");
+		grammarBuilder.append("WS : [ \\n\\u0009\\r]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+		String input =
+			"34\n" +
+			" 34 a2 abc \n" +
+			"   ";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"I\n" +
+			"I\n" +
+			"ID\n" +
+			"ID\n" +
+			"[@0,0:1='34',<1>,1:0]\n" +
+			"[@1,4:5='34',<1>,2:1]\n" +
+			"[@2,7:8='a2',<2>,2:4]\n" +
+			"[@3,10:12='abc',<2>,2:7]\n" +
+			"[@4,18:17='<EOF>',<-1>,3:3]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetWithEscapedChar() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(95);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("DASHBRACK : [\\-\\]]+ {System.out.println(\"DASHBRACK\");} ;\n");
+		grammarBuilder.append("WS : [ \\u]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="- ] ";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"DASHBRACK\n" +
+			"DASHBRACK\n" +
+			"[@0,0:0='-',<1>,1:0]\n" +
+			"[@1,2:2=']',<1>,1:2]\n" +
+			"[@2,4:3='<EOF>',<-1>,1:4]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetWithMissingEndRange() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(83);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("I : [0-]+ {System.out.println(\"I\");} ;\n");
+		grammarBuilder.append("WS : [ \\n\\u000D]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="00\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"I\n" +
+			"[@0,0:1='00',<1>,1:0]\n" +
+			"[@1,3:2='<EOF>',<-1>,2:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetWithMissingEscapeChar() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(78);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("I : [0-9]+ {System.out.println(\"I\");} ;\n");
+		grammarBuilder.append("WS : [ \\u]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="34 ";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"I\n" +
+			"[@0,0:1='34',<1>,1:0]\n" +
+			"[@1,3:2='<EOF>',<-1>,1:3]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetWithQuote1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(81);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : [\"a-z]+ {System.out.println(\"A\");} ;\n");
+		grammarBuilder.append("WS : [ \\n\\t]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="b\"a";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"A\n" +
+			"[@0,0:2='b\"a',<1>,1:0]\n" +
+			"[@1,3:2='<EOF>',<-1>,1:3]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetWithQuote2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(82);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : [\"\\\\ab]+ {System.out.println(\"A\");} ;\n");
+		grammarBuilder.append("WS : [ \\n\\t]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="b\"\\a";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"A\n" +
+			"[@0,0:3='b\"\\a',<1>,1:0]\n" +
+			"[@1,4:3='<EOF>',<-1>,1:4]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetWithReversedRange() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(79);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : [z-a9]+ {System.out.println(\"A\");} ;\n");
+		grammarBuilder.append("WS : [ \\u]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="9";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"A\n" +
+			"[@0,0:0='9',<1>,1:0]\n" +
+			"[@1,1:0='<EOF>',<-1>,1:1]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testEOFByItself() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(38);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("DONE : EOF ;\n");
+		grammarBuilder.append("A : 'a';");
+		String grammar = grammarBuilder.toString();
+
+		String input ="";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:-1='<EOF>',<1>,1:0]\n" +
+			"[@1,0:-1='<EOF>',<-1>,1:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testEOFSuffixInFirstRule_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(48);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : 'a' EOF ;\n");
+		grammarBuilder.append("B : 'a';\n");
+		grammarBuilder.append("C : 'c';");
+		String grammar = grammarBuilder.toString();
+
+		String input ="";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals("[@0,0:-1='<EOF>',<-1>,1:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testEOFSuffixInFirstRule_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(48);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : 'a' EOF ;\n");
+		grammarBuilder.append("B : 'a';\n");
+		grammarBuilder.append("C : 'c';");
+		String grammar = grammarBuilder.toString();
+
+		String input ="a";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:0='a',<1>,1:0]\n" +
+			"[@1,1:0='<EOF>',<-1>,1:1]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testGreedyClosure() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(60);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("CMT : '//' .*? '\\n' CMT*;\n");
+		grammarBuilder.append("WS : (' '|'\\t')+;");
+		String grammar = grammarBuilder.toString();
+
+		String input =
+			"//blah\n" +
+			"//blah\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:13='//blah\\n//blah\\n',<1>,1:0]\n" +
+			"[@1,14:13='<EOF>',<-1>,3:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testGreedyConfigs() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(106);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("I : ('a' | 'ab') {System.out.println(this.getText());} ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;\n");
+		grammarBuilder.append("J : .;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="ab";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"ab\n" +
+			"[@0,0:1='ab',<1>,1:0]\n" +
+			"[@1,2:1='<EOF>',<-1>,1:2]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testGreedyOptional() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(60);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("CMT : '//' .*? '\\n' CMT?;\n");
+		grammarBuilder.append("WS : (' '|'\\t')+;");
+		String grammar = grammarBuilder.toString();
+
+		String input =
+			"//blah\n" +
+			"//blah\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:13='//blah\\n//blah\\n',<1>,1:0]\n" +
+			"[@1,14:13='<EOF>',<-1>,3:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testGreedyPositiveClosure() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(58);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("CMT : ('//' .*? '\\n')+;\n");
+		grammarBuilder.append("WS : (' '|'\\t')+;");
+		String grammar = grammarBuilder.toString();
+
+		String input =
+			"//blah\n" +
+			"//blah\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:13='//blah\\n//blah\\n',<1>,1:0]\n" +
+			"[@1,14:13='<EOF>',<-1>,3:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testHexVsID() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(265);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("HexLiteral : '0' ('x'|'X') HexDigit+ ;\n");
+		grammarBuilder.append("DecimalLiteral : ('0' | '1'..'9' '0'..'9'*) ;\n");
+		grammarBuilder.append("FloatingPointLiteral : ('0x' | '0X') HexDigit* ('.' HexDigit*)? ;\n");
+		grammarBuilder.append("DOT : '.' ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("fragment HexDigit : ('0'..'9'|'a'..'f'|'A'..'F') ;\n");
+		grammarBuilder.append("WS : (' '|'\\n')+;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="x 0 1 a.b a.l";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:0='x',<5>,1:0]\n" +
+			"[@1,1:1=' ',<6>,1:1]\n" +
+			"[@2,2:2='0',<2>,1:2]\n" +
+			"[@3,3:3=' ',<6>,1:3]\n" +
+			"[@4,4:4='1',<2>,1:4]\n" +
+			"[@5,5:5=' ',<6>,1:5]\n" +
+			"[@6,6:6='a',<5>,1:6]\n" +
+			"[@7,7:7='.',<4>,1:7]\n" +
+			"[@8,8:8='b',<5>,1:8]\n" +
+			"[@9,9:9=' ',<6>,1:9]\n" +
+			"[@10,10:10='a',<5>,1:10]\n" +
+			"[@11,11:11='.',<4>,1:11]\n" +
+			"[@12,12:12='l',<5>,1:12]\n" +
+			"[@13,13:12='<EOF>',<-1>,1:13]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testKeywordID() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(82);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("KEND : 'end' ; // has priority\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n')+;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="end eend ending a";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:2='end',<1>,1:0]\n" +
+			"[@1,3:3=' ',<3>,1:3]\n" +
+			"[@2,4:7='eend',<2>,1:4]\n" +
+			"[@3,8:8=' ',<3>,1:8]\n" +
+			"[@4,9:14='ending',<2>,1:9]\n" +
+			"[@5,15:15=' ',<3>,1:15]\n" +
+			"[@6,16:16='a',<2>,1:16]\n" +
+			"[@7,17:16='<EOF>',<-1>,1:17]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLargeLexer() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(85821);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("WS : [ \\t\\r\\n]+ -> skip;\n");
+		grammarBuilder.append("KW0 : 'KW' '0';\n");
+		grammarBuilder.append("KW1 : 'KW' '1';\n");
+		grammarBuilder.append("KW2 : 'KW' '2';\n");
+		grammarBuilder.append("KW3 : 'KW' '3';\n");
+		grammarBuilder.append("KW4 : 'KW' '4';\n");
+		grammarBuilder.append("KW5 : 'KW' '5';\n");
+		grammarBuilder.append("KW6 : 'KW' '6';\n");
+		grammarBuilder.append("KW7 : 'KW' '7';\n");
+		grammarBuilder.append("KW8 : 'KW' '8';\n");
+		grammarBuilder.append("KW9 : 'KW' '9';\n");
+		grammarBuilder.append("KW10 : 'KW' '10';\n");
+		grammarBuilder.append("KW11 : 'KW' '11';\n");
+		grammarBuilder.append("KW12 : 'KW' '12';\n");
+		grammarBuilder.append("KW13 : 'KW' '13';\n");
+		grammarBuilder.append("KW14 : 'KW' '14';\n");
+		grammarBuilder.append("KW15 : 'KW' '15';\n");
+		grammarBuilder.append("KW16 : 'KW' '16';\n");
+		grammarBuilder.append("KW17 : 'KW' '17';\n");
+		grammarBuilder.append("KW18 : 'KW' '18';\n");
+		grammarBuilder.append("KW19 : 'KW' '19';\n");
+		grammarBuilder.append("KW20 : 'KW' '20';\n");
+		grammarBuilder.append("KW21 : 'KW' '21';\n");
+		grammarBuilder.append("KW22 : 'KW' '22';\n");
+		grammarBuilder.append("KW23 : 'KW' '23';\n");
+		grammarBuilder.append("KW24 : 'KW' '24';\n");
+		grammarBuilder.append("KW25 : 'KW' '25';\n");
+		grammarBuilder.append("KW26 : 'KW' '26';\n");
+		grammarBuilder.append("KW27 : 'KW' '27';\n");
+		grammarBuilder.append("KW28 : 'KW' '28';\n");
+		grammarBuilder.append("KW29 : 'KW' '29';\n");
+		grammarBuilder.append("KW30 : 'KW' '30';\n");
+		grammarBuilder.append("KW31 : 'KW' '31';\n");
+		grammarBuilder.append("KW32 : 'KW' '32';\n");
+		grammarBuilder.append("KW33 : 'KW' '33';\n");
+		grammarBuilder.append("KW34 : 'KW' '34';\n");
+		grammarBuilder.append("KW35 : 'KW' '35';\n");
+		grammarBuilder.append("KW36 : 'KW' '36';\n");
+		grammarBuilder.append("KW37 : 'KW' '37';\n");
+		grammarBuilder.append("KW38 : 'KW' '38';\n");
+		grammarBuilder.append("KW39 : 'KW' '39';\n");
+		grammarBuilder.append("KW40 : 'KW' '40';\n");
+		grammarBuilder.append("KW41 : 'KW' '41';\n");
+		grammarBuilder.append("KW42 : 'KW' '42';\n");
+		grammarBuilder.append("KW43 : 'KW' '43';\n");
+		grammarBuilder.append("KW44 : 'KW' '44';\n");
+		grammarBuilder.append("KW45 : 'KW' '45';\n");
+		grammarBuilder.append("KW46 : 'KW' '46';\n");
+		grammarBuilder.append("KW47 : 'KW' '47';\n");
+		grammarBuilder.append("KW48 : 'KW' '48';\n");
+		grammarBuilder.append("KW49 : 'KW' '49';\n");
+		grammarBuilder.append("KW50 : 'KW' '50';\n");
+		grammarBuilder.append("KW51 : 'KW' '51';\n");
+		grammarBuilder.append("KW52 : 'KW' '52';\n");
+		grammarBuilder.append("KW53 : 'KW' '53';\n");
+		grammarBuilder.append("KW54 : 'KW' '54';\n");
+		grammarBuilder.append("KW55 : 'KW' '55';\n");
+		grammarBuilder.append("KW56 : 'KW' '56';\n");
+		grammarBuilder.append("KW57 : 'KW' '57';\n");
+		grammarBuilder.append("KW58 : 'KW' '58';\n");
+		grammarBuilder.append("KW59 : 'KW' '59';\n");
+		grammarBuilder.append("KW60 : 'KW' '60';\n");
+		grammarBuilder.append("KW61 : 'KW' '61';\n");
+		grammarBuilder.append("KW62 : 'KW' '62';\n");
+		grammarBuilder.append("KW63 : 'KW' '63';\n");
+		grammarBuilder.append("KW64 : 'KW' '64';\n");
+		grammarBuilder.append("KW65 : 'KW' '65';\n");
+		grammarBuilder.append("KW66 : 'KW' '66';\n");
+		grammarBuilder.append("KW67 : 'KW' '67';\n");
+		grammarBuilder.append("KW68 : 'KW' '68';\n");
+		grammarBuilder.append("KW69 : 'KW' '69';\n");
+		grammarBuilder.append("KW70 : 'KW' '70';\n");
+		grammarBuilder.append("KW71 : 'KW' '71';\n");
+		grammarBuilder.append("KW72 : 'KW' '72';\n");
+		grammarBuilder.append("KW73 : 'KW' '73';\n");
+		grammarBuilder.append("KW74 : 'KW' '74';\n");
+		grammarBuilder.append("KW75 : 'KW' '75';\n");
+		grammarBuilder.append("KW76 : 'KW' '76';\n");
+		grammarBuilder.append("KW77 : 'KW' '77';\n");
+		grammarBuilder.append("KW78 : 'KW' '78';\n");
+		grammarBuilder.append("KW79 : 'KW' '79';\n");
+		grammarBuilder.append("KW80 : 'KW' '80';\n");
+		grammarBuilder.append("KW81 : 'KW' '81';\n");
+		grammarBuilder.append("KW82 : 'KW' '82';\n");
+		grammarBuilder.append("KW83 : 'KW' '83';\n");
+		grammarBuilder.append("KW84 : 'KW' '84';\n");
+		grammarBuilder.append("KW85 : 'KW' '85';\n");
+		grammarBuilder.append("KW86 : 'KW' '86';\n");
+		grammarBuilder.append("KW87 : 'KW' '87';\n");
+		grammarBuilder.append("KW88 : 'KW' '88';\n");
+		grammarBuilder.append("KW89 : 'KW' '89';\n");
+		grammarBuilder.append("KW90 : 'KW' '90';\n");
+		grammarBuilder.append("KW91 : 'KW' '91';\n");
+		grammarBuilder.append("KW92 : 'KW' '92';\n");
+		grammarBuilder.append("KW93 : 'KW' '93';\n");
+		grammarBuilder.append("KW94 : 'KW' '94';\n");
+		grammarBuilder.append("KW95 : 'KW' '95';\n");
+		grammarBuilder.append("KW96 : 'KW' '96';\n");
+		grammarBuilder.append("KW97 : 'KW' '97';\n");
+		grammarBuilder.append("KW98 : 'KW' '98';\n");
+		grammarBuilder.append("KW99 : 'KW' '99';\n");
+		grammarBuilder.append("KW100 : 'KW' '100';\n");
+		grammarBuilder.append("KW101 : 'KW' '101';\n");
+		grammarBuilder.append("KW102 : 'KW' '102';\n");
+		grammarBuilder.append("KW103 : 'KW' '103';\n");
+		grammarBuilder.append("KW104 : 'KW' '104';\n");
+		grammarBuilder.append("KW105 : 'KW' '105';\n");
+		grammarBuilder.append("KW106 : 'KW' '106';\n");
+		grammarBuilder.append("KW107 : 'KW' '107';\n");
+		grammarBuilder.append("KW108 : 'KW' '108';\n");
+		grammarBuilder.append("KW109 : 'KW' '109';\n");
+		grammarBuilder.append("KW110 : 'KW' '110';\n");
+		grammarBuilder.append("KW111 : 'KW' '111';\n");
+		grammarBuilder.append("KW112 : 'KW' '112';\n");
+		grammarBuilder.append("KW113 : 'KW' '113';\n");
+		grammarBuilder.append("KW114 : 'KW' '114';\n");
+		grammarBuilder.append("KW115 : 'KW' '115';\n");
+		grammarBuilder.append("KW116 : 'KW' '116';\n");
+		grammarBuilder.append("KW117 : 'KW' '117';\n");
+		grammarBuilder.append("KW118 : 'KW' '118';\n");
+		grammarBuilder.append("KW119 : 'KW' '119';\n");
+		grammarBuilder.append("KW120 : 'KW' '120';\n");
+		grammarBuilder.append("KW121 : 'KW' '121';\n");
+		grammarBuilder.append("KW122 : 'KW' '122';\n");
+		grammarBuilder.append("KW123 : 'KW' '123';\n");
+		grammarBuilder.append("KW124 : 'KW' '124';\n");
+		grammarBuilder.append("KW125 : 'KW' '125';\n");
+		grammarBuilder.append("KW126 : 'KW' '126';\n");
+		grammarBuilder.append("KW127 : 'KW' '127';\n");
+		grammarBuilder.append("KW128 : 'KW' '128';\n");
+		grammarBuilder.append("KW129 : 'KW' '129';\n");
+		grammarBuilder.append("KW130 : 'KW' '130';\n");
+		grammarBuilder.append("KW131 : 'KW' '131';\n");
+		grammarBuilder.append("KW132 : 'KW' '132';\n");
+		grammarBuilder.append("KW133 : 'KW' '133';\n");
+		grammarBuilder.append("KW134 : 'KW' '134';\n");
+		grammarBuilder.append("KW135 : 'KW' '135';\n");
+		grammarBuilder.append("KW136 : 'KW' '136';\n");
+		grammarBuilder.append("KW137 : 'KW' '137';\n");
+		grammarBuilder.append("KW138 : 'KW' '138';\n");
+		grammarBuilder.append("KW139 : 'KW' '139';\n");
+		grammarBuilder.append("KW140 : 'KW' '140';\n");
+		grammarBuilder.append("KW141 : 'KW' '141';\n");
+		grammarBuilder.append("KW142 : 'KW' '142';\n");
+		grammarBuilder.append("KW143 : 'KW' '143';\n");
+		grammarBuilder.append("KW144 : 'KW' '144';\n");
+		grammarBuilder.append("KW145 : 'KW' '145';\n");
+		grammarBuilder.append("KW146 : 'KW' '146';\n");
+		grammarBuilder.append("KW147 : 'KW' '147';\n");
+		grammarBuilder.append("KW148 : 'KW' '148';\n");
+		grammarBuilder.append("KW149 : 'KW' '149';\n");
+		grammarBuilder.append("KW150 : 'KW' '150';\n");
+		grammarBuilder.append("KW151 : 'KW' '151';\n");
+		grammarBuilder.append("KW152 : 'KW' '152';\n");
+		grammarBuilder.append("KW153 : 'KW' '153';\n");
+		grammarBuilder.append("KW154 : 'KW' '154';\n");
+		grammarBuilder.append("KW155 : 'KW' '155';\n");
+		grammarBuilder.append("KW156 : 'KW' '156';\n");
+		grammarBuilder.append("KW157 : 'KW' '157';\n");
+		grammarBuilder.append("KW158 : 'KW' '158';\n");
+		grammarBuilder.append("KW159 : 'KW' '159';\n");
+		grammarBuilder.append("KW160 : 'KW' '160';\n");
+		grammarBuilder.append("KW161 : 'KW' '161';\n");
+		grammarBuilder.append("KW162 : 'KW' '162';\n");
+		grammarBuilder.append("KW163 : 'KW' '163';\n");
+		grammarBuilder.append("KW164 : 'KW' '164';\n");
+		grammarBuilder.append("KW165 : 'KW' '165';\n");
+		grammarBuilder.append("KW166 : 'KW' '166';\n");
+		grammarBuilder.append("KW167 : 'KW' '167';\n");
+		grammarBuilder.append("KW168 : 'KW' '168';\n");
+		grammarBuilder.append("KW169 : 'KW' '169';\n");
+		grammarBuilder.append("KW170 : 'KW' '170';\n");
+		grammarBuilder.append("KW171 : 'KW' '171';\n");
+		grammarBuilder.append("KW172 : 'KW' '172';\n");
+		grammarBuilder.append("KW173 : 'KW' '173';\n");
+		grammarBuilder.append("KW174 : 'KW' '174';\n");
+		grammarBuilder.append("KW175 : 'KW' '175';\n");
+		grammarBuilder.append("KW176 : 'KW' '176';\n");
+		grammarBuilder.append("KW177 : 'KW' '177';\n");
+		grammarBuilder.append("KW178 : 'KW' '178';\n");
+		grammarBuilder.append("KW179 : 'KW' '179';\n");
+		grammarBuilder.append("KW180 : 'KW' '180';\n");
+		grammarBuilder.append("KW181 : 'KW' '181';\n");
+		grammarBuilder.append("KW182 : 'KW' '182';\n");
+		grammarBuilder.append("KW183 : 'KW' '183';\n");
+		grammarBuilder.append("KW184 : 'KW' '184';\n");
+		grammarBuilder.append("KW185 : 'KW' '185';\n");
+		grammarBuilder.append("KW186 : 'KW' '186';\n");
+		grammarBuilder.append("KW187 : 'KW' '187';\n");
+		grammarBuilder.append("KW188 : 'KW' '188';\n");
+		grammarBuilder.append("KW189 : 'KW' '189';\n");
+		grammarBuilder.append("KW190 : 'KW' '190';\n");
+		grammarBuilder.append("KW191 : 'KW' '191';\n");
+		grammarBuilder.append("KW192 : 'KW' '192';\n");
+		grammarBuilder.append("KW193 : 'KW' '193';\n");
+		grammarBuilder.append("KW194 : 'KW' '194';\n");
+		grammarBuilder.append("KW195 : 'KW' '195';\n");
+		grammarBuilder.append("KW196 : 'KW' '196';\n");
+		grammarBuilder.append("KW197 : 'KW' '197';\n");
+		grammarBuilder.append("KW198 : 'KW' '198';\n");
+		grammarBuilder.append("KW199 : 'KW' '199';\n");
+		grammarBuilder.append("KW200 : 'KW' '200';\n");
+		grammarBuilder.append("KW201 : 'KW' '201';\n");
+		grammarBuilder.append("KW202 : 'KW' '202';\n");
+		grammarBuilder.append("KW203 : 'KW' '203';\n");
+		grammarBuilder.append("KW204 : 'KW' '204';\n");
+		grammarBuilder.append("KW205 : 'KW' '205';\n");
+		grammarBuilder.append("KW206 : 'KW' '206';\n");
+		grammarBuilder.append("KW207 : 'KW' '207';\n");
+		grammarBuilder.append("KW208 : 'KW' '208';\n");
+		grammarBuilder.append("KW209 : 'KW' '209';\n");
+		grammarBuilder.append("KW210 : 'KW' '210';\n");
+		grammarBuilder.append("KW211 : 'KW' '211';\n");
+		grammarBuilder.append("KW212 : 'KW' '212';\n");
+		grammarBuilder.append("KW213 : 'KW' '213';\n");
+		grammarBuilder.append("KW214 : 'KW' '214';\n");
+		grammarBuilder.append("KW215 : 'KW' '215';\n");
+		grammarBuilder.append("KW216 : 'KW' '216';\n");
+		grammarBuilder.append("KW217 : 'KW' '217';\n");
+		grammarBuilder.append("KW218 : 'KW' '218';\n");
+		grammarBuilder.append("KW219 : 'KW' '219';\n");
+		grammarBuilder.append("KW220 : 'KW' '220';\n");
+		grammarBuilder.append("KW221 : 'KW' '221';\n");
+		grammarBuilder.append("KW222 : 'KW' '222';\n");
+		grammarBuilder.append("KW223 : 'KW' '223';\n");
+		grammarBuilder.append("KW224 : 'KW' '224';\n");
+		grammarBuilder.append("KW225 : 'KW' '225';\n");
+		grammarBuilder.append("KW226 : 'KW' '226';\n");
+		grammarBuilder.append("KW227 : 'KW' '227';\n");
+		grammarBuilder.append("KW228 : 'KW' '228';\n");
+		grammarBuilder.append("KW229 : 'KW' '229';\n");
+		grammarBuilder.append("KW230 : 'KW' '230';\n");
+		grammarBuilder.append("KW231 : 'KW' '231';\n");
+		grammarBuilder.append("KW232 : 'KW' '232';\n");
+		grammarBuilder.append("KW233 : 'KW' '233';\n");
+		grammarBuilder.append("KW234 : 'KW' '234';\n");
+		grammarBuilder.append("KW235 : 'KW' '235';\n");
+		grammarBuilder.append("KW236 : 'KW' '236';\n");
+		grammarBuilder.append("KW237 : 'KW' '237';\n");
+		grammarBuilder.append("KW238 : 'KW' '238';\n");
+		grammarBuilder.append("KW239 : 'KW' '239';\n");
+		grammarBuilder.append("KW240 : 'KW' '240';\n");
+		grammarBuilder.append("KW241 : 'KW' '241';\n");
+		grammarBuilder.append("KW242 : 'KW' '242';\n");
+		grammarBuilder.append("KW243 : 'KW' '243';\n");
+		grammarBuilder.append("KW244 : 'KW' '244';\n");
+		grammarBuilder.append("KW245 : 'KW' '245';\n");
+		grammarBuilder.append("KW246 : 'KW' '246';\n");
+		grammarBuilder.append("KW247 : 'KW' '247';\n");
+		grammarBuilder.append("KW248 : 'KW' '248';\n");
+		grammarBuilder.append("KW249 : 'KW' '249';\n");
+		grammarBuilder.append("KW250 : 'KW' '250';\n");
+		grammarBuilder.append("KW251 : 'KW' '251';\n");
+		grammarBuilder.append("KW252 : 'KW' '252';\n");
+		grammarBuilder.append("KW253 : 'KW' '253';\n");
+		grammarBuilder.append("KW254 : 'KW' '254';\n");
+		grammarBuilder.append("KW255 : 'KW' '255';\n");
+		grammarBuilder.append("KW256 : 'KW' '256';\n");
+		grammarBuilder.append("KW257 : 'KW' '257';\n");
+		grammarBuilder.append("KW258 : 'KW' '258';\n");
+		grammarBuilder.append("KW259 : 'KW' '259';\n");
+		grammarBuilder.append("KW260 : 'KW' '260';\n");
+		grammarBuilder.append("KW261 : 'KW' '261';\n");
+		grammarBuilder.append("KW262 : 'KW' '262';\n");
+		grammarBuilder.append("KW263 : 'KW' '263';\n");
+		grammarBuilder.append("KW264 : 'KW' '264';\n");
+		grammarBuilder.append("KW265 : 'KW' '265';\n");
+		grammarBuilder.append("KW266 : 'KW' '266';\n");
+		grammarBuilder.append("KW267 : 'KW' '267';\n");
+		grammarBuilder.append("KW268 : 'KW' '268';\n");
+		grammarBuilder.append("KW269 : 'KW' '269';\n");
+		grammarBuilder.append("KW270 : 'KW' '270';\n");
+		grammarBuilder.append("KW271 : 'KW' '271';\n");
+		grammarBuilder.append("KW272 : 'KW' '272';\n");
+		grammarBuilder.append("KW273 : 'KW' '273';\n");
+		grammarBuilder.append("KW274 : 'KW' '274';\n");
+		grammarBuilder.append("KW275 : 'KW' '275';\n");
+		grammarBuilder.append("KW276 : 'KW' '276';\n");
+		grammarBuilder.append("KW277 : 'KW' '277';\n");
+		grammarBuilder.append("KW278 : 'KW' '278';\n");
+		grammarBuilder.append("KW279 : 'KW' '279';\n");
+		grammarBuilder.append("KW280 : 'KW' '280';\n");
+		grammarBuilder.append("KW281 : 'KW' '281';\n");
+		grammarBuilder.append("KW282 : 'KW' '282';\n");
+		grammarBuilder.append("KW283 : 'KW' '283';\n");
+		grammarBuilder.append("KW284 : 'KW' '284';\n");
+		grammarBuilder.append("KW285 : 'KW' '285';\n");
+		grammarBuilder.append("KW286 : 'KW' '286';\n");
+		grammarBuilder.append("KW287 : 'KW' '287';\n");
+		grammarBuilder.append("KW288 : 'KW' '288';\n");
+		grammarBuilder.append("KW289 : 'KW' '289';\n");
+		grammarBuilder.append("KW290 : 'KW' '290';\n");
+		grammarBuilder.append("KW291 : 'KW' '291';\n");
+		grammarBuilder.append("KW292 : 'KW' '292';\n");
+		grammarBuilder.append("KW293 : 'KW' '293';\n");
+		grammarBuilder.append("KW294 : 'KW' '294';\n");
+		grammarBuilder.append("KW295 : 'KW' '295';\n");
+		grammarBuilder.append("KW296 : 'KW' '296';\n");
+		grammarBuilder.append("KW297 : 'KW' '297';\n");
+		grammarBuilder.append("KW298 : 'KW' '298';\n");
+		grammarBuilder.append("KW299 : 'KW' '299';\n");
+		grammarBuilder.append("KW300 : 'KW' '300';\n");
+		grammarBuilder.append("KW301 : 'KW' '301';\n");
+		grammarBuilder.append("KW302 : 'KW' '302';\n");
+		grammarBuilder.append("KW303 : 'KW' '303';\n");
+		grammarBuilder.append("KW304 : 'KW' '304';\n");
+		grammarBuilder.append("KW305 : 'KW' '305';\n");
+		grammarBuilder.append("KW306 : 'KW' '306';\n");
+		grammarBuilder.append("KW307 : 'KW' '307';\n");
+		grammarBuilder.append("KW308 : 'KW' '308';\n");
+		grammarBuilder.append("KW309 : 'KW' '309';\n");
+		grammarBuilder.append("KW310 : 'KW' '310';\n");
+		grammarBuilder.append("KW311 : 'KW' '311';\n");
+		grammarBuilder.append("KW312 : 'KW' '312';\n");
+		grammarBuilder.append("KW313 : 'KW' '313';\n");
+		grammarBuilder.append("KW314 : 'KW' '314';\n");
+		grammarBuilder.append("KW315 : 'KW' '315';\n");
+		grammarBuilder.append("KW316 : 'KW' '316';\n");
+		grammarBuilder.append("KW317 : 'KW' '317';\n");
+		grammarBuilder.append("KW318 : 'KW' '318';\n");
+		grammarBuilder.append("KW319 : 'KW' '319';\n");
+		grammarBuilder.append("KW320 : 'KW' '320';\n");
+		grammarBuilder.append("KW321 : 'KW' '321';\n");
+		grammarBuilder.append("KW322 : 'KW' '322';\n");
+		grammarBuilder.append("KW323 : 'KW' '323';\n");
+		grammarBuilder.append("KW324 : 'KW' '324';\n");
+		grammarBuilder.append("KW325 : 'KW' '325';\n");
+		grammarBuilder.append("KW326 : 'KW' '326';\n");
+		grammarBuilder.append("KW327 : 'KW' '327';\n");
+		grammarBuilder.append("KW328 : 'KW' '328';\n");
+		grammarBuilder.append("KW329 : 'KW' '329';\n");
+		grammarBuilder.append("KW330 : 'KW' '330';\n");
+		grammarBuilder.append("KW331 : 'KW' '331';\n");
+		grammarBuilder.append("KW332 : 'KW' '332';\n");
+		grammarBuilder.append("KW333 : 'KW' '333';\n");
+		grammarBuilder.append("KW334 : 'KW' '334';\n");
+		grammarBuilder.append("KW335 : 'KW' '335';\n");
+		grammarBuilder.append("KW336 : 'KW' '336';\n");
+		grammarBuilder.append("KW337 : 'KW' '337';\n");
+		grammarBuilder.append("KW338 : 'KW' '338';\n");
+		grammarBuilder.append("KW339 : 'KW' '339';\n");
+		grammarBuilder.append("KW340 : 'KW' '340';\n");
+		grammarBuilder.append("KW341 : 'KW' '341';\n");
+		grammarBuilder.append("KW342 : 'KW' '342';\n");
+		grammarBuilder.append("KW343 : 'KW' '343';\n");
+		grammarBuilder.append("KW344 : 'KW' '344';\n");
+		grammarBuilder.append("KW345 : 'KW' '345';\n");
+		grammarBuilder.append("KW346 : 'KW' '346';\n");
+		grammarBuilder.append("KW347 : 'KW' '347';\n");
+		grammarBuilder.append("KW348 : 'KW' '348';\n");
+		grammarBuilder.append("KW349 : 'KW' '349';\n");
+		grammarBuilder.append("KW350 : 'KW' '350';\n");
+		grammarBuilder.append("KW351 : 'KW' '351';\n");
+		grammarBuilder.append("KW352 : 'KW' '352';\n");
+		grammarBuilder.append("KW353 : 'KW' '353';\n");
+		grammarBuilder.append("KW354 : 'KW' '354';\n");
+		grammarBuilder.append("KW355 : 'KW' '355';\n");
+		grammarBuilder.append("KW356 : 'KW' '356';\n");
+		grammarBuilder.append("KW357 : 'KW' '357';\n");
+		grammarBuilder.append("KW358 : 'KW' '358';\n");
+		grammarBuilder.append("KW359 : 'KW' '359';\n");
+		grammarBuilder.append("KW360 : 'KW' '360';\n");
+		grammarBuilder.append("KW361 : 'KW' '361';\n");
+		grammarBuilder.append("KW362 : 'KW' '362';\n");
+		grammarBuilder.append("KW363 : 'KW' '363';\n");
+		grammarBuilder.append("KW364 : 'KW' '364';\n");
+		grammarBuilder.append("KW365 : 'KW' '365';\n");
+		grammarBuilder.append("KW366 : 'KW' '366';\n");
+		grammarBuilder.append("KW367 : 'KW' '367';\n");
+		grammarBuilder.append("KW368 : 'KW' '368';\n");
+		grammarBuilder.append("KW369 : 'KW' '369';\n");
+		grammarBuilder.append("KW370 : 'KW' '370';\n");
+		grammarBuilder.append("KW371 : 'KW' '371';\n");
+		grammarBuilder.append("KW372 : 'KW' '372';\n");
+		grammarBuilder.append("KW373 : 'KW' '373';\n");
+		grammarBuilder.append("KW374 : 'KW' '374';\n");
+		grammarBuilder.append("KW375 : 'KW' '375';\n");
+		grammarBuilder.append("KW376 : 'KW' '376';\n");
+		grammarBuilder.append("KW377 : 'KW' '377';\n");
+		grammarBuilder.append("KW378 : 'KW' '378';\n");
+		grammarBuilder.append("KW379 : 'KW' '379';\n");
+		grammarBuilder.append("KW380 : 'KW' '380';\n");
+		grammarBuilder.append("KW381 : 'KW' '381';\n");
+		grammarBuilder.append("KW382 : 'KW' '382';\n");
+		grammarBuilder.append("KW383 : 'KW' '383';\n");
+		grammarBuilder.append("KW384 : 'KW' '384';\n");
+		grammarBuilder.append("KW385 : 'KW' '385';\n");
+		grammarBuilder.append("KW386 : 'KW' '386';\n");
+		grammarBuilder.append("KW387 : 'KW' '387';\n");
+		grammarBuilder.append("KW388 : 'KW' '388';\n");
+		grammarBuilder.append("KW389 : 'KW' '389';\n");
+		grammarBuilder.append("KW390 : 'KW' '390';\n");
+		grammarBuilder.append("KW391 : 'KW' '391';\n");
+		grammarBuilder.append("KW392 : 'KW' '392';\n");
+		grammarBuilder.append("KW393 : 'KW' '393';\n");
+		grammarBuilder.append("KW394 : 'KW' '394';\n");
+		grammarBuilder.append("KW395 : 'KW' '395';\n");
+		grammarBuilder.append("KW396 : 'KW' '396';\n");
+		grammarBuilder.append("KW397 : 'KW' '397';\n");
+		grammarBuilder.append("KW398 : 'KW' '398';\n");
+		grammarBuilder.append("KW399 : 'KW' '399';\n");
+		grammarBuilder.append("KW400 : 'KW' '400';\n");
+		grammarBuilder.append("KW401 : 'KW' '401';\n");
+		grammarBuilder.append("KW402 : 'KW' '402';\n");
+		grammarBuilder.append("KW403 : 'KW' '403';\n");
+		grammarBuilder.append("KW404 : 'KW' '404';\n");
+		grammarBuilder.append("KW405 : 'KW' '405';\n");
+		grammarBuilder.append("KW406 : 'KW' '406';\n");
+		grammarBuilder.append("KW407 : 'KW' '407';\n");
+		grammarBuilder.append("KW408 : 'KW' '408';\n");
+		grammarBuilder.append("KW409 : 'KW' '409';\n");
+		grammarBuilder.append("KW410 : 'KW' '410';\n");
+		grammarBuilder.append("KW411 : 'KW' '411';\n");
+		grammarBuilder.append("KW412 : 'KW' '412';\n");
+		grammarBuilder.append("KW413 : 'KW' '413';\n");
+		grammarBuilder.append("KW414 : 'KW' '414';\n");
+		grammarBuilder.append("KW415 : 'KW' '415';\n");
+		grammarBuilder.append("KW416 : 'KW' '416';\n");
+		grammarBuilder.append("KW417 : 'KW' '417';\n");
+		grammarBuilder.append("KW418 : 'KW' '418';\n");
+		grammarBuilder.append("KW419 : 'KW' '419';\n");
+		grammarBuilder.append("KW420 : 'KW' '420';\n");
+		grammarBuilder.append("KW421 : 'KW' '421';\n");
+		grammarBuilder.append("KW422 : 'KW' '422';\n");
+		grammarBuilder.append("KW423 : 'KW' '423';\n");
+		grammarBuilder.append("KW424 : 'KW' '424';\n");
+		grammarBuilder.append("KW425 : 'KW' '425';\n");
+		grammarBuilder.append("KW426 : 'KW' '426';\n");
+		grammarBuilder.append("KW427 : 'KW' '427';\n");
+		grammarBuilder.append("KW428 : 'KW' '428';\n");
+		grammarBuilder.append("KW429 : 'KW' '429';\n");
+		grammarBuilder.append("KW430 : 'KW' '430';\n");
+		grammarBuilder.append("KW431 : 'KW' '431';\n");
+		grammarBuilder.append("KW432 : 'KW' '432';\n");
+		grammarBuilder.append("KW433 : 'KW' '433';\n");
+		grammarBuilder.append("KW434 : 'KW' '434';\n");
+		grammarBuilder.append("KW435 : 'KW' '435';\n");
+		grammarBuilder.append("KW436 : 'KW' '436';\n");
+		grammarBuilder.append("KW437 : 'KW' '437';\n");
+		grammarBuilder.append("KW438 : 'KW' '438';\n");
+		grammarBuilder.append("KW439 : 'KW' '439';\n");
+		grammarBuilder.append("KW440 : 'KW' '440';\n");
+		grammarBuilder.append("KW441 : 'KW' '441';\n");
+		grammarBuilder.append("KW442 : 'KW' '442';\n");
+		grammarBuilder.append("KW443 : 'KW' '443';\n");
+		grammarBuilder.append("KW444 : 'KW' '444';\n");
+		grammarBuilder.append("KW445 : 'KW' '445';\n");
+		grammarBuilder.append("KW446 : 'KW' '446';\n");
+		grammarBuilder.append("KW447 : 'KW' '447';\n");
+		grammarBuilder.append("KW448 : 'KW' '448';\n");
+		grammarBuilder.append("KW449 : 'KW' '449';\n");
+		grammarBuilder.append("KW450 : 'KW' '450';\n");
+		grammarBuilder.append("KW451 : 'KW' '451';\n");
+		grammarBuilder.append("KW452 : 'KW' '452';\n");
+		grammarBuilder.append("KW453 : 'KW' '453';\n");
+		grammarBuilder.append("KW454 : 'KW' '454';\n");
+		grammarBuilder.append("KW455 : 'KW' '455';\n");
+		grammarBuilder.append("KW456 : 'KW' '456';\n");
+		grammarBuilder.append("KW457 : 'KW' '457';\n");
+		grammarBuilder.append("KW458 : 'KW' '458';\n");
+		grammarBuilder.append("KW459 : 'KW' '459';\n");
+		grammarBuilder.append("KW460 : 'KW' '460';\n");
+		grammarBuilder.append("KW461 : 'KW' '461';\n");
+		grammarBuilder.append("KW462 : 'KW' '462';\n");
+		grammarBuilder.append("KW463 : 'KW' '463';\n");
+		grammarBuilder.append("KW464 : 'KW' '464';\n");
+		grammarBuilder.append("KW465 : 'KW' '465';\n");
+		grammarBuilder.append("KW466 : 'KW' '466';\n");
+		grammarBuilder.append("KW467 : 'KW' '467';\n");
+		grammarBuilder.append("KW468 : 'KW' '468';\n");
+		grammarBuilder.append("KW469 : 'KW' '469';\n");
+		grammarBuilder.append("KW470 : 'KW' '470';\n");
+		grammarBuilder.append("KW471 : 'KW' '471';\n");
+		grammarBuilder.append("KW472 : 'KW' '472';\n");
+		grammarBuilder.append("KW473 : 'KW' '473';\n");
+		grammarBuilder.append("KW474 : 'KW' '474';\n");
+		grammarBuilder.append("KW475 : 'KW' '475';\n");
+		grammarBuilder.append("KW476 : 'KW' '476';\n");
+		grammarBuilder.append("KW477 : 'KW' '477';\n");
+		grammarBuilder.append("KW478 : 'KW' '478';\n");
+		grammarBuilder.append("KW479 : 'KW' '479';\n");
+		grammarBuilder.append("KW480 : 'KW' '480';\n");
+		grammarBuilder.append("KW481 : 'KW' '481';\n");
+		grammarBuilder.append("KW482 : 'KW' '482';\n");
+		grammarBuilder.append("KW483 : 'KW' '483';\n");
+		grammarBuilder.append("KW484 : 'KW' '484';\n");
+		grammarBuilder.append("KW485 : 'KW' '485';\n");
+		grammarBuilder.append("KW486 : 'KW' '486';\n");
+		grammarBuilder.append("KW487 : 'KW' '487';\n");
+		grammarBuilder.append("KW488 : 'KW' '488';\n");
+		grammarBuilder.append("KW489 : 'KW' '489';\n");
+		grammarBuilder.append("KW490 : 'KW' '490';\n");
+		grammarBuilder.append("KW491 : 'KW' '491';\n");
+		grammarBuilder.append("KW492 : 'KW' '492';\n");
+		grammarBuilder.append("KW493 : 'KW' '493';\n");
+		grammarBuilder.append("KW494 : 'KW' '494';\n");
+		grammarBuilder.append("KW495 : 'KW' '495';\n");
+		grammarBuilder.append("KW496 : 'KW' '496';\n");
+		grammarBuilder.append("KW497 : 'KW' '497';\n");
+		grammarBuilder.append("KW498 : 'KW' '498';\n");
+		grammarBuilder.append("KW499 : 'KW' '499';\n");
+		grammarBuilder.append("KW500 : 'KW' '500';\n");
+		grammarBuilder.append("KW501 : 'KW' '501';\n");
+		grammarBuilder.append("KW502 : 'KW' '502';\n");
+		grammarBuilder.append("KW503 : 'KW' '503';\n");
+		grammarBuilder.append("KW504 : 'KW' '504';\n");
+		grammarBuilder.append("KW505 : 'KW' '505';\n");
+		grammarBuilder.append("KW506 : 'KW' '506';\n");
+		grammarBuilder.append("KW507 : 'KW' '507';\n");
+		grammarBuilder.append("KW508 : 'KW' '508';\n");
+		grammarBuilder.append("KW509 : 'KW' '509';\n");
+		grammarBuilder.append("KW510 : 'KW' '510';\n");
+		grammarBuilder.append("KW511 : 'KW' '511';\n");
+		grammarBuilder.append("KW512 : 'KW' '512';\n");
+		grammarBuilder.append("KW513 : 'KW' '513';\n");
+		grammarBuilder.append("KW514 : 'KW' '514';\n");
+		grammarBuilder.append("KW515 : 'KW' '515';\n");
+		grammarBuilder.append("KW516 : 'KW' '516';\n");
+		grammarBuilder.append("KW517 : 'KW' '517';\n");
+		grammarBuilder.append("KW518 : 'KW' '518';\n");
+		grammarBuilder.append("KW519 : 'KW' '519';\n");
+		grammarBuilder.append("KW520 : 'KW' '520';\n");
+		grammarBuilder.append("KW521 : 'KW' '521';\n");
+		grammarBuilder.append("KW522 : 'KW' '522';\n");
+		grammarBuilder.append("KW523 : 'KW' '523';\n");
+		grammarBuilder.append("KW524 : 'KW' '524';\n");
+		grammarBuilder.append("KW525 : 'KW' '525';\n");
+		grammarBuilder.append("KW526 : 'KW' '526';\n");
+		grammarBuilder.append("KW527 : 'KW' '527';\n");
+		grammarBuilder.append("KW528 : 'KW' '528';\n");
+		grammarBuilder.append("KW529 : 'KW' '529';\n");
+		grammarBuilder.append("KW530 : 'KW' '530';\n");
+		grammarBuilder.append("KW531 : 'KW' '531';\n");
+		grammarBuilder.append("KW532 : 'KW' '532';\n");
+		grammarBuilder.append("KW533 : 'KW' '533';\n");
+		grammarBuilder.append("KW534 : 'KW' '534';\n");
+		grammarBuilder.append("KW535 : 'KW' '535';\n");
+		grammarBuilder.append("KW536 : 'KW' '536';\n");
+		grammarBuilder.append("KW537 : 'KW' '537';\n");
+		grammarBuilder.append("KW538 : 'KW' '538';\n");
+		grammarBuilder.append("KW539 : 'KW' '539';\n");
+		grammarBuilder.append("KW540 : 'KW' '540';\n");
+		grammarBuilder.append("KW541 : 'KW' '541';\n");
+		grammarBuilder.append("KW542 : 'KW' '542';\n");
+		grammarBuilder.append("KW543 : 'KW' '543';\n");
+		grammarBuilder.append("KW544 : 'KW' '544';\n");
+		grammarBuilder.append("KW545 : 'KW' '545';\n");
+		grammarBuilder.append("KW546 : 'KW' '546';\n");
+		grammarBuilder.append("KW547 : 'KW' '547';\n");
+		grammarBuilder.append("KW548 : 'KW' '548';\n");
+		grammarBuilder.append("KW549 : 'KW' '549';\n");
+		grammarBuilder.append("KW550 : 'KW' '550';\n");
+		grammarBuilder.append("KW551 : 'KW' '551';\n");
+		grammarBuilder.append("KW552 : 'KW' '552';\n");
+		grammarBuilder.append("KW553 : 'KW' '553';\n");
+		grammarBuilder.append("KW554 : 'KW' '554';\n");
+		grammarBuilder.append("KW555 : 'KW' '555';\n");
+		grammarBuilder.append("KW556 : 'KW' '556';\n");
+		grammarBuilder.append("KW557 : 'KW' '557';\n");
+		grammarBuilder.append("KW558 : 'KW' '558';\n");
+		grammarBuilder.append("KW559 : 'KW' '559';\n");
+		grammarBuilder.append("KW560 : 'KW' '560';\n");
+		grammarBuilder.append("KW561 : 'KW' '561';\n");
+		grammarBuilder.append("KW562 : 'KW' '562';\n");
+		grammarBuilder.append("KW563 : 'KW' '563';\n");
+		grammarBuilder.append("KW564 : 'KW' '564';\n");
+		grammarBuilder.append("KW565 : 'KW' '565';\n");
+		grammarBuilder.append("KW566 : 'KW' '566';\n");
+		grammarBuilder.append("KW567 : 'KW' '567';\n");
+		grammarBuilder.append("KW568 : 'KW' '568';\n");
+		grammarBuilder.append("KW569 : 'KW' '569';\n");
+		grammarBuilder.append("KW570 : 'KW' '570';\n");
+		grammarBuilder.append("KW571 : 'KW' '571';\n");
+		grammarBuilder.append("KW572 : 'KW' '572';\n");
+		grammarBuilder.append("KW573 : 'KW' '573';\n");
+		grammarBuilder.append("KW574 : 'KW' '574';\n");
+		grammarBuilder.append("KW575 : 'KW' '575';\n");
+		grammarBuilder.append("KW576 : 'KW' '576';\n");
+		grammarBuilder.append("KW577 : 'KW' '577';\n");
+		grammarBuilder.append("KW578 : 'KW' '578';\n");
+		grammarBuilder.append("KW579 : 'KW' '579';\n");
+		grammarBuilder.append("KW580 : 'KW' '580';\n");
+		grammarBuilder.append("KW581 : 'KW' '581';\n");
+		grammarBuilder.append("KW582 : 'KW' '582';\n");
+		grammarBuilder.append("KW583 : 'KW' '583';\n");
+		grammarBuilder.append("KW584 : 'KW' '584';\n");
+		grammarBuilder.append("KW585 : 'KW' '585';\n");
+		grammarBuilder.append("KW586 : 'KW' '586';\n");
+		grammarBuilder.append("KW587 : 'KW' '587';\n");
+		grammarBuilder.append("KW588 : 'KW' '588';\n");
+		grammarBuilder.append("KW589 : 'KW' '589';\n");
+		grammarBuilder.append("KW590 : 'KW' '590';\n");
+		grammarBuilder.append("KW591 : 'KW' '591';\n");
+		grammarBuilder.append("KW592 : 'KW' '592';\n");
+		grammarBuilder.append("KW593 : 'KW' '593';\n");
+		grammarBuilder.append("KW594 : 'KW' '594';\n");
+		grammarBuilder.append("KW595 : 'KW' '595';\n");
+		grammarBuilder.append("KW596 : 'KW' '596';\n");
+		grammarBuilder.append("KW597 : 'KW' '597';\n");
+		grammarBuilder.append("KW598 : 'KW' '598';\n");
+		grammarBuilder.append("KW599 : 'KW' '599';\n");
+		grammarBuilder.append("KW600 : 'KW' '600';\n");
+		grammarBuilder.append("KW601 : 'KW' '601';\n");
+		grammarBuilder.append("KW602 : 'KW' '602';\n");
+		grammarBuilder.append("KW603 : 'KW' '603';\n");
+		grammarBuilder.append("KW604 : 'KW' '604';\n");
+		grammarBuilder.append("KW605 : 'KW' '605';\n");
+		grammarBuilder.append("KW606 : 'KW' '606';\n");
+		grammarBuilder.append("KW607 : 'KW' '607';\n");
+		grammarBuilder.append("KW608 : 'KW' '608';\n");
+		grammarBuilder.append("KW609 : 'KW' '609';\n");
+		grammarBuilder.append("KW610 : 'KW' '610';\n");
+		grammarBuilder.append("KW611 : 'KW' '611';\n");
+		grammarBuilder.append("KW612 : 'KW' '612';\n");
+		grammarBuilder.append("KW613 : 'KW' '613';\n");
+		grammarBuilder.append("KW614 : 'KW' '614';\n");
+		grammarBuilder.append("KW615 : 'KW' '615';\n");
+		grammarBuilder.append("KW616 : 'KW' '616';\n");
+		grammarBuilder.append("KW617 : 'KW' '617';\n");
+		grammarBuilder.append("KW618 : 'KW' '618';\n");
+		grammarBuilder.append("KW619 : 'KW' '619';\n");
+		grammarBuilder.append("KW620 : 'KW' '620';\n");
+		grammarBuilder.append("KW621 : 'KW' '621';\n");
+		grammarBuilder.append("KW622 : 'KW' '622';\n");
+		grammarBuilder.append("KW623 : 'KW' '623';\n");
+		grammarBuilder.append("KW624 : 'KW' '624';\n");
+		grammarBuilder.append("KW625 : 'KW' '625';\n");
+		grammarBuilder.append("KW626 : 'KW' '626';\n");
+		grammarBuilder.append("KW627 : 'KW' '627';\n");
+		grammarBuilder.append("KW628 : 'KW' '628';\n");
+		grammarBuilder.append("KW629 : 'KW' '629';\n");
+		grammarBuilder.append("KW630 : 'KW' '630';\n");
+		grammarBuilder.append("KW631 : 'KW' '631';\n");
+		grammarBuilder.append("KW632 : 'KW' '632';\n");
+		grammarBuilder.append("KW633 : 'KW' '633';\n");
+		grammarBuilder.append("KW634 : 'KW' '634';\n");
+		grammarBuilder.append("KW635 : 'KW' '635';\n");
+		grammarBuilder.append("KW636 : 'KW' '636';\n");
+		grammarBuilder.append("KW637 : 'KW' '637';\n");
+		grammarBuilder.append("KW638 : 'KW' '638';\n");
+		grammarBuilder.append("KW639 : 'KW' '639';\n");
+		grammarBuilder.append("KW640 : 'KW' '640';\n");
+		grammarBuilder.append("KW641 : 'KW' '641';\n");
+		grammarBuilder.append("KW642 : 'KW' '642';\n");
+		grammarBuilder.append("KW643 : 'KW' '643';\n");
+		grammarBuilder.append("KW644 : 'KW' '644';\n");
+		grammarBuilder.append("KW645 : 'KW' '645';\n");
+		grammarBuilder.append("KW646 : 'KW' '646';\n");
+		grammarBuilder.append("KW647 : 'KW' '647';\n");
+		grammarBuilder.append("KW648 : 'KW' '648';\n");
+		grammarBuilder.append("KW649 : 'KW' '649';\n");
+		grammarBuilder.append("KW650 : 'KW' '650';\n");
+		grammarBuilder.append("KW651 : 'KW' '651';\n");
+		grammarBuilder.append("KW652 : 'KW' '652';\n");
+		grammarBuilder.append("KW653 : 'KW' '653';\n");
+		grammarBuilder.append("KW654 : 'KW' '654';\n");
+		grammarBuilder.append("KW655 : 'KW' '655';\n");
+		grammarBuilder.append("KW656 : 'KW' '656';\n");
+		grammarBuilder.append("KW657 : 'KW' '657';\n");
+		grammarBuilder.append("KW658 : 'KW' '658';\n");
+		grammarBuilder.append("KW659 : 'KW' '659';\n");
+		grammarBuilder.append("KW660 : 'KW' '660';\n");
+		grammarBuilder.append("KW661 : 'KW' '661';\n");
+		grammarBuilder.append("KW662 : 'KW' '662';\n");
+		grammarBuilder.append("KW663 : 'KW' '663';\n");
+		grammarBuilder.append("KW664 : 'KW' '664';\n");
+		grammarBuilder.append("KW665 : 'KW' '665';\n");
+		grammarBuilder.append("KW666 : 'KW' '666';\n");
+		grammarBuilder.append("KW667 : 'KW' '667';\n");
+		grammarBuilder.append("KW668 : 'KW' '668';\n");
+		grammarBuilder.append("KW669 : 'KW' '669';\n");
+		grammarBuilder.append("KW670 : 'KW' '670';\n");
+		grammarBuilder.append("KW671 : 'KW' '671';\n");
+		grammarBuilder.append("KW672 : 'KW' '672';\n");
+		grammarBuilder.append("KW673 : 'KW' '673';\n");
+		grammarBuilder.append("KW674 : 'KW' '674';\n");
+		grammarBuilder.append("KW675 : 'KW' '675';\n");
+		grammarBuilder.append("KW676 : 'KW' '676';\n");
+		grammarBuilder.append("KW677 : 'KW' '677';\n");
+		grammarBuilder.append("KW678 : 'KW' '678';\n");
+		grammarBuilder.append("KW679 : 'KW' '679';\n");
+		grammarBuilder.append("KW680 : 'KW' '680';\n");
+		grammarBuilder.append("KW681 : 'KW' '681';\n");
+		grammarBuilder.append("KW682 : 'KW' '682';\n");
+		grammarBuilder.append("KW683 : 'KW' '683';\n");
+		grammarBuilder.append("KW684 : 'KW' '684';\n");
+		grammarBuilder.append("KW685 : 'KW' '685';\n");
+		grammarBuilder.append("KW686 : 'KW' '686';\n");
+		grammarBuilder.append("KW687 : 'KW' '687';\n");
+		grammarBuilder.append("KW688 : 'KW' '688';\n");
+		grammarBuilder.append("KW689 : 'KW' '689';\n");
+		grammarBuilder.append("KW690 : 'KW' '690';\n");
+		grammarBuilder.append("KW691 : 'KW' '691';\n");
+		grammarBuilder.append("KW692 : 'KW' '692';\n");
+		grammarBuilder.append("KW693 : 'KW' '693';\n");
+		grammarBuilder.append("KW694 : 'KW' '694';\n");
+		grammarBuilder.append("KW695 : 'KW' '695';\n");
+		grammarBuilder.append("KW696 : 'KW' '696';\n");
+		grammarBuilder.append("KW697 : 'KW' '697';\n");
+		grammarBuilder.append("KW698 : 'KW' '698';\n");
+		grammarBuilder.append("KW699 : 'KW' '699';\n");
+		grammarBuilder.append("KW700 : 'KW' '700';\n");
+		grammarBuilder.append("KW701 : 'KW' '701';\n");
+		grammarBuilder.append("KW702 : 'KW' '702';\n");
+		grammarBuilder.append("KW703 : 'KW' '703';\n");
+		grammarBuilder.append("KW704 : 'KW' '704';\n");
+		grammarBuilder.append("KW705 : 'KW' '705';\n");
+		grammarBuilder.append("KW706 : 'KW' '706';\n");
+		grammarBuilder.append("KW707 : 'KW' '707';\n");
+		grammarBuilder.append("KW708 : 'KW' '708';\n");
+		grammarBuilder.append("KW709 : 'KW' '709';\n");
+		grammarBuilder.append("KW710 : 'KW' '710';\n");
+		grammarBuilder.append("KW711 : 'KW' '711';\n");
+		grammarBuilder.append("KW712 : 'KW' '712';\n");
+		grammarBuilder.append("KW713 : 'KW' '713';\n");
+		grammarBuilder.append("KW714 : 'KW' '714';\n");
+		grammarBuilder.append("KW715 : 'KW' '715';\n");
+		grammarBuilder.append("KW716 : 'KW' '716';\n");
+		grammarBuilder.append("KW717 : 'KW' '717';\n");
+		grammarBuilder.append("KW718 : 'KW' '718';\n");
+		grammarBuilder.append("KW719 : 'KW' '719';\n");
+		grammarBuilder.append("KW720 : 'KW' '720';\n");
+		grammarBuilder.append("KW721 : 'KW' '721';\n");
+		grammarBuilder.append("KW722 : 'KW' '722';\n");
+		grammarBuilder.append("KW723 : 'KW' '723';\n");
+		grammarBuilder.append("KW724 : 'KW' '724';\n");
+		grammarBuilder.append("KW725 : 'KW' '725';\n");
+		grammarBuilder.append("KW726 : 'KW' '726';\n");
+		grammarBuilder.append("KW727 : 'KW' '727';\n");
+		grammarBuilder.append("KW728 : 'KW' '728';\n");
+		grammarBuilder.append("KW729 : 'KW' '729';\n");
+		grammarBuilder.append("KW730 : 'KW' '730';\n");
+		grammarBuilder.append("KW731 : 'KW' '731';\n");
+		grammarBuilder.append("KW732 : 'KW' '732';\n");
+		grammarBuilder.append("KW733 : 'KW' '733';\n");
+		grammarBuilder.append("KW734 : 'KW' '734';\n");
+		grammarBuilder.append("KW735 : 'KW' '735';\n");
+		grammarBuilder.append("KW736 : 'KW' '736';\n");
+		grammarBuilder.append("KW737 : 'KW' '737';\n");
+		grammarBuilder.append("KW738 : 'KW' '738';\n");
+		grammarBuilder.append("KW739 : 'KW' '739';\n");
+		grammarBuilder.append("KW740 : 'KW' '740';\n");
+		grammarBuilder.append("KW741 : 'KW' '741';\n");
+		grammarBuilder.append("KW742 : 'KW' '742';\n");
+		grammarBuilder.append("KW743 : 'KW' '743';\n");
+		grammarBuilder.append("KW744 : 'KW' '744';\n");
+		grammarBuilder.append("KW745 : 'KW' '745';\n");
+		grammarBuilder.append("KW746 : 'KW' '746';\n");
+		grammarBuilder.append("KW747 : 'KW' '747';\n");
+		grammarBuilder.append("KW748 : 'KW' '748';\n");
+		grammarBuilder.append("KW749 : 'KW' '749';\n");
+		grammarBuilder.append("KW750 : 'KW' '750';\n");
+		grammarBuilder.append("KW751 : 'KW' '751';\n");
+		grammarBuilder.append("KW752 : 'KW' '752';\n");
+		grammarBuilder.append("KW753 : 'KW' '753';\n");
+		grammarBuilder.append("KW754 : 'KW' '754';\n");
+		grammarBuilder.append("KW755 : 'KW' '755';\n");
+		grammarBuilder.append("KW756 : 'KW' '756';\n");
+		grammarBuilder.append("KW757 : 'KW' '757';\n");
+		grammarBuilder.append("KW758 : 'KW' '758';\n");
+		grammarBuilder.append("KW759 : 'KW' '759';\n");
+		grammarBuilder.append("KW760 : 'KW' '760';\n");
+		grammarBuilder.append("KW761 : 'KW' '761';\n");
+		grammarBuilder.append("KW762 : 'KW' '762';\n");
+		grammarBuilder.append("KW763 : 'KW' '763';\n");
+		grammarBuilder.append("KW764 : 'KW' '764';\n");
+		grammarBuilder.append("KW765 : 'KW' '765';\n");
+		grammarBuilder.append("KW766 : 'KW' '766';\n");
+		grammarBuilder.append("KW767 : 'KW' '767';\n");
+		grammarBuilder.append("KW768 : 'KW' '768';\n");
+		grammarBuilder.append("KW769 : 'KW' '769';\n");
+		grammarBuilder.append("KW770 : 'KW' '770';\n");
+		grammarBuilder.append("KW771 : 'KW' '771';\n");
+		grammarBuilder.append("KW772 : 'KW' '772';\n");
+		grammarBuilder.append("KW773 : 'KW' '773';\n");
+		grammarBuilder.append("KW774 : 'KW' '774';\n");
+		grammarBuilder.append("KW775 : 'KW' '775';\n");
+		grammarBuilder.append("KW776 : 'KW' '776';\n");
+		grammarBuilder.append("KW777 : 'KW' '777';\n");
+		grammarBuilder.append("KW778 : 'KW' '778';\n");
+		grammarBuilder.append("KW779 : 'KW' '779';\n");
+		grammarBuilder.append("KW780 : 'KW' '780';\n");
+		grammarBuilder.append("KW781 : 'KW' '781';\n");
+		grammarBuilder.append("KW782 : 'KW' '782';\n");
+		grammarBuilder.append("KW783 : 'KW' '783';\n");
+		grammarBuilder.append("KW784 : 'KW' '784';\n");
+		grammarBuilder.append("KW785 : 'KW' '785';\n");
+		grammarBuilder.append("KW786 : 'KW' '786';\n");
+		grammarBuilder.append("KW787 : 'KW' '787';\n");
+		grammarBuilder.append("KW788 : 'KW' '788';\n");
+		grammarBuilder.append("KW789 : 'KW' '789';\n");
+		grammarBuilder.append("KW790 : 'KW' '790';\n");
+		grammarBuilder.append("KW791 : 'KW' '791';\n");
+		grammarBuilder.append("KW792 : 'KW' '792';\n");
+		grammarBuilder.append("KW793 : 'KW' '793';\n");
+		grammarBuilder.append("KW794 : 'KW' '794';\n");
+		grammarBuilder.append("KW795 : 'KW' '795';\n");
+		grammarBuilder.append("KW796 : 'KW' '796';\n");
+		grammarBuilder.append("KW797 : 'KW' '797';\n");
+		grammarBuilder.append("KW798 : 'KW' '798';\n");
+		grammarBuilder.append("KW799 : 'KW' '799';\n");
+		grammarBuilder.append("KW800 : 'KW' '800';\n");
+		grammarBuilder.append("KW801 : 'KW' '801';\n");
+		grammarBuilder.append("KW802 : 'KW' '802';\n");
+		grammarBuilder.append("KW803 : 'KW' '803';\n");
+		grammarBuilder.append("KW804 : 'KW' '804';\n");
+		grammarBuilder.append("KW805 : 'KW' '805';\n");
+		grammarBuilder.append("KW806 : 'KW' '806';\n");
+		grammarBuilder.append("KW807 : 'KW' '807';\n");
+		grammarBuilder.append("KW808 : 'KW' '808';\n");
+		grammarBuilder.append("KW809 : 'KW' '809';\n");
+		grammarBuilder.append("KW810 : 'KW' '810';\n");
+		grammarBuilder.append("KW811 : 'KW' '811';\n");
+		grammarBuilder.append("KW812 : 'KW' '812';\n");
+		grammarBuilder.append("KW813 : 'KW' '813';\n");
+		grammarBuilder.append("KW814 : 'KW' '814';\n");
+		grammarBuilder.append("KW815 : 'KW' '815';\n");
+		grammarBuilder.append("KW816 : 'KW' '816';\n");
+		grammarBuilder.append("KW817 : 'KW' '817';\n");
+		grammarBuilder.append("KW818 : 'KW' '818';\n");
+		grammarBuilder.append("KW819 : 'KW' '819';\n");
+		grammarBuilder.append("KW820 : 'KW' '820';\n");
+		grammarBuilder.append("KW821 : 'KW' '821';\n");
+		grammarBuilder.append("KW822 : 'KW' '822';\n");
+		grammarBuilder.append("KW823 : 'KW' '823';\n");
+		grammarBuilder.append("KW824 : 'KW' '824';\n");
+		grammarBuilder.append("KW825 : 'KW' '825';\n");
+		grammarBuilder.append("KW826 : 'KW' '826';\n");
+		grammarBuilder.append("KW827 : 'KW' '827';\n");
+		grammarBuilder.append("KW828 : 'KW' '828';\n");
+		grammarBuilder.append("KW829 : 'KW' '829';\n");
+		grammarBuilder.append("KW830 : 'KW' '830';\n");
+		grammarBuilder.append("KW831 : 'KW' '831';\n");
+		grammarBuilder.append("KW832 : 'KW' '832';\n");
+		grammarBuilder.append("KW833 : 'KW' '833';\n");
+		grammarBuilder.append("KW834 : 'KW' '834';\n");
+		grammarBuilder.append("KW835 : 'KW' '835';\n");
+		grammarBuilder.append("KW836 : 'KW' '836';\n");
+		grammarBuilder.append("KW837 : 'KW' '837';\n");
+		grammarBuilder.append("KW838 : 'KW' '838';\n");
+		grammarBuilder.append("KW839 : 'KW' '839';\n");
+		grammarBuilder.append("KW840 : 'KW' '840';\n");
+		grammarBuilder.append("KW841 : 'KW' '841';\n");
+		grammarBuilder.append("KW842 : 'KW' '842';\n");
+		grammarBuilder.append("KW843 : 'KW' '843';\n");
+		grammarBuilder.append("KW844 : 'KW' '844';\n");
+		grammarBuilder.append("KW845 : 'KW' '845';\n");
+		grammarBuilder.append("KW846 : 'KW' '846';\n");
+		grammarBuilder.append("KW847 : 'KW' '847';\n");
+		grammarBuilder.append("KW848 : 'KW' '848';\n");
+		grammarBuilder.append("KW849 : 'KW' '849';\n");
+		grammarBuilder.append("KW850 : 'KW' '850';\n");
+		grammarBuilder.append("KW851 : 'KW' '851';\n");
+		grammarBuilder.append("KW852 : 'KW' '852';\n");
+		grammarBuilder.append("KW853 : 'KW' '853';\n");
+		grammarBuilder.append("KW854 : 'KW' '854';\n");
+		grammarBuilder.append("KW855 : 'KW' '855';\n");
+		grammarBuilder.append("KW856 : 'KW' '856';\n");
+		grammarBuilder.append("KW857 : 'KW' '857';\n");
+		grammarBuilder.append("KW858 : 'KW' '858';\n");
+		grammarBuilder.append("KW859 : 'KW' '859';\n");
+		grammarBuilder.append("KW860 : 'KW' '860';\n");
+		grammarBuilder.append("KW861 : 'KW' '861';\n");
+		grammarBuilder.append("KW862 : 'KW' '862';\n");
+		grammarBuilder.append("KW863 : 'KW' '863';\n");
+		grammarBuilder.append("KW864 : 'KW' '864';\n");
+		grammarBuilder.append("KW865 : 'KW' '865';\n");
+		grammarBuilder.append("KW866 : 'KW' '866';\n");
+		grammarBuilder.append("KW867 : 'KW' '867';\n");
+		grammarBuilder.append("KW868 : 'KW' '868';\n");
+		grammarBuilder.append("KW869 : 'KW' '869';\n");
+		grammarBuilder.append("KW870 : 'KW' '870';\n");
+		grammarBuilder.append("KW871 : 'KW' '871';\n");
+		grammarBuilder.append("KW872 : 'KW' '872';\n");
+		grammarBuilder.append("KW873 : 'KW' '873';\n");
+		grammarBuilder.append("KW874 : 'KW' '874';\n");
+		grammarBuilder.append("KW875 : 'KW' '875';\n");
+		grammarBuilder.append("KW876 : 'KW' '876';\n");
+		grammarBuilder.append("KW877 : 'KW' '877';\n");
+		grammarBuilder.append("KW878 : 'KW' '878';\n");
+		grammarBuilder.append("KW879 : 'KW' '879';\n");
+		grammarBuilder.append("KW880 : 'KW' '880';\n");
+		grammarBuilder.append("KW881 : 'KW' '881';\n");
+		grammarBuilder.append("KW882 : 'KW' '882';\n");
+		grammarBuilder.append("KW883 : 'KW' '883';\n");
+		grammarBuilder.append("KW884 : 'KW' '884';\n");
+		grammarBuilder.append("KW885 : 'KW' '885';\n");
+		grammarBuilder.append("KW886 : 'KW' '886';\n");
+		grammarBuilder.append("KW887 : 'KW' '887';\n");
+		grammarBuilder.append("KW888 : 'KW' '888';\n");
+		grammarBuilder.append("KW889 : 'KW' '889';\n");
+		grammarBuilder.append("KW890 : 'KW' '890';\n");
+		grammarBuilder.append("KW891 : 'KW' '891';\n");
+		grammarBuilder.append("KW892 : 'KW' '892';\n");
+		grammarBuilder.append("KW893 : 'KW' '893';\n");
+		grammarBuilder.append("KW894 : 'KW' '894';\n");
+		grammarBuilder.append("KW895 : 'KW' '895';\n");
+		grammarBuilder.append("KW896 : 'KW' '896';\n");
+		grammarBuilder.append("KW897 : 'KW' '897';\n");
+		grammarBuilder.append("KW898 : 'KW' '898';\n");
+		grammarBuilder.append("KW899 : 'KW' '899';\n");
+		grammarBuilder.append("KW900 : 'KW' '900';\n");
+		grammarBuilder.append("KW901 : 'KW' '901';\n");
+		grammarBuilder.append("KW902 : 'KW' '902';\n");
+		grammarBuilder.append("KW903 : 'KW' '903';\n");
+		grammarBuilder.append("KW904 : 'KW' '904';\n");
+		grammarBuilder.append("KW905 : 'KW' '905';\n");
+		grammarBuilder.append("KW906 : 'KW' '906';\n");
+		grammarBuilder.append("KW907 : 'KW' '907';\n");
+		grammarBuilder.append("KW908 : 'KW' '908';\n");
+		grammarBuilder.append("KW909 : 'KW' '909';\n");
+		grammarBuilder.append("KW910 : 'KW' '910';\n");
+		grammarBuilder.append("KW911 : 'KW' '911';\n");
+		grammarBuilder.append("KW912 : 'KW' '912';\n");
+		grammarBuilder.append("KW913 : 'KW' '913';\n");
+		grammarBuilder.append("KW914 : 'KW' '914';\n");
+		grammarBuilder.append("KW915 : 'KW' '915';\n");
+		grammarBuilder.append("KW916 : 'KW' '916';\n");
+		grammarBuilder.append("KW917 : 'KW' '917';\n");
+		grammarBuilder.append("KW918 : 'KW' '918';\n");
+		grammarBuilder.append("KW919 : 'KW' '919';\n");
+		grammarBuilder.append("KW920 : 'KW' '920';\n");
+		grammarBuilder.append("KW921 : 'KW' '921';\n");
+		grammarBuilder.append("KW922 : 'KW' '922';\n");
+		grammarBuilder.append("KW923 : 'KW' '923';\n");
+		grammarBuilder.append("KW924 : 'KW' '924';\n");
+		grammarBuilder.append("KW925 : 'KW' '925';\n");
+		grammarBuilder.append("KW926 : 'KW' '926';\n");
+		grammarBuilder.append("KW927 : 'KW' '927';\n");
+		grammarBuilder.append("KW928 : 'KW' '928';\n");
+		grammarBuilder.append("KW929 : 'KW' '929';\n");
+		grammarBuilder.append("KW930 : 'KW' '930';\n");
+		grammarBuilder.append("KW931 : 'KW' '931';\n");
+		grammarBuilder.append("KW932 : 'KW' '932';\n");
+		grammarBuilder.append("KW933 : 'KW' '933';\n");
+		grammarBuilder.append("KW934 : 'KW' '934';\n");
+		grammarBuilder.append("KW935 : 'KW' '935';\n");
+		grammarBuilder.append("KW936 : 'KW' '936';\n");
+		grammarBuilder.append("KW937 : 'KW' '937';\n");
+		grammarBuilder.append("KW938 : 'KW' '938';\n");
+		grammarBuilder.append("KW939 : 'KW' '939';\n");
+		grammarBuilder.append("KW940 : 'KW' '940';\n");
+		grammarBuilder.append("KW941 : 'KW' '941';\n");
+		grammarBuilder.append("KW942 : 'KW' '942';\n");
+		grammarBuilder.append("KW943 : 'KW' '943';\n");
+		grammarBuilder.append("KW944 : 'KW' '944';\n");
+		grammarBuilder.append("KW945 : 'KW' '945';\n");
+		grammarBuilder.append("KW946 : 'KW' '946';\n");
+		grammarBuilder.append("KW947 : 'KW' '947';\n");
+		grammarBuilder.append("KW948 : 'KW' '948';\n");
+		grammarBuilder.append("KW949 : 'KW' '949';\n");
+		grammarBuilder.append("KW950 : 'KW' '950';\n");
+		grammarBuilder.append("KW951 : 'KW' '951';\n");
+		grammarBuilder.append("KW952 : 'KW' '952';\n");
+		grammarBuilder.append("KW953 : 'KW' '953';\n");
+		grammarBuilder.append("KW954 : 'KW' '954';\n");
+		grammarBuilder.append("KW955 : 'KW' '955';\n");
+		grammarBuilder.append("KW956 : 'KW' '956';\n");
+		grammarBuilder.append("KW957 : 'KW' '957';\n");
+		grammarBuilder.append("KW958 : 'KW' '958';\n");
+		grammarBuilder.append("KW959 : 'KW' '959';\n");
+		grammarBuilder.append("KW960 : 'KW' '960';\n");
+		grammarBuilder.append("KW961 : 'KW' '961';\n");
+		grammarBuilder.append("KW962 : 'KW' '962';\n");
+		grammarBuilder.append("KW963 : 'KW' '963';\n");
+		grammarBuilder.append("KW964 : 'KW' '964';\n");
+		grammarBuilder.append("KW965 : 'KW' '965';\n");
+		grammarBuilder.append("KW966 : 'KW' '966';\n");
+		grammarBuilder.append("KW967 : 'KW' '967';\n");
+		grammarBuilder.append("KW968 : 'KW' '968';\n");
+		grammarBuilder.append("KW969 : 'KW' '969';\n");
+		grammarBuilder.append("KW970 : 'KW' '970';\n");
+		grammarBuilder.append("KW971 : 'KW' '971';\n");
+		grammarBuilder.append("KW972 : 'KW' '972';\n");
+		grammarBuilder.append("KW973 : 'KW' '973';\n");
+		grammarBuilder.append("KW974 : 'KW' '974';\n");
+		grammarBuilder.append("KW975 : 'KW' '975';\n");
+		grammarBuilder.append("KW976 : 'KW' '976';\n");
+		grammarBuilder.append("KW977 : 'KW' '977';\n");
+		grammarBuilder.append("KW978 : 'KW' '978';\n");
+		grammarBuilder.append("KW979 : 'KW' '979';\n");
+		grammarBuilder.append("KW980 : 'KW' '980';\n");
+		grammarBuilder.append("KW981 : 'KW' '981';\n");
+		grammarBuilder.append("KW982 : 'KW' '982';\n");
+		grammarBuilder.append("KW983 : 'KW' '983';\n");
+		grammarBuilder.append("KW984 : 'KW' '984';\n");
+		grammarBuilder.append("KW985 : 'KW' '985';\n");
+		grammarBuilder.append("KW986 : 'KW' '986';\n");
+		grammarBuilder.append("KW987 : 'KW' '987';\n");
+		grammarBuilder.append("KW988 : 'KW' '988';\n");
+		grammarBuilder.append("KW989 : 'KW' '989';\n");
+		grammarBuilder.append("KW990 : 'KW' '990';\n");
+		grammarBuilder.append("KW991 : 'KW' '991';\n");
+		grammarBuilder.append("KW992 : 'KW' '992';\n");
+		grammarBuilder.append("KW993 : 'KW' '993';\n");
+		grammarBuilder.append("KW994 : 'KW' '994';\n");
+		grammarBuilder.append("KW995 : 'KW' '995';\n");
+		grammarBuilder.append("KW996 : 'KW' '996';\n");
+		grammarBuilder.append("KW997 : 'KW' '997';\n");
+		grammarBuilder.append("KW998 : 'KW' '998';\n");
+		grammarBuilder.append("KW999 : 'KW' '999';\n");
+		grammarBuilder.append("KW1000 : 'KW' '1000';\n");
+		grammarBuilder.append("KW1001 : 'KW' '1001';\n");
+		grammarBuilder.append("KW1002 : 'KW' '1002';\n");
+		grammarBuilder.append("KW1003 : 'KW' '1003';\n");
+		grammarBuilder.append("KW1004 : 'KW' '1004';\n");
+		grammarBuilder.append("KW1005 : 'KW' '1005';\n");
+		grammarBuilder.append("KW1006 : 'KW' '1006';\n");
+		grammarBuilder.append("KW1007 : 'KW' '1007';\n");
+		grammarBuilder.append("KW1008 : 'KW' '1008';\n");
+		grammarBuilder.append("KW1009 : 'KW' '1009';\n");
+		grammarBuilder.append("KW1010 : 'KW' '1010';\n");
+		grammarBuilder.append("KW1011 : 'KW' '1011';\n");
+		grammarBuilder.append("KW1012 : 'KW' '1012';\n");
+		grammarBuilder.append("KW1013 : 'KW' '1013';\n");
+		grammarBuilder.append("KW1014 : 'KW' '1014';\n");
+		grammarBuilder.append("KW1015 : 'KW' '1015';\n");
+		grammarBuilder.append("KW1016 : 'KW' '1016';\n");
+		grammarBuilder.append("KW1017 : 'KW' '1017';\n");
+		grammarBuilder.append("KW1018 : 'KW' '1018';\n");
+		grammarBuilder.append("KW1019 : 'KW' '1019';\n");
+		grammarBuilder.append("KW1020 : 'KW' '1020';\n");
+		grammarBuilder.append("KW1021 : 'KW' '1021';\n");
+		grammarBuilder.append("KW1022 : 'KW' '1022';\n");
+		grammarBuilder.append("KW1023 : 'KW' '1023';\n");
+		grammarBuilder.append("KW1024 : 'KW' '1024';\n");
+		grammarBuilder.append("KW1025 : 'KW' '1025';\n");
+		grammarBuilder.append("KW1026 : 'KW' '1026';\n");
+		grammarBuilder.append("KW1027 : 'KW' '1027';\n");
+		grammarBuilder.append("KW1028 : 'KW' '1028';\n");
+		grammarBuilder.append("KW1029 : 'KW' '1029';\n");
+		grammarBuilder.append("KW1030 : 'KW' '1030';\n");
+		grammarBuilder.append("KW1031 : 'KW' '1031';\n");
+		grammarBuilder.append("KW1032 : 'KW' '1032';\n");
+		grammarBuilder.append("KW1033 : 'KW' '1033';\n");
+		grammarBuilder.append("KW1034 : 'KW' '1034';\n");
+		grammarBuilder.append("KW1035 : 'KW' '1035';\n");
+		grammarBuilder.append("KW1036 : 'KW' '1036';\n");
+		grammarBuilder.append("KW1037 : 'KW' '1037';\n");
+		grammarBuilder.append("KW1038 : 'KW' '1038';\n");
+		grammarBuilder.append("KW1039 : 'KW' '1039';\n");
+		grammarBuilder.append("KW1040 : 'KW' '1040';\n");
+		grammarBuilder.append("KW1041 : 'KW' '1041';\n");
+		grammarBuilder.append("KW1042 : 'KW' '1042';\n");
+		grammarBuilder.append("KW1043 : 'KW' '1043';\n");
+		grammarBuilder.append("KW1044 : 'KW' '1044';\n");
+		grammarBuilder.append("KW1045 : 'KW' '1045';\n");
+		grammarBuilder.append("KW1046 : 'KW' '1046';\n");
+		grammarBuilder.append("KW1047 : 'KW' '1047';\n");
+		grammarBuilder.append("KW1048 : 'KW' '1048';\n");
+		grammarBuilder.append("KW1049 : 'KW' '1049';\n");
+		grammarBuilder.append("KW1050 : 'KW' '1050';\n");
+		grammarBuilder.append("KW1051 : 'KW' '1051';\n");
+		grammarBuilder.append("KW1052 : 'KW' '1052';\n");
+		grammarBuilder.append("KW1053 : 'KW' '1053';\n");
+		grammarBuilder.append("KW1054 : 'KW' '1054';\n");
+		grammarBuilder.append("KW1055 : 'KW' '1055';\n");
+		grammarBuilder.append("KW1056 : 'KW' '1056';\n");
+		grammarBuilder.append("KW1057 : 'KW' '1057';\n");
+		grammarBuilder.append("KW1058 : 'KW' '1058';\n");
+		grammarBuilder.append("KW1059 : 'KW' '1059';\n");
+		grammarBuilder.append("KW1060 : 'KW' '1060';\n");
+		grammarBuilder.append("KW1061 : 'KW' '1061';\n");
+		grammarBuilder.append("KW1062 : 'KW' '1062';\n");
+		grammarBuilder.append("KW1063 : 'KW' '1063';\n");
+		grammarBuilder.append("KW1064 : 'KW' '1064';\n");
+		grammarBuilder.append("KW1065 : 'KW' '1065';\n");
+		grammarBuilder.append("KW1066 : 'KW' '1066';\n");
+		grammarBuilder.append("KW1067 : 'KW' '1067';\n");
+		grammarBuilder.append("KW1068 : 'KW' '1068';\n");
+		grammarBuilder.append("KW1069 : 'KW' '1069';\n");
+		grammarBuilder.append("KW1070 : 'KW' '1070';\n");
+		grammarBuilder.append("KW1071 : 'KW' '1071';\n");
+		grammarBuilder.append("KW1072 : 'KW' '1072';\n");
+		grammarBuilder.append("KW1073 : 'KW' '1073';\n");
+		grammarBuilder.append("KW1074 : 'KW' '1074';\n");
+		grammarBuilder.append("KW1075 : 'KW' '1075';\n");
+		grammarBuilder.append("KW1076 : 'KW' '1076';\n");
+		grammarBuilder.append("KW1077 : 'KW' '1077';\n");
+		grammarBuilder.append("KW1078 : 'KW' '1078';\n");
+		grammarBuilder.append("KW1079 : 'KW' '1079';\n");
+		grammarBuilder.append("KW1080 : 'KW' '1080';\n");
+		grammarBuilder.append("KW1081 : 'KW' '1081';\n");
+		grammarBuilder.append("KW1082 : 'KW' '1082';\n");
+		grammarBuilder.append("KW1083 : 'KW' '1083';\n");
+		grammarBuilder.append("KW1084 : 'KW' '1084';\n");
+		grammarBuilder.append("KW1085 : 'KW' '1085';\n");
+		grammarBuilder.append("KW1086 : 'KW' '1086';\n");
+		grammarBuilder.append("KW1087 : 'KW' '1087';\n");
+		grammarBuilder.append("KW1088 : 'KW' '1088';\n");
+		grammarBuilder.append("KW1089 : 'KW' '1089';\n");
+		grammarBuilder.append("KW1090 : 'KW' '1090';\n");
+		grammarBuilder.append("KW1091 : 'KW' '1091';\n");
+		grammarBuilder.append("KW1092 : 'KW' '1092';\n");
+		grammarBuilder.append("KW1093 : 'KW' '1093';\n");
+		grammarBuilder.append("KW1094 : 'KW' '1094';\n");
+		grammarBuilder.append("KW1095 : 'KW' '1095';\n");
+		grammarBuilder.append("KW1096 : 'KW' '1096';\n");
+		grammarBuilder.append("KW1097 : 'KW' '1097';\n");
+		grammarBuilder.append("KW1098 : 'KW' '1098';\n");
+		grammarBuilder.append("KW1099 : 'KW' '1099';\n");
+		grammarBuilder.append("KW1100 : 'KW' '1100';\n");
+		grammarBuilder.append("KW1101 : 'KW' '1101';\n");
+		grammarBuilder.append("KW1102 : 'KW' '1102';\n");
+		grammarBuilder.append("KW1103 : 'KW' '1103';\n");
+		grammarBuilder.append("KW1104 : 'KW' '1104';\n");
+		grammarBuilder.append("KW1105 : 'KW' '1105';\n");
+		grammarBuilder.append("KW1106 : 'KW' '1106';\n");
+		grammarBuilder.append("KW1107 : 'KW' '1107';\n");
+		grammarBuilder.append("KW1108 : 'KW' '1108';\n");
+		grammarBuilder.append("KW1109 : 'KW' '1109';\n");
+		grammarBuilder.append("KW1110 : 'KW' '1110';\n");
+		grammarBuilder.append("KW1111 : 'KW' '1111';\n");
+		grammarBuilder.append("KW1112 : 'KW' '1112';\n");
+		grammarBuilder.append("KW1113 : 'KW' '1113';\n");
+		grammarBuilder.append("KW1114 : 'KW' '1114';\n");
+		grammarBuilder.append("KW1115 : 'KW' '1115';\n");
+		grammarBuilder.append("KW1116 : 'KW' '1116';\n");
+		grammarBuilder.append("KW1117 : 'KW' '1117';\n");
+		grammarBuilder.append("KW1118 : 'KW' '1118';\n");
+		grammarBuilder.append("KW1119 : 'KW' '1119';\n");
+		grammarBuilder.append("KW1120 : 'KW' '1120';\n");
+		grammarBuilder.append("KW1121 : 'KW' '1121';\n");
+		grammarBuilder.append("KW1122 : 'KW' '1122';\n");
+		grammarBuilder.append("KW1123 : 'KW' '1123';\n");
+		grammarBuilder.append("KW1124 : 'KW' '1124';\n");
+		grammarBuilder.append("KW1125 : 'KW' '1125';\n");
+		grammarBuilder.append("KW1126 : 'KW' '1126';\n");
+		grammarBuilder.append("KW1127 : 'KW' '1127';\n");
+		grammarBuilder.append("KW1128 : 'KW' '1128';\n");
+		grammarBuilder.append("KW1129 : 'KW' '1129';\n");
+		grammarBuilder.append("KW1130 : 'KW' '1130';\n");
+		grammarBuilder.append("KW1131 : 'KW' '1131';\n");
+		grammarBuilder.append("KW1132 : 'KW' '1132';\n");
+		grammarBuilder.append("KW1133 : 'KW' '1133';\n");
+		grammarBuilder.append("KW1134 : 'KW' '1134';\n");
+		grammarBuilder.append("KW1135 : 'KW' '1135';\n");
+		grammarBuilder.append("KW1136 : 'KW' '1136';\n");
+		grammarBuilder.append("KW1137 : 'KW' '1137';\n");
+		grammarBuilder.append("KW1138 : 'KW' '1138';\n");
+		grammarBuilder.append("KW1139 : 'KW' '1139';\n");
+		grammarBuilder.append("KW1140 : 'KW' '1140';\n");
+		grammarBuilder.append("KW1141 : 'KW' '1141';\n");
+		grammarBuilder.append("KW1142 : 'KW' '1142';\n");
+		grammarBuilder.append("KW1143 : 'KW' '1143';\n");
+		grammarBuilder.append("KW1144 : 'KW' '1144';\n");
+		grammarBuilder.append("KW1145 : 'KW' '1145';\n");
+		grammarBuilder.append("KW1146 : 'KW' '1146';\n");
+		grammarBuilder.append("KW1147 : 'KW' '1147';\n");
+		grammarBuilder.append("KW1148 : 'KW' '1148';\n");
+		grammarBuilder.append("KW1149 : 'KW' '1149';\n");
+		grammarBuilder.append("KW1150 : 'KW' '1150';\n");
+		grammarBuilder.append("KW1151 : 'KW' '1151';\n");
+		grammarBuilder.append("KW1152 : 'KW' '1152';\n");
+		grammarBuilder.append("KW1153 : 'KW' '1153';\n");
+		grammarBuilder.append("KW1154 : 'KW' '1154';\n");
+		grammarBuilder.append("KW1155 : 'KW' '1155';\n");
+		grammarBuilder.append("KW1156 : 'KW' '1156';\n");
+		grammarBuilder.append("KW1157 : 'KW' '1157';\n");
+		grammarBuilder.append("KW1158 : 'KW' '1158';\n");
+		grammarBuilder.append("KW1159 : 'KW' '1159';\n");
+		grammarBuilder.append("KW1160 : 'KW' '1160';\n");
+		grammarBuilder.append("KW1161 : 'KW' '1161';\n");
+		grammarBuilder.append("KW1162 : 'KW' '1162';\n");
+		grammarBuilder.append("KW1163 : 'KW' '1163';\n");
+		grammarBuilder.append("KW1164 : 'KW' '1164';\n");
+		grammarBuilder.append("KW1165 : 'KW' '1165';\n");
+		grammarBuilder.append("KW1166 : 'KW' '1166';\n");
+		grammarBuilder.append("KW1167 : 'KW' '1167';\n");
+		grammarBuilder.append("KW1168 : 'KW' '1168';\n");
+		grammarBuilder.append("KW1169 : 'KW' '1169';\n");
+		grammarBuilder.append("KW1170 : 'KW' '1170';\n");
+		grammarBuilder.append("KW1171 : 'KW' '1171';\n");
+		grammarBuilder.append("KW1172 : 'KW' '1172';\n");
+		grammarBuilder.append("KW1173 : 'KW' '1173';\n");
+		grammarBuilder.append("KW1174 : 'KW' '1174';\n");
+		grammarBuilder.append("KW1175 : 'KW' '1175';\n");
+		grammarBuilder.append("KW1176 : 'KW' '1176';\n");
+		grammarBuilder.append("KW1177 : 'KW' '1177';\n");
+		grammarBuilder.append("KW1178 : 'KW' '1178';\n");
+		grammarBuilder.append("KW1179 : 'KW' '1179';\n");
+		grammarBuilder.append("KW1180 : 'KW' '1180';\n");
+		grammarBuilder.append("KW1181 : 'KW' '1181';\n");
+		grammarBuilder.append("KW1182 : 'KW' '1182';\n");
+		grammarBuilder.append("KW1183 : 'KW' '1183';\n");
+		grammarBuilder.append("KW1184 : 'KW' '1184';\n");
+		grammarBuilder.append("KW1185 : 'KW' '1185';\n");
+		grammarBuilder.append("KW1186 : 'KW' '1186';\n");
+		grammarBuilder.append("KW1187 : 'KW' '1187';\n");
+		grammarBuilder.append("KW1188 : 'KW' '1188';\n");
+		grammarBuilder.append("KW1189 : 'KW' '1189';\n");
+		grammarBuilder.append("KW1190 : 'KW' '1190';\n");
+		grammarBuilder.append("KW1191 : 'KW' '1191';\n");
+		grammarBuilder.append("KW1192 : 'KW' '1192';\n");
+		grammarBuilder.append("KW1193 : 'KW' '1193';\n");
+		grammarBuilder.append("KW1194 : 'KW' '1194';\n");
+		grammarBuilder.append("KW1195 : 'KW' '1195';\n");
+		grammarBuilder.append("KW1196 : 'KW' '1196';\n");
+		grammarBuilder.append("KW1197 : 'KW' '1197';\n");
+		grammarBuilder.append("KW1198 : 'KW' '1198';\n");
+		grammarBuilder.append("KW1199 : 'KW' '1199';\n");
+		grammarBuilder.append("KW1200 : 'KW' '1200';\n");
+		grammarBuilder.append("KW1201 : 'KW' '1201';\n");
+		grammarBuilder.append("KW1202 : 'KW' '1202';\n");
+		grammarBuilder.append("KW1203 : 'KW' '1203';\n");
+		grammarBuilder.append("KW1204 : 'KW' '1204';\n");
+		grammarBuilder.append("KW1205 : 'KW' '1205';\n");
+		grammarBuilder.append("KW1206 : 'KW' '1206';\n");
+		grammarBuilder.append("KW1207 : 'KW' '1207';\n");
+		grammarBuilder.append("KW1208 : 'KW' '1208';\n");
+		grammarBuilder.append("KW1209 : 'KW' '1209';\n");
+		grammarBuilder.append("KW1210 : 'KW' '1210';\n");
+		grammarBuilder.append("KW1211 : 'KW' '1211';\n");
+		grammarBuilder.append("KW1212 : 'KW' '1212';\n");
+		grammarBuilder.append("KW1213 : 'KW' '1213';\n");
+		grammarBuilder.append("KW1214 : 'KW' '1214';\n");
+		grammarBuilder.append("KW1215 : 'KW' '1215';\n");
+		grammarBuilder.append("KW1216 : 'KW' '1216';\n");
+		grammarBuilder.append("KW1217 : 'KW' '1217';\n");
+		grammarBuilder.append("KW1218 : 'KW' '1218';\n");
+		grammarBuilder.append("KW1219 : 'KW' '1219';\n");
+		grammarBuilder.append("KW1220 : 'KW' '1220';\n");
+		grammarBuilder.append("KW1221 : 'KW' '1221';\n");
+		grammarBuilder.append("KW1222 : 'KW' '1222';\n");
+		grammarBuilder.append("KW1223 : 'KW' '1223';\n");
+		grammarBuilder.append("KW1224 : 'KW' '1224';\n");
+		grammarBuilder.append("KW1225 : 'KW' '1225';\n");
+		grammarBuilder.append("KW1226 : 'KW' '1226';\n");
+		grammarBuilder.append("KW1227 : 'KW' '1227';\n");
+		grammarBuilder.append("KW1228 : 'KW' '1228';\n");
+		grammarBuilder.append("KW1229 : 'KW' '1229';\n");
+		grammarBuilder.append("KW1230 : 'KW' '1230';\n");
+		grammarBuilder.append("KW1231 : 'KW' '1231';\n");
+		grammarBuilder.append("KW1232 : 'KW' '1232';\n");
+		grammarBuilder.append("KW1233 : 'KW' '1233';\n");
+		grammarBuilder.append("KW1234 : 'KW' '1234';\n");
+		grammarBuilder.append("KW1235 : 'KW' '1235';\n");
+		grammarBuilder.append("KW1236 : 'KW' '1236';\n");
+		grammarBuilder.append("KW1237 : 'KW' '1237';\n");
+		grammarBuilder.append("KW1238 : 'KW' '1238';\n");
+		grammarBuilder.append("KW1239 : 'KW' '1239';\n");
+		grammarBuilder.append("KW1240 : 'KW' '1240';\n");
+		grammarBuilder.append("KW1241 : 'KW' '1241';\n");
+		grammarBuilder.append("KW1242 : 'KW' '1242';\n");
+		grammarBuilder.append("KW1243 : 'KW' '1243';\n");
+		grammarBuilder.append("KW1244 : 'KW' '1244';\n");
+		grammarBuilder.append("KW1245 : 'KW' '1245';\n");
+		grammarBuilder.append("KW1246 : 'KW' '1246';\n");
+		grammarBuilder.append("KW1247 : 'KW' '1247';\n");
+		grammarBuilder.append("KW1248 : 'KW' '1248';\n");
+		grammarBuilder.append("KW1249 : 'KW' '1249';\n");
+		grammarBuilder.append("KW1250 : 'KW' '1250';\n");
+		grammarBuilder.append("KW1251 : 'KW' '1251';\n");
+		grammarBuilder.append("KW1252 : 'KW' '1252';\n");
+		grammarBuilder.append("KW1253 : 'KW' '1253';\n");
+		grammarBuilder.append("KW1254 : 'KW' '1254';\n");
+		grammarBuilder.append("KW1255 : 'KW' '1255';\n");
+		grammarBuilder.append("KW1256 : 'KW' '1256';\n");
+		grammarBuilder.append("KW1257 : 'KW' '1257';\n");
+		grammarBuilder.append("KW1258 : 'KW' '1258';\n");
+		grammarBuilder.append("KW1259 : 'KW' '1259';\n");
+		grammarBuilder.append("KW1260 : 'KW' '1260';\n");
+		grammarBuilder.append("KW1261 : 'KW' '1261';\n");
+		grammarBuilder.append("KW1262 : 'KW' '1262';\n");
+		grammarBuilder.append("KW1263 : 'KW' '1263';\n");
+		grammarBuilder.append("KW1264 : 'KW' '1264';\n");
+		grammarBuilder.append("KW1265 : 'KW' '1265';\n");
+		grammarBuilder.append("KW1266 : 'KW' '1266';\n");
+		grammarBuilder.append("KW1267 : 'KW' '1267';\n");
+		grammarBuilder.append("KW1268 : 'KW' '1268';\n");
+		grammarBuilder.append("KW1269 : 'KW' '1269';\n");
+		grammarBuilder.append("KW1270 : 'KW' '1270';\n");
+		grammarBuilder.append("KW1271 : 'KW' '1271';\n");
+		grammarBuilder.append("KW1272 : 'KW' '1272';\n");
+		grammarBuilder.append("KW1273 : 'KW' '1273';\n");
+		grammarBuilder.append("KW1274 : 'KW' '1274';\n");
+		grammarBuilder.append("KW1275 : 'KW' '1275';\n");
+		grammarBuilder.append("KW1276 : 'KW' '1276';\n");
+		grammarBuilder.append("KW1277 : 'KW' '1277';\n");
+		grammarBuilder.append("KW1278 : 'KW' '1278';\n");
+		grammarBuilder.append("KW1279 : 'KW' '1279';\n");
+		grammarBuilder.append("KW1280 : 'KW' '1280';\n");
+		grammarBuilder.append("KW1281 : 'KW' '1281';\n");
+		grammarBuilder.append("KW1282 : 'KW' '1282';\n");
+		grammarBuilder.append("KW1283 : 'KW' '1283';\n");
+		grammarBuilder.append("KW1284 : 'KW' '1284';\n");
+		grammarBuilder.append("KW1285 : 'KW' '1285';\n");
+		grammarBuilder.append("KW1286 : 'KW' '1286';\n");
+		grammarBuilder.append("KW1287 : 'KW' '1287';\n");
+		grammarBuilder.append("KW1288 : 'KW' '1288';\n");
+		grammarBuilder.append("KW1289 : 'KW' '1289';\n");
+		grammarBuilder.append("KW1290 : 'KW' '1290';\n");
+		grammarBuilder.append("KW1291 : 'KW' '1291';\n");
+		grammarBuilder.append("KW1292 : 'KW' '1292';\n");
+		grammarBuilder.append("KW1293 : 'KW' '1293';\n");
+		grammarBuilder.append("KW1294 : 'KW' '1294';\n");
+		grammarBuilder.append("KW1295 : 'KW' '1295';\n");
+		grammarBuilder.append("KW1296 : 'KW' '1296';\n");
+		grammarBuilder.append("KW1297 : 'KW' '1297';\n");
+		grammarBuilder.append("KW1298 : 'KW' '1298';\n");
+		grammarBuilder.append("KW1299 : 'KW' '1299';\n");
+		grammarBuilder.append("KW1300 : 'KW' '1300';\n");
+		grammarBuilder.append("KW1301 : 'KW' '1301';\n");
+		grammarBuilder.append("KW1302 : 'KW' '1302';\n");
+		grammarBuilder.append("KW1303 : 'KW' '1303';\n");
+		grammarBuilder.append("KW1304 : 'KW' '1304';\n");
+		grammarBuilder.append("KW1305 : 'KW' '1305';\n");
+		grammarBuilder.append("KW1306 : 'KW' '1306';\n");
+		grammarBuilder.append("KW1307 : 'KW' '1307';\n");
+		grammarBuilder.append("KW1308 : 'KW' '1308';\n");
+		grammarBuilder.append("KW1309 : 'KW' '1309';\n");
+		grammarBuilder.append("KW1310 : 'KW' '1310';\n");
+		grammarBuilder.append("KW1311 : 'KW' '1311';\n");
+		grammarBuilder.append("KW1312 : 'KW' '1312';\n");
+		grammarBuilder.append("KW1313 : 'KW' '1313';\n");
+		grammarBuilder.append("KW1314 : 'KW' '1314';\n");
+		grammarBuilder.append("KW1315 : 'KW' '1315';\n");
+		grammarBuilder.append("KW1316 : 'KW' '1316';\n");
+		grammarBuilder.append("KW1317 : 'KW' '1317';\n");
+		grammarBuilder.append("KW1318 : 'KW' '1318';\n");
+		grammarBuilder.append("KW1319 : 'KW' '1319';\n");
+		grammarBuilder.append("KW1320 : 'KW' '1320';\n");
+		grammarBuilder.append("KW1321 : 'KW' '1321';\n");
+		grammarBuilder.append("KW1322 : 'KW' '1322';\n");
+		grammarBuilder.append("KW1323 : 'KW' '1323';\n");
+		grammarBuilder.append("KW1324 : 'KW' '1324';\n");
+		grammarBuilder.append("KW1325 : 'KW' '1325';\n");
+		grammarBuilder.append("KW1326 : 'KW' '1326';\n");
+		grammarBuilder.append("KW1327 : 'KW' '1327';\n");
+		grammarBuilder.append("KW1328 : 'KW' '1328';\n");
+		grammarBuilder.append("KW1329 : 'KW' '1329';\n");
+		grammarBuilder.append("KW1330 : 'KW' '1330';\n");
+		grammarBuilder.append("KW1331 : 'KW' '1331';\n");
+		grammarBuilder.append("KW1332 : 'KW' '1332';\n");
+		grammarBuilder.append("KW1333 : 'KW' '1333';\n");
+		grammarBuilder.append("KW1334 : 'KW' '1334';\n");
+		grammarBuilder.append("KW1335 : 'KW' '1335';\n");
+		grammarBuilder.append("KW1336 : 'KW' '1336';\n");
+		grammarBuilder.append("KW1337 : 'KW' '1337';\n");
+		grammarBuilder.append("KW1338 : 'KW' '1338';\n");
+		grammarBuilder.append("KW1339 : 'KW' '1339';\n");
+		grammarBuilder.append("KW1340 : 'KW' '1340';\n");
+		grammarBuilder.append("KW1341 : 'KW' '1341';\n");
+		grammarBuilder.append("KW1342 : 'KW' '1342';\n");
+		grammarBuilder.append("KW1343 : 'KW' '1343';\n");
+		grammarBuilder.append("KW1344 : 'KW' '1344';\n");
+		grammarBuilder.append("KW1345 : 'KW' '1345';\n");
+		grammarBuilder.append("KW1346 : 'KW' '1346';\n");
+		grammarBuilder.append("KW1347 : 'KW' '1347';\n");
+		grammarBuilder.append("KW1348 : 'KW' '1348';\n");
+		grammarBuilder.append("KW1349 : 'KW' '1349';\n");
+		grammarBuilder.append("KW1350 : 'KW' '1350';\n");
+		grammarBuilder.append("KW1351 : 'KW' '1351';\n");
+		grammarBuilder.append("KW1352 : 'KW' '1352';\n");
+		grammarBuilder.append("KW1353 : 'KW' '1353';\n");
+		grammarBuilder.append("KW1354 : 'KW' '1354';\n");
+		grammarBuilder.append("KW1355 : 'KW' '1355';\n");
+		grammarBuilder.append("KW1356 : 'KW' '1356';\n");
+		grammarBuilder.append("KW1357 : 'KW' '1357';\n");
+		grammarBuilder.append("KW1358 : 'KW' '1358';\n");
+		grammarBuilder.append("KW1359 : 'KW' '1359';\n");
+		grammarBuilder.append("KW1360 : 'KW' '1360';\n");
+		grammarBuilder.append("KW1361 : 'KW' '1361';\n");
+		grammarBuilder.append("KW1362 : 'KW' '1362';\n");
+		grammarBuilder.append("KW1363 : 'KW' '1363';\n");
+		grammarBuilder.append("KW1364 : 'KW' '1364';\n");
+		grammarBuilder.append("KW1365 : 'KW' '1365';\n");
+		grammarBuilder.append("KW1366 : 'KW' '1366';\n");
+		grammarBuilder.append("KW1367 : 'KW' '1367';\n");
+		grammarBuilder.append("KW1368 : 'KW' '1368';\n");
+		grammarBuilder.append("KW1369 : 'KW' '1369';\n");
+		grammarBuilder.append("KW1370 : 'KW' '1370';\n");
+		grammarBuilder.append("KW1371 : 'KW' '1371';\n");
+		grammarBuilder.append("KW1372 : 'KW' '1372';\n");
+		grammarBuilder.append("KW1373 : 'KW' '1373';\n");
+		grammarBuilder.append("KW1374 : 'KW' '1374';\n");
+		grammarBuilder.append("KW1375 : 'KW' '1375';\n");
+		grammarBuilder.append("KW1376 : 'KW' '1376';\n");
+		grammarBuilder.append("KW1377 : 'KW' '1377';\n");
+		grammarBuilder.append("KW1378 : 'KW' '1378';\n");
+		grammarBuilder.append("KW1379 : 'KW' '1379';\n");
+		grammarBuilder.append("KW1380 : 'KW' '1380';\n");
+		grammarBuilder.append("KW1381 : 'KW' '1381';\n");
+		grammarBuilder.append("KW1382 : 'KW' '1382';\n");
+		grammarBuilder.append("KW1383 : 'KW' '1383';\n");
+		grammarBuilder.append("KW1384 : 'KW' '1384';\n");
+		grammarBuilder.append("KW1385 : 'KW' '1385';\n");
+		grammarBuilder.append("KW1386 : 'KW' '1386';\n");
+		grammarBuilder.append("KW1387 : 'KW' '1387';\n");
+		grammarBuilder.append("KW1388 : 'KW' '1388';\n");
+		grammarBuilder.append("KW1389 : 'KW' '1389';\n");
+		grammarBuilder.append("KW1390 : 'KW' '1390';\n");
+		grammarBuilder.append("KW1391 : 'KW' '1391';\n");
+		grammarBuilder.append("KW1392 : 'KW' '1392';\n");
+		grammarBuilder.append("KW1393 : 'KW' '1393';\n");
+		grammarBuilder.append("KW1394 : 'KW' '1394';\n");
+		grammarBuilder.append("KW1395 : 'KW' '1395';\n");
+		grammarBuilder.append("KW1396 : 'KW' '1396';\n");
+		grammarBuilder.append("KW1397 : 'KW' '1397';\n");
+		grammarBuilder.append("KW1398 : 'KW' '1398';\n");
+		grammarBuilder.append("KW1399 : 'KW' '1399';\n");
+		grammarBuilder.append("KW1400 : 'KW' '1400';\n");
+		grammarBuilder.append("KW1401 : 'KW' '1401';\n");
+		grammarBuilder.append("KW1402 : 'KW' '1402';\n");
+		grammarBuilder.append("KW1403 : 'KW' '1403';\n");
+		grammarBuilder.append("KW1404 : 'KW' '1404';\n");
+		grammarBuilder.append("KW1405 : 'KW' '1405';\n");
+		grammarBuilder.append("KW1406 : 'KW' '1406';\n");
+		grammarBuilder.append("KW1407 : 'KW' '1407';\n");
+		grammarBuilder.append("KW1408 : 'KW' '1408';\n");
+		grammarBuilder.append("KW1409 : 'KW' '1409';\n");
+		grammarBuilder.append("KW1410 : 'KW' '1410';\n");
+		grammarBuilder.append("KW1411 : 'KW' '1411';\n");
+		grammarBuilder.append("KW1412 : 'KW' '1412';\n");
+		grammarBuilder.append("KW1413 : 'KW' '1413';\n");
+		grammarBuilder.append("KW1414 : 'KW' '1414';\n");
+		grammarBuilder.append("KW1415 : 'KW' '1415';\n");
+		grammarBuilder.append("KW1416 : 'KW' '1416';\n");
+		grammarBuilder.append("KW1417 : 'KW' '1417';\n");
+		grammarBuilder.append("KW1418 : 'KW' '1418';\n");
+		grammarBuilder.append("KW1419 : 'KW' '1419';\n");
+		grammarBuilder.append("KW1420 : 'KW' '1420';\n");
+		grammarBuilder.append("KW1421 : 'KW' '1421';\n");
+		grammarBuilder.append("KW1422 : 'KW' '1422';\n");
+		grammarBuilder.append("KW1423 : 'KW' '1423';\n");
+		grammarBuilder.append("KW1424 : 'KW' '1424';\n");
+		grammarBuilder.append("KW1425 : 'KW' '1425';\n");
+		grammarBuilder.append("KW1426 : 'KW' '1426';\n");
+		grammarBuilder.append("KW1427 : 'KW' '1427';\n");
+		grammarBuilder.append("KW1428 : 'KW' '1428';\n");
+		grammarBuilder.append("KW1429 : 'KW' '1429';\n");
+		grammarBuilder.append("KW1430 : 'KW' '1430';\n");
+		grammarBuilder.append("KW1431 : 'KW' '1431';\n");
+		grammarBuilder.append("KW1432 : 'KW' '1432';\n");
+		grammarBuilder.append("KW1433 : 'KW' '1433';\n");
+		grammarBuilder.append("KW1434 : 'KW' '1434';\n");
+		grammarBuilder.append("KW1435 : 'KW' '1435';\n");
+		grammarBuilder.append("KW1436 : 'KW' '1436';\n");
+		grammarBuilder.append("KW1437 : 'KW' '1437';\n");
+		grammarBuilder.append("KW1438 : 'KW' '1438';\n");
+		grammarBuilder.append("KW1439 : 'KW' '1439';\n");
+		grammarBuilder.append("KW1440 : 'KW' '1440';\n");
+		grammarBuilder.append("KW1441 : 'KW' '1441';\n");
+		grammarBuilder.append("KW1442 : 'KW' '1442';\n");
+		grammarBuilder.append("KW1443 : 'KW' '1443';\n");
+		grammarBuilder.append("KW1444 : 'KW' '1444';\n");
+		grammarBuilder.append("KW1445 : 'KW' '1445';\n");
+		grammarBuilder.append("KW1446 : 'KW' '1446';\n");
+		grammarBuilder.append("KW1447 : 'KW' '1447';\n");
+		grammarBuilder.append("KW1448 : 'KW' '1448';\n");
+		grammarBuilder.append("KW1449 : 'KW' '1449';\n");
+		grammarBuilder.append("KW1450 : 'KW' '1450';\n");
+		grammarBuilder.append("KW1451 : 'KW' '1451';\n");
+		grammarBuilder.append("KW1452 : 'KW' '1452';\n");
+		grammarBuilder.append("KW1453 : 'KW' '1453';\n");
+		grammarBuilder.append("KW1454 : 'KW' '1454';\n");
+		grammarBuilder.append("KW1455 : 'KW' '1455';\n");
+		grammarBuilder.append("KW1456 : 'KW' '1456';\n");
+		grammarBuilder.append("KW1457 : 'KW' '1457';\n");
+		grammarBuilder.append("KW1458 : 'KW' '1458';\n");
+		grammarBuilder.append("KW1459 : 'KW' '1459';\n");
+		grammarBuilder.append("KW1460 : 'KW' '1460';\n");
+		grammarBuilder.append("KW1461 : 'KW' '1461';\n");
+		grammarBuilder.append("KW1462 : 'KW' '1462';\n");
+		grammarBuilder.append("KW1463 : 'KW' '1463';\n");
+		grammarBuilder.append("KW1464 : 'KW' '1464';\n");
+		grammarBuilder.append("KW1465 : 'KW' '1465';\n");
+		grammarBuilder.append("KW1466 : 'KW' '1466';\n");
+		grammarBuilder.append("KW1467 : 'KW' '1467';\n");
+		grammarBuilder.append("KW1468 : 'KW' '1468';\n");
+		grammarBuilder.append("KW1469 : 'KW' '1469';\n");
+		grammarBuilder.append("KW1470 : 'KW' '1470';\n");
+		grammarBuilder.append("KW1471 : 'KW' '1471';\n");
+		grammarBuilder.append("KW1472 : 'KW' '1472';\n");
+		grammarBuilder.append("KW1473 : 'KW' '1473';\n");
+		grammarBuilder.append("KW1474 : 'KW' '1474';\n");
+		grammarBuilder.append("KW1475 : 'KW' '1475';\n");
+		grammarBuilder.append("KW1476 : 'KW' '1476';\n");
+		grammarBuilder.append("KW1477 : 'KW' '1477';\n");
+		grammarBuilder.append("KW1478 : 'KW' '1478';\n");
+		grammarBuilder.append("KW1479 : 'KW' '1479';\n");
+		grammarBuilder.append("KW1480 : 'KW' '1480';\n");
+		grammarBuilder.append("KW1481 : 'KW' '1481';\n");
+		grammarBuilder.append("KW1482 : 'KW' '1482';\n");
+		grammarBuilder.append("KW1483 : 'KW' '1483';\n");
+		grammarBuilder.append("KW1484 : 'KW' '1484';\n");
+		grammarBuilder.append("KW1485 : 'KW' '1485';\n");
+		grammarBuilder.append("KW1486 : 'KW' '1486';\n");
+		grammarBuilder.append("KW1487 : 'KW' '1487';\n");
+		grammarBuilder.append("KW1488 : 'KW' '1488';\n");
+		grammarBuilder.append("KW1489 : 'KW' '1489';\n");
+		grammarBuilder.append("KW1490 : 'KW' '1490';\n");
+		grammarBuilder.append("KW1491 : 'KW' '1491';\n");
+		grammarBuilder.append("KW1492 : 'KW' '1492';\n");
+		grammarBuilder.append("KW1493 : 'KW' '1493';\n");
+		grammarBuilder.append("KW1494 : 'KW' '1494';\n");
+		grammarBuilder.append("KW1495 : 'KW' '1495';\n");
+		grammarBuilder.append("KW1496 : 'KW' '1496';\n");
+		grammarBuilder.append("KW1497 : 'KW' '1497';\n");
+		grammarBuilder.append("KW1498 : 'KW' '1498';\n");
+		grammarBuilder.append("KW1499 : 'KW' '1499';\n");
+		grammarBuilder.append("KW1500 : 'KW' '1500';\n");
+		grammarBuilder.append("KW1501 : 'KW' '1501';\n");
+		grammarBuilder.append("KW1502 : 'KW' '1502';\n");
+		grammarBuilder.append("KW1503 : 'KW' '1503';\n");
+		grammarBuilder.append("KW1504 : 'KW' '1504';\n");
+		grammarBuilder.append("KW1505 : 'KW' '1505';\n");
+		grammarBuilder.append("KW1506 : 'KW' '1506';\n");
+		grammarBuilder.append("KW1507 : 'KW' '1507';\n");
+		grammarBuilder.append("KW1508 : 'KW' '1508';\n");
+		grammarBuilder.append("KW1509 : 'KW' '1509';\n");
+		grammarBuilder.append("KW1510 : 'KW' '1510';\n");
+		grammarBuilder.append("KW1511 : 'KW' '1511';\n");
+		grammarBuilder.append("KW1512 : 'KW' '1512';\n");
+		grammarBuilder.append("KW1513 : 'KW' '1513';\n");
+		grammarBuilder.append("KW1514 : 'KW' '1514';\n");
+		grammarBuilder.append("KW1515 : 'KW' '1515';\n");
+		grammarBuilder.append("KW1516 : 'KW' '1516';\n");
+		grammarBuilder.append("KW1517 : 'KW' '1517';\n");
+		grammarBuilder.append("KW1518 : 'KW' '1518';\n");
+		grammarBuilder.append("KW1519 : 'KW' '1519';\n");
+		grammarBuilder.append("KW1520 : 'KW' '1520';\n");
+		grammarBuilder.append("KW1521 : 'KW' '1521';\n");
+		grammarBuilder.append("KW1522 : 'KW' '1522';\n");
+		grammarBuilder.append("KW1523 : 'KW' '1523';\n");
+		grammarBuilder.append("KW1524 : 'KW' '1524';\n");
+		grammarBuilder.append("KW1525 : 'KW' '1525';\n");
+		grammarBuilder.append("KW1526 : 'KW' '1526';\n");
+		grammarBuilder.append("KW1527 : 'KW' '1527';\n");
+		grammarBuilder.append("KW1528 : 'KW' '1528';\n");
+		grammarBuilder.append("KW1529 : 'KW' '1529';\n");
+		grammarBuilder.append("KW1530 : 'KW' '1530';\n");
+		grammarBuilder.append("KW1531 : 'KW' '1531';\n");
+		grammarBuilder.append("KW1532 : 'KW' '1532';\n");
+		grammarBuilder.append("KW1533 : 'KW' '1533';\n");
+		grammarBuilder.append("KW1534 : 'KW' '1534';\n");
+		grammarBuilder.append("KW1535 : 'KW' '1535';\n");
+		grammarBuilder.append("KW1536 : 'KW' '1536';\n");
+		grammarBuilder.append("KW1537 : 'KW' '1537';\n");
+		grammarBuilder.append("KW1538 : 'KW' '1538';\n");
+		grammarBuilder.append("KW1539 : 'KW' '1539';\n");
+		grammarBuilder.append("KW1540 : 'KW' '1540';\n");
+		grammarBuilder.append("KW1541 : 'KW' '1541';\n");
+		grammarBuilder.append("KW1542 : 'KW' '1542';\n");
+		grammarBuilder.append("KW1543 : 'KW' '1543';\n");
+		grammarBuilder.append("KW1544 : 'KW' '1544';\n");
+		grammarBuilder.append("KW1545 : 'KW' '1545';\n");
+		grammarBuilder.append("KW1546 : 'KW' '1546';\n");
+		grammarBuilder.append("KW1547 : 'KW' '1547';\n");
+		grammarBuilder.append("KW1548 : 'KW' '1548';\n");
+		grammarBuilder.append("KW1549 : 'KW' '1549';\n");
+		grammarBuilder.append("KW1550 : 'KW' '1550';\n");
+		grammarBuilder.append("KW1551 : 'KW' '1551';\n");
+		grammarBuilder.append("KW1552 : 'KW' '1552';\n");
+		grammarBuilder.append("KW1553 : 'KW' '1553';\n");
+		grammarBuilder.append("KW1554 : 'KW' '1554';\n");
+		grammarBuilder.append("KW1555 : 'KW' '1555';\n");
+		grammarBuilder.append("KW1556 : 'KW' '1556';\n");
+		grammarBuilder.append("KW1557 : 'KW' '1557';\n");
+		grammarBuilder.append("KW1558 : 'KW' '1558';\n");
+		grammarBuilder.append("KW1559 : 'KW' '1559';\n");
+		grammarBuilder.append("KW1560 : 'KW' '1560';\n");
+		grammarBuilder.append("KW1561 : 'KW' '1561';\n");
+		grammarBuilder.append("KW1562 : 'KW' '1562';\n");
+		grammarBuilder.append("KW1563 : 'KW' '1563';\n");
+		grammarBuilder.append("KW1564 : 'KW' '1564';\n");
+		grammarBuilder.append("KW1565 : 'KW' '1565';\n");
+		grammarBuilder.append("KW1566 : 'KW' '1566';\n");
+		grammarBuilder.append("KW1567 : 'KW' '1567';\n");
+		grammarBuilder.append("KW1568 : 'KW' '1568';\n");
+		grammarBuilder.append("KW1569 : 'KW' '1569';\n");
+		grammarBuilder.append("KW1570 : 'KW' '1570';\n");
+		grammarBuilder.append("KW1571 : 'KW' '1571';\n");
+		grammarBuilder.append("KW1572 : 'KW' '1572';\n");
+		grammarBuilder.append("KW1573 : 'KW' '1573';\n");
+		grammarBuilder.append("KW1574 : 'KW' '1574';\n");
+		grammarBuilder.append("KW1575 : 'KW' '1575';\n");
+		grammarBuilder.append("KW1576 : 'KW' '1576';\n");
+		grammarBuilder.append("KW1577 : 'KW' '1577';\n");
+		grammarBuilder.append("KW1578 : 'KW' '1578';\n");
+		grammarBuilder.append("KW1579 : 'KW' '1579';\n");
+		grammarBuilder.append("KW1580 : 'KW' '1580';\n");
+		grammarBuilder.append("KW1581 : 'KW' '1581';\n");
+		grammarBuilder.append("KW1582 : 'KW' '1582';\n");
+		grammarBuilder.append("KW1583 : 'KW' '1583';\n");
+		grammarBuilder.append("KW1584 : 'KW' '1584';\n");
+		grammarBuilder.append("KW1585 : 'KW' '1585';\n");
+		grammarBuilder.append("KW1586 : 'KW' '1586';\n");
+		grammarBuilder.append("KW1587 : 'KW' '1587';\n");
+		grammarBuilder.append("KW1588 : 'KW' '1588';\n");
+		grammarBuilder.append("KW1589 : 'KW' '1589';\n");
+		grammarBuilder.append("KW1590 : 'KW' '1590';\n");
+		grammarBuilder.append("KW1591 : 'KW' '1591';\n");
+		grammarBuilder.append("KW1592 : 'KW' '1592';\n");
+		grammarBuilder.append("KW1593 : 'KW' '1593';\n");
+		grammarBuilder.append("KW1594 : 'KW' '1594';\n");
+		grammarBuilder.append("KW1595 : 'KW' '1595';\n");
+		grammarBuilder.append("KW1596 : 'KW' '1596';\n");
+		grammarBuilder.append("KW1597 : 'KW' '1597';\n");
+		grammarBuilder.append("KW1598 : 'KW' '1598';\n");
+		grammarBuilder.append("KW1599 : 'KW' '1599';\n");
+		grammarBuilder.append("KW1600 : 'KW' '1600';\n");
+		grammarBuilder.append("KW1601 : 'KW' '1601';\n");
+		grammarBuilder.append("KW1602 : 'KW' '1602';\n");
+		grammarBuilder.append("KW1603 : 'KW' '1603';\n");
+		grammarBuilder.append("KW1604 : 'KW' '1604';\n");
+		grammarBuilder.append("KW1605 : 'KW' '1605';\n");
+		grammarBuilder.append("KW1606 : 'KW' '1606';\n");
+		grammarBuilder.append("KW1607 : 'KW' '1607';\n");
+		grammarBuilder.append("KW1608 : 'KW' '1608';\n");
+		grammarBuilder.append("KW1609 : 'KW' '1609';\n");
+		grammarBuilder.append("KW1610 : 'KW' '1610';\n");
+		grammarBuilder.append("KW1611 : 'KW' '1611';\n");
+		grammarBuilder.append("KW1612 : 'KW' '1612';\n");
+		grammarBuilder.append("KW1613 : 'KW' '1613';\n");
+		grammarBuilder.append("KW1614 : 'KW' '1614';\n");
+		grammarBuilder.append("KW1615 : 'KW' '1615';\n");
+		grammarBuilder.append("KW1616 : 'KW' '1616';\n");
+		grammarBuilder.append("KW1617 : 'KW' '1617';\n");
+		grammarBuilder.append("KW1618 : 'KW' '1618';\n");
+		grammarBuilder.append("KW1619 : 'KW' '1619';\n");
+		grammarBuilder.append("KW1620 : 'KW' '1620';\n");
+		grammarBuilder.append("KW1621 : 'KW' '1621';\n");
+		grammarBuilder.append("KW1622 : 'KW' '1622';\n");
+		grammarBuilder.append("KW1623 : 'KW' '1623';\n");
+		grammarBuilder.append("KW1624 : 'KW' '1624';\n");
+		grammarBuilder.append("KW1625 : 'KW' '1625';\n");
+		grammarBuilder.append("KW1626 : 'KW' '1626';\n");
+		grammarBuilder.append("KW1627 : 'KW' '1627';\n");
+		grammarBuilder.append("KW1628 : 'KW' '1628';\n");
+		grammarBuilder.append("KW1629 : 'KW' '1629';\n");
+		grammarBuilder.append("KW1630 : 'KW' '1630';\n");
+		grammarBuilder.append("KW1631 : 'KW' '1631';\n");
+		grammarBuilder.append("KW1632 : 'KW' '1632';\n");
+		grammarBuilder.append("KW1633 : 'KW' '1633';\n");
+		grammarBuilder.append("KW1634 : 'KW' '1634';\n");
+		grammarBuilder.append("KW1635 : 'KW' '1635';\n");
+		grammarBuilder.append("KW1636 : 'KW' '1636';\n");
+		grammarBuilder.append("KW1637 : 'KW' '1637';\n");
+		grammarBuilder.append("KW1638 : 'KW' '1638';\n");
+		grammarBuilder.append("KW1639 : 'KW' '1639';\n");
+		grammarBuilder.append("KW1640 : 'KW' '1640';\n");
+		grammarBuilder.append("KW1641 : 'KW' '1641';\n");
+		grammarBuilder.append("KW1642 : 'KW' '1642';\n");
+		grammarBuilder.append("KW1643 : 'KW' '1643';\n");
+		grammarBuilder.append("KW1644 : 'KW' '1644';\n");
+		grammarBuilder.append("KW1645 : 'KW' '1645';\n");
+		grammarBuilder.append("KW1646 : 'KW' '1646';\n");
+		grammarBuilder.append("KW1647 : 'KW' '1647';\n");
+		grammarBuilder.append("KW1648 : 'KW' '1648';\n");
+		grammarBuilder.append("KW1649 : 'KW' '1649';\n");
+		grammarBuilder.append("KW1650 : 'KW' '1650';\n");
+		grammarBuilder.append("KW1651 : 'KW' '1651';\n");
+		grammarBuilder.append("KW1652 : 'KW' '1652';\n");
+		grammarBuilder.append("KW1653 : 'KW' '1653';\n");
+		grammarBuilder.append("KW1654 : 'KW' '1654';\n");
+		grammarBuilder.append("KW1655 : 'KW' '1655';\n");
+		grammarBuilder.append("KW1656 : 'KW' '1656';\n");
+		grammarBuilder.append("KW1657 : 'KW' '1657';\n");
+		grammarBuilder.append("KW1658 : 'KW' '1658';\n");
+		grammarBuilder.append("KW1659 : 'KW' '1659';\n");
+		grammarBuilder.append("KW1660 : 'KW' '1660';\n");
+		grammarBuilder.append("KW1661 : 'KW' '1661';\n");
+		grammarBuilder.append("KW1662 : 'KW' '1662';\n");
+		grammarBuilder.append("KW1663 : 'KW' '1663';\n");
+		grammarBuilder.append("KW1664 : 'KW' '1664';\n");
+		grammarBuilder.append("KW1665 : 'KW' '1665';\n");
+		grammarBuilder.append("KW1666 : 'KW' '1666';\n");
+		grammarBuilder.append("KW1667 : 'KW' '1667';\n");
+		grammarBuilder.append("KW1668 : 'KW' '1668';\n");
+		grammarBuilder.append("KW1669 : 'KW' '1669';\n");
+		grammarBuilder.append("KW1670 : 'KW' '1670';\n");
+		grammarBuilder.append("KW1671 : 'KW' '1671';\n");
+		grammarBuilder.append("KW1672 : 'KW' '1672';\n");
+		grammarBuilder.append("KW1673 : 'KW' '1673';\n");
+		grammarBuilder.append("KW1674 : 'KW' '1674';\n");
+		grammarBuilder.append("KW1675 : 'KW' '1675';\n");
+		grammarBuilder.append("KW1676 : 'KW' '1676';\n");
+		grammarBuilder.append("KW1677 : 'KW' '1677';\n");
+		grammarBuilder.append("KW1678 : 'KW' '1678';\n");
+		grammarBuilder.append("KW1679 : 'KW' '1679';\n");
+		grammarBuilder.append("KW1680 : 'KW' '1680';\n");
+		grammarBuilder.append("KW1681 : 'KW' '1681';\n");
+		grammarBuilder.append("KW1682 : 'KW' '1682';\n");
+		grammarBuilder.append("KW1683 : 'KW' '1683';\n");
+		grammarBuilder.append("KW1684 : 'KW' '1684';\n");
+		grammarBuilder.append("KW1685 : 'KW' '1685';\n");
+		grammarBuilder.append("KW1686 : 'KW' '1686';\n");
+		grammarBuilder.append("KW1687 : 'KW' '1687';\n");
+		grammarBuilder.append("KW1688 : 'KW' '1688';\n");
+		grammarBuilder.append("KW1689 : 'KW' '1689';\n");
+		grammarBuilder.append("KW1690 : 'KW' '1690';\n");
+		grammarBuilder.append("KW1691 : 'KW' '1691';\n");
+		grammarBuilder.append("KW1692 : 'KW' '1692';\n");
+		grammarBuilder.append("KW1693 : 'KW' '1693';\n");
+		grammarBuilder.append("KW1694 : 'KW' '1694';\n");
+		grammarBuilder.append("KW1695 : 'KW' '1695';\n");
+		grammarBuilder.append("KW1696 : 'KW' '1696';\n");
+		grammarBuilder.append("KW1697 : 'KW' '1697';\n");
+		grammarBuilder.append("KW1698 : 'KW' '1698';\n");
+		grammarBuilder.append("KW1699 : 'KW' '1699';\n");
+		grammarBuilder.append("KW1700 : 'KW' '1700';\n");
+		grammarBuilder.append("KW1701 : 'KW' '1701';\n");
+		grammarBuilder.append("KW1702 : 'KW' '1702';\n");
+		grammarBuilder.append("KW1703 : 'KW' '1703';\n");
+		grammarBuilder.append("KW1704 : 'KW' '1704';\n");
+		grammarBuilder.append("KW1705 : 'KW' '1705';\n");
+		grammarBuilder.append("KW1706 : 'KW' '1706';\n");
+		grammarBuilder.append("KW1707 : 'KW' '1707';\n");
+		grammarBuilder.append("KW1708 : 'KW' '1708';\n");
+		grammarBuilder.append("KW1709 : 'KW' '1709';\n");
+		grammarBuilder.append("KW1710 : 'KW' '1710';\n");
+		grammarBuilder.append("KW1711 : 'KW' '1711';\n");
+		grammarBuilder.append("KW1712 : 'KW' '1712';\n");
+		grammarBuilder.append("KW1713 : 'KW' '1713';\n");
+		grammarBuilder.append("KW1714 : 'KW' '1714';\n");
+		grammarBuilder.append("KW1715 : 'KW' '1715';\n");
+		grammarBuilder.append("KW1716 : 'KW' '1716';\n");
+		grammarBuilder.append("KW1717 : 'KW' '1717';\n");
+		grammarBuilder.append("KW1718 : 'KW' '1718';\n");
+		grammarBuilder.append("KW1719 : 'KW' '1719';\n");
+		grammarBuilder.append("KW1720 : 'KW' '1720';\n");
+		grammarBuilder.append("KW1721 : 'KW' '1721';\n");
+		grammarBuilder.append("KW1722 : 'KW' '1722';\n");
+		grammarBuilder.append("KW1723 : 'KW' '1723';\n");
+		grammarBuilder.append("KW1724 : 'KW' '1724';\n");
+		grammarBuilder.append("KW1725 : 'KW' '1725';\n");
+		grammarBuilder.append("KW1726 : 'KW' '1726';\n");
+		grammarBuilder.append("KW1727 : 'KW' '1727';\n");
+		grammarBuilder.append("KW1728 : 'KW' '1728';\n");
+		grammarBuilder.append("KW1729 : 'KW' '1729';\n");
+		grammarBuilder.append("KW1730 : 'KW' '1730';\n");
+		grammarBuilder.append("KW1731 : 'KW' '1731';\n");
+		grammarBuilder.append("KW1732 : 'KW' '1732';\n");
+		grammarBuilder.append("KW1733 : 'KW' '1733';\n");
+		grammarBuilder.append("KW1734 : 'KW' '1734';\n");
+		grammarBuilder.append("KW1735 : 'KW' '1735';\n");
+		grammarBuilder.append("KW1736 : 'KW' '1736';\n");
+		grammarBuilder.append("KW1737 : 'KW' '1737';\n");
+		grammarBuilder.append("KW1738 : 'KW' '1738';\n");
+		grammarBuilder.append("KW1739 : 'KW' '1739';\n");
+		grammarBuilder.append("KW1740 : 'KW' '1740';\n");
+		grammarBuilder.append("KW1741 : 'KW' '1741';\n");
+		grammarBuilder.append("KW1742 : 'KW' '1742';\n");
+		grammarBuilder.append("KW1743 : 'KW' '1743';\n");
+		grammarBuilder.append("KW1744 : 'KW' '1744';\n");
+		grammarBuilder.append("KW1745 : 'KW' '1745';\n");
+		grammarBuilder.append("KW1746 : 'KW' '1746';\n");
+		grammarBuilder.append("KW1747 : 'KW' '1747';\n");
+		grammarBuilder.append("KW1748 : 'KW' '1748';\n");
+		grammarBuilder.append("KW1749 : 'KW' '1749';\n");
+		grammarBuilder.append("KW1750 : 'KW' '1750';\n");
+		grammarBuilder.append("KW1751 : 'KW' '1751';\n");
+		grammarBuilder.append("KW1752 : 'KW' '1752';\n");
+		grammarBuilder.append("KW1753 : 'KW' '1753';\n");
+		grammarBuilder.append("KW1754 : 'KW' '1754';\n");
+		grammarBuilder.append("KW1755 : 'KW' '1755';\n");
+		grammarBuilder.append("KW1756 : 'KW' '1756';\n");
+		grammarBuilder.append("KW1757 : 'KW' '1757';\n");
+		grammarBuilder.append("KW1758 : 'KW' '1758';\n");
+		grammarBuilder.append("KW1759 : 'KW' '1759';\n");
+		grammarBuilder.append("KW1760 : 'KW' '1760';\n");
+		grammarBuilder.append("KW1761 : 'KW' '1761';\n");
+		grammarBuilder.append("KW1762 : 'KW' '1762';\n");
+		grammarBuilder.append("KW1763 : 'KW' '1763';\n");
+		grammarBuilder.append("KW1764 : 'KW' '1764';\n");
+		grammarBuilder.append("KW1765 : 'KW' '1765';\n");
+		grammarBuilder.append("KW1766 : 'KW' '1766';\n");
+		grammarBuilder.append("KW1767 : 'KW' '1767';\n");
+		grammarBuilder.append("KW1768 : 'KW' '1768';\n");
+		grammarBuilder.append("KW1769 : 'KW' '1769';\n");
+		grammarBuilder.append("KW1770 : 'KW' '1770';\n");
+		grammarBuilder.append("KW1771 : 'KW' '1771';\n");
+		grammarBuilder.append("KW1772 : 'KW' '1772';\n");
+		grammarBuilder.append("KW1773 : 'KW' '1773';\n");
+		grammarBuilder.append("KW1774 : 'KW' '1774';\n");
+		grammarBuilder.append("KW1775 : 'KW' '1775';\n");
+		grammarBuilder.append("KW1776 : 'KW' '1776';\n");
+		grammarBuilder.append("KW1777 : 'KW' '1777';\n");
+		grammarBuilder.append("KW1778 : 'KW' '1778';\n");
+		grammarBuilder.append("KW1779 : 'KW' '1779';\n");
+		grammarBuilder.append("KW1780 : 'KW' '1780';\n");
+		grammarBuilder.append("KW1781 : 'KW' '1781';\n");
+		grammarBuilder.append("KW1782 : 'KW' '1782';\n");
+		grammarBuilder.append("KW1783 : 'KW' '1783';\n");
+		grammarBuilder.append("KW1784 : 'KW' '1784';\n");
+		grammarBuilder.append("KW1785 : 'KW' '1785';\n");
+		grammarBuilder.append("KW1786 : 'KW' '1786';\n");
+		grammarBuilder.append("KW1787 : 'KW' '1787';\n");
+		grammarBuilder.append("KW1788 : 'KW' '1788';\n");
+		grammarBuilder.append("KW1789 : 'KW' '1789';\n");
+		grammarBuilder.append("KW1790 : 'KW' '1790';\n");
+		grammarBuilder.append("KW1791 : 'KW' '1791';\n");
+		grammarBuilder.append("KW1792 : 'KW' '1792';\n");
+		grammarBuilder.append("KW1793 : 'KW' '1793';\n");
+		grammarBuilder.append("KW1794 : 'KW' '1794';\n");
+		grammarBuilder.append("KW1795 : 'KW' '1795';\n");
+		grammarBuilder.append("KW1796 : 'KW' '1796';\n");
+		grammarBuilder.append("KW1797 : 'KW' '1797';\n");
+		grammarBuilder.append("KW1798 : 'KW' '1798';\n");
+		grammarBuilder.append("KW1799 : 'KW' '1799';\n");
+		grammarBuilder.append("KW1800 : 'KW' '1800';\n");
+		grammarBuilder.append("KW1801 : 'KW' '1801';\n");
+		grammarBuilder.append("KW1802 : 'KW' '1802';\n");
+		grammarBuilder.append("KW1803 : 'KW' '1803';\n");
+		grammarBuilder.append("KW1804 : 'KW' '1804';\n");
+		grammarBuilder.append("KW1805 : 'KW' '1805';\n");
+		grammarBuilder.append("KW1806 : 'KW' '1806';\n");
+		grammarBuilder.append("KW1807 : 'KW' '1807';\n");
+		grammarBuilder.append("KW1808 : 'KW' '1808';\n");
+		grammarBuilder.append("KW1809 : 'KW' '1809';\n");
+		grammarBuilder.append("KW1810 : 'KW' '1810';\n");
+		grammarBuilder.append("KW1811 : 'KW' '1811';\n");
+		grammarBuilder.append("KW1812 : 'KW' '1812';\n");
+		grammarBuilder.append("KW1813 : 'KW' '1813';\n");
+		grammarBuilder.append("KW1814 : 'KW' '1814';\n");
+		grammarBuilder.append("KW1815 : 'KW' '1815';\n");
+		grammarBuilder.append("KW1816 : 'KW' '1816';\n");
+		grammarBuilder.append("KW1817 : 'KW' '1817';\n");
+		grammarBuilder.append("KW1818 : 'KW' '1818';\n");
+		grammarBuilder.append("KW1819 : 'KW' '1819';\n");
+		grammarBuilder.append("KW1820 : 'KW' '1820';\n");
+		grammarBuilder.append("KW1821 : 'KW' '1821';\n");
+		grammarBuilder.append("KW1822 : 'KW' '1822';\n");
+		grammarBuilder.append("KW1823 : 'KW' '1823';\n");
+		grammarBuilder.append("KW1824 : 'KW' '1824';\n");
+		grammarBuilder.append("KW1825 : 'KW' '1825';\n");
+		grammarBuilder.append("KW1826 : 'KW' '1826';\n");
+		grammarBuilder.append("KW1827 : 'KW' '1827';\n");
+		grammarBuilder.append("KW1828 : 'KW' '1828';\n");
+		grammarBuilder.append("KW1829 : 'KW' '1829';\n");
+		grammarBuilder.append("KW1830 : 'KW' '1830';\n");
+		grammarBuilder.append("KW1831 : 'KW' '1831';\n");
+		grammarBuilder.append("KW1832 : 'KW' '1832';\n");
+		grammarBuilder.append("KW1833 : 'KW' '1833';\n");
+		grammarBuilder.append("KW1834 : 'KW' '1834';\n");
+		grammarBuilder.append("KW1835 : 'KW' '1835';\n");
+		grammarBuilder.append("KW1836 : 'KW' '1836';\n");
+		grammarBuilder.append("KW1837 : 'KW' '1837';\n");
+		grammarBuilder.append("KW1838 : 'KW' '1838';\n");
+		grammarBuilder.append("KW1839 : 'KW' '1839';\n");
+		grammarBuilder.append("KW1840 : 'KW' '1840';\n");
+		grammarBuilder.append("KW1841 : 'KW' '1841';\n");
+		grammarBuilder.append("KW1842 : 'KW' '1842';\n");
+		grammarBuilder.append("KW1843 : 'KW' '1843';\n");
+		grammarBuilder.append("KW1844 : 'KW' '1844';\n");
+		grammarBuilder.append("KW1845 : 'KW' '1845';\n");
+		grammarBuilder.append("KW1846 : 'KW' '1846';\n");
+		grammarBuilder.append("KW1847 : 'KW' '1847';\n");
+		grammarBuilder.append("KW1848 : 'KW' '1848';\n");
+		grammarBuilder.append("KW1849 : 'KW' '1849';\n");
+		grammarBuilder.append("KW1850 : 'KW' '1850';\n");
+		grammarBuilder.append("KW1851 : 'KW' '1851';\n");
+		grammarBuilder.append("KW1852 : 'KW' '1852';\n");
+		grammarBuilder.append("KW1853 : 'KW' '1853';\n");
+		grammarBuilder.append("KW1854 : 'KW' '1854';\n");
+		grammarBuilder.append("KW1855 : 'KW' '1855';\n");
+		grammarBuilder.append("KW1856 : 'KW' '1856';\n");
+		grammarBuilder.append("KW1857 : 'KW' '1857';\n");
+		grammarBuilder.append("KW1858 : 'KW' '1858';\n");
+		grammarBuilder.append("KW1859 : 'KW' '1859';\n");
+		grammarBuilder.append("KW1860 : 'KW' '1860';\n");
+		grammarBuilder.append("KW1861 : 'KW' '1861';\n");
+		grammarBuilder.append("KW1862 : 'KW' '1862';\n");
+		grammarBuilder.append("KW1863 : 'KW' '1863';\n");
+		grammarBuilder.append("KW1864 : 'KW' '1864';\n");
+		grammarBuilder.append("KW1865 : 'KW' '1865';\n");
+		grammarBuilder.append("KW1866 : 'KW' '1866';\n");
+		grammarBuilder.append("KW1867 : 'KW' '1867';\n");
+		grammarBuilder.append("KW1868 : 'KW' '1868';\n");
+		grammarBuilder.append("KW1869 : 'KW' '1869';\n");
+		grammarBuilder.append("KW1870 : 'KW' '1870';\n");
+		grammarBuilder.append("KW1871 : 'KW' '1871';\n");
+		grammarBuilder.append("KW1872 : 'KW' '1872';\n");
+		grammarBuilder.append("KW1873 : 'KW' '1873';\n");
+		grammarBuilder.append("KW1874 : 'KW' '1874';\n");
+		grammarBuilder.append("KW1875 : 'KW' '1875';\n");
+		grammarBuilder.append("KW1876 : 'KW' '1876';\n");
+		grammarBuilder.append("KW1877 : 'KW' '1877';\n");
+		grammarBuilder.append("KW1878 : 'KW' '1878';\n");
+		grammarBuilder.append("KW1879 : 'KW' '1879';\n");
+		grammarBuilder.append("KW1880 : 'KW' '1880';\n");
+		grammarBuilder.append("KW1881 : 'KW' '1881';\n");
+		grammarBuilder.append("KW1882 : 'KW' '1882';\n");
+		grammarBuilder.append("KW1883 : 'KW' '1883';\n");
+		grammarBuilder.append("KW1884 : 'KW' '1884';\n");
+		grammarBuilder.append("KW1885 : 'KW' '1885';\n");
+		grammarBuilder.append("KW1886 : 'KW' '1886';\n");
+		grammarBuilder.append("KW1887 : 'KW' '1887';\n");
+		grammarBuilder.append("KW1888 : 'KW' '1888';\n");
+		grammarBuilder.append("KW1889 : 'KW' '1889';\n");
+		grammarBuilder.append("KW1890 : 'KW' '1890';\n");
+		grammarBuilder.append("KW1891 : 'KW' '1891';\n");
+		grammarBuilder.append("KW1892 : 'KW' '1892';\n");
+		grammarBuilder.append("KW1893 : 'KW' '1893';\n");
+		grammarBuilder.append("KW1894 : 'KW' '1894';\n");
+		grammarBuilder.append("KW1895 : 'KW' '1895';\n");
+		grammarBuilder.append("KW1896 : 'KW' '1896';\n");
+		grammarBuilder.append("KW1897 : 'KW' '1897';\n");
+		grammarBuilder.append("KW1898 : 'KW' '1898';\n");
+		grammarBuilder.append("KW1899 : 'KW' '1899';\n");
+		grammarBuilder.append("KW1900 : 'KW' '1900';\n");
+		grammarBuilder.append("KW1901 : 'KW' '1901';\n");
+		grammarBuilder.append("KW1902 : 'KW' '1902';\n");
+		grammarBuilder.append("KW1903 : 'KW' '1903';\n");
+		grammarBuilder.append("KW1904 : 'KW' '1904';\n");
+		grammarBuilder.append("KW1905 : 'KW' '1905';\n");
+		grammarBuilder.append("KW1906 : 'KW' '1906';\n");
+		grammarBuilder.append("KW1907 : 'KW' '1907';\n");
+		grammarBuilder.append("KW1908 : 'KW' '1908';\n");
+		grammarBuilder.append("KW1909 : 'KW' '1909';\n");
+		grammarBuilder.append("KW1910 : 'KW' '1910';\n");
+		grammarBuilder.append("KW1911 : 'KW' '1911';\n");
+		grammarBuilder.append("KW1912 : 'KW' '1912';\n");
+		grammarBuilder.append("KW1913 : 'KW' '1913';\n");
+		grammarBuilder.append("KW1914 : 'KW' '1914';\n");
+		grammarBuilder.append("KW1915 : 'KW' '1915';\n");
+		grammarBuilder.append("KW1916 : 'KW' '1916';\n");
+		grammarBuilder.append("KW1917 : 'KW' '1917';\n");
+		grammarBuilder.append("KW1918 : 'KW' '1918';\n");
+		grammarBuilder.append("KW1919 : 'KW' '1919';\n");
+		grammarBuilder.append("KW1920 : 'KW' '1920';\n");
+		grammarBuilder.append("KW1921 : 'KW' '1921';\n");
+		grammarBuilder.append("KW1922 : 'KW' '1922';\n");
+		grammarBuilder.append("KW1923 : 'KW' '1923';\n");
+		grammarBuilder.append("KW1924 : 'KW' '1924';\n");
+		grammarBuilder.append("KW1925 : 'KW' '1925';\n");
+		grammarBuilder.append("KW1926 : 'KW' '1926';\n");
+		grammarBuilder.append("KW1927 : 'KW' '1927';\n");
+		grammarBuilder.append("KW1928 : 'KW' '1928';\n");
+		grammarBuilder.append("KW1929 : 'KW' '1929';\n");
+		grammarBuilder.append("KW1930 : 'KW' '1930';\n");
+		grammarBuilder.append("KW1931 : 'KW' '1931';\n");
+		grammarBuilder.append("KW1932 : 'KW' '1932';\n");
+		grammarBuilder.append("KW1933 : 'KW' '1933';\n");
+		grammarBuilder.append("KW1934 : 'KW' '1934';\n");
+		grammarBuilder.append("KW1935 : 'KW' '1935';\n");
+		grammarBuilder.append("KW1936 : 'KW' '1936';\n");
+		grammarBuilder.append("KW1937 : 'KW' '1937';\n");
+		grammarBuilder.append("KW1938 : 'KW' '1938';\n");
+		grammarBuilder.append("KW1939 : 'KW' '1939';\n");
+		grammarBuilder.append("KW1940 : 'KW' '1940';\n");
+		grammarBuilder.append("KW1941 : 'KW' '1941';\n");
+		grammarBuilder.append("KW1942 : 'KW' '1942';\n");
+		grammarBuilder.append("KW1943 : 'KW' '1943';\n");
+		grammarBuilder.append("KW1944 : 'KW' '1944';\n");
+		grammarBuilder.append("KW1945 : 'KW' '1945';\n");
+		grammarBuilder.append("KW1946 : 'KW' '1946';\n");
+		grammarBuilder.append("KW1947 : 'KW' '1947';\n");
+		grammarBuilder.append("KW1948 : 'KW' '1948';\n");
+		grammarBuilder.append("KW1949 : 'KW' '1949';\n");
+		grammarBuilder.append("KW1950 : 'KW' '1950';\n");
+		grammarBuilder.append("KW1951 : 'KW' '1951';\n");
+		grammarBuilder.append("KW1952 : 'KW' '1952';\n");
+		grammarBuilder.append("KW1953 : 'KW' '1953';\n");
+		grammarBuilder.append("KW1954 : 'KW' '1954';\n");
+		grammarBuilder.append("KW1955 : 'KW' '1955';\n");
+		grammarBuilder.append("KW1956 : 'KW' '1956';\n");
+		grammarBuilder.append("KW1957 : 'KW' '1957';\n");
+		grammarBuilder.append("KW1958 : 'KW' '1958';\n");
+		grammarBuilder.append("KW1959 : 'KW' '1959';\n");
+		grammarBuilder.append("KW1960 : 'KW' '1960';\n");
+		grammarBuilder.append("KW1961 : 'KW' '1961';\n");
+		grammarBuilder.append("KW1962 : 'KW' '1962';\n");
+		grammarBuilder.append("KW1963 : 'KW' '1963';\n");
+		grammarBuilder.append("KW1964 : 'KW' '1964';\n");
+		grammarBuilder.append("KW1965 : 'KW' '1965';\n");
+		grammarBuilder.append("KW1966 : 'KW' '1966';\n");
+		grammarBuilder.append("KW1967 : 'KW' '1967';\n");
+		grammarBuilder.append("KW1968 : 'KW' '1968';\n");
+		grammarBuilder.append("KW1969 : 'KW' '1969';\n");
+		grammarBuilder.append("KW1970 : 'KW' '1970';\n");
+		grammarBuilder.append("KW1971 : 'KW' '1971';\n");
+		grammarBuilder.append("KW1972 : 'KW' '1972';\n");
+		grammarBuilder.append("KW1973 : 'KW' '1973';\n");
+		grammarBuilder.append("KW1974 : 'KW' '1974';\n");
+		grammarBuilder.append("KW1975 : 'KW' '1975';\n");
+		grammarBuilder.append("KW1976 : 'KW' '1976';\n");
+		grammarBuilder.append("KW1977 : 'KW' '1977';\n");
+		grammarBuilder.append("KW1978 : 'KW' '1978';\n");
+		grammarBuilder.append("KW1979 : 'KW' '1979';\n");
+		grammarBuilder.append("KW1980 : 'KW' '1980';\n");
+		grammarBuilder.append("KW1981 : 'KW' '1981';\n");
+		grammarBuilder.append("KW1982 : 'KW' '1982';\n");
+		grammarBuilder.append("KW1983 : 'KW' '1983';\n");
+		grammarBuilder.append("KW1984 : 'KW' '1984';\n");
+		grammarBuilder.append("KW1985 : 'KW' '1985';\n");
+		grammarBuilder.append("KW1986 : 'KW' '1986';\n");
+		grammarBuilder.append("KW1987 : 'KW' '1987';\n");
+		grammarBuilder.append("KW1988 : 'KW' '1988';\n");
+		grammarBuilder.append("KW1989 : 'KW' '1989';\n");
+		grammarBuilder.append("KW1990 : 'KW' '1990';\n");
+		grammarBuilder.append("KW1991 : 'KW' '1991';\n");
+		grammarBuilder.append("KW1992 : 'KW' '1992';\n");
+		grammarBuilder.append("KW1993 : 'KW' '1993';\n");
+		grammarBuilder.append("KW1994 : 'KW' '1994';\n");
+		grammarBuilder.append("KW1995 : 'KW' '1995';\n");
+		grammarBuilder.append("KW1996 : 'KW' '1996';\n");
+		grammarBuilder.append("KW1997 : 'KW' '1997';\n");
+		grammarBuilder.append("KW1998 : 'KW' '1998';\n");
+		grammarBuilder.append("KW1999 : 'KW' '1999';\n");
+		grammarBuilder.append("KW2000 : 'KW' '2000';\n");
+		grammarBuilder.append("KW2001 : 'KW' '2001';\n");
+		grammarBuilder.append("KW2002 : 'KW' '2002';\n");
+		grammarBuilder.append("KW2003 : 'KW' '2003';\n");
+		grammarBuilder.append("KW2004 : 'KW' '2004';\n");
+		grammarBuilder.append("KW2005 : 'KW' '2005';\n");
+		grammarBuilder.append("KW2006 : 'KW' '2006';\n");
+		grammarBuilder.append("KW2007 : 'KW' '2007';\n");
+		grammarBuilder.append("KW2008 : 'KW' '2008';\n");
+		grammarBuilder.append("KW2009 : 'KW' '2009';\n");
+		grammarBuilder.append("KW2010 : 'KW' '2010';\n");
+		grammarBuilder.append("KW2011 : 'KW' '2011';\n");
+		grammarBuilder.append("KW2012 : 'KW' '2012';\n");
+		grammarBuilder.append("KW2013 : 'KW' '2013';\n");
+		grammarBuilder.append("KW2014 : 'KW' '2014';\n");
+		grammarBuilder.append("KW2015 : 'KW' '2015';\n");
+		grammarBuilder.append("KW2016 : 'KW' '2016';\n");
+		grammarBuilder.append("KW2017 : 'KW' '2017';\n");
+		grammarBuilder.append("KW2018 : 'KW' '2018';\n");
+		grammarBuilder.append("KW2019 : 'KW' '2019';\n");
+		grammarBuilder.append("KW2020 : 'KW' '2020';\n");
+		grammarBuilder.append("KW2021 : 'KW' '2021';\n");
+		grammarBuilder.append("KW2022 : 'KW' '2022';\n");
+		grammarBuilder.append("KW2023 : 'KW' '2023';\n");
+		grammarBuilder.append("KW2024 : 'KW' '2024';\n");
+		grammarBuilder.append("KW2025 : 'KW' '2025';\n");
+		grammarBuilder.append("KW2026 : 'KW' '2026';\n");
+		grammarBuilder.append("KW2027 : 'KW' '2027';\n");
+		grammarBuilder.append("KW2028 : 'KW' '2028';\n");
+		grammarBuilder.append("KW2029 : 'KW' '2029';\n");
+		grammarBuilder.append("KW2030 : 'KW' '2030';\n");
+		grammarBuilder.append("KW2031 : 'KW' '2031';\n");
+		grammarBuilder.append("KW2032 : 'KW' '2032';\n");
+		grammarBuilder.append("KW2033 : 'KW' '2033';\n");
+		grammarBuilder.append("KW2034 : 'KW' '2034';\n");
+		grammarBuilder.append("KW2035 : 'KW' '2035';\n");
+		grammarBuilder.append("KW2036 : 'KW' '2036';\n");
+		grammarBuilder.append("KW2037 : 'KW' '2037';\n");
+		grammarBuilder.append("KW2038 : 'KW' '2038';\n");
+		grammarBuilder.append("KW2039 : 'KW' '2039';\n");
+		grammarBuilder.append("KW2040 : 'KW' '2040';\n");
+		grammarBuilder.append("KW2041 : 'KW' '2041';\n");
+		grammarBuilder.append("KW2042 : 'KW' '2042';\n");
+		grammarBuilder.append("KW2043 : 'KW' '2043';\n");
+		grammarBuilder.append("KW2044 : 'KW' '2044';\n");
+		grammarBuilder.append("KW2045 : 'KW' '2045';\n");
+		grammarBuilder.append("KW2046 : 'KW' '2046';\n");
+		grammarBuilder.append("KW2047 : 'KW' '2047';\n");
+		grammarBuilder.append("KW2048 : 'KW' '2048';\n");
+		grammarBuilder.append("KW2049 : 'KW' '2049';\n");
+		grammarBuilder.append("KW2050 : 'KW' '2050';\n");
+		grammarBuilder.append("KW2051 : 'KW' '2051';\n");
+		grammarBuilder.append("KW2052 : 'KW' '2052';\n");
+		grammarBuilder.append("KW2053 : 'KW' '2053';\n");
+		grammarBuilder.append("KW2054 : 'KW' '2054';\n");
+		grammarBuilder.append("KW2055 : 'KW' '2055';\n");
+		grammarBuilder.append("KW2056 : 'KW' '2056';\n");
+		grammarBuilder.append("KW2057 : 'KW' '2057';\n");
+		grammarBuilder.append("KW2058 : 'KW' '2058';\n");
+		grammarBuilder.append("KW2059 : 'KW' '2059';\n");
+		grammarBuilder.append("KW2060 : 'KW' '2060';\n");
+		grammarBuilder.append("KW2061 : 'KW' '2061';\n");
+		grammarBuilder.append("KW2062 : 'KW' '2062';\n");
+		grammarBuilder.append("KW2063 : 'KW' '2063';\n");
+		grammarBuilder.append("KW2064 : 'KW' '2064';\n");
+		grammarBuilder.append("KW2065 : 'KW' '2065';\n");
+		grammarBuilder.append("KW2066 : 'KW' '2066';\n");
+		grammarBuilder.append("KW2067 : 'KW' '2067';\n");
+		grammarBuilder.append("KW2068 : 'KW' '2068';\n");
+		grammarBuilder.append("KW2069 : 'KW' '2069';\n");
+		grammarBuilder.append("KW2070 : 'KW' '2070';\n");
+		grammarBuilder.append("KW2071 : 'KW' '2071';\n");
+		grammarBuilder.append("KW2072 : 'KW' '2072';\n");
+		grammarBuilder.append("KW2073 : 'KW' '2073';\n");
+		grammarBuilder.append("KW2074 : 'KW' '2074';\n");
+		grammarBuilder.append("KW2075 : 'KW' '2075';\n");
+		grammarBuilder.append("KW2076 : 'KW' '2076';\n");
+		grammarBuilder.append("KW2077 : 'KW' '2077';\n");
+		grammarBuilder.append("KW2078 : 'KW' '2078';\n");
+		grammarBuilder.append("KW2079 : 'KW' '2079';\n");
+		grammarBuilder.append("KW2080 : 'KW' '2080';\n");
+		grammarBuilder.append("KW2081 : 'KW' '2081';\n");
+		grammarBuilder.append("KW2082 : 'KW' '2082';\n");
+		grammarBuilder.append("KW2083 : 'KW' '2083';\n");
+		grammarBuilder.append("KW2084 : 'KW' '2084';\n");
+		grammarBuilder.append("KW2085 : 'KW' '2085';\n");
+		grammarBuilder.append("KW2086 : 'KW' '2086';\n");
+		grammarBuilder.append("KW2087 : 'KW' '2087';\n");
+		grammarBuilder.append("KW2088 : 'KW' '2088';\n");
+		grammarBuilder.append("KW2089 : 'KW' '2089';\n");
+		grammarBuilder.append("KW2090 : 'KW' '2090';\n");
+		grammarBuilder.append("KW2091 : 'KW' '2091';\n");
+		grammarBuilder.append("KW2092 : 'KW' '2092';\n");
+		grammarBuilder.append("KW2093 : 'KW' '2093';\n");
+		grammarBuilder.append("KW2094 : 'KW' '2094';\n");
+		grammarBuilder.append("KW2095 : 'KW' '2095';\n");
+		grammarBuilder.append("KW2096 : 'KW' '2096';\n");
+		grammarBuilder.append("KW2097 : 'KW' '2097';\n");
+		grammarBuilder.append("KW2098 : 'KW' '2098';\n");
+		grammarBuilder.append("KW2099 : 'KW' '2099';\n");
+		grammarBuilder.append("KW2100 : 'KW' '2100';\n");
+		grammarBuilder.append("KW2101 : 'KW' '2101';\n");
+		grammarBuilder.append("KW2102 : 'KW' '2102';\n");
+		grammarBuilder.append("KW2103 : 'KW' '2103';\n");
+		grammarBuilder.append("KW2104 : 'KW' '2104';\n");
+		grammarBuilder.append("KW2105 : 'KW' '2105';\n");
+		grammarBuilder.append("KW2106 : 'KW' '2106';\n");
+		grammarBuilder.append("KW2107 : 'KW' '2107';\n");
+		grammarBuilder.append("KW2108 : 'KW' '2108';\n");
+		grammarBuilder.append("KW2109 : 'KW' '2109';\n");
+		grammarBuilder.append("KW2110 : 'KW' '2110';\n");
+		grammarBuilder.append("KW2111 : 'KW' '2111';\n");
+		grammarBuilder.append("KW2112 : 'KW' '2112';\n");
+		grammarBuilder.append("KW2113 : 'KW' '2113';\n");
+		grammarBuilder.append("KW2114 : 'KW' '2114';\n");
+		grammarBuilder.append("KW2115 : 'KW' '2115';\n");
+		grammarBuilder.append("KW2116 : 'KW' '2116';\n");
+		grammarBuilder.append("KW2117 : 'KW' '2117';\n");
+		grammarBuilder.append("KW2118 : 'KW' '2118';\n");
+		grammarBuilder.append("KW2119 : 'KW' '2119';\n");
+		grammarBuilder.append("KW2120 : 'KW' '2120';\n");
+		grammarBuilder.append("KW2121 : 'KW' '2121';\n");
+		grammarBuilder.append("KW2122 : 'KW' '2122';\n");
+		grammarBuilder.append("KW2123 : 'KW' '2123';\n");
+		grammarBuilder.append("KW2124 : 'KW' '2124';\n");
+		grammarBuilder.append("KW2125 : 'KW' '2125';\n");
+		grammarBuilder.append("KW2126 : 'KW' '2126';\n");
+		grammarBuilder.append("KW2127 : 'KW' '2127';\n");
+		grammarBuilder.append("KW2128 : 'KW' '2128';\n");
+		grammarBuilder.append("KW2129 : 'KW' '2129';\n");
+		grammarBuilder.append("KW2130 : 'KW' '2130';\n");
+		grammarBuilder.append("KW2131 : 'KW' '2131';\n");
+		grammarBuilder.append("KW2132 : 'KW' '2132';\n");
+		grammarBuilder.append("KW2133 : 'KW' '2133';\n");
+		grammarBuilder.append("KW2134 : 'KW' '2134';\n");
+		grammarBuilder.append("KW2135 : 'KW' '2135';\n");
+		grammarBuilder.append("KW2136 : 'KW' '2136';\n");
+		grammarBuilder.append("KW2137 : 'KW' '2137';\n");
+		grammarBuilder.append("KW2138 : 'KW' '2138';\n");
+		grammarBuilder.append("KW2139 : 'KW' '2139';\n");
+		grammarBuilder.append("KW2140 : 'KW' '2140';\n");
+		grammarBuilder.append("KW2141 : 'KW' '2141';\n");
+		grammarBuilder.append("KW2142 : 'KW' '2142';\n");
+		grammarBuilder.append("KW2143 : 'KW' '2143';\n");
+		grammarBuilder.append("KW2144 : 'KW' '2144';\n");
+		grammarBuilder.append("KW2145 : 'KW' '2145';\n");
+		grammarBuilder.append("KW2146 : 'KW' '2146';\n");
+		grammarBuilder.append("KW2147 : 'KW' '2147';\n");
+		grammarBuilder.append("KW2148 : 'KW' '2148';\n");
+		grammarBuilder.append("KW2149 : 'KW' '2149';\n");
+		grammarBuilder.append("KW2150 : 'KW' '2150';\n");
+		grammarBuilder.append("KW2151 : 'KW' '2151';\n");
+		grammarBuilder.append("KW2152 : 'KW' '2152';\n");
+		grammarBuilder.append("KW2153 : 'KW' '2153';\n");
+		grammarBuilder.append("KW2154 : 'KW' '2154';\n");
+		grammarBuilder.append("KW2155 : 'KW' '2155';\n");
+		grammarBuilder.append("KW2156 : 'KW' '2156';\n");
+		grammarBuilder.append("KW2157 : 'KW' '2157';\n");
+		grammarBuilder.append("KW2158 : 'KW' '2158';\n");
+		grammarBuilder.append("KW2159 : 'KW' '2159';\n");
+		grammarBuilder.append("KW2160 : 'KW' '2160';\n");
+		grammarBuilder.append("KW2161 : 'KW' '2161';\n");
+		grammarBuilder.append("KW2162 : 'KW' '2162';\n");
+		grammarBuilder.append("KW2163 : 'KW' '2163';\n");
+		grammarBuilder.append("KW2164 : 'KW' '2164';\n");
+		grammarBuilder.append("KW2165 : 'KW' '2165';\n");
+		grammarBuilder.append("KW2166 : 'KW' '2166';\n");
+		grammarBuilder.append("KW2167 : 'KW' '2167';\n");
+		grammarBuilder.append("KW2168 : 'KW' '2168';\n");
+		grammarBuilder.append("KW2169 : 'KW' '2169';\n");
+		grammarBuilder.append("KW2170 : 'KW' '2170';\n");
+		grammarBuilder.append("KW2171 : 'KW' '2171';\n");
+		grammarBuilder.append("KW2172 : 'KW' '2172';\n");
+		grammarBuilder.append("KW2173 : 'KW' '2173';\n");
+		grammarBuilder.append("KW2174 : 'KW' '2174';\n");
+		grammarBuilder.append("KW2175 : 'KW' '2175';\n");
+		grammarBuilder.append("KW2176 : 'KW' '2176';\n");
+		grammarBuilder.append("KW2177 : 'KW' '2177';\n");
+		grammarBuilder.append("KW2178 : 'KW' '2178';\n");
+		grammarBuilder.append("KW2179 : 'KW' '2179';\n");
+		grammarBuilder.append("KW2180 : 'KW' '2180';\n");
+		grammarBuilder.append("KW2181 : 'KW' '2181';\n");
+		grammarBuilder.append("KW2182 : 'KW' '2182';\n");
+		grammarBuilder.append("KW2183 : 'KW' '2183';\n");
+		grammarBuilder.append("KW2184 : 'KW' '2184';\n");
+		grammarBuilder.append("KW2185 : 'KW' '2185';\n");
+		grammarBuilder.append("KW2186 : 'KW' '2186';\n");
+		grammarBuilder.append("KW2187 : 'KW' '2187';\n");
+		grammarBuilder.append("KW2188 : 'KW' '2188';\n");
+		grammarBuilder.append("KW2189 : 'KW' '2189';\n");
+		grammarBuilder.append("KW2190 : 'KW' '2190';\n");
+		grammarBuilder.append("KW2191 : 'KW' '2191';\n");
+		grammarBuilder.append("KW2192 : 'KW' '2192';\n");
+		grammarBuilder.append("KW2193 : 'KW' '2193';\n");
+		grammarBuilder.append("KW2194 : 'KW' '2194';\n");
+		grammarBuilder.append("KW2195 : 'KW' '2195';\n");
+		grammarBuilder.append("KW2196 : 'KW' '2196';\n");
+		grammarBuilder.append("KW2197 : 'KW' '2197';\n");
+		grammarBuilder.append("KW2198 : 'KW' '2198';\n");
+		grammarBuilder.append("KW2199 : 'KW' '2199';\n");
+		grammarBuilder.append("KW2200 : 'KW' '2200';\n");
+		grammarBuilder.append("KW2201 : 'KW' '2201';\n");
+		grammarBuilder.append("KW2202 : 'KW' '2202';\n");
+		grammarBuilder.append("KW2203 : 'KW' '2203';\n");
+		grammarBuilder.append("KW2204 : 'KW' '2204';\n");
+		grammarBuilder.append("KW2205 : 'KW' '2205';\n");
+		grammarBuilder.append("KW2206 : 'KW' '2206';\n");
+		grammarBuilder.append("KW2207 : 'KW' '2207';\n");
+		grammarBuilder.append("KW2208 : 'KW' '2208';\n");
+		grammarBuilder.append("KW2209 : 'KW' '2209';\n");
+		grammarBuilder.append("KW2210 : 'KW' '2210';\n");
+		grammarBuilder.append("KW2211 : 'KW' '2211';\n");
+		grammarBuilder.append("KW2212 : 'KW' '2212';\n");
+		grammarBuilder.append("KW2213 : 'KW' '2213';\n");
+		grammarBuilder.append("KW2214 : 'KW' '2214';\n");
+		grammarBuilder.append("KW2215 : 'KW' '2215';\n");
+		grammarBuilder.append("KW2216 : 'KW' '2216';\n");
+		grammarBuilder.append("KW2217 : 'KW' '2217';\n");
+		grammarBuilder.append("KW2218 : 'KW' '2218';\n");
+		grammarBuilder.append("KW2219 : 'KW' '2219';\n");
+		grammarBuilder.append("KW2220 : 'KW' '2220';\n");
+		grammarBuilder.append("KW2221 : 'KW' '2221';\n");
+		grammarBuilder.append("KW2222 : 'KW' '2222';\n");
+		grammarBuilder.append("KW2223 : 'KW' '2223';\n");
+		grammarBuilder.append("KW2224 : 'KW' '2224';\n");
+		grammarBuilder.append("KW2225 : 'KW' '2225';\n");
+		grammarBuilder.append("KW2226 : 'KW' '2226';\n");
+		grammarBuilder.append("KW2227 : 'KW' '2227';\n");
+		grammarBuilder.append("KW2228 : 'KW' '2228';\n");
+		grammarBuilder.append("KW2229 : 'KW' '2229';\n");
+		grammarBuilder.append("KW2230 : 'KW' '2230';\n");
+		grammarBuilder.append("KW2231 : 'KW' '2231';\n");
+		grammarBuilder.append("KW2232 : 'KW' '2232';\n");
+		grammarBuilder.append("KW2233 : 'KW' '2233';\n");
+		grammarBuilder.append("KW2234 : 'KW' '2234';\n");
+		grammarBuilder.append("KW2235 : 'KW' '2235';\n");
+		grammarBuilder.append("KW2236 : 'KW' '2236';\n");
+		grammarBuilder.append("KW2237 : 'KW' '2237';\n");
+		grammarBuilder.append("KW2238 : 'KW' '2238';\n");
+		grammarBuilder.append("KW2239 : 'KW' '2239';\n");
+		grammarBuilder.append("KW2240 : 'KW' '2240';\n");
+		grammarBuilder.append("KW2241 : 'KW' '2241';\n");
+		grammarBuilder.append("KW2242 : 'KW' '2242';\n");
+		grammarBuilder.append("KW2243 : 'KW' '2243';\n");
+		grammarBuilder.append("KW2244 : 'KW' '2244';\n");
+		grammarBuilder.append("KW2245 : 'KW' '2245';\n");
+		grammarBuilder.append("KW2246 : 'KW' '2246';\n");
+		grammarBuilder.append("KW2247 : 'KW' '2247';\n");
+		grammarBuilder.append("KW2248 : 'KW' '2248';\n");
+		grammarBuilder.append("KW2249 : 'KW' '2249';\n");
+		grammarBuilder.append("KW2250 : 'KW' '2250';\n");
+		grammarBuilder.append("KW2251 : 'KW' '2251';\n");
+		grammarBuilder.append("KW2252 : 'KW' '2252';\n");
+		grammarBuilder.append("KW2253 : 'KW' '2253';\n");
+		grammarBuilder.append("KW2254 : 'KW' '2254';\n");
+		grammarBuilder.append("KW2255 : 'KW' '2255';\n");
+		grammarBuilder.append("KW2256 : 'KW' '2256';\n");
+		grammarBuilder.append("KW2257 : 'KW' '2257';\n");
+		grammarBuilder.append("KW2258 : 'KW' '2258';\n");
+		grammarBuilder.append("KW2259 : 'KW' '2259';\n");
+		grammarBuilder.append("KW2260 : 'KW' '2260';\n");
+		grammarBuilder.append("KW2261 : 'KW' '2261';\n");
+		grammarBuilder.append("KW2262 : 'KW' '2262';\n");
+		grammarBuilder.append("KW2263 : 'KW' '2263';\n");
+		grammarBuilder.append("KW2264 : 'KW' '2264';\n");
+		grammarBuilder.append("KW2265 : 'KW' '2265';\n");
+		grammarBuilder.append("KW2266 : 'KW' '2266';\n");
+		grammarBuilder.append("KW2267 : 'KW' '2267';\n");
+		grammarBuilder.append("KW2268 : 'KW' '2268';\n");
+		grammarBuilder.append("KW2269 : 'KW' '2269';\n");
+		grammarBuilder.append("KW2270 : 'KW' '2270';\n");
+		grammarBuilder.append("KW2271 : 'KW' '2271';\n");
+		grammarBuilder.append("KW2272 : 'KW' '2272';\n");
+		grammarBuilder.append("KW2273 : 'KW' '2273';\n");
+		grammarBuilder.append("KW2274 : 'KW' '2274';\n");
+		grammarBuilder.append("KW2275 : 'KW' '2275';\n");
+		grammarBuilder.append("KW2276 : 'KW' '2276';\n");
+		grammarBuilder.append("KW2277 : 'KW' '2277';\n");
+		grammarBuilder.append("KW2278 : 'KW' '2278';\n");
+		grammarBuilder.append("KW2279 : 'KW' '2279';\n");
+		grammarBuilder.append("KW2280 : 'KW' '2280';\n");
+		grammarBuilder.append("KW2281 : 'KW' '2281';\n");
+		grammarBuilder.append("KW2282 : 'KW' '2282';\n");
+		grammarBuilder.append("KW2283 : 'KW' '2283';\n");
+		grammarBuilder.append("KW2284 : 'KW' '2284';\n");
+		grammarBuilder.append("KW2285 : 'KW' '2285';\n");
+		grammarBuilder.append("KW2286 : 'KW' '2286';\n");
+		grammarBuilder.append("KW2287 : 'KW' '2287';\n");
+		grammarBuilder.append("KW2288 : 'KW' '2288';\n");
+		grammarBuilder.append("KW2289 : 'KW' '2289';\n");
+		grammarBuilder.append("KW2290 : 'KW' '2290';\n");
+		grammarBuilder.append("KW2291 : 'KW' '2291';\n");
+		grammarBuilder.append("KW2292 : 'KW' '2292';\n");
+		grammarBuilder.append("KW2293 : 'KW' '2293';\n");
+		grammarBuilder.append("KW2294 : 'KW' '2294';\n");
+		grammarBuilder.append("KW2295 : 'KW' '2295';\n");
+		grammarBuilder.append("KW2296 : 'KW' '2296';\n");
+		grammarBuilder.append("KW2297 : 'KW' '2297';\n");
+		grammarBuilder.append("KW2298 : 'KW' '2298';\n");
+		grammarBuilder.append("KW2299 : 'KW' '2299';\n");
+		grammarBuilder.append("KW2300 : 'KW' '2300';\n");
+		grammarBuilder.append("KW2301 : 'KW' '2301';\n");
+		grammarBuilder.append("KW2302 : 'KW' '2302';\n");
+		grammarBuilder.append("KW2303 : 'KW' '2303';\n");
+		grammarBuilder.append("KW2304 : 'KW' '2304';\n");
+		grammarBuilder.append("KW2305 : 'KW' '2305';\n");
+		grammarBuilder.append("KW2306 : 'KW' '2306';\n");
+		grammarBuilder.append("KW2307 : 'KW' '2307';\n");
+		grammarBuilder.append("KW2308 : 'KW' '2308';\n");
+		grammarBuilder.append("KW2309 : 'KW' '2309';\n");
+		grammarBuilder.append("KW2310 : 'KW' '2310';\n");
+		grammarBuilder.append("KW2311 : 'KW' '2311';\n");
+		grammarBuilder.append("KW2312 : 'KW' '2312';\n");
+		grammarBuilder.append("KW2313 : 'KW' '2313';\n");
+		grammarBuilder.append("KW2314 : 'KW' '2314';\n");
+		grammarBuilder.append("KW2315 : 'KW' '2315';\n");
+		grammarBuilder.append("KW2316 : 'KW' '2316';\n");
+		grammarBuilder.append("KW2317 : 'KW' '2317';\n");
+		grammarBuilder.append("KW2318 : 'KW' '2318';\n");
+		grammarBuilder.append("KW2319 : 'KW' '2319';\n");
+		grammarBuilder.append("KW2320 : 'KW' '2320';\n");
+		grammarBuilder.append("KW2321 : 'KW' '2321';\n");
+		grammarBuilder.append("KW2322 : 'KW' '2322';\n");
+		grammarBuilder.append("KW2323 : 'KW' '2323';\n");
+		grammarBuilder.append("KW2324 : 'KW' '2324';\n");
+		grammarBuilder.append("KW2325 : 'KW' '2325';\n");
+		grammarBuilder.append("KW2326 : 'KW' '2326';\n");
+		grammarBuilder.append("KW2327 : 'KW' '2327';\n");
+		grammarBuilder.append("KW2328 : 'KW' '2328';\n");
+		grammarBuilder.append("KW2329 : 'KW' '2329';\n");
+		grammarBuilder.append("KW2330 : 'KW' '2330';\n");
+		grammarBuilder.append("KW2331 : 'KW' '2331';\n");
+		grammarBuilder.append("KW2332 : 'KW' '2332';\n");
+		grammarBuilder.append("KW2333 : 'KW' '2333';\n");
+		grammarBuilder.append("KW2334 : 'KW' '2334';\n");
+		grammarBuilder.append("KW2335 : 'KW' '2335';\n");
+		grammarBuilder.append("KW2336 : 'KW' '2336';\n");
+		grammarBuilder.append("KW2337 : 'KW' '2337';\n");
+		grammarBuilder.append("KW2338 : 'KW' '2338';\n");
+		grammarBuilder.append("KW2339 : 'KW' '2339';\n");
+		grammarBuilder.append("KW2340 : 'KW' '2340';\n");
+		grammarBuilder.append("KW2341 : 'KW' '2341';\n");
+		grammarBuilder.append("KW2342 : 'KW' '2342';\n");
+		grammarBuilder.append("KW2343 : 'KW' '2343';\n");
+		grammarBuilder.append("KW2344 : 'KW' '2344';\n");
+		grammarBuilder.append("KW2345 : 'KW' '2345';\n");
+		grammarBuilder.append("KW2346 : 'KW' '2346';\n");
+		grammarBuilder.append("KW2347 : 'KW' '2347';\n");
+		grammarBuilder.append("KW2348 : 'KW' '2348';\n");
+		grammarBuilder.append("KW2349 : 'KW' '2349';\n");
+		grammarBuilder.append("KW2350 : 'KW' '2350';\n");
+		grammarBuilder.append("KW2351 : 'KW' '2351';\n");
+		grammarBuilder.append("KW2352 : 'KW' '2352';\n");
+		grammarBuilder.append("KW2353 : 'KW' '2353';\n");
+		grammarBuilder.append("KW2354 : 'KW' '2354';\n");
+		grammarBuilder.append("KW2355 : 'KW' '2355';\n");
+		grammarBuilder.append("KW2356 : 'KW' '2356';\n");
+		grammarBuilder.append("KW2357 : 'KW' '2357';\n");
+		grammarBuilder.append("KW2358 : 'KW' '2358';\n");
+		grammarBuilder.append("KW2359 : 'KW' '2359';\n");
+		grammarBuilder.append("KW2360 : 'KW' '2360';\n");
+		grammarBuilder.append("KW2361 : 'KW' '2361';\n");
+		grammarBuilder.append("KW2362 : 'KW' '2362';\n");
+		grammarBuilder.append("KW2363 : 'KW' '2363';\n");
+		grammarBuilder.append("KW2364 : 'KW' '2364';\n");
+		grammarBuilder.append("KW2365 : 'KW' '2365';\n");
+		grammarBuilder.append("KW2366 : 'KW' '2366';\n");
+		grammarBuilder.append("KW2367 : 'KW' '2367';\n");
+		grammarBuilder.append("KW2368 : 'KW' '2368';\n");
+		grammarBuilder.append("KW2369 : 'KW' '2369';\n");
+		grammarBuilder.append("KW2370 : 'KW' '2370';\n");
+		grammarBuilder.append("KW2371 : 'KW' '2371';\n");
+		grammarBuilder.append("KW2372 : 'KW' '2372';\n");
+		grammarBuilder.append("KW2373 : 'KW' '2373';\n");
+		grammarBuilder.append("KW2374 : 'KW' '2374';\n");
+		grammarBuilder.append("KW2375 : 'KW' '2375';\n");
+		grammarBuilder.append("KW2376 : 'KW' '2376';\n");
+		grammarBuilder.append("KW2377 : 'KW' '2377';\n");
+		grammarBuilder.append("KW2378 : 'KW' '2378';\n");
+		grammarBuilder.append("KW2379 : 'KW' '2379';\n");
+		grammarBuilder.append("KW2380 : 'KW' '2380';\n");
+		grammarBuilder.append("KW2381 : 'KW' '2381';\n");
+		grammarBuilder.append("KW2382 : 'KW' '2382';\n");
+		grammarBuilder.append("KW2383 : 'KW' '2383';\n");
+		grammarBuilder.append("KW2384 : 'KW' '2384';\n");
+		grammarBuilder.append("KW2385 : 'KW' '2385';\n");
+		grammarBuilder.append("KW2386 : 'KW' '2386';\n");
+		grammarBuilder.append("KW2387 : 'KW' '2387';\n");
+		grammarBuilder.append("KW2388 : 'KW' '2388';\n");
+		grammarBuilder.append("KW2389 : 'KW' '2389';\n");
+		grammarBuilder.append("KW2390 : 'KW' '2390';\n");
+		grammarBuilder.append("KW2391 : 'KW' '2391';\n");
+		grammarBuilder.append("KW2392 : 'KW' '2392';\n");
+		grammarBuilder.append("KW2393 : 'KW' '2393';\n");
+		grammarBuilder.append("KW2394 : 'KW' '2394';\n");
+		grammarBuilder.append("KW2395 : 'KW' '2395';\n");
+		grammarBuilder.append("KW2396 : 'KW' '2396';\n");
+		grammarBuilder.append("KW2397 : 'KW' '2397';\n");
+		grammarBuilder.append("KW2398 : 'KW' '2398';\n");
+		grammarBuilder.append("KW2399 : 'KW' '2399';\n");
+		grammarBuilder.append("KW2400 : 'KW' '2400';\n");
+		grammarBuilder.append("KW2401 : 'KW' '2401';\n");
+		grammarBuilder.append("KW2402 : 'KW' '2402';\n");
+		grammarBuilder.append("KW2403 : 'KW' '2403';\n");
+		grammarBuilder.append("KW2404 : 'KW' '2404';\n");
+		grammarBuilder.append("KW2405 : 'KW' '2405';\n");
+		grammarBuilder.append("KW2406 : 'KW' '2406';\n");
+		grammarBuilder.append("KW2407 : 'KW' '2407';\n");
+		grammarBuilder.append("KW2408 : 'KW' '2408';\n");
+		grammarBuilder.append("KW2409 : 'KW' '2409';\n");
+		grammarBuilder.append("KW2410 : 'KW' '2410';\n");
+		grammarBuilder.append("KW2411 : 'KW' '2411';\n");
+		grammarBuilder.append("KW2412 : 'KW' '2412';\n");
+		grammarBuilder.append("KW2413 : 'KW' '2413';\n");
+		grammarBuilder.append("KW2414 : 'KW' '2414';\n");
+		grammarBuilder.append("KW2415 : 'KW' '2415';\n");
+		grammarBuilder.append("KW2416 : 'KW' '2416';\n");
+		grammarBuilder.append("KW2417 : 'KW' '2417';\n");
+		grammarBuilder.append("KW2418 : 'KW' '2418';\n");
+		grammarBuilder.append("KW2419 : 'KW' '2419';\n");
+		grammarBuilder.append("KW2420 : 'KW' '2420';\n");
+		grammarBuilder.append("KW2421 : 'KW' '2421';\n");
+		grammarBuilder.append("KW2422 : 'KW' '2422';\n");
+		grammarBuilder.append("KW2423 : 'KW' '2423';\n");
+		grammarBuilder.append("KW2424 : 'KW' '2424';\n");
+		grammarBuilder.append("KW2425 : 'KW' '2425';\n");
+		grammarBuilder.append("KW2426 : 'KW' '2426';\n");
+		grammarBuilder.append("KW2427 : 'KW' '2427';\n");
+		grammarBuilder.append("KW2428 : 'KW' '2428';\n");
+		grammarBuilder.append("KW2429 : 'KW' '2429';\n");
+		grammarBuilder.append("KW2430 : 'KW' '2430';\n");
+		grammarBuilder.append("KW2431 : 'KW' '2431';\n");
+		grammarBuilder.append("KW2432 : 'KW' '2432';\n");
+		grammarBuilder.append("KW2433 : 'KW' '2433';\n");
+		grammarBuilder.append("KW2434 : 'KW' '2434';\n");
+		grammarBuilder.append("KW2435 : 'KW' '2435';\n");
+		grammarBuilder.append("KW2436 : 'KW' '2436';\n");
+		grammarBuilder.append("KW2437 : 'KW' '2437';\n");
+		grammarBuilder.append("KW2438 : 'KW' '2438';\n");
+		grammarBuilder.append("KW2439 : 'KW' '2439';\n");
+		grammarBuilder.append("KW2440 : 'KW' '2440';\n");
+		grammarBuilder.append("KW2441 : 'KW' '2441';\n");
+		grammarBuilder.append("KW2442 : 'KW' '2442';\n");
+		grammarBuilder.append("KW2443 : 'KW' '2443';\n");
+		grammarBuilder.append("KW2444 : 'KW' '2444';\n");
+		grammarBuilder.append("KW2445 : 'KW' '2445';\n");
+		grammarBuilder.append("KW2446 : 'KW' '2446';\n");
+		grammarBuilder.append("KW2447 : 'KW' '2447';\n");
+		grammarBuilder.append("KW2448 : 'KW' '2448';\n");
+		grammarBuilder.append("KW2449 : 'KW' '2449';\n");
+		grammarBuilder.append("KW2450 : 'KW' '2450';\n");
+		grammarBuilder.append("KW2451 : 'KW' '2451';\n");
+		grammarBuilder.append("KW2452 : 'KW' '2452';\n");
+		grammarBuilder.append("KW2453 : 'KW' '2453';\n");
+		grammarBuilder.append("KW2454 : 'KW' '2454';\n");
+		grammarBuilder.append("KW2455 : 'KW' '2455';\n");
+		grammarBuilder.append("KW2456 : 'KW' '2456';\n");
+		grammarBuilder.append("KW2457 : 'KW' '2457';\n");
+		grammarBuilder.append("KW2458 : 'KW' '2458';\n");
+		grammarBuilder.append("KW2459 : 'KW' '2459';\n");
+		grammarBuilder.append("KW2460 : 'KW' '2460';\n");
+		grammarBuilder.append("KW2461 : 'KW' '2461';\n");
+		grammarBuilder.append("KW2462 : 'KW' '2462';\n");
+		grammarBuilder.append("KW2463 : 'KW' '2463';\n");
+		grammarBuilder.append("KW2464 : 'KW' '2464';\n");
+		grammarBuilder.append("KW2465 : 'KW' '2465';\n");
+		grammarBuilder.append("KW2466 : 'KW' '2466';\n");
+		grammarBuilder.append("KW2467 : 'KW' '2467';\n");
+		grammarBuilder.append("KW2468 : 'KW' '2468';\n");
+		grammarBuilder.append("KW2469 : 'KW' '2469';\n");
+		grammarBuilder.append("KW2470 : 'KW' '2470';\n");
+		grammarBuilder.append("KW2471 : 'KW' '2471';\n");
+		grammarBuilder.append("KW2472 : 'KW' '2472';\n");
+		grammarBuilder.append("KW2473 : 'KW' '2473';\n");
+		grammarBuilder.append("KW2474 : 'KW' '2474';\n");
+		grammarBuilder.append("KW2475 : 'KW' '2475';\n");
+		grammarBuilder.append("KW2476 : 'KW' '2476';\n");
+		grammarBuilder.append("KW2477 : 'KW' '2477';\n");
+		grammarBuilder.append("KW2478 : 'KW' '2478';\n");
+		grammarBuilder.append("KW2479 : 'KW' '2479';\n");
+		grammarBuilder.append("KW2480 : 'KW' '2480';\n");
+		grammarBuilder.append("KW2481 : 'KW' '2481';\n");
+		grammarBuilder.append("KW2482 : 'KW' '2482';\n");
+		grammarBuilder.append("KW2483 : 'KW' '2483';\n");
+		grammarBuilder.append("KW2484 : 'KW' '2484';\n");
+		grammarBuilder.append("KW2485 : 'KW' '2485';\n");
+		grammarBuilder.append("KW2486 : 'KW' '2486';\n");
+		grammarBuilder.append("KW2487 : 'KW' '2487';\n");
+		grammarBuilder.append("KW2488 : 'KW' '2488';\n");
+		grammarBuilder.append("KW2489 : 'KW' '2489';\n");
+		grammarBuilder.append("KW2490 : 'KW' '2490';\n");
+		grammarBuilder.append("KW2491 : 'KW' '2491';\n");
+		grammarBuilder.append("KW2492 : 'KW' '2492';\n");
+		grammarBuilder.append("KW2493 : 'KW' '2493';\n");
+		grammarBuilder.append("KW2494 : 'KW' '2494';\n");
+		grammarBuilder.append("KW2495 : 'KW' '2495';\n");
+		grammarBuilder.append("KW2496 : 'KW' '2496';\n");
+		grammarBuilder.append("KW2497 : 'KW' '2497';\n");
+		grammarBuilder.append("KW2498 : 'KW' '2498';\n");
+		grammarBuilder.append("KW2499 : 'KW' '2499';\n");
+		grammarBuilder.append("KW2500 : 'KW' '2500';\n");
+		grammarBuilder.append("KW2501 : 'KW' '2501';\n");
+		grammarBuilder.append("KW2502 : 'KW' '2502';\n");
+		grammarBuilder.append("KW2503 : 'KW' '2503';\n");
+		grammarBuilder.append("KW2504 : 'KW' '2504';\n");
+		grammarBuilder.append("KW2505 : 'KW' '2505';\n");
+		grammarBuilder.append("KW2506 : 'KW' '2506';\n");
+		grammarBuilder.append("KW2507 : 'KW' '2507';\n");
+		grammarBuilder.append("KW2508 : 'KW' '2508';\n");
+		grammarBuilder.append("KW2509 : 'KW' '2509';\n");
+		grammarBuilder.append("KW2510 : 'KW' '2510';\n");
+		grammarBuilder.append("KW2511 : 'KW' '2511';\n");
+		grammarBuilder.append("KW2512 : 'KW' '2512';\n");
+		grammarBuilder.append("KW2513 : 'KW' '2513';\n");
+		grammarBuilder.append("KW2514 : 'KW' '2514';\n");
+		grammarBuilder.append("KW2515 : 'KW' '2515';\n");
+		grammarBuilder.append("KW2516 : 'KW' '2516';\n");
+		grammarBuilder.append("KW2517 : 'KW' '2517';\n");
+		grammarBuilder.append("KW2518 : 'KW' '2518';\n");
+		grammarBuilder.append("KW2519 : 'KW' '2519';\n");
+		grammarBuilder.append("KW2520 : 'KW' '2520';\n");
+		grammarBuilder.append("KW2521 : 'KW' '2521';\n");
+		grammarBuilder.append("KW2522 : 'KW' '2522';\n");
+		grammarBuilder.append("KW2523 : 'KW' '2523';\n");
+		grammarBuilder.append("KW2524 : 'KW' '2524';\n");
+		grammarBuilder.append("KW2525 : 'KW' '2525';\n");
+		grammarBuilder.append("KW2526 : 'KW' '2526';\n");
+		grammarBuilder.append("KW2527 : 'KW' '2527';\n");
+		grammarBuilder.append("KW2528 : 'KW' '2528';\n");
+		grammarBuilder.append("KW2529 : 'KW' '2529';\n");
+		grammarBuilder.append("KW2530 : 'KW' '2530';\n");
+		grammarBuilder.append("KW2531 : 'KW' '2531';\n");
+		grammarBuilder.append("KW2532 : 'KW' '2532';\n");
+		grammarBuilder.append("KW2533 : 'KW' '2533';\n");
+		grammarBuilder.append("KW2534 : 'KW' '2534';\n");
+		grammarBuilder.append("KW2535 : 'KW' '2535';\n");
+		grammarBuilder.append("KW2536 : 'KW' '2536';\n");
+		grammarBuilder.append("KW2537 : 'KW' '2537';\n");
+		grammarBuilder.append("KW2538 : 'KW' '2538';\n");
+		grammarBuilder.append("KW2539 : 'KW' '2539';\n");
+		grammarBuilder.append("KW2540 : 'KW' '2540';\n");
+		grammarBuilder.append("KW2541 : 'KW' '2541';\n");
+		grammarBuilder.append("KW2542 : 'KW' '2542';\n");
+		grammarBuilder.append("KW2543 : 'KW' '2543';\n");
+		grammarBuilder.append("KW2544 : 'KW' '2544';\n");
+		grammarBuilder.append("KW2545 : 'KW' '2545';\n");
+		grammarBuilder.append("KW2546 : 'KW' '2546';\n");
+		grammarBuilder.append("KW2547 : 'KW' '2547';\n");
+		grammarBuilder.append("KW2548 : 'KW' '2548';\n");
+		grammarBuilder.append("KW2549 : 'KW' '2549';\n");
+		grammarBuilder.append("KW2550 : 'KW' '2550';\n");
+		grammarBuilder.append("KW2551 : 'KW' '2551';\n");
+		grammarBuilder.append("KW2552 : 'KW' '2552';\n");
+		grammarBuilder.append("KW2553 : 'KW' '2553';\n");
+		grammarBuilder.append("KW2554 : 'KW' '2554';\n");
+		grammarBuilder.append("KW2555 : 'KW' '2555';\n");
+		grammarBuilder.append("KW2556 : 'KW' '2556';\n");
+		grammarBuilder.append("KW2557 : 'KW' '2557';\n");
+		grammarBuilder.append("KW2558 : 'KW' '2558';\n");
+		grammarBuilder.append("KW2559 : 'KW' '2559';\n");
+		grammarBuilder.append("KW2560 : 'KW' '2560';\n");
+		grammarBuilder.append("KW2561 : 'KW' '2561';\n");
+		grammarBuilder.append("KW2562 : 'KW' '2562';\n");
+		grammarBuilder.append("KW2563 : 'KW' '2563';\n");
+		grammarBuilder.append("KW2564 : 'KW' '2564';\n");
+		grammarBuilder.append("KW2565 : 'KW' '2565';\n");
+		grammarBuilder.append("KW2566 : 'KW' '2566';\n");
+		grammarBuilder.append("KW2567 : 'KW' '2567';\n");
+		grammarBuilder.append("KW2568 : 'KW' '2568';\n");
+		grammarBuilder.append("KW2569 : 'KW' '2569';\n");
+		grammarBuilder.append("KW2570 : 'KW' '2570';\n");
+		grammarBuilder.append("KW2571 : 'KW' '2571';\n");
+		grammarBuilder.append("KW2572 : 'KW' '2572';\n");
+		grammarBuilder.append("KW2573 : 'KW' '2573';\n");
+		grammarBuilder.append("KW2574 : 'KW' '2574';\n");
+		grammarBuilder.append("KW2575 : 'KW' '2575';\n");
+		grammarBuilder.append("KW2576 : 'KW' '2576';\n");
+		grammarBuilder.append("KW2577 : 'KW' '2577';\n");
+		grammarBuilder.append("KW2578 : 'KW' '2578';\n");
+		grammarBuilder.append("KW2579 : 'KW' '2579';\n");
+		grammarBuilder.append("KW2580 : 'KW' '2580';\n");
+		grammarBuilder.append("KW2581 : 'KW' '2581';\n");
+		grammarBuilder.append("KW2582 : 'KW' '2582';\n");
+		grammarBuilder.append("KW2583 : 'KW' '2583';\n");
+		grammarBuilder.append("KW2584 : 'KW' '2584';\n");
+		grammarBuilder.append("KW2585 : 'KW' '2585';\n");
+		grammarBuilder.append("KW2586 : 'KW' '2586';\n");
+		grammarBuilder.append("KW2587 : 'KW' '2587';\n");
+		grammarBuilder.append("KW2588 : 'KW' '2588';\n");
+		grammarBuilder.append("KW2589 : 'KW' '2589';\n");
+		grammarBuilder.append("KW2590 : 'KW' '2590';\n");
+		grammarBuilder.append("KW2591 : 'KW' '2591';\n");
+		grammarBuilder.append("KW2592 : 'KW' '2592';\n");
+		grammarBuilder.append("KW2593 : 'KW' '2593';\n");
+		grammarBuilder.append("KW2594 : 'KW' '2594';\n");
+		grammarBuilder.append("KW2595 : 'KW' '2595';\n");
+		grammarBuilder.append("KW2596 : 'KW' '2596';\n");
+		grammarBuilder.append("KW2597 : 'KW' '2597';\n");
+		grammarBuilder.append("KW2598 : 'KW' '2598';\n");
+		grammarBuilder.append("KW2599 : 'KW' '2599';\n");
+		grammarBuilder.append("KW2600 : 'KW' '2600';\n");
+		grammarBuilder.append("KW2601 : 'KW' '2601';\n");
+		grammarBuilder.append("KW2602 : 'KW' '2602';\n");
+		grammarBuilder.append("KW2603 : 'KW' '2603';\n");
+		grammarBuilder.append("KW2604 : 'KW' '2604';\n");
+		grammarBuilder.append("KW2605 : 'KW' '2605';\n");
+		grammarBuilder.append("KW2606 : 'KW' '2606';\n");
+		grammarBuilder.append("KW2607 : 'KW' '2607';\n");
+		grammarBuilder.append("KW2608 : 'KW' '2608';\n");
+		grammarBuilder.append("KW2609 : 'KW' '2609';\n");
+		grammarBuilder.append("KW2610 : 'KW' '2610';\n");
+		grammarBuilder.append("KW2611 : 'KW' '2611';\n");
+		grammarBuilder.append("KW2612 : 'KW' '2612';\n");
+		grammarBuilder.append("KW2613 : 'KW' '2613';\n");
+		grammarBuilder.append("KW2614 : 'KW' '2614';\n");
+		grammarBuilder.append("KW2615 : 'KW' '2615';\n");
+		grammarBuilder.append("KW2616 : 'KW' '2616';\n");
+		grammarBuilder.append("KW2617 : 'KW' '2617';\n");
+		grammarBuilder.append("KW2618 : 'KW' '2618';\n");
+		grammarBuilder.append("KW2619 : 'KW' '2619';\n");
+		grammarBuilder.append("KW2620 : 'KW' '2620';\n");
+		grammarBuilder.append("KW2621 : 'KW' '2621';\n");
+		grammarBuilder.append("KW2622 : 'KW' '2622';\n");
+		grammarBuilder.append("KW2623 : 'KW' '2623';\n");
+		grammarBuilder.append("KW2624 : 'KW' '2624';\n");
+		grammarBuilder.append("KW2625 : 'KW' '2625';\n");
+		grammarBuilder.append("KW2626 : 'KW' '2626';\n");
+		grammarBuilder.append("KW2627 : 'KW' '2627';\n");
+		grammarBuilder.append("KW2628 : 'KW' '2628';\n");
+		grammarBuilder.append("KW2629 : 'KW' '2629';\n");
+		grammarBuilder.append("KW2630 : 'KW' '2630';\n");
+		grammarBuilder.append("KW2631 : 'KW' '2631';\n");
+		grammarBuilder.append("KW2632 : 'KW' '2632';\n");
+		grammarBuilder.append("KW2633 : 'KW' '2633';\n");
+		grammarBuilder.append("KW2634 : 'KW' '2634';\n");
+		grammarBuilder.append("KW2635 : 'KW' '2635';\n");
+		grammarBuilder.append("KW2636 : 'KW' '2636';\n");
+		grammarBuilder.append("KW2637 : 'KW' '2637';\n");
+		grammarBuilder.append("KW2638 : 'KW' '2638';\n");
+		grammarBuilder.append("KW2639 : 'KW' '2639';\n");
+		grammarBuilder.append("KW2640 : 'KW' '2640';\n");
+		grammarBuilder.append("KW2641 : 'KW' '2641';\n");
+		grammarBuilder.append("KW2642 : 'KW' '2642';\n");
+		grammarBuilder.append("KW2643 : 'KW' '2643';\n");
+		grammarBuilder.append("KW2644 : 'KW' '2644';\n");
+		grammarBuilder.append("KW2645 : 'KW' '2645';\n");
+		grammarBuilder.append("KW2646 : 'KW' '2646';\n");
+		grammarBuilder.append("KW2647 : 'KW' '2647';\n");
+		grammarBuilder.append("KW2648 : 'KW' '2648';\n");
+		grammarBuilder.append("KW2649 : 'KW' '2649';\n");
+		grammarBuilder.append("KW2650 : 'KW' '2650';\n");
+		grammarBuilder.append("KW2651 : 'KW' '2651';\n");
+		grammarBuilder.append("KW2652 : 'KW' '2652';\n");
+		grammarBuilder.append("KW2653 : 'KW' '2653';\n");
+		grammarBuilder.append("KW2654 : 'KW' '2654';\n");
+		grammarBuilder.append("KW2655 : 'KW' '2655';\n");
+		grammarBuilder.append("KW2656 : 'KW' '2656';\n");
+		grammarBuilder.append("KW2657 : 'KW' '2657';\n");
+		grammarBuilder.append("KW2658 : 'KW' '2658';\n");
+		grammarBuilder.append("KW2659 : 'KW' '2659';\n");
+		grammarBuilder.append("KW2660 : 'KW' '2660';\n");
+		grammarBuilder.append("KW2661 : 'KW' '2661';\n");
+		grammarBuilder.append("KW2662 : 'KW' '2662';\n");
+		grammarBuilder.append("KW2663 : 'KW' '2663';\n");
+		grammarBuilder.append("KW2664 : 'KW' '2664';\n");
+		grammarBuilder.append("KW2665 : 'KW' '2665';\n");
+		grammarBuilder.append("KW2666 : 'KW' '2666';\n");
+		grammarBuilder.append("KW2667 : 'KW' '2667';\n");
+		grammarBuilder.append("KW2668 : 'KW' '2668';\n");
+		grammarBuilder.append("KW2669 : 'KW' '2669';\n");
+		grammarBuilder.append("KW2670 : 'KW' '2670';\n");
+		grammarBuilder.append("KW2671 : 'KW' '2671';\n");
+		grammarBuilder.append("KW2672 : 'KW' '2672';\n");
+		grammarBuilder.append("KW2673 : 'KW' '2673';\n");
+		grammarBuilder.append("KW2674 : 'KW' '2674';\n");
+		grammarBuilder.append("KW2675 : 'KW' '2675';\n");
+		grammarBuilder.append("KW2676 : 'KW' '2676';\n");
+		grammarBuilder.append("KW2677 : 'KW' '2677';\n");
+		grammarBuilder.append("KW2678 : 'KW' '2678';\n");
+		grammarBuilder.append("KW2679 : 'KW' '2679';\n");
+		grammarBuilder.append("KW2680 : 'KW' '2680';\n");
+		grammarBuilder.append("KW2681 : 'KW' '2681';\n");
+		grammarBuilder.append("KW2682 : 'KW' '2682';\n");
+		grammarBuilder.append("KW2683 : 'KW' '2683';\n");
+		grammarBuilder.append("KW2684 : 'KW' '2684';\n");
+		grammarBuilder.append("KW2685 : 'KW' '2685';\n");
+		grammarBuilder.append("KW2686 : 'KW' '2686';\n");
+		grammarBuilder.append("KW2687 : 'KW' '2687';\n");
+		grammarBuilder.append("KW2688 : 'KW' '2688';\n");
+		grammarBuilder.append("KW2689 : 'KW' '2689';\n");
+		grammarBuilder.append("KW2690 : 'KW' '2690';\n");
+		grammarBuilder.append("KW2691 : 'KW' '2691';\n");
+		grammarBuilder.append("KW2692 : 'KW' '2692';\n");
+		grammarBuilder.append("KW2693 : 'KW' '2693';\n");
+		grammarBuilder.append("KW2694 : 'KW' '2694';\n");
+		grammarBuilder.append("KW2695 : 'KW' '2695';\n");
+		grammarBuilder.append("KW2696 : 'KW' '2696';\n");
+		grammarBuilder.append("KW2697 : 'KW' '2697';\n");
+		grammarBuilder.append("KW2698 : 'KW' '2698';\n");
+		grammarBuilder.append("KW2699 : 'KW' '2699';\n");
+		grammarBuilder.append("KW2700 : 'KW' '2700';\n");
+		grammarBuilder.append("KW2701 : 'KW' '2701';\n");
+		grammarBuilder.append("KW2702 : 'KW' '2702';\n");
+		grammarBuilder.append("KW2703 : 'KW' '2703';\n");
+		grammarBuilder.append("KW2704 : 'KW' '2704';\n");
+		grammarBuilder.append("KW2705 : 'KW' '2705';\n");
+		grammarBuilder.append("KW2706 : 'KW' '2706';\n");
+		grammarBuilder.append("KW2707 : 'KW' '2707';\n");
+		grammarBuilder.append("KW2708 : 'KW' '2708';\n");
+		grammarBuilder.append("KW2709 : 'KW' '2709';\n");
+		grammarBuilder.append("KW2710 : 'KW' '2710';\n");
+		grammarBuilder.append("KW2711 : 'KW' '2711';\n");
+		grammarBuilder.append("KW2712 : 'KW' '2712';\n");
+		grammarBuilder.append("KW2713 : 'KW' '2713';\n");
+		grammarBuilder.append("KW2714 : 'KW' '2714';\n");
+		grammarBuilder.append("KW2715 : 'KW' '2715';\n");
+		grammarBuilder.append("KW2716 : 'KW' '2716';\n");
+		grammarBuilder.append("KW2717 : 'KW' '2717';\n");
+		grammarBuilder.append("KW2718 : 'KW' '2718';\n");
+		grammarBuilder.append("KW2719 : 'KW' '2719';\n");
+		grammarBuilder.append("KW2720 : 'KW' '2720';\n");
+		grammarBuilder.append("KW2721 : 'KW' '2721';\n");
+		grammarBuilder.append("KW2722 : 'KW' '2722';\n");
+		grammarBuilder.append("KW2723 : 'KW' '2723';\n");
+		grammarBuilder.append("KW2724 : 'KW' '2724';\n");
+		grammarBuilder.append("KW2725 : 'KW' '2725';\n");
+		grammarBuilder.append("KW2726 : 'KW' '2726';\n");
+		grammarBuilder.append("KW2727 : 'KW' '2727';\n");
+		grammarBuilder.append("KW2728 : 'KW' '2728';\n");
+		grammarBuilder.append("KW2729 : 'KW' '2729';\n");
+		grammarBuilder.append("KW2730 : 'KW' '2730';\n");
+		grammarBuilder.append("KW2731 : 'KW' '2731';\n");
+		grammarBuilder.append("KW2732 : 'KW' '2732';\n");
+		grammarBuilder.append("KW2733 : 'KW' '2733';\n");
+		grammarBuilder.append("KW2734 : 'KW' '2734';\n");
+		grammarBuilder.append("KW2735 : 'KW' '2735';\n");
+		grammarBuilder.append("KW2736 : 'KW' '2736';\n");
+		grammarBuilder.append("KW2737 : 'KW' '2737';\n");
+		grammarBuilder.append("KW2738 : 'KW' '2738';\n");
+		grammarBuilder.append("KW2739 : 'KW' '2739';\n");
+		grammarBuilder.append("KW2740 : 'KW' '2740';\n");
+		grammarBuilder.append("KW2741 : 'KW' '2741';\n");
+		grammarBuilder.append("KW2742 : 'KW' '2742';\n");
+		grammarBuilder.append("KW2743 : 'KW' '2743';\n");
+		grammarBuilder.append("KW2744 : 'KW' '2744';\n");
+		grammarBuilder.append("KW2745 : 'KW' '2745';\n");
+		grammarBuilder.append("KW2746 : 'KW' '2746';\n");
+		grammarBuilder.append("KW2747 : 'KW' '2747';\n");
+		grammarBuilder.append("KW2748 : 'KW' '2748';\n");
+		grammarBuilder.append("KW2749 : 'KW' '2749';\n");
+		grammarBuilder.append("KW2750 : 'KW' '2750';\n");
+		grammarBuilder.append("KW2751 : 'KW' '2751';\n");
+		grammarBuilder.append("KW2752 : 'KW' '2752';\n");
+		grammarBuilder.append("KW2753 : 'KW' '2753';\n");
+		grammarBuilder.append("KW2754 : 'KW' '2754';\n");
+		grammarBuilder.append("KW2755 : 'KW' '2755';\n");
+		grammarBuilder.append("KW2756 : 'KW' '2756';\n");
+		grammarBuilder.append("KW2757 : 'KW' '2757';\n");
+		grammarBuilder.append("KW2758 : 'KW' '2758';\n");
+		grammarBuilder.append("KW2759 : 'KW' '2759';\n");
+		grammarBuilder.append("KW2760 : 'KW' '2760';\n");
+		grammarBuilder.append("KW2761 : 'KW' '2761';\n");
+		grammarBuilder.append("KW2762 : 'KW' '2762';\n");
+		grammarBuilder.append("KW2763 : 'KW' '2763';\n");
+		grammarBuilder.append("KW2764 : 'KW' '2764';\n");
+		grammarBuilder.append("KW2765 : 'KW' '2765';\n");
+		grammarBuilder.append("KW2766 : 'KW' '2766';\n");
+		grammarBuilder.append("KW2767 : 'KW' '2767';\n");
+		grammarBuilder.append("KW2768 : 'KW' '2768';\n");
+		grammarBuilder.append("KW2769 : 'KW' '2769';\n");
+		grammarBuilder.append("KW2770 : 'KW' '2770';\n");
+		grammarBuilder.append("KW2771 : 'KW' '2771';\n");
+		grammarBuilder.append("KW2772 : 'KW' '2772';\n");
+		grammarBuilder.append("KW2773 : 'KW' '2773';\n");
+		grammarBuilder.append("KW2774 : 'KW' '2774';\n");
+		grammarBuilder.append("KW2775 : 'KW' '2775';\n");
+		grammarBuilder.append("KW2776 : 'KW' '2776';\n");
+		grammarBuilder.append("KW2777 : 'KW' '2777';\n");
+		grammarBuilder.append("KW2778 : 'KW' '2778';\n");
+		grammarBuilder.append("KW2779 : 'KW' '2779';\n");
+		grammarBuilder.append("KW2780 : 'KW' '2780';\n");
+		grammarBuilder.append("KW2781 : 'KW' '2781';\n");
+		grammarBuilder.append("KW2782 : 'KW' '2782';\n");
+		grammarBuilder.append("KW2783 : 'KW' '2783';\n");
+		grammarBuilder.append("KW2784 : 'KW' '2784';\n");
+		grammarBuilder.append("KW2785 : 'KW' '2785';\n");
+		grammarBuilder.append("KW2786 : 'KW' '2786';\n");
+		grammarBuilder.append("KW2787 : 'KW' '2787';\n");
+		grammarBuilder.append("KW2788 : 'KW' '2788';\n");
+		grammarBuilder.append("KW2789 : 'KW' '2789';\n");
+		grammarBuilder.append("KW2790 : 'KW' '2790';\n");
+		grammarBuilder.append("KW2791 : 'KW' '2791';\n");
+		grammarBuilder.append("KW2792 : 'KW' '2792';\n");
+		grammarBuilder.append("KW2793 : 'KW' '2793';\n");
+		grammarBuilder.append("KW2794 : 'KW' '2794';\n");
+		grammarBuilder.append("KW2795 : 'KW' '2795';\n");
+		grammarBuilder.append("KW2796 : 'KW' '2796';\n");
+		grammarBuilder.append("KW2797 : 'KW' '2797';\n");
+		grammarBuilder.append("KW2798 : 'KW' '2798';\n");
+		grammarBuilder.append("KW2799 : 'KW' '2799';\n");
+		grammarBuilder.append("KW2800 : 'KW' '2800';\n");
+		grammarBuilder.append("KW2801 : 'KW' '2801';\n");
+		grammarBuilder.append("KW2802 : 'KW' '2802';\n");
+		grammarBuilder.append("KW2803 : 'KW' '2803';\n");
+		grammarBuilder.append("KW2804 : 'KW' '2804';\n");
+		grammarBuilder.append("KW2805 : 'KW' '2805';\n");
+		grammarBuilder.append("KW2806 : 'KW' '2806';\n");
+		grammarBuilder.append("KW2807 : 'KW' '2807';\n");
+		grammarBuilder.append("KW2808 : 'KW' '2808';\n");
+		grammarBuilder.append("KW2809 : 'KW' '2809';\n");
+		grammarBuilder.append("KW2810 : 'KW' '2810';\n");
+		grammarBuilder.append("KW2811 : 'KW' '2811';\n");
+		grammarBuilder.append("KW2812 : 'KW' '2812';\n");
+		grammarBuilder.append("KW2813 : 'KW' '2813';\n");
+		grammarBuilder.append("KW2814 : 'KW' '2814';\n");
+		grammarBuilder.append("KW2815 : 'KW' '2815';\n");
+		grammarBuilder.append("KW2816 : 'KW' '2816';\n");
+		grammarBuilder.append("KW2817 : 'KW' '2817';\n");
+		grammarBuilder.append("KW2818 : 'KW' '2818';\n");
+		grammarBuilder.append("KW2819 : 'KW' '2819';\n");
+		grammarBuilder.append("KW2820 : 'KW' '2820';\n");
+		grammarBuilder.append("KW2821 : 'KW' '2821';\n");
+		grammarBuilder.append("KW2822 : 'KW' '2822';\n");
+		grammarBuilder.append("KW2823 : 'KW' '2823';\n");
+		grammarBuilder.append("KW2824 : 'KW' '2824';\n");
+		grammarBuilder.append("KW2825 : 'KW' '2825';\n");
+		grammarBuilder.append("KW2826 : 'KW' '2826';\n");
+		grammarBuilder.append("KW2827 : 'KW' '2827';\n");
+		grammarBuilder.append("KW2828 : 'KW' '2828';\n");
+		grammarBuilder.append("KW2829 : 'KW' '2829';\n");
+		grammarBuilder.append("KW2830 : 'KW' '2830';\n");
+		grammarBuilder.append("KW2831 : 'KW' '2831';\n");
+		grammarBuilder.append("KW2832 : 'KW' '2832';\n");
+		grammarBuilder.append("KW2833 : 'KW' '2833';\n");
+		grammarBuilder.append("KW2834 : 'KW' '2834';\n");
+		grammarBuilder.append("KW2835 : 'KW' '2835';\n");
+		grammarBuilder.append("KW2836 : 'KW' '2836';\n");
+		grammarBuilder.append("KW2837 : 'KW' '2837';\n");
+		grammarBuilder.append("KW2838 : 'KW' '2838';\n");
+		grammarBuilder.append("KW2839 : 'KW' '2839';\n");
+		grammarBuilder.append("KW2840 : 'KW' '2840';\n");
+		grammarBuilder.append("KW2841 : 'KW' '2841';\n");
+		grammarBuilder.append("KW2842 : 'KW' '2842';\n");
+		grammarBuilder.append("KW2843 : 'KW' '2843';\n");
+		grammarBuilder.append("KW2844 : 'KW' '2844';\n");
+		grammarBuilder.append("KW2845 : 'KW' '2845';\n");
+		grammarBuilder.append("KW2846 : 'KW' '2846';\n");
+		grammarBuilder.append("KW2847 : 'KW' '2847';\n");
+		grammarBuilder.append("KW2848 : 'KW' '2848';\n");
+		grammarBuilder.append("KW2849 : 'KW' '2849';\n");
+		grammarBuilder.append("KW2850 : 'KW' '2850';\n");
+		grammarBuilder.append("KW2851 : 'KW' '2851';\n");
+		grammarBuilder.append("KW2852 : 'KW' '2852';\n");
+		grammarBuilder.append("KW2853 : 'KW' '2853';\n");
+		grammarBuilder.append("KW2854 : 'KW' '2854';\n");
+		grammarBuilder.append("KW2855 : 'KW' '2855';\n");
+		grammarBuilder.append("KW2856 : 'KW' '2856';\n");
+		grammarBuilder.append("KW2857 : 'KW' '2857';\n");
+		grammarBuilder.append("KW2858 : 'KW' '2858';\n");
+		grammarBuilder.append("KW2859 : 'KW' '2859';\n");
+		grammarBuilder.append("KW2860 : 'KW' '2860';\n");
+		grammarBuilder.append("KW2861 : 'KW' '2861';\n");
+		grammarBuilder.append("KW2862 : 'KW' '2862';\n");
+		grammarBuilder.append("KW2863 : 'KW' '2863';\n");
+		grammarBuilder.append("KW2864 : 'KW' '2864';\n");
+		grammarBuilder.append("KW2865 : 'KW' '2865';\n");
+		grammarBuilder.append("KW2866 : 'KW' '2866';\n");
+		grammarBuilder.append("KW2867 : 'KW' '2867';\n");
+		grammarBuilder.append("KW2868 : 'KW' '2868';\n");
+		grammarBuilder.append("KW2869 : 'KW' '2869';\n");
+		grammarBuilder.append("KW2870 : 'KW' '2870';\n");
+		grammarBuilder.append("KW2871 : 'KW' '2871';\n");
+		grammarBuilder.append("KW2872 : 'KW' '2872';\n");
+		grammarBuilder.append("KW2873 : 'KW' '2873';\n");
+		grammarBuilder.append("KW2874 : 'KW' '2874';\n");
+		grammarBuilder.append("KW2875 : 'KW' '2875';\n");
+		grammarBuilder.append("KW2876 : 'KW' '2876';\n");
+		grammarBuilder.append("KW2877 : 'KW' '2877';\n");
+		grammarBuilder.append("KW2878 : 'KW' '2878';\n");
+		grammarBuilder.append("KW2879 : 'KW' '2879';\n");
+		grammarBuilder.append("KW2880 : 'KW' '2880';\n");
+		grammarBuilder.append("KW2881 : 'KW' '2881';\n");
+		grammarBuilder.append("KW2882 : 'KW' '2882';\n");
+		grammarBuilder.append("KW2883 : 'KW' '2883';\n");
+		grammarBuilder.append("KW2884 : 'KW' '2884';\n");
+		grammarBuilder.append("KW2885 : 'KW' '2885';\n");
+		grammarBuilder.append("KW2886 : 'KW' '2886';\n");
+		grammarBuilder.append("KW2887 : 'KW' '2887';\n");
+		grammarBuilder.append("KW2888 : 'KW' '2888';\n");
+		grammarBuilder.append("KW2889 : 'KW' '2889';\n");
+		grammarBuilder.append("KW2890 : 'KW' '2890';\n");
+		grammarBuilder.append("KW2891 : 'KW' '2891';\n");
+		grammarBuilder.append("KW2892 : 'KW' '2892';\n");
+		grammarBuilder.append("KW2893 : 'KW' '2893';\n");
+		grammarBuilder.append("KW2894 : 'KW' '2894';\n");
+		grammarBuilder.append("KW2895 : 'KW' '2895';\n");
+		grammarBuilder.append("KW2896 : 'KW' '2896';\n");
+		grammarBuilder.append("KW2897 : 'KW' '2897';\n");
+		grammarBuilder.append("KW2898 : 'KW' '2898';\n");
+		grammarBuilder.append("KW2899 : 'KW' '2899';\n");
+		grammarBuilder.append("KW2900 : 'KW' '2900';\n");
+		grammarBuilder.append("KW2901 : 'KW' '2901';\n");
+		grammarBuilder.append("KW2902 : 'KW' '2902';\n");
+		grammarBuilder.append("KW2903 : 'KW' '2903';\n");
+		grammarBuilder.append("KW2904 : 'KW' '2904';\n");
+		grammarBuilder.append("KW2905 : 'KW' '2905';\n");
+		grammarBuilder.append("KW2906 : 'KW' '2906';\n");
+		grammarBuilder.append("KW2907 : 'KW' '2907';\n");
+		grammarBuilder.append("KW2908 : 'KW' '2908';\n");
+		grammarBuilder.append("KW2909 : 'KW' '2909';\n");
+		grammarBuilder.append("KW2910 : 'KW' '2910';\n");
+		grammarBuilder.append("KW2911 : 'KW' '2911';\n");
+		grammarBuilder.append("KW2912 : 'KW' '2912';\n");
+		grammarBuilder.append("KW2913 : 'KW' '2913';\n");
+		grammarBuilder.append("KW2914 : 'KW' '2914';\n");
+		grammarBuilder.append("KW2915 : 'KW' '2915';\n");
+		grammarBuilder.append("KW2916 : 'KW' '2916';\n");
+		grammarBuilder.append("KW2917 : 'KW' '2917';\n");
+		grammarBuilder.append("KW2918 : 'KW' '2918';\n");
+		grammarBuilder.append("KW2919 : 'KW' '2919';\n");
+		grammarBuilder.append("KW2920 : 'KW' '2920';\n");
+		grammarBuilder.append("KW2921 : 'KW' '2921';\n");
+		grammarBuilder.append("KW2922 : 'KW' '2922';\n");
+		grammarBuilder.append("KW2923 : 'KW' '2923';\n");
+		grammarBuilder.append("KW2924 : 'KW' '2924';\n");
+		grammarBuilder.append("KW2925 : 'KW' '2925';\n");
+		grammarBuilder.append("KW2926 : 'KW' '2926';\n");
+		grammarBuilder.append("KW2927 : 'KW' '2927';\n");
+		grammarBuilder.append("KW2928 : 'KW' '2928';\n");
+		grammarBuilder.append("KW2929 : 'KW' '2929';\n");
+		grammarBuilder.append("KW2930 : 'KW' '2930';\n");
+		grammarBuilder.append("KW2931 : 'KW' '2931';\n");
+		grammarBuilder.append("KW2932 : 'KW' '2932';\n");
+		grammarBuilder.append("KW2933 : 'KW' '2933';\n");
+		grammarBuilder.append("KW2934 : 'KW' '2934';\n");
+		grammarBuilder.append("KW2935 : 'KW' '2935';\n");
+		grammarBuilder.append("KW2936 : 'KW' '2936';\n");
+		grammarBuilder.append("KW2937 : 'KW' '2937';\n");
+		grammarBuilder.append("KW2938 : 'KW' '2938';\n");
+		grammarBuilder.append("KW2939 : 'KW' '2939';\n");
+		grammarBuilder.append("KW2940 : 'KW' '2940';\n");
+		grammarBuilder.append("KW2941 : 'KW' '2941';\n");
+		grammarBuilder.append("KW2942 : 'KW' '2942';\n");
+		grammarBuilder.append("KW2943 : 'KW' '2943';\n");
+		grammarBuilder.append("KW2944 : 'KW' '2944';\n");
+		grammarBuilder.append("KW2945 : 'KW' '2945';\n");
+		grammarBuilder.append("KW2946 : 'KW' '2946';\n");
+		grammarBuilder.append("KW2947 : 'KW' '2947';\n");
+		grammarBuilder.append("KW2948 : 'KW' '2948';\n");
+		grammarBuilder.append("KW2949 : 'KW' '2949';\n");
+		grammarBuilder.append("KW2950 : 'KW' '2950';\n");
+		grammarBuilder.append("KW2951 : 'KW' '2951';\n");
+		grammarBuilder.append("KW2952 : 'KW' '2952';\n");
+		grammarBuilder.append("KW2953 : 'KW' '2953';\n");
+		grammarBuilder.append("KW2954 : 'KW' '2954';\n");
+		grammarBuilder.append("KW2955 : 'KW' '2955';\n");
+		grammarBuilder.append("KW2956 : 'KW' '2956';\n");
+		grammarBuilder.append("KW2957 : 'KW' '2957';\n");
+		grammarBuilder.append("KW2958 : 'KW' '2958';\n");
+		grammarBuilder.append("KW2959 : 'KW' '2959';\n");
+		grammarBuilder.append("KW2960 : 'KW' '2960';\n");
+		grammarBuilder.append("KW2961 : 'KW' '2961';\n");
+		grammarBuilder.append("KW2962 : 'KW' '2962';\n");
+		grammarBuilder.append("KW2963 : 'KW' '2963';\n");
+		grammarBuilder.append("KW2964 : 'KW' '2964';\n");
+		grammarBuilder.append("KW2965 : 'KW' '2965';\n");
+		grammarBuilder.append("KW2966 : 'KW' '2966';\n");
+		grammarBuilder.append("KW2967 : 'KW' '2967';\n");
+		grammarBuilder.append("KW2968 : 'KW' '2968';\n");
+		grammarBuilder.append("KW2969 : 'KW' '2969';\n");
+		grammarBuilder.append("KW2970 : 'KW' '2970';\n");
+		grammarBuilder.append("KW2971 : 'KW' '2971';\n");
+		grammarBuilder.append("KW2972 : 'KW' '2972';\n");
+		grammarBuilder.append("KW2973 : 'KW' '2973';\n");
+		grammarBuilder.append("KW2974 : 'KW' '2974';\n");
+		grammarBuilder.append("KW2975 : 'KW' '2975';\n");
+		grammarBuilder.append("KW2976 : 'KW' '2976';\n");
+		grammarBuilder.append("KW2977 : 'KW' '2977';\n");
+		grammarBuilder.append("KW2978 : 'KW' '2978';\n");
+		grammarBuilder.append("KW2979 : 'KW' '2979';\n");
+		grammarBuilder.append("KW2980 : 'KW' '2980';\n");
+		grammarBuilder.append("KW2981 : 'KW' '2981';\n");
+		grammarBuilder.append("KW2982 : 'KW' '2982';\n");
+		grammarBuilder.append("KW2983 : 'KW' '2983';\n");
+		grammarBuilder.append("KW2984 : 'KW' '2984';\n");
+		grammarBuilder.append("KW2985 : 'KW' '2985';\n");
+		grammarBuilder.append("KW2986 : 'KW' '2986';\n");
+		grammarBuilder.append("KW2987 : 'KW' '2987';\n");
+		grammarBuilder.append("KW2988 : 'KW' '2988';\n");
+		grammarBuilder.append("KW2989 : 'KW' '2989';\n");
+		grammarBuilder.append("KW2990 : 'KW' '2990';\n");
+		grammarBuilder.append("KW2991 : 'KW' '2991';\n");
+		grammarBuilder.append("KW2992 : 'KW' '2992';\n");
+		grammarBuilder.append("KW2993 : 'KW' '2993';\n");
+		grammarBuilder.append("KW2994 : 'KW' '2994';\n");
+		grammarBuilder.append("KW2995 : 'KW' '2995';\n");
+		grammarBuilder.append("KW2996 : 'KW' '2996';\n");
+		grammarBuilder.append("KW2997 : 'KW' '2997';\n");
+		grammarBuilder.append("KW2998 : 'KW' '2998';\n");
+		grammarBuilder.append("KW2999 : 'KW' '2999';\n");
+		grammarBuilder.append("KW3000 : 'KW' '3000';\n");
+		grammarBuilder.append("KW3001 : 'KW' '3001';\n");
+		grammarBuilder.append("KW3002 : 'KW' '3002';\n");
+		grammarBuilder.append("KW3003 : 'KW' '3003';\n");
+		grammarBuilder.append("KW3004 : 'KW' '3004';\n");
+		grammarBuilder.append("KW3005 : 'KW' '3005';\n");
+		grammarBuilder.append("KW3006 : 'KW' '3006';\n");
+		grammarBuilder.append("KW3007 : 'KW' '3007';\n");
+		grammarBuilder.append("KW3008 : 'KW' '3008';\n");
+		grammarBuilder.append("KW3009 : 'KW' '3009';\n");
+		grammarBuilder.append("KW3010 : 'KW' '3010';\n");
+		grammarBuilder.append("KW3011 : 'KW' '3011';\n");
+		grammarBuilder.append("KW3012 : 'KW' '3012';\n");
+		grammarBuilder.append("KW3013 : 'KW' '3013';\n");
+		grammarBuilder.append("KW3014 : 'KW' '3014';\n");
+		grammarBuilder.append("KW3015 : 'KW' '3015';\n");
+		grammarBuilder.append("KW3016 : 'KW' '3016';\n");
+		grammarBuilder.append("KW3017 : 'KW' '3017';\n");
+		grammarBuilder.append("KW3018 : 'KW' '3018';\n");
+		grammarBuilder.append("KW3019 : 'KW' '3019';\n");
+		grammarBuilder.append("KW3020 : 'KW' '3020';\n");
+		grammarBuilder.append("KW3021 : 'KW' '3021';\n");
+		grammarBuilder.append("KW3022 : 'KW' '3022';\n");
+		grammarBuilder.append("KW3023 : 'KW' '3023';\n");
+		grammarBuilder.append("KW3024 : 'KW' '3024';\n");
+		grammarBuilder.append("KW3025 : 'KW' '3025';\n");
+		grammarBuilder.append("KW3026 : 'KW' '3026';\n");
+		grammarBuilder.append("KW3027 : 'KW' '3027';\n");
+		grammarBuilder.append("KW3028 : 'KW' '3028';\n");
+		grammarBuilder.append("KW3029 : 'KW' '3029';\n");
+		grammarBuilder.append("KW3030 : 'KW' '3030';\n");
+		grammarBuilder.append("KW3031 : 'KW' '3031';\n");
+		grammarBuilder.append("KW3032 : 'KW' '3032';\n");
+		grammarBuilder.append("KW3033 : 'KW' '3033';\n");
+		grammarBuilder.append("KW3034 : 'KW' '3034';\n");
+		grammarBuilder.append("KW3035 : 'KW' '3035';\n");
+		grammarBuilder.append("KW3036 : 'KW' '3036';\n");
+		grammarBuilder.append("KW3037 : 'KW' '3037';\n");
+		grammarBuilder.append("KW3038 : 'KW' '3038';\n");
+		grammarBuilder.append("KW3039 : 'KW' '3039';\n");
+		grammarBuilder.append("KW3040 : 'KW' '3040';\n");
+		grammarBuilder.append("KW3041 : 'KW' '3041';\n");
+		grammarBuilder.append("KW3042 : 'KW' '3042';\n");
+		grammarBuilder.append("KW3043 : 'KW' '3043';\n");
+		grammarBuilder.append("KW3044 : 'KW' '3044';\n");
+		grammarBuilder.append("KW3045 : 'KW' '3045';\n");
+		grammarBuilder.append("KW3046 : 'KW' '3046';\n");
+		grammarBuilder.append("KW3047 : 'KW' '3047';\n");
+		grammarBuilder.append("KW3048 : 'KW' '3048';\n");
+		grammarBuilder.append("KW3049 : 'KW' '3049';\n");
+		grammarBuilder.append("KW3050 : 'KW' '3050';\n");
+		grammarBuilder.append("KW3051 : 'KW' '3051';\n");
+		grammarBuilder.append("KW3052 : 'KW' '3052';\n");
+		grammarBuilder.append("KW3053 : 'KW' '3053';\n");
+		grammarBuilder.append("KW3054 : 'KW' '3054';\n");
+		grammarBuilder.append("KW3055 : 'KW' '3055';\n");
+		grammarBuilder.append("KW3056 : 'KW' '3056';\n");
+		grammarBuilder.append("KW3057 : 'KW' '3057';\n");
+		grammarBuilder.append("KW3058 : 'KW' '3058';\n");
+		grammarBuilder.append("KW3059 : 'KW' '3059';\n");
+		grammarBuilder.append("KW3060 : 'KW' '3060';\n");
+		grammarBuilder.append("KW3061 : 'KW' '3061';\n");
+		grammarBuilder.append("KW3062 : 'KW' '3062';\n");
+		grammarBuilder.append("KW3063 : 'KW' '3063';\n");
+		grammarBuilder.append("KW3064 : 'KW' '3064';\n");
+		grammarBuilder.append("KW3065 : 'KW' '3065';\n");
+		grammarBuilder.append("KW3066 : 'KW' '3066';\n");
+		grammarBuilder.append("KW3067 : 'KW' '3067';\n");
+		grammarBuilder.append("KW3068 : 'KW' '3068';\n");
+		grammarBuilder.append("KW3069 : 'KW' '3069';\n");
+		grammarBuilder.append("KW3070 : 'KW' '3070';\n");
+		grammarBuilder.append("KW3071 : 'KW' '3071';\n");
+		grammarBuilder.append("KW3072 : 'KW' '3072';\n");
+		grammarBuilder.append("KW3073 : 'KW' '3073';\n");
+		grammarBuilder.append("KW3074 : 'KW' '3074';\n");
+		grammarBuilder.append("KW3075 : 'KW' '3075';\n");
+		grammarBuilder.append("KW3076 : 'KW' '3076';\n");
+		grammarBuilder.append("KW3077 : 'KW' '3077';\n");
+		grammarBuilder.append("KW3078 : 'KW' '3078';\n");
+		grammarBuilder.append("KW3079 : 'KW' '3079';\n");
+		grammarBuilder.append("KW3080 : 'KW' '3080';\n");
+		grammarBuilder.append("KW3081 : 'KW' '3081';\n");
+		grammarBuilder.append("KW3082 : 'KW' '3082';\n");
+		grammarBuilder.append("KW3083 : 'KW' '3083';\n");
+		grammarBuilder.append("KW3084 : 'KW' '3084';\n");
+		grammarBuilder.append("KW3085 : 'KW' '3085';\n");
+		grammarBuilder.append("KW3086 : 'KW' '3086';\n");
+		grammarBuilder.append("KW3087 : 'KW' '3087';\n");
+		grammarBuilder.append("KW3088 : 'KW' '3088';\n");
+		grammarBuilder.append("KW3089 : 'KW' '3089';\n");
+		grammarBuilder.append("KW3090 : 'KW' '3090';\n");
+		grammarBuilder.append("KW3091 : 'KW' '3091';\n");
+		grammarBuilder.append("KW3092 : 'KW' '3092';\n");
+		grammarBuilder.append("KW3093 : 'KW' '3093';\n");
+		grammarBuilder.append("KW3094 : 'KW' '3094';\n");
+		grammarBuilder.append("KW3095 : 'KW' '3095';\n");
+		grammarBuilder.append("KW3096 : 'KW' '3096';\n");
+		grammarBuilder.append("KW3097 : 'KW' '3097';\n");
+		grammarBuilder.append("KW3098 : 'KW' '3098';\n");
+		grammarBuilder.append("KW3099 : 'KW' '3099';\n");
+		grammarBuilder.append("KW3100 : 'KW' '3100';\n");
+		grammarBuilder.append("KW3101 : 'KW' '3101';\n");
+		grammarBuilder.append("KW3102 : 'KW' '3102';\n");
+		grammarBuilder.append("KW3103 : 'KW' '3103';\n");
+		grammarBuilder.append("KW3104 : 'KW' '3104';\n");
+		grammarBuilder.append("KW3105 : 'KW' '3105';\n");
+		grammarBuilder.append("KW3106 : 'KW' '3106';\n");
+		grammarBuilder.append("KW3107 : 'KW' '3107';\n");
+		grammarBuilder.append("KW3108 : 'KW' '3108';\n");
+		grammarBuilder.append("KW3109 : 'KW' '3109';\n");
+		grammarBuilder.append("KW3110 : 'KW' '3110';\n");
+		grammarBuilder.append("KW3111 : 'KW' '3111';\n");
+		grammarBuilder.append("KW3112 : 'KW' '3112';\n");
+		grammarBuilder.append("KW3113 : 'KW' '3113';\n");
+		grammarBuilder.append("KW3114 : 'KW' '3114';\n");
+		grammarBuilder.append("KW3115 : 'KW' '3115';\n");
+		grammarBuilder.append("KW3116 : 'KW' '3116';\n");
+		grammarBuilder.append("KW3117 : 'KW' '3117';\n");
+		grammarBuilder.append("KW3118 : 'KW' '3118';\n");
+		grammarBuilder.append("KW3119 : 'KW' '3119';\n");
+		grammarBuilder.append("KW3120 : 'KW' '3120';\n");
+		grammarBuilder.append("KW3121 : 'KW' '3121';\n");
+		grammarBuilder.append("KW3122 : 'KW' '3122';\n");
+		grammarBuilder.append("KW3123 : 'KW' '3123';\n");
+		grammarBuilder.append("KW3124 : 'KW' '3124';\n");
+		grammarBuilder.append("KW3125 : 'KW' '3125';\n");
+		grammarBuilder.append("KW3126 : 'KW' '3126';\n");
+		grammarBuilder.append("KW3127 : 'KW' '3127';\n");
+		grammarBuilder.append("KW3128 : 'KW' '3128';\n");
+		grammarBuilder.append("KW3129 : 'KW' '3129';\n");
+		grammarBuilder.append("KW3130 : 'KW' '3130';\n");
+		grammarBuilder.append("KW3131 : 'KW' '3131';\n");
+		grammarBuilder.append("KW3132 : 'KW' '3132';\n");
+		grammarBuilder.append("KW3133 : 'KW' '3133';\n");
+		grammarBuilder.append("KW3134 : 'KW' '3134';\n");
+		grammarBuilder.append("KW3135 : 'KW' '3135';\n");
+		grammarBuilder.append("KW3136 : 'KW' '3136';\n");
+		grammarBuilder.append("KW3137 : 'KW' '3137';\n");
+		grammarBuilder.append("KW3138 : 'KW' '3138';\n");
+		grammarBuilder.append("KW3139 : 'KW' '3139';\n");
+		grammarBuilder.append("KW3140 : 'KW' '3140';\n");
+		grammarBuilder.append("KW3141 : 'KW' '3141';\n");
+		grammarBuilder.append("KW3142 : 'KW' '3142';\n");
+		grammarBuilder.append("KW3143 : 'KW' '3143';\n");
+		grammarBuilder.append("KW3144 : 'KW' '3144';\n");
+		grammarBuilder.append("KW3145 : 'KW' '3145';\n");
+		grammarBuilder.append("KW3146 : 'KW' '3146';\n");
+		grammarBuilder.append("KW3147 : 'KW' '3147';\n");
+		grammarBuilder.append("KW3148 : 'KW' '3148';\n");
+		grammarBuilder.append("KW3149 : 'KW' '3149';\n");
+		grammarBuilder.append("KW3150 : 'KW' '3150';\n");
+		grammarBuilder.append("KW3151 : 'KW' '3151';\n");
+		grammarBuilder.append("KW3152 : 'KW' '3152';\n");
+		grammarBuilder.append("KW3153 : 'KW' '3153';\n");
+		grammarBuilder.append("KW3154 : 'KW' '3154';\n");
+		grammarBuilder.append("KW3155 : 'KW' '3155';\n");
+		grammarBuilder.append("KW3156 : 'KW' '3156';\n");
+		grammarBuilder.append("KW3157 : 'KW' '3157';\n");
+		grammarBuilder.append("KW3158 : 'KW' '3158';\n");
+		grammarBuilder.append("KW3159 : 'KW' '3159';\n");
+		grammarBuilder.append("KW3160 : 'KW' '3160';\n");
+		grammarBuilder.append("KW3161 : 'KW' '3161';\n");
+		grammarBuilder.append("KW3162 : 'KW' '3162';\n");
+		grammarBuilder.append("KW3163 : 'KW' '3163';\n");
+		grammarBuilder.append("KW3164 : 'KW' '3164';\n");
+		grammarBuilder.append("KW3165 : 'KW' '3165';\n");
+		grammarBuilder.append("KW3166 : 'KW' '3166';\n");
+		grammarBuilder.append("KW3167 : 'KW' '3167';\n");
+		grammarBuilder.append("KW3168 : 'KW' '3168';\n");
+		grammarBuilder.append("KW3169 : 'KW' '3169';\n");
+		grammarBuilder.append("KW3170 : 'KW' '3170';\n");
+		grammarBuilder.append("KW3171 : 'KW' '3171';\n");
+		grammarBuilder.append("KW3172 : 'KW' '3172';\n");
+		grammarBuilder.append("KW3173 : 'KW' '3173';\n");
+		grammarBuilder.append("KW3174 : 'KW' '3174';\n");
+		grammarBuilder.append("KW3175 : 'KW' '3175';\n");
+		grammarBuilder.append("KW3176 : 'KW' '3176';\n");
+		grammarBuilder.append("KW3177 : 'KW' '3177';\n");
+		grammarBuilder.append("KW3178 : 'KW' '3178';\n");
+		grammarBuilder.append("KW3179 : 'KW' '3179';\n");
+		grammarBuilder.append("KW3180 : 'KW' '3180';\n");
+		grammarBuilder.append("KW3181 : 'KW' '3181';\n");
+		grammarBuilder.append("KW3182 : 'KW' '3182';\n");
+		grammarBuilder.append("KW3183 : 'KW' '3183';\n");
+		grammarBuilder.append("KW3184 : 'KW' '3184';\n");
+		grammarBuilder.append("KW3185 : 'KW' '3185';\n");
+		grammarBuilder.append("KW3186 : 'KW' '3186';\n");
+		grammarBuilder.append("KW3187 : 'KW' '3187';\n");
+		grammarBuilder.append("KW3188 : 'KW' '3188';\n");
+		grammarBuilder.append("KW3189 : 'KW' '3189';\n");
+		grammarBuilder.append("KW3190 : 'KW' '3190';\n");
+		grammarBuilder.append("KW3191 : 'KW' '3191';\n");
+		grammarBuilder.append("KW3192 : 'KW' '3192';\n");
+		grammarBuilder.append("KW3193 : 'KW' '3193';\n");
+		grammarBuilder.append("KW3194 : 'KW' '3194';\n");
+		grammarBuilder.append("KW3195 : 'KW' '3195';\n");
+		grammarBuilder.append("KW3196 : 'KW' '3196';\n");
+		grammarBuilder.append("KW3197 : 'KW' '3197';\n");
+		grammarBuilder.append("KW3198 : 'KW' '3198';\n");
+		grammarBuilder.append("KW3199 : 'KW' '3199';\n");
+		grammarBuilder.append("KW3200 : 'KW' '3200';\n");
+		grammarBuilder.append("KW3201 : 'KW' '3201';\n");
+		grammarBuilder.append("KW3202 : 'KW' '3202';\n");
+		grammarBuilder.append("KW3203 : 'KW' '3203';\n");
+		grammarBuilder.append("KW3204 : 'KW' '3204';\n");
+		grammarBuilder.append("KW3205 : 'KW' '3205';\n");
+		grammarBuilder.append("KW3206 : 'KW' '3206';\n");
+		grammarBuilder.append("KW3207 : 'KW' '3207';\n");
+		grammarBuilder.append("KW3208 : 'KW' '3208';\n");
+		grammarBuilder.append("KW3209 : 'KW' '3209';\n");
+		grammarBuilder.append("KW3210 : 'KW' '3210';\n");
+		grammarBuilder.append("KW3211 : 'KW' '3211';\n");
+		grammarBuilder.append("KW3212 : 'KW' '3212';\n");
+		grammarBuilder.append("KW3213 : 'KW' '3213';\n");
+		grammarBuilder.append("KW3214 : 'KW' '3214';\n");
+		grammarBuilder.append("KW3215 : 'KW' '3215';\n");
+		grammarBuilder.append("KW3216 : 'KW' '3216';\n");
+		grammarBuilder.append("KW3217 : 'KW' '3217';\n");
+		grammarBuilder.append("KW3218 : 'KW' '3218';\n");
+		grammarBuilder.append("KW3219 : 'KW' '3219';\n");
+		grammarBuilder.append("KW3220 : 'KW' '3220';\n");
+		grammarBuilder.append("KW3221 : 'KW' '3221';\n");
+		grammarBuilder.append("KW3222 : 'KW' '3222';\n");
+		grammarBuilder.append("KW3223 : 'KW' '3223';\n");
+		grammarBuilder.append("KW3224 : 'KW' '3224';\n");
+		grammarBuilder.append("KW3225 : 'KW' '3225';\n");
+		grammarBuilder.append("KW3226 : 'KW' '3226';\n");
+		grammarBuilder.append("KW3227 : 'KW' '3227';\n");
+		grammarBuilder.append("KW3228 : 'KW' '3228';\n");
+		grammarBuilder.append("KW3229 : 'KW' '3229';\n");
+		grammarBuilder.append("KW3230 : 'KW' '3230';\n");
+		grammarBuilder.append("KW3231 : 'KW' '3231';\n");
+		grammarBuilder.append("KW3232 : 'KW' '3232';\n");
+		grammarBuilder.append("KW3233 : 'KW' '3233';\n");
+		grammarBuilder.append("KW3234 : 'KW' '3234';\n");
+		grammarBuilder.append("KW3235 : 'KW' '3235';\n");
+		grammarBuilder.append("KW3236 : 'KW' '3236';\n");
+		grammarBuilder.append("KW3237 : 'KW' '3237';\n");
+		grammarBuilder.append("KW3238 : 'KW' '3238';\n");
+		grammarBuilder.append("KW3239 : 'KW' '3239';\n");
+		grammarBuilder.append("KW3240 : 'KW' '3240';\n");
+		grammarBuilder.append("KW3241 : 'KW' '3241';\n");
+		grammarBuilder.append("KW3242 : 'KW' '3242';\n");
+		grammarBuilder.append("KW3243 : 'KW' '3243';\n");
+		grammarBuilder.append("KW3244 : 'KW' '3244';\n");
+		grammarBuilder.append("KW3245 : 'KW' '3245';\n");
+		grammarBuilder.append("KW3246 : 'KW' '3246';\n");
+		grammarBuilder.append("KW3247 : 'KW' '3247';\n");
+		grammarBuilder.append("KW3248 : 'KW' '3248';\n");
+		grammarBuilder.append("KW3249 : 'KW' '3249';\n");
+		grammarBuilder.append("KW3250 : 'KW' '3250';\n");
+		grammarBuilder.append("KW3251 : 'KW' '3251';\n");
+		grammarBuilder.append("KW3252 : 'KW' '3252';\n");
+		grammarBuilder.append("KW3253 : 'KW' '3253';\n");
+		grammarBuilder.append("KW3254 : 'KW' '3254';\n");
+		grammarBuilder.append("KW3255 : 'KW' '3255';\n");
+		grammarBuilder.append("KW3256 : 'KW' '3256';\n");
+		grammarBuilder.append("KW3257 : 'KW' '3257';\n");
+		grammarBuilder.append("KW3258 : 'KW' '3258';\n");
+		grammarBuilder.append("KW3259 : 'KW' '3259';\n");
+		grammarBuilder.append("KW3260 : 'KW' '3260';\n");
+		grammarBuilder.append("KW3261 : 'KW' '3261';\n");
+		grammarBuilder.append("KW3262 : 'KW' '3262';\n");
+		grammarBuilder.append("KW3263 : 'KW' '3263';\n");
+		grammarBuilder.append("KW3264 : 'KW' '3264';\n");
+		grammarBuilder.append("KW3265 : 'KW' '3265';\n");
+		grammarBuilder.append("KW3266 : 'KW' '3266';\n");
+		grammarBuilder.append("KW3267 : 'KW' '3267';\n");
+		grammarBuilder.append("KW3268 : 'KW' '3268';\n");
+		grammarBuilder.append("KW3269 : 'KW' '3269';\n");
+		grammarBuilder.append("KW3270 : 'KW' '3270';\n");
+		grammarBuilder.append("KW3271 : 'KW' '3271';\n");
+		grammarBuilder.append("KW3272 : 'KW' '3272';\n");
+		grammarBuilder.append("KW3273 : 'KW' '3273';\n");
+		grammarBuilder.append("KW3274 : 'KW' '3274';\n");
+		grammarBuilder.append("KW3275 : 'KW' '3275';\n");
+		grammarBuilder.append("KW3276 : 'KW' '3276';\n");
+		grammarBuilder.append("KW3277 : 'KW' '3277';\n");
+		grammarBuilder.append("KW3278 : 'KW' '3278';\n");
+		grammarBuilder.append("KW3279 : 'KW' '3279';\n");
+		grammarBuilder.append("KW3280 : 'KW' '3280';\n");
+		grammarBuilder.append("KW3281 : 'KW' '3281';\n");
+		grammarBuilder.append("KW3282 : 'KW' '3282';\n");
+		grammarBuilder.append("KW3283 : 'KW' '3283';\n");
+		grammarBuilder.append("KW3284 : 'KW' '3284';\n");
+		grammarBuilder.append("KW3285 : 'KW' '3285';\n");
+		grammarBuilder.append("KW3286 : 'KW' '3286';\n");
+		grammarBuilder.append("KW3287 : 'KW' '3287';\n");
+		grammarBuilder.append("KW3288 : 'KW' '3288';\n");
+		grammarBuilder.append("KW3289 : 'KW' '3289';\n");
+		grammarBuilder.append("KW3290 : 'KW' '3290';\n");
+		grammarBuilder.append("KW3291 : 'KW' '3291';\n");
+		grammarBuilder.append("KW3292 : 'KW' '3292';\n");
+		grammarBuilder.append("KW3293 : 'KW' '3293';\n");
+		grammarBuilder.append("KW3294 : 'KW' '3294';\n");
+		grammarBuilder.append("KW3295 : 'KW' '3295';\n");
+		grammarBuilder.append("KW3296 : 'KW' '3296';\n");
+		grammarBuilder.append("KW3297 : 'KW' '3297';\n");
+		grammarBuilder.append("KW3298 : 'KW' '3298';\n");
+		grammarBuilder.append("KW3299 : 'KW' '3299';\n");
+		grammarBuilder.append("KW3300 : 'KW' '3300';\n");
+		grammarBuilder.append("KW3301 : 'KW' '3301';\n");
+		grammarBuilder.append("KW3302 : 'KW' '3302';\n");
+		grammarBuilder.append("KW3303 : 'KW' '3303';\n");
+		grammarBuilder.append("KW3304 : 'KW' '3304';\n");
+		grammarBuilder.append("KW3305 : 'KW' '3305';\n");
+		grammarBuilder.append("KW3306 : 'KW' '3306';\n");
+		grammarBuilder.append("KW3307 : 'KW' '3307';\n");
+		grammarBuilder.append("KW3308 : 'KW' '3308';\n");
+		grammarBuilder.append("KW3309 : 'KW' '3309';\n");
+		grammarBuilder.append("KW3310 : 'KW' '3310';\n");
+		grammarBuilder.append("KW3311 : 'KW' '3311';\n");
+		grammarBuilder.append("KW3312 : 'KW' '3312';\n");
+		grammarBuilder.append("KW3313 : 'KW' '3313';\n");
+		grammarBuilder.append("KW3314 : 'KW' '3314';\n");
+		grammarBuilder.append("KW3315 : 'KW' '3315';\n");
+		grammarBuilder.append("KW3316 : 'KW' '3316';\n");
+		grammarBuilder.append("KW3317 : 'KW' '3317';\n");
+		grammarBuilder.append("KW3318 : 'KW' '3318';\n");
+		grammarBuilder.append("KW3319 : 'KW' '3319';\n");
+		grammarBuilder.append("KW3320 : 'KW' '3320';\n");
+		grammarBuilder.append("KW3321 : 'KW' '3321';\n");
+		grammarBuilder.append("KW3322 : 'KW' '3322';\n");
+		grammarBuilder.append("KW3323 : 'KW' '3323';\n");
+		grammarBuilder.append("KW3324 : 'KW' '3324';\n");
+		grammarBuilder.append("KW3325 : 'KW' '3325';\n");
+		grammarBuilder.append("KW3326 : 'KW' '3326';\n");
+		grammarBuilder.append("KW3327 : 'KW' '3327';\n");
+		grammarBuilder.append("KW3328 : 'KW' '3328';\n");
+		grammarBuilder.append("KW3329 : 'KW' '3329';\n");
+		grammarBuilder.append("KW3330 : 'KW' '3330';\n");
+		grammarBuilder.append("KW3331 : 'KW' '3331';\n");
+		grammarBuilder.append("KW3332 : 'KW' '3332';\n");
+		grammarBuilder.append("KW3333 : 'KW' '3333';\n");
+		grammarBuilder.append("KW3334 : 'KW' '3334';\n");
+		grammarBuilder.append("KW3335 : 'KW' '3335';\n");
+		grammarBuilder.append("KW3336 : 'KW' '3336';\n");
+		grammarBuilder.append("KW3337 : 'KW' '3337';\n");
+		grammarBuilder.append("KW3338 : 'KW' '3338';\n");
+		grammarBuilder.append("KW3339 : 'KW' '3339';\n");
+		grammarBuilder.append("KW3340 : 'KW' '3340';\n");
+		grammarBuilder.append("KW3341 : 'KW' '3341';\n");
+		grammarBuilder.append("KW3342 : 'KW' '3342';\n");
+		grammarBuilder.append("KW3343 : 'KW' '3343';\n");
+		grammarBuilder.append("KW3344 : 'KW' '3344';\n");
+		grammarBuilder.append("KW3345 : 'KW' '3345';\n");
+		grammarBuilder.append("KW3346 : 'KW' '3346';\n");
+		grammarBuilder.append("KW3347 : 'KW' '3347';\n");
+		grammarBuilder.append("KW3348 : 'KW' '3348';\n");
+		grammarBuilder.append("KW3349 : 'KW' '3349';\n");
+		grammarBuilder.append("KW3350 : 'KW' '3350';\n");
+		grammarBuilder.append("KW3351 : 'KW' '3351';\n");
+		grammarBuilder.append("KW3352 : 'KW' '3352';\n");
+		grammarBuilder.append("KW3353 : 'KW' '3353';\n");
+		grammarBuilder.append("KW3354 : 'KW' '3354';\n");
+		grammarBuilder.append("KW3355 : 'KW' '3355';\n");
+		grammarBuilder.append("KW3356 : 'KW' '3356';\n");
+		grammarBuilder.append("KW3357 : 'KW' '3357';\n");
+		grammarBuilder.append("KW3358 : 'KW' '3358';\n");
+		grammarBuilder.append("KW3359 : 'KW' '3359';\n");
+		grammarBuilder.append("KW3360 : 'KW' '3360';\n");
+		grammarBuilder.append("KW3361 : 'KW' '3361';\n");
+		grammarBuilder.append("KW3362 : 'KW' '3362';\n");
+		grammarBuilder.append("KW3363 : 'KW' '3363';\n");
+		grammarBuilder.append("KW3364 : 'KW' '3364';\n");
+		grammarBuilder.append("KW3365 : 'KW' '3365';\n");
+		grammarBuilder.append("KW3366 : 'KW' '3366';\n");
+		grammarBuilder.append("KW3367 : 'KW' '3367';\n");
+		grammarBuilder.append("KW3368 : 'KW' '3368';\n");
+		grammarBuilder.append("KW3369 : 'KW' '3369';\n");
+		grammarBuilder.append("KW3370 : 'KW' '3370';\n");
+		grammarBuilder.append("KW3371 : 'KW' '3371';\n");
+		grammarBuilder.append("KW3372 : 'KW' '3372';\n");
+		grammarBuilder.append("KW3373 : 'KW' '3373';\n");
+		grammarBuilder.append("KW3374 : 'KW' '3374';\n");
+		grammarBuilder.append("KW3375 : 'KW' '3375';\n");
+		grammarBuilder.append("KW3376 : 'KW' '3376';\n");
+		grammarBuilder.append("KW3377 : 'KW' '3377';\n");
+		grammarBuilder.append("KW3378 : 'KW' '3378';\n");
+		grammarBuilder.append("KW3379 : 'KW' '3379';\n");
+		grammarBuilder.append("KW3380 : 'KW' '3380';\n");
+		grammarBuilder.append("KW3381 : 'KW' '3381';\n");
+		grammarBuilder.append("KW3382 : 'KW' '3382';\n");
+		grammarBuilder.append("KW3383 : 'KW' '3383';\n");
+		grammarBuilder.append("KW3384 : 'KW' '3384';\n");
+		grammarBuilder.append("KW3385 : 'KW' '3385';\n");
+		grammarBuilder.append("KW3386 : 'KW' '3386';\n");
+		grammarBuilder.append("KW3387 : 'KW' '3387';\n");
+		grammarBuilder.append("KW3388 : 'KW' '3388';\n");
+		grammarBuilder.append("KW3389 : 'KW' '3389';\n");
+		grammarBuilder.append("KW3390 : 'KW' '3390';\n");
+		grammarBuilder.append("KW3391 : 'KW' '3391';\n");
+		grammarBuilder.append("KW3392 : 'KW' '3392';\n");
+		grammarBuilder.append("KW3393 : 'KW' '3393';\n");
+		grammarBuilder.append("KW3394 : 'KW' '3394';\n");
+		grammarBuilder.append("KW3395 : 'KW' '3395';\n");
+		grammarBuilder.append("KW3396 : 'KW' '3396';\n");
+		grammarBuilder.append("KW3397 : 'KW' '3397';\n");
+		grammarBuilder.append("KW3398 : 'KW' '3398';\n");
+		grammarBuilder.append("KW3399 : 'KW' '3399';\n");
+		grammarBuilder.append("KW3400 : 'KW' '3400';\n");
+		grammarBuilder.append("KW3401 : 'KW' '3401';\n");
+		grammarBuilder.append("KW3402 : 'KW' '3402';\n");
+		grammarBuilder.append("KW3403 : 'KW' '3403';\n");
+		grammarBuilder.append("KW3404 : 'KW' '3404';\n");
+		grammarBuilder.append("KW3405 : 'KW' '3405';\n");
+		grammarBuilder.append("KW3406 : 'KW' '3406';\n");
+		grammarBuilder.append("KW3407 : 'KW' '3407';\n");
+		grammarBuilder.append("KW3408 : 'KW' '3408';\n");
+		grammarBuilder.append("KW3409 : 'KW' '3409';\n");
+		grammarBuilder.append("KW3410 : 'KW' '3410';\n");
+		grammarBuilder.append("KW3411 : 'KW' '3411';\n");
+		grammarBuilder.append("KW3412 : 'KW' '3412';\n");
+		grammarBuilder.append("KW3413 : 'KW' '3413';\n");
+		grammarBuilder.append("KW3414 : 'KW' '3414';\n");
+		grammarBuilder.append("KW3415 : 'KW' '3415';\n");
+		grammarBuilder.append("KW3416 : 'KW' '3416';\n");
+		grammarBuilder.append("KW3417 : 'KW' '3417';\n");
+		grammarBuilder.append("KW3418 : 'KW' '3418';\n");
+		grammarBuilder.append("KW3419 : 'KW' '3419';\n");
+		grammarBuilder.append("KW3420 : 'KW' '3420';\n");
+		grammarBuilder.append("KW3421 : 'KW' '3421';\n");
+		grammarBuilder.append("KW3422 : 'KW' '3422';\n");
+		grammarBuilder.append("KW3423 : 'KW' '3423';\n");
+		grammarBuilder.append("KW3424 : 'KW' '3424';\n");
+		grammarBuilder.append("KW3425 : 'KW' '3425';\n");
+		grammarBuilder.append("KW3426 : 'KW' '3426';\n");
+		grammarBuilder.append("KW3427 : 'KW' '3427';\n");
+		grammarBuilder.append("KW3428 : 'KW' '3428';\n");
+		grammarBuilder.append("KW3429 : 'KW' '3429';\n");
+		grammarBuilder.append("KW3430 : 'KW' '3430';\n");
+		grammarBuilder.append("KW3431 : 'KW' '3431';\n");
+		grammarBuilder.append("KW3432 : 'KW' '3432';\n");
+		grammarBuilder.append("KW3433 : 'KW' '3433';\n");
+		grammarBuilder.append("KW3434 : 'KW' '3434';\n");
+		grammarBuilder.append("KW3435 : 'KW' '3435';\n");
+		grammarBuilder.append("KW3436 : 'KW' '3436';\n");
+		grammarBuilder.append("KW3437 : 'KW' '3437';\n");
+		grammarBuilder.append("KW3438 : 'KW' '3438';\n");
+		grammarBuilder.append("KW3439 : 'KW' '3439';\n");
+		grammarBuilder.append("KW3440 : 'KW' '3440';\n");
+		grammarBuilder.append("KW3441 : 'KW' '3441';\n");
+		grammarBuilder.append("KW3442 : 'KW' '3442';\n");
+		grammarBuilder.append("KW3443 : 'KW' '3443';\n");
+		grammarBuilder.append("KW3444 : 'KW' '3444';\n");
+		grammarBuilder.append("KW3445 : 'KW' '3445';\n");
+		grammarBuilder.append("KW3446 : 'KW' '3446';\n");
+		grammarBuilder.append("KW3447 : 'KW' '3447';\n");
+		grammarBuilder.append("KW3448 : 'KW' '3448';\n");
+		grammarBuilder.append("KW3449 : 'KW' '3449';\n");
+		grammarBuilder.append("KW3450 : 'KW' '3450';\n");
+		grammarBuilder.append("KW3451 : 'KW' '3451';\n");
+		grammarBuilder.append("KW3452 : 'KW' '3452';\n");
+		grammarBuilder.append("KW3453 : 'KW' '3453';\n");
+		grammarBuilder.append("KW3454 : 'KW' '3454';\n");
+		grammarBuilder.append("KW3455 : 'KW' '3455';\n");
+		grammarBuilder.append("KW3456 : 'KW' '3456';\n");
+		grammarBuilder.append("KW3457 : 'KW' '3457';\n");
+		grammarBuilder.append("KW3458 : 'KW' '3458';\n");
+		grammarBuilder.append("KW3459 : 'KW' '3459';\n");
+		grammarBuilder.append("KW3460 : 'KW' '3460';\n");
+		grammarBuilder.append("KW3461 : 'KW' '3461';\n");
+		grammarBuilder.append("KW3462 : 'KW' '3462';\n");
+		grammarBuilder.append("KW3463 : 'KW' '3463';\n");
+		grammarBuilder.append("KW3464 : 'KW' '3464';\n");
+		grammarBuilder.append("KW3465 : 'KW' '3465';\n");
+		grammarBuilder.append("KW3466 : 'KW' '3466';\n");
+		grammarBuilder.append("KW3467 : 'KW' '3467';\n");
+		grammarBuilder.append("KW3468 : 'KW' '3468';\n");
+		grammarBuilder.append("KW3469 : 'KW' '3469';\n");
+		grammarBuilder.append("KW3470 : 'KW' '3470';\n");
+		grammarBuilder.append("KW3471 : 'KW' '3471';\n");
+		grammarBuilder.append("KW3472 : 'KW' '3472';\n");
+		grammarBuilder.append("KW3473 : 'KW' '3473';\n");
+		grammarBuilder.append("KW3474 : 'KW' '3474';\n");
+		grammarBuilder.append("KW3475 : 'KW' '3475';\n");
+		grammarBuilder.append("KW3476 : 'KW' '3476';\n");
+		grammarBuilder.append("KW3477 : 'KW' '3477';\n");
+		grammarBuilder.append("KW3478 : 'KW' '3478';\n");
+		grammarBuilder.append("KW3479 : 'KW' '3479';\n");
+		grammarBuilder.append("KW3480 : 'KW' '3480';\n");
+		grammarBuilder.append("KW3481 : 'KW' '3481';\n");
+		grammarBuilder.append("KW3482 : 'KW' '3482';\n");
+		grammarBuilder.append("KW3483 : 'KW' '3483';\n");
+		grammarBuilder.append("KW3484 : 'KW' '3484';\n");
+		grammarBuilder.append("KW3485 : 'KW' '3485';\n");
+		grammarBuilder.append("KW3486 : 'KW' '3486';\n");
+		grammarBuilder.append("KW3487 : 'KW' '3487';\n");
+		grammarBuilder.append("KW3488 : 'KW' '3488';\n");
+		grammarBuilder.append("KW3489 : 'KW' '3489';\n");
+		grammarBuilder.append("KW3490 : 'KW' '3490';\n");
+		grammarBuilder.append("KW3491 : 'KW' '3491';\n");
+		grammarBuilder.append("KW3492 : 'KW' '3492';\n");
+		grammarBuilder.append("KW3493 : 'KW' '3493';\n");
+		grammarBuilder.append("KW3494 : 'KW' '3494';\n");
+		grammarBuilder.append("KW3495 : 'KW' '3495';\n");
+		grammarBuilder.append("KW3496 : 'KW' '3496';\n");
+		grammarBuilder.append("KW3497 : 'KW' '3497';\n");
+		grammarBuilder.append("KW3498 : 'KW' '3498';\n");
+		grammarBuilder.append("KW3499 : 'KW' '3499';\n");
+		grammarBuilder.append("KW3500 : 'KW' '3500';\n");
+		grammarBuilder.append("KW3501 : 'KW' '3501';\n");
+		grammarBuilder.append("KW3502 : 'KW' '3502';\n");
+		grammarBuilder.append("KW3503 : 'KW' '3503';\n");
+		grammarBuilder.append("KW3504 : 'KW' '3504';\n");
+		grammarBuilder.append("KW3505 : 'KW' '3505';\n");
+		grammarBuilder.append("KW3506 : 'KW' '3506';\n");
+		grammarBuilder.append("KW3507 : 'KW' '3507';\n");
+		grammarBuilder.append("KW3508 : 'KW' '3508';\n");
+		grammarBuilder.append("KW3509 : 'KW' '3509';\n");
+		grammarBuilder.append("KW3510 : 'KW' '3510';\n");
+		grammarBuilder.append("KW3511 : 'KW' '3511';\n");
+		grammarBuilder.append("KW3512 : 'KW' '3512';\n");
+		grammarBuilder.append("KW3513 : 'KW' '3513';\n");
+		grammarBuilder.append("KW3514 : 'KW' '3514';\n");
+		grammarBuilder.append("KW3515 : 'KW' '3515';\n");
+		grammarBuilder.append("KW3516 : 'KW' '3516';\n");
+		grammarBuilder.append("KW3517 : 'KW' '3517';\n");
+		grammarBuilder.append("KW3518 : 'KW' '3518';\n");
+		grammarBuilder.append("KW3519 : 'KW' '3519';\n");
+		grammarBuilder.append("KW3520 : 'KW' '3520';\n");
+		grammarBuilder.append("KW3521 : 'KW' '3521';\n");
+		grammarBuilder.append("KW3522 : 'KW' '3522';\n");
+		grammarBuilder.append("KW3523 : 'KW' '3523';\n");
+		grammarBuilder.append("KW3524 : 'KW' '3524';\n");
+		grammarBuilder.append("KW3525 : 'KW' '3525';\n");
+		grammarBuilder.append("KW3526 : 'KW' '3526';\n");
+		grammarBuilder.append("KW3527 : 'KW' '3527';\n");
+		grammarBuilder.append("KW3528 : 'KW' '3528';\n");
+		grammarBuilder.append("KW3529 : 'KW' '3529';\n");
+		grammarBuilder.append("KW3530 : 'KW' '3530';\n");
+		grammarBuilder.append("KW3531 : 'KW' '3531';\n");
+		grammarBuilder.append("KW3532 : 'KW' '3532';\n");
+		grammarBuilder.append("KW3533 : 'KW' '3533';\n");
+		grammarBuilder.append("KW3534 : 'KW' '3534';\n");
+		grammarBuilder.append("KW3535 : 'KW' '3535';\n");
+		grammarBuilder.append("KW3536 : 'KW' '3536';\n");
+		grammarBuilder.append("KW3537 : 'KW' '3537';\n");
+		grammarBuilder.append("KW3538 : 'KW' '3538';\n");
+		grammarBuilder.append("KW3539 : 'KW' '3539';\n");
+		grammarBuilder.append("KW3540 : 'KW' '3540';\n");
+		grammarBuilder.append("KW3541 : 'KW' '3541';\n");
+		grammarBuilder.append("KW3542 : 'KW' '3542';\n");
+		grammarBuilder.append("KW3543 : 'KW' '3543';\n");
+		grammarBuilder.append("KW3544 : 'KW' '3544';\n");
+		grammarBuilder.append("KW3545 : 'KW' '3545';\n");
+		grammarBuilder.append("KW3546 : 'KW' '3546';\n");
+		grammarBuilder.append("KW3547 : 'KW' '3547';\n");
+		grammarBuilder.append("KW3548 : 'KW' '3548';\n");
+		grammarBuilder.append("KW3549 : 'KW' '3549';\n");
+		grammarBuilder.append("KW3550 : 'KW' '3550';\n");
+		grammarBuilder.append("KW3551 : 'KW' '3551';\n");
+		grammarBuilder.append("KW3552 : 'KW' '3552';\n");
+		grammarBuilder.append("KW3553 : 'KW' '3553';\n");
+		grammarBuilder.append("KW3554 : 'KW' '3554';\n");
+		grammarBuilder.append("KW3555 : 'KW' '3555';\n");
+		grammarBuilder.append("KW3556 : 'KW' '3556';\n");
+		grammarBuilder.append("KW3557 : 'KW' '3557';\n");
+		grammarBuilder.append("KW3558 : 'KW' '3558';\n");
+		grammarBuilder.append("KW3559 : 'KW' '3559';\n");
+		grammarBuilder.append("KW3560 : 'KW' '3560';\n");
+		grammarBuilder.append("KW3561 : 'KW' '3561';\n");
+		grammarBuilder.append("KW3562 : 'KW' '3562';\n");
+		grammarBuilder.append("KW3563 : 'KW' '3563';\n");
+		grammarBuilder.append("KW3564 : 'KW' '3564';\n");
+		grammarBuilder.append("KW3565 : 'KW' '3565';\n");
+		grammarBuilder.append("KW3566 : 'KW' '3566';\n");
+		grammarBuilder.append("KW3567 : 'KW' '3567';\n");
+		grammarBuilder.append("KW3568 : 'KW' '3568';\n");
+		grammarBuilder.append("KW3569 : 'KW' '3569';\n");
+		grammarBuilder.append("KW3570 : 'KW' '3570';\n");
+		grammarBuilder.append("KW3571 : 'KW' '3571';\n");
+		grammarBuilder.append("KW3572 : 'KW' '3572';\n");
+		grammarBuilder.append("KW3573 : 'KW' '3573';\n");
+		grammarBuilder.append("KW3574 : 'KW' '3574';\n");
+		grammarBuilder.append("KW3575 : 'KW' '3575';\n");
+		grammarBuilder.append("KW3576 : 'KW' '3576';\n");
+		grammarBuilder.append("KW3577 : 'KW' '3577';\n");
+		grammarBuilder.append("KW3578 : 'KW' '3578';\n");
+		grammarBuilder.append("KW3579 : 'KW' '3579';\n");
+		grammarBuilder.append("KW3580 : 'KW' '3580';\n");
+		grammarBuilder.append("KW3581 : 'KW' '3581';\n");
+		grammarBuilder.append("KW3582 : 'KW' '3582';\n");
+		grammarBuilder.append("KW3583 : 'KW' '3583';\n");
+		grammarBuilder.append("KW3584 : 'KW' '3584';\n");
+		grammarBuilder.append("KW3585 : 'KW' '3585';\n");
+		grammarBuilder.append("KW3586 : 'KW' '3586';\n");
+		grammarBuilder.append("KW3587 : 'KW' '3587';\n");
+		grammarBuilder.append("KW3588 : 'KW' '3588';\n");
+		grammarBuilder.append("KW3589 : 'KW' '3589';\n");
+		grammarBuilder.append("KW3590 : 'KW' '3590';\n");
+		grammarBuilder.append("KW3591 : 'KW' '3591';\n");
+		grammarBuilder.append("KW3592 : 'KW' '3592';\n");
+		grammarBuilder.append("KW3593 : 'KW' '3593';\n");
+		grammarBuilder.append("KW3594 : 'KW' '3594';\n");
+		grammarBuilder.append("KW3595 : 'KW' '3595';\n");
+		grammarBuilder.append("KW3596 : 'KW' '3596';\n");
+		grammarBuilder.append("KW3597 : 'KW' '3597';\n");
+		grammarBuilder.append("KW3598 : 'KW' '3598';\n");
+		grammarBuilder.append("KW3599 : 'KW' '3599';\n");
+		grammarBuilder.append("KW3600 : 'KW' '3600';\n");
+		grammarBuilder.append("KW3601 : 'KW' '3601';\n");
+		grammarBuilder.append("KW3602 : 'KW' '3602';\n");
+		grammarBuilder.append("KW3603 : 'KW' '3603';\n");
+		grammarBuilder.append("KW3604 : 'KW' '3604';\n");
+		grammarBuilder.append("KW3605 : 'KW' '3605';\n");
+		grammarBuilder.append("KW3606 : 'KW' '3606';\n");
+		grammarBuilder.append("KW3607 : 'KW' '3607';\n");
+		grammarBuilder.append("KW3608 : 'KW' '3608';\n");
+		grammarBuilder.append("KW3609 : 'KW' '3609';\n");
+		grammarBuilder.append("KW3610 : 'KW' '3610';\n");
+		grammarBuilder.append("KW3611 : 'KW' '3611';\n");
+		grammarBuilder.append("KW3612 : 'KW' '3612';\n");
+		grammarBuilder.append("KW3613 : 'KW' '3613';\n");
+		grammarBuilder.append("KW3614 : 'KW' '3614';\n");
+		grammarBuilder.append("KW3615 : 'KW' '3615';\n");
+		grammarBuilder.append("KW3616 : 'KW' '3616';\n");
+		grammarBuilder.append("KW3617 : 'KW' '3617';\n");
+		grammarBuilder.append("KW3618 : 'KW' '3618';\n");
+		grammarBuilder.append("KW3619 : 'KW' '3619';\n");
+		grammarBuilder.append("KW3620 : 'KW' '3620';\n");
+		grammarBuilder.append("KW3621 : 'KW' '3621';\n");
+		grammarBuilder.append("KW3622 : 'KW' '3622';\n");
+		grammarBuilder.append("KW3623 : 'KW' '3623';\n");
+		grammarBuilder.append("KW3624 : 'KW' '3624';\n");
+		grammarBuilder.append("KW3625 : 'KW' '3625';\n");
+		grammarBuilder.append("KW3626 : 'KW' '3626';\n");
+		grammarBuilder.append("KW3627 : 'KW' '3627';\n");
+		grammarBuilder.append("KW3628 : 'KW' '3628';\n");
+		grammarBuilder.append("KW3629 : 'KW' '3629';\n");
+		grammarBuilder.append("KW3630 : 'KW' '3630';\n");
+		grammarBuilder.append("KW3631 : 'KW' '3631';\n");
+		grammarBuilder.append("KW3632 : 'KW' '3632';\n");
+		grammarBuilder.append("KW3633 : 'KW' '3633';\n");
+		grammarBuilder.append("KW3634 : 'KW' '3634';\n");
+		grammarBuilder.append("KW3635 : 'KW' '3635';\n");
+		grammarBuilder.append("KW3636 : 'KW' '3636';\n");
+		grammarBuilder.append("KW3637 : 'KW' '3637';\n");
+		grammarBuilder.append("KW3638 : 'KW' '3638';\n");
+		grammarBuilder.append("KW3639 : 'KW' '3639';\n");
+		grammarBuilder.append("KW3640 : 'KW' '3640';\n");
+		grammarBuilder.append("KW3641 : 'KW' '3641';\n");
+		grammarBuilder.append("KW3642 : 'KW' '3642';\n");
+		grammarBuilder.append("KW3643 : 'KW' '3643';\n");
+		grammarBuilder.append("KW3644 : 'KW' '3644';\n");
+		grammarBuilder.append("KW3645 : 'KW' '3645';\n");
+		grammarBuilder.append("KW3646 : 'KW' '3646';\n");
+		grammarBuilder.append("KW3647 : 'KW' '3647';\n");
+		grammarBuilder.append("KW3648 : 'KW' '3648';\n");
+		grammarBuilder.append("KW3649 : 'KW' '3649';\n");
+		grammarBuilder.append("KW3650 : 'KW' '3650';\n");
+		grammarBuilder.append("KW3651 : 'KW' '3651';\n");
+		grammarBuilder.append("KW3652 : 'KW' '3652';\n");
+		grammarBuilder.append("KW3653 : 'KW' '3653';\n");
+		grammarBuilder.append("KW3654 : 'KW' '3654';\n");
+		grammarBuilder.append("KW3655 : 'KW' '3655';\n");
+		grammarBuilder.append("KW3656 : 'KW' '3656';\n");
+		grammarBuilder.append("KW3657 : 'KW' '3657';\n");
+		grammarBuilder.append("KW3658 : 'KW' '3658';\n");
+		grammarBuilder.append("KW3659 : 'KW' '3659';\n");
+		grammarBuilder.append("KW3660 : 'KW' '3660';\n");
+		grammarBuilder.append("KW3661 : 'KW' '3661';\n");
+		grammarBuilder.append("KW3662 : 'KW' '3662';\n");
+		grammarBuilder.append("KW3663 : 'KW' '3663';\n");
+		grammarBuilder.append("KW3664 : 'KW' '3664';\n");
+		grammarBuilder.append("KW3665 : 'KW' '3665';\n");
+		grammarBuilder.append("KW3666 : 'KW' '3666';\n");
+		grammarBuilder.append("KW3667 : 'KW' '3667';\n");
+		grammarBuilder.append("KW3668 : 'KW' '3668';\n");
+		grammarBuilder.append("KW3669 : 'KW' '3669';\n");
+		grammarBuilder.append("KW3670 : 'KW' '3670';\n");
+		grammarBuilder.append("KW3671 : 'KW' '3671';\n");
+		grammarBuilder.append("KW3672 : 'KW' '3672';\n");
+		grammarBuilder.append("KW3673 : 'KW' '3673';\n");
+		grammarBuilder.append("KW3674 : 'KW' '3674';\n");
+		grammarBuilder.append("KW3675 : 'KW' '3675';\n");
+		grammarBuilder.append("KW3676 : 'KW' '3676';\n");
+		grammarBuilder.append("KW3677 : 'KW' '3677';\n");
+		grammarBuilder.append("KW3678 : 'KW' '3678';\n");
+		grammarBuilder.append("KW3679 : 'KW' '3679';\n");
+		grammarBuilder.append("KW3680 : 'KW' '3680';\n");
+		grammarBuilder.append("KW3681 : 'KW' '3681';\n");
+		grammarBuilder.append("KW3682 : 'KW' '3682';\n");
+		grammarBuilder.append("KW3683 : 'KW' '3683';\n");
+		grammarBuilder.append("KW3684 : 'KW' '3684';\n");
+		grammarBuilder.append("KW3685 : 'KW' '3685';\n");
+		grammarBuilder.append("KW3686 : 'KW' '3686';\n");
+		grammarBuilder.append("KW3687 : 'KW' '3687';\n");
+		grammarBuilder.append("KW3688 : 'KW' '3688';\n");
+		grammarBuilder.append("KW3689 : 'KW' '3689';\n");
+		grammarBuilder.append("KW3690 : 'KW' '3690';\n");
+		grammarBuilder.append("KW3691 : 'KW' '3691';\n");
+		grammarBuilder.append("KW3692 : 'KW' '3692';\n");
+		grammarBuilder.append("KW3693 : 'KW' '3693';\n");
+		grammarBuilder.append("KW3694 : 'KW' '3694';\n");
+		grammarBuilder.append("KW3695 : 'KW' '3695';\n");
+		grammarBuilder.append("KW3696 : 'KW' '3696';\n");
+		grammarBuilder.append("KW3697 : 'KW' '3697';\n");
+		grammarBuilder.append("KW3698 : 'KW' '3698';\n");
+		grammarBuilder.append("KW3699 : 'KW' '3699';\n");
+		grammarBuilder.append("KW3700 : 'KW' '3700';\n");
+		grammarBuilder.append("KW3701 : 'KW' '3701';\n");
+		grammarBuilder.append("KW3702 : 'KW' '3702';\n");
+		grammarBuilder.append("KW3703 : 'KW' '3703';\n");
+		grammarBuilder.append("KW3704 : 'KW' '3704';\n");
+		grammarBuilder.append("KW3705 : 'KW' '3705';\n");
+		grammarBuilder.append("KW3706 : 'KW' '3706';\n");
+		grammarBuilder.append("KW3707 : 'KW' '3707';\n");
+		grammarBuilder.append("KW3708 : 'KW' '3708';\n");
+		grammarBuilder.append("KW3709 : 'KW' '3709';\n");
+		grammarBuilder.append("KW3710 : 'KW' '3710';\n");
+		grammarBuilder.append("KW3711 : 'KW' '3711';\n");
+		grammarBuilder.append("KW3712 : 'KW' '3712';\n");
+		grammarBuilder.append("KW3713 : 'KW' '3713';\n");
+		grammarBuilder.append("KW3714 : 'KW' '3714';\n");
+		grammarBuilder.append("KW3715 : 'KW' '3715';\n");
+		grammarBuilder.append("KW3716 : 'KW' '3716';\n");
+		grammarBuilder.append("KW3717 : 'KW' '3717';\n");
+		grammarBuilder.append("KW3718 : 'KW' '3718';\n");
+		grammarBuilder.append("KW3719 : 'KW' '3719';\n");
+		grammarBuilder.append("KW3720 : 'KW' '3720';\n");
+		grammarBuilder.append("KW3721 : 'KW' '3721';\n");
+		grammarBuilder.append("KW3722 : 'KW' '3722';\n");
+		grammarBuilder.append("KW3723 : 'KW' '3723';\n");
+		grammarBuilder.append("KW3724 : 'KW' '3724';\n");
+		grammarBuilder.append("KW3725 : 'KW' '3725';\n");
+		grammarBuilder.append("KW3726 : 'KW' '3726';\n");
+		grammarBuilder.append("KW3727 : 'KW' '3727';\n");
+		grammarBuilder.append("KW3728 : 'KW' '3728';\n");
+		grammarBuilder.append("KW3729 : 'KW' '3729';\n");
+		grammarBuilder.append("KW3730 : 'KW' '3730';\n");
+		grammarBuilder.append("KW3731 : 'KW' '3731';\n");
+		grammarBuilder.append("KW3732 : 'KW' '3732';\n");
+		grammarBuilder.append("KW3733 : 'KW' '3733';\n");
+		grammarBuilder.append("KW3734 : 'KW' '3734';\n");
+		grammarBuilder.append("KW3735 : 'KW' '3735';\n");
+		grammarBuilder.append("KW3736 : 'KW' '3736';\n");
+		grammarBuilder.append("KW3737 : 'KW' '3737';\n");
+		grammarBuilder.append("KW3738 : 'KW' '3738';\n");
+		grammarBuilder.append("KW3739 : 'KW' '3739';\n");
+		grammarBuilder.append("KW3740 : 'KW' '3740';\n");
+		grammarBuilder.append("KW3741 : 'KW' '3741';\n");
+		grammarBuilder.append("KW3742 : 'KW' '3742';\n");
+		grammarBuilder.append("KW3743 : 'KW' '3743';\n");
+		grammarBuilder.append("KW3744 : 'KW' '3744';\n");
+		grammarBuilder.append("KW3745 : 'KW' '3745';\n");
+		grammarBuilder.append("KW3746 : 'KW' '3746';\n");
+		grammarBuilder.append("KW3747 : 'KW' '3747';\n");
+		grammarBuilder.append("KW3748 : 'KW' '3748';\n");
+		grammarBuilder.append("KW3749 : 'KW' '3749';\n");
+		grammarBuilder.append("KW3750 : 'KW' '3750';\n");
+		grammarBuilder.append("KW3751 : 'KW' '3751';\n");
+		grammarBuilder.append("KW3752 : 'KW' '3752';\n");
+		grammarBuilder.append("KW3753 : 'KW' '3753';\n");
+		grammarBuilder.append("KW3754 : 'KW' '3754';\n");
+		grammarBuilder.append("KW3755 : 'KW' '3755';\n");
+		grammarBuilder.append("KW3756 : 'KW' '3756';\n");
+		grammarBuilder.append("KW3757 : 'KW' '3757';\n");
+		grammarBuilder.append("KW3758 : 'KW' '3758';\n");
+		grammarBuilder.append("KW3759 : 'KW' '3759';\n");
+		grammarBuilder.append("KW3760 : 'KW' '3760';\n");
+		grammarBuilder.append("KW3761 : 'KW' '3761';\n");
+		grammarBuilder.append("KW3762 : 'KW' '3762';\n");
+		grammarBuilder.append("KW3763 : 'KW' '3763';\n");
+		grammarBuilder.append("KW3764 : 'KW' '3764';\n");
+		grammarBuilder.append("KW3765 : 'KW' '3765';\n");
+		grammarBuilder.append("KW3766 : 'KW' '3766';\n");
+		grammarBuilder.append("KW3767 : 'KW' '3767';\n");
+		grammarBuilder.append("KW3768 : 'KW' '3768';\n");
+		grammarBuilder.append("KW3769 : 'KW' '3769';\n");
+		grammarBuilder.append("KW3770 : 'KW' '3770';\n");
+		grammarBuilder.append("KW3771 : 'KW' '3771';\n");
+		grammarBuilder.append("KW3772 : 'KW' '3772';\n");
+		grammarBuilder.append("KW3773 : 'KW' '3773';\n");
+		grammarBuilder.append("KW3774 : 'KW' '3774';\n");
+		grammarBuilder.append("KW3775 : 'KW' '3775';\n");
+		grammarBuilder.append("KW3776 : 'KW' '3776';\n");
+		grammarBuilder.append("KW3777 : 'KW' '3777';\n");
+		grammarBuilder.append("KW3778 : 'KW' '3778';\n");
+		grammarBuilder.append("KW3779 : 'KW' '3779';\n");
+		grammarBuilder.append("KW3780 : 'KW' '3780';\n");
+		grammarBuilder.append("KW3781 : 'KW' '3781';\n");
+		grammarBuilder.append("KW3782 : 'KW' '3782';\n");
+		grammarBuilder.append("KW3783 : 'KW' '3783';\n");
+		grammarBuilder.append("KW3784 : 'KW' '3784';\n");
+		grammarBuilder.append("KW3785 : 'KW' '3785';\n");
+		grammarBuilder.append("KW3786 : 'KW' '3786';\n");
+		grammarBuilder.append("KW3787 : 'KW' '3787';\n");
+		grammarBuilder.append("KW3788 : 'KW' '3788';\n");
+		grammarBuilder.append("KW3789 : 'KW' '3789';\n");
+		grammarBuilder.append("KW3790 : 'KW' '3790';\n");
+		grammarBuilder.append("KW3791 : 'KW' '3791';\n");
+		grammarBuilder.append("KW3792 : 'KW' '3792';\n");
+		grammarBuilder.append("KW3793 : 'KW' '3793';\n");
+		grammarBuilder.append("KW3794 : 'KW' '3794';\n");
+		grammarBuilder.append("KW3795 : 'KW' '3795';\n");
+		grammarBuilder.append("KW3796 : 'KW' '3796';\n");
+		grammarBuilder.append("KW3797 : 'KW' '3797';\n");
+		grammarBuilder.append("KW3798 : 'KW' '3798';\n");
+		grammarBuilder.append("KW3799 : 'KW' '3799';\n");
+		grammarBuilder.append("KW3800 : 'KW' '3800';\n");
+		grammarBuilder.append("KW3801 : 'KW' '3801';\n");
+		grammarBuilder.append("KW3802 : 'KW' '3802';\n");
+		grammarBuilder.append("KW3803 : 'KW' '3803';\n");
+		grammarBuilder.append("KW3804 : 'KW' '3804';\n");
+		grammarBuilder.append("KW3805 : 'KW' '3805';\n");
+		grammarBuilder.append("KW3806 : 'KW' '3806';\n");
+		grammarBuilder.append("KW3807 : 'KW' '3807';\n");
+		grammarBuilder.append("KW3808 : 'KW' '3808';\n");
+		grammarBuilder.append("KW3809 : 'KW' '3809';\n");
+		grammarBuilder.append("KW3810 : 'KW' '3810';\n");
+		grammarBuilder.append("KW3811 : 'KW' '3811';\n");
+		grammarBuilder.append("KW3812 : 'KW' '3812';\n");
+		grammarBuilder.append("KW3813 : 'KW' '3813';\n");
+		grammarBuilder.append("KW3814 : 'KW' '3814';\n");
+		grammarBuilder.append("KW3815 : 'KW' '3815';\n");
+		grammarBuilder.append("KW3816 : 'KW' '3816';\n");
+		grammarBuilder.append("KW3817 : 'KW' '3817';\n");
+		grammarBuilder.append("KW3818 : 'KW' '3818';\n");
+		grammarBuilder.append("KW3819 : 'KW' '3819';\n");
+		grammarBuilder.append("KW3820 : 'KW' '3820';\n");
+		grammarBuilder.append("KW3821 : 'KW' '3821';\n");
+		grammarBuilder.append("KW3822 : 'KW' '3822';\n");
+		grammarBuilder.append("KW3823 : 'KW' '3823';\n");
+		grammarBuilder.append("KW3824 : 'KW' '3824';\n");
+		grammarBuilder.append("KW3825 : 'KW' '3825';\n");
+		grammarBuilder.append("KW3826 : 'KW' '3826';\n");
+		grammarBuilder.append("KW3827 : 'KW' '3827';\n");
+		grammarBuilder.append("KW3828 : 'KW' '3828';\n");
+		grammarBuilder.append("KW3829 : 'KW' '3829';\n");
+		grammarBuilder.append("KW3830 : 'KW' '3830';\n");
+		grammarBuilder.append("KW3831 : 'KW' '3831';\n");
+		grammarBuilder.append("KW3832 : 'KW' '3832';\n");
+		grammarBuilder.append("KW3833 : 'KW' '3833';\n");
+		grammarBuilder.append("KW3834 : 'KW' '3834';\n");
+		grammarBuilder.append("KW3835 : 'KW' '3835';\n");
+		grammarBuilder.append("KW3836 : 'KW' '3836';\n");
+		grammarBuilder.append("KW3837 : 'KW' '3837';\n");
+		grammarBuilder.append("KW3838 : 'KW' '3838';\n");
+		grammarBuilder.append("KW3839 : 'KW' '3839';\n");
+		grammarBuilder.append("KW3840 : 'KW' '3840';\n");
+		grammarBuilder.append("KW3841 : 'KW' '3841';\n");
+		grammarBuilder.append("KW3842 : 'KW' '3842';\n");
+		grammarBuilder.append("KW3843 : 'KW' '3843';\n");
+		grammarBuilder.append("KW3844 : 'KW' '3844';\n");
+		grammarBuilder.append("KW3845 : 'KW' '3845';\n");
+		grammarBuilder.append("KW3846 : 'KW' '3846';\n");
+		grammarBuilder.append("KW3847 : 'KW' '3847';\n");
+		grammarBuilder.append("KW3848 : 'KW' '3848';\n");
+		grammarBuilder.append("KW3849 : 'KW' '3849';\n");
+		grammarBuilder.append("KW3850 : 'KW' '3850';\n");
+		grammarBuilder.append("KW3851 : 'KW' '3851';\n");
+		grammarBuilder.append("KW3852 : 'KW' '3852';\n");
+		grammarBuilder.append("KW3853 : 'KW' '3853';\n");
+		grammarBuilder.append("KW3854 : 'KW' '3854';\n");
+		grammarBuilder.append("KW3855 : 'KW' '3855';\n");
+		grammarBuilder.append("KW3856 : 'KW' '3856';\n");
+		grammarBuilder.append("KW3857 : 'KW' '3857';\n");
+		grammarBuilder.append("KW3858 : 'KW' '3858';\n");
+		grammarBuilder.append("KW3859 : 'KW' '3859';\n");
+		grammarBuilder.append("KW3860 : 'KW' '3860';\n");
+		grammarBuilder.append("KW3861 : 'KW' '3861';\n");
+		grammarBuilder.append("KW3862 : 'KW' '3862';\n");
+		grammarBuilder.append("KW3863 : 'KW' '3863';\n");
+		grammarBuilder.append("KW3864 : 'KW' '3864';\n");
+		grammarBuilder.append("KW3865 : 'KW' '3865';\n");
+		grammarBuilder.append("KW3866 : 'KW' '3866';\n");
+		grammarBuilder.append("KW3867 : 'KW' '3867';\n");
+		grammarBuilder.append("KW3868 : 'KW' '3868';\n");
+		grammarBuilder.append("KW3869 : 'KW' '3869';\n");
+		grammarBuilder.append("KW3870 : 'KW' '3870';\n");
+		grammarBuilder.append("KW3871 : 'KW' '3871';\n");
+		grammarBuilder.append("KW3872 : 'KW' '3872';\n");
+		grammarBuilder.append("KW3873 : 'KW' '3873';\n");
+		grammarBuilder.append("KW3874 : 'KW' '3874';\n");
+		grammarBuilder.append("KW3875 : 'KW' '3875';\n");
+		grammarBuilder.append("KW3876 : 'KW' '3876';\n");
+		grammarBuilder.append("KW3877 : 'KW' '3877';\n");
+		grammarBuilder.append("KW3878 : 'KW' '3878';\n");
+		grammarBuilder.append("KW3879 : 'KW' '3879';\n");
+		grammarBuilder.append("KW3880 : 'KW' '3880';\n");
+		grammarBuilder.append("KW3881 : 'KW' '3881';\n");
+		grammarBuilder.append("KW3882 : 'KW' '3882';\n");
+		grammarBuilder.append("KW3883 : 'KW' '3883';\n");
+		grammarBuilder.append("KW3884 : 'KW' '3884';\n");
+		grammarBuilder.append("KW3885 : 'KW' '3885';\n");
+		grammarBuilder.append("KW3886 : 'KW' '3886';\n");
+		grammarBuilder.append("KW3887 : 'KW' '3887';\n");
+		grammarBuilder.append("KW3888 : 'KW' '3888';\n");
+		grammarBuilder.append("KW3889 : 'KW' '3889';\n");
+		grammarBuilder.append("KW3890 : 'KW' '3890';\n");
+		grammarBuilder.append("KW3891 : 'KW' '3891';\n");
+		grammarBuilder.append("KW3892 : 'KW' '3892';\n");
+		grammarBuilder.append("KW3893 : 'KW' '3893';\n");
+		grammarBuilder.append("KW3894 : 'KW' '3894';\n");
+		grammarBuilder.append("KW3895 : 'KW' '3895';\n");
+		grammarBuilder.append("KW3896 : 'KW' '3896';\n");
+		grammarBuilder.append("KW3897 : 'KW' '3897';\n");
+		grammarBuilder.append("KW3898 : 'KW' '3898';\n");
+		grammarBuilder.append("KW3899 : 'KW' '3899';\n");
+		grammarBuilder.append("KW3900 : 'KW' '3900';\n");
+		grammarBuilder.append("KW3901 : 'KW' '3901';\n");
+		grammarBuilder.append("KW3902 : 'KW' '3902';\n");
+		grammarBuilder.append("KW3903 : 'KW' '3903';\n");
+		grammarBuilder.append("KW3904 : 'KW' '3904';\n");
+		grammarBuilder.append("KW3905 : 'KW' '3905';\n");
+		grammarBuilder.append("KW3906 : 'KW' '3906';\n");
+		grammarBuilder.append("KW3907 : 'KW' '3907';\n");
+		grammarBuilder.append("KW3908 : 'KW' '3908';\n");
+		grammarBuilder.append("KW3909 : 'KW' '3909';\n");
+		grammarBuilder.append("KW3910 : 'KW' '3910';\n");
+		grammarBuilder.append("KW3911 : 'KW' '3911';\n");
+		grammarBuilder.append("KW3912 : 'KW' '3912';\n");
+		grammarBuilder.append("KW3913 : 'KW' '3913';\n");
+		grammarBuilder.append("KW3914 : 'KW' '3914';\n");
+		grammarBuilder.append("KW3915 : 'KW' '3915';\n");
+		grammarBuilder.append("KW3916 : 'KW' '3916';\n");
+		grammarBuilder.append("KW3917 : 'KW' '3917';\n");
+		grammarBuilder.append("KW3918 : 'KW' '3918';\n");
+		grammarBuilder.append("KW3919 : 'KW' '3919';\n");
+		grammarBuilder.append("KW3920 : 'KW' '3920';\n");
+		grammarBuilder.append("KW3921 : 'KW' '3921';\n");
+		grammarBuilder.append("KW3922 : 'KW' '3922';\n");
+		grammarBuilder.append("KW3923 : 'KW' '3923';\n");
+		grammarBuilder.append("KW3924 : 'KW' '3924';\n");
+		grammarBuilder.append("KW3925 : 'KW' '3925';\n");
+		grammarBuilder.append("KW3926 : 'KW' '3926';\n");
+		grammarBuilder.append("KW3927 : 'KW' '3927';\n");
+		grammarBuilder.append("KW3928 : 'KW' '3928';\n");
+		grammarBuilder.append("KW3929 : 'KW' '3929';\n");
+		grammarBuilder.append("KW3930 : 'KW' '3930';\n");
+		grammarBuilder.append("KW3931 : 'KW' '3931';\n");
+		grammarBuilder.append("KW3932 : 'KW' '3932';\n");
+		grammarBuilder.append("KW3933 : 'KW' '3933';\n");
+		grammarBuilder.append("KW3934 : 'KW' '3934';\n");
+		grammarBuilder.append("KW3935 : 'KW' '3935';\n");
+		grammarBuilder.append("KW3936 : 'KW' '3936';\n");
+		grammarBuilder.append("KW3937 : 'KW' '3937';\n");
+		grammarBuilder.append("KW3938 : 'KW' '3938';\n");
+		grammarBuilder.append("KW3939 : 'KW' '3939';\n");
+		grammarBuilder.append("KW3940 : 'KW' '3940';\n");
+		grammarBuilder.append("KW3941 : 'KW' '3941';\n");
+		grammarBuilder.append("KW3942 : 'KW' '3942';\n");
+		grammarBuilder.append("KW3943 : 'KW' '3943';\n");
+		grammarBuilder.append("KW3944 : 'KW' '3944';\n");
+		grammarBuilder.append("KW3945 : 'KW' '3945';\n");
+		grammarBuilder.append("KW3946 : 'KW' '3946';\n");
+		grammarBuilder.append("KW3947 : 'KW' '3947';\n");
+		grammarBuilder.append("KW3948 : 'KW' '3948';\n");
+		grammarBuilder.append("KW3949 : 'KW' '3949';\n");
+		grammarBuilder.append("KW3950 : 'KW' '3950';\n");
+		grammarBuilder.append("KW3951 : 'KW' '3951';\n");
+		grammarBuilder.append("KW3952 : 'KW' '3952';\n");
+		grammarBuilder.append("KW3953 : 'KW' '3953';\n");
+		grammarBuilder.append("KW3954 : 'KW' '3954';\n");
+		grammarBuilder.append("KW3955 : 'KW' '3955';\n");
+		grammarBuilder.append("KW3956 : 'KW' '3956';\n");
+		grammarBuilder.append("KW3957 : 'KW' '3957';\n");
+		grammarBuilder.append("KW3958 : 'KW' '3958';\n");
+		grammarBuilder.append("KW3959 : 'KW' '3959';\n");
+		grammarBuilder.append("KW3960 : 'KW' '3960';\n");
+		grammarBuilder.append("KW3961 : 'KW' '3961';\n");
+		grammarBuilder.append("KW3962 : 'KW' '3962';\n");
+		grammarBuilder.append("KW3963 : 'KW' '3963';\n");
+		grammarBuilder.append("KW3964 : 'KW' '3964';\n");
+		grammarBuilder.append("KW3965 : 'KW' '3965';\n");
+		grammarBuilder.append("KW3966 : 'KW' '3966';\n");
+		grammarBuilder.append("KW3967 : 'KW' '3967';\n");
+		grammarBuilder.append("KW3968 : 'KW' '3968';\n");
+		grammarBuilder.append("KW3969 : 'KW' '3969';\n");
+		grammarBuilder.append("KW3970 : 'KW' '3970';\n");
+		grammarBuilder.append("KW3971 : 'KW' '3971';\n");
+		grammarBuilder.append("KW3972 : 'KW' '3972';\n");
+		grammarBuilder.append("KW3973 : 'KW' '3973';\n");
+		grammarBuilder.append("KW3974 : 'KW' '3974';\n");
+		grammarBuilder.append("KW3975 : 'KW' '3975';\n");
+		grammarBuilder.append("KW3976 : 'KW' '3976';\n");
+		grammarBuilder.append("KW3977 : 'KW' '3977';\n");
+		grammarBuilder.append("KW3978 : 'KW' '3978';\n");
+		grammarBuilder.append("KW3979 : 'KW' '3979';\n");
+		grammarBuilder.append("KW3980 : 'KW' '3980';\n");
+		grammarBuilder.append("KW3981 : 'KW' '3981';\n");
+		grammarBuilder.append("KW3982 : 'KW' '3982';\n");
+		grammarBuilder.append("KW3983 : 'KW' '3983';\n");
+		grammarBuilder.append("KW3984 : 'KW' '3984';\n");
+		grammarBuilder.append("KW3985 : 'KW' '3985';\n");
+		grammarBuilder.append("KW3986 : 'KW' '3986';\n");
+		grammarBuilder.append("KW3987 : 'KW' '3987';\n");
+		grammarBuilder.append("KW3988 : 'KW' '3988';\n");
+		grammarBuilder.append("KW3989 : 'KW' '3989';\n");
+		grammarBuilder.append("KW3990 : 'KW' '3990';\n");
+		grammarBuilder.append("KW3991 : 'KW' '3991';\n");
+		grammarBuilder.append("KW3992 : 'KW' '3992';\n");
+		grammarBuilder.append("KW3993 : 'KW' '3993';\n");
+		grammarBuilder.append("KW3994 : 'KW' '3994';\n");
+		grammarBuilder.append("KW3995 : 'KW' '3995';\n");
+		grammarBuilder.append("KW3996 : 'KW' '3996';\n");
+		grammarBuilder.append("KW3997 : 'KW' '3997';\n");
+		grammarBuilder.append("KW3998 : 'KW' '3998';\n");
+		grammarBuilder.append("KW3999 : 'KW' '3999';");
+		String grammar = grammarBuilder.toString();
+
+		String input ="KW400";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:4='KW400',<402>,1:0]\n" +
+			"[@1,5:4='<EOF>',<-1>,1:5]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNonGreedyClosure() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(61);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("CMT : '//' .*? '\\n' CMT*?;\n");
+		grammarBuilder.append("WS : (' '|'\\t')+;");
+		String grammar = grammarBuilder.toString();
+
+		String input =
+			"//blah\n" +
+			"//blah\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:6='//blah\\n',<1>,1:0]\n" +
+			"[@1,7:13='//blah\\n',<1>,2:0]\n" +
+			"[@2,14:13='<EOF>',<-1>,3:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNonGreedyConfigs() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(148);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("I : .*? ('a' | 'ab') {System.out.println(this.getText());} ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;\n");
+		grammarBuilder.append("J : . {System.out.println(this.getText());};");
+		String grammar = grammarBuilder.toString();
+
+		String input ="ab";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"a\n" +
+			"b\n" +
+			"[@0,0:0='a',<1>,1:0]\n" +
+			"[@1,1:1='b',<3>,1:1]\n" +
+			"[@2,2:1='<EOF>',<-1>,1:2]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNonGreedyOptional() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(61);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("CMT : '//' .*? '\\n' CMT??;\n");
+		grammarBuilder.append("WS : (' '|'\\t')+;");
+		String grammar = grammarBuilder.toString();
+
+		String input =
+			"//blah\n" +
+			"//blah\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:6='//blah\\n',<1>,1:0]\n" +
+			"[@1,7:13='//blah\\n',<1>,2:0]\n" +
+			"[@2,14:13='<EOF>',<-1>,3:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNonGreedyPositiveClosure() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(59);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("CMT : ('//' .*? '\\n')+?;\n");
+		grammarBuilder.append("WS : (' '|'\\t')+;");
+		String grammar = grammarBuilder.toString();
+
+		String input =
+			"//blah\n" +
+			"//blah\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:6='//blah\\n',<1>,1:0]\n" +
+			"[@1,7:13='//blah\\n',<1>,2:0]\n" +
+			"[@2,14:13='<EOF>',<-1>,3:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNonGreedyTermination1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(47);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("STRING : '\"' ('\"\"' | .)*? '\"';");
+		String grammar = grammarBuilder.toString();
+
+		String input ="\"hi\"\"mom\"";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:3='\"hi\"',<1>,1:0]\n" +
+			"[@1,4:8='\"mom\"',<1>,1:4]\n" +
+			"[@2,9:8='<EOF>',<-1>,1:9]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNonGreedyTermination2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(47);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("STRING : '\"' ('\"\"' | .)+? '\"';");
+		String grammar = grammarBuilder.toString();
+
+		String input ="\"\"\"mom\"";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:6='\"\"\"mom\"',<1>,1:0]\n" +
+			"[@1,7:6='<EOF>',<-1>,1:7]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testParentheses() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(166);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("START_BLOCK: '-.-.-';\n");
+		grammarBuilder.append("ID : (LETTER SEPARATOR) (LETTER SEPARATOR)+;\n");
+		grammarBuilder.append("fragment LETTER: L_A|L_K;\n");
+		grammarBuilder.append("fragment L_A: '.-';\n");
+		grammarBuilder.append("fragment L_K: '-.-';\n");
+		grammarBuilder.append("SEPARATOR: '!';");
+		String grammar = grammarBuilder.toString();
+
+		String input ="-.-.-!";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:4='-.-.-',<1>,1:0]\n" +
+			"[@1,5:5='!',<3>,1:5]\n" +
+			"[@2,6:5='<EOF>',<-1>,1:6]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPositionAdjustingLexer() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(2501);
+		grammarBuilder.append("lexer grammar PositionAdjustingLexer;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("@members {\n");
+		grammarBuilder.append("@Override\n");
+		grammarBuilder.append("public Token nextToken() {\n");
+		grammarBuilder.append("	if (!(_interp instanceof PositionAdjustingLexerATNSimulator)) {\n");
+		grammarBuilder.append("		_interp = new PositionAdjustingLexerATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache);\n");
+		grammarBuilder.append("	}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("	return super.nextToken();\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("@Override\n");
+		grammarBuilder.append("public Token emit() {\n");
+		grammarBuilder.append("	switch (_type) {\n");
+		grammarBuilder.append("	case TOKENS:\n");
+		grammarBuilder.append("		handleAcceptPositionForKeyword(\"tokens\");\n");
+		grammarBuilder.append("		break;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("	case LABEL:\n");
+		grammarBuilder.append("		handleAcceptPositionForIdentifier();\n");
+		grammarBuilder.append("		break;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("	default:\n");
+		grammarBuilder.append("		break;\n");
+		grammarBuilder.append("	}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("	return super.emit();\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("private boolean handleAcceptPositionForIdentifier() {\n");
+		grammarBuilder.append("	String tokenText = getText();\n");
+		grammarBuilder.append("	int identifierLength = 0;\n");
+		grammarBuilder.append("	while (identifierLength < tokenText.length() && isIdentifierChar(tokenText.charAt(identifierLength))) {\n");
+		grammarBuilder.append("		identifierLength++;\n");
+		grammarBuilder.append("	}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("	if (getInputStream().index() > _tokenStartCharIndex + identifierLength) {\n");
+		grammarBuilder.append("		int offset = identifierLength - 1;\n");
+		grammarBuilder.append("		getInterpreter().resetAcceptPosition(getInputStream(), _tokenStartCharIndex + offset, _tokenStartLine, _tokenStartCharPositionInLine + offset);\n");
+		grammarBuilder.append("		return true;\n");
+		grammarBuilder.append("	}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("	return false;\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("private boolean handleAcceptPositionForKeyword(String keyword) {\n");
+		grammarBuilder.append("	if (getInputStream().index() > _tokenStartCharIndex + keyword.length()) {\n");
+		grammarBuilder.append("		int offset = keyword.length() - 1;\n");
+		grammarBuilder.append("		getInterpreter().resetAcceptPosition(getInputStream(), _tokenStartCharIndex + offset, _tokenStartLine, _tokenStartCharPositionInLine + offset);\n");
+		grammarBuilder.append("		return true;\n");
+		grammarBuilder.append("	}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("	return false;\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("@Override\n");
+		grammarBuilder.append("public PositionAdjustingLexerATNSimulator getInterpreter() {\n");
+		grammarBuilder.append("	return (PositionAdjustingLexerATNSimulator)super.getInterpreter();\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("private static boolean isIdentifierChar(char c) {\n");
+		grammarBuilder.append("	return Character.isLetterOrDigit(c) || c == '_';\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("protected static class PositionAdjustingLexerATNSimulator extends LexerATNSimulator {\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("	public PositionAdjustingLexerATNSimulator(Lexer recog, ATN atn,\n");
+		grammarBuilder.append("											  DFA[] decisionToDFA,\n");
+		grammarBuilder.append("											  PredictionContextCache sharedContextCache)\n");
+		grammarBuilder.append("	{\n");
+		grammarBuilder.append("		super(recog, atn, decisionToDFA, sharedContextCache);\n");
+		grammarBuilder.append("	}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("	protected void resetAcceptPosition(CharStream input, int index, int line, int charPositionInLine) {\n");
+		grammarBuilder.append("		input.seek(index);\n");
+		grammarBuilder.append("		this.line = line;\n");
+		grammarBuilder.append("		this.charPositionInLine = charPositionInLine;\n");
+		grammarBuilder.append("		consume(input);\n");
+		grammarBuilder.append("	}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("ASSIGN : '=' ;\n");
+		grammarBuilder.append("PLUS_ASSIGN : '+=' ;\n");
+		grammarBuilder.append("LCURLY:	'{';\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("// 'tokens' followed by '{'\n");
+		grammarBuilder.append("TOKENS : 'tokens' IGNORED '{';\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("// IDENTIFIER followed by '+=' or '='\n");
+		grammarBuilder.append("LABEL\n");
+		grammarBuilder.append("	:	IDENTIFIER IGNORED '+'? '='\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("IDENTIFIER\n");
+		grammarBuilder.append("	:	[a-zA-Z_] [a-zA-Z0-9_]*\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("fragment\n");
+		grammarBuilder.append("IGNORED\n");
+		grammarBuilder.append("	:	[ \\t\\r\\n]*\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("NEWLINE\n");
+		grammarBuilder.append("	:	[\\r\\n]+ -> skip\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("WS\n");
+		grammarBuilder.append("	:	[ \\t]+ -> skip\n");
+		grammarBuilder.append("	;");
+		String grammar = grammarBuilder.toString();
+
+		String input =
+			"tokens\n" +
+			"tokens {\n" +
+			"notLabel\n" +
+			"label1 =\n" +
+			"label2 +=\n" +
+			"notLabel\n";
+		String found = execLexer("PositionAdjustingLexer.g4", grammar, "PositionAdjustingLexer", input, false);
+		assertEquals(
+			"[@0,0:5='tokens',<6>,1:0]\n" +
+			"[@1,7:12='tokens',<4>,2:0]\n" +
+			"[@2,14:14='{',<3>,2:7]\n" +
+			"[@3,16:23='notLabel',<6>,3:0]\n" +
+			"[@4,25:30='label1',<5>,4:0]\n" +
+			"[@5,32:32='=',<1>,4:7]\n" +
+			"[@6,34:39='label2',<5>,5:0]\n" +
+			"[@7,41:42='+=',<2>,5:7]\n" +
+			"[@8,44:51='notLabel',<6>,6:0]\n" +
+			"[@9,53:52='<EOF>',<-1>,7:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testQuoteTranslation() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(57);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("QUOTE : '\"' ; // make sure this compiles");
+		String grammar = grammarBuilder.toString();
+
+		String input ="\"";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:0='\"',<1>,1:0]\n" +
+			"[@1,1:0='<EOF>',<-1>,1:1]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testRecursiveLexerRuleRefWithWildcardPlus_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(64);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("CMT : '/*' (CMT | .)+? '*/' ;\n");
+		grammarBuilder.append("WS : (' '|'\\n')+;");
+		String grammar = grammarBuilder.toString();
+
+		String input =
+			"/* ick */\n" +
+			"/* /* */\n" +
+			"/* /*nested*/ */\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:8='/* ick */',<1>,1:0]\n" +
+			"[@1,9:9='\\n',<2>,1:9]\n" +
+			"[@2,10:34='/* /* */\\n/* /*nested*/ */',<1>,2:0]\n" +
+			"[@3,35:35='\\n',<2>,3:16]\n" +
+			"[@4,36:35='<EOF>',<-1>,4:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testRecursiveLexerRuleRefWithWildcardPlus_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(64);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("CMT : '/*' (CMT | .)+? '*/' ;\n");
+		grammarBuilder.append("WS : (' '|'\\n')+;");
+		String grammar = grammarBuilder.toString();
+
+		String input =
+			"/* ick */x\n" +
+			"/* /* */x\n" +
+			"/* /*nested*/ */x\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:8='/* ick */',<1>,1:0]\n" +
+			"[@1,10:10='\\n',<2>,1:10]\n" +
+			"[@2,11:36='/* /* */x\\n/* /*nested*/ */',<1>,2:0]\n" +
+			"[@3,38:38='\\n',<2>,3:17]\n" +
+			"[@4,39:38='<EOF>',<-1>,4:0]\n", found);
+
+		assertEquals(
+			"line 1:9 token recognition error at: 'x'\n" +
+			"line 3:16 token recognition error at: 'x'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testRecursiveLexerRuleRefWithWildcardStar_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(64);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("CMT : '/*' (CMT | .)*? '*/' ;\n");
+		grammarBuilder.append("WS : (' '|'\\n')+;");
+		String grammar = grammarBuilder.toString();
+
+		String input =
+			"/* ick */\n" +
+			"/* /* */\n" +
+			"/* /*nested*/ */\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:8='/* ick */',<1>,1:0]\n" +
+			"[@1,9:9='\\n',<2>,1:9]\n" +
+			"[@2,10:34='/* /* */\\n/* /*nested*/ */',<1>,2:0]\n" +
+			"[@3,35:35='\\n',<2>,3:16]\n" +
+			"[@4,36:35='<EOF>',<-1>,4:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testRecursiveLexerRuleRefWithWildcardStar_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(64);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("CMT : '/*' (CMT | .)*? '*/' ;\n");
+		grammarBuilder.append("WS : (' '|'\\n')+;");
+		String grammar = grammarBuilder.toString();
+
+		String input =
+			"/* ick */x\n" +
+			"/* /* */x\n" +
+			"/* /*nested*/ */x\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:8='/* ick */',<1>,1:0]\n" +
+			"[@1,10:10='\\n',<2>,1:10]\n" +
+			"[@2,11:36='/* /* */x\\n/* /*nested*/ */',<1>,2:0]\n" +
+			"[@3,38:38='\\n',<2>,3:17]\n" +
+			"[@4,39:38='<EOF>',<-1>,4:0]\n", found);
+
+		assertEquals(
+			"line 1:9 token recognition error at: 'x'\n" +
+			"line 3:16 token recognition error at: 'x'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testRefToRuleDoesNotSetTokenNorEmitAnother() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(70);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : '-' I ;\n");
+		grammarBuilder.append("I : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="34 -21 3";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:1='34',<2>,1:0]\n" +
+			"[@1,3:5='-21',<1>,1:3]\n" +
+			"[@2,7:7='3',<2>,1:7]\n" +
+			"[@3,8:7='<EOF>',<-1>,1:8]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSlashes() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(95);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("Backslash : '\\\\';\n");
+		grammarBuilder.append("Slash : '/';\n");
+		grammarBuilder.append("Vee : '\\\\/';\n");
+		grammarBuilder.append("Wedge : '/\\\\';\n");
+		grammarBuilder.append("WS : [ \\t] -> skip;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="\\ / \\/ /\\";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:0='\\',<1>,1:0]\n" +
+			"[@1,2:2='/',<2>,1:2]\n" +
+			"[@2,4:5='\\/',<3>,1:4]\n" +
+			"[@3,7:8='/\\',<4>,1:7]\n" +
+			"[@4,9:8='<EOF>',<-1>,1:9]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testZeroLengthToken() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(215);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("BeginString\n");
+		grammarBuilder.append("	:	'\\'' -> more, pushMode(StringMode)\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("mode StringMode;\n");
+		grammarBuilder.append("	StringMode_X : 'x' -> more;\n");
+		grammarBuilder.append("	StringMode_Done : -> more, mode(EndStringMode);\n");
+		grammarBuilder.append("mode EndStringMode;	\n");
+		grammarBuilder.append("	EndString : '\\'' -> popMode;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="'xxx'";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:4=''xxx'',<1>,1:0]\n" +
+			"[@1,5:4='<EOF>',<-1>,1:5]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+
+}
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/java/TestListeners.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/java/TestListeners.java
new file mode 100644
index 000000000..d8dd6e995
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/java/TestListeners.java
@@ -0,0 +1,362 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.java;
+
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class TestListeners extends BaseTest {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testBasic() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(473);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@parser::header {\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("@parser::members {\n");
+		grammarBuilder.append("public static class LeafListener extends TBaseListener {\n");
+		grammarBuilder.append("	public void visitTerminal(TerminalNode node) {\n");
+		grammarBuilder.append("		System.out.println(node.getSymbol().getText());\n");
+		grammarBuilder.append("	}\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("System.out.println($ctx.r.toStringTree(this));\n");
+		grammarBuilder.append("ParseTreeWalker walker = new ParseTreeWalker();\n");
+		grammarBuilder.append("walker.walk(new LeafListener(), $ctx.r);\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : INT INT\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("MULT: '*' ;\n");
+		grammarBuilder.append("ADD : '+' ;\n");
+		grammarBuilder.append("INT : [0-9]+ ;\n");
+		grammarBuilder.append("ID  : [a-z]+ ;\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="1 2";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals(
+			"(a 1 2)\n" +
+			"1\n" +
+			"2\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLR() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(653);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@parser::header {\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("@parser::members {\n");
+		grammarBuilder.append("public static class LeafListener extends TBaseListener {\n");
+		grammarBuilder.append("	public void exitE(TParser.EContext ctx) {\n");
+		grammarBuilder.append("		if (ctx.getChildCount()==3) {\n");
+		grammarBuilder.append("			System.out.printf(\"%s %s %s\\n\",ctx.e(0).start.getText(),\n");
+		grammarBuilder.append("				ctx.e(1).start.getText(), ctx.e().get(0).start.getText());\n");
+		grammarBuilder.append("		} else\n");
+		grammarBuilder.append("			System.out.println(ctx.INT().getSymbol().getText());\n");
+		grammarBuilder.append("	}\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("System.out.println($ctx.r.toStringTree(this));\n");
+		grammarBuilder.append("ParseTreeWalker walker = new ParseTreeWalker();\n");
+		grammarBuilder.append("walker.walk(new LeafListener(), $ctx.r);\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("	: r=e ;\n");
+		grammarBuilder.append("e : e op='*' e\n");
+		grammarBuilder.append("	| e op='+' e\n");
+		grammarBuilder.append("	| INT\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("MULT: '*' ;\n");
+		grammarBuilder.append("ADD : '+' ;\n");
+		grammarBuilder.append("INT : [0-9]+ ;\n");
+		grammarBuilder.append("ID  : [a-z]+ ;\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="1+2*3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals(
+			"(e (e 1) + (e (e 2) * (e 3)))\n" +
+			"1\n" +
+			"2\n" +
+			"3\n" +
+			"2 3 2\n" +
+			"1 2 1\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLRWithLabels() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(650);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@parser::header {\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("@parser::members {\n");
+		grammarBuilder.append("public static class LeafListener extends TBaseListener {\n");
+		grammarBuilder.append("	public void exitCall(TParser.CallContext ctx) {\n");
+		grammarBuilder.append("		System.out.printf(\"%s %s\",ctx.e().start.getText(),ctx.eList());\n");
+		grammarBuilder.append("	}\n");
+		grammarBuilder.append("	public void exitInt(TParser.IntContext ctx) {\n");
+		grammarBuilder.append("		System.out.println(ctx.INT().getSymbol().getText());\n");
+		grammarBuilder.append("	}\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("System.out.println($ctx.r.toStringTree(this));\n");
+		grammarBuilder.append("ParseTreeWalker walker = new ParseTreeWalker();\n");
+		grammarBuilder.append("walker.walk(new LeafListener(), $ctx.r);\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=e ;\n");
+		grammarBuilder.append("e : e '(' eList ')' # Call\n");
+		grammarBuilder.append("  | INT             # Int\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("eList : e (',' e)* ;\n");
+		grammarBuilder.append("MULT: '*' ;\n");
+		grammarBuilder.append("ADD : '+' ;\n");
+		grammarBuilder.append("INT : [0-9]+ ;\n");
+		grammarBuilder.append("ID  : [a-z]+ ;\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="1(2,3)";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals(
+			"(e (e 1) ( (eList (e 2) , (e 3)) ))\n" +
+			"1\n" +
+			"2\n" +
+			"3\n" +
+			"1 [13 6]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testRuleGetters_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(670);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@parser::header {\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("@parser::members {\n");
+		grammarBuilder.append("public static class LeafListener extends TBaseListener {\n");
+		grammarBuilder.append("	public void exitA(TParser.AContext ctx) {\n");
+		grammarBuilder.append("		if (ctx.getChildCount()==2) {\n");
+		grammarBuilder.append("			System.out.printf(\"%s %s %s\",ctx.b(0).start.getText(),\n");
+		grammarBuilder.append("				ctx.b(1).start.getText(),ctx.b().get(0).start.getText());\n");
+		grammarBuilder.append("		} else\n");
+		grammarBuilder.append("			System.out.println(ctx.b(0).start.getText());\n");
+		grammarBuilder.append("	}\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("System.out.println($ctx.r.toStringTree(this));\n");
+		grammarBuilder.append("ParseTreeWalker walker = new ParseTreeWalker();\n");
+		grammarBuilder.append("walker.walk(new LeafListener(), $ctx.r);\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : b b		// forces list\n");
+		grammarBuilder.append("  | b		// a list still\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("b : ID | INT;\n");
+		grammarBuilder.append("MULT: '*' ;\n");
+		grammarBuilder.append("ADD : '+' ;\n");
+		grammarBuilder.append("INT : [0-9]+ ;\n");
+		grammarBuilder.append("ID  : [a-z]+ ;\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="1 2";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals(
+			"(a (b 1) (b 2))\n" +
+			"1 2 1\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testRuleGetters_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(670);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@parser::header {\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("@parser::members {\n");
+		grammarBuilder.append("public static class LeafListener extends TBaseListener {\n");
+		grammarBuilder.append("	public void exitA(TParser.AContext ctx) {\n");
+		grammarBuilder.append("		if (ctx.getChildCount()==2) {\n");
+		grammarBuilder.append("			System.out.printf(\"%s %s %s\",ctx.b(0).start.getText(),\n");
+		grammarBuilder.append("				ctx.b(1).start.getText(),ctx.b().get(0).start.getText());\n");
+		grammarBuilder.append("		} else\n");
+		grammarBuilder.append("			System.out.println(ctx.b(0).start.getText());\n");
+		grammarBuilder.append("	}\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("System.out.println($ctx.r.toStringTree(this));\n");
+		grammarBuilder.append("ParseTreeWalker walker = new ParseTreeWalker();\n");
+		grammarBuilder.append("walker.walk(new LeafListener(), $ctx.r);\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : b b		// forces list\n");
+		grammarBuilder.append("  | b		// a list still\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("b : ID | INT;\n");
+		grammarBuilder.append("MULT: '*' ;\n");
+		grammarBuilder.append("ADD : '+' ;\n");
+		grammarBuilder.append("INT : [0-9]+ ;\n");
+		grammarBuilder.append("ID  : [a-z]+ ;\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="abc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals(
+			"(a (b abc))\n" +
+			"abc\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTokenGetters_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(615);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@parser::header {\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("@parser::members {\n");
+		grammarBuilder.append("public static class LeafListener extends TBaseListener {\n");
+		grammarBuilder.append("	public void exitA(TParser.AContext ctx) {\n");
+		grammarBuilder.append("		if (ctx.getChildCount()==2)\n");
+		grammarBuilder.append("			System.out.printf(\"%s %s %s\",ctx.INT(0).getSymbol().getText(),\n");
+		grammarBuilder.append("				ctx.INT(1).getSymbol().getText(),ctx.INT());\n");
+		grammarBuilder.append("		else\n");
+		grammarBuilder.append("			System.out.println(ctx.ID().getSymbol());\n");
+		grammarBuilder.append("	}\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("System.out.println($ctx.r.toStringTree(this));\n");
+		grammarBuilder.append("ParseTreeWalker walker = new ParseTreeWalker();\n");
+		grammarBuilder.append("walker.walk(new LeafListener(), $ctx.r);\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : INT INT\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("MULT: '*' ;\n");
+		grammarBuilder.append("ADD : '+' ;\n");
+		grammarBuilder.append("INT : [0-9]+ ;\n");
+		grammarBuilder.append("ID  : [a-z]+ ;\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="1 2";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals(
+			"(a 1 2)\n" +
+			"1 2 [1, 2]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTokenGetters_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(615);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@parser::header {\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("@parser::members {\n");
+		grammarBuilder.append("public static class LeafListener extends TBaseListener {\n");
+		grammarBuilder.append("	public void exitA(TParser.AContext ctx) {\n");
+		grammarBuilder.append("		if (ctx.getChildCount()==2)\n");
+		grammarBuilder.append("			System.out.printf(\"%s %s %s\",ctx.INT(0).getSymbol().getText(),\n");
+		grammarBuilder.append("				ctx.INT(1).getSymbol().getText(),ctx.INT());\n");
+		grammarBuilder.append("		else\n");
+		grammarBuilder.append("			System.out.println(ctx.ID().getSymbol());\n");
+		grammarBuilder.append("	}\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("System.out.println($ctx.r.toStringTree(this));\n");
+		grammarBuilder.append("ParseTreeWalker walker = new ParseTreeWalker();\n");
+		grammarBuilder.append("walker.walk(new LeafListener(), $ctx.r);\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : INT INT\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("MULT: '*' ;\n");
+		grammarBuilder.append("ADD : '+' ;\n");
+		grammarBuilder.append("INT : [0-9]+ ;\n");
+		grammarBuilder.append("ID  : [a-z]+ ;\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="abc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals(
+			"(a abc)\n" +
+			"[@0,0:2='abc',<4>,1:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+
+}
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/java/TestParseTrees.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/java/TestParseTrees.java
new file mode 100644
index 000000000..7a0a944df
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/java/TestParseTrees.java
@@ -0,0 +1,291 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.java;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
+public class TestParseTrees extends BaseTest {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void test2AltLoop() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(140);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {\n");
+		grammarBuilder.append("setBuildParseTree(true);\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("System.out.println($r.ctx.toStringTree(this));\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : ('x' | 'y')* 'z'\n");
+		grammarBuilder.append("  ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="xyyxyxz";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(a x y y x y x z)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void test2Alts() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(133);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {\n");
+		grammarBuilder.append("setBuildParseTree(true);\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("System.out.println($r.ctx.toStringTree(this));\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : 'x' | 'y'\n");
+		grammarBuilder.append("  ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="y";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(a y)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAltNum() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(562);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("options { contextSuperClass=MyRuleNode; }\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("@parser::members {\n");
+		grammarBuilder.append("public static class MyRuleNode extends ParserRuleContext {\n");
+		grammarBuilder.append("	public int altNum;\n");
+		grammarBuilder.append("	public MyRuleNode(ParserRuleContext parent, int invokingStateNumber) {\n");
+		grammarBuilder.append("		super(parent, invokingStateNumber);\n");
+		grammarBuilder.append("	}\n");
+		grammarBuilder.append("	@Override public int getAltNumber() { return altNum; }\n");
+		grammarBuilder.append("	@Override public void setAltNumber(int altNum) { this.altNum = altNum; }\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {\n");
+		grammarBuilder.append("setBuildParseTree(true);\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("System.out.println($r.ctx.toStringTree(this));\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("a : 'f'\n");
+		grammarBuilder.append("  | 'g'\n");
+		grammarBuilder.append("  | 'x' b 'z'\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("b : 'e' {} | 'y'\n");
+		grammarBuilder.append("  ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="xyz";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(a:3 x (b:2 y) z)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExtraToken() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(146);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {\n");
+		grammarBuilder.append("setBuildParseTree(true);\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("System.out.println($r.ctx.toStringTree(this));\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : 'x' 'y'\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("Z : 'z' \n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append(" ");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="xzy";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(a x z y)\n", found);
+
+		assertEquals("line 1:1 extraneous input 'z' expecting 'y'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNoViableAlt() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(148);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {\n");
+		grammarBuilder.append("setBuildParseTree(true);\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("System.out.println($r.ctx.toStringTree(this));\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : 'x' | 'y'\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("Z : 'z' \n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append(" ");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="z";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(a z)\n", found);
+
+		assertEquals("line 1:0 mismatched input 'z' expecting {'x', 'y'}\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testRuleRef() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(142);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {\n");
+		grammarBuilder.append("setBuildParseTree(true);\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("System.out.println($r.ctx.toStringTree(this));\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : b 'x'\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("b : 'y' \n");
+		grammarBuilder.append("  ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="yx";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(a (b y) x)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSync() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(149);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {\n");
+		grammarBuilder.append("setBuildParseTree(true);\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("System.out.println($r.ctx.toStringTree(this));\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : 'x' 'y'* '!'\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("Z : 'z' \n");
+		grammarBuilder.append("  ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="xzyy!";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(a x z y y !)\n", found);
+
+		assertEquals("line 1:1 extraneous input 'z' expecting {'y', '!'}\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testToken2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(131);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {\n");
+		grammarBuilder.append("setBuildParseTree(true);\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("System.out.println($r.ctx.toStringTree(this));\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : 'x' 'y'\n");
+		grammarBuilder.append("  ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="xy";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("(a x y)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTokenAndRuleContextString() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(176);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {\n");
+		grammarBuilder.append("setBuildParseTree(true);\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("System.out.println($r.ctx.toStringTree(this));\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : 'x' { \n");
+		grammarBuilder.append("System.out.println(getRuleInvocationStack());\n");
+		grammarBuilder.append("} ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals(
+			"[a, s]\n" +
+			"(a x)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+
+}
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/java/TestParserErrors.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/java/TestParserErrors.java
new file mode 100644
index 000000000..4788eb79b
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/java/TestParserErrors.java
@@ -0,0 +1,687 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.java;
+
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class TestParserErrors extends BaseTest {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testConjuringUpToken() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(70);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' x='b' {System.out.println(\"conjured=\" + $x);} 'c' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="ac";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("conjured=[@-1,-1:-1='<missing 'b'>',<2>,1:1]\n", found);
+
+		assertEquals("line 1:1 missing 'b' at 'c'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testConjuringUpTokenFromSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(76);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' x=('b'|'c') {System.out.println(\"conjured=\" + $x);} 'd' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="ad";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("conjured=[@-1,-1:-1='<missing 'b'>',<2>,1:1]\n", found);
+
+		assertEquals("line 1:1 missing {'b', 'c'} at 'd'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testContextListGetters() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(221);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@parser::members{\n");
+		grammarBuilder.append("void foo() {\n");
+		grammarBuilder.append("	SContext s = null;\n");
+		grammarBuilder.append("	List<? extends AContext> a = s.a();\n");
+		grammarBuilder.append("	List<? extends BContext> b = s.b();\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("s : (a | b)+;\n");
+		grammarBuilder.append("a : 'a' {System.out.print('a');};\n");
+		grammarBuilder.append("b : 'b' {System.out.print('b');};");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="abab";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, true);
+		assertEquals("abab\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDuplicatedLeftRecursiveCall_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(63);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : expr EOF;\n");
+		grammarBuilder.append("expr : 'x'\n");
+		grammarBuilder.append("     | expr expr\n");
+		grammarBuilder.append("     ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "start", input, true);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDuplicatedLeftRecursiveCall_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(63);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : expr EOF;\n");
+		grammarBuilder.append("expr : 'x'\n");
+		grammarBuilder.append("     | expr expr\n");
+		grammarBuilder.append("     ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="xx";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "start", input, true);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDuplicatedLeftRecursiveCall_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(63);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : expr EOF;\n");
+		grammarBuilder.append("expr : 'x'\n");
+		grammarBuilder.append("     | expr expr\n");
+		grammarBuilder.append("     ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="xxx";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "start", input, true);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDuplicatedLeftRecursiveCall_4() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(63);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : expr EOF;\n");
+		grammarBuilder.append("expr : 'x'\n");
+		grammarBuilder.append("     | expr expr\n");
+		grammarBuilder.append("     ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="xxxx";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "start", input, true);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testInvalidATNStateRemoval() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(98);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : ID ':' expr;\n");
+		grammarBuilder.append("expr : primary expr? {} | expr '->' ID;\n");
+		grammarBuilder.append("primary : ID;\n");
+		grammarBuilder.append("ID : [a-z]+;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x:x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "start", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testInvalidEmptyInput() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(36);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : ID+;\n");
+		grammarBuilder.append("ID : [a-z]+;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "start", input, true);
+		assertEquals("", found);
+
+		assertEquals("line 1:0 missing ID at '<EOF>'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLL1ErrorInfo() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(306);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : animal (AND acClass)? service EOF;\n");
+		grammarBuilder.append("animal : (DOG | CAT );\n");
+		grammarBuilder.append("service : (HARDWARE | SOFTWARE) ;\n");
+		grammarBuilder.append("AND : 'and';\n");
+		grammarBuilder.append("DOG : 'dog';\n");
+		grammarBuilder.append("CAT : 'cat';\n");
+		grammarBuilder.append("HARDWARE: 'hardware';\n");
+		grammarBuilder.append("SOFTWARE: 'software';\n");
+		grammarBuilder.append("WS : ' ' -> skip ;\n");
+		grammarBuilder.append("acClass\n");
+		grammarBuilder.append("@init\n");
+		grammarBuilder.append("{System.out.println(this.getExpectedTokens().toString(this.tokenNames));}\n");
+		grammarBuilder.append("  : ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="dog and software";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "start", input, false);
+		assertEquals("{'hardware', 'software'}\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLL2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(46);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' 'b'\n");
+		grammarBuilder.append("  | 'a' 'c'\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("q : 'e' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="ae";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:1 no viable alternative at input 'ae'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLL3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(55);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' 'b'* 'c'\n");
+		grammarBuilder.append("  | 'a' 'b' 'd'\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("q : 'e' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="abe";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:2 no viable alternative at input 'abe'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLLStar() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(48);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a'+ 'b'\n");
+		grammarBuilder.append("  | 'a'+ 'c'\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("q : 'e' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="aaae";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:3 no viable alternative at input 'aaae'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultiTokenDeletionBeforeLoop() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(28);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' 'b'* 'c';");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="aacabc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:1 extraneous input 'a' expecting {'b', 'c'}\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultiTokenDeletionBeforeLoop2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(36);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' ('b'|'z'{})* 'c';");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="aacabc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:1 extraneous input 'a' expecting {'b', 'z', 'c'}\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultiTokenDeletionDuringLoop() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(29);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' 'b'* 'c' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="abaaababc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("", found);
+
+		assertEquals(
+			"line 1:2 extraneous input 'a' expecting {'b', 'c'}\n" +
+			"line 1:6 extraneous input 'a' expecting {'b', 'c'}\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultiTokenDeletionDuringLoop2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(37);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' ('b'|'z'{})* 'c' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="abaaababc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("", found);
+
+		assertEquals(
+			"line 1:2 extraneous input 'a' expecting {'b', 'z', 'c'}\n" +
+			"line 1:6 extraneous input 'a' expecting {'b', 'z', 'c'}\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNoViableAltAvoidance() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(83);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e '!' ;\n");
+		grammarBuilder.append("e : 'a' 'b'\n");
+		grammarBuilder.append("  | 'a'\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("DOT : '.' ;\n");
+		grammarBuilder.append("WS : [ \\t\\r\\n]+ -> skip;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a.";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:1 mismatched input '.' expecting '!'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleSetInsertion() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(34);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' ('b'|'c') 'd' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="ad";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:1 missing {'b', 'c'} at 'd'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleSetInsertionConsumption() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(89);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("myset: ('b'|'c') ;\n");
+		grammarBuilder.append("a: 'a' myset 'd' {System.out.println(\"\" + $myset.stop);} ; ");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="ad";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("[@0,0:0='a',<3>,1:0]\n", found);
+
+		assertEquals("line 1:1 missing {'b', 'c'} at 'd'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleTokenDeletion() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(24);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' 'b' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="aab";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:1 extraneous input 'a' expecting 'b'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleTokenDeletionBeforeAlt() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(38);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : ('b' | 'c')\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("q : 'a'\n");
+		grammarBuilder.append(";");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="ac";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:0 extraneous input 'a' expecting {'b', 'c'}\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleTokenDeletionBeforeLoop() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(25);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' 'b'* ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="aabc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("", found);
+
+		assertEquals(
+			"line 1:1 extraneous input 'a' expecting {<EOF>, 'b'}\n" +
+			"line 1:3 token recognition error at: 'c'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleTokenDeletionBeforeLoop2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(32);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' ('b'|'z'{})*;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="aabc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("", found);
+
+		assertEquals(
+			"line 1:1 extraneous input 'a' expecting {<EOF>, 'b', 'z'}\n" +
+			"line 1:3 token recognition error at: 'c'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleTokenDeletionBeforePredict() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(48);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a'+ 'b'\n");
+		grammarBuilder.append("  | 'a'+ 'c'\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("q : 'e' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="caaab";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:0 extraneous input 'c' expecting 'a'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleTokenDeletionConsumption() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(89);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("myset: ('b'|'c') ;\n");
+		grammarBuilder.append("a: 'a' myset 'd' {System.out.println(\"\" + $myset.stop);} ; ");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="aabd";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("[@2,2:2='b',<1>,1:2]\n", found);
+
+		assertEquals("line 1:1 extraneous input 'a' expecting {'b', 'c'}\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleTokenDeletionDuringLoop() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(29);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' 'b'* 'c' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="ababbc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:2 extraneous input 'a' expecting {'b', 'c'}\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleTokenDeletionDuringLoop2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(37);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' ('b'|'z'{})* 'c' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="ababbc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:2 extraneous input 'a' expecting {'b', 'z', 'c'}\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleTokenDeletionExpectingSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(30);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' ('b'|'c') ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="aab";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:1 extraneous input 'a' expecting {'b', 'c'}\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleTokenInsertion() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(28);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' 'b' 'c' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="ac";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:1 missing 'b' at 'c'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTokenMismatch() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(24);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' 'b' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="aa";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:1 mismatched input 'a' expecting 'b'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTokenMismatch2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(165);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("stat:   ( '(' expr? ')' )? EOF ;\n");
+		grammarBuilder.append("expr:   ID '=' STR ;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("ERR :   '~FORCE_ERROR~' ;\n");
+		grammarBuilder.append("ID  :   [a-zA-Z]+ ;\n");
+		grammarBuilder.append("STR :   '\"' ~[\"]* '\"' ;\n");
+		grammarBuilder.append("WS  :   [ \\t\\r\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="( ~FORCE_ERROR~ ";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "stat", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:2 mismatched input '~FORCE_ERROR~' expecting ')'\n", this.stderrDuringParse);
+
+	}
+
+
+}
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/java/TestParserExec.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/java/TestParserExec.java
new file mode 100644
index 000000000..8964d093b
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/java/TestParserExec.java
@@ -0,0 +1,758 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.java;
+
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class TestParserExec extends BaseTest {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAPlus() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(91);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : ID+ {\n");
+		grammarBuilder.append("System.out.println($text);\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a b c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("abc\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAStar_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(91);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : ID* {\n");
+		grammarBuilder.append("System.out.println($text);\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAStar_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(91);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : ID* {\n");
+		grammarBuilder.append("System.out.println($text);\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a b c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("abc\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAorAPlus() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(96);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (ID|ID)+ {\n");
+		grammarBuilder.append("System.out.println($text);\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a b c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("abc\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAorAStar_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(96);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (ID|ID)* {\n");
+		grammarBuilder.append("System.out.println($text);\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAorAStar_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(96);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (ID|ID)* {\n");
+		grammarBuilder.append("System.out.println($text);\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a b c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("abc\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAorB() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(150);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : ID {\n");
+		grammarBuilder.append("System.out.println(\"alt 1\");\n");
+		grammarBuilder.append("} | INT {\n");
+		grammarBuilder.append("System.out.println(\"alt 2\");\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="34";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("alt 2\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAorBPlus() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(119);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (ID|INT{\n");
+		grammarBuilder.append("})+ {\n");
+		grammarBuilder.append("System.out.println($text);\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a 34 c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("a34c\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAorBStar_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(119);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (ID|INT{\n");
+		grammarBuilder.append("})* {\n");
+		grammarBuilder.append("System.out.println($text);\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAorBStar_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(119);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (ID|INT{\n");
+		grammarBuilder.append("})* {\n");
+		grammarBuilder.append("System.out.println($text);\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a 34 c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("a34c\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testBasic() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(112);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : ID INT {\n");
+		grammarBuilder.append("System.out.println($text);\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="abc 34";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("abc34\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testEOFInClosure() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(53);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("prog : stat EOF;\n");
+		grammarBuilder.append("stat : 'x' ('y' | EOF)*?;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "prog", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testIfIfElseGreedyBinding1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(200);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : statement+ ;\n");
+		grammarBuilder.append("statement : 'x' | ifStatement;\n");
+		grammarBuilder.append("ifStatement : 'if' 'y' statement ('else' statement)? {\n");
+		grammarBuilder.append("System.out.println($text);\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> channel(HIDDEN);");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="if y if y x else x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "start", input, false);
+		assertEquals(
+			"if y x else x\n" +
+			"if y if y x else x\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testIfIfElseGreedyBinding2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(200);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : statement+ ;\n");
+		grammarBuilder.append("statement : 'x' | ifStatement;\n");
+		grammarBuilder.append("ifStatement : 'if' 'y' statement ('else' statement|) {\n");
+		grammarBuilder.append("System.out.println($text);\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> channel(HIDDEN);");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="if y if y x else x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "start", input, false);
+		assertEquals(
+			"if y x else x\n" +
+			"if y if y x else x\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testIfIfElseNonGreedyBinding1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(201);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : statement+ ;\n");
+		grammarBuilder.append("statement : 'x' | ifStatement;\n");
+		grammarBuilder.append("ifStatement : 'if' 'y' statement ('else' statement)?? {\n");
+		grammarBuilder.append("System.out.println($text);\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> channel(HIDDEN);");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="if y if y x else x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "start", input, false);
+		assertEquals(
+			"if y x\n" +
+			"if y if y x else x\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testIfIfElseNonGreedyBinding2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(200);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : statement+ ;\n");
+		grammarBuilder.append("statement : 'x' | ifStatement;\n");
+		grammarBuilder.append("ifStatement : 'if' 'y' statement (|'else' statement) {\n");
+		grammarBuilder.append("System.out.println($text);\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> channel(HIDDEN);");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="if y if y x else x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "start", input, false);
+		assertEquals(
+			"if y x\n" +
+			"if y if y x else x\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLL1OptionalBlock_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(117);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (ID|{}INT)? {\n");
+		grammarBuilder.append("System.out.println($text);\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLL1OptionalBlock_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(117);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (ID|{}INT)? {\n");
+		grammarBuilder.append("System.out.println($text);\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("a\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLabelAliasingAcrossLabeledAlternatives() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(185);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : a* EOF;\n");
+		grammarBuilder.append("a\n");
+		grammarBuilder.append("  : label=subrule {System.out.println($label.text);} #One\n");
+		grammarBuilder.append("  | label='y' {System.out.println($label.text);} #Two\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("subrule : 'x';\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="xy";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "start", input, false);
+		assertEquals(
+			"x\n" +
+			"y\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLabels() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(118);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : b1=b b2+=b* b3+=';' ;\n");
+		grammarBuilder.append("b : id_=ID val+=INT*;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="abc 34;";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testListLabelForClosureContext() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(462);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("ifStatement\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("List<?> __ttt__ = $ctx.elseIfStatement();\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("    : 'if' expression\n");
+		grammarBuilder.append("      ( ( 'then'\n");
+		grammarBuilder.append("          executableStatement*\n");
+		grammarBuilder.append("          elseIfStatement*  // <--- problem is here; should yield a list not node\n");
+		grammarBuilder.append("          elseStatement?\n");
+		grammarBuilder.append("          'end' 'if'\n");
+		grammarBuilder.append("        ) | executableStatement )\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("elseIfStatement\n");
+		grammarBuilder.append("    : 'else' 'if' expression 'then' executableStatement*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("expression : 'a' ;\n");
+		grammarBuilder.append("executableStatement : 'a' ;\n");
+		grammarBuilder.append("elseStatement : 'a' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "expression", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testListLabelsOnSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(140);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : b b* ';' ;\n");
+		grammarBuilder.append("b : ID val+=(INT | FLOAT)*;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("FLOAT : [0-9]+ '.' [0-9]+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="abc 34;";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleEOFHandling() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(42);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("prog : ('x' | 'x' 'y') EOF EOF;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "prog", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testOptional_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(90);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("stat : ifstat | 'x';\n");
+		grammarBuilder.append("ifstat : 'if' stat ('else' stat)?;\n");
+		grammarBuilder.append("WS : [ \\n\\t]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "stat", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testOptional_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(90);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("stat : ifstat | 'x';\n");
+		grammarBuilder.append("ifstat : 'if' stat ('else' stat)?;\n");
+		grammarBuilder.append("WS : [ \\n\\t]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="if x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "stat", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testOptional_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(90);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("stat : ifstat | 'x';\n");
+		grammarBuilder.append("ifstat : 'if' stat ('else' stat)?;\n");
+		grammarBuilder.append("WS : [ \\n\\t]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="if x else x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "stat", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testOptional_4() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(90);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("stat : ifstat | 'x';\n");
+		grammarBuilder.append("ifstat : 'if' stat ('else' stat)?;\n");
+		grammarBuilder.append("WS : [ \\n\\t]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="if if x else x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "stat", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testParserProperty() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(168);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@members {\n");
+		grammarBuilder.append("boolean Property() {\n");
+		grammarBuilder.append("  return true;\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("a : {$parser.Property()}? ID {System.out.println(\"valid\");}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="abc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("valid\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPredicatedIfIfElse() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(175);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : stmt EOF ;\n");
+		grammarBuilder.append("stmt : ifStmt | ID;\n");
+		grammarBuilder.append("ifStmt : 'if' ID stmt ('else' stmt | { this._input.LA(1)!=TParser.ELSE }?);\n");
+		grammarBuilder.append("ELSE : 'else';\n");
+		grammarBuilder.append("ID : [a-zA-Z]+;\n");
+		grammarBuilder.append("WS : [ \\n\\t]+ -> skip;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="if x if x a else b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, true);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPredictionIssue334() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(255);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("file_ @init{\n");
+		grammarBuilder.append("setErrorHandler(new BailErrorStrategy());\n");
+		grammarBuilder.append("} \n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("System.out.println($ctx.toStringTree(this));\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  :   item (SEMICOLON item)* SEMICOLON? EOF ;\n");
+		grammarBuilder.append("item : A B?;\n");
+		grammarBuilder.append("SEMICOLON: ';';\n");
+		grammarBuilder.append("A : 'a'|'A';\n");
+		grammarBuilder.append("B : 'b'|'B';\n");
+		grammarBuilder.append("WS      : [ \\r\\t\\n]+ -> skip;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "file_", input, false);
+		assertEquals("(file_ (item a) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReferenceToATN_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(120);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (ID|ATN)* ATN? {System.out.println($text);} ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("ATN : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReferenceToATN_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(120);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (ID|ATN)* ATN? {System.out.println($text);} ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("ATN : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a 34 c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("a34c\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+
+}
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/java/TestPerformance.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/java/TestPerformance.java
new file mode 100644
index 000000000..464ce3497
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/java/TestPerformance.java
@@ -0,0 +1,215 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.java;
+
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class TestPerformance extends BaseTest {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test(timeout = 60000)
+	public void testExpressionGrammar_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(164);
+		grammarBuilder.append("grammar Expr;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("program: expr EOF;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("expr\n");
+		grammarBuilder.append("	: ID\n");
+		grammarBuilder.append("	| 'not' expr\n");
+		grammarBuilder.append("	| expr 'and' expr\n");
+		grammarBuilder.append("	| expr 'or' expr\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("ID: [a-zA-Z_][a-zA-Z_0-9]*;\n");
+		grammarBuilder.append("WS: [ \\t\\n\\r\\f]+ -> skip;\n");
+		grammarBuilder.append("ERROR: .;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input =
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12";
+		String found = execParser("Expr.g4", grammar, "ExprParser", "ExprLexer", "program", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test(timeout = 60000)
+	public void testExpressionGrammar_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(164);
+		grammarBuilder.append("grammar Expr;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("program: expr EOF;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("expr\n");
+		grammarBuilder.append("	: ID\n");
+		grammarBuilder.append("	| 'not' expr\n");
+		grammarBuilder.append("	| expr 'and' expr\n");
+		grammarBuilder.append("	| expr 'or' expr\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("ID: [a-zA-Z_][a-zA-Z_0-9]*;\n");
+		grammarBuilder.append("WS: [ \\t\\n\\r\\f]+ -> skip;\n");
+		grammarBuilder.append("ERROR: .;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input =
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12";
+		String found = execParser("Expr.g4", grammar, "ExprParser", "ExprLexer", "program", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+
+}
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/java/TestSemPredEvalLexer.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/java/TestSemPredEvalLexer.java
new file mode 100644
index 000000000..590a66fd9
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/java/TestSemPredEvalLexer.java
@@ -0,0 +1,217 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.java;
+
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class TestSemPredEvalLexer extends BaseTest {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDisableRule() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(131);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("E1 : 'enum' { false }? ;\n");
+		grammarBuilder.append("E2 : 'enum' { true }? ;  // winner not E1 or ID\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="enum abc";
+		String found = execLexer("L.g4", grammar, "L", input, true);
+		assertEquals(
+			"[@0,0:3='enum',<2>,1:0]\n" +
+			"[@1,5:7='abc',<3>,1:5]\n" +
+			"[@2,8:7='<EOF>',<-1>,1:8]\n" +
+			"s0-' '->:s5=>4\n" +
+			"s0-'a'->:s6=>3\n" +
+			"s0-'e'->:s1=>3\n" +
+			":s1=>3-'n'->:s2=>3\n" +
+			":s2=>3-'u'->:s3=>3\n" +
+			":s6=>3-'b'->:s6=>3\n" +
+			":s6=>3-'c'->:s6=>3\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testEnumNotID() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(108);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("ENUM : [a-z]+  { this.getText().equals(\"enum\") }? ;\n");
+		grammarBuilder.append("ID : [a-z]+  ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="enum abc enum";
+		String found = execLexer("L.g4", grammar, "L", input, true);
+		assertEquals(
+			"[@0,0:3='enum',<1>,1:0]\n" +
+			"[@1,5:7='abc',<2>,1:5]\n" +
+			"[@2,9:12='enum',<1>,1:9]\n" +
+			"[@3,13:12='<EOF>',<-1>,1:13]\n" +
+			"s0-' '->:s3=>3\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testIDnotEnum() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(84);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("ENUM : [a-z]+  { false }? ;\n");
+		grammarBuilder.append("ID : [a-z]+  ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="enum abc enum";
+		String found = execLexer("L.g4", grammar, "L", input, true);
+		assertEquals(
+			"[@0,0:3='enum',<2>,1:0]\n" +
+			"[@1,5:7='abc',<2>,1:5]\n" +
+			"[@2,9:12='enum',<2>,1:9]\n" +
+			"[@3,13:12='<EOF>',<-1>,1:13]\n" +
+			"s0-' '->:s2=>3\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testIDvsEnum() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(85);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("ENUM : 'enum' { false }? ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="enum abc enum";
+		String found = execLexer("L.g4", grammar, "L", input, true);
+		assertEquals(
+			"[@0,0:3='enum',<2>,1:0]\n" +
+			"[@1,5:7='abc',<2>,1:5]\n" +
+			"[@2,9:12='enum',<2>,1:9]\n" +
+			"[@3,13:12='<EOF>',<-1>,1:13]\n" +
+			"s0-' '->:s5=>3\n" +
+			"s0-'a'->:s4=>2\n" +
+			"s0-'e'->:s1=>2\n" +
+			":s1=>2-'n'->:s2=>2\n" +
+			":s2=>2-'u'->:s3=>2\n" +
+			":s4=>2-'b'->:s4=>2\n" +
+			":s4=>2-'c'->:s4=>2\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testIndent() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(161);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("ID : [a-z]+  ;\n");
+		grammarBuilder.append("INDENT : [ \\t]+ { this._tokenStartCharPositionInLine==0 }?\n");
+		grammarBuilder.append("         { System.out.println(\"INDENT\"); }  ;\n");
+		grammarBuilder.append("NL : '\\n';\n");
+		grammarBuilder.append("WS : [ \\t]+ ;");
+		String grammar = grammarBuilder.toString();
+
+		String input =
+			"abc\n" +
+			"  def  \n";
+		String found = execLexer("L.g4", grammar, "L", input, true);
+		assertEquals(
+			"INDENT\n" +
+			"[@0,0:2='abc',<1>,1:0]\n" +
+			"[@1,3:3='\\n',<3>,1:3]\n" +
+			"[@2,4:5='  ',<2>,2:0]\n" +
+			"[@3,6:8='def',<1>,2:2]\n" +
+			"[@4,9:10='  ',<4>,2:5]\n" +
+			"[@5,11:11='\\n',<3>,2:7]\n" +
+			"[@6,12:11='<EOF>',<-1>,3:0]\n" +
+			"s0-'\n" +
+			"'->:s2=>3\n" +
+			"s0-'a'->:s1=>1\n" +
+			"s0-'d'->:s1=>1\n" +
+			":s1=>1-'b'->:s1=>1\n" +
+			":s1=>1-'c'->:s1=>1\n" +
+			":s1=>1-'e'->:s1=>1\n" +
+			":s1=>1-'f'->:s1=>1\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLexerInputPositionSensitivePredicates() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(278);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("WORD1 : ID1+ { System.out.println(this.getText()); } ;\n");
+		grammarBuilder.append("WORD2 : ID2+ { System.out.println(this.getText()); } ;\n");
+		grammarBuilder.append("fragment ID1 : { this.getCharPositionInLine() < 2 }? [a-zA-Z];\n");
+		grammarBuilder.append("fragment ID2 : { this.getCharPositionInLine() >= 2 }? [a-zA-Z];\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+
+		String input =
+			"a cde\n" +
+			"abcde\n";
+		String found = execLexer("L.g4", grammar, "L", input, true);
+		assertEquals(
+			"a\n" +
+			"cde\n" +
+			"ab\n" +
+			"cde\n" +
+			"[@0,0:0='a',<1>,1:0]\n" +
+			"[@1,2:4='cde',<2>,1:2]\n" +
+			"[@2,6:7='ab',<1>,2:0]\n" +
+			"[@3,8:10='cde',<2>,2:2]\n" +
+			"[@4,12:11='<EOF>',<-1>,3:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPredicatedKeywords() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(187);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("ENUM : [a-z]+ { this.getText().equals(\"enum\") }? { System.out.println(\"enum!\"); } ;\n");
+		grammarBuilder.append("ID   : [a-z]+ { System.out.println(\"ID \" + this.getText()); } ;\n");
+		grammarBuilder.append("WS   : [ \\n] -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="enum enu a";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"enum!\n" +
+			"ID enu\n" +
+			"ID a\n" +
+			"[@0,0:3='enum',<1>,1:0]\n" +
+			"[@1,5:7='enu',<2>,1:5]\n" +
+			"[@2,9:9='a',<2>,1:9]\n" +
+			"[@3,10:9='<EOF>',<-1>,1:10]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+
+}
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/java/TestSemPredEvalParser.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/java/TestSemPredEvalParser.java
new file mode 100644
index 000000000..6a749a76d
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/java/TestSemPredEvalParser.java
@@ -0,0 +1,735 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.java;
+
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class TestSemPredEvalParser extends BaseTest {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void test2UnpredicatedAlts() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(315);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : {_interp.setPredictionMode(PredictionMode.LL_EXACT_AMBIG_DETECTION);} a ';' a; // do 2x: once in ATN, next in DFA\n");
+		grammarBuilder.append("a : ID {System.out.println(\"alt 1\");}\n");
+		grammarBuilder.append("  | ID {System.out.println(\"alt 2\");}\n");
+		grammarBuilder.append("  | {false}? ID {System.out.println(\"alt 3\");}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x; y";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, true);
+		assertEquals(
+			"alt 1\n" +
+			"alt 1\n", found);
+
+		assertEquals(
+			"line 1:0 reportAttemptingFullContext d=0 (a), input='x'\n" +
+			"line 1:0 reportAmbiguity d=0 (a): ambigAlts={1, 2}, input='x'\n" +
+			"line 1:3 reportAttemptingFullContext d=0 (a), input='y'\n" +
+			"line 1:3 reportAmbiguity d=0 (a): ambigAlts={1, 2}, input='y'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void test2UnpredicatedAltsAndOneOrthogonalAlt() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(374);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : {_interp.setPredictionMode(PredictionMode.LL_EXACT_AMBIG_DETECTION);} a ';' a ';' a;\n");
+		grammarBuilder.append("a : INT {System.out.println(\"alt 1\");}\n");
+		grammarBuilder.append("  | ID {System.out.println(\"alt 2\");} // must pick this one for ID since pred is false\n");
+		grammarBuilder.append("  | ID {System.out.println(\"alt 3\");}\n");
+		grammarBuilder.append("  | {false}? ID {System.out.println(\"alt 4\");}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="34; x; y";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, true);
+		assertEquals(
+			"alt 1\n" +
+			"alt 2\n" +
+			"alt 2\n", found);
+
+		assertEquals(
+			"line 1:4 reportAttemptingFullContext d=0 (a), input='x'\n" +
+			"line 1:4 reportAmbiguity d=0 (a): ambigAlts={2, 3}, input='x'\n" +
+			"line 1:7 reportAttemptingFullContext d=0 (a), input='y'\n" +
+			"line 1:7 reportAmbiguity d=0 (a): ambigAlts={2, 3}, input='y'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testActionHidesPreds() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(239);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@members {int i = 0;}\n");
+		grammarBuilder.append("s : a+ ;\n");
+		grammarBuilder.append("a : {this.i = 1;} ID {this.i == 1}? {System.out.println(\"alt 1\");}\n");
+		grammarBuilder.append("  | {this.i = 2;} ID {this.i == 2}? {System.out.println(\"alt 2\");}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x x y";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals(
+			"alt 1\n" +
+			"alt 1\n" +
+			"alt 1\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testActionsHidePredsInGlobalFOLLOW() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(291);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@members {\n");
+		grammarBuilder.append("boolean pred(boolean v) {\n");
+		grammarBuilder.append("	System.out.println(\"eval=\"+v);\n");
+		grammarBuilder.append("	return v;\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("s : e {} {this.pred(true)}? {System.out.println(\"parse\");} '!' ;\n");
+		grammarBuilder.append("t : e {} {this.pred(false)}? ID ;\n");
+		grammarBuilder.append("e : ID | ; // non-LL(1) so we use ATN\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a!";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals(
+			"eval=true\n" +
+			"parse\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAtomWithClosureInTranslatedLRRule() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(94);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : e[0] EOF;\n");
+		grammarBuilder.append("e[int _p]\n");
+		grammarBuilder.append("    :   ( 'a' | 'b'+ ) ( {3 >= $_p}? '+' e[4] )*\n");
+		grammarBuilder.append("    ;\n");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a+b+a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "start", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDepedentPredsInGlobalFOLLOW() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(314);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@members {\n");
+		grammarBuilder.append("boolean pred(boolean v) {\n");
+		grammarBuilder.append("	System.out.println(\"eval=\"+v);\n");
+		grammarBuilder.append("	return v;\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("s : a[99] ;\n");
+		grammarBuilder.append("a[int i] : e {this.pred($i==99)}? {System.out.println(\"parse\");} '!' ;\n");
+		grammarBuilder.append("b[int i] : e {this.pred($i==99)}? ID ;\n");
+		grammarBuilder.append("e : ID | ; // non-LL(1) so we use ATN\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a!";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals(
+			"eval=true\n" +
+			"parse\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDependentPredNotInOuterCtxShouldBeIgnored() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(284);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : b[2] ';' |  b[2] '.' ; // decision in s drills down to ctx-dependent pred in a;\n");
+		grammarBuilder.append("b[int i] : a[i] ;\n");
+		grammarBuilder.append("a[int i]\n");
+		grammarBuilder.append("  : {$i==1}? ID {System.out.println(\"alt 1\");}\n");
+		grammarBuilder.append("    | {$i==2}? ID {System.out.println(\"alt 2\");}\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;\n");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a;";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("alt 2\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDisabledAlternative() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(121);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("cppCompilationUnit : content+ EOF;\n");
+		grammarBuilder.append("content: anything | {false}? .;\n");
+		grammarBuilder.append("anything: ANY_CHAR;\n");
+		grammarBuilder.append("ANY_CHAR: [_a-zA-Z0-9];");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="hello";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "cppCompilationUnit", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testIndependentPredNotPassedOuterCtxToAvoidCastException() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(197);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : b ';' |  b '.' ;\n");
+		grammarBuilder.append("b : a ;\n");
+		grammarBuilder.append("a\n");
+		grammarBuilder.append("  : {false}? ID {System.out.println(\"alt 1\");}\n");
+		grammarBuilder.append("  | {true}? ID {System.out.println(\"alt 2\");}\n");
+		grammarBuilder.append(" ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a;";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("alt 2\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNoTruePredsThrowsNoViableAlt() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(185);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : a a;\n");
+		grammarBuilder.append("a : {false}? ID INT {System.out.println(\"alt 1\");}\n");
+		grammarBuilder.append("  | {false}? ID INT {System.out.println(\"alt 2\");}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="y 3 x 4";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:0 no viable alternative at input 'y'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testOrder() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(311);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : a {} a; // do 2x: once in ATN, next in DFA;\n");
+		grammarBuilder.append("// action blocks lookahead from falling off of 'a'\n");
+		grammarBuilder.append("// and looking into 2nd 'a' ref. !ctx dependent pred\n");
+		grammarBuilder.append("a : ID {System.out.println(\"alt 1\");}\n");
+		grammarBuilder.append("  | {true}?  ID {System.out.println(\"alt 2\");}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x y";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals(
+			"alt 1\n" +
+			"alt 1\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPredFromAltTestedInLoopBack_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(211);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("file_\n");
+		grammarBuilder.append("@after {System.out.println($ctx.toStringTree(this));}\n");
+		grammarBuilder.append("  : para para EOF ;\n");
+		grammarBuilder.append("para: paraContent NL NL ;\n");
+		grammarBuilder.append("paraContent : ('s'|'x'|{this._input.LA(2)!=TParser.NL}? NL)+ ;\n");
+		grammarBuilder.append("NL : '\\n' ;\n");
+		grammarBuilder.append("s : 's' ;\n");
+		grammarBuilder.append("X : 'x' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input =
+			"s\n" +
+			"\n" +
+			"\n" +
+			"x\n";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "file_", input, true);
+		assertEquals("(file_ (para (paraContent s) \\n \\n) (para (paraContent \\n x \\n)) <EOF>)\n", found);
+
+		assertEquals(
+			"line 5:0 mismatched input '<EOF>' expecting '\n" +
+			"'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPredFromAltTestedInLoopBack_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(211);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("file_\n");
+		grammarBuilder.append("@after {System.out.println($ctx.toStringTree(this));}\n");
+		grammarBuilder.append("  : para para EOF ;\n");
+		grammarBuilder.append("para: paraContent NL NL ;\n");
+		grammarBuilder.append("paraContent : ('s'|'x'|{this._input.LA(2)!=TParser.NL}? NL)+ ;\n");
+		grammarBuilder.append("NL : '\\n' ;\n");
+		grammarBuilder.append("s : 's' ;\n");
+		grammarBuilder.append("X : 'x' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input =
+			"s\n" +
+			"\n" +
+			"\n" +
+			"x\n" +
+			"\n";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "file_", input, true);
+		assertEquals("(file_ (para (paraContent s) \\n \\n) (para (paraContent \\n x) \\n \\n) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPredTestedEvenWhenUnAmbig_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(218);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@members {boolean enumKeyword = true;}\n");
+		grammarBuilder.append("primary\n");
+		grammarBuilder.append("    :   ID {System.out.println(\"ID \"+$ID.text);}\n");
+		grammarBuilder.append("    |   {!this.enumKeyword}? 'enum' {System.out.println(\"enum\");}\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : [a-z]+ ;\n");
+		grammarBuilder.append("WS : [ \\t\\n\\r]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="abc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "primary", input, false);
+		assertEquals("ID abc\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPredTestedEvenWhenUnAmbig_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(218);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@members {boolean enumKeyword = true;}\n");
+		grammarBuilder.append("primary\n");
+		grammarBuilder.append("    :   ID {System.out.println(\"ID \"+$ID.text);}\n");
+		grammarBuilder.append("    |   {!this.enumKeyword}? 'enum' {System.out.println(\"enum\");}\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : [a-z]+ ;\n");
+		grammarBuilder.append("WS : [ \\t\\n\\r]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="enum";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "primary", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:0 no viable alternative at input 'enum'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPredicateDependentOnArg() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(214);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@members {int i = 0;}\n");
+		grammarBuilder.append("s : a[2] a[1];\n");
+		grammarBuilder.append("a[int i]\n");
+		grammarBuilder.append("  : {$i==1}? ID {System.out.println(\"alt 1\");}\n");
+		grammarBuilder.append("  | {$i==2}? ID {System.out.println(\"alt 2\");}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals(
+			"alt 2\n" +
+			"alt 1\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPredicateDependentOnArg2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(154);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@members {int i = 0;}\n");
+		grammarBuilder.append("s : a[2] a[1];\n");
+		grammarBuilder.append("a[int i]\n");
+		grammarBuilder.append("  : {$i==1}? ID \n");
+		grammarBuilder.append("  | {$i==2}? ID \n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPredsInGlobalFOLLOW() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(285);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@members {\n");
+		grammarBuilder.append("boolean pred(boolean v) {\n");
+		grammarBuilder.append("	System.out.println(\"eval=\"+v);\n");
+		grammarBuilder.append("	return v;\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("s : e {this.pred(true)}? {System.out.println(\"parse\");} '!' ;\n");
+		grammarBuilder.append("t : e {this.pred(false)}? ID ;\n");
+		grammarBuilder.append("e : ID | ; // non-LL(1) so we use ATN\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a!";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals(
+			"eval=true\n" +
+			"parse\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testRewindBeforePredEval() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(253);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : a a;\n");
+		grammarBuilder.append("a : {this._input.LT(1).getText().equals(\"x\")}? ID INT {System.out.println(\"alt 1\");}\n");
+		grammarBuilder.append("  | {this._input.LT(1).getText().equals(\"y\")}? ID INT {System.out.println(\"alt 2\");}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="y 3 x 4";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals(
+			"alt 2\n" +
+			"alt 1\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSimple() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(277);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : a a a; // do 3x: once in ATN, next in DFA then INT in ATN\n");
+		grammarBuilder.append("a : {false}? ID {System.out.println(\"alt 1\");}\n");
+		grammarBuilder.append("  | {true}?  ID {System.out.println(\"alt 2\");}\n");
+		grammarBuilder.append("  | INT         {System.out.println(\"alt 3\");}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x y 3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals(
+			"alt 2\n" +
+			"alt 2\n" +
+			"alt 3\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSimpleValidate() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(178);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : a ;\n");
+		grammarBuilder.append("a : {false}? ID  {System.out.println(\"alt 1\");}\n");
+		grammarBuilder.append("  | {true}?  INT {System.out.println(\"alt 2\");}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:0 no viable alternative at input 'x'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSimpleValidate2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(181);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : a a a;\n");
+		grammarBuilder.append("a : {false}? ID  {System.out.println(\"alt 1\");}\n");
+		grammarBuilder.append("  | {true}?  INT {System.out.println(\"alt 2\");}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="3 4 x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals(
+			"alt 2\n" +
+			"alt 2\n", found);
+
+		assertEquals("line 1:4 no viable alternative at input 'x'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testToLeft() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(178);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("	s : a+ ;\n");
+		grammarBuilder.append("a : {false}? ID {System.out.println(\"alt 1\");}\n");
+		grammarBuilder.append("  | {true}?  ID {System.out.println(\"alt 2\");}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x x y";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals(
+			"alt 2\n" +
+			"alt 2\n" +
+			"alt 2\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testToLeftWithVaryingPredicate() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(271);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@members {int i = 0;}\n");
+		grammarBuilder.append("s : ({this.i += 1;\n");
+		grammarBuilder.append("System.out.println(\"i=\" + this.i);} a)+ ;\n");
+		grammarBuilder.append("a : {this.i % 2 == 0}? ID {System.out.println(\"alt 1\");}\n");
+		grammarBuilder.append("  | {this.i % 2 != 0}? ID {System.out.println(\"alt 2\");}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x x y";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals(
+			"i=1\n" +
+			"alt 2\n" +
+			"i=2\n" +
+			"alt 1\n" +
+			"i=3\n" +
+			"alt 2\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testUnpredicatedPathsInAlt() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(197);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : a {System.out.println(\"alt 1\");}\n");
+		grammarBuilder.append("  | b {System.out.println(\"alt 2\");}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("a : {false}? ID INT\n");
+		grammarBuilder.append("  | ID INT\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("b : ID ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x 4";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("alt 1\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testValidateInDFA() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(346);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : a ';' a;\n");
+		grammarBuilder.append("// ';' helps us to resynchronize without consuming\n");
+		grammarBuilder.append("// 2nd 'a' reference. We our testing that the DFA also\n");
+		grammarBuilder.append("// throws an exception if the validating predicate fails\n");
+		grammarBuilder.append("a : {false}? ID  {System.out.println(\"alt 1\");}\n");
+		grammarBuilder.append("  | {true}?  INT {System.out.println(\"alt 2\");}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x ; y";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", input, false);
+		assertEquals("", found);
+
+		assertEquals(
+			"line 1:0 no viable alternative at input 'x'\n" +
+			"line 1:4 no viable alternative at input 'y'\n", this.stderrDuringParse);
+
+	}
+
+
+}
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/java/TestSets.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/java/TestSets.java
new file mode 100644
index 000000000..61011b44b
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/java/TestSets.java
@@ -0,0 +1,453 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.java;
+
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class TestSets extends BaseTest {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetLiteral() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(92);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (A {System.out.println($A.text);})+ ;\n");
+		grammarBuilder.append("A : [AaBb] ;\n");
+		grammarBuilder.append("WS : (' '|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="A a B b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals(
+			"A\n" +
+			"a\n" +
+			"B\n" +
+			"b\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testComplementSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(51);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("parse : ~NEW_LINE;\n");
+		grammarBuilder.append("NEW_LINE: '\\r'? '\\n';");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "parse", input, false);
+		assertEquals("", found);
+
+		assertEquals(
+			"line 1:0 token recognition error at: 'a'\n" +
+			"line 1:1 missing {} at '<EOF>'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLexerOptionalSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(84);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {System.out.println(this._input.getText());} ;\n");
+		grammarBuilder.append("A : ('a'|'b')? 'c' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="ac";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("ac\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLexerPlusSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(84);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {System.out.println(this._input.getText());} ;\n");
+		grammarBuilder.append("A : ('a'|'b')+ 'c' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="abaac";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("abaac\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLexerStarSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(84);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {System.out.println(this._input.getText());} ;\n");
+		grammarBuilder.append("A : ('a'|'b')* 'c' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="abaac";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("abaac\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNotChar() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(60);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {System.out.println($A.text);} ;\n");
+		grammarBuilder.append("A : ~'b' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("x\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNotCharSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(66);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {System.out.println($A.text);} ;\n");
+		grammarBuilder.append("A : ~('b'|'c') ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("x\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNotCharSetWithLabel() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(68);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {System.out.println($A.text);} ;\n");
+		grammarBuilder.append("A : h=~('b'|'c') ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("x\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNotCharSetWithRuleRef3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(132);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {System.out.println($A.text);} ;\n");
+		grammarBuilder.append("A : ('a'|B) ;  // this doesn't collapse to set but works\n");
+		grammarBuilder.append("fragment\n");
+		grammarBuilder.append("B : ~('a'|'c') ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("x\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testOptionalLexerSingleElement() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(78);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {System.out.println(this._input.getText());} ;\n");
+		grammarBuilder.append("A : 'b'? 'c' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="bc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("bc\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testOptionalSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(76);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : ('a'|'b')? 'c' {System.out.println(this._input.getText());} ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="ac";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("ac\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testOptionalSingleElement() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(78);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A? 'c' {System.out.println(this._input.getText());} ;\n");
+		grammarBuilder.append("A : 'b' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="bc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("bc\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testParserNotSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(64);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : t=~('x'|'y') 'z' {System.out.println($t.text);} ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="zz";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("z\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testParserNotToken() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(70);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : ~'x' 'z' {System.out.println(this._input.getText());} ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="zz";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("zz\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testParserNotTokenWithLabel() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(58);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : t=~'x' 'z' {System.out.println($t.text);} ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="zz";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("z\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testParserSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(59);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : t=('x'|'y') {System.out.println($t.text);} ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("x\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPlusLexerSingleElement() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(78);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {System.out.println(this._input.getText());} ;\n");
+		grammarBuilder.append("A : 'b'+ 'c' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="bbbbc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("bbbbc\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPlusSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(76);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : ('a'|'b')+ 'c' {System.out.println(this._input.getText());} ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="abaac";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("abaac\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testRuleAsSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(83);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a @after {System.out.println(this._input.getText());} : 'a' | 'b' |'c' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("b\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSeqDoesNotBecomeSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(120);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : C {System.out.println(this._input.getText());} ;\n");
+		grammarBuilder.append("fragment A : '1' | '2';\n");
+		grammarBuilder.append("fragment B : '3' '4';\n");
+		grammarBuilder.append("C : A | B;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="34";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("34\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testStarLexerSingleElement_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(78);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {System.out.println(this._input.getText());} ;\n");
+		grammarBuilder.append("A : 'b'* 'c' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="bbbbc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("bbbbc\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testStarLexerSingleElement_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(78);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {System.out.println(this._input.getText());} ;\n");
+		grammarBuilder.append("A : 'b'* 'c' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("c\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testStarSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(76);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : ('a'|'b')* 'c' {System.out.println(this._input.getText());} ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="abaac";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", input, false);
+		assertEquals("abaac\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+
+}
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/browser/BaseBrowserTest.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/browser/BaseBrowserTest.java
new file mode 100644
index 000000000..6878dfeab
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/browser/BaseBrowserTest.java
@@ -0,0 +1,1081 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2012 Terence Parr
+ *  Copyright (c) 2012 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.
+ */
+package org.antlr.v4.test.runtime.javascript.browser;
+
+import org.antlr.v4.Tool;
+import org.antlr.v4.automata.ATNFactory;
+import org.antlr.v4.automata.ATNPrinter;
+import org.antlr.v4.automata.LexerATNFactory;
+import org.antlr.v4.automata.ParserATNFactory;
+import org.antlr.v4.codegen.CodeGenerator;
+import org.antlr.v4.runtime.ANTLRInputStream;
+import org.antlr.v4.runtime.CharStream;
+import org.antlr.v4.runtime.CommonToken;
+import org.antlr.v4.runtime.CommonTokenStream;
+import org.antlr.v4.runtime.IntStream;
+import org.antlr.v4.runtime.Lexer;
+import org.antlr.v4.runtime.RuleContext;
+import org.antlr.v4.runtime.Token;
+import org.antlr.v4.runtime.TokenSource;
+import org.antlr.v4.runtime.TokenStream;
+import org.antlr.v4.runtime.WritableToken;
+import org.antlr.v4.runtime.atn.ATN;
+import org.antlr.v4.runtime.atn.ATNDeserializer;
+import org.antlr.v4.runtime.atn.ATNSerializer;
+import org.antlr.v4.runtime.atn.ATNState;
+import org.antlr.v4.runtime.atn.LexerATNSimulator;
+import org.antlr.v4.runtime.dfa.DFA;
+import org.antlr.v4.runtime.misc.IntegerList;
+import org.antlr.v4.runtime.misc.Interval;
+import org.antlr.v4.semantics.SemanticPipeline;
+import org.antlr.v4.test.runtime.java.ErrorQueue;
+import org.antlr.v4.tool.ANTLRMessage;
+import org.antlr.v4.tool.DOTGenerator;
+import org.antlr.v4.tool.DefaultToolListener;
+import org.antlr.v4.tool.Grammar;
+import org.antlr.v4.tool.GrammarSemanticsMessage;
+import org.antlr.v4.tool.LexerGrammar;
+import org.antlr.v4.tool.Rule;
+import org.eclipse.jetty.server.Handler;
+import org.eclipse.jetty.server.Server;
+import org.eclipse.jetty.server.handler.DefaultHandler;
+import org.eclipse.jetty.server.handler.HandlerList;
+import org.eclipse.jetty.server.handler.ResourceHandler;
+import org.junit.Before;
+import org.junit.rules.TestRule;
+import org.junit.rules.TestWatcher;
+import org.junit.runner.Description;
+import org.openqa.selenium.By.ById;
+import org.openqa.selenium.WebDriver;
+import org.stringtemplate.v4.ST;
+import org.stringtemplate.v4.STGroup;
+import org.stringtemplate.v4.STGroupString;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.net.BindException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+public abstract class BaseBrowserTest {
+	// -J-Dorg.antlr.v4.test.BaseTest.level=FINE
+	// private static final Logger LOGGER = Logger.getLogger(BaseTest.class.getName());
+
+	public static final String newline = System.getProperty("line.separator");
+	public static final String pathSep = System.getProperty("path.separator");
+
+	public String httpdir = null;
+	public String tmpdir = null;
+
+	/** If error during parser execution, store stderr here; can't return
+     *  stdout and stderr.  This doesn't trap errors from running antlr.
+     */
+	protected String stderrDuringParse;
+
+	@org.junit.Rule
+	public final TestRule testWatcher = new TestWatcher() {
+
+		@Override
+		protected void succeeded(Description description) {
+			// remove tmpdir if no error.
+			eraseTempDir();
+		}
+
+	};
+
+    @Before
+	public void setUp() throws Exception {
+        // new output dir for each test
+    	String prop = System.getProperty("antlr-javascript-test-dir");
+    	if(prop!=null && prop.length()>0)
+    		httpdir = prop;
+    	else
+    		httpdir = new File(System.getProperty("java.io.tmpdir"), getClass().getSimpleName()+"-"+System.currentTimeMillis()).getAbsolutePath();
+    	File dir = new File(httpdir);
+    	if(dir.exists())
+    		this.eraseFiles(dir);
+    	tmpdir = new File(httpdir, "parser").getAbsolutePath();
+    }
+
+    protected org.antlr.v4.Tool newTool(String[] args) {
+		Tool tool = new Tool(args);
+		return tool;
+	}
+
+	protected Tool newTool() {
+		org.antlr.v4.Tool tool = new Tool(new String[] {"-o", tmpdir});
+		return tool;
+	}
+
+	protected ATN createATN(Grammar g, boolean useSerializer) {
+		if ( g.atn==null ) {
+			semanticProcess(g);
+			assertEquals(0, g.tool.getNumErrors());
+
+			ParserATNFactory f;
+			if ( g.isLexer() ) {
+				f = new LexerATNFactory((LexerGrammar)g);
+			}
+			else {
+				f = new ParserATNFactory(g);
+			}
+
+			g.atn = f.createATN();
+			assertEquals(0, g.tool.getNumErrors());
+		}
+
+		ATN atn = g.atn;
+		if (useSerializer) {
+			char[] serialized = ATNSerializer.getSerializedAsChars(atn);
+			return new ATNDeserializer().deserialize(serialized);
+		}
+
+		return atn;
+	}
+
+	protected void semanticProcess(Grammar g) {
+		if ( g.ast!=null && !g.ast.hasErrors ) {
+			System.out.println(g.ast.toStringTree());
+			Tool antlr = new Tool();
+			SemanticPipeline sem = new SemanticPipeline(g);
+			sem.process();
+			if ( g.getImportedGrammars()!=null ) { // process imported grammars (if any)
+				for (Grammar imp : g.getImportedGrammars()) {
+					antlr.processNonCombinedGrammar(imp, false);
+				}
+			}
+		}
+	}
+
+
+	IntegerList getTypesFromString(Grammar g, String expecting) {
+		IntegerList expectingTokenTypes = new IntegerList();
+		if ( expecting!=null && !expecting.trim().isEmpty() ) {
+			for (String tname : expecting.replace(" ", "").split(",")) {
+				int ttype = g.getTokenType(tname);
+				expectingTokenTypes.add(ttype);
+			}
+		}
+		return expectingTokenTypes;
+	}
+
+	public IntegerList getTokenTypesViaATN(String input, LexerATNSimulator lexerATN) {
+		ANTLRInputStream in = new ANTLRInputStream(input);
+		IntegerList tokenTypes = new IntegerList();
+		int ttype;
+		do {
+			ttype = lexerATN.match(in, Lexer.DEFAULT_MODE);
+			tokenTypes.add(ttype);
+		} while ( ttype!= Token.EOF );
+		return tokenTypes;
+	}
+
+	public List<String> getTokenTypes(LexerGrammar lg,
+									  ATN atn,
+									  CharStream input)
+	{
+		LexerATNSimulator interp = new LexerATNSimulator(atn,new DFA[] { new DFA(atn.modeToStartState.get(Lexer.DEFAULT_MODE)) },null);
+		List<String> tokenTypes = new ArrayList<String>();
+		int ttype;
+		boolean hitEOF = false;
+		do {
+			if ( hitEOF ) {
+				tokenTypes.add("EOF");
+				break;
+			}
+			int t = input.LA(1);
+			ttype = interp.match(input, Lexer.DEFAULT_MODE);
+			if ( ttype == Token.EOF ) {
+				tokenTypes.add("EOF");
+			}
+			else {
+				tokenTypes.add(lg.typeToTokenList.get(ttype));
+			}
+
+			if ( t==IntStream.EOF ) {
+				hitEOF = true;
+			}
+		} while ( ttype!=Token.EOF );
+		return tokenTypes;
+	}
+
+
+	/** Return true if all is ok, no errors */
+	protected ErrorQueue antlr(String fileName, String grammarFileName, String grammarStr, boolean defaultListener, String... extraOptions) {
+		System.out.println("dir "+tmpdir);
+		mkdir(tmpdir);
+		writeFile(tmpdir, fileName, grammarStr);
+		final List<String> options = new ArrayList<String>();
+		Collections.addAll(options, extraOptions);
+		options.add("-Dlanguage=JavaScript");
+		options.add("-o");
+		options.add(tmpdir);
+		options.add("-lib");
+		options.add(tmpdir);
+		options.add(new File(tmpdir,grammarFileName).toString());
+
+		final String[] optionsA = new String[options.size()];
+		options.toArray(optionsA);
+		Tool antlr = newTool(optionsA);
+		ErrorQueue equeue = new ErrorQueue(antlr);
+		antlr.addListener(equeue);
+		if (defaultListener) {
+			antlr.addListener(new DefaultToolListener(antlr));
+		}
+		antlr.processGrammarsOnCommandLine();
+
+		if ( !defaultListener && !equeue.errors.isEmpty() ) {
+			System.err.println("antlr reports errors from "+options);
+			for (int i = 0; i < equeue.errors.size(); i++) {
+				ANTLRMessage msg = equeue.errors.get(i);
+				System.err.println(msg);
+			}
+			System.out.println("!!!\ngrammar:");
+			System.out.println(grammarStr);
+			System.out.println("###");
+		}
+		if ( !defaultListener && !equeue.warnings.isEmpty() ) {
+			System.err.println("antlr reports warnings from "+options);
+			for (int i = 0; i < equeue.warnings.size(); i++) {
+				ANTLRMessage msg = equeue.warnings.get(i);
+				System.err.println(msg);
+			}
+		}
+
+		return equeue;
+	}
+
+	protected String execLexer(String grammarFileName,
+							   String grammarStr,
+							   String lexerName,
+							   String input, boolean showDFA) throws Exception
+	{
+		boolean success = rawGenerateAndBuildRecognizer(grammarFileName,
+									  grammarStr,
+									  null,
+									  lexerName,"-no-listener");
+		assertTrue(success);
+		writeLexerTestFile(lexerName, showDFA);
+		String output = execHtmlPage("Test.html", input);
+		if ( stderrDuringParse!=null && stderrDuringParse.length()>0 ) {
+			System.err.println(stderrDuringParse);
+		}
+		return output;
+	}
+
+	protected String execParser(String grammarFileName,
+								String grammarStr,
+								String parserName,
+								String lexerName,
+								String listenerName,
+								String visitorName,
+								String startRuleName,
+								String input,
+								boolean debug) throws Exception
+	{
+		boolean success = rawGenerateAndBuildRecognizer(grammarFileName,
+														grammarStr,
+														parserName,
+														lexerName,
+														"-visitor");
+		assertTrue(success);
+		rawBuildRecognizerTestFile(parserName,
+								 lexerName,
+								 listenerName,
+								 visitorName,
+								 startRuleName,
+								 debug);
+		return execRecognizer(input);
+	}
+
+	/** Return true if all is well */
+	protected boolean rawGenerateAndBuildRecognizer(String grammarFileName,
+													String grammarStr,
+													String parserName,
+													String lexerName,
+													String... extraOptions)
+	{
+		return rawGenerateAndBuildRecognizer(grammarFileName, grammarStr, parserName, lexerName, false, extraOptions);
+	}
+
+	/** Return true if all is well */
+	protected boolean rawGenerateAndBuildRecognizer(String grammarFileName,
+													String grammarStr,
+													String parserName,
+													String lexerName,
+													boolean defaultListener,
+													String... extraOptions)
+	{
+		ErrorQueue equeue =
+			antlr(grammarFileName, grammarFileName, grammarStr, defaultListener, extraOptions);
+		if (!equeue.errors.isEmpty()) {
+			return false;
+		}
+
+		List<String> files = new ArrayList<String>();
+		if ( lexerName!=null ) {
+			files.add(lexerName+".js");
+		}
+		if ( parserName!=null ) {
+			files.add(parserName+".js");
+			Set<String> optionsSet = new HashSet<String>(Arrays.asList(extraOptions));
+			if (!optionsSet.contains("-no-listener")) {
+				files.add(grammarFileName.substring(0, grammarFileName.lastIndexOf('.'))+"Listener.js");
+			}
+			if (optionsSet.contains("-visitor")) {
+				files.add(grammarFileName.substring(0, grammarFileName.lastIndexOf('.'))+"Visitor.js");
+			}
+		}
+		return true; // allIsWell: no compile
+	}
+
+	protected void rawBuildRecognizerTestFile(String parserName,
+									   String lexerName,
+									   String listenerName,
+									   String visitorName,
+									   String parserStartRuleName, boolean debug)
+	{
+        this.stderrDuringParse = null;
+		if ( parserName==null ) {
+			writeLexerTestFile(lexerName, false);
+		}
+		else {
+			writeParserTestFile(parserName,
+						  lexerName,
+						  listenerName,
+						  visitorName,
+						  parserStartRuleName,
+						  debug);
+		}
+	}
+
+	public String execRecognizer(String input) throws Exception {
+		return execHtmlPage("Test.html", input);
+	}
+
+	static int httpPort = 8080;
+
+	class ServerThread extends Thread {
+
+		Server server;
+		String runtimePath;
+		String fileName;
+		Exception ex;
+
+		public ServerThread(String fileName) {
+			this.runtimePath = locateRuntime();
+			this.fileName = fileName;
+		}
+
+		@Override
+		public void run() {
+			try {
+				Server server = new Server(httpPort);
+				ResourceHandler rh1 = new ResourceHandler();
+				rh1.setDirectoriesListed(false);
+				rh1.setResourceBase(httpdir);
+				rh1.setWelcomeFiles(new String[] { fileName });
+				ResourceHandler rh2 = new ResourceHandler();
+				rh2.setDirectoriesListed(false);
+				rh2.setResourceBase(runtimePath);
+				HandlerList handlers = new HandlerList();
+				handlers.setHandlers(new Handler[] { rh1, rh2, new DefaultHandler() });
+				server.setHandler(handlers);
+				server.start();
+				this.server = server;
+				this.server.join();
+			} catch(BindException e) {
+				httpPort++;
+				run();
+			} catch (Exception e) {
+				ex = e;
+			}
+		}
+	}
+	
+	protected static WebDriver driver;
+
+	public String execHtmlPage(String fileName, String input) throws Exception {
+		// 'file' protocol is not supported by Selenium drivers
+		// so we run an embedded Jetty server
+		ServerThread thread = new ServerThread(fileName);
+		thread.start();
+		try {
+			while(thread.server==null && thread.ex==null)
+				Thread.sleep(10);
+			if(thread.ex!=null)
+				throw thread.ex;
+			while(thread.server.isStarting())
+				Thread.sleep(10);
+			Thread.sleep(400); // despite all the above precautions, driver.get often fails if you don't give time to Jetty
+			driver.get("http://localhost:" + httpPort + "/" + fileName);
+			driver.findElement(new ById("input")).clear();
+			driver.findElement(new ById("output")).clear();
+			driver.findElement(new ById("errors")).clear();
+			driver.navigate().refresh();
+			driver.findElement(new ById("input")).sendKeys(input);
+			driver.findElement(new ById("load")).click();
+			driver.findElement(new ById("submit")).click();
+			String errors = driver.findElement(new ById("errors")).getAttribute("value");
+			if(errors!=null && errors.length()>0) {
+				this.stderrDuringParse = errors;
+				System.err.print(errors);
+			}
+			String value = driver.findElement(new ById("output")).getAttribute("value");
+			// mimic stdout which adds a NL
+			if(value.length()>0 && !value.endsWith("\n"))
+				value = value + "\n";
+			return value;
+		}
+		catch (Exception e) {
+			System.err.println("can't exec recognizer");
+			e.printStackTrace(System.err);
+		} finally {
+			if(thread.server!=null) {
+				thread.server.stop();
+				while(!thread.server.isStopped())
+					Thread.sleep(10);
+				Thread.sleep(100); // ensure the port is freed
+			}
+		}
+		return null;
+	}
+
+	private String locateRuntime() {
+		String propName = "antlr-javascript-runtime";
+		String prop = System.getProperty(propName);
+		if(prop==null || prop.length()==0)
+			prop = "../runtime/JavaScript/src";
+		File file = new File(prop);
+		System.out.println(file.getAbsolutePath());
+		if(!file.exists())
+			throw new RuntimeException("Missing system property:" + propName);
+		return file.getAbsolutePath();
+	}
+
+	public void testErrors(String[] pairs, boolean printTree) {
+        for (int i = 0; i < pairs.length; i+=2) {
+            String input = pairs[i];
+            String expect = pairs[i+1];
+
+			String[] lines = input.split("\n");
+			String fileName = getFilenameFromFirstLineOfGrammar(lines[0]);
+			ErrorQueue equeue = antlr(fileName, fileName, input, false);
+
+			String actual = equeue.toString(true);
+			actual = actual.replace(tmpdir + File.separator, "");
+			System.err.println(actual);
+			String msg = input;
+			msg = msg.replace("\n","\\n");
+			msg = msg.replace("\r","\\r");
+			msg = msg.replace("\t","\\t");
+
+            assertEquals("error in: "+msg,expect,actual);
+        }
+    }
+
+	public String getFilenameFromFirstLineOfGrammar(String line) {
+		String fileName = "A" + Tool.GRAMMAR_EXTENSION;
+		int grIndex = line.lastIndexOf("grammar");
+		int semi = line.lastIndexOf(';');
+		if ( grIndex>=0 && semi>=0 ) {
+			int space = line.indexOf(' ', grIndex);
+			fileName = line.substring(space+1, semi)+Tool.GRAMMAR_EXTENSION;
+		}
+		if ( fileName.length()==Tool.GRAMMAR_EXTENSION.length() ) fileName = "A" + Tool.GRAMMAR_EXTENSION;
+		return fileName;
+	}
+
+	List<ANTLRMessage> getMessagesOfType(List<ANTLRMessage> msgs, Class<? extends ANTLRMessage> c) {
+		List<ANTLRMessage> filtered = new ArrayList<ANTLRMessage>();
+		for (ANTLRMessage m : msgs) {
+			if ( m.getClass() == c ) filtered.add(m);
+		}
+		return filtered;
+	}
+
+	void checkRuleATN(Grammar g, String ruleName, String expecting) {
+		ParserATNFactory f = new ParserATNFactory(g);
+		ATN atn = f.createATN();
+
+		DOTGenerator dot = new DOTGenerator(g);
+		System.out.println(dot.getDOT(atn.ruleToStartState[g.getRule(ruleName).index]));
+
+		Rule r = g.getRule(ruleName);
+		ATNState startState = atn.ruleToStartState[r.index];
+		ATNPrinter serializer = new ATNPrinter(g, startState);
+		String result = serializer.asString();
+
+		//System.out.print(result);
+		assertEquals(expecting, result);
+	}
+
+	public void testActions(String templates, String actionName, String action, String expected) throws org.antlr.runtime.RecognitionException {
+		int lp = templates.indexOf('(');
+		String name = templates.substring(0, lp);
+		STGroup group = new STGroupString(templates);
+		ST st = group.getInstanceOf(name);
+		st.add(actionName, action);
+		String grammar = st.render();
+		ErrorQueue equeue = new ErrorQueue();
+		Grammar g = new Grammar(grammar, equeue);
+		if ( g.ast!=null && !g.ast.hasErrors ) {
+			SemanticPipeline sem = new SemanticPipeline(g);
+			sem.process();
+
+			ATNFactory factory = new ParserATNFactory(g);
+			if ( g.isLexer() ) factory = new LexerATNFactory((LexerGrammar)g);
+			g.atn = factory.createATN();
+
+			CodeGenerator gen = new CodeGenerator(g);
+			ST outputFileST = gen.generateParser();
+			String output = outputFileST.render();
+			//System.out.println(output);
+			String b = "#" + actionName + "#";
+			int start = output.indexOf(b);
+			String e = "#end-" + actionName + "#";
+			int end = output.indexOf(e);
+			String snippet = output.substring(start+b.length(),end);
+			assertEquals(expected, snippet);
+		}
+		if ( equeue.size()>0 ) {
+			System.err.println(equeue.toString());
+		}
+	}
+
+	public static class StreamVacuum implements Runnable {
+		StringBuilder buf = new StringBuilder();
+		BufferedReader in;
+		Thread sucker;
+		public StreamVacuum(InputStream in) {
+			this.in = new BufferedReader( new InputStreamReader(in) );
+		}
+		public void start() {
+			sucker = new Thread(this);
+			sucker.start();
+		}
+		@Override
+		public void run() {
+			try {
+				String line = in.readLine();
+				while (line!=null) {
+					buf.append(line);
+					buf.append('\n');
+					line = in.readLine();
+				}
+			}
+			catch (IOException ioe) {
+				System.err.println("can't read output from process");
+			}
+		}
+		/** wait for the thread to finish */
+		public void join() throws InterruptedException {
+			sucker.join();
+		}
+		@Override
+		public String toString() {
+			return buf.toString();
+		}
+	}
+
+	protected void checkGrammarSemanticsError(ErrorQueue equeue,
+											  GrammarSemanticsMessage expectedMessage)
+		throws Exception
+	{
+		ANTLRMessage foundMsg = null;
+		for (int i = 0; i < equeue.errors.size(); i++) {
+			ANTLRMessage m = equeue.errors.get(i);
+			if (m.getErrorType()==expectedMessage.getErrorType() ) {
+				foundMsg = m;
+			}
+		}
+		assertNotNull("no error; "+expectedMessage.getErrorType()+" expected", foundMsg);
+		assertTrue("error is not a GrammarSemanticsMessage",
+				   foundMsg instanceof GrammarSemanticsMessage);
+		assertEquals(Arrays.toString(expectedMessage.getArgs()), Arrays.toString(foundMsg.getArgs()));
+		if ( equeue.size()!=1 ) {
+			System.err.println(equeue);
+		}
+	}
+
+	protected void checkGrammarSemanticsWarning(ErrorQueue equeue,
+											    GrammarSemanticsMessage expectedMessage)
+		throws Exception
+	{
+		ANTLRMessage foundMsg = null;
+		for (int i = 0; i < equeue.warnings.size(); i++) {
+			ANTLRMessage m = equeue.warnings.get(i);
+			if (m.getErrorType()==expectedMessage.getErrorType() ) {
+				foundMsg = m;
+			}
+		}
+		assertNotNull("no error; "+expectedMessage.getErrorType()+" expected", foundMsg);
+		assertTrue("error is not a GrammarSemanticsMessage",
+				   foundMsg instanceof GrammarSemanticsMessage);
+		assertEquals(Arrays.toString(expectedMessage.getArgs()), Arrays.toString(foundMsg.getArgs()));
+		if ( equeue.size()!=1 ) {
+			System.err.println(equeue);
+		}
+	}
+
+	protected void checkError(ErrorQueue equeue,
+							  ANTLRMessage expectedMessage)
+		throws Exception
+	{
+		//System.out.println("errors="+equeue);
+		ANTLRMessage foundMsg = null;
+		for (int i = 0; i < equeue.errors.size(); i++) {
+			ANTLRMessage m = equeue.errors.get(i);
+			if (m.getErrorType()==expectedMessage.getErrorType() ) {
+				foundMsg = m;
+			}
+		}
+		assertTrue("no error; "+expectedMessage.getErrorType()+" expected", !equeue.errors.isEmpty());
+		assertTrue("too many errors; "+equeue.errors, equeue.errors.size()<=1);
+		assertNotNull("couldn't find expected error: "+expectedMessage.getErrorType(), foundMsg);
+		/*
+		assertTrue("error is not a GrammarSemanticsMessage",
+				   foundMsg instanceof GrammarSemanticsMessage);
+		 */
+		assertArrayEquals(expectedMessage.getArgs(), foundMsg.getArgs());
+	}
+
+    public static class FilteringTokenStream extends CommonTokenStream {
+        public FilteringTokenStream(TokenSource src) { super(src); }
+        Set<Integer> hide = new HashSet<Integer>();
+        @Override
+        protected boolean sync(int i) {
+            if (!super.sync(i)) {
+				return false;
+			}
+
+			Token t = get(i);
+			if ( hide.contains(t.getType()) ) {
+				((WritableToken)t).setChannel(Token.HIDDEN_CHANNEL);
+			}
+
+			return true;
+        }
+        public void setTokenTypeChannel(int ttype, int channel) {
+            hide.add(ttype);
+        }
+    }
+
+	public static void writeFile(String dir, String fileName, String content) {
+		try {
+			File f = new File(dir, fileName);
+			FileWriter w = new FileWriter(f);
+			BufferedWriter bw = new BufferedWriter(w);
+			bw.write(content);
+			bw.close();
+			w.close();
+		}
+		catch (IOException ioe) {
+			System.err.println("can't write file");
+			ioe.printStackTrace(System.err);
+		}
+	}
+
+	protected void mkdir(String dir) {
+		File f = new File(dir);
+		f.mkdirs();
+	}
+
+	protected void writeParserTestFile(String parserName,
+			 String lexerName,
+			 String listenerName,
+			 String visitorName,
+			 String parserStartRuleName, boolean debug) {
+		String html = "<!DOCTYPE html>\r\n" +
+		"<html>\r\n" +
+	    "	<head>\r\n" +
+        "		<script src='lib/require.js'></script>\r\n" +
+        "		<script>\r\n" +
+        "			antlr4 = null;\r\n" +
+        "			listener = null;\r\n" +
+        "			TreeShapeListener = null;\r\n" +
+        "			" + lexerName + " = null;\r\n" +
+        "			" + parserName + " = null;\r\n" +
+        "			" + listenerName + " = null;\r\n" +
+        "			" + visitorName + " = null;\r\n" +
+        "			printer = function() {\r\n" +
+        "				this.println = function(s) { document.getElementById('output').value += s + '\\n'; }\r\n" +
+        "				this.print = function(s) { document.getElementById('output').value += s; }\r\n" +
+        "				return this;\r\n" +
+        "			};\r\n" +
+		"\r\n" +
+		"			loadParser = function() {\r\n" +
+        "				try {\r\n" +
+        "					antlr4 = require('antlr4/index');\r\n" +
+		"					" + lexerName + " = require('./parser/" + lexerName + "');\n" +
+		"					" + parserName + " = require('./parser/" + parserName + "');\n" +
+		"					" + listenerName + " = require('./parser/" + listenerName + "');\n" +
+		"					" + visitorName + " = require('./parser/" + visitorName + "');\n" +
+        "				} catch (ex) {\r\n" +
+        "					document.getElementById('errors').value = ex.toString();\r\n" +
+        "				}\r\n" +
+		"\r\n" +
+		"				listener = function() {\r\n" +
+		"					antlr4.error.ErrorListener.call(this);\r\n" +
+		"					return this;\r\n" +
+		"				}\r\n" +
+		"				listener.prototype = Object.create(antlr4.error.ErrorListener.prototype);\r\n" +
+		"				listener.prototype.constructor = listener;\r\n" +
+		"				listener.prototype.syntaxError = function(recognizer, offendingSymbol, line, column, msg, e) {\r\n" +
+		"    				document.getElementById('errors').value += 'line ' + line + ':' + column + ' ' + msg + '\\r\\n';\r\n" +
+		"				};\r\n" +
+		"\r\n" +
+        "				TreeShapeListener = function() {\r\n" +
+        "					antlr4.tree.ParseTreeListener.call(this);\r\n" +
+        "					return this;\r\n" +
+        "				};\r\n" +
+		"\r\n" +
+		"				TreeShapeListener.prototype = Object.create(antlr4.tree.ParseTreeListener.prototype);\r\n" +
+		"				TreeShapeListener.prototype.constructor = TreeShapeListener;\r\n" +
+		"\r\n" +
+		"				TreeShapeListener.prototype.enterEveryRule = function(ctx) {\r\n" +
+		"					for(var i=0;i<ctx.getChildCount; i++) {\r\n" +
+		"						var child = ctx.getChild(i);\r\n" +
+		"						var parent = child.parentCtx;\r\n" +
+		"						if(parent.getRuleContext() !== ctx || !(parent instanceof antlr4.tree.RuleNode)) {\r\n" +
+		"							throw 'Invalid parse tree shape detected.';\r\n" +
+		"						}\r\n" +
+		"					}\r\n" +
+		"				};\r\n" +
+		"			}\r\n" +
+		"\r\n" +
+		"			test = function() {\r\n" +
+		"				document.getElementById('output').value = ''\r\n" +
+		"				var input = document.getElementById('input').value;\r\n" +
+		"    			var stream = new antlr4.InputStream(input);\n" +
+		"    			var lexer = new " + lexerName + "." + lexerName + "(stream);\n" +
+		"				lexer._listeners = [new listener()];\r\n" +
+	    "    			var tokens = new antlr4.CommonTokenStream(lexer);\n" +
+	    "				var parser = new " + parserName + "." + parserName + "(tokens);\n" +
+	    "				parser._listeners.push(new listener());\n" +
+	    (debug ?
+	    "				parser._listeners.push(new antlr4.error.DiagnosticErrorListener());\n" : "") +
+	    "    			parser.buildParseTrees = true;\n" +
+	    "    			parser.printer = new printer();\n" +
+		"    			var tree = parser." + parserStartRuleName + "();\n" +
+		"    			antlr4.tree.ParseTreeWalker.DEFAULT.walk(new TreeShapeListener(), tree);\n" +
+		"			};\r\n" +
+		"\r\n" +
+        "		</script>\r\n" +
+	    "	</head>\r\n" +
+	    "	<body>\r\n" +
+	    "		<textarea id='input'></textarea><br>\r\n" +
+	    "		<button id='load' type='button' onclick='loadParser()'>Load</button><br>\r\n" +
+	    "		<button id='submit' type='button' onclick='test()'>Test</button><br>\r\n" +
+	    "		<textarea id='output'></textarea><br>\r\n" +
+	    "		<textarea id='errors'></textarea><br>\r\n" +
+	    "	</body>\r\n" +
+	    "</html>\r\n";
+		writeFile(httpdir, "Test.html", html);
+	};
+
+
+	protected void writeLexerTestFile(String lexerName, boolean showDFA) {
+		String html = "<!DOCTYPE html>\r\n" +
+		"<html>\r\n" +
+	    "	<head>\r\n" +
+        "		<script src='lib/require.js'></script>\r\n" +
+        "		<script>\r\n" +
+        "			antlr4 = null;\r\n" +
+        "			listener = null;\r\n" +
+        "			" + lexerName + " = null;\r\n" +
+ 		"\r\n" +
+		"			loadLexer = function() {\r\n" +
+        "				try {\r\n" +
+        "					antlr4 = require('antlr4/index');\r\n" +
+		"					" + lexerName + " = require('./parser/" + lexerName + "');\r\n" +
+        "				} catch (ex) {\r\n" +
+        "					document.getElementById('errors').value = ex.toString();\r\n" +
+        "				}\r\n" +
+		"				listener = function() {\r\n" +
+		"					antlr4.error.ErrorListener.call(this);\r\n" +
+		"					return this;\r\n" +
+		"				}\r\n" +
+		"				listener.prototype = Object.create(antlr4.error.ErrorListener.prototype);\r\n" +
+		"				listener.prototype.constructor = listener;\r\n" +
+		"				listener.prototype.syntaxError = function(recognizer, offendingSymbol, line, column, msg, e) {\r\n" +
+		"    				document.getElementById('errors').value += 'line ' + line + ':' + column + ' ' + msg + '\\r\\n';\r\n" +
+		"				};\r\n" +
+		"			}\r\n" +
+		"\r\n" +
+		"			test = function() {\r\n" +
+		"				document.getElementById('output').value = ''\r\n" +
+		"				var input = document.getElementById('input').value;\r\n" +
+		"    			var chars = new antlr4.InputStream(input);\r\n" +
+		"    			var lexer = new " + lexerName + "." + lexerName + "(chars);\r\n" +
+		"				lexer._listeners = [new listener()];\r\n" +
+	    "    			var stream = new antlr4.CommonTokenStream(lexer);\r\n" +
+		"    			stream.fill();\r\n" +
+	    "    			for(var i=0; i<stream.tokens.length; i++) {\r\n" +
+	    "					document.getElementById('output').value += stream.tokens[i].toString() + '\\r\\n';\r\n" +
+		"    			}\n" +
+		(showDFA ?
+		"    			document.getElementById('output').value += lexer._interp.decisionToDFA[antlr4.Lexer.DEFAULT_MODE].toLexerString();\r\n"
+						:"") +
+		"			};\r\n" +
+		"\r\n" +
+        "		</script>\r\n" +
+	    "	</head>\r\n" +
+	    "	<body>\r\n" +
+	    "		<textarea id='input'></textarea><br>\r\n" +
+	    "		<button id='load' type='button' onclick='loadLexer()'>Load</button><br>\r\n" +
+	    "		<button id='submit' type='button' onclick='test()'>Test</button><br>\r\n" +
+	    "		<textarea id='output'></textarea><br>\r\n" +
+	    "		<textarea id='errors'></textarea><br>\r\n" +
+	    "	</body>\r\n" +
+	    "</html>\r\n";
+		writeFile(httpdir, "Test.html", html);
+	}
+
+	public void writeRecognizer(String parserName, String lexerName,
+								String listenerName, String visitorName,
+								String parserStartRuleName, boolean debug) {
+		if ( parserName==null )
+			writeLexerTestFile(lexerName, debug);
+		else
+			writeParserTestFile(parserName,
+						  lexerName,
+						  listenerName,
+						  visitorName,
+						  parserStartRuleName,
+						  debug);
+	}
+
+
+    protected void eraseFiles(final String filesEndingWith) {
+        File tmpdirF = new File(httpdir);
+        String[] files = tmpdirF.list();
+        for(int i = 0; files!=null && i < files.length; i++) {
+            if ( files[i].endsWith(filesEndingWith) ) {
+                new File(httpdir+"/"+files[i]).delete();
+            }
+        }
+    }
+
+    protected void eraseFiles(File dir) {
+       String[] files = dir.list();
+        for(int i = 0; files!=null && i < files.length; i++) {
+            new File(dir,files[i]).delete();
+        }
+    }
+
+    protected void eraseTempDir() {
+       	boolean doErase = true;
+    	String propName = "antlr-javascript-erase-test-dir";
+    	String prop = System.getProperty(propName);
+    	if(prop!=null && prop.length()>0)
+    		doErase = Boolean.getBoolean(prop);
+        if(doErase) {
+	        File tmpdirF = new File(httpdir);
+	        if ( tmpdirF.exists() ) {
+	            eraseFiles(tmpdirF);
+	            tmpdirF.delete();
+	        }
+        }
+    }
+
+   public String getFirstLineOfException() {
+		if ( this.stderrDuringParse ==null ) {
+			return null;
+		}
+		String[] lines = this.stderrDuringParse.split("\n");
+		String prefix="Exception in thread \"main\" ";
+		return lines[0].substring(prefix.length(),lines[0].length());
+	}
+
+    /**
+     * When looking at a result set that consists of a Map/HashTable
+     * we cannot rely on the output order, as the hashing algorithm or other aspects
+     * of the implementation may be different on differnt JDKs or platforms. Hence
+     * we take the Map, convert the keys to a List, sort them and Stringify the Map, which is a
+     * bit of a hack, but guarantees that we get the same order on all systems. We assume that
+     * the keys are strings.
+     *
+     * @param m The Map that contains keys we wish to return in sorted order
+     * @return A string that represents all the keys in sorted order.
+     */
+    public <K, V> String sortMapToString(Map<K, V> m) {
+        // Pass in crap, and get nothing back
+        //
+        if  (m == null) {
+            return null;
+        }
+
+        System.out.println("Map toString looks like: " + m.toString());
+
+        // Sort the keys in the Map
+        //
+        TreeMap<K, V> nset = new TreeMap<K, V>(m);
+
+        System.out.println("Tree map looks like: " + nset.toString());
+        return nset.toString();
+    }
+
+	public List<String> realElements(List<String> elements) {
+		return elements.subList(Token.MIN_USER_TOKEN_TYPE, elements.size());
+	}
+
+	public void assertNotNullOrEmpty(String message, String text) {
+		assertNotNull(message, text);
+		assertFalse(message, text.isEmpty());
+	}
+
+	public void assertNotNullOrEmpty(String text) {
+		assertNotNull(text);
+		assertFalse(text.isEmpty());
+	}
+
+	public static class IntTokenStream implements TokenStream {
+		IntegerList types;
+		int p=0;
+		public IntTokenStream(IntegerList types) { this.types = types; }
+
+		@Override
+		public void consume() { p++; }
+
+		@Override
+		public int LA(int i) { return LT(i).getType(); }
+
+		@Override
+		public int mark() {
+			return index();
+		}
+
+		@Override
+		public int index() { return p; }
+
+		@Override
+		public void release(int marker) {
+			seek(marker);
+		}
+
+		@Override
+		public void seek(int index) {
+			p = index;
+		}
+
+		@Override
+		public int size() {
+			return types.size();
+		}
+
+		@Override
+		public String getSourceName() {
+			return null;
+		}
+
+		@Override
+		public Token LT(int i) {
+			CommonToken t;
+			int rawIndex = p + i - 1;
+			if ( rawIndex>=types.size() ) t = new CommonToken(Token.EOF);
+			else t = new CommonToken(types.get(rawIndex));
+			t.setTokenIndex(rawIndex);
+			return t;
+		}
+
+		@Override
+		public Token get(int i) {
+			return new org.antlr.v4.runtime.CommonToken(types.get(i));
+		}
+
+		@Override
+		public TokenSource getTokenSource() {
+			return null;
+		}
+
+
+		@Override
+		public String getText() {
+			throw new UnsupportedOperationException("can't give strings");
+		}
+
+
+		@Override
+		public String getText(Interval interval) {
+			throw new UnsupportedOperationException("can't give strings");
+		}
+
+
+		@Override
+		public String getText(RuleContext ctx) {
+			throw new UnsupportedOperationException("can't give strings");
+		}
+
+
+		@Override
+		public String getText(Token start, Token stop) {
+			throw new UnsupportedOperationException("can't give strings");
+		}
+	}
+
+	/** Sort a list */
+	public <T extends Comparable<? super T>> List<T> sort(List<T> data) {
+		List<T> dup = new ArrayList<T>();
+		dup.addAll(data);
+		Collections.sort(dup);
+		return dup;
+	}
+
+	/** Return map sorted by key */
+	public <K extends Comparable<? super K>,V> LinkedHashMap<K,V> sort(Map<K,V> data) {
+		LinkedHashMap<K,V> dup = new LinkedHashMap<K, V>();
+		List<K> keys = new ArrayList<K>();
+		keys.addAll(data.keySet());
+		Collections.sort(keys);
+		for (K k : keys) {
+			dup.put(k, data.get(k));
+		}
+		return dup;
+	}
+}
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/chrome/BaseTest.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/chrome/BaseTest.java
new file mode 100644
index 000000000..6d919a311
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/chrome/BaseTest.java
@@ -0,0 +1,48 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2012 Terence Parr
+ *  Copyright (c) 2012 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.
+ */
+package org.antlr.v4.test.runtime.javascript.chrome;
+
+import org.antlr.v4.test.runtime.javascript.browser.BaseBrowserTest;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+
+public abstract class BaseTest extends BaseBrowserTest {
+
+	@BeforeClass
+	public static void initWebDriver() {
+		driver = SharedWebDriver.init();
+	}
+
+	@AfterClass
+	public static void closeWebDriver() {
+		SharedWebDriver.close();
+	}
+
+}
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/chrome/SharedWebDriver.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/chrome/SharedWebDriver.java
new file mode 100644
index 000000000..32f86c1a0
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/chrome/SharedWebDriver.java
@@ -0,0 +1,50 @@
+package org.antlr.v4.test.runtime.javascript.chrome;
+
+import org.openqa.selenium.WebDriver;
+import org.openqa.selenium.chrome.ChromeDriver;
+
+import java.io.File;
+import java.net.URL;
+import java.util.Timer;
+import java.util.TimerTask;
+
+import static org.junit.Assert.assertTrue;
+
+public class SharedWebDriver {
+
+	static WebDriver driver;
+	static Timer timer;
+
+	public static WebDriver init() {
+		if(driver==null) {
+			String path = SharedWebDriver.class.getPackage().getName().replace(".", "/") + "/chromedriver.bin";
+			URL url = Thread.currentThread().getContextClassLoader().getResource(path);
+			File file = new File(url.toExternalForm().substring(5)); // skip 'file:'
+			assertTrue(file.exists());
+			System.setProperty("webdriver.chrome.driver", file.getAbsolutePath());
+			driver = new ChromeDriver();
+		} else if(timer!=null) {
+			timer.cancel();
+			timer = null;
+		}
+
+		return driver;
+	}
+
+	public static void close() {
+		if(driver!=null) {
+			if(timer!=null) {
+				timer.cancel();
+				timer = null;
+			}
+			timer = new Timer();
+			timer.schedule(new TimerTask() {
+				@Override public void run() {
+					driver.quit();
+					driver = null;
+				}
+			}, 2000); // close with delay to allow next Test to start
+		}
+	}
+
+}
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/chrome/chromedriver.bin b/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/chrome/chromedriver.bin
new file mode 100755
index 000000000..d5eeb48ba
Binary files /dev/null and b/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/chrome/chromedriver.bin differ
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/explorer/BaseTest.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/explorer/BaseTest.java
new file mode 100644
index 000000000..df354f69b
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/explorer/BaseTest.java
@@ -0,0 +1,52 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2012 Terence Parr
+ *  Copyright (c) 2012 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.
+ */
+package org.antlr.v4.test.runtime.javascript.explorer;
+
+import org.antlr.v4.test.runtime.javascript.browser.BaseBrowserTest;
+import org.junit.After;
+import org.junit.Before;
+import org.openqa.selenium.ie.InternetExplorerDriver;
+
+public abstract class BaseTest extends BaseBrowserTest {
+
+	@Before
+	public void initWebDriver() {
+		System.setProperty("webdriver.ie.driver", "C:\\Program Files (x86)\\Selenium\\IEDriverServer.exe");
+		driver = new InternetExplorerDriver();
+	}
+
+	@After
+	public void closeWebDriver() {
+		if(driver!=null) {
+	      driver.quit();
+	    }
+	}
+
+}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/misc/Nullable.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/firefox/BaseTest.java
similarity index 79%
rename from runtime/Java/src/org/antlr/v4/runtime/misc/Nullable.java
rename to runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/firefox/BaseTest.java
index ae527a477..ab932da7b 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/misc/Nullable.java
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/firefox/BaseTest.java
@@ -27,11 +27,21 @@
  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
+package org.antlr.v4.test.runtime.javascript.firefox;
 
-package org.antlr.v4.runtime.misc;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+
+public abstract class BaseTest extends org.antlr.v4.test.runtime.javascript.browser.BaseBrowserTest {
+
+	@BeforeClass
+	public static void initWebDriver() {
+		driver = SharedWebDriver.init();
+	}
+
+	@AfterClass
+	public static void closeWebDriver() {
+		SharedWebDriver.close();
+	}
 
-@java.lang.annotation.Documented
-@java.lang.annotation.Retention(java.lang.annotation.RetentionPolicy.CLASS)
-@java.lang.annotation.Target({java.lang.annotation.ElementType.FIELD, java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.PARAMETER, java.lang.annotation.ElementType.LOCAL_VARIABLE})
-public @interface Nullable {
 }
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/firefox/SharedWebDriver.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/firefox/SharedWebDriver.java
new file mode 100644
index 000000000..00f6259cc
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/firefox/SharedWebDriver.java
@@ -0,0 +1,41 @@
+package org.antlr.v4.test.runtime.javascript.firefox;
+
+import org.openqa.selenium.WebDriver;
+import org.openqa.selenium.firefox.FirefoxDriver;
+
+import java.util.Timer;
+import java.util.TimerTask;
+
+public class SharedWebDriver {
+
+	static WebDriver driver;
+	static Timer timer;
+
+	public static WebDriver init() {
+		if(driver==null) {
+			driver = new FirefoxDriver();
+		} else if(timer!=null) {
+			timer.cancel();
+			timer = null;
+		}
+
+		return driver;
+	}
+
+	public static void close() {
+		if(driver!=null) {
+			if(timer!=null) {
+				timer.cancel();
+				timer = null;
+			}
+			timer = new Timer();
+			timer.schedule(new TimerTask() {
+				@Override public void run() {
+					driver.quit();
+					driver = null;
+				}
+			}, 2000); // close with delay to allow next Test to start
+		}
+	}
+
+}
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/node/BaseTest.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/node/BaseTest.java
new file mode 100644
index 000000000..59b68d14c
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/node/BaseTest.java
@@ -0,0 +1,1036 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2012 Terence Parr
+ *  Copyright (c) 2012 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.
+ */
+package org.antlr.v4.test.runtime.javascript.node;
+
+import org.antlr.v4.Tool;
+import org.antlr.v4.automata.ATNFactory;
+import org.antlr.v4.automata.ATNPrinter;
+import org.antlr.v4.automata.LexerATNFactory;
+import org.antlr.v4.automata.ParserATNFactory;
+import org.antlr.v4.codegen.CodeGenerator;
+import org.antlr.v4.runtime.ANTLRInputStream;
+import org.antlr.v4.runtime.CharStream;
+import org.antlr.v4.runtime.CommonToken;
+import org.antlr.v4.runtime.CommonTokenStream;
+import org.antlr.v4.runtime.IntStream;
+import org.antlr.v4.runtime.Lexer;
+import org.antlr.v4.runtime.RuleContext;
+import org.antlr.v4.runtime.Token;
+import org.antlr.v4.runtime.TokenSource;
+import org.antlr.v4.runtime.TokenStream;
+import org.antlr.v4.runtime.WritableToken;
+import org.antlr.v4.runtime.atn.ATN;
+import org.antlr.v4.runtime.atn.ATNDeserializer;
+import org.antlr.v4.runtime.atn.ATNSerializer;
+import org.antlr.v4.runtime.atn.ATNState;
+import org.antlr.v4.runtime.atn.LexerATNSimulator;
+import org.antlr.v4.runtime.dfa.DFA;
+import org.antlr.v4.runtime.misc.IntegerList;
+import org.antlr.v4.runtime.misc.Interval;
+import org.antlr.v4.semantics.SemanticPipeline;
+import org.antlr.v4.test.runtime.java.ErrorQueue;
+import org.antlr.v4.tool.ANTLRMessage;
+import org.antlr.v4.tool.DOTGenerator;
+import org.antlr.v4.tool.DefaultToolListener;
+import org.antlr.v4.tool.Grammar;
+import org.antlr.v4.tool.GrammarSemanticsMessage;
+import org.antlr.v4.tool.LexerGrammar;
+import org.antlr.v4.tool.Rule;
+import org.junit.Before;
+import org.junit.rules.TestRule;
+import org.junit.rules.TestWatcher;
+import org.junit.runner.Description;
+import org.stringtemplate.v4.ST;
+import org.stringtemplate.v4.STGroup;
+import org.stringtemplate.v4.STGroupString;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+public abstract class BaseTest {
+	// -J-Dorg.antlr.v4.test.BaseTest.level=FINE
+	// private static final Logger LOGGER =
+	// Logger.getLogger(BaseTest.class.getName());
+
+	public static final String newline = System.getProperty("line.separator");
+	public static final String pathSep = System.getProperty("path.separator");
+
+	public String tmpdir = null;
+
+	/**
+	 * If error during parser execution, store stderr here; can't return stdout
+	 * and stderr. This doesn't trap errors from running antlr.
+	 */
+	protected String stderrDuringParse;
+
+	@org.junit.Rule
+	public final TestRule testWatcher = new TestWatcher() {
+
+		@Override
+		protected void succeeded(Description description) {
+			// remove tmpdir if no error.
+			eraseTempDir();
+		}
+
+	};
+
+	@Before
+	public void setUp() throws Exception {
+		// new output dir for each test
+		String prop = System.getProperty("antlr-javascript-test-dir");
+		if (prop != null && prop.length() > 0)
+			tmpdir = prop;
+		else
+			tmpdir = new File(System.getProperty("java.io.tmpdir"), getClass()
+					.getSimpleName() + "-" + System.currentTimeMillis())
+					.getAbsolutePath();
+		File dir = new File(tmpdir);
+		if (dir.exists())
+			this.eraseFiles(dir);
+	}
+
+	protected org.antlr.v4.Tool newTool(String[] args) {
+		Tool tool = new Tool(args);
+		return tool;
+	}
+
+	protected Tool newTool() {
+		org.antlr.v4.Tool tool = new Tool(new String[] { "-o", tmpdir });
+		return tool;
+	}
+
+	protected ATN createATN(Grammar g, boolean useSerializer) {
+		if (g.atn == null) {
+			semanticProcess(g);
+			assertEquals(0, g.tool.getNumErrors());
+
+			ParserATNFactory f;
+			if (g.isLexer()) {
+				f = new LexerATNFactory((LexerGrammar) g);
+			} else {
+				f = new ParserATNFactory(g);
+			}
+
+			g.atn = f.createATN();
+			assertEquals(0, g.tool.getNumErrors());
+		}
+
+		ATN atn = g.atn;
+		if (useSerializer) {
+			char[] serialized = ATNSerializer.getSerializedAsChars(atn);
+			return new ATNDeserializer().deserialize(serialized);
+		}
+
+		return atn;
+	}
+
+	protected void semanticProcess(Grammar g) {
+		if (g.ast != null && !g.ast.hasErrors) {
+			System.out.println(g.ast.toStringTree());
+			Tool antlr = new Tool();
+			SemanticPipeline sem = new SemanticPipeline(g);
+			sem.process();
+			if (g.getImportedGrammars() != null) { // process imported grammars
+													// (if any)
+				for (Grammar imp : g.getImportedGrammars()) {
+					antlr.processNonCombinedGrammar(imp, false);
+				}
+			}
+		}
+	}
+
+	IntegerList getTypesFromString(Grammar g, String expecting) {
+		IntegerList expectingTokenTypes = new IntegerList();
+		if (expecting != null && !expecting.trim().isEmpty()) {
+			for (String tname : expecting.replace(" ", "").split(",")) {
+				int ttype = g.getTokenType(tname);
+				expectingTokenTypes.add(ttype);
+			}
+		}
+		return expectingTokenTypes;
+	}
+
+	public IntegerList getTokenTypesViaATN(String input,
+			LexerATNSimulator lexerATN) {
+		ANTLRInputStream in = new ANTLRInputStream(input);
+		IntegerList tokenTypes = new IntegerList();
+		int ttype;
+		do {
+			ttype = lexerATN.match(in, Lexer.DEFAULT_MODE);
+			tokenTypes.add(ttype);
+		} while (ttype != Token.EOF);
+		return tokenTypes;
+	}
+
+	public List<String> getTokenTypes(LexerGrammar lg, ATN atn, CharStream input) {
+		LexerATNSimulator interp = new LexerATNSimulator(atn,
+				new DFA[] { new DFA(
+						atn.modeToStartState.get(Lexer.DEFAULT_MODE)) }, null);
+		List<String> tokenTypes = new ArrayList<String>();
+		int ttype;
+		boolean hitEOF = false;
+		do {
+			if (hitEOF) {
+				tokenTypes.add("EOF");
+				break;
+			}
+			int t = input.LA(1);
+			ttype = interp.match(input, Lexer.DEFAULT_MODE);
+			if (ttype == Token.EOF) {
+				tokenTypes.add("EOF");
+			} else {
+				tokenTypes.add(lg.typeToTokenList.get(ttype));
+			}
+
+			if (t == IntStream.EOF) {
+				hitEOF = true;
+			}
+		} while (ttype != Token.EOF);
+		return tokenTypes;
+	}
+
+	/** Return true if all is ok, no errors */
+	protected ErrorQueue antlr(String fileName, String grammarFileName,
+			String grammarStr, boolean defaultListener, String... extraOptions) {
+		if(grammarStr!=null) {
+			System.out.println("dir " + tmpdir);
+			mkdir(tmpdir);
+			writeFile(tmpdir, fileName, grammarStr);
+		}
+		final List<String> options = new ArrayList<String>();
+		Collections.addAll(options, extraOptions);
+		options.add("-Dlanguage=JavaScript");
+		options.add("-o");
+		options.add(tmpdir);
+		options.add("-lib");
+		options.add(tmpdir);
+		options.add(new File(tmpdir, grammarFileName).toString());
+
+		final String[] optionsA = new String[options.size()];
+		options.toArray(optionsA);
+		Tool antlr = newTool(optionsA);
+		ErrorQueue equeue = new ErrorQueue(antlr);
+		antlr.addListener(equeue);
+		if (defaultListener) {
+			antlr.addListener(new DefaultToolListener(antlr));
+		}
+		antlr.processGrammarsOnCommandLine();
+
+		if (!defaultListener && !equeue.errors.isEmpty()) {
+			System.err.println("antlr reports errors from " + options);
+			for (int i = 0; i < equeue.errors.size(); i++) {
+				ANTLRMessage msg = equeue.errors.get(i);
+				System.err.println(msg);
+			}
+			System.out.println("!!!\ngrammar:");
+			System.out.println(grammarStr);
+			System.out.println("###");
+		}
+		if (!defaultListener && !equeue.warnings.isEmpty()) {
+			System.err.println("antlr reports warnings from " + options);
+			for (int i = 0; i < equeue.warnings.size(); i++) {
+				ANTLRMessage msg = equeue.warnings.get(i);
+				System.err.println(msg);
+			}
+		}
+
+		return equeue;
+	}
+
+	protected String execLexer(String grammarFileName, String grammarStr,
+			String lexerName, String input) {
+		return execLexer(grammarFileName, grammarStr, lexerName, input, false);
+	}
+
+	protected String execLexer(String grammarFileName, String grammarStr,
+			String lexerName, String input, boolean showDFA) {
+		boolean success = rawGenerateAndBuildRecognizer(grammarFileName,
+				grammarStr, null, lexerName, "-no-listener");
+		assertTrue(success);
+		writeFile(tmpdir, "input", input);
+		writeLexerTestFile(lexerName, showDFA);
+		String output = execModule("Test.js");
+		if (stderrDuringParse != null && stderrDuringParse.length() > 0) {
+			System.err.println(stderrDuringParse);
+		}
+		return output;
+	}
+
+	protected String execParser(String grammarFileName, String grammarStr,
+			String parserName, String lexerName, String listenerName,
+			String visitorName, String startRuleName, String input,
+			boolean debug) {
+		boolean success = rawGenerateAndBuildRecognizer(grammarFileName,
+				grammarStr, parserName, lexerName, "-visitor");
+		assertTrue(success);
+		writeFile(tmpdir, "input", input);
+		rawBuildRecognizerTestFile(parserName, lexerName, listenerName,
+				visitorName, startRuleName, debug);
+		return execRecognizer();
+	}
+
+	/** Return true if all is well */
+	protected boolean rawGenerateAndBuildRecognizer(String grammarFileName,
+			String grammarStr, String parserName, String lexerName,
+			String... extraOptions) {
+		return rawGenerateAndBuildRecognizer(grammarFileName, grammarStr,
+				parserName, lexerName, false, extraOptions);
+	}
+
+	/** Return true if all is well */
+	protected boolean rawGenerateAndBuildRecognizer(String grammarFileName,
+			String grammarStr, String parserName, String lexerName,
+			boolean defaultListener, String... extraOptions) {
+		ErrorQueue equeue = antlr(grammarFileName, grammarFileName, grammarStr,
+				defaultListener, extraOptions);
+		if (!equeue.errors.isEmpty()) {
+			return false;
+		}
+
+		List<String> files = new ArrayList<String>();
+		if (lexerName != null) {
+			files.add(lexerName + ".js");
+		}
+		if (parserName != null) {
+			files.add(parserName + ".js");
+			Set<String> optionsSet = new HashSet<String>(
+					Arrays.asList(extraOptions));
+			if (!optionsSet.contains("-no-listener")) {
+				files.add(grammarFileName.substring(0,
+						grammarFileName.lastIndexOf('.'))
+						+ "Listener.js");
+			}
+			if (optionsSet.contains("-visitor")) {
+				files.add(grammarFileName.substring(0,
+						grammarFileName.lastIndexOf('.'))
+						+ "Visitor.js");
+			}
+		}
+		return true; // allIsWell: no compile
+	}
+
+	protected void rawBuildRecognizerTestFile(String parserName,
+			String lexerName, String listenerName, String visitorName,
+			String parserStartRuleName, boolean debug) {
+		this.stderrDuringParse = null;
+		if (parserName == null) {
+			writeLexerTestFile(lexerName, false);
+		} else {
+			writeParserTestFile(parserName, lexerName, listenerName,
+					visitorName, parserStartRuleName, debug);
+		}
+	}
+
+	public String execRecognizer() {
+		return execModule("Test.js");
+	}
+
+	public String execModule(String fileName) {
+		String nodejsPath = locateNodeJS();
+		String runtimePath = locateRuntime();
+		String modulePath = new File(new File(tmpdir), fileName)
+				.getAbsolutePath();
+		String inputPath = new File(new File(tmpdir), "input")
+				.getAbsolutePath();
+		try {
+			ProcessBuilder builder = new ProcessBuilder(nodejsPath, modulePath,
+					inputPath);
+			builder.environment().put("NODE_PATH",
+					runtimePath + File.pathSeparator + tmpdir);
+			builder.directory(new File(tmpdir));
+			Process process = builder.start();
+			StreamVacuum stdoutVacuum = new StreamVacuum(
+					process.getInputStream());
+			StreamVacuum stderrVacuum = new StreamVacuum(
+					process.getErrorStream());
+			stdoutVacuum.start();
+			stderrVacuum.start();
+			process.waitFor();
+			stdoutVacuum.join();
+			stderrVacuum.join();
+			String output = stdoutVacuum.toString();
+			if (stderrVacuum.toString().length() > 0) {
+				this.stderrDuringParse = stderrVacuum.toString();
+				System.err.println("exec stderrVacuum: " + stderrVacuum);
+			}
+			return output;
+		}
+		catch (Exception e) {
+			System.err.println("can't exec recognizer");
+			e.printStackTrace(System.err);
+		}
+		return null;
+	}
+
+	private String locateTool(String tool) {
+		String[] roots = { "/usr/bin/", "/usr/local/bin/" };
+		for (String root : roots) {
+			if (new File(root + tool).exists()) {
+				return root + tool;
+			}
+		}
+		return null;
+	}
+
+	private String locateNodeJS() {
+		// typically /usr/local/bin/node
+		String propName = "antlr-javascript-nodejs";
+		String prop = System.getProperty(propName);
+		if (prop == null || prop.length() == 0) {
+			prop = locateTool("nodejs"); // seems to be nodejs on ubuntu
+		}
+		if ( prop==null ) {
+			prop = locateTool("node"); // seems to be node on mac
+		}
+		File file = new File(prop);
+		if (!file.exists()) {
+			throw new RuntimeException("Missing system property:" + propName);
+		}
+		return prop;
+	}
+
+	private String locateRuntime() {
+		final ClassLoader loader = Thread.currentThread().getContextClassLoader();
+		final URL runtimeSrc = loader.getResource("JavaScript/src");
+		if ( runtimeSrc==null ) {
+			throw new RuntimeException("Cannot find JavaScript runtime");
+		}
+		return runtimeSrc.getPath();
+	}
+
+	public void testErrors(String[] pairs, boolean printTree) {
+		for (int i = 0; i < pairs.length; i += 2) {
+			String input = pairs[i];
+			String expect = pairs[i + 1];
+
+			String[] lines = input.split("\n");
+			String fileName = getFilenameFromFirstLineOfGrammar(lines[0]);
+			ErrorQueue equeue = antlr(fileName, fileName, input, false);
+
+			String actual = equeue.toString(true);
+			actual = actual.replace(tmpdir + File.separator, "");
+			System.err.println(actual);
+			String msg = input;
+			msg = msg.replace("\n", "\\n");
+			msg = msg.replace("\r", "\\r");
+			msg = msg.replace("\t", "\\t");
+
+			assertEquals("error in: " + msg, expect, actual);
+		}
+	}
+
+	public String getFilenameFromFirstLineOfGrammar(String line) {
+		String fileName = "A" + Tool.GRAMMAR_EXTENSION;
+		int grIndex = line.lastIndexOf("grammar");
+		int semi = line.lastIndexOf(';');
+		if (grIndex >= 0 && semi >= 0) {
+			int space = line.indexOf(' ', grIndex);
+			fileName = line.substring(space + 1, semi) + Tool.GRAMMAR_EXTENSION;
+		}
+		if (fileName.length() == Tool.GRAMMAR_EXTENSION.length())
+			fileName = "A" + Tool.GRAMMAR_EXTENSION;
+		return fileName;
+	}
+
+	// void ambig(List<Message> msgs, int[] expectedAmbigAlts, String
+	// expectedAmbigInput)
+	// throws Exception
+	// {
+	// ambig(msgs, 0, expectedAmbigAlts, expectedAmbigInput);
+	// }
+
+	// void ambig(List<Message> msgs, int i, int[] expectedAmbigAlts, String
+	// expectedAmbigInput)
+	// throws Exception
+	// {
+	// List<Message> amsgs = getMessagesOfType(msgs, AmbiguityMessage.class);
+	// AmbiguityMessage a = (AmbiguityMessage)amsgs.get(i);
+	// if ( a==null ) assertNull(expectedAmbigAlts);
+	// else {
+	// assertEquals(a.conflictingAlts.toString(),
+	// Arrays.toString(expectedAmbigAlts));
+	// }
+	// assertEquals(expectedAmbigInput, a.input);
+	// }
+
+	// void unreachable(List<Message> msgs, int[] expectedUnreachableAlts)
+	// throws Exception
+	// {
+	// unreachable(msgs, 0, expectedUnreachableAlts);
+	// }
+
+	// void unreachable(List<Message> msgs, int i, int[]
+	// expectedUnreachableAlts)
+	// throws Exception
+	// {
+	// List<Message> amsgs = getMessagesOfType(msgs,
+	// UnreachableAltsMessage.class);
+	// UnreachableAltsMessage u = (UnreachableAltsMessage)amsgs.get(i);
+	// if ( u==null ) assertNull(expectedUnreachableAlts);
+	// else {
+	// assertEquals(u.conflictingAlts.toString(),
+	// Arrays.toString(expectedUnreachableAlts));
+	// }
+	// }
+
+	List<ANTLRMessage> getMessagesOfType(List<ANTLRMessage> msgs,
+			Class<? extends ANTLRMessage> c) {
+		List<ANTLRMessage> filtered = new ArrayList<ANTLRMessage>();
+		for (ANTLRMessage m : msgs) {
+			if (m.getClass() == c)
+				filtered.add(m);
+		}
+		return filtered;
+	}
+
+	void checkRuleATN(Grammar g, String ruleName, String expecting) {
+		ParserATNFactory f = new ParserATNFactory(g);
+		ATN atn = f.createATN();
+
+		DOTGenerator dot = new DOTGenerator(g);
+		System.out
+				.println(dot.getDOT(atn.ruleToStartState[g.getRule(ruleName).index]));
+
+		Rule r = g.getRule(ruleName);
+		ATNState startState = atn.ruleToStartState[r.index];
+		ATNPrinter serializer = new ATNPrinter(g, startState);
+		String result = serializer.asString();
+
+		// System.out.print(result);
+		assertEquals(expecting, result);
+	}
+
+	public void testActions(String templates, String actionName, String action,
+			String expected) throws org.antlr.runtime.RecognitionException {
+		int lp = templates.indexOf('(');
+		String name = templates.substring(0, lp);
+		STGroup group = new STGroupString(templates);
+		ST st = group.getInstanceOf(name);
+		st.add(actionName, action);
+		String grammar = st.render();
+		ErrorQueue equeue = new ErrorQueue();
+		Grammar g = new Grammar(grammar, equeue);
+		if (g.ast != null && !g.ast.hasErrors) {
+			SemanticPipeline sem = new SemanticPipeline(g);
+			sem.process();
+
+			ATNFactory factory = new ParserATNFactory(g);
+			if (g.isLexer())
+				factory = new LexerATNFactory((LexerGrammar) g);
+			g.atn = factory.createATN();
+
+			CodeGenerator gen = new CodeGenerator(g);
+			ST outputFileST = gen.generateParser();
+			String output = outputFileST.render();
+			// System.out.println(output);
+			String b = "#" + actionName + "#";
+			int start = output.indexOf(b);
+			String e = "#end-" + actionName + "#";
+			int end = output.indexOf(e);
+			String snippet = output.substring(start + b.length(), end);
+			assertEquals(expected, snippet);
+		}
+		if (equeue.size() > 0) {
+			System.err.println(equeue.toString());
+		}
+	}
+
+	public static class StreamVacuum implements Runnable {
+		StringBuilder buf = new StringBuilder();
+		BufferedReader in;
+		Thread sucker;
+
+		public StreamVacuum(InputStream in) {
+			this.in = new BufferedReader(new InputStreamReader(in));
+		}
+
+		public void start() {
+			sucker = new Thread(this);
+			sucker.start();
+		}
+
+		@Override
+		public void run() {
+			try {
+				String line = in.readLine();
+				while (line != null) {
+					buf.append(line);
+					buf.append('\n');
+					line = in.readLine();
+				}
+			} catch (IOException ioe) {
+				System.err.println("can't read output from process");
+			}
+		}
+
+		/** wait for the thread to finish */
+		public void join() throws InterruptedException {
+			sucker.join();
+		}
+
+		@Override
+		public String toString() {
+			return buf.toString();
+		}
+	}
+
+	protected void checkGrammarSemanticsError(ErrorQueue equeue,
+			GrammarSemanticsMessage expectedMessage) throws Exception {
+		ANTLRMessage foundMsg = null;
+		for (int i = 0; i < equeue.errors.size(); i++) {
+			ANTLRMessage m = equeue.errors.get(i);
+			if (m.getErrorType() == expectedMessage.getErrorType()) {
+				foundMsg = m;
+			}
+		}
+		assertNotNull("no error; " + expectedMessage.getErrorType()
+				+ " expected", foundMsg);
+		assertTrue("error is not a GrammarSemanticsMessage",
+				foundMsg instanceof GrammarSemanticsMessage);
+		assertEquals(Arrays.toString(expectedMessage.getArgs()),
+				Arrays.toString(foundMsg.getArgs()));
+		if (equeue.size() != 1) {
+			System.err.println(equeue);
+		}
+	}
+
+	protected void checkGrammarSemanticsWarning(ErrorQueue equeue,
+			GrammarSemanticsMessage expectedMessage) throws Exception {
+		ANTLRMessage foundMsg = null;
+		for (int i = 0; i < equeue.warnings.size(); i++) {
+			ANTLRMessage m = equeue.warnings.get(i);
+			if (m.getErrorType() == expectedMessage.getErrorType()) {
+				foundMsg = m;
+			}
+		}
+		assertNotNull("no error; " + expectedMessage.getErrorType()
+				+ " expected", foundMsg);
+		assertTrue("error is not a GrammarSemanticsMessage",
+				foundMsg instanceof GrammarSemanticsMessage);
+		assertEquals(Arrays.toString(expectedMessage.getArgs()),
+				Arrays.toString(foundMsg.getArgs()));
+		if (equeue.size() != 1) {
+			System.err.println(equeue);
+		}
+	}
+
+	protected void checkError(ErrorQueue equeue, ANTLRMessage expectedMessage)
+			throws Exception {
+		// System.out.println("errors="+equeue);
+		ANTLRMessage foundMsg = null;
+		for (int i = 0; i < equeue.errors.size(); i++) {
+			ANTLRMessage m = equeue.errors.get(i);
+			if (m.getErrorType() == expectedMessage.getErrorType()) {
+				foundMsg = m;
+			}
+		}
+		assertTrue("no error; " + expectedMessage.getErrorType() + " expected",
+				!equeue.errors.isEmpty());
+		assertTrue("too many errors; " + equeue.errors,
+				equeue.errors.size() <= 1);
+		assertNotNull(
+				"couldn't find expected error: "
+						+ expectedMessage.getErrorType(), foundMsg);
+		/*
+		 * assertTrue("error is not a GrammarSemanticsMessage", foundMsg
+		 * instanceof GrammarSemanticsMessage);
+		 */
+		assertArrayEquals(expectedMessage.getArgs(), foundMsg.getArgs());
+	}
+
+	public static class FilteringTokenStream extends CommonTokenStream {
+		public FilteringTokenStream(TokenSource src) {
+			super(src);
+		}
+
+		Set<Integer> hide = new HashSet<Integer>();
+
+		@Override
+		protected boolean sync(int i) {
+			if (!super.sync(i)) {
+				return false;
+			}
+
+			Token t = get(i);
+			if (hide.contains(t.getType())) {
+				((WritableToken) t).setChannel(Token.HIDDEN_CHANNEL);
+			}
+
+			return true;
+		}
+
+		public void setTokenTypeChannel(int ttype, int channel) {
+			hide.add(ttype);
+		}
+	}
+
+	public static void writeFile(String dir, String fileName, String content) {
+		try {
+			File f = new File(dir, fileName);
+			FileWriter w = new FileWriter(f);
+			BufferedWriter bw = new BufferedWriter(w);
+			bw.write(content);
+			bw.close();
+			w.close();
+		} catch (IOException ioe) {
+			System.err.println("can't write file");
+			ioe.printStackTrace(System.err);
+		}
+	}
+
+	public static void writeFile(String dir, String fileName, InputStream content) {
+		try {
+			File f = new File(dir, fileName);
+			OutputStream output = new FileOutputStream(f);
+			while(content.available()>0) {
+				int b = content.read();
+				output.write(b);
+			}
+			output.close();
+		} catch (IOException ioe) {
+			System.err.println("can't write file");
+			ioe.printStackTrace(System.err);
+		}
+	}
+
+	protected void mkdir(String dir) {
+		File f = new File(dir);
+		f.mkdirs();
+	}
+
+	protected void writeParserTestFile(String parserName, String lexerName,
+			String listenerName, String visitorName,
+			String parserStartRuleName, boolean debug) {
+		ST outputFileST = new ST(
+				"var antlr4 = require('antlr4');\n"
+						+ "var <lexerName> = require('./<lexerName>');\n"
+						+ "var <parserName> = require('./<parserName>');\n"
+						+ "var <listenerName> = require('./<listenerName>').<listenerName>;\n"
+						+ "var <visitorName> = require('./<visitorName>').<visitorName>;\n"
+						+ "\n"
+						+ "function TreeShapeListener() {\n"
+						+ "	antlr4.tree.ParseTreeListener.call(this);\n"
+						+ "	return this;\n"
+						+ "}\n"
+						+ "\n"
+						+ "TreeShapeListener.prototype = Object.create(antlr4.tree.ParseTreeListener.prototype);\n"
+						+ "TreeShapeListener.prototype.constructor = TreeShapeListener;\n"
+						+ "\n"
+						+ "TreeShapeListener.prototype.enterEveryRule = function(ctx) {\n"
+						+ "	for(var i=0;i\\<ctx.getChildCount; i++) {\n"
+						+ "		var child = ctx.getChild(i);\n"
+						+ "       var parent = child.parentCtx;\n"
+						+ "       if(parent.getRuleContext() !== ctx || !(parent instanceof antlr4.tree.RuleNode)) {\n"
+						+ "           throw \"Invalid parse tree shape detected.\";\n"
+						+ "		}\n"
+						+ "	}\n"
+						+ "};\n"
+						+ "\n"
+						+ "function main(argv) {\n"
+						+ "    var input = new antlr4.FileStream(argv[2]);\n"
+						+ "    var lexer = new <lexerName>.<lexerName>(input);\n"
+						+ "    var stream = new antlr4.CommonTokenStream(lexer);\n"
+						+ "<createParser>"
+						+ "    parser.buildParseTrees = true;\n"
+						+ "	 printer = function() {\n"
+						+ "		this.println = function(s) { console.log(s); }\n"
+						+ "		this.print = function(s) { process.stdout.write(s); }\n"
+						+ "		return this;\n"
+						+ "	 };\n"
+						+ "    parser.printer = new printer();\n"
+						+ "    var tree = parser.<parserStartRuleName>();\n"
+						+ "    antlr4.tree.ParseTreeWalker.DEFAULT.walk(new TreeShapeListener(), tree);\n"
+						+ "}\n" + "\n" + "main(process.argv);\n" + "\n");
+		ST createParserST = new ST(
+				"	var parser = new <parserName>.<parserName>(stream);\n");
+		if (debug) {
+			createParserST = new ST(
+					"	var parser = new <parserName>.<parserName>(stream);\n"
+							+ "	parser.addErrorListener(new antlr4.error.DiagnosticErrorListener());\n");
+		}
+		outputFileST.add("createParser", createParserST);
+		outputFileST.add("parserName", parserName);
+		outputFileST.add("lexerName", lexerName);
+		outputFileST.add("listenerName", listenerName);
+		outputFileST.add("visitorName", visitorName);
+		outputFileST.add("parserStartRuleName", parserStartRuleName);
+		writeFile(tmpdir, "Test.js", outputFileST.render());
+	}
+
+	protected void writeLexerTestFile(String lexerName, boolean showDFA) {
+		ST outputFileST = new ST(
+				"var antlr4 = require('antlr4');\n"
+						+ "var <lexerName> = require('./<lexerName>');\n"
+						+ "\n"
+						+ "function main(argv) {\n"
+						+ "    var input = new antlr4.FileStream(argv[2]);\n"
+						+ "    var lexer = new <lexerName>.<lexerName>(input);\n"
+						+ "    var stream = new antlr4.CommonTokenStream(lexer);\n"
+						+ "    stream.fill();\n"
+						+ "    for(var i=0; i\\<stream.tokens.length; i++) {\n"
+						+ "		console.log(stream.tokens[i].toString());\n"
+						+ "    }\n"
+						+ (showDFA ? "    process.stdout.write(lexer._interp.decisionToDFA[antlr4.Lexer.DEFAULT_MODE].toLexerString());\n"
+								: "") + "}\n" + "\n" + "main(process.argv);\n"
+						+ "\n");
+		outputFileST.add("lexerName", lexerName);
+		writeFile(tmpdir, "Test.js", outputFileST.render());
+	}
+
+	public void writeRecognizer(String parserName, String lexerName,
+			String listenerName, String visitorName,
+			String parserStartRuleName, boolean debug) {
+		if (parserName == null) {
+			writeLexerTestFile(lexerName, debug);
+		} else {
+			writeParserTestFile(parserName, lexerName, listenerName,
+					visitorName, parserStartRuleName, debug);
+		}
+	}
+
+	protected void eraseFiles(final String filesEndingWith) {
+		File tmpdirF = new File(tmpdir);
+		String[] files = tmpdirF.list();
+		for (int i = 0; files != null && i < files.length; i++) {
+			if (files[i].endsWith(filesEndingWith)) {
+				new File(tmpdir + "/" + files[i]).delete();
+			}
+		}
+	}
+
+	protected void eraseFiles(File dir) {
+		String[] files = dir.list();
+		for (int i = 0; files != null && i < files.length; i++) {
+			new File(dir, files[i]).delete();
+		}
+	}
+
+	protected void eraseTempDir() {
+		boolean doErase = true;
+		String propName = "antlr-javascript-erase-test-dir";
+		String prop = System.getProperty(propName);
+		if (prop != null && prop.length() > 0)
+			doErase = Boolean.getBoolean(prop);
+		if (doErase) {
+			File tmpdirF = new File(tmpdir);
+			if (tmpdirF.exists()) {
+				eraseFiles(tmpdirF);
+				tmpdirF.delete();
+			}
+		}
+	}
+
+	public String getFirstLineOfException() {
+		if (this.stderrDuringParse == null) {
+			return null;
+		}
+		String[] lines = this.stderrDuringParse.split("\n");
+		String prefix = "Exception in thread \"main\" ";
+		return lines[0].substring(prefix.length(), lines[0].length());
+	}
+
+	/**
+	 * When looking at a result set that consists of a Map/HashTable we cannot
+	 * rely on the output order, as the hashing algorithm or other aspects of
+	 * the implementation may be different on differnt JDKs or platforms. Hence
+	 * we take the Map, convert the keys to a List, sort them and Stringify the
+	 * Map, which is a bit of a hack, but guarantees that we get the same order
+	 * on all systems. We assume that the keys are strings.
+	 *
+	 * @param m
+	 *            The Map that contains keys we wish to return in sorted order
+	 * @return A string that represents all the keys in sorted order.
+	 */
+	public <K, V> String sortMapToString(Map<K, V> m) {
+		// Pass in crap, and get nothing back
+		//
+		if (m == null) {
+			return null;
+		}
+
+		System.out.println("Map toString looks like: " + m.toString());
+
+		// Sort the keys in the Map
+		//
+		TreeMap<K, V> nset = new TreeMap<K, V>(m);
+
+		System.out.println("Tree map looks like: " + nset.toString());
+		return nset.toString();
+	}
+
+	public List<String> realElements(List<String> elements) {
+		return elements.subList(Token.MIN_USER_TOKEN_TYPE, elements.size());
+	}
+
+	public void assertNotNullOrEmpty(String message, String text) {
+		assertNotNull(message, text);
+		assertFalse(message, text.isEmpty());
+	}
+
+	public void assertNotNullOrEmpty(String text) {
+		assertNotNull(text);
+		assertFalse(text.isEmpty());
+	}
+
+	public static class IntTokenStream implements TokenStream {
+		IntegerList types;
+		int p = 0;
+
+		public IntTokenStream(IntegerList types) {
+			this.types = types;
+		}
+
+		@Override
+		public void consume() {
+			p++;
+		}
+
+		@Override
+		public int LA(int i) {
+			return LT(i).getType();
+		}
+
+		@Override
+		public int mark() {
+			return index();
+		}
+
+		@Override
+		public int index() {
+			return p;
+		}
+
+		@Override
+		public void release(int marker) {
+			seek(marker);
+		}
+
+		@Override
+		public void seek(int index) {
+			p = index;
+		}
+
+		@Override
+		public int size() {
+			return types.size();
+		}
+
+		@Override
+		public String getSourceName() {
+			return null;
+		}
+
+		@Override
+		public Token LT(int i) {
+			CommonToken t;
+			int rawIndex = p + i - 1;
+			if (rawIndex >= types.size())
+				t = new CommonToken(Token.EOF);
+			else
+				t = new CommonToken(types.get(rawIndex));
+			t.setTokenIndex(rawIndex);
+			return t;
+		}
+
+		@Override
+		public Token get(int i) {
+			return new org.antlr.v4.runtime.CommonToken(types.get(i));
+		}
+
+		@Override
+		public TokenSource getTokenSource() {
+			return null;
+		}
+
+		@Override
+		public String getText() {
+			throw new UnsupportedOperationException("can't give strings");
+		}
+
+		@Override
+		public String getText(Interval interval) {
+			throw new UnsupportedOperationException("can't give strings");
+		}
+
+		@Override
+		public String getText(RuleContext ctx) {
+			throw new UnsupportedOperationException("can't give strings");
+		}
+
+		@Override
+		public String getText(Token start, Token stop) {
+			throw new UnsupportedOperationException("can't give strings");
+		}
+	}
+
+	/** Sort a list */
+	public <T extends Comparable<? super T>> List<T> sort(List<T> data) {
+		List<T> dup = new ArrayList<T>();
+		dup.addAll(data);
+		Collections.sort(dup);
+		return dup;
+	}
+
+	/** Return map sorted by key */
+	public <K extends Comparable<? super K>, V> LinkedHashMap<K, V> sort(
+			Map<K, V> data) {
+		LinkedHashMap<K, V> dup = new LinkedHashMap<K, V>();
+		List<K> keys = new ArrayList<K>();
+		keys.addAll(data.keySet());
+		Collections.sort(keys);
+		for (K k : keys) {
+			dup.put(k, data.get(k));
+		}
+		return dup;
+	}
+}
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/node/TestCompositeLexers.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/node/TestCompositeLexers.java
new file mode 100644
index 000000000..dad1ac891
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/node/TestCompositeLexers.java
@@ -0,0 +1,67 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.javascript.node;
+
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+@SuppressWarnings("unused")
+public class TestCompositeLexers extends BaseTest {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLexerDelegatorInvokesDelegateRule() throws Exception {
+		mkdir(tmpdir);
+		String slave_S =
+			"lexer grammar S;\n" +
+			"A : 'a' {console.log(\"S.A\");};\n" +
+			"C : 'c' ;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+
+		StringBuilder grammarBuilder = new StringBuilder(61);
+		grammarBuilder.append("lexer grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("B : 'b';\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="abc";
+		String found = execLexer("M.g4", grammar, "M", input, false);
+		assertEquals(
+			"S.A\n" +
+			"[@0,0:0='a',<3>,1:0]\n" +
+			"[@1,1:1='b',<1>,1:1]\n" +
+			"[@2,2:2='c',<4>,1:2]\n" +
+			"[@3,3:2='<EOF>',<-1>,1:3]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLexerDelegatorRuleOverridesDelegate() throws Exception {
+		mkdir(tmpdir);
+		String slave_S =
+			"lexer grammar S;\n" +
+			"A : 'a' {console.log(\"S.A\");} ;\n" +
+			"B : 'b' {console.log(\"S.B\");} ;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+
+		StringBuilder grammarBuilder = new StringBuilder(86);
+		grammarBuilder.append("lexer grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("A : 'a' B {console.log(\"M.A\");} ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="ab";
+		String found = execLexer("M.g4", grammar, "M", input, false);
+		assertEquals(
+			"M.A\n" +
+			"[@0,0:1='ab',<1>,1:0]\n" +
+			"[@1,2:1='<EOF>',<-1>,1:2]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+}
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/node/TestCompositeParsers.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/node/TestCompositeParsers.java
new file mode 100644
index 000000000..8690954e3
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/node/TestCompositeParsers.java
@@ -0,0 +1,427 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.javascript.node;
+
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+import org.antlr.v4.test.runtime.java.ErrorQueue;
+import org.antlr.v4.tool.Grammar;
+
+@SuppressWarnings("unused")
+public class TestCompositeParsers extends BaseTest {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testBringInLiteralsFromDelegate() throws Exception {
+		mkdir(tmpdir);
+		String slave_S =
+			"parser grammar S;\n" +
+			"a : '=' 'a' {process.stdout.write(\"S.a\");};";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(54);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("s : a ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="=a";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer",
+		                          "MListener", "MVisitor",
+		                          "s", input, false);
+		assertEquals("S.a\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCombinedImportsCombined() throws Exception {
+		mkdir(tmpdir);
+		String slave_S =
+			"parser grammar S;\n" +
+			"tokens { A, B, C }\n" +
+			"x : 'x' INT {console.log(\"S.x\");};\n" +
+			"INT : '0'..'9'+ ;\n" +
+			"WS : (' '|'\\n') -> skip ;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(31);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("s : x INT;");
+		String grammar = grammarBuilder.toString();
+		String input ="x 34 9";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer",
+		                          "MListener", "MVisitor",
+		                          "s", input, false);
+		assertEquals("S.x\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDelegatesSeeSameTokenType() throws Exception {
+		mkdir(tmpdir);
+		String slave_S =
+			"parser grammar S;\n" +
+			"tokens { A, B, C }\n" +
+			"x : A {console.log(\"S.x\");};";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		String slave_T =
+			"parser grammar T;\n" +
+			"tokens { C, B, A } // reverse order\n" +
+			"y : A {console.log(\"T.y\");};";
+		writeFile(tmpdir, "T.g4", slave_T);
+
+		StringBuilder grammarBuilder = new StringBuilder(598);
+		grammarBuilder.append("// The lexer will create rules to match letters a, b, c.\n");
+		grammarBuilder.append("// The associated token types A, B, C must have the same value\n");
+		grammarBuilder.append("// and all import'd parsers.  Since ANTLR regenerates all imports\n");
+		grammarBuilder.append("// for use with the delegator M, it can generate the same token type\n");
+		grammarBuilder.append("// mapping in each parser:\n");
+		grammarBuilder.append("// public static final int C=6;\n");
+		grammarBuilder.append("// public static final int EOF=-1;\n");
+		grammarBuilder.append("// public static final int B=5;\n");
+		grammarBuilder.append("// public static final int WS=7;\n");
+		grammarBuilder.append("// public static final int A=4;\n");
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S,T;\n");
+		grammarBuilder.append("s : x y ; // matches AA, which should be 'aa'\n");
+		grammarBuilder.append("B : 'b' ; // another order: B, A, C\n");
+		grammarBuilder.append("A : 'a' ; \n");
+		grammarBuilder.append("C : 'c' ; \n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="aa";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer",
+		                          "MListener", "MVisitor",
+		                          "s", input, false);
+		assertEquals(
+			"S.x\n" +
+			"T.y\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDelegatorAccessesDelegateMembers() throws Exception {
+		mkdir(tmpdir);
+		String slave_S =
+			"parser grammar S;\n" +
+			"@parser::members {\n" +
+			"this.foo = function() {console.log('foo');};\n" +
+			"}\n" +
+			"a : B;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(127);
+		grammarBuilder.append("grammar M; // uses no rules from the import\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("s : 'b' {this.foo();} ; // gS is import pointer\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="b";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer",
+		                          "MListener", "MVisitor",
+		                          "s", input, false);
+		assertEquals("foo\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDelegatorInvokesDelegateRule() throws Exception {
+		mkdir(tmpdir);
+		String slave_S =
+			"parser grammar S;\n" +
+			"a : B {console.log(\"S.a\");};";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(104);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("s : a ;\n");
+		grammarBuilder.append("B : 'b' ; // defines B from inherited token space\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="b";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer",
+		                          "MListener", "MVisitor",
+		                          "s", input, false);
+		assertEquals("S.a\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDelegatorInvokesDelegateRuleWithArgs() throws Exception {
+		mkdir(tmpdir);
+		String slave_S =
+			"parser grammar S;\n" +
+			"a[int x] returns [int y] : B {process.stdout.write(\"S.a\");} {$y=1000;} ;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(138);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("s : label=a[3] {console.log($label.y);} ;\n");
+		grammarBuilder.append("B : 'b' ; // defines B from inherited token space\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="b";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer",
+		                          "MListener", "MVisitor",
+		                          "s", input, false);
+		assertEquals("S.a1000\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDelegatorInvokesDelegateRuleWithReturnStruct() throws Exception {
+		mkdir(tmpdir);
+		String slave_S =
+			"parser grammar S;\n" +
+			"a : B {process.stdout.write(\"S.a\");} ;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(137);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("s : a {process.stdout.write($a.text);} ;\n");
+		grammarBuilder.append("B : 'b' ; // defines B from inherited token space\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="b";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer",
+		                          "MListener", "MVisitor",
+		                          "s", input, false);
+		assertEquals("S.ab\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDelegatorInvokesFirstVersionOfDelegateRule() throws Exception {
+		mkdir(tmpdir);
+		String slave_S =
+			"parser grammar S;\n" +
+			"a : b {console.log(\"S.a\");};\n" +
+			"b : B;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		String slave_T =
+			"parser grammar T;\n" +
+			"a : B {console.log(\"T.a\");};";
+		writeFile(tmpdir, "T.g4", slave_T);
+
+		StringBuilder grammarBuilder = new StringBuilder(106);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S,T;\n");
+		grammarBuilder.append("s : a ;\n");
+		grammarBuilder.append("B : 'b' ; // defines B from inherited token space\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="b";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer",
+		                          "MListener", "MVisitor",
+		                          "s", input, false);
+		assertEquals("S.a\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDelegatorRuleOverridesDelegate() throws Exception {
+		mkdir(tmpdir);
+		String slave_S =
+			"parser grammar S;\n" +
+			"a : b {process.stdout.write(\"S.a\");};\n" +
+			"b : B ;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(59);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("b : 'b'|'c';\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="c";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer",
+		                          "MListener", "MVisitor",
+		                          "a", input, false);
+		assertEquals("S.a\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDelegatorRuleOverridesDelegates() throws Exception {
+		mkdir(tmpdir);
+		String slave_S =
+			"parser grammar S;\n" +
+			"a : b {console.log(\"S.a\");};\n" +
+			"b : 'b' ;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		String slave_T =
+			"parser grammar T;\n" +
+			"tokens { A }\n" +
+			"b : 'b' {console.log(\"T.b\");};";
+		writeFile(tmpdir, "T.g4", slave_T);
+
+		StringBuilder grammarBuilder = new StringBuilder(88);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S, T;\n");
+		grammarBuilder.append("b : 'b'|'c' {console.log(\"M.b\");}|B|A;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="c";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer",
+		                          "MListener", "MVisitor",
+		                          "a", input, false);
+		assertEquals(
+			"M.b\n" +
+			"S.a\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDelegatorRuleOverridesLookaheadInDelegate() throws Exception {
+		mkdir(tmpdir);
+		String slave_S =
+			"parser grammar S;\n" +
+			"type_ : 'int' ;\n" +
+			"decl : type_ ID ';'\n" +
+			"	| type_ ID init ';' {process.stdout.write(\"JavaDecl: \" + $text);};\n" +
+			"init : '=' INT;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(121);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("prog : decl ;\n");
+		grammarBuilder.append("type_ : 'int' | 'float' ;\n");
+		grammarBuilder.append("ID  : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+		String input ="float x = 3;";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer",
+		                          "MListener", "MVisitor",
+		                          "prog", input, false);
+		assertEquals("JavaDecl: floatx=3;\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testImportLexerWithOnlyFragmentRules() throws Exception {
+		mkdir(tmpdir);
+		String slave_Unicode =
+			"lexer grammar Unicode;\n" +
+			"\n" +
+			"fragment\n" +
+			"UNICODE_CLASS_Zs    : '\\u0020' | '\\u00A0' | '\\u1680' | '\\u180E'\n" +
+			"                    | '\\u2000'..'\\u200A'\n" +
+			"                    | '\\u202F' | '\\u205F' | '\\u3000'\n" +
+			"                    ;\n";
+		writeFile(tmpdir, "Unicode.g4", slave_Unicode);
+
+		StringBuilder grammarBuilder = new StringBuilder(91);
+		grammarBuilder.append("grammar Test;\n");
+		grammarBuilder.append("import Unicode;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("program : 'test' 'test';\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("WS : (UNICODE_CLASS_Zs)+ -> skip;\n");
+		String grammar = grammarBuilder.toString();
+		String input ="test test";
+		String found = execParser("Test.g4", grammar, "TestParser", "TestLexer",
+		                          "TestListener", "TestVisitor",
+		                          "program", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testImportedGrammarWithEmptyOptions() throws Exception {
+		mkdir(tmpdir);
+		String slave_S =
+			"parser grammar S;\n" +
+			"options {}\n" +
+			"a : B ;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(64);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("s : a ;\n");
+		grammarBuilder.append("B : 'b' ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="b";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer",
+		                          "MListener", "MVisitor",
+		                          "s", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testImportedRuleWithAction() throws Exception {
+		mkdir(tmpdir);
+		String slave_S =
+			"parser grammar S;\n" +
+			"a @after {this.x = 0;} : B;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(62);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("s : a;\n");
+		grammarBuilder.append("B : 'b';\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="b";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer",
+		                          "MListener", "MVisitor",
+		                          "s", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testKeywordVSIDOrder() throws Exception {
+		mkdir(tmpdir);
+		String slave_S =
+			"lexer grammar S;\n" +
+			"ID : 'a'..'z'+;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(115);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("a : A {console.log(\"M.a: \" + $A);};\n");
+		grammarBuilder.append("A : 'abc' {console.log(\"M.A\");};\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="abc";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer",
+		                          "MListener", "MVisitor",
+		                          "a", input, false);
+		assertEquals(
+			"M.A\n" +
+			"M.a: [@0,0:2='abc',<1>,1:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+}
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/node/TestFullContextParsing.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/node/TestFullContextParsing.java
new file mode 100644
index 000000000..62039ccd7
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/node/TestFullContextParsing.java
@@ -0,0 +1,462 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.javascript.node;
+
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+@SuppressWarnings("unused")
+public class TestFullContextParsing extends BaseTest {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAmbigYieldsCtxSensitiveDFA() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(101);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {this.dumpDFA();}\n");
+		grammarBuilder.append("	: ID | ID {} ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="abc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, true);
+		assertEquals(
+			"Decision 0:\n" +
+			"s0-ID->:s1^=>1\n", found);
+
+		assertEquals("line 1:0 reportAttemptingFullContext d=0 (s), input='abc'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAmbiguityNoLoop() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(224);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("prog\n");
+		grammarBuilder.append("@init {this._interp.predictionMode = antlr4.atn.PredictionMode.LL_EXACT_AMBIG_DETECTION;}\n");
+		grammarBuilder.append("	: expr expr {console.log(\"alt 1\");}\n");
+		grammarBuilder.append("	| expr\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("expr: '@'\n");
+		grammarBuilder.append("	| ID '@'\n");
+		grammarBuilder.append("	| ID\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("ID  : [a-z]+ ;\n");
+		grammarBuilder.append("WS  : [ \\r\\n\\t]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a@";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "prog", input, true);
+		assertEquals("alt 1\n", found);
+
+		assertEquals(
+			"line 1:2 reportAttemptingFullContext d=0 (prog), input='a@'\n" +
+			"line 1:2 reportAmbiguity d=0 (prog): ambigAlts={1, 2}, input='a@'\n" +
+			"line 1:2 reportAttemptingFullContext d=1 (expr), input='a@'\n" +
+			"line 1:2 reportContextSensitivity d=1 (expr), input='a@'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCtxSensitiveDFATwoDiffInput() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(165);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {this.dumpDFA();}\n");
+		grammarBuilder.append("  : ('$' a | '@' b)+ ;\n");
+		grammarBuilder.append("a : e ID ;\n");
+		grammarBuilder.append("b : e INT ID ;\n");
+		grammarBuilder.append("e : INT | ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="$ 34 abc @ 34 abc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, true);
+		assertEquals(
+			"Decision 2:\n" +
+			"s0-INT->s1\n" +
+			"s1-ID->:s2^=>1\n", found);
+
+		assertEquals(
+			"line 1:5 reportAttemptingFullContext d=2 (e), input='34abc'\n" +
+			"line 1:2 reportContextSensitivity d=2 (e), input='34'\n" +
+			"line 1:14 reportAttemptingFullContext d=2 (e), input='34abc'\n" +
+			"line 1:14 reportContextSensitivity d=2 (e), input='34abc'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCtxSensitiveDFA_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(162);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {this.dumpDFA();}\n");
+		grammarBuilder.append("  : '$' a | '@' b ;\n");
+		grammarBuilder.append("a : e ID ;\n");
+		grammarBuilder.append("b : e INT ID ;\n");
+		grammarBuilder.append("e : INT | ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="$ 34 abc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, true);
+		assertEquals(
+			"Decision 1:\n" +
+			"s0-INT->s1\n" +
+			"s1-ID->:s2^=>1\n", found);
+
+		assertEquals(
+			"line 1:5 reportAttemptingFullContext d=1 (e), input='34abc'\n" +
+			"line 1:2 reportContextSensitivity d=1 (e), input='34'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCtxSensitiveDFA_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(162);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {this.dumpDFA();}\n");
+		grammarBuilder.append("  : '$' a | '@' b ;\n");
+		grammarBuilder.append("a : e ID ;\n");
+		grammarBuilder.append("b : e INT ID ;\n");
+		grammarBuilder.append("e : INT | ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="@ 34 abc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, true);
+		assertEquals(
+			"Decision 1:\n" +
+			"s0-INT->s1\n" +
+			"s1-ID->:s2^=>1\n", found);
+
+		assertEquals(
+			"line 1:5 reportAttemptingFullContext d=1 (e), input='34abc'\n" +
+			"line 1:5 reportContextSensitivity d=1 (e), input='34abc'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExprAmbiguity_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(304);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {this._interp.predictionMode = antlr4.atn.PredictionMode.LL_EXACT_AMBIG_DETECTION;}\n");
+		grammarBuilder.append(":   expr[0] {console.log($expr.ctx.toStringTree(null, this));};\n");
+		grammarBuilder.append("	expr[int _p]\n");
+		grammarBuilder.append("		: ID \n");
+		grammarBuilder.append("		( \n");
+		grammarBuilder.append("			{5 >= $_p}? '*' expr[6]\n");
+		grammarBuilder.append("			| {4 >= $_p}? '+' expr[5]\n");
+		grammarBuilder.append("		)*\n");
+		grammarBuilder.append("		;\n");
+		grammarBuilder.append("ID  : [a-zA-Z]+ ;\n");
+		grammarBuilder.append("WS  : [ \\r\\n\\t]+ -> skip ;\n");
+		String grammar = grammarBuilder.toString();
+		String input ="a+b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, true);
+		assertEquals("(expr a + (expr b))\n", found);
+
+		assertEquals(
+			"line 1:1 reportAttemptingFullContext d=1 (expr), input='+'\n" +
+			"line 1:2 reportContextSensitivity d=1 (expr), input='+b'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExprAmbiguity_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(304);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {this._interp.predictionMode = antlr4.atn.PredictionMode.LL_EXACT_AMBIG_DETECTION;}\n");
+		grammarBuilder.append(":   expr[0] {console.log($expr.ctx.toStringTree(null, this));};\n");
+		grammarBuilder.append("	expr[int _p]\n");
+		grammarBuilder.append("		: ID \n");
+		grammarBuilder.append("		( \n");
+		grammarBuilder.append("			{5 >= $_p}? '*' expr[6]\n");
+		grammarBuilder.append("			| {4 >= $_p}? '+' expr[5]\n");
+		grammarBuilder.append("		)*\n");
+		grammarBuilder.append("		;\n");
+		grammarBuilder.append("ID  : [a-zA-Z]+ ;\n");
+		grammarBuilder.append("WS  : [ \\r\\n\\t]+ -> skip ;\n");
+		String grammar = grammarBuilder.toString();
+		String input ="a+b*c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, true);
+		assertEquals("(expr a + (expr b * (expr c)))\n", found);
+
+		assertEquals(
+			"line 1:1 reportAttemptingFullContext d=1 (expr), input='+'\n" +
+			"line 1:2 reportContextSensitivity d=1 (expr), input='+b'\n" +
+			"line 1:3 reportAttemptingFullContext d=1 (expr), input='*'\n" +
+			"line 1:5 reportAmbiguity d=1 (expr): ambigAlts={1, 2}, input='*c'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testFullContextIF_THEN_ELSEParse_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(252);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s \n");
+		grammarBuilder.append("@init {this._interp.predictionMode = antlr4.atn.PredictionMode.LL_EXACT_AMBIG_DETECTION;}\n");
+		grammarBuilder.append("@after {this.dumpDFA();}\n");
+		grammarBuilder.append("	: '{' stat* '}' ;\n");
+		grammarBuilder.append("stat: 'if' ID 'then' stat ('else' ID)?\n");
+		grammarBuilder.append("		| 'return'\n");
+		grammarBuilder.append("		;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="{ if x then return }";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, true);
+		assertEquals(
+			"Decision 1:\n" +
+			"s0-'}'->:s1=>2\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testFullContextIF_THEN_ELSEParse_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(252);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s \n");
+		grammarBuilder.append("@init {this._interp.predictionMode = antlr4.atn.PredictionMode.LL_EXACT_AMBIG_DETECTION;}\n");
+		grammarBuilder.append("@after {this.dumpDFA();}\n");
+		grammarBuilder.append("	: '{' stat* '}' ;\n");
+		grammarBuilder.append("stat: 'if' ID 'then' stat ('else' ID)?\n");
+		grammarBuilder.append("		| 'return'\n");
+		grammarBuilder.append("		;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="{ if x then return else foo }";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, true);
+		assertEquals(
+			"Decision 1:\n" +
+			"s0-'else'->:s1^=>1\n", found);
+
+		assertEquals(
+			"line 1:19 reportAttemptingFullContext d=1 (stat), input='else'\n" +
+			"line 1:19 reportContextSensitivity d=1 (stat), input='else'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testFullContextIF_THEN_ELSEParse_3() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(252);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s \n");
+		grammarBuilder.append("@init {this._interp.predictionMode = antlr4.atn.PredictionMode.LL_EXACT_AMBIG_DETECTION;}\n");
+		grammarBuilder.append("@after {this.dumpDFA();}\n");
+		grammarBuilder.append("	: '{' stat* '}' ;\n");
+		grammarBuilder.append("stat: 'if' ID 'then' stat ('else' ID)?\n");
+		grammarBuilder.append("		| 'return'\n");
+		grammarBuilder.append("		;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="{ if x then if y then return else foo }";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, true);
+		assertEquals(
+			"Decision 1:\n" +
+			"s0-'}'->:s2=>2\n" +
+			"s0-'else'->:s1^=>1\n", found);
+
+		assertEquals(
+			"line 1:29 reportAttemptingFullContext d=1 (stat), input='else'\n" +
+			"line 1:38 reportAmbiguity d=1 (stat): ambigAlts={1, 2}, input='elsefoo}'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testFullContextIF_THEN_ELSEParse_4() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(252);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s \n");
+		grammarBuilder.append("@init {this._interp.predictionMode = antlr4.atn.PredictionMode.LL_EXACT_AMBIG_DETECTION;}\n");
+		grammarBuilder.append("@after {this.dumpDFA();}\n");
+		grammarBuilder.append("	: '{' stat* '}' ;\n");
+		grammarBuilder.append("stat: 'if' ID 'then' stat ('else' ID)?\n");
+		grammarBuilder.append("		| 'return'\n");
+		grammarBuilder.append("		;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="{ if x then if y then return else foo else bar }";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, true);
+		assertEquals(
+			"Decision 1:\n" +
+			"s0-'else'->:s1^=>1\n", found);
+
+		assertEquals(
+			"line 1:29 reportAttemptingFullContext d=1 (stat), input='else'\n" +
+			"line 1:38 reportContextSensitivity d=1 (stat), input='elsefooelse'\n" +
+			"line 1:38 reportAttemptingFullContext d=1 (stat), input='else'\n" +
+			"line 1:38 reportContextSensitivity d=1 (stat), input='else'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testFullContextIF_THEN_ELSEParse_5() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(252);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s \n");
+		grammarBuilder.append("@init {this._interp.predictionMode = antlr4.atn.PredictionMode.LL_EXACT_AMBIG_DETECTION;}\n");
+		grammarBuilder.append("@after {this.dumpDFA();}\n");
+		grammarBuilder.append("	: '{' stat* '}' ;\n");
+		grammarBuilder.append("stat: 'if' ID 'then' stat ('else' ID)?\n");
+		grammarBuilder.append("		| 'return'\n");
+		grammarBuilder.append("		;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input =
+			"{ if x then return else foo\n" +
+			"if x then if y then return else foo }";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, true);
+		assertEquals(
+			"Decision 1:\n" +
+			"s0-'}'->:s2=>2\n" +
+			"s0-'else'->:s1^=>1\n", found);
+
+		assertEquals(
+			"line 1:19 reportAttemptingFullContext d=1 (stat), input='else'\n" +
+			"line 1:19 reportContextSensitivity d=1 (stat), input='else'\n" +
+			"line 2:27 reportAttemptingFullContext d=1 (stat), input='else'\n" +
+			"line 2:36 reportAmbiguity d=1 (stat): ambigAlts={1, 2}, input='elsefoo}'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testFullContextIF_THEN_ELSEParse_6() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(252);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s \n");
+		grammarBuilder.append("@init {this._interp.predictionMode = antlr4.atn.PredictionMode.LL_EXACT_AMBIG_DETECTION;}\n");
+		grammarBuilder.append("@after {this.dumpDFA();}\n");
+		grammarBuilder.append("	: '{' stat* '}' ;\n");
+		grammarBuilder.append("stat: 'if' ID 'then' stat ('else' ID)?\n");
+		grammarBuilder.append("		| 'return'\n");
+		grammarBuilder.append("		;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input =
+			"{ if x then return else foo\n" +
+			"if x then if y then return else foo }";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, true);
+		assertEquals(
+			"Decision 1:\n" +
+			"s0-'}'->:s2=>2\n" +
+			"s0-'else'->:s1^=>1\n", found);
+
+		assertEquals(
+			"line 1:19 reportAttemptingFullContext d=1 (stat), input='else'\n" +
+			"line 1:19 reportContextSensitivity d=1 (stat), input='else'\n" +
+			"line 2:27 reportAttemptingFullContext d=1 (stat), input='else'\n" +
+			"line 2:36 reportAmbiguity d=1 (stat): ambigAlts={1, 2}, input='elsefoo}'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLoopsSimulateTailRecursion() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(324);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("prog\n");
+		grammarBuilder.append("@init {this._interp.predictionMode = antlr4.atn.PredictionMode.LL_EXACT_AMBIG_DETECTION;}\n");
+		grammarBuilder.append("	: expr_or_assign*;\n");
+		grammarBuilder.append("expr_or_assign\n");
+		grammarBuilder.append("	: expr '++' {console.log(\"fail.\");}\n");
+		grammarBuilder.append("	|  expr {console.log(\"pass: \"+$expr.text);}\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("expr: expr_primary ('<-' ID)?;\n");
+		grammarBuilder.append("expr_primary\n");
+		grammarBuilder.append("	: '(' ID ')'\n");
+		grammarBuilder.append("	| ID '(' ID ')'\n");
+		grammarBuilder.append("	| ID\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("ID  : [a-z]+ ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a(i)<-x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "prog", input, true);
+		assertEquals("pass: a(i)<-x\n", found);
+
+		assertEquals(
+			"line 1:3 reportAttemptingFullContext d=3 (expr_primary), input='a(i)'\n" +
+			"line 1:7 reportAmbiguity d=3 (expr_primary): ambigAlts={2, 3}, input='a(i)<-x'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSLLSeesEOFInLLGrammar() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(149);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {this.dumpDFA();}\n");
+		grammarBuilder.append("  : a;\n");
+		grammarBuilder.append("a : e ID ;\n");
+		grammarBuilder.append("b : e INT ID ;\n");
+		grammarBuilder.append("e : INT | ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="34 abc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, true);
+		assertEquals(
+			"Decision 0:\n" +
+			"s0-INT->s1\n" +
+			"s1-ID->:s2^=>1\n", found);
+
+		assertEquals(
+			"line 1:3 reportAttemptingFullContext d=0 (e), input='34abc'\n" +
+			"line 1:0 reportContextSensitivity d=0 (e), input='34'\n", this.stderrDuringParse);
+
+	}
+
+}
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/node/TestLeftRecursion.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/node/TestLeftRecursion.java
new file mode 100644
index 000000000..2b392fc44
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/node/TestLeftRecursion.java
@@ -0,0 +1,3114 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.javascript.node;
+
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+@SuppressWarnings("unused")
+public class TestLeftRecursion extends BaseTest {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAmbigLR_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(705);
+		grammarBuilder.append("grammar Expr;\n");
+		grammarBuilder.append("prog:   stat ;\n");
+		grammarBuilder.append("stat:   expr NEWLINE                # printExpr\n");
+		grammarBuilder.append("    |   ID '=' expr NEWLINE         # assign\n");
+		grammarBuilder.append("    |   NEWLINE                     # blank\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("expr:   expr ('*'|'/') expr      # MulDiv\n");
+		grammarBuilder.append("    |   expr ('+'|'-') expr      # AddSub\n");
+		grammarBuilder.append("    |   INT                      # int\n");
+		grammarBuilder.append("    |   ID                       # id\n");
+		grammarBuilder.append("    |   '(' expr ')'             # parens\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("MUL :   '*' ; // assigns token name to '*' used above in grammar\n");
+		grammarBuilder.append("DIV :   '/' ;\n");
+		grammarBuilder.append("ADD :   '+' ;\n");
+		grammarBuilder.append("SUB :   '-' ;\n");
+		grammarBuilder.append("ID  :   [a-zA-Z]+ ;      // match identifiers\n");
+		grammarBuilder.append("INT :   [0-9]+ ;         // match integers\n");
+		grammarBuilder.append("NEWLINE:'\\r'? '\\n' ;     // return newlines to parser (is end-statement signal)\n");
+		grammarBuilder.append("WS  :   [ \\t]+ -> skip ; // toss out whitespace");
+		String grammar = grammarBuilder.toString();
+		String input ="1\n";
+		String found = execParser("Expr.g4", grammar, "ExprParser", "ExprLexer",
+		                          "ExprListener", "ExprVisitor",
+		                          "prog", input, true);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAmbigLR_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(705);
+		grammarBuilder.append("grammar Expr;\n");
+		grammarBuilder.append("prog:   stat ;\n");
+		grammarBuilder.append("stat:   expr NEWLINE                # printExpr\n");
+		grammarBuilder.append("    |   ID '=' expr NEWLINE         # assign\n");
+		grammarBuilder.append("    |   NEWLINE                     # blank\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("expr:   expr ('*'|'/') expr      # MulDiv\n");
+		grammarBuilder.append("    |   expr ('+'|'-') expr      # AddSub\n");
+		grammarBuilder.append("    |   INT                      # int\n");
+		grammarBuilder.append("    |   ID                       # id\n");
+		grammarBuilder.append("    |   '(' expr ')'             # parens\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("MUL :   '*' ; // assigns token name to '*' used above in grammar\n");
+		grammarBuilder.append("DIV :   '/' ;\n");
+		grammarBuilder.append("ADD :   '+' ;\n");
+		grammarBuilder.append("SUB :   '-' ;\n");
+		grammarBuilder.append("ID  :   [a-zA-Z]+ ;      // match identifiers\n");
+		grammarBuilder.append("INT :   [0-9]+ ;         // match integers\n");
+		grammarBuilder.append("NEWLINE:'\\r'? '\\n' ;     // return newlines to parser (is end-statement signal)\n");
+		grammarBuilder.append("WS  :   [ \\t]+ -> skip ; // toss out whitespace");
+		String grammar = grammarBuilder.toString();
+		String input ="a = 5\n";
+		String found = execParser("Expr.g4", grammar, "ExprParser", "ExprLexer",
+		                          "ExprListener", "ExprVisitor",
+		                          "prog", input, true);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAmbigLR_3() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(705);
+		grammarBuilder.append("grammar Expr;\n");
+		grammarBuilder.append("prog:   stat ;\n");
+		grammarBuilder.append("stat:   expr NEWLINE                # printExpr\n");
+		grammarBuilder.append("    |   ID '=' expr NEWLINE         # assign\n");
+		grammarBuilder.append("    |   NEWLINE                     # blank\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("expr:   expr ('*'|'/') expr      # MulDiv\n");
+		grammarBuilder.append("    |   expr ('+'|'-') expr      # AddSub\n");
+		grammarBuilder.append("    |   INT                      # int\n");
+		grammarBuilder.append("    |   ID                       # id\n");
+		grammarBuilder.append("    |   '(' expr ')'             # parens\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("MUL :   '*' ; // assigns token name to '*' used above in grammar\n");
+		grammarBuilder.append("DIV :   '/' ;\n");
+		grammarBuilder.append("ADD :   '+' ;\n");
+		grammarBuilder.append("SUB :   '-' ;\n");
+		grammarBuilder.append("ID  :   [a-zA-Z]+ ;      // match identifiers\n");
+		grammarBuilder.append("INT :   [0-9]+ ;         // match integers\n");
+		grammarBuilder.append("NEWLINE:'\\r'? '\\n' ;     // return newlines to parser (is end-statement signal)\n");
+		grammarBuilder.append("WS  :   [ \\t]+ -> skip ; // toss out whitespace");
+		String grammar = grammarBuilder.toString();
+		String input ="b = 6\n";
+		String found = execParser("Expr.g4", grammar, "ExprParser", "ExprLexer",
+		                          "ExprListener", "ExprVisitor",
+		                          "prog", input, true);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAmbigLR_4() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(705);
+		grammarBuilder.append("grammar Expr;\n");
+		grammarBuilder.append("prog:   stat ;\n");
+		grammarBuilder.append("stat:   expr NEWLINE                # printExpr\n");
+		grammarBuilder.append("    |   ID '=' expr NEWLINE         # assign\n");
+		grammarBuilder.append("    |   NEWLINE                     # blank\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("expr:   expr ('*'|'/') expr      # MulDiv\n");
+		grammarBuilder.append("    |   expr ('+'|'-') expr      # AddSub\n");
+		grammarBuilder.append("    |   INT                      # int\n");
+		grammarBuilder.append("    |   ID                       # id\n");
+		grammarBuilder.append("    |   '(' expr ')'             # parens\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("MUL :   '*' ; // assigns token name to '*' used above in grammar\n");
+		grammarBuilder.append("DIV :   '/' ;\n");
+		grammarBuilder.append("ADD :   '+' ;\n");
+		grammarBuilder.append("SUB :   '-' ;\n");
+		grammarBuilder.append("ID  :   [a-zA-Z]+ ;      // match identifiers\n");
+		grammarBuilder.append("INT :   [0-9]+ ;         // match integers\n");
+		grammarBuilder.append("NEWLINE:'\\r'? '\\n' ;     // return newlines to parser (is end-statement signal)\n");
+		grammarBuilder.append("WS  :   [ \\t]+ -> skip ; // toss out whitespace");
+		String grammar = grammarBuilder.toString();
+		String input ="a+b*2\n";
+		String found = execParser("Expr.g4", grammar, "ExprParser", "ExprLexer",
+		                          "ExprListener", "ExprVisitor",
+		                          "prog", input, true);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAmbigLR_5() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(705);
+		grammarBuilder.append("grammar Expr;\n");
+		grammarBuilder.append("prog:   stat ;\n");
+		grammarBuilder.append("stat:   expr NEWLINE                # printExpr\n");
+		grammarBuilder.append("    |   ID '=' expr NEWLINE         # assign\n");
+		grammarBuilder.append("    |   NEWLINE                     # blank\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("expr:   expr ('*'|'/') expr      # MulDiv\n");
+		grammarBuilder.append("    |   expr ('+'|'-') expr      # AddSub\n");
+		grammarBuilder.append("    |   INT                      # int\n");
+		grammarBuilder.append("    |   ID                       # id\n");
+		grammarBuilder.append("    |   '(' expr ')'             # parens\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("MUL :   '*' ; // assigns token name to '*' used above in grammar\n");
+		grammarBuilder.append("DIV :   '/' ;\n");
+		grammarBuilder.append("ADD :   '+' ;\n");
+		grammarBuilder.append("SUB :   '-' ;\n");
+		grammarBuilder.append("ID  :   [a-zA-Z]+ ;      // match identifiers\n");
+		grammarBuilder.append("INT :   [0-9]+ ;         // match integers\n");
+		grammarBuilder.append("NEWLINE:'\\r'? '\\n' ;     // return newlines to parser (is end-statement signal)\n");
+		grammarBuilder.append("WS  :   [ \\t]+ -> skip ; // toss out whitespace");
+		String grammar = grammarBuilder.toString();
+		String input ="(1+2)*3\n";
+		String found = execParser("Expr.g4", grammar, "ExprParser", "ExprLexer",
+		                          "ExprListener", "ExprVisitor",
+		                          "prog", input, true);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDeclarations_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(398);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : declarator EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("declarator\n");
+		grammarBuilder.append("        : declarator '[' e ']'\n");
+		grammarBuilder.append("        | declarator '[' ']'\n");
+		grammarBuilder.append("        | declarator '(' ')'\n");
+		grammarBuilder.append("        | '*' declarator // binds less tight than suffixes\n");
+		grammarBuilder.append("        | '(' declarator ')'\n");
+		grammarBuilder.append("        | ID\n");
+		grammarBuilder.append("        ;\n");
+		grammarBuilder.append("e : INT ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (declarator a) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDeclarations_10() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(398);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : declarator EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("declarator\n");
+		grammarBuilder.append("        : declarator '[' e ']'\n");
+		grammarBuilder.append("        | declarator '[' ']'\n");
+		grammarBuilder.append("        | declarator '(' ')'\n");
+		grammarBuilder.append("        | '*' declarator // binds less tight than suffixes\n");
+		grammarBuilder.append("        | '(' declarator ')'\n");
+		grammarBuilder.append("        | ID\n");
+		grammarBuilder.append("        ;\n");
+		grammarBuilder.append("e : INT ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="(*a)[]";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (declarator (declarator ( (declarator * (declarator a)) )) [ ]) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDeclarations_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(398);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : declarator EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("declarator\n");
+		grammarBuilder.append("        : declarator '[' e ']'\n");
+		grammarBuilder.append("        | declarator '[' ']'\n");
+		grammarBuilder.append("        | declarator '(' ')'\n");
+		grammarBuilder.append("        | '*' declarator // binds less tight than suffixes\n");
+		grammarBuilder.append("        | '(' declarator ')'\n");
+		grammarBuilder.append("        | ID\n");
+		grammarBuilder.append("        ;\n");
+		grammarBuilder.append("e : INT ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="*a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (declarator * (declarator a)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDeclarations_3() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(398);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : declarator EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("declarator\n");
+		grammarBuilder.append("        : declarator '[' e ']'\n");
+		grammarBuilder.append("        | declarator '[' ']'\n");
+		grammarBuilder.append("        | declarator '(' ')'\n");
+		grammarBuilder.append("        | '*' declarator // binds less tight than suffixes\n");
+		grammarBuilder.append("        | '(' declarator ')'\n");
+		grammarBuilder.append("        | ID\n");
+		grammarBuilder.append("        ;\n");
+		grammarBuilder.append("e : INT ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="**a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (declarator * (declarator * (declarator a))) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDeclarations_4() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(398);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : declarator EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("declarator\n");
+		grammarBuilder.append("        : declarator '[' e ']'\n");
+		grammarBuilder.append("        | declarator '[' ']'\n");
+		grammarBuilder.append("        | declarator '(' ')'\n");
+		grammarBuilder.append("        | '*' declarator // binds less tight than suffixes\n");
+		grammarBuilder.append("        | '(' declarator ')'\n");
+		grammarBuilder.append("        | ID\n");
+		grammarBuilder.append("        ;\n");
+		grammarBuilder.append("e : INT ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a[3]";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (declarator (declarator a) [ (e 3) ]) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDeclarations_5() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(398);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : declarator EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("declarator\n");
+		grammarBuilder.append("        : declarator '[' e ']'\n");
+		grammarBuilder.append("        | declarator '[' ']'\n");
+		grammarBuilder.append("        | declarator '(' ')'\n");
+		grammarBuilder.append("        | '*' declarator // binds less tight than suffixes\n");
+		grammarBuilder.append("        | '(' declarator ')'\n");
+		grammarBuilder.append("        | ID\n");
+		grammarBuilder.append("        ;\n");
+		grammarBuilder.append("e : INT ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="b[]";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (declarator (declarator b) [ ]) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDeclarations_6() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(398);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : declarator EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("declarator\n");
+		grammarBuilder.append("        : declarator '[' e ']'\n");
+		grammarBuilder.append("        | declarator '[' ']'\n");
+		grammarBuilder.append("        | declarator '(' ')'\n");
+		grammarBuilder.append("        | '*' declarator // binds less tight than suffixes\n");
+		grammarBuilder.append("        | '(' declarator ')'\n");
+		grammarBuilder.append("        | ID\n");
+		grammarBuilder.append("        ;\n");
+		grammarBuilder.append("e : INT ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="(a)";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (declarator ( (declarator a) )) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDeclarations_7() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(398);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : declarator EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("declarator\n");
+		grammarBuilder.append("        : declarator '[' e ']'\n");
+		grammarBuilder.append("        | declarator '[' ']'\n");
+		grammarBuilder.append("        | declarator '(' ')'\n");
+		grammarBuilder.append("        | '*' declarator // binds less tight than suffixes\n");
+		grammarBuilder.append("        | '(' declarator ')'\n");
+		grammarBuilder.append("        | ID\n");
+		grammarBuilder.append("        ;\n");
+		grammarBuilder.append("e : INT ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a[]()";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (declarator (declarator (declarator a) [ ]) ( )) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDeclarations_8() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(398);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : declarator EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("declarator\n");
+		grammarBuilder.append("        : declarator '[' e ']'\n");
+		grammarBuilder.append("        | declarator '[' ']'\n");
+		grammarBuilder.append("        | declarator '(' ')'\n");
+		grammarBuilder.append("        | '*' declarator // binds less tight than suffixes\n");
+		grammarBuilder.append("        | '(' declarator ')'\n");
+		grammarBuilder.append("        | ID\n");
+		grammarBuilder.append("        ;\n");
+		grammarBuilder.append("e : INT ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a[][]";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (declarator (declarator (declarator a) [ ]) [ ]) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDeclarations_9() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(398);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : declarator EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("declarator\n");
+		grammarBuilder.append("        : declarator '[' e ']'\n");
+		grammarBuilder.append("        | declarator '[' ']'\n");
+		grammarBuilder.append("        | declarator '(' ')'\n");
+		grammarBuilder.append("        | '*' declarator // binds less tight than suffixes\n");
+		grammarBuilder.append("        | '(' declarator ')'\n");
+		grammarBuilder.append("        | ID\n");
+		grammarBuilder.append("        ;\n");
+		grammarBuilder.append("e : INT ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="*a[]";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (declarator * (declarator (declarator a) [ ])) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDirectCallToLeftRecursiveRule_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(126);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a @after {console.log($ctx.toStringTree(null, this));} : a ID\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("(a x)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDirectCallToLeftRecursiveRule_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(126);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a @after {console.log($ctx.toStringTree(null, this));} : a ID\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x y";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("(a (a x) y)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDirectCallToLeftRecursiveRule_3() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(126);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a @after {console.log($ctx.toStringTree(null, this));} : a ID\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x y z";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("(a (a (a x) y) z)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExpressions_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(257);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("e : e '.' ID\n");
+		grammarBuilder.append("  | e '.' 'this'\n");
+		grammarBuilder.append("  | '-' e\n");
+		grammarBuilder.append("  | e '*' e\n");
+		grammarBuilder.append("  | e ('+'|'-') e\n");
+		grammarBuilder.append("  | INT\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (e a) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExpressions_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(257);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("e : e '.' ID\n");
+		grammarBuilder.append("  | e '.' 'this'\n");
+		grammarBuilder.append("  | '-' e\n");
+		grammarBuilder.append("  | e '*' e\n");
+		grammarBuilder.append("  | e ('+'|'-') e\n");
+		grammarBuilder.append("  | INT\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="1";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (e 1) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExpressions_3() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(257);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("e : e '.' ID\n");
+		grammarBuilder.append("  | e '.' 'this'\n");
+		grammarBuilder.append("  | '-' e\n");
+		grammarBuilder.append("  | e '*' e\n");
+		grammarBuilder.append("  | e ('+'|'-') e\n");
+		grammarBuilder.append("  | INT\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a-1";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (e (e a) - (e 1)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExpressions_4() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(257);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("e : e '.' ID\n");
+		grammarBuilder.append("  | e '.' 'this'\n");
+		grammarBuilder.append("  | '-' e\n");
+		grammarBuilder.append("  | e '*' e\n");
+		grammarBuilder.append("  | e ('+'|'-') e\n");
+		grammarBuilder.append("  | INT\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a.b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (e (e a) . b) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExpressions_5() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(257);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("e : e '.' ID\n");
+		grammarBuilder.append("  | e '.' 'this'\n");
+		grammarBuilder.append("  | '-' e\n");
+		grammarBuilder.append("  | e '*' e\n");
+		grammarBuilder.append("  | e ('+'|'-') e\n");
+		grammarBuilder.append("  | INT\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a.this";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (e (e a) . this) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExpressions_6() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(257);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("e : e '.' ID\n");
+		grammarBuilder.append("  | e '.' 'this'\n");
+		grammarBuilder.append("  | '-' e\n");
+		grammarBuilder.append("  | e '*' e\n");
+		grammarBuilder.append("  | e ('+'|'-') e\n");
+		grammarBuilder.append("  | INT\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="-a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (e - (e a)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExpressions_7() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(257);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("e : e '.' ID\n");
+		grammarBuilder.append("  | e '.' 'this'\n");
+		grammarBuilder.append("  | '-' e\n");
+		grammarBuilder.append("  | e '*' e\n");
+		grammarBuilder.append("  | e ('+'|'-') e\n");
+		grammarBuilder.append("  | INT\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="-a+b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (e (e - (e a)) + (e b)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(1254);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a|b&c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (e (e a) | (e (e b) & (e c))) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_10() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(1254);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a.f(x)==T.c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (e (e (e (e a) . f) ( (expressionList (e x)) )) == (e (e T) . c)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_11() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(1254);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a.f().g(x,1)";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (e (e (e (e (e a) . f) ( )) . g) ( (expressionList (e x) , (e 1)) )) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_12() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(1254);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="new T[((n-1) * x) + 1]";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (e new (typespec T) [ (e (e ( (e (e ( (e (e n) - (e 1)) )) * (e x)) )) + (e 1)) ]) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(1254);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="(a|b)&c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (e (e ( (e (e a) | (e b)) )) & (e c)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_3() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(1254);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a > b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (e (e a) > (e b)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_4() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(1254);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a >> b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (e (e a) >> (e b)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_5() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(1254);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a=b=c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (e (e a) = (e (e b) = (e c))) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_6() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(1254);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a^b^c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (e (e a) ^ (e (e b) ^ (e c))) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_7() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(1254);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="(T)x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (e ( (typespec T) ) (e x)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_8() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(1254);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="new A().b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (e (e new (typespec A) ( )) . b) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_9() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(1254);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="(T)t.f()";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (e (e ( (typespec T) ) (e (e t) . f)) ( )) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLabelsOnOpSubrule_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(177);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : e;\n");
+		grammarBuilder.append("e : a=e op=('*'|'/') b=e  {}\n");
+		grammarBuilder.append("  | INT {}\n");
+		grammarBuilder.append("  | '(' x=e ')' {}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="4";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (e 4))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLabelsOnOpSubrule_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(177);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : e;\n");
+		grammarBuilder.append("e : a=e op=('*'|'/') b=e  {}\n");
+		grammarBuilder.append("  | INT {}\n");
+		grammarBuilder.append("  | '(' x=e ')' {}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="1*2/3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (e (e (e 1) * (e 2)) / (e 3)))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLabelsOnOpSubrule_3() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(177);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : e;\n");
+		grammarBuilder.append("e : a=e op=('*'|'/') b=e  {}\n");
+		grammarBuilder.append("  | INT {}\n");
+		grammarBuilder.append("  | '(' x=e ')' {}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="(1/2)*3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (e (e ( (e (e 1) / (e 2)) )) * (e 3)))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleActionsPredicatesOptions_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(246);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : e ;\n");
+		grammarBuilder.append("e : a=e op=('*'|'/') b=e  {}{true}?\n");
+		grammarBuilder.append("  | a=e op=('+'|'-') b=e  {}<p=3>{true}?<fail='Message'>\n");
+		grammarBuilder.append("  | INT {}{}\n");
+		grammarBuilder.append("  | '(' x=e ')' {}{}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="4";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (e 4))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleActionsPredicatesOptions_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(246);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : e ;\n");
+		grammarBuilder.append("e : a=e op=('*'|'/') b=e  {}{true}?\n");
+		grammarBuilder.append("  | a=e op=('+'|'-') b=e  {}<p=3>{true}?<fail='Message'>\n");
+		grammarBuilder.append("  | INT {}{}\n");
+		grammarBuilder.append("  | '(' x=e ')' {}{}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="1*2/3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (e (e (e 1) * (e 2)) / (e 3)))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleActionsPredicatesOptions_3() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(246);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : e ;\n");
+		grammarBuilder.append("e : a=e op=('*'|'/') b=e  {}{true}?\n");
+		grammarBuilder.append("  | a=e op=('+'|'-') b=e  {}<p=3>{true}?<fail='Message'>\n");
+		grammarBuilder.append("  | INT {}{}\n");
+		grammarBuilder.append("  | '(' x=e ')' {}{}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="(1/2)*3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (e (e ( (e (e 1) / (e 2)) )) * (e 3)))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleActions_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(184);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : e ;\n");
+		grammarBuilder.append("e : a=e op=('*'|'/') b=e  {}{}\n");
+		grammarBuilder.append("  | INT {}{}\n");
+		grammarBuilder.append("  | '(' x=e ')' {}{}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="4";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (e 4))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleActions_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(184);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : e ;\n");
+		grammarBuilder.append("e : a=e op=('*'|'/') b=e  {}{}\n");
+		grammarBuilder.append("  | INT {}{}\n");
+		grammarBuilder.append("  | '(' x=e ')' {}{}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="1*2/3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (e (e (e 1) * (e 2)) / (e 3)))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleActions_3() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(184);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : e ;\n");
+		grammarBuilder.append("e : a=e op=('*'|'/') b=e  {}{}\n");
+		grammarBuilder.append("  | INT {}{}\n");
+		grammarBuilder.append("  | '(' x=e ')' {}{}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="(1/2)*3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (e (e ( (e (e 1) / (e 2)) )) * (e 3)))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleAlternativesWithCommonLabel_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(639);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {console.log($e.v);};\n");
+		grammarBuilder.append("e returns [int v]\n");
+		grammarBuilder.append("  : e '*' e     {$v = $ctx.e(0).v * $ctx.e(1).v;}  # binary\n");
+		grammarBuilder.append("  | e '+' e     {$v = $ctx.e(0).v + $ctx.e(1).v;}  # binary\n");
+		grammarBuilder.append("  | INT         {$v = $INT.int;}                   # anInt\n");
+		grammarBuilder.append("  | '(' e ')'   {$v = $e.v;}                       # parens\n");
+		grammarBuilder.append("  | left=e INC  {console.assert($ctx.INC() != null);$v = $left.v + 1;}      # unary\n");
+		grammarBuilder.append("  | left=e DEC  {console.assert($ctx.DEC() != null);$v = $left.v - 1;}      # unary\n");
+		grammarBuilder.append("  | ID          {$v = 3;}                                                     # anID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("INC : '++' ;\n");
+		grammarBuilder.append("DEC : '--' ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="4";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("4\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleAlternativesWithCommonLabel_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(639);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {console.log($e.v);};\n");
+		grammarBuilder.append("e returns [int v]\n");
+		grammarBuilder.append("  : e '*' e     {$v = $ctx.e(0).v * $ctx.e(1).v;}  # binary\n");
+		grammarBuilder.append("  | e '+' e     {$v = $ctx.e(0).v + $ctx.e(1).v;}  # binary\n");
+		grammarBuilder.append("  | INT         {$v = $INT.int;}                   # anInt\n");
+		grammarBuilder.append("  | '(' e ')'   {$v = $e.v;}                       # parens\n");
+		grammarBuilder.append("  | left=e INC  {console.assert($ctx.INC() != null);$v = $left.v + 1;}      # unary\n");
+		grammarBuilder.append("  | left=e DEC  {console.assert($ctx.DEC() != null);$v = $left.v - 1;}      # unary\n");
+		grammarBuilder.append("  | ID          {$v = 3;}                                                     # anID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("INC : '++' ;\n");
+		grammarBuilder.append("DEC : '--' ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="1+2";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("3\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleAlternativesWithCommonLabel_3() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(639);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {console.log($e.v);};\n");
+		grammarBuilder.append("e returns [int v]\n");
+		grammarBuilder.append("  : e '*' e     {$v = $ctx.e(0).v * $ctx.e(1).v;}  # binary\n");
+		grammarBuilder.append("  | e '+' e     {$v = $ctx.e(0).v + $ctx.e(1).v;}  # binary\n");
+		grammarBuilder.append("  | INT         {$v = $INT.int;}                   # anInt\n");
+		grammarBuilder.append("  | '(' e ')'   {$v = $e.v;}                       # parens\n");
+		grammarBuilder.append("  | left=e INC  {console.assert($ctx.INC() != null);$v = $left.v + 1;}      # unary\n");
+		grammarBuilder.append("  | left=e DEC  {console.assert($ctx.DEC() != null);$v = $left.v - 1;}      # unary\n");
+		grammarBuilder.append("  | ID          {$v = 3;}                                                     # anID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("INC : '++' ;\n");
+		grammarBuilder.append("DEC : '--' ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="1+2*3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("7\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleAlternativesWithCommonLabel_4() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(639);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {console.log($e.v);};\n");
+		grammarBuilder.append("e returns [int v]\n");
+		grammarBuilder.append("  : e '*' e     {$v = $ctx.e(0).v * $ctx.e(1).v;}  # binary\n");
+		grammarBuilder.append("  | e '+' e     {$v = $ctx.e(0).v + $ctx.e(1).v;}  # binary\n");
+		grammarBuilder.append("  | INT         {$v = $INT.int;}                   # anInt\n");
+		grammarBuilder.append("  | '(' e ')'   {$v = $e.v;}                       # parens\n");
+		grammarBuilder.append("  | left=e INC  {console.assert($ctx.INC() != null);$v = $left.v + 1;}      # unary\n");
+		grammarBuilder.append("  | left=e DEC  {console.assert($ctx.DEC() != null);$v = $left.v - 1;}      # unary\n");
+		grammarBuilder.append("  | ID          {$v = 3;}                                                     # anID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("INC : '++' ;\n");
+		grammarBuilder.append("DEC : '--' ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="i++*3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("12\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPrecedenceFilterConsidersContext() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(149);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("prog \n");
+		grammarBuilder.append("@after {console.log($ctx.toStringTree(null, this));}\n");
+		grammarBuilder.append(": statement* EOF {};\n");
+		grammarBuilder.append("statement: letterA | statement letterA 'b' ;\n");
+		grammarBuilder.append("letterA: 'a';");
+		String grammar = grammarBuilder.toString();
+		String input ="aa";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "prog", input, false);
+		assertEquals("(prog (statement (letterA a)) (statement (letterA a)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPrefixAndOtherAlt_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(223);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : expr EOF ; \n");
+		grammarBuilder.append("expr : literal\n");
+		grammarBuilder.append("     | op expr\n");
+		grammarBuilder.append("     | expr op expr\n");
+		grammarBuilder.append("     ;\n");
+		grammarBuilder.append("literal : '-'? Integer ;\n");
+		grammarBuilder.append("op : '+' | '-' ;\n");
+		grammarBuilder.append("Integer : [0-9]+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="-1";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (expr (literal - 1)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPrefixAndOtherAlt_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(223);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : expr EOF ; \n");
+		grammarBuilder.append("expr : literal\n");
+		grammarBuilder.append("     | op expr\n");
+		grammarBuilder.append("     | expr op expr\n");
+		grammarBuilder.append("     ;\n");
+		grammarBuilder.append("literal : '-'? Integer ;\n");
+		grammarBuilder.append("op : '+' | '-' ;\n");
+		grammarBuilder.append("Integer : [0-9]+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="-1 + -1";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (expr (expr (literal - 1)) (op +) (expr (literal - 1))) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPrefixOpWithActionAndLabel_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(336);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {console.log($e.result);} ;\n");
+		grammarBuilder.append("e returns [String result]\n");
+		grammarBuilder.append("    :   ID '=' e1=e    {$result = \"(\" + $ID.text + \"=\" + $e1.result + \")\";}\n");
+		grammarBuilder.append("    |   ID             {$result = $ID.text;}\n");
+		grammarBuilder.append("    |   e1=e '+' e2=e  {$result = \"(\" + $e1.result + \"+\" + $e2.result + \")\";}\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("a\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPrefixOpWithActionAndLabel_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(336);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {console.log($e.result);} ;\n");
+		grammarBuilder.append("e returns [String result]\n");
+		grammarBuilder.append("    :   ID '=' e1=e    {$result = \"(\" + $ID.text + \"=\" + $e1.result + \")\";}\n");
+		grammarBuilder.append("    |   ID             {$result = $ID.text;}\n");
+		grammarBuilder.append("    |   e1=e '+' e2=e  {$result = \"(\" + $e1.result + \"+\" + $e2.result + \")\";}\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a+b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(a+b)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPrefixOpWithActionAndLabel_3() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(336);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {console.log($e.result);} ;\n");
+		grammarBuilder.append("e returns [String result]\n");
+		grammarBuilder.append("    :   ID '=' e1=e    {$result = \"(\" + $ID.text + \"=\" + $e1.result + \")\";}\n");
+		grammarBuilder.append("    |   ID             {$result = $ID.text;}\n");
+		grammarBuilder.append("    |   e1=e '+' e2=e  {$result = \"(\" + $e1.result + \"+\" + $e2.result + \")\";}\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a=b+c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("((a=b)+c)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsAndLabels_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(454);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : q=e {console.log($e.v);}; \n");
+		grammarBuilder.append("e returns [int v]\n");
+		grammarBuilder.append("  : a=e op='*' b=e {$v = $a.v * $b.v;}  # mult\n");
+		grammarBuilder.append("  | a=e '+' b=e {$v = $a.v + $b.v;}     # add\n");
+		grammarBuilder.append("  | INT         {$v = $INT.int;}        # anInt\n");
+		grammarBuilder.append("  | '(' x=e ')' {$v = $x.v;}            # parens\n");
+		grammarBuilder.append("  | x=e '++'    {$v = $x.v+1;}          # inc\n");
+		grammarBuilder.append("  | e '--'                              # dec\n");
+		grammarBuilder.append("  | ID          {$v = 3;}               # anID\n");
+		grammarBuilder.append("  ; \n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="4";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("4\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsAndLabels_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(454);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : q=e {console.log($e.v);}; \n");
+		grammarBuilder.append("e returns [int v]\n");
+		grammarBuilder.append("  : a=e op='*' b=e {$v = $a.v * $b.v;}  # mult\n");
+		grammarBuilder.append("  | a=e '+' b=e {$v = $a.v + $b.v;}     # add\n");
+		grammarBuilder.append("  | INT         {$v = $INT.int;}        # anInt\n");
+		grammarBuilder.append("  | '(' x=e ')' {$v = $x.v;}            # parens\n");
+		grammarBuilder.append("  | x=e '++'    {$v = $x.v+1;}          # inc\n");
+		grammarBuilder.append("  | e '--'                              # dec\n");
+		grammarBuilder.append("  | ID          {$v = 3;}               # anID\n");
+		grammarBuilder.append("  ; \n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="1+2";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("3\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsAndLabels_3() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(454);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : q=e {console.log($e.v);}; \n");
+		grammarBuilder.append("e returns [int v]\n");
+		grammarBuilder.append("  : a=e op='*' b=e {$v = $a.v * $b.v;}  # mult\n");
+		grammarBuilder.append("  | a=e '+' b=e {$v = $a.v + $b.v;}     # add\n");
+		grammarBuilder.append("  | INT         {$v = $INT.int;}        # anInt\n");
+		grammarBuilder.append("  | '(' x=e ')' {$v = $x.v;}            # parens\n");
+		grammarBuilder.append("  | x=e '++'    {$v = $x.v+1;}          # inc\n");
+		grammarBuilder.append("  | e '--'                              # dec\n");
+		grammarBuilder.append("  | ID          {$v = 3;}               # anID\n");
+		grammarBuilder.append("  ; \n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="1+2*3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("7\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsAndLabels_4() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(454);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : q=e {console.log($e.v);}; \n");
+		grammarBuilder.append("e returns [int v]\n");
+		grammarBuilder.append("  : a=e op='*' b=e {$v = $a.v * $b.v;}  # mult\n");
+		grammarBuilder.append("  | a=e '+' b=e {$v = $a.v + $b.v;}     # add\n");
+		grammarBuilder.append("  | INT         {$v = $INT.int;}        # anInt\n");
+		grammarBuilder.append("  | '(' x=e ')' {$v = $x.v;}            # parens\n");
+		grammarBuilder.append("  | x=e '++'    {$v = $x.v+1;}          # inc\n");
+		grammarBuilder.append("  | e '--'                              # dec\n");
+		grammarBuilder.append("  | ID          {$v = 3;}               # anID\n");
+		grammarBuilder.append("  ; \n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="i++*3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("12\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsList1_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(307);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : expr EOF;\n");
+		grammarBuilder.append("expr:\n");
+		grammarBuilder.append("    a=expr '*' a=expr #Factor\n");
+		grammarBuilder.append("    | b+=expr (',' b+=expr)* '>>' c=expr #Send\n");
+		grammarBuilder.append("    | ID #JustId //semantic check on modifiers\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("ID  : ('a'..'z'|'A'..'Z'|'_')\n");
+		grammarBuilder.append("      ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a*b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (expr (expr a) * (expr b)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsList1_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(307);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : expr EOF;\n");
+		grammarBuilder.append("expr:\n");
+		grammarBuilder.append("    a=expr '*' a=expr #Factor\n");
+		grammarBuilder.append("    | b+=expr (',' b+=expr)* '>>' c=expr #Send\n");
+		grammarBuilder.append("    | ID #JustId //semantic check on modifiers\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("ID  : ('a'..'z'|'A'..'Z'|'_')\n");
+		grammarBuilder.append("      ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a,c>>x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (expr (expr a) , (expr c) >> (expr x)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsList1_3() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(307);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : expr EOF;\n");
+		grammarBuilder.append("expr:\n");
+		grammarBuilder.append("    a=expr '*' a=expr #Factor\n");
+		grammarBuilder.append("    | b+=expr (',' b+=expr)* '>>' c=expr #Send\n");
+		grammarBuilder.append("    | ID #JustId //semantic check on modifiers\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("ID  : ('a'..'z'|'A'..'Z'|'_')\n");
+		grammarBuilder.append("      ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (expr x) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsList1_4() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(307);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : expr EOF;\n");
+		grammarBuilder.append("expr:\n");
+		grammarBuilder.append("    a=expr '*' a=expr #Factor\n");
+		grammarBuilder.append("    | b+=expr (',' b+=expr)* '>>' c=expr #Send\n");
+		grammarBuilder.append("    | ID #JustId //semantic check on modifiers\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("ID  : ('a'..'z'|'A'..'Z'|'_')\n");
+		grammarBuilder.append("      ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a*b,c,x*y>>r";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (expr (expr (expr a) * (expr b)) , (expr c) , (expr (expr x) * (expr y)) >> (expr r)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsList2_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(324);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : expr EOF;\n");
+		grammarBuilder.append("expr:\n");
+		grammarBuilder.append("    a=expr '*' a=expr #Factor\n");
+		grammarBuilder.append("    | b+=expr ',' b+=expr #Comma\n");
+		grammarBuilder.append("    | b+=expr '>>' c=expr #Send\n");
+		grammarBuilder.append("    | ID #JustId //semantic check on modifiers\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("ID  : ('a'..'z'|'A'..'Z'|'_')\n");
+		grammarBuilder.append("      ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a*b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (expr (expr a) * (expr b)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsList2_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(324);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : expr EOF;\n");
+		grammarBuilder.append("expr:\n");
+		grammarBuilder.append("    a=expr '*' a=expr #Factor\n");
+		grammarBuilder.append("    | b+=expr ',' b+=expr #Comma\n");
+		grammarBuilder.append("    | b+=expr '>>' c=expr #Send\n");
+		grammarBuilder.append("    | ID #JustId //semantic check on modifiers\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("ID  : ('a'..'z'|'A'..'Z'|'_')\n");
+		grammarBuilder.append("      ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a,c>>x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (expr (expr (expr a) , (expr c)) >> (expr x)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsList2_3() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(324);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : expr EOF;\n");
+		grammarBuilder.append("expr:\n");
+		grammarBuilder.append("    a=expr '*' a=expr #Factor\n");
+		grammarBuilder.append("    | b+=expr ',' b+=expr #Comma\n");
+		grammarBuilder.append("    | b+=expr '>>' c=expr #Send\n");
+		grammarBuilder.append("    | ID #JustId //semantic check on modifiers\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("ID  : ('a'..'z'|'A'..'Z'|'_')\n");
+		grammarBuilder.append("      ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (expr x) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsList2_4() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(324);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : expr EOF;\n");
+		grammarBuilder.append("expr:\n");
+		grammarBuilder.append("    a=expr '*' a=expr #Factor\n");
+		grammarBuilder.append("    | b+=expr ',' b+=expr #Comma\n");
+		grammarBuilder.append("    | b+=expr '>>' c=expr #Send\n");
+		grammarBuilder.append("    | ID #JustId //semantic check on modifiers\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("ID  : ('a'..'z'|'A'..'Z'|'_')\n");
+		grammarBuilder.append("      ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a*b,c,x*y>>r";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (expr (expr (expr (expr (expr a) * (expr b)) , (expr c)) , (expr (expr x) * (expr y))) >> (expr r)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActions_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(246);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {console.log($e.v);}; \n");
+		grammarBuilder.append("e returns [int v, list ignored]\n");
+		grammarBuilder.append("  : a=e '*' b=e {$v = $a.v * $b.v;}\n");
+		grammarBuilder.append("  | a=e '+' b=e {$v = $a.v + $b.v;}\n");
+		grammarBuilder.append("  | INT {$v = $INT.int;}\n");
+		grammarBuilder.append("  | '(' x=e ')' {$v = $x.v;}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;\n");
+		String grammar = grammarBuilder.toString();
+		String input ="4";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("4\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActions_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(246);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {console.log($e.v);}; \n");
+		grammarBuilder.append("e returns [int v, list ignored]\n");
+		grammarBuilder.append("  : a=e '*' b=e {$v = $a.v * $b.v;}\n");
+		grammarBuilder.append("  | a=e '+' b=e {$v = $a.v + $b.v;}\n");
+		grammarBuilder.append("  | INT {$v = $INT.int;}\n");
+		grammarBuilder.append("  | '(' x=e ')' {$v = $x.v;}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;\n");
+		String grammar = grammarBuilder.toString();
+		String input ="1+2";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("3\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActions_3() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(246);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {console.log($e.v);}; \n");
+		grammarBuilder.append("e returns [int v, list ignored]\n");
+		grammarBuilder.append("  : a=e '*' b=e {$v = $a.v * $b.v;}\n");
+		grammarBuilder.append("  | a=e '+' b=e {$v = $a.v + $b.v;}\n");
+		grammarBuilder.append("  | INT {$v = $INT.int;}\n");
+		grammarBuilder.append("  | '(' x=e ')' {$v = $x.v;}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;\n");
+		String grammar = grammarBuilder.toString();
+		String input ="1+2*3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("7\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActions_4() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(246);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {console.log($e.v);}; \n");
+		grammarBuilder.append("e returns [int v, list ignored]\n");
+		grammarBuilder.append("  : a=e '*' b=e {$v = $a.v * $b.v;}\n");
+		grammarBuilder.append("  | a=e '+' b=e {$v = $a.v + $b.v;}\n");
+		grammarBuilder.append("  | INT {$v = $INT.int;}\n");
+		grammarBuilder.append("  | '(' x=e ')' {$v = $x.v;}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;\n");
+		String grammar = grammarBuilder.toString();
+		String input ="(1+2)*3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("9\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSemPred() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(142);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : a ;\n");
+		grammarBuilder.append("a : a {true}? ID\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x y z";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (a (a (a x) y) z))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSemPredFailOption() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(166);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : a ;\n");
+		grammarBuilder.append("a : a ID {false}?<fail='custom message'>\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x y z";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (a (a x) y z))\n", found);
+
+		assertEquals("line 1:4 rule a custom message\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSimple_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(134);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : a ;\n");
+		grammarBuilder.append("a : a ID\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (a x))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSimple_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(134);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : a ;\n");
+		grammarBuilder.append("a : a ID\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x y";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (a (a x) y))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSimple_3() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(134);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : a ;\n");
+		grammarBuilder.append("a : a ID\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x y z";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (a (a (a x) y) z))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExprExplicitAssociativity_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(290);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : e EOF; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e :<assoc=right> e '*' e\n");
+		grammarBuilder.append("  |<assoc=right> e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (e a) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExprExplicitAssociativity_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(290);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : e EOF; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e :<assoc=right> e '*' e\n");
+		grammarBuilder.append("  |<assoc=right> e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a+b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (e (e a) + (e b)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExprExplicitAssociativity_3() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(290);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : e EOF; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e :<assoc=right> e '*' e\n");
+		grammarBuilder.append("  |<assoc=right> e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a*b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (e (e a) * (e b)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExprExplicitAssociativity_4() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(290);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : e EOF; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e :<assoc=right> e '*' e\n");
+		grammarBuilder.append("  |<assoc=right> e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a?b:c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (e (e a) ? (e b) : (e c)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExprExplicitAssociativity_5() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(290);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : e EOF; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e :<assoc=right> e '*' e\n");
+		grammarBuilder.append("  |<assoc=right> e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a=b=c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (e (e a) = (e (e b) = (e c))) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExprExplicitAssociativity_6() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(290);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : e EOF; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e :<assoc=right> e '*' e\n");
+		grammarBuilder.append("  |<assoc=right> e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a?b+c:d";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (e (e a) ? (e (e b) + (e c)) : (e d)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExprExplicitAssociativity_7() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(290);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : e EOF; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e :<assoc=right> e '*' e\n");
+		grammarBuilder.append("  |<assoc=right> e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a?b=c:d";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (e (e a) ? (e (e b) = (e c)) : (e d)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExprExplicitAssociativity_8() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(290);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : e EOF; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e :<assoc=right> e '*' e\n");
+		grammarBuilder.append("  |<assoc=right> e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a? b?c:d : e";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (e (e a) ? (e (e b) ? (e c) : (e d)) : (e e)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExprExplicitAssociativity_9() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(290);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : e EOF; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e :<assoc=right> e '*' e\n");
+		grammarBuilder.append("  |<assoc=right> e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a?b: c?d:e";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (e (e a) ? (e b) : (e (e c) ? (e d) : (e e))) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExpr_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(265);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : e EOF ; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e : e '*' e\n");
+		grammarBuilder.append("  | e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (e a) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExpr_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(265);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : e EOF ; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e : e '*' e\n");
+		grammarBuilder.append("  | e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a+b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (e (e a) + (e b)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExpr_3() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(265);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : e EOF ; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e : e '*' e\n");
+		grammarBuilder.append("  | e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a*b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (e (e a) * (e b)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExpr_4() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(265);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : e EOF ; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e : e '*' e\n");
+		grammarBuilder.append("  | e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a?b:c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (e (e a) ? (e b) : (e c)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExpr_5() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(265);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : e EOF ; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e : e '*' e\n");
+		grammarBuilder.append("  | e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a=b=c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (e (e a) = (e (e b) = (e c))) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExpr_6() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(265);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : e EOF ; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e : e '*' e\n");
+		grammarBuilder.append("  | e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a?b+c:d";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (e (e a) ? (e (e b) + (e c)) : (e d)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExpr_7() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(265);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : e EOF ; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e : e '*' e\n");
+		grammarBuilder.append("  | e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a?b=c:d";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (e (e a) ? (e (e b) = (e c)) : (e d)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExpr_8() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(265);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : e EOF ; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e : e '*' e\n");
+		grammarBuilder.append("  | e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a? b?c:d : e";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (e (e a) ? (e (e b) ? (e c) : (e d)) : (e e)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExpr_9() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(265);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {console.log($ctx.toStringTree(null, this));} : e EOF ; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e : e '*' e\n");
+		grammarBuilder.append("  | e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a?b: c?d:e";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(s (e (e a) ? (e b) : (e (e c) ? (e d) : (e e))) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testWhitespaceInfluence_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(2763);
+		grammarBuilder.append("grammar Expr;\n");
+		grammarBuilder.append("prog : expression EOF;\n");
+		grammarBuilder.append("expression\n");
+		grammarBuilder.append("    : ID '(' expression (',' expression)* ')'               # doFunction\n");
+		grammarBuilder.append("    | '(' expression ')'                                    # doParenthesis\n");
+		grammarBuilder.append("    | '!' expression                                        # doNot\n");
+		grammarBuilder.append("    | '-' expression                                        # doNegate\n");
+		grammarBuilder.append("    | '+' expression                                        # doPositiv\n");
+		grammarBuilder.append("    | expression '^' expression                             # doPower\n");
+		grammarBuilder.append("    | expression '*' expression                             # doMultipy\n");
+		grammarBuilder.append("    | expression '/' expression                             # doDivide\n");
+		grammarBuilder.append("    | expression '%' expression                             # doModulo\n");
+		grammarBuilder.append("    | expression '-' expression                             # doMinus\n");
+		grammarBuilder.append("    | expression '+' expression                             # doPlus\n");
+		grammarBuilder.append("    | expression '=' expression                             # doEqual\n");
+		grammarBuilder.append("    | expression '!=' expression                            # doNotEqual\n");
+		grammarBuilder.append("    | expression '>' expression                             # doGreather\n");
+		grammarBuilder.append("    | expression '>=' expression                            # doGreatherEqual\n");
+		grammarBuilder.append("    | expression '<' expression                             # doLesser\n");
+		grammarBuilder.append("    | expression '<=' expression                            # doLesserEqual\n");
+		grammarBuilder.append("    | expression K_IN '(' expression (',' expression)* ')'  # doIn\n");
+		grammarBuilder.append("    | expression ( '&' | K_AND) expression                  # doAnd\n");
+		grammarBuilder.append("    | expression ( '|' | K_OR) expression                   # doOr\n");
+		grammarBuilder.append("    | '[' expression (',' expression)* ']'                  # newArray\n");
+		grammarBuilder.append("    | K_TRUE                                                # newTrueBoolean\n");
+		grammarBuilder.append("    | K_FALSE                                               # newFalseBoolean\n");
+		grammarBuilder.append("    | NUMBER                                                # newNumber\n");
+		grammarBuilder.append("    | DATE                                                  # newDateTime\n");
+		grammarBuilder.append("    | ID                                                    # newIdentifier\n");
+		grammarBuilder.append("    | SQ_STRING                                             # newString\n");
+		grammarBuilder.append("    | K_NULL                                                # newNull\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("// Fragments\n");
+		grammarBuilder.append("fragment DIGIT    : '0' .. '9';  \n");
+		grammarBuilder.append("fragment UPPER    : 'A' .. 'Z';\n");
+		grammarBuilder.append("fragment LOWER    : 'a' .. 'z';\n");
+		grammarBuilder.append("fragment LETTER   : LOWER | UPPER;\n");
+		grammarBuilder.append("fragment WORD     : LETTER | '_' | '$' | '#' | '.';\n");
+		grammarBuilder.append("fragment ALPHANUM : WORD | DIGIT;  \n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("// Tokens\n");
+		grammarBuilder.append("ID              : LETTER ALPHANUM*;\n");
+		grammarBuilder.append("NUMBER          : DIGIT+ ('.' DIGIT+)? (('e'|'E')('+'|'-')? DIGIT+)?;\n");
+		grammarBuilder.append("DATE            : '\\'' DIGIT DIGIT DIGIT DIGIT '-' DIGIT DIGIT '-' DIGIT DIGIT (' ' DIGIT DIGIT ':' DIGIT DIGIT ':' DIGIT DIGIT ('.' DIGIT+)?)? '\\'';\n");
+		grammarBuilder.append("SQ_STRING       : '\\'' ('\\'\\'' | ~'\\'')* '\\'';\n");
+		grammarBuilder.append("DQ_STRING       : '\"' ('\\\\\"' | ~'\"')* '\"';\n");
+		grammarBuilder.append("WS              : [ \\t\\n\\r]+ -> skip ;\n");
+		grammarBuilder.append("COMMENTS        : ('/*' .*? '*/' | '//' ~'\\n'* '\\n' ) -> skip;");
+		String grammar = grammarBuilder.toString();
+		String input ="Test(1,3)";
+		String found = execParser("Expr.g4", grammar, "ExprParser", "ExprLexer",
+		                          "ExprListener", "ExprVisitor",
+		                          "prog", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testWhitespaceInfluence_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(2763);
+		grammarBuilder.append("grammar Expr;\n");
+		grammarBuilder.append("prog : expression EOF;\n");
+		grammarBuilder.append("expression\n");
+		grammarBuilder.append("    : ID '(' expression (',' expression)* ')'               # doFunction\n");
+		grammarBuilder.append("    | '(' expression ')'                                    # doParenthesis\n");
+		grammarBuilder.append("    | '!' expression                                        # doNot\n");
+		grammarBuilder.append("    | '-' expression                                        # doNegate\n");
+		grammarBuilder.append("    | '+' expression                                        # doPositiv\n");
+		grammarBuilder.append("    | expression '^' expression                             # doPower\n");
+		grammarBuilder.append("    | expression '*' expression                             # doMultipy\n");
+		grammarBuilder.append("    | expression '/' expression                             # doDivide\n");
+		grammarBuilder.append("    | expression '%' expression                             # doModulo\n");
+		grammarBuilder.append("    | expression '-' expression                             # doMinus\n");
+		grammarBuilder.append("    | expression '+' expression                             # doPlus\n");
+		grammarBuilder.append("    | expression '=' expression                             # doEqual\n");
+		grammarBuilder.append("    | expression '!=' expression                            # doNotEqual\n");
+		grammarBuilder.append("    | expression '>' expression                             # doGreather\n");
+		grammarBuilder.append("    | expression '>=' expression                            # doGreatherEqual\n");
+		grammarBuilder.append("    | expression '<' expression                             # doLesser\n");
+		grammarBuilder.append("    | expression '<=' expression                            # doLesserEqual\n");
+		grammarBuilder.append("    | expression K_IN '(' expression (',' expression)* ')'  # doIn\n");
+		grammarBuilder.append("    | expression ( '&' | K_AND) expression                  # doAnd\n");
+		grammarBuilder.append("    | expression ( '|' | K_OR) expression                   # doOr\n");
+		grammarBuilder.append("    | '[' expression (',' expression)* ']'                  # newArray\n");
+		grammarBuilder.append("    | K_TRUE                                                # newTrueBoolean\n");
+		grammarBuilder.append("    | K_FALSE                                               # newFalseBoolean\n");
+		grammarBuilder.append("    | NUMBER                                                # newNumber\n");
+		grammarBuilder.append("    | DATE                                                  # newDateTime\n");
+		grammarBuilder.append("    | ID                                                    # newIdentifier\n");
+		grammarBuilder.append("    | SQ_STRING                                             # newString\n");
+		grammarBuilder.append("    | K_NULL                                                # newNull\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("// Fragments\n");
+		grammarBuilder.append("fragment DIGIT    : '0' .. '9';  \n");
+		grammarBuilder.append("fragment UPPER    : 'A' .. 'Z';\n");
+		grammarBuilder.append("fragment LOWER    : 'a' .. 'z';\n");
+		grammarBuilder.append("fragment LETTER   : LOWER | UPPER;\n");
+		grammarBuilder.append("fragment WORD     : LETTER | '_' | '$' | '#' | '.';\n");
+		grammarBuilder.append("fragment ALPHANUM : WORD | DIGIT;  \n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("// Tokens\n");
+		grammarBuilder.append("ID              : LETTER ALPHANUM*;\n");
+		grammarBuilder.append("NUMBER          : DIGIT+ ('.' DIGIT+)? (('e'|'E')('+'|'-')? DIGIT+)?;\n");
+		grammarBuilder.append("DATE            : '\\'' DIGIT DIGIT DIGIT DIGIT '-' DIGIT DIGIT '-' DIGIT DIGIT (' ' DIGIT DIGIT ':' DIGIT DIGIT ':' DIGIT DIGIT ('.' DIGIT+)?)? '\\'';\n");
+		grammarBuilder.append("SQ_STRING       : '\\'' ('\\'\\'' | ~'\\'')* '\\'';\n");
+		grammarBuilder.append("DQ_STRING       : '\"' ('\\\\\"' | ~'\"')* '\"';\n");
+		grammarBuilder.append("WS              : [ \\t\\n\\r]+ -> skip ;\n");
+		grammarBuilder.append("COMMENTS        : ('/*' .*? '*/' | '//' ~'\\n'* '\\n' ) -> skip;");
+		String grammar = grammarBuilder.toString();
+		String input ="Test(1, 3)";
+		String found = execParser("Expr.g4", grammar, "ExprParser", "ExprLexer",
+		                          "ExprListener", "ExprVisitor",
+		                          "prog", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+}
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/node/TestLexerErrors.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/node/TestLexerErrors.java
new file mode 100644
index 000000000..7ab3cfddd
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/node/TestLexerErrors.java
@@ -0,0 +1,235 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.javascript.node;
+
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+@SuppressWarnings("unused")
+public class TestLexerErrors extends BaseTest {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDFAToATNThatFailsBackToDFA() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(39);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : 'ab' ;\n");
+		grammarBuilder.append("B : 'abc' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="ababx";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:1='ab',<1>,1:0]\n" +
+			"[@1,2:3='ab',<1>,1:2]\n" +
+			"[@2,5:4='<EOF>',<-1>,1:5]\n", found);
+
+		assertEquals("line 1:4 token recognition error at: 'x'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDFAToATNThatMatchesThenFailsInATN() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(52);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : 'ab' ;\n");
+		grammarBuilder.append("B : 'abc' ;\n");
+		grammarBuilder.append("C : 'abcd' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="ababcx";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:1='ab',<1>,1:0]\n" +
+			"[@1,2:4='abc',<2>,1:2]\n" +
+			"[@2,6:5='<EOF>',<-1>,1:6]\n", found);
+
+		assertEquals("line 1:5 token recognition error at: 'x'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testEnforcedGreedyNestedBrances_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(77);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("ACTION : '{' (ACTION | ~[{}])* '}';\n");
+		grammarBuilder.append("WS : [ \\r\\n\\t]+ -> skip;");
+		String grammar = grammarBuilder.toString();
+		String input ="{ { } }";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:6='{ { } }',<1>,1:0]\n" +
+			"[@1,7:6='<EOF>',<-1>,1:7]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testEnforcedGreedyNestedBrances_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(77);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("ACTION : '{' (ACTION | ~[{}])* '}';\n");
+		grammarBuilder.append("WS : [ \\r\\n\\t]+ -> skip;");
+		String grammar = grammarBuilder.toString();
+		String input ="{ { }";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals("[@0,5:4='<EOF>',<-1>,1:5]\n", found);
+
+		assertEquals("line 1:0 token recognition error at: '{ { }'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testErrorInMiddle() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(28);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : 'abc' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="abx";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals("[@0,3:2='<EOF>',<-1>,1:3]\n", found);
+
+		assertEquals("line 1:0 token recognition error at: 'abx'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testInvalidCharAtStart() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(30);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : 'a' 'b' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals("[@0,1:0='<EOF>',<-1>,1:1]\n", found);
+
+		assertEquals("line 1:0 token recognition error at: 'x'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testInvalidCharAtStartAfterDFACache() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(30);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : 'a' 'b' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="abx";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:1='ab',<1>,1:0]\n" +
+			"[@1,3:2='<EOF>',<-1>,1:3]\n", found);
+
+		assertEquals("line 1:2 token recognition error at: 'x'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testInvalidCharInToken() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(30);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : 'a' 'b' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="ax";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals("[@0,2:1='<EOF>',<-1>,1:2]\n", found);
+
+		assertEquals("line 1:0 token recognition error at: 'ax'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testInvalidCharInTokenAfterDFACache() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(30);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : 'a' 'b' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="abax";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:1='ab',<1>,1:0]\n" +
+			"[@1,4:3='<EOF>',<-1>,1:4]\n", found);
+
+		assertEquals("line 1:2 token recognition error at: 'ax'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLexerExecDFA() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(98);
+		grammarBuilder.append("grammar L;\n");
+		grammarBuilder.append("start : ID ':' expr;\n");
+		grammarBuilder.append("expr : primary expr? {} | expr '->' ID;\n");
+		grammarBuilder.append("primary : ID;\n");
+		grammarBuilder.append("ID : [a-z]+;");
+		String grammar = grammarBuilder.toString();
+		String input ="x : x";
+		String found = execLexer("L.g4", grammar, "LLexer", input, false);
+		assertEquals(
+			"[@0,0:0='x',<3>,1:0]\n" +
+			"[@1,2:2=':',<1>,1:2]\n" +
+			"[@2,4:4='x',<3>,1:4]\n" +
+			"[@3,5:4='<EOF>',<-1>,1:5]\n", found);
+
+		assertEquals(
+			"line 1:1 token recognition error at: ' '\n" +
+			"line 1:3 token recognition error at: ' '\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testStringsEmbeddedInActions_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(109);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("ACTION2 : '[' (STRING | ~'\"')*? ']';\n");
+		grammarBuilder.append("STRING : '\"' ('\\\"' | .)*? '\"';\n");
+		grammarBuilder.append("WS : [ \\t\\r\\n]+ -> skip;");
+		String grammar = grammarBuilder.toString();
+		String input ="[\"foo\"]";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:6='[\"foo\"]',<1>,1:0]\n" +
+			"[@1,7:6='<EOF>',<-1>,1:7]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testStringsEmbeddedInActions_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(109);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("ACTION2 : '[' (STRING | ~'\"')*? ']';\n");
+		grammarBuilder.append("STRING : '\"' ('\\\"' | .)*? '\"';\n");
+		grammarBuilder.append("WS : [ \\t\\r\\n]+ -> skip;");
+		String grammar = grammarBuilder.toString();
+		String input ="[\"foo]";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals("[@0,6:5='<EOF>',<-1>,1:6]\n", found);
+
+		assertEquals("line 1:0 token recognition error at: '[\"foo]'\n", this.stderrDuringParse);
+
+	}
+
+}
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/node/TestLexerExec.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/node/TestLexerExec.java
new file mode 100644
index 000000000..7b353bea7
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/node/TestLexerExec.java
@@ -0,0 +1,4935 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.javascript.node;
+
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+@SuppressWarnings("unused")
+public class TestLexerExec extends BaseTest {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testActionPlacement() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(263);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("I : ({console.log(\"stuff fail: \" + this.text);} 'a'\n");
+		grammarBuilder.append("| {console.log(\"stuff0: \" + this.text);}\n");
+		grammarBuilder.append("		'a' {console.log(\"stuff1: \" + this.text);}\n");
+		grammarBuilder.append("		'b' {console.log(\"stuff2: \" + this.text);})\n");
+		grammarBuilder.append("		{console.log(this.text);} ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;\n");
+		grammarBuilder.append("J : .;");
+		String grammar = grammarBuilder.toString();
+		String input ="ab";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"stuff0: \n" +
+			"stuff1: a\n" +
+			"stuff2: ab\n" +
+			"ab\n" +
+			"[@0,0:1='ab',<1>,1:0]\n" +
+			"[@1,2:1='<EOF>',<-1>,1:2]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(79);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("I : '0'..'9'+ {console.log(\"I\");} ;\n");
+		grammarBuilder.append("WS : [ \\n\\u000D] -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input =
+			"34\n" +
+			" 34";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"I\n" +
+			"I\n" +
+			"[@0,0:1='34',<1>,1:0]\n" +
+			"[@1,4:5='34',<1>,2:1]\n" +
+			"[@2,6:5='<EOF>',<-1>,2:3]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetInSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(86);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("I : (~[ab \\n]|'a')  {console.log(\"I\");} ;\n");
+		grammarBuilder.append("WS : [ \\n\\u000D]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a x";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"I\n" +
+			"I\n" +
+			"[@0,0:0='a',<1>,1:0]\n" +
+			"[@1,2:2='x',<1>,1:2]\n" +
+			"[@2,3:2='<EOF>',<-1>,1:3]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetNot() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(89);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("I : ~[ab \\n] ~[ \\ncd]* {console.log(\"I\");} ;\n");
+		grammarBuilder.append("WS : [ \\n\\u000D]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="xaf";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"I\n" +
+			"[@0,0:2='xaf',<1>,1:0]\n" +
+			"[@1,3:2='<EOF>',<-1>,1:3]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetPlus() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(80);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("I : '0'..'9'+ {console.log(\"I\");} ;\n");
+		grammarBuilder.append("WS : [ \\n\\u000D]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input =
+			"34\n" +
+			" 34";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"I\n" +
+			"I\n" +
+			"[@0,0:1='34',<1>,1:0]\n" +
+			"[@1,4:5='34',<1>,2:1]\n" +
+			"[@2,6:5='<EOF>',<-1>,2:3]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetRange() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(129);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("I : [0-9]+ {console.log(\"I\");} ;\n");
+		grammarBuilder.append("ID : [a-zA-Z] [a-zA-Z0-9]* {console.log(\"ID\");} ;\n");
+		grammarBuilder.append("WS : [ \\n\\u0009\\r]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input =
+			"34\n" +
+			" 34 a2 abc \n" +
+			"   ";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"I\n" +
+			"I\n" +
+			"ID\n" +
+			"ID\n" +
+			"[@0,0:1='34',<1>,1:0]\n" +
+			"[@1,4:5='34',<1>,2:1]\n" +
+			"[@2,7:8='a2',<2>,2:4]\n" +
+			"[@3,10:12='abc',<2>,2:7]\n" +
+			"[@4,18:17='<EOF>',<-1>,3:3]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetWithEscapedChar() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(88);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("DASHBRACK : [\\-\\]]+ {console.log(\"DASHBRACK\");} ;\n");
+		grammarBuilder.append("WS : [ \\u]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="- ] ";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"DASHBRACK\n" +
+			"DASHBRACK\n" +
+			"[@0,0:0='-',<1>,1:0]\n" +
+			"[@1,2:2=']',<1>,1:2]\n" +
+			"[@2,4:3='<EOF>',<-1>,1:4]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetWithMissingEndRange() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(76);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("I : [0-]+ {console.log(\"I\");} ;\n");
+		grammarBuilder.append("WS : [ \\n\\u000D]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="00\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"I\n" +
+			"[@0,0:1='00',<1>,1:0]\n" +
+			"[@1,3:2='<EOF>',<-1>,2:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetWithMissingEscapeChar() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(71);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("I : [0-9]+ {console.log(\"I\");} ;\n");
+		grammarBuilder.append("WS : [ \\u]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="34 ";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"I\n" +
+			"[@0,0:1='34',<1>,1:0]\n" +
+			"[@1,3:2='<EOF>',<-1>,1:3]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetWithQuote1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(74);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : [\"a-z]+ {console.log(\"A\");} ;\n");
+		grammarBuilder.append("WS : [ \\n\\t]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="b\"a";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"A\n" +
+			"[@0,0:2='b\"a',<1>,1:0]\n" +
+			"[@1,3:2='<EOF>',<-1>,1:3]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetWithQuote2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(75);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : [\"\\\\ab]+ {console.log(\"A\");} ;\n");
+		grammarBuilder.append("WS : [ \\n\\t]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="b\"\\a";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"A\n" +
+			"[@0,0:3='b\"\\a',<1>,1:0]\n" +
+			"[@1,4:3='<EOF>',<-1>,1:4]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetWithReversedRange() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(72);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : [z-a9]+ {console.log(\"A\");} ;\n");
+		grammarBuilder.append("WS : [ \\u]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="9";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"A\n" +
+			"[@0,0:0='9',<1>,1:0]\n" +
+			"[@1,1:0='<EOF>',<-1>,1:1]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testEOFByItself() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(38);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("DONE : EOF ;\n");
+		grammarBuilder.append("A : 'a';");
+		String grammar = grammarBuilder.toString();
+		String input ="";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:-1='<EOF>',<1>,1:0]\n" +
+			"[@1,0:-1='<EOF>',<-1>,1:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testEOFSuffixInFirstRule_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(48);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : 'a' EOF ;\n");
+		grammarBuilder.append("B : 'a';\n");
+		grammarBuilder.append("C : 'c';");
+		String grammar = grammarBuilder.toString();
+		String input ="";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals("[@0,0:-1='<EOF>',<-1>,1:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testEOFSuffixInFirstRule_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(48);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : 'a' EOF ;\n");
+		grammarBuilder.append("B : 'a';\n");
+		grammarBuilder.append("C : 'c';");
+		String grammar = grammarBuilder.toString();
+		String input ="a";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:0='a',<1>,1:0]\n" +
+			"[@1,1:0='<EOF>',<-1>,1:1]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testGreedyClosure() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(60);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("CMT : '//' .*? '\\n' CMT*;\n");
+		grammarBuilder.append("WS : (' '|'\\t')+;");
+		String grammar = grammarBuilder.toString();
+		String input =
+			"//blah\n" +
+			"//blah\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:13='//blah\\n//blah\\n',<1>,1:0]\n" +
+			"[@1,14:13='<EOF>',<-1>,3:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testGreedyConfigs() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(94);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("I : ('a' | 'ab') {console.log(this.text);} ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;\n");
+		grammarBuilder.append("J : .;");
+		String grammar = grammarBuilder.toString();
+		String input ="ab";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"ab\n" +
+			"[@0,0:1='ab',<1>,1:0]\n" +
+			"[@1,2:1='<EOF>',<-1>,1:2]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testGreedyOptional() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(60);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("CMT : '//' .*? '\\n' CMT?;\n");
+		grammarBuilder.append("WS : (' '|'\\t')+;");
+		String grammar = grammarBuilder.toString();
+		String input =
+			"//blah\n" +
+			"//blah\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:13='//blah\\n//blah\\n',<1>,1:0]\n" +
+			"[@1,14:13='<EOF>',<-1>,3:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testGreedyPositiveClosure() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(58);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("CMT : ('//' .*? '\\n')+;\n");
+		grammarBuilder.append("WS : (' '|'\\t')+;");
+		String grammar = grammarBuilder.toString();
+		String input =
+			"//blah\n" +
+			"//blah\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:13='//blah\\n//blah\\n',<1>,1:0]\n" +
+			"[@1,14:13='<EOF>',<-1>,3:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testHexVsID() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(265);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("HexLiteral : '0' ('x'|'X') HexDigit+ ;\n");
+		grammarBuilder.append("DecimalLiteral : ('0' | '1'..'9' '0'..'9'*) ;\n");
+		grammarBuilder.append("FloatingPointLiteral : ('0x' | '0X') HexDigit* ('.' HexDigit*)? ;\n");
+		grammarBuilder.append("DOT : '.' ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("fragment HexDigit : ('0'..'9'|'a'..'f'|'A'..'F') ;\n");
+		grammarBuilder.append("WS : (' '|'\\n')+;");
+		String grammar = grammarBuilder.toString();
+		String input ="x 0 1 a.b a.l";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:0='x',<5>,1:0]\n" +
+			"[@1,1:1=' ',<6>,1:1]\n" +
+			"[@2,2:2='0',<2>,1:2]\n" +
+			"[@3,3:3=' ',<6>,1:3]\n" +
+			"[@4,4:4='1',<2>,1:4]\n" +
+			"[@5,5:5=' ',<6>,1:5]\n" +
+			"[@6,6:6='a',<5>,1:6]\n" +
+			"[@7,7:7='.',<4>,1:7]\n" +
+			"[@8,8:8='b',<5>,1:8]\n" +
+			"[@9,9:9=' ',<6>,1:9]\n" +
+			"[@10,10:10='a',<5>,1:10]\n" +
+			"[@11,11:11='.',<4>,1:11]\n" +
+			"[@12,12:12='l',<5>,1:12]\n" +
+			"[@13,13:12='<EOF>',<-1>,1:13]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testKeywordID() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(82);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("KEND : 'end' ; // has priority\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n')+;");
+		String grammar = grammarBuilder.toString();
+		String input ="end eend ending a";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:2='end',<1>,1:0]\n" +
+			"[@1,3:3=' ',<3>,1:3]\n" +
+			"[@2,4:7='eend',<2>,1:4]\n" +
+			"[@3,8:8=' ',<3>,1:8]\n" +
+			"[@4,9:14='ending',<2>,1:9]\n" +
+			"[@5,15:15=' ',<3>,1:15]\n" +
+			"[@6,16:16='a',<2>,1:16]\n" +
+			"[@7,17:16='<EOF>',<-1>,1:17]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLargeLexer() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(85821);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("WS : [ \\t\\r\\n]+ -> skip;\n");
+		grammarBuilder.append("KW0 : 'KW' '0';\n");
+		grammarBuilder.append("KW1 : 'KW' '1';\n");
+		grammarBuilder.append("KW2 : 'KW' '2';\n");
+		grammarBuilder.append("KW3 : 'KW' '3';\n");
+		grammarBuilder.append("KW4 : 'KW' '4';\n");
+		grammarBuilder.append("KW5 : 'KW' '5';\n");
+		grammarBuilder.append("KW6 : 'KW' '6';\n");
+		grammarBuilder.append("KW7 : 'KW' '7';\n");
+		grammarBuilder.append("KW8 : 'KW' '8';\n");
+		grammarBuilder.append("KW9 : 'KW' '9';\n");
+		grammarBuilder.append("KW10 : 'KW' '10';\n");
+		grammarBuilder.append("KW11 : 'KW' '11';\n");
+		grammarBuilder.append("KW12 : 'KW' '12';\n");
+		grammarBuilder.append("KW13 : 'KW' '13';\n");
+		grammarBuilder.append("KW14 : 'KW' '14';\n");
+		grammarBuilder.append("KW15 : 'KW' '15';\n");
+		grammarBuilder.append("KW16 : 'KW' '16';\n");
+		grammarBuilder.append("KW17 : 'KW' '17';\n");
+		grammarBuilder.append("KW18 : 'KW' '18';\n");
+		grammarBuilder.append("KW19 : 'KW' '19';\n");
+		grammarBuilder.append("KW20 : 'KW' '20';\n");
+		grammarBuilder.append("KW21 : 'KW' '21';\n");
+		grammarBuilder.append("KW22 : 'KW' '22';\n");
+		grammarBuilder.append("KW23 : 'KW' '23';\n");
+		grammarBuilder.append("KW24 : 'KW' '24';\n");
+		grammarBuilder.append("KW25 : 'KW' '25';\n");
+		grammarBuilder.append("KW26 : 'KW' '26';\n");
+		grammarBuilder.append("KW27 : 'KW' '27';\n");
+		grammarBuilder.append("KW28 : 'KW' '28';\n");
+		grammarBuilder.append("KW29 : 'KW' '29';\n");
+		grammarBuilder.append("KW30 : 'KW' '30';\n");
+		grammarBuilder.append("KW31 : 'KW' '31';\n");
+		grammarBuilder.append("KW32 : 'KW' '32';\n");
+		grammarBuilder.append("KW33 : 'KW' '33';\n");
+		grammarBuilder.append("KW34 : 'KW' '34';\n");
+		grammarBuilder.append("KW35 : 'KW' '35';\n");
+		grammarBuilder.append("KW36 : 'KW' '36';\n");
+		grammarBuilder.append("KW37 : 'KW' '37';\n");
+		grammarBuilder.append("KW38 : 'KW' '38';\n");
+		grammarBuilder.append("KW39 : 'KW' '39';\n");
+		grammarBuilder.append("KW40 : 'KW' '40';\n");
+		grammarBuilder.append("KW41 : 'KW' '41';\n");
+		grammarBuilder.append("KW42 : 'KW' '42';\n");
+		grammarBuilder.append("KW43 : 'KW' '43';\n");
+		grammarBuilder.append("KW44 : 'KW' '44';\n");
+		grammarBuilder.append("KW45 : 'KW' '45';\n");
+		grammarBuilder.append("KW46 : 'KW' '46';\n");
+		grammarBuilder.append("KW47 : 'KW' '47';\n");
+		grammarBuilder.append("KW48 : 'KW' '48';\n");
+		grammarBuilder.append("KW49 : 'KW' '49';\n");
+		grammarBuilder.append("KW50 : 'KW' '50';\n");
+		grammarBuilder.append("KW51 : 'KW' '51';\n");
+		grammarBuilder.append("KW52 : 'KW' '52';\n");
+		grammarBuilder.append("KW53 : 'KW' '53';\n");
+		grammarBuilder.append("KW54 : 'KW' '54';\n");
+		grammarBuilder.append("KW55 : 'KW' '55';\n");
+		grammarBuilder.append("KW56 : 'KW' '56';\n");
+		grammarBuilder.append("KW57 : 'KW' '57';\n");
+		grammarBuilder.append("KW58 : 'KW' '58';\n");
+		grammarBuilder.append("KW59 : 'KW' '59';\n");
+		grammarBuilder.append("KW60 : 'KW' '60';\n");
+		grammarBuilder.append("KW61 : 'KW' '61';\n");
+		grammarBuilder.append("KW62 : 'KW' '62';\n");
+		grammarBuilder.append("KW63 : 'KW' '63';\n");
+		grammarBuilder.append("KW64 : 'KW' '64';\n");
+		grammarBuilder.append("KW65 : 'KW' '65';\n");
+		grammarBuilder.append("KW66 : 'KW' '66';\n");
+		grammarBuilder.append("KW67 : 'KW' '67';\n");
+		grammarBuilder.append("KW68 : 'KW' '68';\n");
+		grammarBuilder.append("KW69 : 'KW' '69';\n");
+		grammarBuilder.append("KW70 : 'KW' '70';\n");
+		grammarBuilder.append("KW71 : 'KW' '71';\n");
+		grammarBuilder.append("KW72 : 'KW' '72';\n");
+		grammarBuilder.append("KW73 : 'KW' '73';\n");
+		grammarBuilder.append("KW74 : 'KW' '74';\n");
+		grammarBuilder.append("KW75 : 'KW' '75';\n");
+		grammarBuilder.append("KW76 : 'KW' '76';\n");
+		grammarBuilder.append("KW77 : 'KW' '77';\n");
+		grammarBuilder.append("KW78 : 'KW' '78';\n");
+		grammarBuilder.append("KW79 : 'KW' '79';\n");
+		grammarBuilder.append("KW80 : 'KW' '80';\n");
+		grammarBuilder.append("KW81 : 'KW' '81';\n");
+		grammarBuilder.append("KW82 : 'KW' '82';\n");
+		grammarBuilder.append("KW83 : 'KW' '83';\n");
+		grammarBuilder.append("KW84 : 'KW' '84';\n");
+		grammarBuilder.append("KW85 : 'KW' '85';\n");
+		grammarBuilder.append("KW86 : 'KW' '86';\n");
+		grammarBuilder.append("KW87 : 'KW' '87';\n");
+		grammarBuilder.append("KW88 : 'KW' '88';\n");
+		grammarBuilder.append("KW89 : 'KW' '89';\n");
+		grammarBuilder.append("KW90 : 'KW' '90';\n");
+		grammarBuilder.append("KW91 : 'KW' '91';\n");
+		grammarBuilder.append("KW92 : 'KW' '92';\n");
+		grammarBuilder.append("KW93 : 'KW' '93';\n");
+		grammarBuilder.append("KW94 : 'KW' '94';\n");
+		grammarBuilder.append("KW95 : 'KW' '95';\n");
+		grammarBuilder.append("KW96 : 'KW' '96';\n");
+		grammarBuilder.append("KW97 : 'KW' '97';\n");
+		grammarBuilder.append("KW98 : 'KW' '98';\n");
+		grammarBuilder.append("KW99 : 'KW' '99';\n");
+		grammarBuilder.append("KW100 : 'KW' '100';\n");
+		grammarBuilder.append("KW101 : 'KW' '101';\n");
+		grammarBuilder.append("KW102 : 'KW' '102';\n");
+		grammarBuilder.append("KW103 : 'KW' '103';\n");
+		grammarBuilder.append("KW104 : 'KW' '104';\n");
+		grammarBuilder.append("KW105 : 'KW' '105';\n");
+		grammarBuilder.append("KW106 : 'KW' '106';\n");
+		grammarBuilder.append("KW107 : 'KW' '107';\n");
+		grammarBuilder.append("KW108 : 'KW' '108';\n");
+		grammarBuilder.append("KW109 : 'KW' '109';\n");
+		grammarBuilder.append("KW110 : 'KW' '110';\n");
+		grammarBuilder.append("KW111 : 'KW' '111';\n");
+		grammarBuilder.append("KW112 : 'KW' '112';\n");
+		grammarBuilder.append("KW113 : 'KW' '113';\n");
+		grammarBuilder.append("KW114 : 'KW' '114';\n");
+		grammarBuilder.append("KW115 : 'KW' '115';\n");
+		grammarBuilder.append("KW116 : 'KW' '116';\n");
+		grammarBuilder.append("KW117 : 'KW' '117';\n");
+		grammarBuilder.append("KW118 : 'KW' '118';\n");
+		grammarBuilder.append("KW119 : 'KW' '119';\n");
+		grammarBuilder.append("KW120 : 'KW' '120';\n");
+		grammarBuilder.append("KW121 : 'KW' '121';\n");
+		grammarBuilder.append("KW122 : 'KW' '122';\n");
+		grammarBuilder.append("KW123 : 'KW' '123';\n");
+		grammarBuilder.append("KW124 : 'KW' '124';\n");
+		grammarBuilder.append("KW125 : 'KW' '125';\n");
+		grammarBuilder.append("KW126 : 'KW' '126';\n");
+		grammarBuilder.append("KW127 : 'KW' '127';\n");
+		grammarBuilder.append("KW128 : 'KW' '128';\n");
+		grammarBuilder.append("KW129 : 'KW' '129';\n");
+		grammarBuilder.append("KW130 : 'KW' '130';\n");
+		grammarBuilder.append("KW131 : 'KW' '131';\n");
+		grammarBuilder.append("KW132 : 'KW' '132';\n");
+		grammarBuilder.append("KW133 : 'KW' '133';\n");
+		grammarBuilder.append("KW134 : 'KW' '134';\n");
+		grammarBuilder.append("KW135 : 'KW' '135';\n");
+		grammarBuilder.append("KW136 : 'KW' '136';\n");
+		grammarBuilder.append("KW137 : 'KW' '137';\n");
+		grammarBuilder.append("KW138 : 'KW' '138';\n");
+		grammarBuilder.append("KW139 : 'KW' '139';\n");
+		grammarBuilder.append("KW140 : 'KW' '140';\n");
+		grammarBuilder.append("KW141 : 'KW' '141';\n");
+		grammarBuilder.append("KW142 : 'KW' '142';\n");
+		grammarBuilder.append("KW143 : 'KW' '143';\n");
+		grammarBuilder.append("KW144 : 'KW' '144';\n");
+		grammarBuilder.append("KW145 : 'KW' '145';\n");
+		grammarBuilder.append("KW146 : 'KW' '146';\n");
+		grammarBuilder.append("KW147 : 'KW' '147';\n");
+		grammarBuilder.append("KW148 : 'KW' '148';\n");
+		grammarBuilder.append("KW149 : 'KW' '149';\n");
+		grammarBuilder.append("KW150 : 'KW' '150';\n");
+		grammarBuilder.append("KW151 : 'KW' '151';\n");
+		grammarBuilder.append("KW152 : 'KW' '152';\n");
+		grammarBuilder.append("KW153 : 'KW' '153';\n");
+		grammarBuilder.append("KW154 : 'KW' '154';\n");
+		grammarBuilder.append("KW155 : 'KW' '155';\n");
+		grammarBuilder.append("KW156 : 'KW' '156';\n");
+		grammarBuilder.append("KW157 : 'KW' '157';\n");
+		grammarBuilder.append("KW158 : 'KW' '158';\n");
+		grammarBuilder.append("KW159 : 'KW' '159';\n");
+		grammarBuilder.append("KW160 : 'KW' '160';\n");
+		grammarBuilder.append("KW161 : 'KW' '161';\n");
+		grammarBuilder.append("KW162 : 'KW' '162';\n");
+		grammarBuilder.append("KW163 : 'KW' '163';\n");
+		grammarBuilder.append("KW164 : 'KW' '164';\n");
+		grammarBuilder.append("KW165 : 'KW' '165';\n");
+		grammarBuilder.append("KW166 : 'KW' '166';\n");
+		grammarBuilder.append("KW167 : 'KW' '167';\n");
+		grammarBuilder.append("KW168 : 'KW' '168';\n");
+		grammarBuilder.append("KW169 : 'KW' '169';\n");
+		grammarBuilder.append("KW170 : 'KW' '170';\n");
+		grammarBuilder.append("KW171 : 'KW' '171';\n");
+		grammarBuilder.append("KW172 : 'KW' '172';\n");
+		grammarBuilder.append("KW173 : 'KW' '173';\n");
+		grammarBuilder.append("KW174 : 'KW' '174';\n");
+		grammarBuilder.append("KW175 : 'KW' '175';\n");
+		grammarBuilder.append("KW176 : 'KW' '176';\n");
+		grammarBuilder.append("KW177 : 'KW' '177';\n");
+		grammarBuilder.append("KW178 : 'KW' '178';\n");
+		grammarBuilder.append("KW179 : 'KW' '179';\n");
+		grammarBuilder.append("KW180 : 'KW' '180';\n");
+		grammarBuilder.append("KW181 : 'KW' '181';\n");
+		grammarBuilder.append("KW182 : 'KW' '182';\n");
+		grammarBuilder.append("KW183 : 'KW' '183';\n");
+		grammarBuilder.append("KW184 : 'KW' '184';\n");
+		grammarBuilder.append("KW185 : 'KW' '185';\n");
+		grammarBuilder.append("KW186 : 'KW' '186';\n");
+		grammarBuilder.append("KW187 : 'KW' '187';\n");
+		grammarBuilder.append("KW188 : 'KW' '188';\n");
+		grammarBuilder.append("KW189 : 'KW' '189';\n");
+		grammarBuilder.append("KW190 : 'KW' '190';\n");
+		grammarBuilder.append("KW191 : 'KW' '191';\n");
+		grammarBuilder.append("KW192 : 'KW' '192';\n");
+		grammarBuilder.append("KW193 : 'KW' '193';\n");
+		grammarBuilder.append("KW194 : 'KW' '194';\n");
+		grammarBuilder.append("KW195 : 'KW' '195';\n");
+		grammarBuilder.append("KW196 : 'KW' '196';\n");
+		grammarBuilder.append("KW197 : 'KW' '197';\n");
+		grammarBuilder.append("KW198 : 'KW' '198';\n");
+		grammarBuilder.append("KW199 : 'KW' '199';\n");
+		grammarBuilder.append("KW200 : 'KW' '200';\n");
+		grammarBuilder.append("KW201 : 'KW' '201';\n");
+		grammarBuilder.append("KW202 : 'KW' '202';\n");
+		grammarBuilder.append("KW203 : 'KW' '203';\n");
+		grammarBuilder.append("KW204 : 'KW' '204';\n");
+		grammarBuilder.append("KW205 : 'KW' '205';\n");
+		grammarBuilder.append("KW206 : 'KW' '206';\n");
+		grammarBuilder.append("KW207 : 'KW' '207';\n");
+		grammarBuilder.append("KW208 : 'KW' '208';\n");
+		grammarBuilder.append("KW209 : 'KW' '209';\n");
+		grammarBuilder.append("KW210 : 'KW' '210';\n");
+		grammarBuilder.append("KW211 : 'KW' '211';\n");
+		grammarBuilder.append("KW212 : 'KW' '212';\n");
+		grammarBuilder.append("KW213 : 'KW' '213';\n");
+		grammarBuilder.append("KW214 : 'KW' '214';\n");
+		grammarBuilder.append("KW215 : 'KW' '215';\n");
+		grammarBuilder.append("KW216 : 'KW' '216';\n");
+		grammarBuilder.append("KW217 : 'KW' '217';\n");
+		grammarBuilder.append("KW218 : 'KW' '218';\n");
+		grammarBuilder.append("KW219 : 'KW' '219';\n");
+		grammarBuilder.append("KW220 : 'KW' '220';\n");
+		grammarBuilder.append("KW221 : 'KW' '221';\n");
+		grammarBuilder.append("KW222 : 'KW' '222';\n");
+		grammarBuilder.append("KW223 : 'KW' '223';\n");
+		grammarBuilder.append("KW224 : 'KW' '224';\n");
+		grammarBuilder.append("KW225 : 'KW' '225';\n");
+		grammarBuilder.append("KW226 : 'KW' '226';\n");
+		grammarBuilder.append("KW227 : 'KW' '227';\n");
+		grammarBuilder.append("KW228 : 'KW' '228';\n");
+		grammarBuilder.append("KW229 : 'KW' '229';\n");
+		grammarBuilder.append("KW230 : 'KW' '230';\n");
+		grammarBuilder.append("KW231 : 'KW' '231';\n");
+		grammarBuilder.append("KW232 : 'KW' '232';\n");
+		grammarBuilder.append("KW233 : 'KW' '233';\n");
+		grammarBuilder.append("KW234 : 'KW' '234';\n");
+		grammarBuilder.append("KW235 : 'KW' '235';\n");
+		grammarBuilder.append("KW236 : 'KW' '236';\n");
+		grammarBuilder.append("KW237 : 'KW' '237';\n");
+		grammarBuilder.append("KW238 : 'KW' '238';\n");
+		grammarBuilder.append("KW239 : 'KW' '239';\n");
+		grammarBuilder.append("KW240 : 'KW' '240';\n");
+		grammarBuilder.append("KW241 : 'KW' '241';\n");
+		grammarBuilder.append("KW242 : 'KW' '242';\n");
+		grammarBuilder.append("KW243 : 'KW' '243';\n");
+		grammarBuilder.append("KW244 : 'KW' '244';\n");
+		grammarBuilder.append("KW245 : 'KW' '245';\n");
+		grammarBuilder.append("KW246 : 'KW' '246';\n");
+		grammarBuilder.append("KW247 : 'KW' '247';\n");
+		grammarBuilder.append("KW248 : 'KW' '248';\n");
+		grammarBuilder.append("KW249 : 'KW' '249';\n");
+		grammarBuilder.append("KW250 : 'KW' '250';\n");
+		grammarBuilder.append("KW251 : 'KW' '251';\n");
+		grammarBuilder.append("KW252 : 'KW' '252';\n");
+		grammarBuilder.append("KW253 : 'KW' '253';\n");
+		grammarBuilder.append("KW254 : 'KW' '254';\n");
+		grammarBuilder.append("KW255 : 'KW' '255';\n");
+		grammarBuilder.append("KW256 : 'KW' '256';\n");
+		grammarBuilder.append("KW257 : 'KW' '257';\n");
+		grammarBuilder.append("KW258 : 'KW' '258';\n");
+		grammarBuilder.append("KW259 : 'KW' '259';\n");
+		grammarBuilder.append("KW260 : 'KW' '260';\n");
+		grammarBuilder.append("KW261 : 'KW' '261';\n");
+		grammarBuilder.append("KW262 : 'KW' '262';\n");
+		grammarBuilder.append("KW263 : 'KW' '263';\n");
+		grammarBuilder.append("KW264 : 'KW' '264';\n");
+		grammarBuilder.append("KW265 : 'KW' '265';\n");
+		grammarBuilder.append("KW266 : 'KW' '266';\n");
+		grammarBuilder.append("KW267 : 'KW' '267';\n");
+		grammarBuilder.append("KW268 : 'KW' '268';\n");
+		grammarBuilder.append("KW269 : 'KW' '269';\n");
+		grammarBuilder.append("KW270 : 'KW' '270';\n");
+		grammarBuilder.append("KW271 : 'KW' '271';\n");
+		grammarBuilder.append("KW272 : 'KW' '272';\n");
+		grammarBuilder.append("KW273 : 'KW' '273';\n");
+		grammarBuilder.append("KW274 : 'KW' '274';\n");
+		grammarBuilder.append("KW275 : 'KW' '275';\n");
+		grammarBuilder.append("KW276 : 'KW' '276';\n");
+		grammarBuilder.append("KW277 : 'KW' '277';\n");
+		grammarBuilder.append("KW278 : 'KW' '278';\n");
+		grammarBuilder.append("KW279 : 'KW' '279';\n");
+		grammarBuilder.append("KW280 : 'KW' '280';\n");
+		grammarBuilder.append("KW281 : 'KW' '281';\n");
+		grammarBuilder.append("KW282 : 'KW' '282';\n");
+		grammarBuilder.append("KW283 : 'KW' '283';\n");
+		grammarBuilder.append("KW284 : 'KW' '284';\n");
+		grammarBuilder.append("KW285 : 'KW' '285';\n");
+		grammarBuilder.append("KW286 : 'KW' '286';\n");
+		grammarBuilder.append("KW287 : 'KW' '287';\n");
+		grammarBuilder.append("KW288 : 'KW' '288';\n");
+		grammarBuilder.append("KW289 : 'KW' '289';\n");
+		grammarBuilder.append("KW290 : 'KW' '290';\n");
+		grammarBuilder.append("KW291 : 'KW' '291';\n");
+		grammarBuilder.append("KW292 : 'KW' '292';\n");
+		grammarBuilder.append("KW293 : 'KW' '293';\n");
+		grammarBuilder.append("KW294 : 'KW' '294';\n");
+		grammarBuilder.append("KW295 : 'KW' '295';\n");
+		grammarBuilder.append("KW296 : 'KW' '296';\n");
+		grammarBuilder.append("KW297 : 'KW' '297';\n");
+		grammarBuilder.append("KW298 : 'KW' '298';\n");
+		grammarBuilder.append("KW299 : 'KW' '299';\n");
+		grammarBuilder.append("KW300 : 'KW' '300';\n");
+		grammarBuilder.append("KW301 : 'KW' '301';\n");
+		grammarBuilder.append("KW302 : 'KW' '302';\n");
+		grammarBuilder.append("KW303 : 'KW' '303';\n");
+		grammarBuilder.append("KW304 : 'KW' '304';\n");
+		grammarBuilder.append("KW305 : 'KW' '305';\n");
+		grammarBuilder.append("KW306 : 'KW' '306';\n");
+		grammarBuilder.append("KW307 : 'KW' '307';\n");
+		grammarBuilder.append("KW308 : 'KW' '308';\n");
+		grammarBuilder.append("KW309 : 'KW' '309';\n");
+		grammarBuilder.append("KW310 : 'KW' '310';\n");
+		grammarBuilder.append("KW311 : 'KW' '311';\n");
+		grammarBuilder.append("KW312 : 'KW' '312';\n");
+		grammarBuilder.append("KW313 : 'KW' '313';\n");
+		grammarBuilder.append("KW314 : 'KW' '314';\n");
+		grammarBuilder.append("KW315 : 'KW' '315';\n");
+		grammarBuilder.append("KW316 : 'KW' '316';\n");
+		grammarBuilder.append("KW317 : 'KW' '317';\n");
+		grammarBuilder.append("KW318 : 'KW' '318';\n");
+		grammarBuilder.append("KW319 : 'KW' '319';\n");
+		grammarBuilder.append("KW320 : 'KW' '320';\n");
+		grammarBuilder.append("KW321 : 'KW' '321';\n");
+		grammarBuilder.append("KW322 : 'KW' '322';\n");
+		grammarBuilder.append("KW323 : 'KW' '323';\n");
+		grammarBuilder.append("KW324 : 'KW' '324';\n");
+		grammarBuilder.append("KW325 : 'KW' '325';\n");
+		grammarBuilder.append("KW326 : 'KW' '326';\n");
+		grammarBuilder.append("KW327 : 'KW' '327';\n");
+		grammarBuilder.append("KW328 : 'KW' '328';\n");
+		grammarBuilder.append("KW329 : 'KW' '329';\n");
+		grammarBuilder.append("KW330 : 'KW' '330';\n");
+		grammarBuilder.append("KW331 : 'KW' '331';\n");
+		grammarBuilder.append("KW332 : 'KW' '332';\n");
+		grammarBuilder.append("KW333 : 'KW' '333';\n");
+		grammarBuilder.append("KW334 : 'KW' '334';\n");
+		grammarBuilder.append("KW335 : 'KW' '335';\n");
+		grammarBuilder.append("KW336 : 'KW' '336';\n");
+		grammarBuilder.append("KW337 : 'KW' '337';\n");
+		grammarBuilder.append("KW338 : 'KW' '338';\n");
+		grammarBuilder.append("KW339 : 'KW' '339';\n");
+		grammarBuilder.append("KW340 : 'KW' '340';\n");
+		grammarBuilder.append("KW341 : 'KW' '341';\n");
+		grammarBuilder.append("KW342 : 'KW' '342';\n");
+		grammarBuilder.append("KW343 : 'KW' '343';\n");
+		grammarBuilder.append("KW344 : 'KW' '344';\n");
+		grammarBuilder.append("KW345 : 'KW' '345';\n");
+		grammarBuilder.append("KW346 : 'KW' '346';\n");
+		grammarBuilder.append("KW347 : 'KW' '347';\n");
+		grammarBuilder.append("KW348 : 'KW' '348';\n");
+		grammarBuilder.append("KW349 : 'KW' '349';\n");
+		grammarBuilder.append("KW350 : 'KW' '350';\n");
+		grammarBuilder.append("KW351 : 'KW' '351';\n");
+		grammarBuilder.append("KW352 : 'KW' '352';\n");
+		grammarBuilder.append("KW353 : 'KW' '353';\n");
+		grammarBuilder.append("KW354 : 'KW' '354';\n");
+		grammarBuilder.append("KW355 : 'KW' '355';\n");
+		grammarBuilder.append("KW356 : 'KW' '356';\n");
+		grammarBuilder.append("KW357 : 'KW' '357';\n");
+		grammarBuilder.append("KW358 : 'KW' '358';\n");
+		grammarBuilder.append("KW359 : 'KW' '359';\n");
+		grammarBuilder.append("KW360 : 'KW' '360';\n");
+		grammarBuilder.append("KW361 : 'KW' '361';\n");
+		grammarBuilder.append("KW362 : 'KW' '362';\n");
+		grammarBuilder.append("KW363 : 'KW' '363';\n");
+		grammarBuilder.append("KW364 : 'KW' '364';\n");
+		grammarBuilder.append("KW365 : 'KW' '365';\n");
+		grammarBuilder.append("KW366 : 'KW' '366';\n");
+		grammarBuilder.append("KW367 : 'KW' '367';\n");
+		grammarBuilder.append("KW368 : 'KW' '368';\n");
+		grammarBuilder.append("KW369 : 'KW' '369';\n");
+		grammarBuilder.append("KW370 : 'KW' '370';\n");
+		grammarBuilder.append("KW371 : 'KW' '371';\n");
+		grammarBuilder.append("KW372 : 'KW' '372';\n");
+		grammarBuilder.append("KW373 : 'KW' '373';\n");
+		grammarBuilder.append("KW374 : 'KW' '374';\n");
+		grammarBuilder.append("KW375 : 'KW' '375';\n");
+		grammarBuilder.append("KW376 : 'KW' '376';\n");
+		grammarBuilder.append("KW377 : 'KW' '377';\n");
+		grammarBuilder.append("KW378 : 'KW' '378';\n");
+		grammarBuilder.append("KW379 : 'KW' '379';\n");
+		grammarBuilder.append("KW380 : 'KW' '380';\n");
+		grammarBuilder.append("KW381 : 'KW' '381';\n");
+		grammarBuilder.append("KW382 : 'KW' '382';\n");
+		grammarBuilder.append("KW383 : 'KW' '383';\n");
+		grammarBuilder.append("KW384 : 'KW' '384';\n");
+		grammarBuilder.append("KW385 : 'KW' '385';\n");
+		grammarBuilder.append("KW386 : 'KW' '386';\n");
+		grammarBuilder.append("KW387 : 'KW' '387';\n");
+		grammarBuilder.append("KW388 : 'KW' '388';\n");
+		grammarBuilder.append("KW389 : 'KW' '389';\n");
+		grammarBuilder.append("KW390 : 'KW' '390';\n");
+		grammarBuilder.append("KW391 : 'KW' '391';\n");
+		grammarBuilder.append("KW392 : 'KW' '392';\n");
+		grammarBuilder.append("KW393 : 'KW' '393';\n");
+		grammarBuilder.append("KW394 : 'KW' '394';\n");
+		grammarBuilder.append("KW395 : 'KW' '395';\n");
+		grammarBuilder.append("KW396 : 'KW' '396';\n");
+		grammarBuilder.append("KW397 : 'KW' '397';\n");
+		grammarBuilder.append("KW398 : 'KW' '398';\n");
+		grammarBuilder.append("KW399 : 'KW' '399';\n");
+		grammarBuilder.append("KW400 : 'KW' '400';\n");
+		grammarBuilder.append("KW401 : 'KW' '401';\n");
+		grammarBuilder.append("KW402 : 'KW' '402';\n");
+		grammarBuilder.append("KW403 : 'KW' '403';\n");
+		grammarBuilder.append("KW404 : 'KW' '404';\n");
+		grammarBuilder.append("KW405 : 'KW' '405';\n");
+		grammarBuilder.append("KW406 : 'KW' '406';\n");
+		grammarBuilder.append("KW407 : 'KW' '407';\n");
+		grammarBuilder.append("KW408 : 'KW' '408';\n");
+		grammarBuilder.append("KW409 : 'KW' '409';\n");
+		grammarBuilder.append("KW410 : 'KW' '410';\n");
+		grammarBuilder.append("KW411 : 'KW' '411';\n");
+		grammarBuilder.append("KW412 : 'KW' '412';\n");
+		grammarBuilder.append("KW413 : 'KW' '413';\n");
+		grammarBuilder.append("KW414 : 'KW' '414';\n");
+		grammarBuilder.append("KW415 : 'KW' '415';\n");
+		grammarBuilder.append("KW416 : 'KW' '416';\n");
+		grammarBuilder.append("KW417 : 'KW' '417';\n");
+		grammarBuilder.append("KW418 : 'KW' '418';\n");
+		grammarBuilder.append("KW419 : 'KW' '419';\n");
+		grammarBuilder.append("KW420 : 'KW' '420';\n");
+		grammarBuilder.append("KW421 : 'KW' '421';\n");
+		grammarBuilder.append("KW422 : 'KW' '422';\n");
+		grammarBuilder.append("KW423 : 'KW' '423';\n");
+		grammarBuilder.append("KW424 : 'KW' '424';\n");
+		grammarBuilder.append("KW425 : 'KW' '425';\n");
+		grammarBuilder.append("KW426 : 'KW' '426';\n");
+		grammarBuilder.append("KW427 : 'KW' '427';\n");
+		grammarBuilder.append("KW428 : 'KW' '428';\n");
+		grammarBuilder.append("KW429 : 'KW' '429';\n");
+		grammarBuilder.append("KW430 : 'KW' '430';\n");
+		grammarBuilder.append("KW431 : 'KW' '431';\n");
+		grammarBuilder.append("KW432 : 'KW' '432';\n");
+		grammarBuilder.append("KW433 : 'KW' '433';\n");
+		grammarBuilder.append("KW434 : 'KW' '434';\n");
+		grammarBuilder.append("KW435 : 'KW' '435';\n");
+		grammarBuilder.append("KW436 : 'KW' '436';\n");
+		grammarBuilder.append("KW437 : 'KW' '437';\n");
+		grammarBuilder.append("KW438 : 'KW' '438';\n");
+		grammarBuilder.append("KW439 : 'KW' '439';\n");
+		grammarBuilder.append("KW440 : 'KW' '440';\n");
+		grammarBuilder.append("KW441 : 'KW' '441';\n");
+		grammarBuilder.append("KW442 : 'KW' '442';\n");
+		grammarBuilder.append("KW443 : 'KW' '443';\n");
+		grammarBuilder.append("KW444 : 'KW' '444';\n");
+		grammarBuilder.append("KW445 : 'KW' '445';\n");
+		grammarBuilder.append("KW446 : 'KW' '446';\n");
+		grammarBuilder.append("KW447 : 'KW' '447';\n");
+		grammarBuilder.append("KW448 : 'KW' '448';\n");
+		grammarBuilder.append("KW449 : 'KW' '449';\n");
+		grammarBuilder.append("KW450 : 'KW' '450';\n");
+		grammarBuilder.append("KW451 : 'KW' '451';\n");
+		grammarBuilder.append("KW452 : 'KW' '452';\n");
+		grammarBuilder.append("KW453 : 'KW' '453';\n");
+		grammarBuilder.append("KW454 : 'KW' '454';\n");
+		grammarBuilder.append("KW455 : 'KW' '455';\n");
+		grammarBuilder.append("KW456 : 'KW' '456';\n");
+		grammarBuilder.append("KW457 : 'KW' '457';\n");
+		grammarBuilder.append("KW458 : 'KW' '458';\n");
+		grammarBuilder.append("KW459 : 'KW' '459';\n");
+		grammarBuilder.append("KW460 : 'KW' '460';\n");
+		grammarBuilder.append("KW461 : 'KW' '461';\n");
+		grammarBuilder.append("KW462 : 'KW' '462';\n");
+		grammarBuilder.append("KW463 : 'KW' '463';\n");
+		grammarBuilder.append("KW464 : 'KW' '464';\n");
+		grammarBuilder.append("KW465 : 'KW' '465';\n");
+		grammarBuilder.append("KW466 : 'KW' '466';\n");
+		grammarBuilder.append("KW467 : 'KW' '467';\n");
+		grammarBuilder.append("KW468 : 'KW' '468';\n");
+		grammarBuilder.append("KW469 : 'KW' '469';\n");
+		grammarBuilder.append("KW470 : 'KW' '470';\n");
+		grammarBuilder.append("KW471 : 'KW' '471';\n");
+		grammarBuilder.append("KW472 : 'KW' '472';\n");
+		grammarBuilder.append("KW473 : 'KW' '473';\n");
+		grammarBuilder.append("KW474 : 'KW' '474';\n");
+		grammarBuilder.append("KW475 : 'KW' '475';\n");
+		grammarBuilder.append("KW476 : 'KW' '476';\n");
+		grammarBuilder.append("KW477 : 'KW' '477';\n");
+		grammarBuilder.append("KW478 : 'KW' '478';\n");
+		grammarBuilder.append("KW479 : 'KW' '479';\n");
+		grammarBuilder.append("KW480 : 'KW' '480';\n");
+		grammarBuilder.append("KW481 : 'KW' '481';\n");
+		grammarBuilder.append("KW482 : 'KW' '482';\n");
+		grammarBuilder.append("KW483 : 'KW' '483';\n");
+		grammarBuilder.append("KW484 : 'KW' '484';\n");
+		grammarBuilder.append("KW485 : 'KW' '485';\n");
+		grammarBuilder.append("KW486 : 'KW' '486';\n");
+		grammarBuilder.append("KW487 : 'KW' '487';\n");
+		grammarBuilder.append("KW488 : 'KW' '488';\n");
+		grammarBuilder.append("KW489 : 'KW' '489';\n");
+		grammarBuilder.append("KW490 : 'KW' '490';\n");
+		grammarBuilder.append("KW491 : 'KW' '491';\n");
+		grammarBuilder.append("KW492 : 'KW' '492';\n");
+		grammarBuilder.append("KW493 : 'KW' '493';\n");
+		grammarBuilder.append("KW494 : 'KW' '494';\n");
+		grammarBuilder.append("KW495 : 'KW' '495';\n");
+		grammarBuilder.append("KW496 : 'KW' '496';\n");
+		grammarBuilder.append("KW497 : 'KW' '497';\n");
+		grammarBuilder.append("KW498 : 'KW' '498';\n");
+		grammarBuilder.append("KW499 : 'KW' '499';\n");
+		grammarBuilder.append("KW500 : 'KW' '500';\n");
+		grammarBuilder.append("KW501 : 'KW' '501';\n");
+		grammarBuilder.append("KW502 : 'KW' '502';\n");
+		grammarBuilder.append("KW503 : 'KW' '503';\n");
+		grammarBuilder.append("KW504 : 'KW' '504';\n");
+		grammarBuilder.append("KW505 : 'KW' '505';\n");
+		grammarBuilder.append("KW506 : 'KW' '506';\n");
+		grammarBuilder.append("KW507 : 'KW' '507';\n");
+		grammarBuilder.append("KW508 : 'KW' '508';\n");
+		grammarBuilder.append("KW509 : 'KW' '509';\n");
+		grammarBuilder.append("KW510 : 'KW' '510';\n");
+		grammarBuilder.append("KW511 : 'KW' '511';\n");
+		grammarBuilder.append("KW512 : 'KW' '512';\n");
+		grammarBuilder.append("KW513 : 'KW' '513';\n");
+		grammarBuilder.append("KW514 : 'KW' '514';\n");
+		grammarBuilder.append("KW515 : 'KW' '515';\n");
+		grammarBuilder.append("KW516 : 'KW' '516';\n");
+		grammarBuilder.append("KW517 : 'KW' '517';\n");
+		grammarBuilder.append("KW518 : 'KW' '518';\n");
+		grammarBuilder.append("KW519 : 'KW' '519';\n");
+		grammarBuilder.append("KW520 : 'KW' '520';\n");
+		grammarBuilder.append("KW521 : 'KW' '521';\n");
+		grammarBuilder.append("KW522 : 'KW' '522';\n");
+		grammarBuilder.append("KW523 : 'KW' '523';\n");
+		grammarBuilder.append("KW524 : 'KW' '524';\n");
+		grammarBuilder.append("KW525 : 'KW' '525';\n");
+		grammarBuilder.append("KW526 : 'KW' '526';\n");
+		grammarBuilder.append("KW527 : 'KW' '527';\n");
+		grammarBuilder.append("KW528 : 'KW' '528';\n");
+		grammarBuilder.append("KW529 : 'KW' '529';\n");
+		grammarBuilder.append("KW530 : 'KW' '530';\n");
+		grammarBuilder.append("KW531 : 'KW' '531';\n");
+		grammarBuilder.append("KW532 : 'KW' '532';\n");
+		grammarBuilder.append("KW533 : 'KW' '533';\n");
+		grammarBuilder.append("KW534 : 'KW' '534';\n");
+		grammarBuilder.append("KW535 : 'KW' '535';\n");
+		grammarBuilder.append("KW536 : 'KW' '536';\n");
+		grammarBuilder.append("KW537 : 'KW' '537';\n");
+		grammarBuilder.append("KW538 : 'KW' '538';\n");
+		grammarBuilder.append("KW539 : 'KW' '539';\n");
+		grammarBuilder.append("KW540 : 'KW' '540';\n");
+		grammarBuilder.append("KW541 : 'KW' '541';\n");
+		grammarBuilder.append("KW542 : 'KW' '542';\n");
+		grammarBuilder.append("KW543 : 'KW' '543';\n");
+		grammarBuilder.append("KW544 : 'KW' '544';\n");
+		grammarBuilder.append("KW545 : 'KW' '545';\n");
+		grammarBuilder.append("KW546 : 'KW' '546';\n");
+		grammarBuilder.append("KW547 : 'KW' '547';\n");
+		grammarBuilder.append("KW548 : 'KW' '548';\n");
+		grammarBuilder.append("KW549 : 'KW' '549';\n");
+		grammarBuilder.append("KW550 : 'KW' '550';\n");
+		grammarBuilder.append("KW551 : 'KW' '551';\n");
+		grammarBuilder.append("KW552 : 'KW' '552';\n");
+		grammarBuilder.append("KW553 : 'KW' '553';\n");
+		grammarBuilder.append("KW554 : 'KW' '554';\n");
+		grammarBuilder.append("KW555 : 'KW' '555';\n");
+		grammarBuilder.append("KW556 : 'KW' '556';\n");
+		grammarBuilder.append("KW557 : 'KW' '557';\n");
+		grammarBuilder.append("KW558 : 'KW' '558';\n");
+		grammarBuilder.append("KW559 : 'KW' '559';\n");
+		grammarBuilder.append("KW560 : 'KW' '560';\n");
+		grammarBuilder.append("KW561 : 'KW' '561';\n");
+		grammarBuilder.append("KW562 : 'KW' '562';\n");
+		grammarBuilder.append("KW563 : 'KW' '563';\n");
+		grammarBuilder.append("KW564 : 'KW' '564';\n");
+		grammarBuilder.append("KW565 : 'KW' '565';\n");
+		grammarBuilder.append("KW566 : 'KW' '566';\n");
+		grammarBuilder.append("KW567 : 'KW' '567';\n");
+		grammarBuilder.append("KW568 : 'KW' '568';\n");
+		grammarBuilder.append("KW569 : 'KW' '569';\n");
+		grammarBuilder.append("KW570 : 'KW' '570';\n");
+		grammarBuilder.append("KW571 : 'KW' '571';\n");
+		grammarBuilder.append("KW572 : 'KW' '572';\n");
+		grammarBuilder.append("KW573 : 'KW' '573';\n");
+		grammarBuilder.append("KW574 : 'KW' '574';\n");
+		grammarBuilder.append("KW575 : 'KW' '575';\n");
+		grammarBuilder.append("KW576 : 'KW' '576';\n");
+		grammarBuilder.append("KW577 : 'KW' '577';\n");
+		grammarBuilder.append("KW578 : 'KW' '578';\n");
+		grammarBuilder.append("KW579 : 'KW' '579';\n");
+		grammarBuilder.append("KW580 : 'KW' '580';\n");
+		grammarBuilder.append("KW581 : 'KW' '581';\n");
+		grammarBuilder.append("KW582 : 'KW' '582';\n");
+		grammarBuilder.append("KW583 : 'KW' '583';\n");
+		grammarBuilder.append("KW584 : 'KW' '584';\n");
+		grammarBuilder.append("KW585 : 'KW' '585';\n");
+		grammarBuilder.append("KW586 : 'KW' '586';\n");
+		grammarBuilder.append("KW587 : 'KW' '587';\n");
+		grammarBuilder.append("KW588 : 'KW' '588';\n");
+		grammarBuilder.append("KW589 : 'KW' '589';\n");
+		grammarBuilder.append("KW590 : 'KW' '590';\n");
+		grammarBuilder.append("KW591 : 'KW' '591';\n");
+		grammarBuilder.append("KW592 : 'KW' '592';\n");
+		grammarBuilder.append("KW593 : 'KW' '593';\n");
+		grammarBuilder.append("KW594 : 'KW' '594';\n");
+		grammarBuilder.append("KW595 : 'KW' '595';\n");
+		grammarBuilder.append("KW596 : 'KW' '596';\n");
+		grammarBuilder.append("KW597 : 'KW' '597';\n");
+		grammarBuilder.append("KW598 : 'KW' '598';\n");
+		grammarBuilder.append("KW599 : 'KW' '599';\n");
+		grammarBuilder.append("KW600 : 'KW' '600';\n");
+		grammarBuilder.append("KW601 : 'KW' '601';\n");
+		grammarBuilder.append("KW602 : 'KW' '602';\n");
+		grammarBuilder.append("KW603 : 'KW' '603';\n");
+		grammarBuilder.append("KW604 : 'KW' '604';\n");
+		grammarBuilder.append("KW605 : 'KW' '605';\n");
+		grammarBuilder.append("KW606 : 'KW' '606';\n");
+		grammarBuilder.append("KW607 : 'KW' '607';\n");
+		grammarBuilder.append("KW608 : 'KW' '608';\n");
+		grammarBuilder.append("KW609 : 'KW' '609';\n");
+		grammarBuilder.append("KW610 : 'KW' '610';\n");
+		grammarBuilder.append("KW611 : 'KW' '611';\n");
+		grammarBuilder.append("KW612 : 'KW' '612';\n");
+		grammarBuilder.append("KW613 : 'KW' '613';\n");
+		grammarBuilder.append("KW614 : 'KW' '614';\n");
+		grammarBuilder.append("KW615 : 'KW' '615';\n");
+		grammarBuilder.append("KW616 : 'KW' '616';\n");
+		grammarBuilder.append("KW617 : 'KW' '617';\n");
+		grammarBuilder.append("KW618 : 'KW' '618';\n");
+		grammarBuilder.append("KW619 : 'KW' '619';\n");
+		grammarBuilder.append("KW620 : 'KW' '620';\n");
+		grammarBuilder.append("KW621 : 'KW' '621';\n");
+		grammarBuilder.append("KW622 : 'KW' '622';\n");
+		grammarBuilder.append("KW623 : 'KW' '623';\n");
+		grammarBuilder.append("KW624 : 'KW' '624';\n");
+		grammarBuilder.append("KW625 : 'KW' '625';\n");
+		grammarBuilder.append("KW626 : 'KW' '626';\n");
+		grammarBuilder.append("KW627 : 'KW' '627';\n");
+		grammarBuilder.append("KW628 : 'KW' '628';\n");
+		grammarBuilder.append("KW629 : 'KW' '629';\n");
+		grammarBuilder.append("KW630 : 'KW' '630';\n");
+		grammarBuilder.append("KW631 : 'KW' '631';\n");
+		grammarBuilder.append("KW632 : 'KW' '632';\n");
+		grammarBuilder.append("KW633 : 'KW' '633';\n");
+		grammarBuilder.append("KW634 : 'KW' '634';\n");
+		grammarBuilder.append("KW635 : 'KW' '635';\n");
+		grammarBuilder.append("KW636 : 'KW' '636';\n");
+		grammarBuilder.append("KW637 : 'KW' '637';\n");
+		grammarBuilder.append("KW638 : 'KW' '638';\n");
+		grammarBuilder.append("KW639 : 'KW' '639';\n");
+		grammarBuilder.append("KW640 : 'KW' '640';\n");
+		grammarBuilder.append("KW641 : 'KW' '641';\n");
+		grammarBuilder.append("KW642 : 'KW' '642';\n");
+		grammarBuilder.append("KW643 : 'KW' '643';\n");
+		grammarBuilder.append("KW644 : 'KW' '644';\n");
+		grammarBuilder.append("KW645 : 'KW' '645';\n");
+		grammarBuilder.append("KW646 : 'KW' '646';\n");
+		grammarBuilder.append("KW647 : 'KW' '647';\n");
+		grammarBuilder.append("KW648 : 'KW' '648';\n");
+		grammarBuilder.append("KW649 : 'KW' '649';\n");
+		grammarBuilder.append("KW650 : 'KW' '650';\n");
+		grammarBuilder.append("KW651 : 'KW' '651';\n");
+		grammarBuilder.append("KW652 : 'KW' '652';\n");
+		grammarBuilder.append("KW653 : 'KW' '653';\n");
+		grammarBuilder.append("KW654 : 'KW' '654';\n");
+		grammarBuilder.append("KW655 : 'KW' '655';\n");
+		grammarBuilder.append("KW656 : 'KW' '656';\n");
+		grammarBuilder.append("KW657 : 'KW' '657';\n");
+		grammarBuilder.append("KW658 : 'KW' '658';\n");
+		grammarBuilder.append("KW659 : 'KW' '659';\n");
+		grammarBuilder.append("KW660 : 'KW' '660';\n");
+		grammarBuilder.append("KW661 : 'KW' '661';\n");
+		grammarBuilder.append("KW662 : 'KW' '662';\n");
+		grammarBuilder.append("KW663 : 'KW' '663';\n");
+		grammarBuilder.append("KW664 : 'KW' '664';\n");
+		grammarBuilder.append("KW665 : 'KW' '665';\n");
+		grammarBuilder.append("KW666 : 'KW' '666';\n");
+		grammarBuilder.append("KW667 : 'KW' '667';\n");
+		grammarBuilder.append("KW668 : 'KW' '668';\n");
+		grammarBuilder.append("KW669 : 'KW' '669';\n");
+		grammarBuilder.append("KW670 : 'KW' '670';\n");
+		grammarBuilder.append("KW671 : 'KW' '671';\n");
+		grammarBuilder.append("KW672 : 'KW' '672';\n");
+		grammarBuilder.append("KW673 : 'KW' '673';\n");
+		grammarBuilder.append("KW674 : 'KW' '674';\n");
+		grammarBuilder.append("KW675 : 'KW' '675';\n");
+		grammarBuilder.append("KW676 : 'KW' '676';\n");
+		grammarBuilder.append("KW677 : 'KW' '677';\n");
+		grammarBuilder.append("KW678 : 'KW' '678';\n");
+		grammarBuilder.append("KW679 : 'KW' '679';\n");
+		grammarBuilder.append("KW680 : 'KW' '680';\n");
+		grammarBuilder.append("KW681 : 'KW' '681';\n");
+		grammarBuilder.append("KW682 : 'KW' '682';\n");
+		grammarBuilder.append("KW683 : 'KW' '683';\n");
+		grammarBuilder.append("KW684 : 'KW' '684';\n");
+		grammarBuilder.append("KW685 : 'KW' '685';\n");
+		grammarBuilder.append("KW686 : 'KW' '686';\n");
+		grammarBuilder.append("KW687 : 'KW' '687';\n");
+		grammarBuilder.append("KW688 : 'KW' '688';\n");
+		grammarBuilder.append("KW689 : 'KW' '689';\n");
+		grammarBuilder.append("KW690 : 'KW' '690';\n");
+		grammarBuilder.append("KW691 : 'KW' '691';\n");
+		grammarBuilder.append("KW692 : 'KW' '692';\n");
+		grammarBuilder.append("KW693 : 'KW' '693';\n");
+		grammarBuilder.append("KW694 : 'KW' '694';\n");
+		grammarBuilder.append("KW695 : 'KW' '695';\n");
+		grammarBuilder.append("KW696 : 'KW' '696';\n");
+		grammarBuilder.append("KW697 : 'KW' '697';\n");
+		grammarBuilder.append("KW698 : 'KW' '698';\n");
+		grammarBuilder.append("KW699 : 'KW' '699';\n");
+		grammarBuilder.append("KW700 : 'KW' '700';\n");
+		grammarBuilder.append("KW701 : 'KW' '701';\n");
+		grammarBuilder.append("KW702 : 'KW' '702';\n");
+		grammarBuilder.append("KW703 : 'KW' '703';\n");
+		grammarBuilder.append("KW704 : 'KW' '704';\n");
+		grammarBuilder.append("KW705 : 'KW' '705';\n");
+		grammarBuilder.append("KW706 : 'KW' '706';\n");
+		grammarBuilder.append("KW707 : 'KW' '707';\n");
+		grammarBuilder.append("KW708 : 'KW' '708';\n");
+		grammarBuilder.append("KW709 : 'KW' '709';\n");
+		grammarBuilder.append("KW710 : 'KW' '710';\n");
+		grammarBuilder.append("KW711 : 'KW' '711';\n");
+		grammarBuilder.append("KW712 : 'KW' '712';\n");
+		grammarBuilder.append("KW713 : 'KW' '713';\n");
+		grammarBuilder.append("KW714 : 'KW' '714';\n");
+		grammarBuilder.append("KW715 : 'KW' '715';\n");
+		grammarBuilder.append("KW716 : 'KW' '716';\n");
+		grammarBuilder.append("KW717 : 'KW' '717';\n");
+		grammarBuilder.append("KW718 : 'KW' '718';\n");
+		grammarBuilder.append("KW719 : 'KW' '719';\n");
+		grammarBuilder.append("KW720 : 'KW' '720';\n");
+		grammarBuilder.append("KW721 : 'KW' '721';\n");
+		grammarBuilder.append("KW722 : 'KW' '722';\n");
+		grammarBuilder.append("KW723 : 'KW' '723';\n");
+		grammarBuilder.append("KW724 : 'KW' '724';\n");
+		grammarBuilder.append("KW725 : 'KW' '725';\n");
+		grammarBuilder.append("KW726 : 'KW' '726';\n");
+		grammarBuilder.append("KW727 : 'KW' '727';\n");
+		grammarBuilder.append("KW728 : 'KW' '728';\n");
+		grammarBuilder.append("KW729 : 'KW' '729';\n");
+		grammarBuilder.append("KW730 : 'KW' '730';\n");
+		grammarBuilder.append("KW731 : 'KW' '731';\n");
+		grammarBuilder.append("KW732 : 'KW' '732';\n");
+		grammarBuilder.append("KW733 : 'KW' '733';\n");
+		grammarBuilder.append("KW734 : 'KW' '734';\n");
+		grammarBuilder.append("KW735 : 'KW' '735';\n");
+		grammarBuilder.append("KW736 : 'KW' '736';\n");
+		grammarBuilder.append("KW737 : 'KW' '737';\n");
+		grammarBuilder.append("KW738 : 'KW' '738';\n");
+		grammarBuilder.append("KW739 : 'KW' '739';\n");
+		grammarBuilder.append("KW740 : 'KW' '740';\n");
+		grammarBuilder.append("KW741 : 'KW' '741';\n");
+		grammarBuilder.append("KW742 : 'KW' '742';\n");
+		grammarBuilder.append("KW743 : 'KW' '743';\n");
+		grammarBuilder.append("KW744 : 'KW' '744';\n");
+		grammarBuilder.append("KW745 : 'KW' '745';\n");
+		grammarBuilder.append("KW746 : 'KW' '746';\n");
+		grammarBuilder.append("KW747 : 'KW' '747';\n");
+		grammarBuilder.append("KW748 : 'KW' '748';\n");
+		grammarBuilder.append("KW749 : 'KW' '749';\n");
+		grammarBuilder.append("KW750 : 'KW' '750';\n");
+		grammarBuilder.append("KW751 : 'KW' '751';\n");
+		grammarBuilder.append("KW752 : 'KW' '752';\n");
+		grammarBuilder.append("KW753 : 'KW' '753';\n");
+		grammarBuilder.append("KW754 : 'KW' '754';\n");
+		grammarBuilder.append("KW755 : 'KW' '755';\n");
+		grammarBuilder.append("KW756 : 'KW' '756';\n");
+		grammarBuilder.append("KW757 : 'KW' '757';\n");
+		grammarBuilder.append("KW758 : 'KW' '758';\n");
+		grammarBuilder.append("KW759 : 'KW' '759';\n");
+		grammarBuilder.append("KW760 : 'KW' '760';\n");
+		grammarBuilder.append("KW761 : 'KW' '761';\n");
+		grammarBuilder.append("KW762 : 'KW' '762';\n");
+		grammarBuilder.append("KW763 : 'KW' '763';\n");
+		grammarBuilder.append("KW764 : 'KW' '764';\n");
+		grammarBuilder.append("KW765 : 'KW' '765';\n");
+		grammarBuilder.append("KW766 : 'KW' '766';\n");
+		grammarBuilder.append("KW767 : 'KW' '767';\n");
+		grammarBuilder.append("KW768 : 'KW' '768';\n");
+		grammarBuilder.append("KW769 : 'KW' '769';\n");
+		grammarBuilder.append("KW770 : 'KW' '770';\n");
+		grammarBuilder.append("KW771 : 'KW' '771';\n");
+		grammarBuilder.append("KW772 : 'KW' '772';\n");
+		grammarBuilder.append("KW773 : 'KW' '773';\n");
+		grammarBuilder.append("KW774 : 'KW' '774';\n");
+		grammarBuilder.append("KW775 : 'KW' '775';\n");
+		grammarBuilder.append("KW776 : 'KW' '776';\n");
+		grammarBuilder.append("KW777 : 'KW' '777';\n");
+		grammarBuilder.append("KW778 : 'KW' '778';\n");
+		grammarBuilder.append("KW779 : 'KW' '779';\n");
+		grammarBuilder.append("KW780 : 'KW' '780';\n");
+		grammarBuilder.append("KW781 : 'KW' '781';\n");
+		grammarBuilder.append("KW782 : 'KW' '782';\n");
+		grammarBuilder.append("KW783 : 'KW' '783';\n");
+		grammarBuilder.append("KW784 : 'KW' '784';\n");
+		grammarBuilder.append("KW785 : 'KW' '785';\n");
+		grammarBuilder.append("KW786 : 'KW' '786';\n");
+		grammarBuilder.append("KW787 : 'KW' '787';\n");
+		grammarBuilder.append("KW788 : 'KW' '788';\n");
+		grammarBuilder.append("KW789 : 'KW' '789';\n");
+		grammarBuilder.append("KW790 : 'KW' '790';\n");
+		grammarBuilder.append("KW791 : 'KW' '791';\n");
+		grammarBuilder.append("KW792 : 'KW' '792';\n");
+		grammarBuilder.append("KW793 : 'KW' '793';\n");
+		grammarBuilder.append("KW794 : 'KW' '794';\n");
+		grammarBuilder.append("KW795 : 'KW' '795';\n");
+		grammarBuilder.append("KW796 : 'KW' '796';\n");
+		grammarBuilder.append("KW797 : 'KW' '797';\n");
+		grammarBuilder.append("KW798 : 'KW' '798';\n");
+		grammarBuilder.append("KW799 : 'KW' '799';\n");
+		grammarBuilder.append("KW800 : 'KW' '800';\n");
+		grammarBuilder.append("KW801 : 'KW' '801';\n");
+		grammarBuilder.append("KW802 : 'KW' '802';\n");
+		grammarBuilder.append("KW803 : 'KW' '803';\n");
+		grammarBuilder.append("KW804 : 'KW' '804';\n");
+		grammarBuilder.append("KW805 : 'KW' '805';\n");
+		grammarBuilder.append("KW806 : 'KW' '806';\n");
+		grammarBuilder.append("KW807 : 'KW' '807';\n");
+		grammarBuilder.append("KW808 : 'KW' '808';\n");
+		grammarBuilder.append("KW809 : 'KW' '809';\n");
+		grammarBuilder.append("KW810 : 'KW' '810';\n");
+		grammarBuilder.append("KW811 : 'KW' '811';\n");
+		grammarBuilder.append("KW812 : 'KW' '812';\n");
+		grammarBuilder.append("KW813 : 'KW' '813';\n");
+		grammarBuilder.append("KW814 : 'KW' '814';\n");
+		grammarBuilder.append("KW815 : 'KW' '815';\n");
+		grammarBuilder.append("KW816 : 'KW' '816';\n");
+		grammarBuilder.append("KW817 : 'KW' '817';\n");
+		grammarBuilder.append("KW818 : 'KW' '818';\n");
+		grammarBuilder.append("KW819 : 'KW' '819';\n");
+		grammarBuilder.append("KW820 : 'KW' '820';\n");
+		grammarBuilder.append("KW821 : 'KW' '821';\n");
+		grammarBuilder.append("KW822 : 'KW' '822';\n");
+		grammarBuilder.append("KW823 : 'KW' '823';\n");
+		grammarBuilder.append("KW824 : 'KW' '824';\n");
+		grammarBuilder.append("KW825 : 'KW' '825';\n");
+		grammarBuilder.append("KW826 : 'KW' '826';\n");
+		grammarBuilder.append("KW827 : 'KW' '827';\n");
+		grammarBuilder.append("KW828 : 'KW' '828';\n");
+		grammarBuilder.append("KW829 : 'KW' '829';\n");
+		grammarBuilder.append("KW830 : 'KW' '830';\n");
+		grammarBuilder.append("KW831 : 'KW' '831';\n");
+		grammarBuilder.append("KW832 : 'KW' '832';\n");
+		grammarBuilder.append("KW833 : 'KW' '833';\n");
+		grammarBuilder.append("KW834 : 'KW' '834';\n");
+		grammarBuilder.append("KW835 : 'KW' '835';\n");
+		grammarBuilder.append("KW836 : 'KW' '836';\n");
+		grammarBuilder.append("KW837 : 'KW' '837';\n");
+		grammarBuilder.append("KW838 : 'KW' '838';\n");
+		grammarBuilder.append("KW839 : 'KW' '839';\n");
+		grammarBuilder.append("KW840 : 'KW' '840';\n");
+		grammarBuilder.append("KW841 : 'KW' '841';\n");
+		grammarBuilder.append("KW842 : 'KW' '842';\n");
+		grammarBuilder.append("KW843 : 'KW' '843';\n");
+		grammarBuilder.append("KW844 : 'KW' '844';\n");
+		grammarBuilder.append("KW845 : 'KW' '845';\n");
+		grammarBuilder.append("KW846 : 'KW' '846';\n");
+		grammarBuilder.append("KW847 : 'KW' '847';\n");
+		grammarBuilder.append("KW848 : 'KW' '848';\n");
+		grammarBuilder.append("KW849 : 'KW' '849';\n");
+		grammarBuilder.append("KW850 : 'KW' '850';\n");
+		grammarBuilder.append("KW851 : 'KW' '851';\n");
+		grammarBuilder.append("KW852 : 'KW' '852';\n");
+		grammarBuilder.append("KW853 : 'KW' '853';\n");
+		grammarBuilder.append("KW854 : 'KW' '854';\n");
+		grammarBuilder.append("KW855 : 'KW' '855';\n");
+		grammarBuilder.append("KW856 : 'KW' '856';\n");
+		grammarBuilder.append("KW857 : 'KW' '857';\n");
+		grammarBuilder.append("KW858 : 'KW' '858';\n");
+		grammarBuilder.append("KW859 : 'KW' '859';\n");
+		grammarBuilder.append("KW860 : 'KW' '860';\n");
+		grammarBuilder.append("KW861 : 'KW' '861';\n");
+		grammarBuilder.append("KW862 : 'KW' '862';\n");
+		grammarBuilder.append("KW863 : 'KW' '863';\n");
+		grammarBuilder.append("KW864 : 'KW' '864';\n");
+		grammarBuilder.append("KW865 : 'KW' '865';\n");
+		grammarBuilder.append("KW866 : 'KW' '866';\n");
+		grammarBuilder.append("KW867 : 'KW' '867';\n");
+		grammarBuilder.append("KW868 : 'KW' '868';\n");
+		grammarBuilder.append("KW869 : 'KW' '869';\n");
+		grammarBuilder.append("KW870 : 'KW' '870';\n");
+		grammarBuilder.append("KW871 : 'KW' '871';\n");
+		grammarBuilder.append("KW872 : 'KW' '872';\n");
+		grammarBuilder.append("KW873 : 'KW' '873';\n");
+		grammarBuilder.append("KW874 : 'KW' '874';\n");
+		grammarBuilder.append("KW875 : 'KW' '875';\n");
+		grammarBuilder.append("KW876 : 'KW' '876';\n");
+		grammarBuilder.append("KW877 : 'KW' '877';\n");
+		grammarBuilder.append("KW878 : 'KW' '878';\n");
+		grammarBuilder.append("KW879 : 'KW' '879';\n");
+		grammarBuilder.append("KW880 : 'KW' '880';\n");
+		grammarBuilder.append("KW881 : 'KW' '881';\n");
+		grammarBuilder.append("KW882 : 'KW' '882';\n");
+		grammarBuilder.append("KW883 : 'KW' '883';\n");
+		grammarBuilder.append("KW884 : 'KW' '884';\n");
+		grammarBuilder.append("KW885 : 'KW' '885';\n");
+		grammarBuilder.append("KW886 : 'KW' '886';\n");
+		grammarBuilder.append("KW887 : 'KW' '887';\n");
+		grammarBuilder.append("KW888 : 'KW' '888';\n");
+		grammarBuilder.append("KW889 : 'KW' '889';\n");
+		grammarBuilder.append("KW890 : 'KW' '890';\n");
+		grammarBuilder.append("KW891 : 'KW' '891';\n");
+		grammarBuilder.append("KW892 : 'KW' '892';\n");
+		grammarBuilder.append("KW893 : 'KW' '893';\n");
+		grammarBuilder.append("KW894 : 'KW' '894';\n");
+		grammarBuilder.append("KW895 : 'KW' '895';\n");
+		grammarBuilder.append("KW896 : 'KW' '896';\n");
+		grammarBuilder.append("KW897 : 'KW' '897';\n");
+		grammarBuilder.append("KW898 : 'KW' '898';\n");
+		grammarBuilder.append("KW899 : 'KW' '899';\n");
+		grammarBuilder.append("KW900 : 'KW' '900';\n");
+		grammarBuilder.append("KW901 : 'KW' '901';\n");
+		grammarBuilder.append("KW902 : 'KW' '902';\n");
+		grammarBuilder.append("KW903 : 'KW' '903';\n");
+		grammarBuilder.append("KW904 : 'KW' '904';\n");
+		grammarBuilder.append("KW905 : 'KW' '905';\n");
+		grammarBuilder.append("KW906 : 'KW' '906';\n");
+		grammarBuilder.append("KW907 : 'KW' '907';\n");
+		grammarBuilder.append("KW908 : 'KW' '908';\n");
+		grammarBuilder.append("KW909 : 'KW' '909';\n");
+		grammarBuilder.append("KW910 : 'KW' '910';\n");
+		grammarBuilder.append("KW911 : 'KW' '911';\n");
+		grammarBuilder.append("KW912 : 'KW' '912';\n");
+		grammarBuilder.append("KW913 : 'KW' '913';\n");
+		grammarBuilder.append("KW914 : 'KW' '914';\n");
+		grammarBuilder.append("KW915 : 'KW' '915';\n");
+		grammarBuilder.append("KW916 : 'KW' '916';\n");
+		grammarBuilder.append("KW917 : 'KW' '917';\n");
+		grammarBuilder.append("KW918 : 'KW' '918';\n");
+		grammarBuilder.append("KW919 : 'KW' '919';\n");
+		grammarBuilder.append("KW920 : 'KW' '920';\n");
+		grammarBuilder.append("KW921 : 'KW' '921';\n");
+		grammarBuilder.append("KW922 : 'KW' '922';\n");
+		grammarBuilder.append("KW923 : 'KW' '923';\n");
+		grammarBuilder.append("KW924 : 'KW' '924';\n");
+		grammarBuilder.append("KW925 : 'KW' '925';\n");
+		grammarBuilder.append("KW926 : 'KW' '926';\n");
+		grammarBuilder.append("KW927 : 'KW' '927';\n");
+		grammarBuilder.append("KW928 : 'KW' '928';\n");
+		grammarBuilder.append("KW929 : 'KW' '929';\n");
+		grammarBuilder.append("KW930 : 'KW' '930';\n");
+		grammarBuilder.append("KW931 : 'KW' '931';\n");
+		grammarBuilder.append("KW932 : 'KW' '932';\n");
+		grammarBuilder.append("KW933 : 'KW' '933';\n");
+		grammarBuilder.append("KW934 : 'KW' '934';\n");
+		grammarBuilder.append("KW935 : 'KW' '935';\n");
+		grammarBuilder.append("KW936 : 'KW' '936';\n");
+		grammarBuilder.append("KW937 : 'KW' '937';\n");
+		grammarBuilder.append("KW938 : 'KW' '938';\n");
+		grammarBuilder.append("KW939 : 'KW' '939';\n");
+		grammarBuilder.append("KW940 : 'KW' '940';\n");
+		grammarBuilder.append("KW941 : 'KW' '941';\n");
+		grammarBuilder.append("KW942 : 'KW' '942';\n");
+		grammarBuilder.append("KW943 : 'KW' '943';\n");
+		grammarBuilder.append("KW944 : 'KW' '944';\n");
+		grammarBuilder.append("KW945 : 'KW' '945';\n");
+		grammarBuilder.append("KW946 : 'KW' '946';\n");
+		grammarBuilder.append("KW947 : 'KW' '947';\n");
+		grammarBuilder.append("KW948 : 'KW' '948';\n");
+		grammarBuilder.append("KW949 : 'KW' '949';\n");
+		grammarBuilder.append("KW950 : 'KW' '950';\n");
+		grammarBuilder.append("KW951 : 'KW' '951';\n");
+		grammarBuilder.append("KW952 : 'KW' '952';\n");
+		grammarBuilder.append("KW953 : 'KW' '953';\n");
+		grammarBuilder.append("KW954 : 'KW' '954';\n");
+		grammarBuilder.append("KW955 : 'KW' '955';\n");
+		grammarBuilder.append("KW956 : 'KW' '956';\n");
+		grammarBuilder.append("KW957 : 'KW' '957';\n");
+		grammarBuilder.append("KW958 : 'KW' '958';\n");
+		grammarBuilder.append("KW959 : 'KW' '959';\n");
+		grammarBuilder.append("KW960 : 'KW' '960';\n");
+		grammarBuilder.append("KW961 : 'KW' '961';\n");
+		grammarBuilder.append("KW962 : 'KW' '962';\n");
+		grammarBuilder.append("KW963 : 'KW' '963';\n");
+		grammarBuilder.append("KW964 : 'KW' '964';\n");
+		grammarBuilder.append("KW965 : 'KW' '965';\n");
+		grammarBuilder.append("KW966 : 'KW' '966';\n");
+		grammarBuilder.append("KW967 : 'KW' '967';\n");
+		grammarBuilder.append("KW968 : 'KW' '968';\n");
+		grammarBuilder.append("KW969 : 'KW' '969';\n");
+		grammarBuilder.append("KW970 : 'KW' '970';\n");
+		grammarBuilder.append("KW971 : 'KW' '971';\n");
+		grammarBuilder.append("KW972 : 'KW' '972';\n");
+		grammarBuilder.append("KW973 : 'KW' '973';\n");
+		grammarBuilder.append("KW974 : 'KW' '974';\n");
+		grammarBuilder.append("KW975 : 'KW' '975';\n");
+		grammarBuilder.append("KW976 : 'KW' '976';\n");
+		grammarBuilder.append("KW977 : 'KW' '977';\n");
+		grammarBuilder.append("KW978 : 'KW' '978';\n");
+		grammarBuilder.append("KW979 : 'KW' '979';\n");
+		grammarBuilder.append("KW980 : 'KW' '980';\n");
+		grammarBuilder.append("KW981 : 'KW' '981';\n");
+		grammarBuilder.append("KW982 : 'KW' '982';\n");
+		grammarBuilder.append("KW983 : 'KW' '983';\n");
+		grammarBuilder.append("KW984 : 'KW' '984';\n");
+		grammarBuilder.append("KW985 : 'KW' '985';\n");
+		grammarBuilder.append("KW986 : 'KW' '986';\n");
+		grammarBuilder.append("KW987 : 'KW' '987';\n");
+		grammarBuilder.append("KW988 : 'KW' '988';\n");
+		grammarBuilder.append("KW989 : 'KW' '989';\n");
+		grammarBuilder.append("KW990 : 'KW' '990';\n");
+		grammarBuilder.append("KW991 : 'KW' '991';\n");
+		grammarBuilder.append("KW992 : 'KW' '992';\n");
+		grammarBuilder.append("KW993 : 'KW' '993';\n");
+		grammarBuilder.append("KW994 : 'KW' '994';\n");
+		grammarBuilder.append("KW995 : 'KW' '995';\n");
+		grammarBuilder.append("KW996 : 'KW' '996';\n");
+		grammarBuilder.append("KW997 : 'KW' '997';\n");
+		grammarBuilder.append("KW998 : 'KW' '998';\n");
+		grammarBuilder.append("KW999 : 'KW' '999';\n");
+		grammarBuilder.append("KW1000 : 'KW' '1000';\n");
+		grammarBuilder.append("KW1001 : 'KW' '1001';\n");
+		grammarBuilder.append("KW1002 : 'KW' '1002';\n");
+		grammarBuilder.append("KW1003 : 'KW' '1003';\n");
+		grammarBuilder.append("KW1004 : 'KW' '1004';\n");
+		grammarBuilder.append("KW1005 : 'KW' '1005';\n");
+		grammarBuilder.append("KW1006 : 'KW' '1006';\n");
+		grammarBuilder.append("KW1007 : 'KW' '1007';\n");
+		grammarBuilder.append("KW1008 : 'KW' '1008';\n");
+		grammarBuilder.append("KW1009 : 'KW' '1009';\n");
+		grammarBuilder.append("KW1010 : 'KW' '1010';\n");
+		grammarBuilder.append("KW1011 : 'KW' '1011';\n");
+		grammarBuilder.append("KW1012 : 'KW' '1012';\n");
+		grammarBuilder.append("KW1013 : 'KW' '1013';\n");
+		grammarBuilder.append("KW1014 : 'KW' '1014';\n");
+		grammarBuilder.append("KW1015 : 'KW' '1015';\n");
+		grammarBuilder.append("KW1016 : 'KW' '1016';\n");
+		grammarBuilder.append("KW1017 : 'KW' '1017';\n");
+		grammarBuilder.append("KW1018 : 'KW' '1018';\n");
+		grammarBuilder.append("KW1019 : 'KW' '1019';\n");
+		grammarBuilder.append("KW1020 : 'KW' '1020';\n");
+		grammarBuilder.append("KW1021 : 'KW' '1021';\n");
+		grammarBuilder.append("KW1022 : 'KW' '1022';\n");
+		grammarBuilder.append("KW1023 : 'KW' '1023';\n");
+		grammarBuilder.append("KW1024 : 'KW' '1024';\n");
+		grammarBuilder.append("KW1025 : 'KW' '1025';\n");
+		grammarBuilder.append("KW1026 : 'KW' '1026';\n");
+		grammarBuilder.append("KW1027 : 'KW' '1027';\n");
+		grammarBuilder.append("KW1028 : 'KW' '1028';\n");
+		grammarBuilder.append("KW1029 : 'KW' '1029';\n");
+		grammarBuilder.append("KW1030 : 'KW' '1030';\n");
+		grammarBuilder.append("KW1031 : 'KW' '1031';\n");
+		grammarBuilder.append("KW1032 : 'KW' '1032';\n");
+		grammarBuilder.append("KW1033 : 'KW' '1033';\n");
+		grammarBuilder.append("KW1034 : 'KW' '1034';\n");
+		grammarBuilder.append("KW1035 : 'KW' '1035';\n");
+		grammarBuilder.append("KW1036 : 'KW' '1036';\n");
+		grammarBuilder.append("KW1037 : 'KW' '1037';\n");
+		grammarBuilder.append("KW1038 : 'KW' '1038';\n");
+		grammarBuilder.append("KW1039 : 'KW' '1039';\n");
+		grammarBuilder.append("KW1040 : 'KW' '1040';\n");
+		grammarBuilder.append("KW1041 : 'KW' '1041';\n");
+		grammarBuilder.append("KW1042 : 'KW' '1042';\n");
+		grammarBuilder.append("KW1043 : 'KW' '1043';\n");
+		grammarBuilder.append("KW1044 : 'KW' '1044';\n");
+		grammarBuilder.append("KW1045 : 'KW' '1045';\n");
+		grammarBuilder.append("KW1046 : 'KW' '1046';\n");
+		grammarBuilder.append("KW1047 : 'KW' '1047';\n");
+		grammarBuilder.append("KW1048 : 'KW' '1048';\n");
+		grammarBuilder.append("KW1049 : 'KW' '1049';\n");
+		grammarBuilder.append("KW1050 : 'KW' '1050';\n");
+		grammarBuilder.append("KW1051 : 'KW' '1051';\n");
+		grammarBuilder.append("KW1052 : 'KW' '1052';\n");
+		grammarBuilder.append("KW1053 : 'KW' '1053';\n");
+		grammarBuilder.append("KW1054 : 'KW' '1054';\n");
+		grammarBuilder.append("KW1055 : 'KW' '1055';\n");
+		grammarBuilder.append("KW1056 : 'KW' '1056';\n");
+		grammarBuilder.append("KW1057 : 'KW' '1057';\n");
+		grammarBuilder.append("KW1058 : 'KW' '1058';\n");
+		grammarBuilder.append("KW1059 : 'KW' '1059';\n");
+		grammarBuilder.append("KW1060 : 'KW' '1060';\n");
+		grammarBuilder.append("KW1061 : 'KW' '1061';\n");
+		grammarBuilder.append("KW1062 : 'KW' '1062';\n");
+		grammarBuilder.append("KW1063 : 'KW' '1063';\n");
+		grammarBuilder.append("KW1064 : 'KW' '1064';\n");
+		grammarBuilder.append("KW1065 : 'KW' '1065';\n");
+		grammarBuilder.append("KW1066 : 'KW' '1066';\n");
+		grammarBuilder.append("KW1067 : 'KW' '1067';\n");
+		grammarBuilder.append("KW1068 : 'KW' '1068';\n");
+		grammarBuilder.append("KW1069 : 'KW' '1069';\n");
+		grammarBuilder.append("KW1070 : 'KW' '1070';\n");
+		grammarBuilder.append("KW1071 : 'KW' '1071';\n");
+		grammarBuilder.append("KW1072 : 'KW' '1072';\n");
+		grammarBuilder.append("KW1073 : 'KW' '1073';\n");
+		grammarBuilder.append("KW1074 : 'KW' '1074';\n");
+		grammarBuilder.append("KW1075 : 'KW' '1075';\n");
+		grammarBuilder.append("KW1076 : 'KW' '1076';\n");
+		grammarBuilder.append("KW1077 : 'KW' '1077';\n");
+		grammarBuilder.append("KW1078 : 'KW' '1078';\n");
+		grammarBuilder.append("KW1079 : 'KW' '1079';\n");
+		grammarBuilder.append("KW1080 : 'KW' '1080';\n");
+		grammarBuilder.append("KW1081 : 'KW' '1081';\n");
+		grammarBuilder.append("KW1082 : 'KW' '1082';\n");
+		grammarBuilder.append("KW1083 : 'KW' '1083';\n");
+		grammarBuilder.append("KW1084 : 'KW' '1084';\n");
+		grammarBuilder.append("KW1085 : 'KW' '1085';\n");
+		grammarBuilder.append("KW1086 : 'KW' '1086';\n");
+		grammarBuilder.append("KW1087 : 'KW' '1087';\n");
+		grammarBuilder.append("KW1088 : 'KW' '1088';\n");
+		grammarBuilder.append("KW1089 : 'KW' '1089';\n");
+		grammarBuilder.append("KW1090 : 'KW' '1090';\n");
+		grammarBuilder.append("KW1091 : 'KW' '1091';\n");
+		grammarBuilder.append("KW1092 : 'KW' '1092';\n");
+		grammarBuilder.append("KW1093 : 'KW' '1093';\n");
+		grammarBuilder.append("KW1094 : 'KW' '1094';\n");
+		grammarBuilder.append("KW1095 : 'KW' '1095';\n");
+		grammarBuilder.append("KW1096 : 'KW' '1096';\n");
+		grammarBuilder.append("KW1097 : 'KW' '1097';\n");
+		grammarBuilder.append("KW1098 : 'KW' '1098';\n");
+		grammarBuilder.append("KW1099 : 'KW' '1099';\n");
+		grammarBuilder.append("KW1100 : 'KW' '1100';\n");
+		grammarBuilder.append("KW1101 : 'KW' '1101';\n");
+		grammarBuilder.append("KW1102 : 'KW' '1102';\n");
+		grammarBuilder.append("KW1103 : 'KW' '1103';\n");
+		grammarBuilder.append("KW1104 : 'KW' '1104';\n");
+		grammarBuilder.append("KW1105 : 'KW' '1105';\n");
+		grammarBuilder.append("KW1106 : 'KW' '1106';\n");
+		grammarBuilder.append("KW1107 : 'KW' '1107';\n");
+		grammarBuilder.append("KW1108 : 'KW' '1108';\n");
+		grammarBuilder.append("KW1109 : 'KW' '1109';\n");
+		grammarBuilder.append("KW1110 : 'KW' '1110';\n");
+		grammarBuilder.append("KW1111 : 'KW' '1111';\n");
+		grammarBuilder.append("KW1112 : 'KW' '1112';\n");
+		grammarBuilder.append("KW1113 : 'KW' '1113';\n");
+		grammarBuilder.append("KW1114 : 'KW' '1114';\n");
+		grammarBuilder.append("KW1115 : 'KW' '1115';\n");
+		grammarBuilder.append("KW1116 : 'KW' '1116';\n");
+		grammarBuilder.append("KW1117 : 'KW' '1117';\n");
+		grammarBuilder.append("KW1118 : 'KW' '1118';\n");
+		grammarBuilder.append("KW1119 : 'KW' '1119';\n");
+		grammarBuilder.append("KW1120 : 'KW' '1120';\n");
+		grammarBuilder.append("KW1121 : 'KW' '1121';\n");
+		grammarBuilder.append("KW1122 : 'KW' '1122';\n");
+		grammarBuilder.append("KW1123 : 'KW' '1123';\n");
+		grammarBuilder.append("KW1124 : 'KW' '1124';\n");
+		grammarBuilder.append("KW1125 : 'KW' '1125';\n");
+		grammarBuilder.append("KW1126 : 'KW' '1126';\n");
+		grammarBuilder.append("KW1127 : 'KW' '1127';\n");
+		grammarBuilder.append("KW1128 : 'KW' '1128';\n");
+		grammarBuilder.append("KW1129 : 'KW' '1129';\n");
+		grammarBuilder.append("KW1130 : 'KW' '1130';\n");
+		grammarBuilder.append("KW1131 : 'KW' '1131';\n");
+		grammarBuilder.append("KW1132 : 'KW' '1132';\n");
+		grammarBuilder.append("KW1133 : 'KW' '1133';\n");
+		grammarBuilder.append("KW1134 : 'KW' '1134';\n");
+		grammarBuilder.append("KW1135 : 'KW' '1135';\n");
+		grammarBuilder.append("KW1136 : 'KW' '1136';\n");
+		grammarBuilder.append("KW1137 : 'KW' '1137';\n");
+		grammarBuilder.append("KW1138 : 'KW' '1138';\n");
+		grammarBuilder.append("KW1139 : 'KW' '1139';\n");
+		grammarBuilder.append("KW1140 : 'KW' '1140';\n");
+		grammarBuilder.append("KW1141 : 'KW' '1141';\n");
+		grammarBuilder.append("KW1142 : 'KW' '1142';\n");
+		grammarBuilder.append("KW1143 : 'KW' '1143';\n");
+		grammarBuilder.append("KW1144 : 'KW' '1144';\n");
+		grammarBuilder.append("KW1145 : 'KW' '1145';\n");
+		grammarBuilder.append("KW1146 : 'KW' '1146';\n");
+		grammarBuilder.append("KW1147 : 'KW' '1147';\n");
+		grammarBuilder.append("KW1148 : 'KW' '1148';\n");
+		grammarBuilder.append("KW1149 : 'KW' '1149';\n");
+		grammarBuilder.append("KW1150 : 'KW' '1150';\n");
+		grammarBuilder.append("KW1151 : 'KW' '1151';\n");
+		grammarBuilder.append("KW1152 : 'KW' '1152';\n");
+		grammarBuilder.append("KW1153 : 'KW' '1153';\n");
+		grammarBuilder.append("KW1154 : 'KW' '1154';\n");
+		grammarBuilder.append("KW1155 : 'KW' '1155';\n");
+		grammarBuilder.append("KW1156 : 'KW' '1156';\n");
+		grammarBuilder.append("KW1157 : 'KW' '1157';\n");
+		grammarBuilder.append("KW1158 : 'KW' '1158';\n");
+		grammarBuilder.append("KW1159 : 'KW' '1159';\n");
+		grammarBuilder.append("KW1160 : 'KW' '1160';\n");
+		grammarBuilder.append("KW1161 : 'KW' '1161';\n");
+		grammarBuilder.append("KW1162 : 'KW' '1162';\n");
+		grammarBuilder.append("KW1163 : 'KW' '1163';\n");
+		grammarBuilder.append("KW1164 : 'KW' '1164';\n");
+		grammarBuilder.append("KW1165 : 'KW' '1165';\n");
+		grammarBuilder.append("KW1166 : 'KW' '1166';\n");
+		grammarBuilder.append("KW1167 : 'KW' '1167';\n");
+		grammarBuilder.append("KW1168 : 'KW' '1168';\n");
+		grammarBuilder.append("KW1169 : 'KW' '1169';\n");
+		grammarBuilder.append("KW1170 : 'KW' '1170';\n");
+		grammarBuilder.append("KW1171 : 'KW' '1171';\n");
+		grammarBuilder.append("KW1172 : 'KW' '1172';\n");
+		grammarBuilder.append("KW1173 : 'KW' '1173';\n");
+		grammarBuilder.append("KW1174 : 'KW' '1174';\n");
+		grammarBuilder.append("KW1175 : 'KW' '1175';\n");
+		grammarBuilder.append("KW1176 : 'KW' '1176';\n");
+		grammarBuilder.append("KW1177 : 'KW' '1177';\n");
+		grammarBuilder.append("KW1178 : 'KW' '1178';\n");
+		grammarBuilder.append("KW1179 : 'KW' '1179';\n");
+		grammarBuilder.append("KW1180 : 'KW' '1180';\n");
+		grammarBuilder.append("KW1181 : 'KW' '1181';\n");
+		grammarBuilder.append("KW1182 : 'KW' '1182';\n");
+		grammarBuilder.append("KW1183 : 'KW' '1183';\n");
+		grammarBuilder.append("KW1184 : 'KW' '1184';\n");
+		grammarBuilder.append("KW1185 : 'KW' '1185';\n");
+		grammarBuilder.append("KW1186 : 'KW' '1186';\n");
+		grammarBuilder.append("KW1187 : 'KW' '1187';\n");
+		grammarBuilder.append("KW1188 : 'KW' '1188';\n");
+		grammarBuilder.append("KW1189 : 'KW' '1189';\n");
+		grammarBuilder.append("KW1190 : 'KW' '1190';\n");
+		grammarBuilder.append("KW1191 : 'KW' '1191';\n");
+		grammarBuilder.append("KW1192 : 'KW' '1192';\n");
+		grammarBuilder.append("KW1193 : 'KW' '1193';\n");
+		grammarBuilder.append("KW1194 : 'KW' '1194';\n");
+		grammarBuilder.append("KW1195 : 'KW' '1195';\n");
+		grammarBuilder.append("KW1196 : 'KW' '1196';\n");
+		grammarBuilder.append("KW1197 : 'KW' '1197';\n");
+		grammarBuilder.append("KW1198 : 'KW' '1198';\n");
+		grammarBuilder.append("KW1199 : 'KW' '1199';\n");
+		grammarBuilder.append("KW1200 : 'KW' '1200';\n");
+		grammarBuilder.append("KW1201 : 'KW' '1201';\n");
+		grammarBuilder.append("KW1202 : 'KW' '1202';\n");
+		grammarBuilder.append("KW1203 : 'KW' '1203';\n");
+		grammarBuilder.append("KW1204 : 'KW' '1204';\n");
+		grammarBuilder.append("KW1205 : 'KW' '1205';\n");
+		grammarBuilder.append("KW1206 : 'KW' '1206';\n");
+		grammarBuilder.append("KW1207 : 'KW' '1207';\n");
+		grammarBuilder.append("KW1208 : 'KW' '1208';\n");
+		grammarBuilder.append("KW1209 : 'KW' '1209';\n");
+		grammarBuilder.append("KW1210 : 'KW' '1210';\n");
+		grammarBuilder.append("KW1211 : 'KW' '1211';\n");
+		grammarBuilder.append("KW1212 : 'KW' '1212';\n");
+		grammarBuilder.append("KW1213 : 'KW' '1213';\n");
+		grammarBuilder.append("KW1214 : 'KW' '1214';\n");
+		grammarBuilder.append("KW1215 : 'KW' '1215';\n");
+		grammarBuilder.append("KW1216 : 'KW' '1216';\n");
+		grammarBuilder.append("KW1217 : 'KW' '1217';\n");
+		grammarBuilder.append("KW1218 : 'KW' '1218';\n");
+		grammarBuilder.append("KW1219 : 'KW' '1219';\n");
+		grammarBuilder.append("KW1220 : 'KW' '1220';\n");
+		grammarBuilder.append("KW1221 : 'KW' '1221';\n");
+		grammarBuilder.append("KW1222 : 'KW' '1222';\n");
+		grammarBuilder.append("KW1223 : 'KW' '1223';\n");
+		grammarBuilder.append("KW1224 : 'KW' '1224';\n");
+		grammarBuilder.append("KW1225 : 'KW' '1225';\n");
+		grammarBuilder.append("KW1226 : 'KW' '1226';\n");
+		grammarBuilder.append("KW1227 : 'KW' '1227';\n");
+		grammarBuilder.append("KW1228 : 'KW' '1228';\n");
+		grammarBuilder.append("KW1229 : 'KW' '1229';\n");
+		grammarBuilder.append("KW1230 : 'KW' '1230';\n");
+		grammarBuilder.append("KW1231 : 'KW' '1231';\n");
+		grammarBuilder.append("KW1232 : 'KW' '1232';\n");
+		grammarBuilder.append("KW1233 : 'KW' '1233';\n");
+		grammarBuilder.append("KW1234 : 'KW' '1234';\n");
+		grammarBuilder.append("KW1235 : 'KW' '1235';\n");
+		grammarBuilder.append("KW1236 : 'KW' '1236';\n");
+		grammarBuilder.append("KW1237 : 'KW' '1237';\n");
+		grammarBuilder.append("KW1238 : 'KW' '1238';\n");
+		grammarBuilder.append("KW1239 : 'KW' '1239';\n");
+		grammarBuilder.append("KW1240 : 'KW' '1240';\n");
+		grammarBuilder.append("KW1241 : 'KW' '1241';\n");
+		grammarBuilder.append("KW1242 : 'KW' '1242';\n");
+		grammarBuilder.append("KW1243 : 'KW' '1243';\n");
+		grammarBuilder.append("KW1244 : 'KW' '1244';\n");
+		grammarBuilder.append("KW1245 : 'KW' '1245';\n");
+		grammarBuilder.append("KW1246 : 'KW' '1246';\n");
+		grammarBuilder.append("KW1247 : 'KW' '1247';\n");
+		grammarBuilder.append("KW1248 : 'KW' '1248';\n");
+		grammarBuilder.append("KW1249 : 'KW' '1249';\n");
+		grammarBuilder.append("KW1250 : 'KW' '1250';\n");
+		grammarBuilder.append("KW1251 : 'KW' '1251';\n");
+		grammarBuilder.append("KW1252 : 'KW' '1252';\n");
+		grammarBuilder.append("KW1253 : 'KW' '1253';\n");
+		grammarBuilder.append("KW1254 : 'KW' '1254';\n");
+		grammarBuilder.append("KW1255 : 'KW' '1255';\n");
+		grammarBuilder.append("KW1256 : 'KW' '1256';\n");
+		grammarBuilder.append("KW1257 : 'KW' '1257';\n");
+		grammarBuilder.append("KW1258 : 'KW' '1258';\n");
+		grammarBuilder.append("KW1259 : 'KW' '1259';\n");
+		grammarBuilder.append("KW1260 : 'KW' '1260';\n");
+		grammarBuilder.append("KW1261 : 'KW' '1261';\n");
+		grammarBuilder.append("KW1262 : 'KW' '1262';\n");
+		grammarBuilder.append("KW1263 : 'KW' '1263';\n");
+		grammarBuilder.append("KW1264 : 'KW' '1264';\n");
+		grammarBuilder.append("KW1265 : 'KW' '1265';\n");
+		grammarBuilder.append("KW1266 : 'KW' '1266';\n");
+		grammarBuilder.append("KW1267 : 'KW' '1267';\n");
+		grammarBuilder.append("KW1268 : 'KW' '1268';\n");
+		grammarBuilder.append("KW1269 : 'KW' '1269';\n");
+		grammarBuilder.append("KW1270 : 'KW' '1270';\n");
+		grammarBuilder.append("KW1271 : 'KW' '1271';\n");
+		grammarBuilder.append("KW1272 : 'KW' '1272';\n");
+		grammarBuilder.append("KW1273 : 'KW' '1273';\n");
+		grammarBuilder.append("KW1274 : 'KW' '1274';\n");
+		grammarBuilder.append("KW1275 : 'KW' '1275';\n");
+		grammarBuilder.append("KW1276 : 'KW' '1276';\n");
+		grammarBuilder.append("KW1277 : 'KW' '1277';\n");
+		grammarBuilder.append("KW1278 : 'KW' '1278';\n");
+		grammarBuilder.append("KW1279 : 'KW' '1279';\n");
+		grammarBuilder.append("KW1280 : 'KW' '1280';\n");
+		grammarBuilder.append("KW1281 : 'KW' '1281';\n");
+		grammarBuilder.append("KW1282 : 'KW' '1282';\n");
+		grammarBuilder.append("KW1283 : 'KW' '1283';\n");
+		grammarBuilder.append("KW1284 : 'KW' '1284';\n");
+		grammarBuilder.append("KW1285 : 'KW' '1285';\n");
+		grammarBuilder.append("KW1286 : 'KW' '1286';\n");
+		grammarBuilder.append("KW1287 : 'KW' '1287';\n");
+		grammarBuilder.append("KW1288 : 'KW' '1288';\n");
+		grammarBuilder.append("KW1289 : 'KW' '1289';\n");
+		grammarBuilder.append("KW1290 : 'KW' '1290';\n");
+		grammarBuilder.append("KW1291 : 'KW' '1291';\n");
+		grammarBuilder.append("KW1292 : 'KW' '1292';\n");
+		grammarBuilder.append("KW1293 : 'KW' '1293';\n");
+		grammarBuilder.append("KW1294 : 'KW' '1294';\n");
+		grammarBuilder.append("KW1295 : 'KW' '1295';\n");
+		grammarBuilder.append("KW1296 : 'KW' '1296';\n");
+		grammarBuilder.append("KW1297 : 'KW' '1297';\n");
+		grammarBuilder.append("KW1298 : 'KW' '1298';\n");
+		grammarBuilder.append("KW1299 : 'KW' '1299';\n");
+		grammarBuilder.append("KW1300 : 'KW' '1300';\n");
+		grammarBuilder.append("KW1301 : 'KW' '1301';\n");
+		grammarBuilder.append("KW1302 : 'KW' '1302';\n");
+		grammarBuilder.append("KW1303 : 'KW' '1303';\n");
+		grammarBuilder.append("KW1304 : 'KW' '1304';\n");
+		grammarBuilder.append("KW1305 : 'KW' '1305';\n");
+		grammarBuilder.append("KW1306 : 'KW' '1306';\n");
+		grammarBuilder.append("KW1307 : 'KW' '1307';\n");
+		grammarBuilder.append("KW1308 : 'KW' '1308';\n");
+		grammarBuilder.append("KW1309 : 'KW' '1309';\n");
+		grammarBuilder.append("KW1310 : 'KW' '1310';\n");
+		grammarBuilder.append("KW1311 : 'KW' '1311';\n");
+		grammarBuilder.append("KW1312 : 'KW' '1312';\n");
+		grammarBuilder.append("KW1313 : 'KW' '1313';\n");
+		grammarBuilder.append("KW1314 : 'KW' '1314';\n");
+		grammarBuilder.append("KW1315 : 'KW' '1315';\n");
+		grammarBuilder.append("KW1316 : 'KW' '1316';\n");
+		grammarBuilder.append("KW1317 : 'KW' '1317';\n");
+		grammarBuilder.append("KW1318 : 'KW' '1318';\n");
+		grammarBuilder.append("KW1319 : 'KW' '1319';\n");
+		grammarBuilder.append("KW1320 : 'KW' '1320';\n");
+		grammarBuilder.append("KW1321 : 'KW' '1321';\n");
+		grammarBuilder.append("KW1322 : 'KW' '1322';\n");
+		grammarBuilder.append("KW1323 : 'KW' '1323';\n");
+		grammarBuilder.append("KW1324 : 'KW' '1324';\n");
+		grammarBuilder.append("KW1325 : 'KW' '1325';\n");
+		grammarBuilder.append("KW1326 : 'KW' '1326';\n");
+		grammarBuilder.append("KW1327 : 'KW' '1327';\n");
+		grammarBuilder.append("KW1328 : 'KW' '1328';\n");
+		grammarBuilder.append("KW1329 : 'KW' '1329';\n");
+		grammarBuilder.append("KW1330 : 'KW' '1330';\n");
+		grammarBuilder.append("KW1331 : 'KW' '1331';\n");
+		grammarBuilder.append("KW1332 : 'KW' '1332';\n");
+		grammarBuilder.append("KW1333 : 'KW' '1333';\n");
+		grammarBuilder.append("KW1334 : 'KW' '1334';\n");
+		grammarBuilder.append("KW1335 : 'KW' '1335';\n");
+		grammarBuilder.append("KW1336 : 'KW' '1336';\n");
+		grammarBuilder.append("KW1337 : 'KW' '1337';\n");
+		grammarBuilder.append("KW1338 : 'KW' '1338';\n");
+		grammarBuilder.append("KW1339 : 'KW' '1339';\n");
+		grammarBuilder.append("KW1340 : 'KW' '1340';\n");
+		grammarBuilder.append("KW1341 : 'KW' '1341';\n");
+		grammarBuilder.append("KW1342 : 'KW' '1342';\n");
+		grammarBuilder.append("KW1343 : 'KW' '1343';\n");
+		grammarBuilder.append("KW1344 : 'KW' '1344';\n");
+		grammarBuilder.append("KW1345 : 'KW' '1345';\n");
+		grammarBuilder.append("KW1346 : 'KW' '1346';\n");
+		grammarBuilder.append("KW1347 : 'KW' '1347';\n");
+		grammarBuilder.append("KW1348 : 'KW' '1348';\n");
+		grammarBuilder.append("KW1349 : 'KW' '1349';\n");
+		grammarBuilder.append("KW1350 : 'KW' '1350';\n");
+		grammarBuilder.append("KW1351 : 'KW' '1351';\n");
+		grammarBuilder.append("KW1352 : 'KW' '1352';\n");
+		grammarBuilder.append("KW1353 : 'KW' '1353';\n");
+		grammarBuilder.append("KW1354 : 'KW' '1354';\n");
+		grammarBuilder.append("KW1355 : 'KW' '1355';\n");
+		grammarBuilder.append("KW1356 : 'KW' '1356';\n");
+		grammarBuilder.append("KW1357 : 'KW' '1357';\n");
+		grammarBuilder.append("KW1358 : 'KW' '1358';\n");
+		grammarBuilder.append("KW1359 : 'KW' '1359';\n");
+		grammarBuilder.append("KW1360 : 'KW' '1360';\n");
+		grammarBuilder.append("KW1361 : 'KW' '1361';\n");
+		grammarBuilder.append("KW1362 : 'KW' '1362';\n");
+		grammarBuilder.append("KW1363 : 'KW' '1363';\n");
+		grammarBuilder.append("KW1364 : 'KW' '1364';\n");
+		grammarBuilder.append("KW1365 : 'KW' '1365';\n");
+		grammarBuilder.append("KW1366 : 'KW' '1366';\n");
+		grammarBuilder.append("KW1367 : 'KW' '1367';\n");
+		grammarBuilder.append("KW1368 : 'KW' '1368';\n");
+		grammarBuilder.append("KW1369 : 'KW' '1369';\n");
+		grammarBuilder.append("KW1370 : 'KW' '1370';\n");
+		grammarBuilder.append("KW1371 : 'KW' '1371';\n");
+		grammarBuilder.append("KW1372 : 'KW' '1372';\n");
+		grammarBuilder.append("KW1373 : 'KW' '1373';\n");
+		grammarBuilder.append("KW1374 : 'KW' '1374';\n");
+		grammarBuilder.append("KW1375 : 'KW' '1375';\n");
+		grammarBuilder.append("KW1376 : 'KW' '1376';\n");
+		grammarBuilder.append("KW1377 : 'KW' '1377';\n");
+		grammarBuilder.append("KW1378 : 'KW' '1378';\n");
+		grammarBuilder.append("KW1379 : 'KW' '1379';\n");
+		grammarBuilder.append("KW1380 : 'KW' '1380';\n");
+		grammarBuilder.append("KW1381 : 'KW' '1381';\n");
+		grammarBuilder.append("KW1382 : 'KW' '1382';\n");
+		grammarBuilder.append("KW1383 : 'KW' '1383';\n");
+		grammarBuilder.append("KW1384 : 'KW' '1384';\n");
+		grammarBuilder.append("KW1385 : 'KW' '1385';\n");
+		grammarBuilder.append("KW1386 : 'KW' '1386';\n");
+		grammarBuilder.append("KW1387 : 'KW' '1387';\n");
+		grammarBuilder.append("KW1388 : 'KW' '1388';\n");
+		grammarBuilder.append("KW1389 : 'KW' '1389';\n");
+		grammarBuilder.append("KW1390 : 'KW' '1390';\n");
+		grammarBuilder.append("KW1391 : 'KW' '1391';\n");
+		grammarBuilder.append("KW1392 : 'KW' '1392';\n");
+		grammarBuilder.append("KW1393 : 'KW' '1393';\n");
+		grammarBuilder.append("KW1394 : 'KW' '1394';\n");
+		grammarBuilder.append("KW1395 : 'KW' '1395';\n");
+		grammarBuilder.append("KW1396 : 'KW' '1396';\n");
+		grammarBuilder.append("KW1397 : 'KW' '1397';\n");
+		grammarBuilder.append("KW1398 : 'KW' '1398';\n");
+		grammarBuilder.append("KW1399 : 'KW' '1399';\n");
+		grammarBuilder.append("KW1400 : 'KW' '1400';\n");
+		grammarBuilder.append("KW1401 : 'KW' '1401';\n");
+		grammarBuilder.append("KW1402 : 'KW' '1402';\n");
+		grammarBuilder.append("KW1403 : 'KW' '1403';\n");
+		grammarBuilder.append("KW1404 : 'KW' '1404';\n");
+		grammarBuilder.append("KW1405 : 'KW' '1405';\n");
+		grammarBuilder.append("KW1406 : 'KW' '1406';\n");
+		grammarBuilder.append("KW1407 : 'KW' '1407';\n");
+		grammarBuilder.append("KW1408 : 'KW' '1408';\n");
+		grammarBuilder.append("KW1409 : 'KW' '1409';\n");
+		grammarBuilder.append("KW1410 : 'KW' '1410';\n");
+		grammarBuilder.append("KW1411 : 'KW' '1411';\n");
+		grammarBuilder.append("KW1412 : 'KW' '1412';\n");
+		grammarBuilder.append("KW1413 : 'KW' '1413';\n");
+		grammarBuilder.append("KW1414 : 'KW' '1414';\n");
+		grammarBuilder.append("KW1415 : 'KW' '1415';\n");
+		grammarBuilder.append("KW1416 : 'KW' '1416';\n");
+		grammarBuilder.append("KW1417 : 'KW' '1417';\n");
+		grammarBuilder.append("KW1418 : 'KW' '1418';\n");
+		grammarBuilder.append("KW1419 : 'KW' '1419';\n");
+		grammarBuilder.append("KW1420 : 'KW' '1420';\n");
+		grammarBuilder.append("KW1421 : 'KW' '1421';\n");
+		grammarBuilder.append("KW1422 : 'KW' '1422';\n");
+		grammarBuilder.append("KW1423 : 'KW' '1423';\n");
+		grammarBuilder.append("KW1424 : 'KW' '1424';\n");
+		grammarBuilder.append("KW1425 : 'KW' '1425';\n");
+		grammarBuilder.append("KW1426 : 'KW' '1426';\n");
+		grammarBuilder.append("KW1427 : 'KW' '1427';\n");
+		grammarBuilder.append("KW1428 : 'KW' '1428';\n");
+		grammarBuilder.append("KW1429 : 'KW' '1429';\n");
+		grammarBuilder.append("KW1430 : 'KW' '1430';\n");
+		grammarBuilder.append("KW1431 : 'KW' '1431';\n");
+		grammarBuilder.append("KW1432 : 'KW' '1432';\n");
+		grammarBuilder.append("KW1433 : 'KW' '1433';\n");
+		grammarBuilder.append("KW1434 : 'KW' '1434';\n");
+		grammarBuilder.append("KW1435 : 'KW' '1435';\n");
+		grammarBuilder.append("KW1436 : 'KW' '1436';\n");
+		grammarBuilder.append("KW1437 : 'KW' '1437';\n");
+		grammarBuilder.append("KW1438 : 'KW' '1438';\n");
+		grammarBuilder.append("KW1439 : 'KW' '1439';\n");
+		grammarBuilder.append("KW1440 : 'KW' '1440';\n");
+		grammarBuilder.append("KW1441 : 'KW' '1441';\n");
+		grammarBuilder.append("KW1442 : 'KW' '1442';\n");
+		grammarBuilder.append("KW1443 : 'KW' '1443';\n");
+		grammarBuilder.append("KW1444 : 'KW' '1444';\n");
+		grammarBuilder.append("KW1445 : 'KW' '1445';\n");
+		grammarBuilder.append("KW1446 : 'KW' '1446';\n");
+		grammarBuilder.append("KW1447 : 'KW' '1447';\n");
+		grammarBuilder.append("KW1448 : 'KW' '1448';\n");
+		grammarBuilder.append("KW1449 : 'KW' '1449';\n");
+		grammarBuilder.append("KW1450 : 'KW' '1450';\n");
+		grammarBuilder.append("KW1451 : 'KW' '1451';\n");
+		grammarBuilder.append("KW1452 : 'KW' '1452';\n");
+		grammarBuilder.append("KW1453 : 'KW' '1453';\n");
+		grammarBuilder.append("KW1454 : 'KW' '1454';\n");
+		grammarBuilder.append("KW1455 : 'KW' '1455';\n");
+		grammarBuilder.append("KW1456 : 'KW' '1456';\n");
+		grammarBuilder.append("KW1457 : 'KW' '1457';\n");
+		grammarBuilder.append("KW1458 : 'KW' '1458';\n");
+		grammarBuilder.append("KW1459 : 'KW' '1459';\n");
+		grammarBuilder.append("KW1460 : 'KW' '1460';\n");
+		grammarBuilder.append("KW1461 : 'KW' '1461';\n");
+		grammarBuilder.append("KW1462 : 'KW' '1462';\n");
+		grammarBuilder.append("KW1463 : 'KW' '1463';\n");
+		grammarBuilder.append("KW1464 : 'KW' '1464';\n");
+		grammarBuilder.append("KW1465 : 'KW' '1465';\n");
+		grammarBuilder.append("KW1466 : 'KW' '1466';\n");
+		grammarBuilder.append("KW1467 : 'KW' '1467';\n");
+		grammarBuilder.append("KW1468 : 'KW' '1468';\n");
+		grammarBuilder.append("KW1469 : 'KW' '1469';\n");
+		grammarBuilder.append("KW1470 : 'KW' '1470';\n");
+		grammarBuilder.append("KW1471 : 'KW' '1471';\n");
+		grammarBuilder.append("KW1472 : 'KW' '1472';\n");
+		grammarBuilder.append("KW1473 : 'KW' '1473';\n");
+		grammarBuilder.append("KW1474 : 'KW' '1474';\n");
+		grammarBuilder.append("KW1475 : 'KW' '1475';\n");
+		grammarBuilder.append("KW1476 : 'KW' '1476';\n");
+		grammarBuilder.append("KW1477 : 'KW' '1477';\n");
+		grammarBuilder.append("KW1478 : 'KW' '1478';\n");
+		grammarBuilder.append("KW1479 : 'KW' '1479';\n");
+		grammarBuilder.append("KW1480 : 'KW' '1480';\n");
+		grammarBuilder.append("KW1481 : 'KW' '1481';\n");
+		grammarBuilder.append("KW1482 : 'KW' '1482';\n");
+		grammarBuilder.append("KW1483 : 'KW' '1483';\n");
+		grammarBuilder.append("KW1484 : 'KW' '1484';\n");
+		grammarBuilder.append("KW1485 : 'KW' '1485';\n");
+		grammarBuilder.append("KW1486 : 'KW' '1486';\n");
+		grammarBuilder.append("KW1487 : 'KW' '1487';\n");
+		grammarBuilder.append("KW1488 : 'KW' '1488';\n");
+		grammarBuilder.append("KW1489 : 'KW' '1489';\n");
+		grammarBuilder.append("KW1490 : 'KW' '1490';\n");
+		grammarBuilder.append("KW1491 : 'KW' '1491';\n");
+		grammarBuilder.append("KW1492 : 'KW' '1492';\n");
+		grammarBuilder.append("KW1493 : 'KW' '1493';\n");
+		grammarBuilder.append("KW1494 : 'KW' '1494';\n");
+		grammarBuilder.append("KW1495 : 'KW' '1495';\n");
+		grammarBuilder.append("KW1496 : 'KW' '1496';\n");
+		grammarBuilder.append("KW1497 : 'KW' '1497';\n");
+		grammarBuilder.append("KW1498 : 'KW' '1498';\n");
+		grammarBuilder.append("KW1499 : 'KW' '1499';\n");
+		grammarBuilder.append("KW1500 : 'KW' '1500';\n");
+		grammarBuilder.append("KW1501 : 'KW' '1501';\n");
+		grammarBuilder.append("KW1502 : 'KW' '1502';\n");
+		grammarBuilder.append("KW1503 : 'KW' '1503';\n");
+		grammarBuilder.append("KW1504 : 'KW' '1504';\n");
+		grammarBuilder.append("KW1505 : 'KW' '1505';\n");
+		grammarBuilder.append("KW1506 : 'KW' '1506';\n");
+		grammarBuilder.append("KW1507 : 'KW' '1507';\n");
+		grammarBuilder.append("KW1508 : 'KW' '1508';\n");
+		grammarBuilder.append("KW1509 : 'KW' '1509';\n");
+		grammarBuilder.append("KW1510 : 'KW' '1510';\n");
+		grammarBuilder.append("KW1511 : 'KW' '1511';\n");
+		grammarBuilder.append("KW1512 : 'KW' '1512';\n");
+		grammarBuilder.append("KW1513 : 'KW' '1513';\n");
+		grammarBuilder.append("KW1514 : 'KW' '1514';\n");
+		grammarBuilder.append("KW1515 : 'KW' '1515';\n");
+		grammarBuilder.append("KW1516 : 'KW' '1516';\n");
+		grammarBuilder.append("KW1517 : 'KW' '1517';\n");
+		grammarBuilder.append("KW1518 : 'KW' '1518';\n");
+		grammarBuilder.append("KW1519 : 'KW' '1519';\n");
+		grammarBuilder.append("KW1520 : 'KW' '1520';\n");
+		grammarBuilder.append("KW1521 : 'KW' '1521';\n");
+		grammarBuilder.append("KW1522 : 'KW' '1522';\n");
+		grammarBuilder.append("KW1523 : 'KW' '1523';\n");
+		grammarBuilder.append("KW1524 : 'KW' '1524';\n");
+		grammarBuilder.append("KW1525 : 'KW' '1525';\n");
+		grammarBuilder.append("KW1526 : 'KW' '1526';\n");
+		grammarBuilder.append("KW1527 : 'KW' '1527';\n");
+		grammarBuilder.append("KW1528 : 'KW' '1528';\n");
+		grammarBuilder.append("KW1529 : 'KW' '1529';\n");
+		grammarBuilder.append("KW1530 : 'KW' '1530';\n");
+		grammarBuilder.append("KW1531 : 'KW' '1531';\n");
+		grammarBuilder.append("KW1532 : 'KW' '1532';\n");
+		grammarBuilder.append("KW1533 : 'KW' '1533';\n");
+		grammarBuilder.append("KW1534 : 'KW' '1534';\n");
+		grammarBuilder.append("KW1535 : 'KW' '1535';\n");
+		grammarBuilder.append("KW1536 : 'KW' '1536';\n");
+		grammarBuilder.append("KW1537 : 'KW' '1537';\n");
+		grammarBuilder.append("KW1538 : 'KW' '1538';\n");
+		grammarBuilder.append("KW1539 : 'KW' '1539';\n");
+		grammarBuilder.append("KW1540 : 'KW' '1540';\n");
+		grammarBuilder.append("KW1541 : 'KW' '1541';\n");
+		grammarBuilder.append("KW1542 : 'KW' '1542';\n");
+		grammarBuilder.append("KW1543 : 'KW' '1543';\n");
+		grammarBuilder.append("KW1544 : 'KW' '1544';\n");
+		grammarBuilder.append("KW1545 : 'KW' '1545';\n");
+		grammarBuilder.append("KW1546 : 'KW' '1546';\n");
+		grammarBuilder.append("KW1547 : 'KW' '1547';\n");
+		grammarBuilder.append("KW1548 : 'KW' '1548';\n");
+		grammarBuilder.append("KW1549 : 'KW' '1549';\n");
+		grammarBuilder.append("KW1550 : 'KW' '1550';\n");
+		grammarBuilder.append("KW1551 : 'KW' '1551';\n");
+		grammarBuilder.append("KW1552 : 'KW' '1552';\n");
+		grammarBuilder.append("KW1553 : 'KW' '1553';\n");
+		grammarBuilder.append("KW1554 : 'KW' '1554';\n");
+		grammarBuilder.append("KW1555 : 'KW' '1555';\n");
+		grammarBuilder.append("KW1556 : 'KW' '1556';\n");
+		grammarBuilder.append("KW1557 : 'KW' '1557';\n");
+		grammarBuilder.append("KW1558 : 'KW' '1558';\n");
+		grammarBuilder.append("KW1559 : 'KW' '1559';\n");
+		grammarBuilder.append("KW1560 : 'KW' '1560';\n");
+		grammarBuilder.append("KW1561 : 'KW' '1561';\n");
+		grammarBuilder.append("KW1562 : 'KW' '1562';\n");
+		grammarBuilder.append("KW1563 : 'KW' '1563';\n");
+		grammarBuilder.append("KW1564 : 'KW' '1564';\n");
+		grammarBuilder.append("KW1565 : 'KW' '1565';\n");
+		grammarBuilder.append("KW1566 : 'KW' '1566';\n");
+		grammarBuilder.append("KW1567 : 'KW' '1567';\n");
+		grammarBuilder.append("KW1568 : 'KW' '1568';\n");
+		grammarBuilder.append("KW1569 : 'KW' '1569';\n");
+		grammarBuilder.append("KW1570 : 'KW' '1570';\n");
+		grammarBuilder.append("KW1571 : 'KW' '1571';\n");
+		grammarBuilder.append("KW1572 : 'KW' '1572';\n");
+		grammarBuilder.append("KW1573 : 'KW' '1573';\n");
+		grammarBuilder.append("KW1574 : 'KW' '1574';\n");
+		grammarBuilder.append("KW1575 : 'KW' '1575';\n");
+		grammarBuilder.append("KW1576 : 'KW' '1576';\n");
+		grammarBuilder.append("KW1577 : 'KW' '1577';\n");
+		grammarBuilder.append("KW1578 : 'KW' '1578';\n");
+		grammarBuilder.append("KW1579 : 'KW' '1579';\n");
+		grammarBuilder.append("KW1580 : 'KW' '1580';\n");
+		grammarBuilder.append("KW1581 : 'KW' '1581';\n");
+		grammarBuilder.append("KW1582 : 'KW' '1582';\n");
+		grammarBuilder.append("KW1583 : 'KW' '1583';\n");
+		grammarBuilder.append("KW1584 : 'KW' '1584';\n");
+		grammarBuilder.append("KW1585 : 'KW' '1585';\n");
+		grammarBuilder.append("KW1586 : 'KW' '1586';\n");
+		grammarBuilder.append("KW1587 : 'KW' '1587';\n");
+		grammarBuilder.append("KW1588 : 'KW' '1588';\n");
+		grammarBuilder.append("KW1589 : 'KW' '1589';\n");
+		grammarBuilder.append("KW1590 : 'KW' '1590';\n");
+		grammarBuilder.append("KW1591 : 'KW' '1591';\n");
+		grammarBuilder.append("KW1592 : 'KW' '1592';\n");
+		grammarBuilder.append("KW1593 : 'KW' '1593';\n");
+		grammarBuilder.append("KW1594 : 'KW' '1594';\n");
+		grammarBuilder.append("KW1595 : 'KW' '1595';\n");
+		grammarBuilder.append("KW1596 : 'KW' '1596';\n");
+		grammarBuilder.append("KW1597 : 'KW' '1597';\n");
+		grammarBuilder.append("KW1598 : 'KW' '1598';\n");
+		grammarBuilder.append("KW1599 : 'KW' '1599';\n");
+		grammarBuilder.append("KW1600 : 'KW' '1600';\n");
+		grammarBuilder.append("KW1601 : 'KW' '1601';\n");
+		grammarBuilder.append("KW1602 : 'KW' '1602';\n");
+		grammarBuilder.append("KW1603 : 'KW' '1603';\n");
+		grammarBuilder.append("KW1604 : 'KW' '1604';\n");
+		grammarBuilder.append("KW1605 : 'KW' '1605';\n");
+		grammarBuilder.append("KW1606 : 'KW' '1606';\n");
+		grammarBuilder.append("KW1607 : 'KW' '1607';\n");
+		grammarBuilder.append("KW1608 : 'KW' '1608';\n");
+		grammarBuilder.append("KW1609 : 'KW' '1609';\n");
+		grammarBuilder.append("KW1610 : 'KW' '1610';\n");
+		grammarBuilder.append("KW1611 : 'KW' '1611';\n");
+		grammarBuilder.append("KW1612 : 'KW' '1612';\n");
+		grammarBuilder.append("KW1613 : 'KW' '1613';\n");
+		grammarBuilder.append("KW1614 : 'KW' '1614';\n");
+		grammarBuilder.append("KW1615 : 'KW' '1615';\n");
+		grammarBuilder.append("KW1616 : 'KW' '1616';\n");
+		grammarBuilder.append("KW1617 : 'KW' '1617';\n");
+		grammarBuilder.append("KW1618 : 'KW' '1618';\n");
+		grammarBuilder.append("KW1619 : 'KW' '1619';\n");
+		grammarBuilder.append("KW1620 : 'KW' '1620';\n");
+		grammarBuilder.append("KW1621 : 'KW' '1621';\n");
+		grammarBuilder.append("KW1622 : 'KW' '1622';\n");
+		grammarBuilder.append("KW1623 : 'KW' '1623';\n");
+		grammarBuilder.append("KW1624 : 'KW' '1624';\n");
+		grammarBuilder.append("KW1625 : 'KW' '1625';\n");
+		grammarBuilder.append("KW1626 : 'KW' '1626';\n");
+		grammarBuilder.append("KW1627 : 'KW' '1627';\n");
+		grammarBuilder.append("KW1628 : 'KW' '1628';\n");
+		grammarBuilder.append("KW1629 : 'KW' '1629';\n");
+		grammarBuilder.append("KW1630 : 'KW' '1630';\n");
+		grammarBuilder.append("KW1631 : 'KW' '1631';\n");
+		grammarBuilder.append("KW1632 : 'KW' '1632';\n");
+		grammarBuilder.append("KW1633 : 'KW' '1633';\n");
+		grammarBuilder.append("KW1634 : 'KW' '1634';\n");
+		grammarBuilder.append("KW1635 : 'KW' '1635';\n");
+		grammarBuilder.append("KW1636 : 'KW' '1636';\n");
+		grammarBuilder.append("KW1637 : 'KW' '1637';\n");
+		grammarBuilder.append("KW1638 : 'KW' '1638';\n");
+		grammarBuilder.append("KW1639 : 'KW' '1639';\n");
+		grammarBuilder.append("KW1640 : 'KW' '1640';\n");
+		grammarBuilder.append("KW1641 : 'KW' '1641';\n");
+		grammarBuilder.append("KW1642 : 'KW' '1642';\n");
+		grammarBuilder.append("KW1643 : 'KW' '1643';\n");
+		grammarBuilder.append("KW1644 : 'KW' '1644';\n");
+		grammarBuilder.append("KW1645 : 'KW' '1645';\n");
+		grammarBuilder.append("KW1646 : 'KW' '1646';\n");
+		grammarBuilder.append("KW1647 : 'KW' '1647';\n");
+		grammarBuilder.append("KW1648 : 'KW' '1648';\n");
+		grammarBuilder.append("KW1649 : 'KW' '1649';\n");
+		grammarBuilder.append("KW1650 : 'KW' '1650';\n");
+		grammarBuilder.append("KW1651 : 'KW' '1651';\n");
+		grammarBuilder.append("KW1652 : 'KW' '1652';\n");
+		grammarBuilder.append("KW1653 : 'KW' '1653';\n");
+		grammarBuilder.append("KW1654 : 'KW' '1654';\n");
+		grammarBuilder.append("KW1655 : 'KW' '1655';\n");
+		grammarBuilder.append("KW1656 : 'KW' '1656';\n");
+		grammarBuilder.append("KW1657 : 'KW' '1657';\n");
+		grammarBuilder.append("KW1658 : 'KW' '1658';\n");
+		grammarBuilder.append("KW1659 : 'KW' '1659';\n");
+		grammarBuilder.append("KW1660 : 'KW' '1660';\n");
+		grammarBuilder.append("KW1661 : 'KW' '1661';\n");
+		grammarBuilder.append("KW1662 : 'KW' '1662';\n");
+		grammarBuilder.append("KW1663 : 'KW' '1663';\n");
+		grammarBuilder.append("KW1664 : 'KW' '1664';\n");
+		grammarBuilder.append("KW1665 : 'KW' '1665';\n");
+		grammarBuilder.append("KW1666 : 'KW' '1666';\n");
+		grammarBuilder.append("KW1667 : 'KW' '1667';\n");
+		grammarBuilder.append("KW1668 : 'KW' '1668';\n");
+		grammarBuilder.append("KW1669 : 'KW' '1669';\n");
+		grammarBuilder.append("KW1670 : 'KW' '1670';\n");
+		grammarBuilder.append("KW1671 : 'KW' '1671';\n");
+		grammarBuilder.append("KW1672 : 'KW' '1672';\n");
+		grammarBuilder.append("KW1673 : 'KW' '1673';\n");
+		grammarBuilder.append("KW1674 : 'KW' '1674';\n");
+		grammarBuilder.append("KW1675 : 'KW' '1675';\n");
+		grammarBuilder.append("KW1676 : 'KW' '1676';\n");
+		grammarBuilder.append("KW1677 : 'KW' '1677';\n");
+		grammarBuilder.append("KW1678 : 'KW' '1678';\n");
+		grammarBuilder.append("KW1679 : 'KW' '1679';\n");
+		grammarBuilder.append("KW1680 : 'KW' '1680';\n");
+		grammarBuilder.append("KW1681 : 'KW' '1681';\n");
+		grammarBuilder.append("KW1682 : 'KW' '1682';\n");
+		grammarBuilder.append("KW1683 : 'KW' '1683';\n");
+		grammarBuilder.append("KW1684 : 'KW' '1684';\n");
+		grammarBuilder.append("KW1685 : 'KW' '1685';\n");
+		grammarBuilder.append("KW1686 : 'KW' '1686';\n");
+		grammarBuilder.append("KW1687 : 'KW' '1687';\n");
+		grammarBuilder.append("KW1688 : 'KW' '1688';\n");
+		grammarBuilder.append("KW1689 : 'KW' '1689';\n");
+		grammarBuilder.append("KW1690 : 'KW' '1690';\n");
+		grammarBuilder.append("KW1691 : 'KW' '1691';\n");
+		grammarBuilder.append("KW1692 : 'KW' '1692';\n");
+		grammarBuilder.append("KW1693 : 'KW' '1693';\n");
+		grammarBuilder.append("KW1694 : 'KW' '1694';\n");
+		grammarBuilder.append("KW1695 : 'KW' '1695';\n");
+		grammarBuilder.append("KW1696 : 'KW' '1696';\n");
+		grammarBuilder.append("KW1697 : 'KW' '1697';\n");
+		grammarBuilder.append("KW1698 : 'KW' '1698';\n");
+		grammarBuilder.append("KW1699 : 'KW' '1699';\n");
+		grammarBuilder.append("KW1700 : 'KW' '1700';\n");
+		grammarBuilder.append("KW1701 : 'KW' '1701';\n");
+		grammarBuilder.append("KW1702 : 'KW' '1702';\n");
+		grammarBuilder.append("KW1703 : 'KW' '1703';\n");
+		grammarBuilder.append("KW1704 : 'KW' '1704';\n");
+		grammarBuilder.append("KW1705 : 'KW' '1705';\n");
+		grammarBuilder.append("KW1706 : 'KW' '1706';\n");
+		grammarBuilder.append("KW1707 : 'KW' '1707';\n");
+		grammarBuilder.append("KW1708 : 'KW' '1708';\n");
+		grammarBuilder.append("KW1709 : 'KW' '1709';\n");
+		grammarBuilder.append("KW1710 : 'KW' '1710';\n");
+		grammarBuilder.append("KW1711 : 'KW' '1711';\n");
+		grammarBuilder.append("KW1712 : 'KW' '1712';\n");
+		grammarBuilder.append("KW1713 : 'KW' '1713';\n");
+		grammarBuilder.append("KW1714 : 'KW' '1714';\n");
+		grammarBuilder.append("KW1715 : 'KW' '1715';\n");
+		grammarBuilder.append("KW1716 : 'KW' '1716';\n");
+		grammarBuilder.append("KW1717 : 'KW' '1717';\n");
+		grammarBuilder.append("KW1718 : 'KW' '1718';\n");
+		grammarBuilder.append("KW1719 : 'KW' '1719';\n");
+		grammarBuilder.append("KW1720 : 'KW' '1720';\n");
+		grammarBuilder.append("KW1721 : 'KW' '1721';\n");
+		grammarBuilder.append("KW1722 : 'KW' '1722';\n");
+		grammarBuilder.append("KW1723 : 'KW' '1723';\n");
+		grammarBuilder.append("KW1724 : 'KW' '1724';\n");
+		grammarBuilder.append("KW1725 : 'KW' '1725';\n");
+		grammarBuilder.append("KW1726 : 'KW' '1726';\n");
+		grammarBuilder.append("KW1727 : 'KW' '1727';\n");
+		grammarBuilder.append("KW1728 : 'KW' '1728';\n");
+		grammarBuilder.append("KW1729 : 'KW' '1729';\n");
+		grammarBuilder.append("KW1730 : 'KW' '1730';\n");
+		grammarBuilder.append("KW1731 : 'KW' '1731';\n");
+		grammarBuilder.append("KW1732 : 'KW' '1732';\n");
+		grammarBuilder.append("KW1733 : 'KW' '1733';\n");
+		grammarBuilder.append("KW1734 : 'KW' '1734';\n");
+		grammarBuilder.append("KW1735 : 'KW' '1735';\n");
+		grammarBuilder.append("KW1736 : 'KW' '1736';\n");
+		grammarBuilder.append("KW1737 : 'KW' '1737';\n");
+		grammarBuilder.append("KW1738 : 'KW' '1738';\n");
+		grammarBuilder.append("KW1739 : 'KW' '1739';\n");
+		grammarBuilder.append("KW1740 : 'KW' '1740';\n");
+		grammarBuilder.append("KW1741 : 'KW' '1741';\n");
+		grammarBuilder.append("KW1742 : 'KW' '1742';\n");
+		grammarBuilder.append("KW1743 : 'KW' '1743';\n");
+		grammarBuilder.append("KW1744 : 'KW' '1744';\n");
+		grammarBuilder.append("KW1745 : 'KW' '1745';\n");
+		grammarBuilder.append("KW1746 : 'KW' '1746';\n");
+		grammarBuilder.append("KW1747 : 'KW' '1747';\n");
+		grammarBuilder.append("KW1748 : 'KW' '1748';\n");
+		grammarBuilder.append("KW1749 : 'KW' '1749';\n");
+		grammarBuilder.append("KW1750 : 'KW' '1750';\n");
+		grammarBuilder.append("KW1751 : 'KW' '1751';\n");
+		grammarBuilder.append("KW1752 : 'KW' '1752';\n");
+		grammarBuilder.append("KW1753 : 'KW' '1753';\n");
+		grammarBuilder.append("KW1754 : 'KW' '1754';\n");
+		grammarBuilder.append("KW1755 : 'KW' '1755';\n");
+		grammarBuilder.append("KW1756 : 'KW' '1756';\n");
+		grammarBuilder.append("KW1757 : 'KW' '1757';\n");
+		grammarBuilder.append("KW1758 : 'KW' '1758';\n");
+		grammarBuilder.append("KW1759 : 'KW' '1759';\n");
+		grammarBuilder.append("KW1760 : 'KW' '1760';\n");
+		grammarBuilder.append("KW1761 : 'KW' '1761';\n");
+		grammarBuilder.append("KW1762 : 'KW' '1762';\n");
+		grammarBuilder.append("KW1763 : 'KW' '1763';\n");
+		grammarBuilder.append("KW1764 : 'KW' '1764';\n");
+		grammarBuilder.append("KW1765 : 'KW' '1765';\n");
+		grammarBuilder.append("KW1766 : 'KW' '1766';\n");
+		grammarBuilder.append("KW1767 : 'KW' '1767';\n");
+		grammarBuilder.append("KW1768 : 'KW' '1768';\n");
+		grammarBuilder.append("KW1769 : 'KW' '1769';\n");
+		grammarBuilder.append("KW1770 : 'KW' '1770';\n");
+		grammarBuilder.append("KW1771 : 'KW' '1771';\n");
+		grammarBuilder.append("KW1772 : 'KW' '1772';\n");
+		grammarBuilder.append("KW1773 : 'KW' '1773';\n");
+		grammarBuilder.append("KW1774 : 'KW' '1774';\n");
+		grammarBuilder.append("KW1775 : 'KW' '1775';\n");
+		grammarBuilder.append("KW1776 : 'KW' '1776';\n");
+		grammarBuilder.append("KW1777 : 'KW' '1777';\n");
+		grammarBuilder.append("KW1778 : 'KW' '1778';\n");
+		grammarBuilder.append("KW1779 : 'KW' '1779';\n");
+		grammarBuilder.append("KW1780 : 'KW' '1780';\n");
+		grammarBuilder.append("KW1781 : 'KW' '1781';\n");
+		grammarBuilder.append("KW1782 : 'KW' '1782';\n");
+		grammarBuilder.append("KW1783 : 'KW' '1783';\n");
+		grammarBuilder.append("KW1784 : 'KW' '1784';\n");
+		grammarBuilder.append("KW1785 : 'KW' '1785';\n");
+		grammarBuilder.append("KW1786 : 'KW' '1786';\n");
+		grammarBuilder.append("KW1787 : 'KW' '1787';\n");
+		grammarBuilder.append("KW1788 : 'KW' '1788';\n");
+		grammarBuilder.append("KW1789 : 'KW' '1789';\n");
+		grammarBuilder.append("KW1790 : 'KW' '1790';\n");
+		grammarBuilder.append("KW1791 : 'KW' '1791';\n");
+		grammarBuilder.append("KW1792 : 'KW' '1792';\n");
+		grammarBuilder.append("KW1793 : 'KW' '1793';\n");
+		grammarBuilder.append("KW1794 : 'KW' '1794';\n");
+		grammarBuilder.append("KW1795 : 'KW' '1795';\n");
+		grammarBuilder.append("KW1796 : 'KW' '1796';\n");
+		grammarBuilder.append("KW1797 : 'KW' '1797';\n");
+		grammarBuilder.append("KW1798 : 'KW' '1798';\n");
+		grammarBuilder.append("KW1799 : 'KW' '1799';\n");
+		grammarBuilder.append("KW1800 : 'KW' '1800';\n");
+		grammarBuilder.append("KW1801 : 'KW' '1801';\n");
+		grammarBuilder.append("KW1802 : 'KW' '1802';\n");
+		grammarBuilder.append("KW1803 : 'KW' '1803';\n");
+		grammarBuilder.append("KW1804 : 'KW' '1804';\n");
+		grammarBuilder.append("KW1805 : 'KW' '1805';\n");
+		grammarBuilder.append("KW1806 : 'KW' '1806';\n");
+		grammarBuilder.append("KW1807 : 'KW' '1807';\n");
+		grammarBuilder.append("KW1808 : 'KW' '1808';\n");
+		grammarBuilder.append("KW1809 : 'KW' '1809';\n");
+		grammarBuilder.append("KW1810 : 'KW' '1810';\n");
+		grammarBuilder.append("KW1811 : 'KW' '1811';\n");
+		grammarBuilder.append("KW1812 : 'KW' '1812';\n");
+		grammarBuilder.append("KW1813 : 'KW' '1813';\n");
+		grammarBuilder.append("KW1814 : 'KW' '1814';\n");
+		grammarBuilder.append("KW1815 : 'KW' '1815';\n");
+		grammarBuilder.append("KW1816 : 'KW' '1816';\n");
+		grammarBuilder.append("KW1817 : 'KW' '1817';\n");
+		grammarBuilder.append("KW1818 : 'KW' '1818';\n");
+		grammarBuilder.append("KW1819 : 'KW' '1819';\n");
+		grammarBuilder.append("KW1820 : 'KW' '1820';\n");
+		grammarBuilder.append("KW1821 : 'KW' '1821';\n");
+		grammarBuilder.append("KW1822 : 'KW' '1822';\n");
+		grammarBuilder.append("KW1823 : 'KW' '1823';\n");
+		grammarBuilder.append("KW1824 : 'KW' '1824';\n");
+		grammarBuilder.append("KW1825 : 'KW' '1825';\n");
+		grammarBuilder.append("KW1826 : 'KW' '1826';\n");
+		grammarBuilder.append("KW1827 : 'KW' '1827';\n");
+		grammarBuilder.append("KW1828 : 'KW' '1828';\n");
+		grammarBuilder.append("KW1829 : 'KW' '1829';\n");
+		grammarBuilder.append("KW1830 : 'KW' '1830';\n");
+		grammarBuilder.append("KW1831 : 'KW' '1831';\n");
+		grammarBuilder.append("KW1832 : 'KW' '1832';\n");
+		grammarBuilder.append("KW1833 : 'KW' '1833';\n");
+		grammarBuilder.append("KW1834 : 'KW' '1834';\n");
+		grammarBuilder.append("KW1835 : 'KW' '1835';\n");
+		grammarBuilder.append("KW1836 : 'KW' '1836';\n");
+		grammarBuilder.append("KW1837 : 'KW' '1837';\n");
+		grammarBuilder.append("KW1838 : 'KW' '1838';\n");
+		grammarBuilder.append("KW1839 : 'KW' '1839';\n");
+		grammarBuilder.append("KW1840 : 'KW' '1840';\n");
+		grammarBuilder.append("KW1841 : 'KW' '1841';\n");
+		grammarBuilder.append("KW1842 : 'KW' '1842';\n");
+		grammarBuilder.append("KW1843 : 'KW' '1843';\n");
+		grammarBuilder.append("KW1844 : 'KW' '1844';\n");
+		grammarBuilder.append("KW1845 : 'KW' '1845';\n");
+		grammarBuilder.append("KW1846 : 'KW' '1846';\n");
+		grammarBuilder.append("KW1847 : 'KW' '1847';\n");
+		grammarBuilder.append("KW1848 : 'KW' '1848';\n");
+		grammarBuilder.append("KW1849 : 'KW' '1849';\n");
+		grammarBuilder.append("KW1850 : 'KW' '1850';\n");
+		grammarBuilder.append("KW1851 : 'KW' '1851';\n");
+		grammarBuilder.append("KW1852 : 'KW' '1852';\n");
+		grammarBuilder.append("KW1853 : 'KW' '1853';\n");
+		grammarBuilder.append("KW1854 : 'KW' '1854';\n");
+		grammarBuilder.append("KW1855 : 'KW' '1855';\n");
+		grammarBuilder.append("KW1856 : 'KW' '1856';\n");
+		grammarBuilder.append("KW1857 : 'KW' '1857';\n");
+		grammarBuilder.append("KW1858 : 'KW' '1858';\n");
+		grammarBuilder.append("KW1859 : 'KW' '1859';\n");
+		grammarBuilder.append("KW1860 : 'KW' '1860';\n");
+		grammarBuilder.append("KW1861 : 'KW' '1861';\n");
+		grammarBuilder.append("KW1862 : 'KW' '1862';\n");
+		grammarBuilder.append("KW1863 : 'KW' '1863';\n");
+		grammarBuilder.append("KW1864 : 'KW' '1864';\n");
+		grammarBuilder.append("KW1865 : 'KW' '1865';\n");
+		grammarBuilder.append("KW1866 : 'KW' '1866';\n");
+		grammarBuilder.append("KW1867 : 'KW' '1867';\n");
+		grammarBuilder.append("KW1868 : 'KW' '1868';\n");
+		grammarBuilder.append("KW1869 : 'KW' '1869';\n");
+		grammarBuilder.append("KW1870 : 'KW' '1870';\n");
+		grammarBuilder.append("KW1871 : 'KW' '1871';\n");
+		grammarBuilder.append("KW1872 : 'KW' '1872';\n");
+		grammarBuilder.append("KW1873 : 'KW' '1873';\n");
+		grammarBuilder.append("KW1874 : 'KW' '1874';\n");
+		grammarBuilder.append("KW1875 : 'KW' '1875';\n");
+		grammarBuilder.append("KW1876 : 'KW' '1876';\n");
+		grammarBuilder.append("KW1877 : 'KW' '1877';\n");
+		grammarBuilder.append("KW1878 : 'KW' '1878';\n");
+		grammarBuilder.append("KW1879 : 'KW' '1879';\n");
+		grammarBuilder.append("KW1880 : 'KW' '1880';\n");
+		grammarBuilder.append("KW1881 : 'KW' '1881';\n");
+		grammarBuilder.append("KW1882 : 'KW' '1882';\n");
+		grammarBuilder.append("KW1883 : 'KW' '1883';\n");
+		grammarBuilder.append("KW1884 : 'KW' '1884';\n");
+		grammarBuilder.append("KW1885 : 'KW' '1885';\n");
+		grammarBuilder.append("KW1886 : 'KW' '1886';\n");
+		grammarBuilder.append("KW1887 : 'KW' '1887';\n");
+		grammarBuilder.append("KW1888 : 'KW' '1888';\n");
+		grammarBuilder.append("KW1889 : 'KW' '1889';\n");
+		grammarBuilder.append("KW1890 : 'KW' '1890';\n");
+		grammarBuilder.append("KW1891 : 'KW' '1891';\n");
+		grammarBuilder.append("KW1892 : 'KW' '1892';\n");
+		grammarBuilder.append("KW1893 : 'KW' '1893';\n");
+		grammarBuilder.append("KW1894 : 'KW' '1894';\n");
+		grammarBuilder.append("KW1895 : 'KW' '1895';\n");
+		grammarBuilder.append("KW1896 : 'KW' '1896';\n");
+		grammarBuilder.append("KW1897 : 'KW' '1897';\n");
+		grammarBuilder.append("KW1898 : 'KW' '1898';\n");
+		grammarBuilder.append("KW1899 : 'KW' '1899';\n");
+		grammarBuilder.append("KW1900 : 'KW' '1900';\n");
+		grammarBuilder.append("KW1901 : 'KW' '1901';\n");
+		grammarBuilder.append("KW1902 : 'KW' '1902';\n");
+		grammarBuilder.append("KW1903 : 'KW' '1903';\n");
+		grammarBuilder.append("KW1904 : 'KW' '1904';\n");
+		grammarBuilder.append("KW1905 : 'KW' '1905';\n");
+		grammarBuilder.append("KW1906 : 'KW' '1906';\n");
+		grammarBuilder.append("KW1907 : 'KW' '1907';\n");
+		grammarBuilder.append("KW1908 : 'KW' '1908';\n");
+		grammarBuilder.append("KW1909 : 'KW' '1909';\n");
+		grammarBuilder.append("KW1910 : 'KW' '1910';\n");
+		grammarBuilder.append("KW1911 : 'KW' '1911';\n");
+		grammarBuilder.append("KW1912 : 'KW' '1912';\n");
+		grammarBuilder.append("KW1913 : 'KW' '1913';\n");
+		grammarBuilder.append("KW1914 : 'KW' '1914';\n");
+		grammarBuilder.append("KW1915 : 'KW' '1915';\n");
+		grammarBuilder.append("KW1916 : 'KW' '1916';\n");
+		grammarBuilder.append("KW1917 : 'KW' '1917';\n");
+		grammarBuilder.append("KW1918 : 'KW' '1918';\n");
+		grammarBuilder.append("KW1919 : 'KW' '1919';\n");
+		grammarBuilder.append("KW1920 : 'KW' '1920';\n");
+		grammarBuilder.append("KW1921 : 'KW' '1921';\n");
+		grammarBuilder.append("KW1922 : 'KW' '1922';\n");
+		grammarBuilder.append("KW1923 : 'KW' '1923';\n");
+		grammarBuilder.append("KW1924 : 'KW' '1924';\n");
+		grammarBuilder.append("KW1925 : 'KW' '1925';\n");
+		grammarBuilder.append("KW1926 : 'KW' '1926';\n");
+		grammarBuilder.append("KW1927 : 'KW' '1927';\n");
+		grammarBuilder.append("KW1928 : 'KW' '1928';\n");
+		grammarBuilder.append("KW1929 : 'KW' '1929';\n");
+		grammarBuilder.append("KW1930 : 'KW' '1930';\n");
+		grammarBuilder.append("KW1931 : 'KW' '1931';\n");
+		grammarBuilder.append("KW1932 : 'KW' '1932';\n");
+		grammarBuilder.append("KW1933 : 'KW' '1933';\n");
+		grammarBuilder.append("KW1934 : 'KW' '1934';\n");
+		grammarBuilder.append("KW1935 : 'KW' '1935';\n");
+		grammarBuilder.append("KW1936 : 'KW' '1936';\n");
+		grammarBuilder.append("KW1937 : 'KW' '1937';\n");
+		grammarBuilder.append("KW1938 : 'KW' '1938';\n");
+		grammarBuilder.append("KW1939 : 'KW' '1939';\n");
+		grammarBuilder.append("KW1940 : 'KW' '1940';\n");
+		grammarBuilder.append("KW1941 : 'KW' '1941';\n");
+		grammarBuilder.append("KW1942 : 'KW' '1942';\n");
+		grammarBuilder.append("KW1943 : 'KW' '1943';\n");
+		grammarBuilder.append("KW1944 : 'KW' '1944';\n");
+		grammarBuilder.append("KW1945 : 'KW' '1945';\n");
+		grammarBuilder.append("KW1946 : 'KW' '1946';\n");
+		grammarBuilder.append("KW1947 : 'KW' '1947';\n");
+		grammarBuilder.append("KW1948 : 'KW' '1948';\n");
+		grammarBuilder.append("KW1949 : 'KW' '1949';\n");
+		grammarBuilder.append("KW1950 : 'KW' '1950';\n");
+		grammarBuilder.append("KW1951 : 'KW' '1951';\n");
+		grammarBuilder.append("KW1952 : 'KW' '1952';\n");
+		grammarBuilder.append("KW1953 : 'KW' '1953';\n");
+		grammarBuilder.append("KW1954 : 'KW' '1954';\n");
+		grammarBuilder.append("KW1955 : 'KW' '1955';\n");
+		grammarBuilder.append("KW1956 : 'KW' '1956';\n");
+		grammarBuilder.append("KW1957 : 'KW' '1957';\n");
+		grammarBuilder.append("KW1958 : 'KW' '1958';\n");
+		grammarBuilder.append("KW1959 : 'KW' '1959';\n");
+		grammarBuilder.append("KW1960 : 'KW' '1960';\n");
+		grammarBuilder.append("KW1961 : 'KW' '1961';\n");
+		grammarBuilder.append("KW1962 : 'KW' '1962';\n");
+		grammarBuilder.append("KW1963 : 'KW' '1963';\n");
+		grammarBuilder.append("KW1964 : 'KW' '1964';\n");
+		grammarBuilder.append("KW1965 : 'KW' '1965';\n");
+		grammarBuilder.append("KW1966 : 'KW' '1966';\n");
+		grammarBuilder.append("KW1967 : 'KW' '1967';\n");
+		grammarBuilder.append("KW1968 : 'KW' '1968';\n");
+		grammarBuilder.append("KW1969 : 'KW' '1969';\n");
+		grammarBuilder.append("KW1970 : 'KW' '1970';\n");
+		grammarBuilder.append("KW1971 : 'KW' '1971';\n");
+		grammarBuilder.append("KW1972 : 'KW' '1972';\n");
+		grammarBuilder.append("KW1973 : 'KW' '1973';\n");
+		grammarBuilder.append("KW1974 : 'KW' '1974';\n");
+		grammarBuilder.append("KW1975 : 'KW' '1975';\n");
+		grammarBuilder.append("KW1976 : 'KW' '1976';\n");
+		grammarBuilder.append("KW1977 : 'KW' '1977';\n");
+		grammarBuilder.append("KW1978 : 'KW' '1978';\n");
+		grammarBuilder.append("KW1979 : 'KW' '1979';\n");
+		grammarBuilder.append("KW1980 : 'KW' '1980';\n");
+		grammarBuilder.append("KW1981 : 'KW' '1981';\n");
+		grammarBuilder.append("KW1982 : 'KW' '1982';\n");
+		grammarBuilder.append("KW1983 : 'KW' '1983';\n");
+		grammarBuilder.append("KW1984 : 'KW' '1984';\n");
+		grammarBuilder.append("KW1985 : 'KW' '1985';\n");
+		grammarBuilder.append("KW1986 : 'KW' '1986';\n");
+		grammarBuilder.append("KW1987 : 'KW' '1987';\n");
+		grammarBuilder.append("KW1988 : 'KW' '1988';\n");
+		grammarBuilder.append("KW1989 : 'KW' '1989';\n");
+		grammarBuilder.append("KW1990 : 'KW' '1990';\n");
+		grammarBuilder.append("KW1991 : 'KW' '1991';\n");
+		grammarBuilder.append("KW1992 : 'KW' '1992';\n");
+		grammarBuilder.append("KW1993 : 'KW' '1993';\n");
+		grammarBuilder.append("KW1994 : 'KW' '1994';\n");
+		grammarBuilder.append("KW1995 : 'KW' '1995';\n");
+		grammarBuilder.append("KW1996 : 'KW' '1996';\n");
+		grammarBuilder.append("KW1997 : 'KW' '1997';\n");
+		grammarBuilder.append("KW1998 : 'KW' '1998';\n");
+		grammarBuilder.append("KW1999 : 'KW' '1999';\n");
+		grammarBuilder.append("KW2000 : 'KW' '2000';\n");
+		grammarBuilder.append("KW2001 : 'KW' '2001';\n");
+		grammarBuilder.append("KW2002 : 'KW' '2002';\n");
+		grammarBuilder.append("KW2003 : 'KW' '2003';\n");
+		grammarBuilder.append("KW2004 : 'KW' '2004';\n");
+		grammarBuilder.append("KW2005 : 'KW' '2005';\n");
+		grammarBuilder.append("KW2006 : 'KW' '2006';\n");
+		grammarBuilder.append("KW2007 : 'KW' '2007';\n");
+		grammarBuilder.append("KW2008 : 'KW' '2008';\n");
+		grammarBuilder.append("KW2009 : 'KW' '2009';\n");
+		grammarBuilder.append("KW2010 : 'KW' '2010';\n");
+		grammarBuilder.append("KW2011 : 'KW' '2011';\n");
+		grammarBuilder.append("KW2012 : 'KW' '2012';\n");
+		grammarBuilder.append("KW2013 : 'KW' '2013';\n");
+		grammarBuilder.append("KW2014 : 'KW' '2014';\n");
+		grammarBuilder.append("KW2015 : 'KW' '2015';\n");
+		grammarBuilder.append("KW2016 : 'KW' '2016';\n");
+		grammarBuilder.append("KW2017 : 'KW' '2017';\n");
+		grammarBuilder.append("KW2018 : 'KW' '2018';\n");
+		grammarBuilder.append("KW2019 : 'KW' '2019';\n");
+		grammarBuilder.append("KW2020 : 'KW' '2020';\n");
+		grammarBuilder.append("KW2021 : 'KW' '2021';\n");
+		grammarBuilder.append("KW2022 : 'KW' '2022';\n");
+		grammarBuilder.append("KW2023 : 'KW' '2023';\n");
+		grammarBuilder.append("KW2024 : 'KW' '2024';\n");
+		grammarBuilder.append("KW2025 : 'KW' '2025';\n");
+		grammarBuilder.append("KW2026 : 'KW' '2026';\n");
+		grammarBuilder.append("KW2027 : 'KW' '2027';\n");
+		grammarBuilder.append("KW2028 : 'KW' '2028';\n");
+		grammarBuilder.append("KW2029 : 'KW' '2029';\n");
+		grammarBuilder.append("KW2030 : 'KW' '2030';\n");
+		grammarBuilder.append("KW2031 : 'KW' '2031';\n");
+		grammarBuilder.append("KW2032 : 'KW' '2032';\n");
+		grammarBuilder.append("KW2033 : 'KW' '2033';\n");
+		grammarBuilder.append("KW2034 : 'KW' '2034';\n");
+		grammarBuilder.append("KW2035 : 'KW' '2035';\n");
+		grammarBuilder.append("KW2036 : 'KW' '2036';\n");
+		grammarBuilder.append("KW2037 : 'KW' '2037';\n");
+		grammarBuilder.append("KW2038 : 'KW' '2038';\n");
+		grammarBuilder.append("KW2039 : 'KW' '2039';\n");
+		grammarBuilder.append("KW2040 : 'KW' '2040';\n");
+		grammarBuilder.append("KW2041 : 'KW' '2041';\n");
+		grammarBuilder.append("KW2042 : 'KW' '2042';\n");
+		grammarBuilder.append("KW2043 : 'KW' '2043';\n");
+		grammarBuilder.append("KW2044 : 'KW' '2044';\n");
+		grammarBuilder.append("KW2045 : 'KW' '2045';\n");
+		grammarBuilder.append("KW2046 : 'KW' '2046';\n");
+		grammarBuilder.append("KW2047 : 'KW' '2047';\n");
+		grammarBuilder.append("KW2048 : 'KW' '2048';\n");
+		grammarBuilder.append("KW2049 : 'KW' '2049';\n");
+		grammarBuilder.append("KW2050 : 'KW' '2050';\n");
+		grammarBuilder.append("KW2051 : 'KW' '2051';\n");
+		grammarBuilder.append("KW2052 : 'KW' '2052';\n");
+		grammarBuilder.append("KW2053 : 'KW' '2053';\n");
+		grammarBuilder.append("KW2054 : 'KW' '2054';\n");
+		grammarBuilder.append("KW2055 : 'KW' '2055';\n");
+		grammarBuilder.append("KW2056 : 'KW' '2056';\n");
+		grammarBuilder.append("KW2057 : 'KW' '2057';\n");
+		grammarBuilder.append("KW2058 : 'KW' '2058';\n");
+		grammarBuilder.append("KW2059 : 'KW' '2059';\n");
+		grammarBuilder.append("KW2060 : 'KW' '2060';\n");
+		grammarBuilder.append("KW2061 : 'KW' '2061';\n");
+		grammarBuilder.append("KW2062 : 'KW' '2062';\n");
+		grammarBuilder.append("KW2063 : 'KW' '2063';\n");
+		grammarBuilder.append("KW2064 : 'KW' '2064';\n");
+		grammarBuilder.append("KW2065 : 'KW' '2065';\n");
+		grammarBuilder.append("KW2066 : 'KW' '2066';\n");
+		grammarBuilder.append("KW2067 : 'KW' '2067';\n");
+		grammarBuilder.append("KW2068 : 'KW' '2068';\n");
+		grammarBuilder.append("KW2069 : 'KW' '2069';\n");
+		grammarBuilder.append("KW2070 : 'KW' '2070';\n");
+		grammarBuilder.append("KW2071 : 'KW' '2071';\n");
+		grammarBuilder.append("KW2072 : 'KW' '2072';\n");
+		grammarBuilder.append("KW2073 : 'KW' '2073';\n");
+		grammarBuilder.append("KW2074 : 'KW' '2074';\n");
+		grammarBuilder.append("KW2075 : 'KW' '2075';\n");
+		grammarBuilder.append("KW2076 : 'KW' '2076';\n");
+		grammarBuilder.append("KW2077 : 'KW' '2077';\n");
+		grammarBuilder.append("KW2078 : 'KW' '2078';\n");
+		grammarBuilder.append("KW2079 : 'KW' '2079';\n");
+		grammarBuilder.append("KW2080 : 'KW' '2080';\n");
+		grammarBuilder.append("KW2081 : 'KW' '2081';\n");
+		grammarBuilder.append("KW2082 : 'KW' '2082';\n");
+		grammarBuilder.append("KW2083 : 'KW' '2083';\n");
+		grammarBuilder.append("KW2084 : 'KW' '2084';\n");
+		grammarBuilder.append("KW2085 : 'KW' '2085';\n");
+		grammarBuilder.append("KW2086 : 'KW' '2086';\n");
+		grammarBuilder.append("KW2087 : 'KW' '2087';\n");
+		grammarBuilder.append("KW2088 : 'KW' '2088';\n");
+		grammarBuilder.append("KW2089 : 'KW' '2089';\n");
+		grammarBuilder.append("KW2090 : 'KW' '2090';\n");
+		grammarBuilder.append("KW2091 : 'KW' '2091';\n");
+		grammarBuilder.append("KW2092 : 'KW' '2092';\n");
+		grammarBuilder.append("KW2093 : 'KW' '2093';\n");
+		grammarBuilder.append("KW2094 : 'KW' '2094';\n");
+		grammarBuilder.append("KW2095 : 'KW' '2095';\n");
+		grammarBuilder.append("KW2096 : 'KW' '2096';\n");
+		grammarBuilder.append("KW2097 : 'KW' '2097';\n");
+		grammarBuilder.append("KW2098 : 'KW' '2098';\n");
+		grammarBuilder.append("KW2099 : 'KW' '2099';\n");
+		grammarBuilder.append("KW2100 : 'KW' '2100';\n");
+		grammarBuilder.append("KW2101 : 'KW' '2101';\n");
+		grammarBuilder.append("KW2102 : 'KW' '2102';\n");
+		grammarBuilder.append("KW2103 : 'KW' '2103';\n");
+		grammarBuilder.append("KW2104 : 'KW' '2104';\n");
+		grammarBuilder.append("KW2105 : 'KW' '2105';\n");
+		grammarBuilder.append("KW2106 : 'KW' '2106';\n");
+		grammarBuilder.append("KW2107 : 'KW' '2107';\n");
+		grammarBuilder.append("KW2108 : 'KW' '2108';\n");
+		grammarBuilder.append("KW2109 : 'KW' '2109';\n");
+		grammarBuilder.append("KW2110 : 'KW' '2110';\n");
+		grammarBuilder.append("KW2111 : 'KW' '2111';\n");
+		grammarBuilder.append("KW2112 : 'KW' '2112';\n");
+		grammarBuilder.append("KW2113 : 'KW' '2113';\n");
+		grammarBuilder.append("KW2114 : 'KW' '2114';\n");
+		grammarBuilder.append("KW2115 : 'KW' '2115';\n");
+		grammarBuilder.append("KW2116 : 'KW' '2116';\n");
+		grammarBuilder.append("KW2117 : 'KW' '2117';\n");
+		grammarBuilder.append("KW2118 : 'KW' '2118';\n");
+		grammarBuilder.append("KW2119 : 'KW' '2119';\n");
+		grammarBuilder.append("KW2120 : 'KW' '2120';\n");
+		grammarBuilder.append("KW2121 : 'KW' '2121';\n");
+		grammarBuilder.append("KW2122 : 'KW' '2122';\n");
+		grammarBuilder.append("KW2123 : 'KW' '2123';\n");
+		grammarBuilder.append("KW2124 : 'KW' '2124';\n");
+		grammarBuilder.append("KW2125 : 'KW' '2125';\n");
+		grammarBuilder.append("KW2126 : 'KW' '2126';\n");
+		grammarBuilder.append("KW2127 : 'KW' '2127';\n");
+		grammarBuilder.append("KW2128 : 'KW' '2128';\n");
+		grammarBuilder.append("KW2129 : 'KW' '2129';\n");
+		grammarBuilder.append("KW2130 : 'KW' '2130';\n");
+		grammarBuilder.append("KW2131 : 'KW' '2131';\n");
+		grammarBuilder.append("KW2132 : 'KW' '2132';\n");
+		grammarBuilder.append("KW2133 : 'KW' '2133';\n");
+		grammarBuilder.append("KW2134 : 'KW' '2134';\n");
+		grammarBuilder.append("KW2135 : 'KW' '2135';\n");
+		grammarBuilder.append("KW2136 : 'KW' '2136';\n");
+		grammarBuilder.append("KW2137 : 'KW' '2137';\n");
+		grammarBuilder.append("KW2138 : 'KW' '2138';\n");
+		grammarBuilder.append("KW2139 : 'KW' '2139';\n");
+		grammarBuilder.append("KW2140 : 'KW' '2140';\n");
+		grammarBuilder.append("KW2141 : 'KW' '2141';\n");
+		grammarBuilder.append("KW2142 : 'KW' '2142';\n");
+		grammarBuilder.append("KW2143 : 'KW' '2143';\n");
+		grammarBuilder.append("KW2144 : 'KW' '2144';\n");
+		grammarBuilder.append("KW2145 : 'KW' '2145';\n");
+		grammarBuilder.append("KW2146 : 'KW' '2146';\n");
+		grammarBuilder.append("KW2147 : 'KW' '2147';\n");
+		grammarBuilder.append("KW2148 : 'KW' '2148';\n");
+		grammarBuilder.append("KW2149 : 'KW' '2149';\n");
+		grammarBuilder.append("KW2150 : 'KW' '2150';\n");
+		grammarBuilder.append("KW2151 : 'KW' '2151';\n");
+		grammarBuilder.append("KW2152 : 'KW' '2152';\n");
+		grammarBuilder.append("KW2153 : 'KW' '2153';\n");
+		grammarBuilder.append("KW2154 : 'KW' '2154';\n");
+		grammarBuilder.append("KW2155 : 'KW' '2155';\n");
+		grammarBuilder.append("KW2156 : 'KW' '2156';\n");
+		grammarBuilder.append("KW2157 : 'KW' '2157';\n");
+		grammarBuilder.append("KW2158 : 'KW' '2158';\n");
+		grammarBuilder.append("KW2159 : 'KW' '2159';\n");
+		grammarBuilder.append("KW2160 : 'KW' '2160';\n");
+		grammarBuilder.append("KW2161 : 'KW' '2161';\n");
+		grammarBuilder.append("KW2162 : 'KW' '2162';\n");
+		grammarBuilder.append("KW2163 : 'KW' '2163';\n");
+		grammarBuilder.append("KW2164 : 'KW' '2164';\n");
+		grammarBuilder.append("KW2165 : 'KW' '2165';\n");
+		grammarBuilder.append("KW2166 : 'KW' '2166';\n");
+		grammarBuilder.append("KW2167 : 'KW' '2167';\n");
+		grammarBuilder.append("KW2168 : 'KW' '2168';\n");
+		grammarBuilder.append("KW2169 : 'KW' '2169';\n");
+		grammarBuilder.append("KW2170 : 'KW' '2170';\n");
+		grammarBuilder.append("KW2171 : 'KW' '2171';\n");
+		grammarBuilder.append("KW2172 : 'KW' '2172';\n");
+		grammarBuilder.append("KW2173 : 'KW' '2173';\n");
+		grammarBuilder.append("KW2174 : 'KW' '2174';\n");
+		grammarBuilder.append("KW2175 : 'KW' '2175';\n");
+		grammarBuilder.append("KW2176 : 'KW' '2176';\n");
+		grammarBuilder.append("KW2177 : 'KW' '2177';\n");
+		grammarBuilder.append("KW2178 : 'KW' '2178';\n");
+		grammarBuilder.append("KW2179 : 'KW' '2179';\n");
+		grammarBuilder.append("KW2180 : 'KW' '2180';\n");
+		grammarBuilder.append("KW2181 : 'KW' '2181';\n");
+		grammarBuilder.append("KW2182 : 'KW' '2182';\n");
+		grammarBuilder.append("KW2183 : 'KW' '2183';\n");
+		grammarBuilder.append("KW2184 : 'KW' '2184';\n");
+		grammarBuilder.append("KW2185 : 'KW' '2185';\n");
+		grammarBuilder.append("KW2186 : 'KW' '2186';\n");
+		grammarBuilder.append("KW2187 : 'KW' '2187';\n");
+		grammarBuilder.append("KW2188 : 'KW' '2188';\n");
+		grammarBuilder.append("KW2189 : 'KW' '2189';\n");
+		grammarBuilder.append("KW2190 : 'KW' '2190';\n");
+		grammarBuilder.append("KW2191 : 'KW' '2191';\n");
+		grammarBuilder.append("KW2192 : 'KW' '2192';\n");
+		grammarBuilder.append("KW2193 : 'KW' '2193';\n");
+		grammarBuilder.append("KW2194 : 'KW' '2194';\n");
+		grammarBuilder.append("KW2195 : 'KW' '2195';\n");
+		grammarBuilder.append("KW2196 : 'KW' '2196';\n");
+		grammarBuilder.append("KW2197 : 'KW' '2197';\n");
+		grammarBuilder.append("KW2198 : 'KW' '2198';\n");
+		grammarBuilder.append("KW2199 : 'KW' '2199';\n");
+		grammarBuilder.append("KW2200 : 'KW' '2200';\n");
+		grammarBuilder.append("KW2201 : 'KW' '2201';\n");
+		grammarBuilder.append("KW2202 : 'KW' '2202';\n");
+		grammarBuilder.append("KW2203 : 'KW' '2203';\n");
+		grammarBuilder.append("KW2204 : 'KW' '2204';\n");
+		grammarBuilder.append("KW2205 : 'KW' '2205';\n");
+		grammarBuilder.append("KW2206 : 'KW' '2206';\n");
+		grammarBuilder.append("KW2207 : 'KW' '2207';\n");
+		grammarBuilder.append("KW2208 : 'KW' '2208';\n");
+		grammarBuilder.append("KW2209 : 'KW' '2209';\n");
+		grammarBuilder.append("KW2210 : 'KW' '2210';\n");
+		grammarBuilder.append("KW2211 : 'KW' '2211';\n");
+		grammarBuilder.append("KW2212 : 'KW' '2212';\n");
+		grammarBuilder.append("KW2213 : 'KW' '2213';\n");
+		grammarBuilder.append("KW2214 : 'KW' '2214';\n");
+		grammarBuilder.append("KW2215 : 'KW' '2215';\n");
+		grammarBuilder.append("KW2216 : 'KW' '2216';\n");
+		grammarBuilder.append("KW2217 : 'KW' '2217';\n");
+		grammarBuilder.append("KW2218 : 'KW' '2218';\n");
+		grammarBuilder.append("KW2219 : 'KW' '2219';\n");
+		grammarBuilder.append("KW2220 : 'KW' '2220';\n");
+		grammarBuilder.append("KW2221 : 'KW' '2221';\n");
+		grammarBuilder.append("KW2222 : 'KW' '2222';\n");
+		grammarBuilder.append("KW2223 : 'KW' '2223';\n");
+		grammarBuilder.append("KW2224 : 'KW' '2224';\n");
+		grammarBuilder.append("KW2225 : 'KW' '2225';\n");
+		grammarBuilder.append("KW2226 : 'KW' '2226';\n");
+		grammarBuilder.append("KW2227 : 'KW' '2227';\n");
+		grammarBuilder.append("KW2228 : 'KW' '2228';\n");
+		grammarBuilder.append("KW2229 : 'KW' '2229';\n");
+		grammarBuilder.append("KW2230 : 'KW' '2230';\n");
+		grammarBuilder.append("KW2231 : 'KW' '2231';\n");
+		grammarBuilder.append("KW2232 : 'KW' '2232';\n");
+		grammarBuilder.append("KW2233 : 'KW' '2233';\n");
+		grammarBuilder.append("KW2234 : 'KW' '2234';\n");
+		grammarBuilder.append("KW2235 : 'KW' '2235';\n");
+		grammarBuilder.append("KW2236 : 'KW' '2236';\n");
+		grammarBuilder.append("KW2237 : 'KW' '2237';\n");
+		grammarBuilder.append("KW2238 : 'KW' '2238';\n");
+		grammarBuilder.append("KW2239 : 'KW' '2239';\n");
+		grammarBuilder.append("KW2240 : 'KW' '2240';\n");
+		grammarBuilder.append("KW2241 : 'KW' '2241';\n");
+		grammarBuilder.append("KW2242 : 'KW' '2242';\n");
+		grammarBuilder.append("KW2243 : 'KW' '2243';\n");
+		grammarBuilder.append("KW2244 : 'KW' '2244';\n");
+		grammarBuilder.append("KW2245 : 'KW' '2245';\n");
+		grammarBuilder.append("KW2246 : 'KW' '2246';\n");
+		grammarBuilder.append("KW2247 : 'KW' '2247';\n");
+		grammarBuilder.append("KW2248 : 'KW' '2248';\n");
+		grammarBuilder.append("KW2249 : 'KW' '2249';\n");
+		grammarBuilder.append("KW2250 : 'KW' '2250';\n");
+		grammarBuilder.append("KW2251 : 'KW' '2251';\n");
+		grammarBuilder.append("KW2252 : 'KW' '2252';\n");
+		grammarBuilder.append("KW2253 : 'KW' '2253';\n");
+		grammarBuilder.append("KW2254 : 'KW' '2254';\n");
+		grammarBuilder.append("KW2255 : 'KW' '2255';\n");
+		grammarBuilder.append("KW2256 : 'KW' '2256';\n");
+		grammarBuilder.append("KW2257 : 'KW' '2257';\n");
+		grammarBuilder.append("KW2258 : 'KW' '2258';\n");
+		grammarBuilder.append("KW2259 : 'KW' '2259';\n");
+		grammarBuilder.append("KW2260 : 'KW' '2260';\n");
+		grammarBuilder.append("KW2261 : 'KW' '2261';\n");
+		grammarBuilder.append("KW2262 : 'KW' '2262';\n");
+		grammarBuilder.append("KW2263 : 'KW' '2263';\n");
+		grammarBuilder.append("KW2264 : 'KW' '2264';\n");
+		grammarBuilder.append("KW2265 : 'KW' '2265';\n");
+		grammarBuilder.append("KW2266 : 'KW' '2266';\n");
+		grammarBuilder.append("KW2267 : 'KW' '2267';\n");
+		grammarBuilder.append("KW2268 : 'KW' '2268';\n");
+		grammarBuilder.append("KW2269 : 'KW' '2269';\n");
+		grammarBuilder.append("KW2270 : 'KW' '2270';\n");
+		grammarBuilder.append("KW2271 : 'KW' '2271';\n");
+		grammarBuilder.append("KW2272 : 'KW' '2272';\n");
+		grammarBuilder.append("KW2273 : 'KW' '2273';\n");
+		grammarBuilder.append("KW2274 : 'KW' '2274';\n");
+		grammarBuilder.append("KW2275 : 'KW' '2275';\n");
+		grammarBuilder.append("KW2276 : 'KW' '2276';\n");
+		grammarBuilder.append("KW2277 : 'KW' '2277';\n");
+		grammarBuilder.append("KW2278 : 'KW' '2278';\n");
+		grammarBuilder.append("KW2279 : 'KW' '2279';\n");
+		grammarBuilder.append("KW2280 : 'KW' '2280';\n");
+		grammarBuilder.append("KW2281 : 'KW' '2281';\n");
+		grammarBuilder.append("KW2282 : 'KW' '2282';\n");
+		grammarBuilder.append("KW2283 : 'KW' '2283';\n");
+		grammarBuilder.append("KW2284 : 'KW' '2284';\n");
+		grammarBuilder.append("KW2285 : 'KW' '2285';\n");
+		grammarBuilder.append("KW2286 : 'KW' '2286';\n");
+		grammarBuilder.append("KW2287 : 'KW' '2287';\n");
+		grammarBuilder.append("KW2288 : 'KW' '2288';\n");
+		grammarBuilder.append("KW2289 : 'KW' '2289';\n");
+		grammarBuilder.append("KW2290 : 'KW' '2290';\n");
+		grammarBuilder.append("KW2291 : 'KW' '2291';\n");
+		grammarBuilder.append("KW2292 : 'KW' '2292';\n");
+		grammarBuilder.append("KW2293 : 'KW' '2293';\n");
+		grammarBuilder.append("KW2294 : 'KW' '2294';\n");
+		grammarBuilder.append("KW2295 : 'KW' '2295';\n");
+		grammarBuilder.append("KW2296 : 'KW' '2296';\n");
+		grammarBuilder.append("KW2297 : 'KW' '2297';\n");
+		grammarBuilder.append("KW2298 : 'KW' '2298';\n");
+		grammarBuilder.append("KW2299 : 'KW' '2299';\n");
+		grammarBuilder.append("KW2300 : 'KW' '2300';\n");
+		grammarBuilder.append("KW2301 : 'KW' '2301';\n");
+		grammarBuilder.append("KW2302 : 'KW' '2302';\n");
+		grammarBuilder.append("KW2303 : 'KW' '2303';\n");
+		grammarBuilder.append("KW2304 : 'KW' '2304';\n");
+		grammarBuilder.append("KW2305 : 'KW' '2305';\n");
+		grammarBuilder.append("KW2306 : 'KW' '2306';\n");
+		grammarBuilder.append("KW2307 : 'KW' '2307';\n");
+		grammarBuilder.append("KW2308 : 'KW' '2308';\n");
+		grammarBuilder.append("KW2309 : 'KW' '2309';\n");
+		grammarBuilder.append("KW2310 : 'KW' '2310';\n");
+		grammarBuilder.append("KW2311 : 'KW' '2311';\n");
+		grammarBuilder.append("KW2312 : 'KW' '2312';\n");
+		grammarBuilder.append("KW2313 : 'KW' '2313';\n");
+		grammarBuilder.append("KW2314 : 'KW' '2314';\n");
+		grammarBuilder.append("KW2315 : 'KW' '2315';\n");
+		grammarBuilder.append("KW2316 : 'KW' '2316';\n");
+		grammarBuilder.append("KW2317 : 'KW' '2317';\n");
+		grammarBuilder.append("KW2318 : 'KW' '2318';\n");
+		grammarBuilder.append("KW2319 : 'KW' '2319';\n");
+		grammarBuilder.append("KW2320 : 'KW' '2320';\n");
+		grammarBuilder.append("KW2321 : 'KW' '2321';\n");
+		grammarBuilder.append("KW2322 : 'KW' '2322';\n");
+		grammarBuilder.append("KW2323 : 'KW' '2323';\n");
+		grammarBuilder.append("KW2324 : 'KW' '2324';\n");
+		grammarBuilder.append("KW2325 : 'KW' '2325';\n");
+		grammarBuilder.append("KW2326 : 'KW' '2326';\n");
+		grammarBuilder.append("KW2327 : 'KW' '2327';\n");
+		grammarBuilder.append("KW2328 : 'KW' '2328';\n");
+		grammarBuilder.append("KW2329 : 'KW' '2329';\n");
+		grammarBuilder.append("KW2330 : 'KW' '2330';\n");
+		grammarBuilder.append("KW2331 : 'KW' '2331';\n");
+		grammarBuilder.append("KW2332 : 'KW' '2332';\n");
+		grammarBuilder.append("KW2333 : 'KW' '2333';\n");
+		grammarBuilder.append("KW2334 : 'KW' '2334';\n");
+		grammarBuilder.append("KW2335 : 'KW' '2335';\n");
+		grammarBuilder.append("KW2336 : 'KW' '2336';\n");
+		grammarBuilder.append("KW2337 : 'KW' '2337';\n");
+		grammarBuilder.append("KW2338 : 'KW' '2338';\n");
+		grammarBuilder.append("KW2339 : 'KW' '2339';\n");
+		grammarBuilder.append("KW2340 : 'KW' '2340';\n");
+		grammarBuilder.append("KW2341 : 'KW' '2341';\n");
+		grammarBuilder.append("KW2342 : 'KW' '2342';\n");
+		grammarBuilder.append("KW2343 : 'KW' '2343';\n");
+		grammarBuilder.append("KW2344 : 'KW' '2344';\n");
+		grammarBuilder.append("KW2345 : 'KW' '2345';\n");
+		grammarBuilder.append("KW2346 : 'KW' '2346';\n");
+		grammarBuilder.append("KW2347 : 'KW' '2347';\n");
+		grammarBuilder.append("KW2348 : 'KW' '2348';\n");
+		grammarBuilder.append("KW2349 : 'KW' '2349';\n");
+		grammarBuilder.append("KW2350 : 'KW' '2350';\n");
+		grammarBuilder.append("KW2351 : 'KW' '2351';\n");
+		grammarBuilder.append("KW2352 : 'KW' '2352';\n");
+		grammarBuilder.append("KW2353 : 'KW' '2353';\n");
+		grammarBuilder.append("KW2354 : 'KW' '2354';\n");
+		grammarBuilder.append("KW2355 : 'KW' '2355';\n");
+		grammarBuilder.append("KW2356 : 'KW' '2356';\n");
+		grammarBuilder.append("KW2357 : 'KW' '2357';\n");
+		grammarBuilder.append("KW2358 : 'KW' '2358';\n");
+		grammarBuilder.append("KW2359 : 'KW' '2359';\n");
+		grammarBuilder.append("KW2360 : 'KW' '2360';\n");
+		grammarBuilder.append("KW2361 : 'KW' '2361';\n");
+		grammarBuilder.append("KW2362 : 'KW' '2362';\n");
+		grammarBuilder.append("KW2363 : 'KW' '2363';\n");
+		grammarBuilder.append("KW2364 : 'KW' '2364';\n");
+		grammarBuilder.append("KW2365 : 'KW' '2365';\n");
+		grammarBuilder.append("KW2366 : 'KW' '2366';\n");
+		grammarBuilder.append("KW2367 : 'KW' '2367';\n");
+		grammarBuilder.append("KW2368 : 'KW' '2368';\n");
+		grammarBuilder.append("KW2369 : 'KW' '2369';\n");
+		grammarBuilder.append("KW2370 : 'KW' '2370';\n");
+		grammarBuilder.append("KW2371 : 'KW' '2371';\n");
+		grammarBuilder.append("KW2372 : 'KW' '2372';\n");
+		grammarBuilder.append("KW2373 : 'KW' '2373';\n");
+		grammarBuilder.append("KW2374 : 'KW' '2374';\n");
+		grammarBuilder.append("KW2375 : 'KW' '2375';\n");
+		grammarBuilder.append("KW2376 : 'KW' '2376';\n");
+		grammarBuilder.append("KW2377 : 'KW' '2377';\n");
+		grammarBuilder.append("KW2378 : 'KW' '2378';\n");
+		grammarBuilder.append("KW2379 : 'KW' '2379';\n");
+		grammarBuilder.append("KW2380 : 'KW' '2380';\n");
+		grammarBuilder.append("KW2381 : 'KW' '2381';\n");
+		grammarBuilder.append("KW2382 : 'KW' '2382';\n");
+		grammarBuilder.append("KW2383 : 'KW' '2383';\n");
+		grammarBuilder.append("KW2384 : 'KW' '2384';\n");
+		grammarBuilder.append("KW2385 : 'KW' '2385';\n");
+		grammarBuilder.append("KW2386 : 'KW' '2386';\n");
+		grammarBuilder.append("KW2387 : 'KW' '2387';\n");
+		grammarBuilder.append("KW2388 : 'KW' '2388';\n");
+		grammarBuilder.append("KW2389 : 'KW' '2389';\n");
+		grammarBuilder.append("KW2390 : 'KW' '2390';\n");
+		grammarBuilder.append("KW2391 : 'KW' '2391';\n");
+		grammarBuilder.append("KW2392 : 'KW' '2392';\n");
+		grammarBuilder.append("KW2393 : 'KW' '2393';\n");
+		grammarBuilder.append("KW2394 : 'KW' '2394';\n");
+		grammarBuilder.append("KW2395 : 'KW' '2395';\n");
+		grammarBuilder.append("KW2396 : 'KW' '2396';\n");
+		grammarBuilder.append("KW2397 : 'KW' '2397';\n");
+		grammarBuilder.append("KW2398 : 'KW' '2398';\n");
+		grammarBuilder.append("KW2399 : 'KW' '2399';\n");
+		grammarBuilder.append("KW2400 : 'KW' '2400';\n");
+		grammarBuilder.append("KW2401 : 'KW' '2401';\n");
+		grammarBuilder.append("KW2402 : 'KW' '2402';\n");
+		grammarBuilder.append("KW2403 : 'KW' '2403';\n");
+		grammarBuilder.append("KW2404 : 'KW' '2404';\n");
+		grammarBuilder.append("KW2405 : 'KW' '2405';\n");
+		grammarBuilder.append("KW2406 : 'KW' '2406';\n");
+		grammarBuilder.append("KW2407 : 'KW' '2407';\n");
+		grammarBuilder.append("KW2408 : 'KW' '2408';\n");
+		grammarBuilder.append("KW2409 : 'KW' '2409';\n");
+		grammarBuilder.append("KW2410 : 'KW' '2410';\n");
+		grammarBuilder.append("KW2411 : 'KW' '2411';\n");
+		grammarBuilder.append("KW2412 : 'KW' '2412';\n");
+		grammarBuilder.append("KW2413 : 'KW' '2413';\n");
+		grammarBuilder.append("KW2414 : 'KW' '2414';\n");
+		grammarBuilder.append("KW2415 : 'KW' '2415';\n");
+		grammarBuilder.append("KW2416 : 'KW' '2416';\n");
+		grammarBuilder.append("KW2417 : 'KW' '2417';\n");
+		grammarBuilder.append("KW2418 : 'KW' '2418';\n");
+		grammarBuilder.append("KW2419 : 'KW' '2419';\n");
+		grammarBuilder.append("KW2420 : 'KW' '2420';\n");
+		grammarBuilder.append("KW2421 : 'KW' '2421';\n");
+		grammarBuilder.append("KW2422 : 'KW' '2422';\n");
+		grammarBuilder.append("KW2423 : 'KW' '2423';\n");
+		grammarBuilder.append("KW2424 : 'KW' '2424';\n");
+		grammarBuilder.append("KW2425 : 'KW' '2425';\n");
+		grammarBuilder.append("KW2426 : 'KW' '2426';\n");
+		grammarBuilder.append("KW2427 : 'KW' '2427';\n");
+		grammarBuilder.append("KW2428 : 'KW' '2428';\n");
+		grammarBuilder.append("KW2429 : 'KW' '2429';\n");
+		grammarBuilder.append("KW2430 : 'KW' '2430';\n");
+		grammarBuilder.append("KW2431 : 'KW' '2431';\n");
+		grammarBuilder.append("KW2432 : 'KW' '2432';\n");
+		grammarBuilder.append("KW2433 : 'KW' '2433';\n");
+		grammarBuilder.append("KW2434 : 'KW' '2434';\n");
+		grammarBuilder.append("KW2435 : 'KW' '2435';\n");
+		grammarBuilder.append("KW2436 : 'KW' '2436';\n");
+		grammarBuilder.append("KW2437 : 'KW' '2437';\n");
+		grammarBuilder.append("KW2438 : 'KW' '2438';\n");
+		grammarBuilder.append("KW2439 : 'KW' '2439';\n");
+		grammarBuilder.append("KW2440 : 'KW' '2440';\n");
+		grammarBuilder.append("KW2441 : 'KW' '2441';\n");
+		grammarBuilder.append("KW2442 : 'KW' '2442';\n");
+		grammarBuilder.append("KW2443 : 'KW' '2443';\n");
+		grammarBuilder.append("KW2444 : 'KW' '2444';\n");
+		grammarBuilder.append("KW2445 : 'KW' '2445';\n");
+		grammarBuilder.append("KW2446 : 'KW' '2446';\n");
+		grammarBuilder.append("KW2447 : 'KW' '2447';\n");
+		grammarBuilder.append("KW2448 : 'KW' '2448';\n");
+		grammarBuilder.append("KW2449 : 'KW' '2449';\n");
+		grammarBuilder.append("KW2450 : 'KW' '2450';\n");
+		grammarBuilder.append("KW2451 : 'KW' '2451';\n");
+		grammarBuilder.append("KW2452 : 'KW' '2452';\n");
+		grammarBuilder.append("KW2453 : 'KW' '2453';\n");
+		grammarBuilder.append("KW2454 : 'KW' '2454';\n");
+		grammarBuilder.append("KW2455 : 'KW' '2455';\n");
+		grammarBuilder.append("KW2456 : 'KW' '2456';\n");
+		grammarBuilder.append("KW2457 : 'KW' '2457';\n");
+		grammarBuilder.append("KW2458 : 'KW' '2458';\n");
+		grammarBuilder.append("KW2459 : 'KW' '2459';\n");
+		grammarBuilder.append("KW2460 : 'KW' '2460';\n");
+		grammarBuilder.append("KW2461 : 'KW' '2461';\n");
+		grammarBuilder.append("KW2462 : 'KW' '2462';\n");
+		grammarBuilder.append("KW2463 : 'KW' '2463';\n");
+		grammarBuilder.append("KW2464 : 'KW' '2464';\n");
+		grammarBuilder.append("KW2465 : 'KW' '2465';\n");
+		grammarBuilder.append("KW2466 : 'KW' '2466';\n");
+		grammarBuilder.append("KW2467 : 'KW' '2467';\n");
+		grammarBuilder.append("KW2468 : 'KW' '2468';\n");
+		grammarBuilder.append("KW2469 : 'KW' '2469';\n");
+		grammarBuilder.append("KW2470 : 'KW' '2470';\n");
+		grammarBuilder.append("KW2471 : 'KW' '2471';\n");
+		grammarBuilder.append("KW2472 : 'KW' '2472';\n");
+		grammarBuilder.append("KW2473 : 'KW' '2473';\n");
+		grammarBuilder.append("KW2474 : 'KW' '2474';\n");
+		grammarBuilder.append("KW2475 : 'KW' '2475';\n");
+		grammarBuilder.append("KW2476 : 'KW' '2476';\n");
+		grammarBuilder.append("KW2477 : 'KW' '2477';\n");
+		grammarBuilder.append("KW2478 : 'KW' '2478';\n");
+		grammarBuilder.append("KW2479 : 'KW' '2479';\n");
+		grammarBuilder.append("KW2480 : 'KW' '2480';\n");
+		grammarBuilder.append("KW2481 : 'KW' '2481';\n");
+		grammarBuilder.append("KW2482 : 'KW' '2482';\n");
+		grammarBuilder.append("KW2483 : 'KW' '2483';\n");
+		grammarBuilder.append("KW2484 : 'KW' '2484';\n");
+		grammarBuilder.append("KW2485 : 'KW' '2485';\n");
+		grammarBuilder.append("KW2486 : 'KW' '2486';\n");
+		grammarBuilder.append("KW2487 : 'KW' '2487';\n");
+		grammarBuilder.append("KW2488 : 'KW' '2488';\n");
+		grammarBuilder.append("KW2489 : 'KW' '2489';\n");
+		grammarBuilder.append("KW2490 : 'KW' '2490';\n");
+		grammarBuilder.append("KW2491 : 'KW' '2491';\n");
+		grammarBuilder.append("KW2492 : 'KW' '2492';\n");
+		grammarBuilder.append("KW2493 : 'KW' '2493';\n");
+		grammarBuilder.append("KW2494 : 'KW' '2494';\n");
+		grammarBuilder.append("KW2495 : 'KW' '2495';\n");
+		grammarBuilder.append("KW2496 : 'KW' '2496';\n");
+		grammarBuilder.append("KW2497 : 'KW' '2497';\n");
+		grammarBuilder.append("KW2498 : 'KW' '2498';\n");
+		grammarBuilder.append("KW2499 : 'KW' '2499';\n");
+		grammarBuilder.append("KW2500 : 'KW' '2500';\n");
+		grammarBuilder.append("KW2501 : 'KW' '2501';\n");
+		grammarBuilder.append("KW2502 : 'KW' '2502';\n");
+		grammarBuilder.append("KW2503 : 'KW' '2503';\n");
+		grammarBuilder.append("KW2504 : 'KW' '2504';\n");
+		grammarBuilder.append("KW2505 : 'KW' '2505';\n");
+		grammarBuilder.append("KW2506 : 'KW' '2506';\n");
+		grammarBuilder.append("KW2507 : 'KW' '2507';\n");
+		grammarBuilder.append("KW2508 : 'KW' '2508';\n");
+		grammarBuilder.append("KW2509 : 'KW' '2509';\n");
+		grammarBuilder.append("KW2510 : 'KW' '2510';\n");
+		grammarBuilder.append("KW2511 : 'KW' '2511';\n");
+		grammarBuilder.append("KW2512 : 'KW' '2512';\n");
+		grammarBuilder.append("KW2513 : 'KW' '2513';\n");
+		grammarBuilder.append("KW2514 : 'KW' '2514';\n");
+		grammarBuilder.append("KW2515 : 'KW' '2515';\n");
+		grammarBuilder.append("KW2516 : 'KW' '2516';\n");
+		grammarBuilder.append("KW2517 : 'KW' '2517';\n");
+		grammarBuilder.append("KW2518 : 'KW' '2518';\n");
+		grammarBuilder.append("KW2519 : 'KW' '2519';\n");
+		grammarBuilder.append("KW2520 : 'KW' '2520';\n");
+		grammarBuilder.append("KW2521 : 'KW' '2521';\n");
+		grammarBuilder.append("KW2522 : 'KW' '2522';\n");
+		grammarBuilder.append("KW2523 : 'KW' '2523';\n");
+		grammarBuilder.append("KW2524 : 'KW' '2524';\n");
+		grammarBuilder.append("KW2525 : 'KW' '2525';\n");
+		grammarBuilder.append("KW2526 : 'KW' '2526';\n");
+		grammarBuilder.append("KW2527 : 'KW' '2527';\n");
+		grammarBuilder.append("KW2528 : 'KW' '2528';\n");
+		grammarBuilder.append("KW2529 : 'KW' '2529';\n");
+		grammarBuilder.append("KW2530 : 'KW' '2530';\n");
+		grammarBuilder.append("KW2531 : 'KW' '2531';\n");
+		grammarBuilder.append("KW2532 : 'KW' '2532';\n");
+		grammarBuilder.append("KW2533 : 'KW' '2533';\n");
+		grammarBuilder.append("KW2534 : 'KW' '2534';\n");
+		grammarBuilder.append("KW2535 : 'KW' '2535';\n");
+		grammarBuilder.append("KW2536 : 'KW' '2536';\n");
+		grammarBuilder.append("KW2537 : 'KW' '2537';\n");
+		grammarBuilder.append("KW2538 : 'KW' '2538';\n");
+		grammarBuilder.append("KW2539 : 'KW' '2539';\n");
+		grammarBuilder.append("KW2540 : 'KW' '2540';\n");
+		grammarBuilder.append("KW2541 : 'KW' '2541';\n");
+		grammarBuilder.append("KW2542 : 'KW' '2542';\n");
+		grammarBuilder.append("KW2543 : 'KW' '2543';\n");
+		grammarBuilder.append("KW2544 : 'KW' '2544';\n");
+		grammarBuilder.append("KW2545 : 'KW' '2545';\n");
+		grammarBuilder.append("KW2546 : 'KW' '2546';\n");
+		grammarBuilder.append("KW2547 : 'KW' '2547';\n");
+		grammarBuilder.append("KW2548 : 'KW' '2548';\n");
+		grammarBuilder.append("KW2549 : 'KW' '2549';\n");
+		grammarBuilder.append("KW2550 : 'KW' '2550';\n");
+		grammarBuilder.append("KW2551 : 'KW' '2551';\n");
+		grammarBuilder.append("KW2552 : 'KW' '2552';\n");
+		grammarBuilder.append("KW2553 : 'KW' '2553';\n");
+		grammarBuilder.append("KW2554 : 'KW' '2554';\n");
+		grammarBuilder.append("KW2555 : 'KW' '2555';\n");
+		grammarBuilder.append("KW2556 : 'KW' '2556';\n");
+		grammarBuilder.append("KW2557 : 'KW' '2557';\n");
+		grammarBuilder.append("KW2558 : 'KW' '2558';\n");
+		grammarBuilder.append("KW2559 : 'KW' '2559';\n");
+		grammarBuilder.append("KW2560 : 'KW' '2560';\n");
+		grammarBuilder.append("KW2561 : 'KW' '2561';\n");
+		grammarBuilder.append("KW2562 : 'KW' '2562';\n");
+		grammarBuilder.append("KW2563 : 'KW' '2563';\n");
+		grammarBuilder.append("KW2564 : 'KW' '2564';\n");
+		grammarBuilder.append("KW2565 : 'KW' '2565';\n");
+		grammarBuilder.append("KW2566 : 'KW' '2566';\n");
+		grammarBuilder.append("KW2567 : 'KW' '2567';\n");
+		grammarBuilder.append("KW2568 : 'KW' '2568';\n");
+		grammarBuilder.append("KW2569 : 'KW' '2569';\n");
+		grammarBuilder.append("KW2570 : 'KW' '2570';\n");
+		grammarBuilder.append("KW2571 : 'KW' '2571';\n");
+		grammarBuilder.append("KW2572 : 'KW' '2572';\n");
+		grammarBuilder.append("KW2573 : 'KW' '2573';\n");
+		grammarBuilder.append("KW2574 : 'KW' '2574';\n");
+		grammarBuilder.append("KW2575 : 'KW' '2575';\n");
+		grammarBuilder.append("KW2576 : 'KW' '2576';\n");
+		grammarBuilder.append("KW2577 : 'KW' '2577';\n");
+		grammarBuilder.append("KW2578 : 'KW' '2578';\n");
+		grammarBuilder.append("KW2579 : 'KW' '2579';\n");
+		grammarBuilder.append("KW2580 : 'KW' '2580';\n");
+		grammarBuilder.append("KW2581 : 'KW' '2581';\n");
+		grammarBuilder.append("KW2582 : 'KW' '2582';\n");
+		grammarBuilder.append("KW2583 : 'KW' '2583';\n");
+		grammarBuilder.append("KW2584 : 'KW' '2584';\n");
+		grammarBuilder.append("KW2585 : 'KW' '2585';\n");
+		grammarBuilder.append("KW2586 : 'KW' '2586';\n");
+		grammarBuilder.append("KW2587 : 'KW' '2587';\n");
+		grammarBuilder.append("KW2588 : 'KW' '2588';\n");
+		grammarBuilder.append("KW2589 : 'KW' '2589';\n");
+		grammarBuilder.append("KW2590 : 'KW' '2590';\n");
+		grammarBuilder.append("KW2591 : 'KW' '2591';\n");
+		grammarBuilder.append("KW2592 : 'KW' '2592';\n");
+		grammarBuilder.append("KW2593 : 'KW' '2593';\n");
+		grammarBuilder.append("KW2594 : 'KW' '2594';\n");
+		grammarBuilder.append("KW2595 : 'KW' '2595';\n");
+		grammarBuilder.append("KW2596 : 'KW' '2596';\n");
+		grammarBuilder.append("KW2597 : 'KW' '2597';\n");
+		grammarBuilder.append("KW2598 : 'KW' '2598';\n");
+		grammarBuilder.append("KW2599 : 'KW' '2599';\n");
+		grammarBuilder.append("KW2600 : 'KW' '2600';\n");
+		grammarBuilder.append("KW2601 : 'KW' '2601';\n");
+		grammarBuilder.append("KW2602 : 'KW' '2602';\n");
+		grammarBuilder.append("KW2603 : 'KW' '2603';\n");
+		grammarBuilder.append("KW2604 : 'KW' '2604';\n");
+		grammarBuilder.append("KW2605 : 'KW' '2605';\n");
+		grammarBuilder.append("KW2606 : 'KW' '2606';\n");
+		grammarBuilder.append("KW2607 : 'KW' '2607';\n");
+		grammarBuilder.append("KW2608 : 'KW' '2608';\n");
+		grammarBuilder.append("KW2609 : 'KW' '2609';\n");
+		grammarBuilder.append("KW2610 : 'KW' '2610';\n");
+		grammarBuilder.append("KW2611 : 'KW' '2611';\n");
+		grammarBuilder.append("KW2612 : 'KW' '2612';\n");
+		grammarBuilder.append("KW2613 : 'KW' '2613';\n");
+		grammarBuilder.append("KW2614 : 'KW' '2614';\n");
+		grammarBuilder.append("KW2615 : 'KW' '2615';\n");
+		grammarBuilder.append("KW2616 : 'KW' '2616';\n");
+		grammarBuilder.append("KW2617 : 'KW' '2617';\n");
+		grammarBuilder.append("KW2618 : 'KW' '2618';\n");
+		grammarBuilder.append("KW2619 : 'KW' '2619';\n");
+		grammarBuilder.append("KW2620 : 'KW' '2620';\n");
+		grammarBuilder.append("KW2621 : 'KW' '2621';\n");
+		grammarBuilder.append("KW2622 : 'KW' '2622';\n");
+		grammarBuilder.append("KW2623 : 'KW' '2623';\n");
+		grammarBuilder.append("KW2624 : 'KW' '2624';\n");
+		grammarBuilder.append("KW2625 : 'KW' '2625';\n");
+		grammarBuilder.append("KW2626 : 'KW' '2626';\n");
+		grammarBuilder.append("KW2627 : 'KW' '2627';\n");
+		grammarBuilder.append("KW2628 : 'KW' '2628';\n");
+		grammarBuilder.append("KW2629 : 'KW' '2629';\n");
+		grammarBuilder.append("KW2630 : 'KW' '2630';\n");
+		grammarBuilder.append("KW2631 : 'KW' '2631';\n");
+		grammarBuilder.append("KW2632 : 'KW' '2632';\n");
+		grammarBuilder.append("KW2633 : 'KW' '2633';\n");
+		grammarBuilder.append("KW2634 : 'KW' '2634';\n");
+		grammarBuilder.append("KW2635 : 'KW' '2635';\n");
+		grammarBuilder.append("KW2636 : 'KW' '2636';\n");
+		grammarBuilder.append("KW2637 : 'KW' '2637';\n");
+		grammarBuilder.append("KW2638 : 'KW' '2638';\n");
+		grammarBuilder.append("KW2639 : 'KW' '2639';\n");
+		grammarBuilder.append("KW2640 : 'KW' '2640';\n");
+		grammarBuilder.append("KW2641 : 'KW' '2641';\n");
+		grammarBuilder.append("KW2642 : 'KW' '2642';\n");
+		grammarBuilder.append("KW2643 : 'KW' '2643';\n");
+		grammarBuilder.append("KW2644 : 'KW' '2644';\n");
+		grammarBuilder.append("KW2645 : 'KW' '2645';\n");
+		grammarBuilder.append("KW2646 : 'KW' '2646';\n");
+		grammarBuilder.append("KW2647 : 'KW' '2647';\n");
+		grammarBuilder.append("KW2648 : 'KW' '2648';\n");
+		grammarBuilder.append("KW2649 : 'KW' '2649';\n");
+		grammarBuilder.append("KW2650 : 'KW' '2650';\n");
+		grammarBuilder.append("KW2651 : 'KW' '2651';\n");
+		grammarBuilder.append("KW2652 : 'KW' '2652';\n");
+		grammarBuilder.append("KW2653 : 'KW' '2653';\n");
+		grammarBuilder.append("KW2654 : 'KW' '2654';\n");
+		grammarBuilder.append("KW2655 : 'KW' '2655';\n");
+		grammarBuilder.append("KW2656 : 'KW' '2656';\n");
+		grammarBuilder.append("KW2657 : 'KW' '2657';\n");
+		grammarBuilder.append("KW2658 : 'KW' '2658';\n");
+		grammarBuilder.append("KW2659 : 'KW' '2659';\n");
+		grammarBuilder.append("KW2660 : 'KW' '2660';\n");
+		grammarBuilder.append("KW2661 : 'KW' '2661';\n");
+		grammarBuilder.append("KW2662 : 'KW' '2662';\n");
+		grammarBuilder.append("KW2663 : 'KW' '2663';\n");
+		grammarBuilder.append("KW2664 : 'KW' '2664';\n");
+		grammarBuilder.append("KW2665 : 'KW' '2665';\n");
+		grammarBuilder.append("KW2666 : 'KW' '2666';\n");
+		grammarBuilder.append("KW2667 : 'KW' '2667';\n");
+		grammarBuilder.append("KW2668 : 'KW' '2668';\n");
+		grammarBuilder.append("KW2669 : 'KW' '2669';\n");
+		grammarBuilder.append("KW2670 : 'KW' '2670';\n");
+		grammarBuilder.append("KW2671 : 'KW' '2671';\n");
+		grammarBuilder.append("KW2672 : 'KW' '2672';\n");
+		grammarBuilder.append("KW2673 : 'KW' '2673';\n");
+		grammarBuilder.append("KW2674 : 'KW' '2674';\n");
+		grammarBuilder.append("KW2675 : 'KW' '2675';\n");
+		grammarBuilder.append("KW2676 : 'KW' '2676';\n");
+		grammarBuilder.append("KW2677 : 'KW' '2677';\n");
+		grammarBuilder.append("KW2678 : 'KW' '2678';\n");
+		grammarBuilder.append("KW2679 : 'KW' '2679';\n");
+		grammarBuilder.append("KW2680 : 'KW' '2680';\n");
+		grammarBuilder.append("KW2681 : 'KW' '2681';\n");
+		grammarBuilder.append("KW2682 : 'KW' '2682';\n");
+		grammarBuilder.append("KW2683 : 'KW' '2683';\n");
+		grammarBuilder.append("KW2684 : 'KW' '2684';\n");
+		grammarBuilder.append("KW2685 : 'KW' '2685';\n");
+		grammarBuilder.append("KW2686 : 'KW' '2686';\n");
+		grammarBuilder.append("KW2687 : 'KW' '2687';\n");
+		grammarBuilder.append("KW2688 : 'KW' '2688';\n");
+		grammarBuilder.append("KW2689 : 'KW' '2689';\n");
+		grammarBuilder.append("KW2690 : 'KW' '2690';\n");
+		grammarBuilder.append("KW2691 : 'KW' '2691';\n");
+		grammarBuilder.append("KW2692 : 'KW' '2692';\n");
+		grammarBuilder.append("KW2693 : 'KW' '2693';\n");
+		grammarBuilder.append("KW2694 : 'KW' '2694';\n");
+		grammarBuilder.append("KW2695 : 'KW' '2695';\n");
+		grammarBuilder.append("KW2696 : 'KW' '2696';\n");
+		grammarBuilder.append("KW2697 : 'KW' '2697';\n");
+		grammarBuilder.append("KW2698 : 'KW' '2698';\n");
+		grammarBuilder.append("KW2699 : 'KW' '2699';\n");
+		grammarBuilder.append("KW2700 : 'KW' '2700';\n");
+		grammarBuilder.append("KW2701 : 'KW' '2701';\n");
+		grammarBuilder.append("KW2702 : 'KW' '2702';\n");
+		grammarBuilder.append("KW2703 : 'KW' '2703';\n");
+		grammarBuilder.append("KW2704 : 'KW' '2704';\n");
+		grammarBuilder.append("KW2705 : 'KW' '2705';\n");
+		grammarBuilder.append("KW2706 : 'KW' '2706';\n");
+		grammarBuilder.append("KW2707 : 'KW' '2707';\n");
+		grammarBuilder.append("KW2708 : 'KW' '2708';\n");
+		grammarBuilder.append("KW2709 : 'KW' '2709';\n");
+		grammarBuilder.append("KW2710 : 'KW' '2710';\n");
+		grammarBuilder.append("KW2711 : 'KW' '2711';\n");
+		grammarBuilder.append("KW2712 : 'KW' '2712';\n");
+		grammarBuilder.append("KW2713 : 'KW' '2713';\n");
+		grammarBuilder.append("KW2714 : 'KW' '2714';\n");
+		grammarBuilder.append("KW2715 : 'KW' '2715';\n");
+		grammarBuilder.append("KW2716 : 'KW' '2716';\n");
+		grammarBuilder.append("KW2717 : 'KW' '2717';\n");
+		grammarBuilder.append("KW2718 : 'KW' '2718';\n");
+		grammarBuilder.append("KW2719 : 'KW' '2719';\n");
+		grammarBuilder.append("KW2720 : 'KW' '2720';\n");
+		grammarBuilder.append("KW2721 : 'KW' '2721';\n");
+		grammarBuilder.append("KW2722 : 'KW' '2722';\n");
+		grammarBuilder.append("KW2723 : 'KW' '2723';\n");
+		grammarBuilder.append("KW2724 : 'KW' '2724';\n");
+		grammarBuilder.append("KW2725 : 'KW' '2725';\n");
+		grammarBuilder.append("KW2726 : 'KW' '2726';\n");
+		grammarBuilder.append("KW2727 : 'KW' '2727';\n");
+		grammarBuilder.append("KW2728 : 'KW' '2728';\n");
+		grammarBuilder.append("KW2729 : 'KW' '2729';\n");
+		grammarBuilder.append("KW2730 : 'KW' '2730';\n");
+		grammarBuilder.append("KW2731 : 'KW' '2731';\n");
+		grammarBuilder.append("KW2732 : 'KW' '2732';\n");
+		grammarBuilder.append("KW2733 : 'KW' '2733';\n");
+		grammarBuilder.append("KW2734 : 'KW' '2734';\n");
+		grammarBuilder.append("KW2735 : 'KW' '2735';\n");
+		grammarBuilder.append("KW2736 : 'KW' '2736';\n");
+		grammarBuilder.append("KW2737 : 'KW' '2737';\n");
+		grammarBuilder.append("KW2738 : 'KW' '2738';\n");
+		grammarBuilder.append("KW2739 : 'KW' '2739';\n");
+		grammarBuilder.append("KW2740 : 'KW' '2740';\n");
+		grammarBuilder.append("KW2741 : 'KW' '2741';\n");
+		grammarBuilder.append("KW2742 : 'KW' '2742';\n");
+		grammarBuilder.append("KW2743 : 'KW' '2743';\n");
+		grammarBuilder.append("KW2744 : 'KW' '2744';\n");
+		grammarBuilder.append("KW2745 : 'KW' '2745';\n");
+		grammarBuilder.append("KW2746 : 'KW' '2746';\n");
+		grammarBuilder.append("KW2747 : 'KW' '2747';\n");
+		grammarBuilder.append("KW2748 : 'KW' '2748';\n");
+		grammarBuilder.append("KW2749 : 'KW' '2749';\n");
+		grammarBuilder.append("KW2750 : 'KW' '2750';\n");
+		grammarBuilder.append("KW2751 : 'KW' '2751';\n");
+		grammarBuilder.append("KW2752 : 'KW' '2752';\n");
+		grammarBuilder.append("KW2753 : 'KW' '2753';\n");
+		grammarBuilder.append("KW2754 : 'KW' '2754';\n");
+		grammarBuilder.append("KW2755 : 'KW' '2755';\n");
+		grammarBuilder.append("KW2756 : 'KW' '2756';\n");
+		grammarBuilder.append("KW2757 : 'KW' '2757';\n");
+		grammarBuilder.append("KW2758 : 'KW' '2758';\n");
+		grammarBuilder.append("KW2759 : 'KW' '2759';\n");
+		grammarBuilder.append("KW2760 : 'KW' '2760';\n");
+		grammarBuilder.append("KW2761 : 'KW' '2761';\n");
+		grammarBuilder.append("KW2762 : 'KW' '2762';\n");
+		grammarBuilder.append("KW2763 : 'KW' '2763';\n");
+		grammarBuilder.append("KW2764 : 'KW' '2764';\n");
+		grammarBuilder.append("KW2765 : 'KW' '2765';\n");
+		grammarBuilder.append("KW2766 : 'KW' '2766';\n");
+		grammarBuilder.append("KW2767 : 'KW' '2767';\n");
+		grammarBuilder.append("KW2768 : 'KW' '2768';\n");
+		grammarBuilder.append("KW2769 : 'KW' '2769';\n");
+		grammarBuilder.append("KW2770 : 'KW' '2770';\n");
+		grammarBuilder.append("KW2771 : 'KW' '2771';\n");
+		grammarBuilder.append("KW2772 : 'KW' '2772';\n");
+		grammarBuilder.append("KW2773 : 'KW' '2773';\n");
+		grammarBuilder.append("KW2774 : 'KW' '2774';\n");
+		grammarBuilder.append("KW2775 : 'KW' '2775';\n");
+		grammarBuilder.append("KW2776 : 'KW' '2776';\n");
+		grammarBuilder.append("KW2777 : 'KW' '2777';\n");
+		grammarBuilder.append("KW2778 : 'KW' '2778';\n");
+		grammarBuilder.append("KW2779 : 'KW' '2779';\n");
+		grammarBuilder.append("KW2780 : 'KW' '2780';\n");
+		grammarBuilder.append("KW2781 : 'KW' '2781';\n");
+		grammarBuilder.append("KW2782 : 'KW' '2782';\n");
+		grammarBuilder.append("KW2783 : 'KW' '2783';\n");
+		grammarBuilder.append("KW2784 : 'KW' '2784';\n");
+		grammarBuilder.append("KW2785 : 'KW' '2785';\n");
+		grammarBuilder.append("KW2786 : 'KW' '2786';\n");
+		grammarBuilder.append("KW2787 : 'KW' '2787';\n");
+		grammarBuilder.append("KW2788 : 'KW' '2788';\n");
+		grammarBuilder.append("KW2789 : 'KW' '2789';\n");
+		grammarBuilder.append("KW2790 : 'KW' '2790';\n");
+		grammarBuilder.append("KW2791 : 'KW' '2791';\n");
+		grammarBuilder.append("KW2792 : 'KW' '2792';\n");
+		grammarBuilder.append("KW2793 : 'KW' '2793';\n");
+		grammarBuilder.append("KW2794 : 'KW' '2794';\n");
+		grammarBuilder.append("KW2795 : 'KW' '2795';\n");
+		grammarBuilder.append("KW2796 : 'KW' '2796';\n");
+		grammarBuilder.append("KW2797 : 'KW' '2797';\n");
+		grammarBuilder.append("KW2798 : 'KW' '2798';\n");
+		grammarBuilder.append("KW2799 : 'KW' '2799';\n");
+		grammarBuilder.append("KW2800 : 'KW' '2800';\n");
+		grammarBuilder.append("KW2801 : 'KW' '2801';\n");
+		grammarBuilder.append("KW2802 : 'KW' '2802';\n");
+		grammarBuilder.append("KW2803 : 'KW' '2803';\n");
+		grammarBuilder.append("KW2804 : 'KW' '2804';\n");
+		grammarBuilder.append("KW2805 : 'KW' '2805';\n");
+		grammarBuilder.append("KW2806 : 'KW' '2806';\n");
+		grammarBuilder.append("KW2807 : 'KW' '2807';\n");
+		grammarBuilder.append("KW2808 : 'KW' '2808';\n");
+		grammarBuilder.append("KW2809 : 'KW' '2809';\n");
+		grammarBuilder.append("KW2810 : 'KW' '2810';\n");
+		grammarBuilder.append("KW2811 : 'KW' '2811';\n");
+		grammarBuilder.append("KW2812 : 'KW' '2812';\n");
+		grammarBuilder.append("KW2813 : 'KW' '2813';\n");
+		grammarBuilder.append("KW2814 : 'KW' '2814';\n");
+		grammarBuilder.append("KW2815 : 'KW' '2815';\n");
+		grammarBuilder.append("KW2816 : 'KW' '2816';\n");
+		grammarBuilder.append("KW2817 : 'KW' '2817';\n");
+		grammarBuilder.append("KW2818 : 'KW' '2818';\n");
+		grammarBuilder.append("KW2819 : 'KW' '2819';\n");
+		grammarBuilder.append("KW2820 : 'KW' '2820';\n");
+		grammarBuilder.append("KW2821 : 'KW' '2821';\n");
+		grammarBuilder.append("KW2822 : 'KW' '2822';\n");
+		grammarBuilder.append("KW2823 : 'KW' '2823';\n");
+		grammarBuilder.append("KW2824 : 'KW' '2824';\n");
+		grammarBuilder.append("KW2825 : 'KW' '2825';\n");
+		grammarBuilder.append("KW2826 : 'KW' '2826';\n");
+		grammarBuilder.append("KW2827 : 'KW' '2827';\n");
+		grammarBuilder.append("KW2828 : 'KW' '2828';\n");
+		grammarBuilder.append("KW2829 : 'KW' '2829';\n");
+		grammarBuilder.append("KW2830 : 'KW' '2830';\n");
+		grammarBuilder.append("KW2831 : 'KW' '2831';\n");
+		grammarBuilder.append("KW2832 : 'KW' '2832';\n");
+		grammarBuilder.append("KW2833 : 'KW' '2833';\n");
+		grammarBuilder.append("KW2834 : 'KW' '2834';\n");
+		grammarBuilder.append("KW2835 : 'KW' '2835';\n");
+		grammarBuilder.append("KW2836 : 'KW' '2836';\n");
+		grammarBuilder.append("KW2837 : 'KW' '2837';\n");
+		grammarBuilder.append("KW2838 : 'KW' '2838';\n");
+		grammarBuilder.append("KW2839 : 'KW' '2839';\n");
+		grammarBuilder.append("KW2840 : 'KW' '2840';\n");
+		grammarBuilder.append("KW2841 : 'KW' '2841';\n");
+		grammarBuilder.append("KW2842 : 'KW' '2842';\n");
+		grammarBuilder.append("KW2843 : 'KW' '2843';\n");
+		grammarBuilder.append("KW2844 : 'KW' '2844';\n");
+		grammarBuilder.append("KW2845 : 'KW' '2845';\n");
+		grammarBuilder.append("KW2846 : 'KW' '2846';\n");
+		grammarBuilder.append("KW2847 : 'KW' '2847';\n");
+		grammarBuilder.append("KW2848 : 'KW' '2848';\n");
+		grammarBuilder.append("KW2849 : 'KW' '2849';\n");
+		grammarBuilder.append("KW2850 : 'KW' '2850';\n");
+		grammarBuilder.append("KW2851 : 'KW' '2851';\n");
+		grammarBuilder.append("KW2852 : 'KW' '2852';\n");
+		grammarBuilder.append("KW2853 : 'KW' '2853';\n");
+		grammarBuilder.append("KW2854 : 'KW' '2854';\n");
+		grammarBuilder.append("KW2855 : 'KW' '2855';\n");
+		grammarBuilder.append("KW2856 : 'KW' '2856';\n");
+		grammarBuilder.append("KW2857 : 'KW' '2857';\n");
+		grammarBuilder.append("KW2858 : 'KW' '2858';\n");
+		grammarBuilder.append("KW2859 : 'KW' '2859';\n");
+		grammarBuilder.append("KW2860 : 'KW' '2860';\n");
+		grammarBuilder.append("KW2861 : 'KW' '2861';\n");
+		grammarBuilder.append("KW2862 : 'KW' '2862';\n");
+		grammarBuilder.append("KW2863 : 'KW' '2863';\n");
+		grammarBuilder.append("KW2864 : 'KW' '2864';\n");
+		grammarBuilder.append("KW2865 : 'KW' '2865';\n");
+		grammarBuilder.append("KW2866 : 'KW' '2866';\n");
+		grammarBuilder.append("KW2867 : 'KW' '2867';\n");
+		grammarBuilder.append("KW2868 : 'KW' '2868';\n");
+		grammarBuilder.append("KW2869 : 'KW' '2869';\n");
+		grammarBuilder.append("KW2870 : 'KW' '2870';\n");
+		grammarBuilder.append("KW2871 : 'KW' '2871';\n");
+		grammarBuilder.append("KW2872 : 'KW' '2872';\n");
+		grammarBuilder.append("KW2873 : 'KW' '2873';\n");
+		grammarBuilder.append("KW2874 : 'KW' '2874';\n");
+		grammarBuilder.append("KW2875 : 'KW' '2875';\n");
+		grammarBuilder.append("KW2876 : 'KW' '2876';\n");
+		grammarBuilder.append("KW2877 : 'KW' '2877';\n");
+		grammarBuilder.append("KW2878 : 'KW' '2878';\n");
+		grammarBuilder.append("KW2879 : 'KW' '2879';\n");
+		grammarBuilder.append("KW2880 : 'KW' '2880';\n");
+		grammarBuilder.append("KW2881 : 'KW' '2881';\n");
+		grammarBuilder.append("KW2882 : 'KW' '2882';\n");
+		grammarBuilder.append("KW2883 : 'KW' '2883';\n");
+		grammarBuilder.append("KW2884 : 'KW' '2884';\n");
+		grammarBuilder.append("KW2885 : 'KW' '2885';\n");
+		grammarBuilder.append("KW2886 : 'KW' '2886';\n");
+		grammarBuilder.append("KW2887 : 'KW' '2887';\n");
+		grammarBuilder.append("KW2888 : 'KW' '2888';\n");
+		grammarBuilder.append("KW2889 : 'KW' '2889';\n");
+		grammarBuilder.append("KW2890 : 'KW' '2890';\n");
+		grammarBuilder.append("KW2891 : 'KW' '2891';\n");
+		grammarBuilder.append("KW2892 : 'KW' '2892';\n");
+		grammarBuilder.append("KW2893 : 'KW' '2893';\n");
+		grammarBuilder.append("KW2894 : 'KW' '2894';\n");
+		grammarBuilder.append("KW2895 : 'KW' '2895';\n");
+		grammarBuilder.append("KW2896 : 'KW' '2896';\n");
+		grammarBuilder.append("KW2897 : 'KW' '2897';\n");
+		grammarBuilder.append("KW2898 : 'KW' '2898';\n");
+		grammarBuilder.append("KW2899 : 'KW' '2899';\n");
+		grammarBuilder.append("KW2900 : 'KW' '2900';\n");
+		grammarBuilder.append("KW2901 : 'KW' '2901';\n");
+		grammarBuilder.append("KW2902 : 'KW' '2902';\n");
+		grammarBuilder.append("KW2903 : 'KW' '2903';\n");
+		grammarBuilder.append("KW2904 : 'KW' '2904';\n");
+		grammarBuilder.append("KW2905 : 'KW' '2905';\n");
+		grammarBuilder.append("KW2906 : 'KW' '2906';\n");
+		grammarBuilder.append("KW2907 : 'KW' '2907';\n");
+		grammarBuilder.append("KW2908 : 'KW' '2908';\n");
+		grammarBuilder.append("KW2909 : 'KW' '2909';\n");
+		grammarBuilder.append("KW2910 : 'KW' '2910';\n");
+		grammarBuilder.append("KW2911 : 'KW' '2911';\n");
+		grammarBuilder.append("KW2912 : 'KW' '2912';\n");
+		grammarBuilder.append("KW2913 : 'KW' '2913';\n");
+		grammarBuilder.append("KW2914 : 'KW' '2914';\n");
+		grammarBuilder.append("KW2915 : 'KW' '2915';\n");
+		grammarBuilder.append("KW2916 : 'KW' '2916';\n");
+		grammarBuilder.append("KW2917 : 'KW' '2917';\n");
+		grammarBuilder.append("KW2918 : 'KW' '2918';\n");
+		grammarBuilder.append("KW2919 : 'KW' '2919';\n");
+		grammarBuilder.append("KW2920 : 'KW' '2920';\n");
+		grammarBuilder.append("KW2921 : 'KW' '2921';\n");
+		grammarBuilder.append("KW2922 : 'KW' '2922';\n");
+		grammarBuilder.append("KW2923 : 'KW' '2923';\n");
+		grammarBuilder.append("KW2924 : 'KW' '2924';\n");
+		grammarBuilder.append("KW2925 : 'KW' '2925';\n");
+		grammarBuilder.append("KW2926 : 'KW' '2926';\n");
+		grammarBuilder.append("KW2927 : 'KW' '2927';\n");
+		grammarBuilder.append("KW2928 : 'KW' '2928';\n");
+		grammarBuilder.append("KW2929 : 'KW' '2929';\n");
+		grammarBuilder.append("KW2930 : 'KW' '2930';\n");
+		grammarBuilder.append("KW2931 : 'KW' '2931';\n");
+		grammarBuilder.append("KW2932 : 'KW' '2932';\n");
+		grammarBuilder.append("KW2933 : 'KW' '2933';\n");
+		grammarBuilder.append("KW2934 : 'KW' '2934';\n");
+		grammarBuilder.append("KW2935 : 'KW' '2935';\n");
+		grammarBuilder.append("KW2936 : 'KW' '2936';\n");
+		grammarBuilder.append("KW2937 : 'KW' '2937';\n");
+		grammarBuilder.append("KW2938 : 'KW' '2938';\n");
+		grammarBuilder.append("KW2939 : 'KW' '2939';\n");
+		grammarBuilder.append("KW2940 : 'KW' '2940';\n");
+		grammarBuilder.append("KW2941 : 'KW' '2941';\n");
+		grammarBuilder.append("KW2942 : 'KW' '2942';\n");
+		grammarBuilder.append("KW2943 : 'KW' '2943';\n");
+		grammarBuilder.append("KW2944 : 'KW' '2944';\n");
+		grammarBuilder.append("KW2945 : 'KW' '2945';\n");
+		grammarBuilder.append("KW2946 : 'KW' '2946';\n");
+		grammarBuilder.append("KW2947 : 'KW' '2947';\n");
+		grammarBuilder.append("KW2948 : 'KW' '2948';\n");
+		grammarBuilder.append("KW2949 : 'KW' '2949';\n");
+		grammarBuilder.append("KW2950 : 'KW' '2950';\n");
+		grammarBuilder.append("KW2951 : 'KW' '2951';\n");
+		grammarBuilder.append("KW2952 : 'KW' '2952';\n");
+		grammarBuilder.append("KW2953 : 'KW' '2953';\n");
+		grammarBuilder.append("KW2954 : 'KW' '2954';\n");
+		grammarBuilder.append("KW2955 : 'KW' '2955';\n");
+		grammarBuilder.append("KW2956 : 'KW' '2956';\n");
+		grammarBuilder.append("KW2957 : 'KW' '2957';\n");
+		grammarBuilder.append("KW2958 : 'KW' '2958';\n");
+		grammarBuilder.append("KW2959 : 'KW' '2959';\n");
+		grammarBuilder.append("KW2960 : 'KW' '2960';\n");
+		grammarBuilder.append("KW2961 : 'KW' '2961';\n");
+		grammarBuilder.append("KW2962 : 'KW' '2962';\n");
+		grammarBuilder.append("KW2963 : 'KW' '2963';\n");
+		grammarBuilder.append("KW2964 : 'KW' '2964';\n");
+		grammarBuilder.append("KW2965 : 'KW' '2965';\n");
+		grammarBuilder.append("KW2966 : 'KW' '2966';\n");
+		grammarBuilder.append("KW2967 : 'KW' '2967';\n");
+		grammarBuilder.append("KW2968 : 'KW' '2968';\n");
+		grammarBuilder.append("KW2969 : 'KW' '2969';\n");
+		grammarBuilder.append("KW2970 : 'KW' '2970';\n");
+		grammarBuilder.append("KW2971 : 'KW' '2971';\n");
+		grammarBuilder.append("KW2972 : 'KW' '2972';\n");
+		grammarBuilder.append("KW2973 : 'KW' '2973';\n");
+		grammarBuilder.append("KW2974 : 'KW' '2974';\n");
+		grammarBuilder.append("KW2975 : 'KW' '2975';\n");
+		grammarBuilder.append("KW2976 : 'KW' '2976';\n");
+		grammarBuilder.append("KW2977 : 'KW' '2977';\n");
+		grammarBuilder.append("KW2978 : 'KW' '2978';\n");
+		grammarBuilder.append("KW2979 : 'KW' '2979';\n");
+		grammarBuilder.append("KW2980 : 'KW' '2980';\n");
+		grammarBuilder.append("KW2981 : 'KW' '2981';\n");
+		grammarBuilder.append("KW2982 : 'KW' '2982';\n");
+		grammarBuilder.append("KW2983 : 'KW' '2983';\n");
+		grammarBuilder.append("KW2984 : 'KW' '2984';\n");
+		grammarBuilder.append("KW2985 : 'KW' '2985';\n");
+		grammarBuilder.append("KW2986 : 'KW' '2986';\n");
+		grammarBuilder.append("KW2987 : 'KW' '2987';\n");
+		grammarBuilder.append("KW2988 : 'KW' '2988';\n");
+		grammarBuilder.append("KW2989 : 'KW' '2989';\n");
+		grammarBuilder.append("KW2990 : 'KW' '2990';\n");
+		grammarBuilder.append("KW2991 : 'KW' '2991';\n");
+		grammarBuilder.append("KW2992 : 'KW' '2992';\n");
+		grammarBuilder.append("KW2993 : 'KW' '2993';\n");
+		grammarBuilder.append("KW2994 : 'KW' '2994';\n");
+		grammarBuilder.append("KW2995 : 'KW' '2995';\n");
+		grammarBuilder.append("KW2996 : 'KW' '2996';\n");
+		grammarBuilder.append("KW2997 : 'KW' '2997';\n");
+		grammarBuilder.append("KW2998 : 'KW' '2998';\n");
+		grammarBuilder.append("KW2999 : 'KW' '2999';\n");
+		grammarBuilder.append("KW3000 : 'KW' '3000';\n");
+		grammarBuilder.append("KW3001 : 'KW' '3001';\n");
+		grammarBuilder.append("KW3002 : 'KW' '3002';\n");
+		grammarBuilder.append("KW3003 : 'KW' '3003';\n");
+		grammarBuilder.append("KW3004 : 'KW' '3004';\n");
+		grammarBuilder.append("KW3005 : 'KW' '3005';\n");
+		grammarBuilder.append("KW3006 : 'KW' '3006';\n");
+		grammarBuilder.append("KW3007 : 'KW' '3007';\n");
+		grammarBuilder.append("KW3008 : 'KW' '3008';\n");
+		grammarBuilder.append("KW3009 : 'KW' '3009';\n");
+		grammarBuilder.append("KW3010 : 'KW' '3010';\n");
+		grammarBuilder.append("KW3011 : 'KW' '3011';\n");
+		grammarBuilder.append("KW3012 : 'KW' '3012';\n");
+		grammarBuilder.append("KW3013 : 'KW' '3013';\n");
+		grammarBuilder.append("KW3014 : 'KW' '3014';\n");
+		grammarBuilder.append("KW3015 : 'KW' '3015';\n");
+		grammarBuilder.append("KW3016 : 'KW' '3016';\n");
+		grammarBuilder.append("KW3017 : 'KW' '3017';\n");
+		grammarBuilder.append("KW3018 : 'KW' '3018';\n");
+		grammarBuilder.append("KW3019 : 'KW' '3019';\n");
+		grammarBuilder.append("KW3020 : 'KW' '3020';\n");
+		grammarBuilder.append("KW3021 : 'KW' '3021';\n");
+		grammarBuilder.append("KW3022 : 'KW' '3022';\n");
+		grammarBuilder.append("KW3023 : 'KW' '3023';\n");
+		grammarBuilder.append("KW3024 : 'KW' '3024';\n");
+		grammarBuilder.append("KW3025 : 'KW' '3025';\n");
+		grammarBuilder.append("KW3026 : 'KW' '3026';\n");
+		grammarBuilder.append("KW3027 : 'KW' '3027';\n");
+		grammarBuilder.append("KW3028 : 'KW' '3028';\n");
+		grammarBuilder.append("KW3029 : 'KW' '3029';\n");
+		grammarBuilder.append("KW3030 : 'KW' '3030';\n");
+		grammarBuilder.append("KW3031 : 'KW' '3031';\n");
+		grammarBuilder.append("KW3032 : 'KW' '3032';\n");
+		grammarBuilder.append("KW3033 : 'KW' '3033';\n");
+		grammarBuilder.append("KW3034 : 'KW' '3034';\n");
+		grammarBuilder.append("KW3035 : 'KW' '3035';\n");
+		grammarBuilder.append("KW3036 : 'KW' '3036';\n");
+		grammarBuilder.append("KW3037 : 'KW' '3037';\n");
+		grammarBuilder.append("KW3038 : 'KW' '3038';\n");
+		grammarBuilder.append("KW3039 : 'KW' '3039';\n");
+		grammarBuilder.append("KW3040 : 'KW' '3040';\n");
+		grammarBuilder.append("KW3041 : 'KW' '3041';\n");
+		grammarBuilder.append("KW3042 : 'KW' '3042';\n");
+		grammarBuilder.append("KW3043 : 'KW' '3043';\n");
+		grammarBuilder.append("KW3044 : 'KW' '3044';\n");
+		grammarBuilder.append("KW3045 : 'KW' '3045';\n");
+		grammarBuilder.append("KW3046 : 'KW' '3046';\n");
+		grammarBuilder.append("KW3047 : 'KW' '3047';\n");
+		grammarBuilder.append("KW3048 : 'KW' '3048';\n");
+		grammarBuilder.append("KW3049 : 'KW' '3049';\n");
+		grammarBuilder.append("KW3050 : 'KW' '3050';\n");
+		grammarBuilder.append("KW3051 : 'KW' '3051';\n");
+		grammarBuilder.append("KW3052 : 'KW' '3052';\n");
+		grammarBuilder.append("KW3053 : 'KW' '3053';\n");
+		grammarBuilder.append("KW3054 : 'KW' '3054';\n");
+		grammarBuilder.append("KW3055 : 'KW' '3055';\n");
+		grammarBuilder.append("KW3056 : 'KW' '3056';\n");
+		grammarBuilder.append("KW3057 : 'KW' '3057';\n");
+		grammarBuilder.append("KW3058 : 'KW' '3058';\n");
+		grammarBuilder.append("KW3059 : 'KW' '3059';\n");
+		grammarBuilder.append("KW3060 : 'KW' '3060';\n");
+		grammarBuilder.append("KW3061 : 'KW' '3061';\n");
+		grammarBuilder.append("KW3062 : 'KW' '3062';\n");
+		grammarBuilder.append("KW3063 : 'KW' '3063';\n");
+		grammarBuilder.append("KW3064 : 'KW' '3064';\n");
+		grammarBuilder.append("KW3065 : 'KW' '3065';\n");
+		grammarBuilder.append("KW3066 : 'KW' '3066';\n");
+		grammarBuilder.append("KW3067 : 'KW' '3067';\n");
+		grammarBuilder.append("KW3068 : 'KW' '3068';\n");
+		grammarBuilder.append("KW3069 : 'KW' '3069';\n");
+		grammarBuilder.append("KW3070 : 'KW' '3070';\n");
+		grammarBuilder.append("KW3071 : 'KW' '3071';\n");
+		grammarBuilder.append("KW3072 : 'KW' '3072';\n");
+		grammarBuilder.append("KW3073 : 'KW' '3073';\n");
+		grammarBuilder.append("KW3074 : 'KW' '3074';\n");
+		grammarBuilder.append("KW3075 : 'KW' '3075';\n");
+		grammarBuilder.append("KW3076 : 'KW' '3076';\n");
+		grammarBuilder.append("KW3077 : 'KW' '3077';\n");
+		grammarBuilder.append("KW3078 : 'KW' '3078';\n");
+		grammarBuilder.append("KW3079 : 'KW' '3079';\n");
+		grammarBuilder.append("KW3080 : 'KW' '3080';\n");
+		grammarBuilder.append("KW3081 : 'KW' '3081';\n");
+		grammarBuilder.append("KW3082 : 'KW' '3082';\n");
+		grammarBuilder.append("KW3083 : 'KW' '3083';\n");
+		grammarBuilder.append("KW3084 : 'KW' '3084';\n");
+		grammarBuilder.append("KW3085 : 'KW' '3085';\n");
+		grammarBuilder.append("KW3086 : 'KW' '3086';\n");
+		grammarBuilder.append("KW3087 : 'KW' '3087';\n");
+		grammarBuilder.append("KW3088 : 'KW' '3088';\n");
+		grammarBuilder.append("KW3089 : 'KW' '3089';\n");
+		grammarBuilder.append("KW3090 : 'KW' '3090';\n");
+		grammarBuilder.append("KW3091 : 'KW' '3091';\n");
+		grammarBuilder.append("KW3092 : 'KW' '3092';\n");
+		grammarBuilder.append("KW3093 : 'KW' '3093';\n");
+		grammarBuilder.append("KW3094 : 'KW' '3094';\n");
+		grammarBuilder.append("KW3095 : 'KW' '3095';\n");
+		grammarBuilder.append("KW3096 : 'KW' '3096';\n");
+		grammarBuilder.append("KW3097 : 'KW' '3097';\n");
+		grammarBuilder.append("KW3098 : 'KW' '3098';\n");
+		grammarBuilder.append("KW3099 : 'KW' '3099';\n");
+		grammarBuilder.append("KW3100 : 'KW' '3100';\n");
+		grammarBuilder.append("KW3101 : 'KW' '3101';\n");
+		grammarBuilder.append("KW3102 : 'KW' '3102';\n");
+		grammarBuilder.append("KW3103 : 'KW' '3103';\n");
+		grammarBuilder.append("KW3104 : 'KW' '3104';\n");
+		grammarBuilder.append("KW3105 : 'KW' '3105';\n");
+		grammarBuilder.append("KW3106 : 'KW' '3106';\n");
+		grammarBuilder.append("KW3107 : 'KW' '3107';\n");
+		grammarBuilder.append("KW3108 : 'KW' '3108';\n");
+		grammarBuilder.append("KW3109 : 'KW' '3109';\n");
+		grammarBuilder.append("KW3110 : 'KW' '3110';\n");
+		grammarBuilder.append("KW3111 : 'KW' '3111';\n");
+		grammarBuilder.append("KW3112 : 'KW' '3112';\n");
+		grammarBuilder.append("KW3113 : 'KW' '3113';\n");
+		grammarBuilder.append("KW3114 : 'KW' '3114';\n");
+		grammarBuilder.append("KW3115 : 'KW' '3115';\n");
+		grammarBuilder.append("KW3116 : 'KW' '3116';\n");
+		grammarBuilder.append("KW3117 : 'KW' '3117';\n");
+		grammarBuilder.append("KW3118 : 'KW' '3118';\n");
+		grammarBuilder.append("KW3119 : 'KW' '3119';\n");
+		grammarBuilder.append("KW3120 : 'KW' '3120';\n");
+		grammarBuilder.append("KW3121 : 'KW' '3121';\n");
+		grammarBuilder.append("KW3122 : 'KW' '3122';\n");
+		grammarBuilder.append("KW3123 : 'KW' '3123';\n");
+		grammarBuilder.append("KW3124 : 'KW' '3124';\n");
+		grammarBuilder.append("KW3125 : 'KW' '3125';\n");
+		grammarBuilder.append("KW3126 : 'KW' '3126';\n");
+		grammarBuilder.append("KW3127 : 'KW' '3127';\n");
+		grammarBuilder.append("KW3128 : 'KW' '3128';\n");
+		grammarBuilder.append("KW3129 : 'KW' '3129';\n");
+		grammarBuilder.append("KW3130 : 'KW' '3130';\n");
+		grammarBuilder.append("KW3131 : 'KW' '3131';\n");
+		grammarBuilder.append("KW3132 : 'KW' '3132';\n");
+		grammarBuilder.append("KW3133 : 'KW' '3133';\n");
+		grammarBuilder.append("KW3134 : 'KW' '3134';\n");
+		grammarBuilder.append("KW3135 : 'KW' '3135';\n");
+		grammarBuilder.append("KW3136 : 'KW' '3136';\n");
+		grammarBuilder.append("KW3137 : 'KW' '3137';\n");
+		grammarBuilder.append("KW3138 : 'KW' '3138';\n");
+		grammarBuilder.append("KW3139 : 'KW' '3139';\n");
+		grammarBuilder.append("KW3140 : 'KW' '3140';\n");
+		grammarBuilder.append("KW3141 : 'KW' '3141';\n");
+		grammarBuilder.append("KW3142 : 'KW' '3142';\n");
+		grammarBuilder.append("KW3143 : 'KW' '3143';\n");
+		grammarBuilder.append("KW3144 : 'KW' '3144';\n");
+		grammarBuilder.append("KW3145 : 'KW' '3145';\n");
+		grammarBuilder.append("KW3146 : 'KW' '3146';\n");
+		grammarBuilder.append("KW3147 : 'KW' '3147';\n");
+		grammarBuilder.append("KW3148 : 'KW' '3148';\n");
+		grammarBuilder.append("KW3149 : 'KW' '3149';\n");
+		grammarBuilder.append("KW3150 : 'KW' '3150';\n");
+		grammarBuilder.append("KW3151 : 'KW' '3151';\n");
+		grammarBuilder.append("KW3152 : 'KW' '3152';\n");
+		grammarBuilder.append("KW3153 : 'KW' '3153';\n");
+		grammarBuilder.append("KW3154 : 'KW' '3154';\n");
+		grammarBuilder.append("KW3155 : 'KW' '3155';\n");
+		grammarBuilder.append("KW3156 : 'KW' '3156';\n");
+		grammarBuilder.append("KW3157 : 'KW' '3157';\n");
+		grammarBuilder.append("KW3158 : 'KW' '3158';\n");
+		grammarBuilder.append("KW3159 : 'KW' '3159';\n");
+		grammarBuilder.append("KW3160 : 'KW' '3160';\n");
+		grammarBuilder.append("KW3161 : 'KW' '3161';\n");
+		grammarBuilder.append("KW3162 : 'KW' '3162';\n");
+		grammarBuilder.append("KW3163 : 'KW' '3163';\n");
+		grammarBuilder.append("KW3164 : 'KW' '3164';\n");
+		grammarBuilder.append("KW3165 : 'KW' '3165';\n");
+		grammarBuilder.append("KW3166 : 'KW' '3166';\n");
+		grammarBuilder.append("KW3167 : 'KW' '3167';\n");
+		grammarBuilder.append("KW3168 : 'KW' '3168';\n");
+		grammarBuilder.append("KW3169 : 'KW' '3169';\n");
+		grammarBuilder.append("KW3170 : 'KW' '3170';\n");
+		grammarBuilder.append("KW3171 : 'KW' '3171';\n");
+		grammarBuilder.append("KW3172 : 'KW' '3172';\n");
+		grammarBuilder.append("KW3173 : 'KW' '3173';\n");
+		grammarBuilder.append("KW3174 : 'KW' '3174';\n");
+		grammarBuilder.append("KW3175 : 'KW' '3175';\n");
+		grammarBuilder.append("KW3176 : 'KW' '3176';\n");
+		grammarBuilder.append("KW3177 : 'KW' '3177';\n");
+		grammarBuilder.append("KW3178 : 'KW' '3178';\n");
+		grammarBuilder.append("KW3179 : 'KW' '3179';\n");
+		grammarBuilder.append("KW3180 : 'KW' '3180';\n");
+		grammarBuilder.append("KW3181 : 'KW' '3181';\n");
+		grammarBuilder.append("KW3182 : 'KW' '3182';\n");
+		grammarBuilder.append("KW3183 : 'KW' '3183';\n");
+		grammarBuilder.append("KW3184 : 'KW' '3184';\n");
+		grammarBuilder.append("KW3185 : 'KW' '3185';\n");
+		grammarBuilder.append("KW3186 : 'KW' '3186';\n");
+		grammarBuilder.append("KW3187 : 'KW' '3187';\n");
+		grammarBuilder.append("KW3188 : 'KW' '3188';\n");
+		grammarBuilder.append("KW3189 : 'KW' '3189';\n");
+		grammarBuilder.append("KW3190 : 'KW' '3190';\n");
+		grammarBuilder.append("KW3191 : 'KW' '3191';\n");
+		grammarBuilder.append("KW3192 : 'KW' '3192';\n");
+		grammarBuilder.append("KW3193 : 'KW' '3193';\n");
+		grammarBuilder.append("KW3194 : 'KW' '3194';\n");
+		grammarBuilder.append("KW3195 : 'KW' '3195';\n");
+		grammarBuilder.append("KW3196 : 'KW' '3196';\n");
+		grammarBuilder.append("KW3197 : 'KW' '3197';\n");
+		grammarBuilder.append("KW3198 : 'KW' '3198';\n");
+		grammarBuilder.append("KW3199 : 'KW' '3199';\n");
+		grammarBuilder.append("KW3200 : 'KW' '3200';\n");
+		grammarBuilder.append("KW3201 : 'KW' '3201';\n");
+		grammarBuilder.append("KW3202 : 'KW' '3202';\n");
+		grammarBuilder.append("KW3203 : 'KW' '3203';\n");
+		grammarBuilder.append("KW3204 : 'KW' '3204';\n");
+		grammarBuilder.append("KW3205 : 'KW' '3205';\n");
+		grammarBuilder.append("KW3206 : 'KW' '3206';\n");
+		grammarBuilder.append("KW3207 : 'KW' '3207';\n");
+		grammarBuilder.append("KW3208 : 'KW' '3208';\n");
+		grammarBuilder.append("KW3209 : 'KW' '3209';\n");
+		grammarBuilder.append("KW3210 : 'KW' '3210';\n");
+		grammarBuilder.append("KW3211 : 'KW' '3211';\n");
+		grammarBuilder.append("KW3212 : 'KW' '3212';\n");
+		grammarBuilder.append("KW3213 : 'KW' '3213';\n");
+		grammarBuilder.append("KW3214 : 'KW' '3214';\n");
+		grammarBuilder.append("KW3215 : 'KW' '3215';\n");
+		grammarBuilder.append("KW3216 : 'KW' '3216';\n");
+		grammarBuilder.append("KW3217 : 'KW' '3217';\n");
+		grammarBuilder.append("KW3218 : 'KW' '3218';\n");
+		grammarBuilder.append("KW3219 : 'KW' '3219';\n");
+		grammarBuilder.append("KW3220 : 'KW' '3220';\n");
+		grammarBuilder.append("KW3221 : 'KW' '3221';\n");
+		grammarBuilder.append("KW3222 : 'KW' '3222';\n");
+		grammarBuilder.append("KW3223 : 'KW' '3223';\n");
+		grammarBuilder.append("KW3224 : 'KW' '3224';\n");
+		grammarBuilder.append("KW3225 : 'KW' '3225';\n");
+		grammarBuilder.append("KW3226 : 'KW' '3226';\n");
+		grammarBuilder.append("KW3227 : 'KW' '3227';\n");
+		grammarBuilder.append("KW3228 : 'KW' '3228';\n");
+		grammarBuilder.append("KW3229 : 'KW' '3229';\n");
+		grammarBuilder.append("KW3230 : 'KW' '3230';\n");
+		grammarBuilder.append("KW3231 : 'KW' '3231';\n");
+		grammarBuilder.append("KW3232 : 'KW' '3232';\n");
+		grammarBuilder.append("KW3233 : 'KW' '3233';\n");
+		grammarBuilder.append("KW3234 : 'KW' '3234';\n");
+		grammarBuilder.append("KW3235 : 'KW' '3235';\n");
+		grammarBuilder.append("KW3236 : 'KW' '3236';\n");
+		grammarBuilder.append("KW3237 : 'KW' '3237';\n");
+		grammarBuilder.append("KW3238 : 'KW' '3238';\n");
+		grammarBuilder.append("KW3239 : 'KW' '3239';\n");
+		grammarBuilder.append("KW3240 : 'KW' '3240';\n");
+		grammarBuilder.append("KW3241 : 'KW' '3241';\n");
+		grammarBuilder.append("KW3242 : 'KW' '3242';\n");
+		grammarBuilder.append("KW3243 : 'KW' '3243';\n");
+		grammarBuilder.append("KW3244 : 'KW' '3244';\n");
+		grammarBuilder.append("KW3245 : 'KW' '3245';\n");
+		grammarBuilder.append("KW3246 : 'KW' '3246';\n");
+		grammarBuilder.append("KW3247 : 'KW' '3247';\n");
+		grammarBuilder.append("KW3248 : 'KW' '3248';\n");
+		grammarBuilder.append("KW3249 : 'KW' '3249';\n");
+		grammarBuilder.append("KW3250 : 'KW' '3250';\n");
+		grammarBuilder.append("KW3251 : 'KW' '3251';\n");
+		grammarBuilder.append("KW3252 : 'KW' '3252';\n");
+		grammarBuilder.append("KW3253 : 'KW' '3253';\n");
+		grammarBuilder.append("KW3254 : 'KW' '3254';\n");
+		grammarBuilder.append("KW3255 : 'KW' '3255';\n");
+		grammarBuilder.append("KW3256 : 'KW' '3256';\n");
+		grammarBuilder.append("KW3257 : 'KW' '3257';\n");
+		grammarBuilder.append("KW3258 : 'KW' '3258';\n");
+		grammarBuilder.append("KW3259 : 'KW' '3259';\n");
+		grammarBuilder.append("KW3260 : 'KW' '3260';\n");
+		grammarBuilder.append("KW3261 : 'KW' '3261';\n");
+		grammarBuilder.append("KW3262 : 'KW' '3262';\n");
+		grammarBuilder.append("KW3263 : 'KW' '3263';\n");
+		grammarBuilder.append("KW3264 : 'KW' '3264';\n");
+		grammarBuilder.append("KW3265 : 'KW' '3265';\n");
+		grammarBuilder.append("KW3266 : 'KW' '3266';\n");
+		grammarBuilder.append("KW3267 : 'KW' '3267';\n");
+		grammarBuilder.append("KW3268 : 'KW' '3268';\n");
+		grammarBuilder.append("KW3269 : 'KW' '3269';\n");
+		grammarBuilder.append("KW3270 : 'KW' '3270';\n");
+		grammarBuilder.append("KW3271 : 'KW' '3271';\n");
+		grammarBuilder.append("KW3272 : 'KW' '3272';\n");
+		grammarBuilder.append("KW3273 : 'KW' '3273';\n");
+		grammarBuilder.append("KW3274 : 'KW' '3274';\n");
+		grammarBuilder.append("KW3275 : 'KW' '3275';\n");
+		grammarBuilder.append("KW3276 : 'KW' '3276';\n");
+		grammarBuilder.append("KW3277 : 'KW' '3277';\n");
+		grammarBuilder.append("KW3278 : 'KW' '3278';\n");
+		grammarBuilder.append("KW3279 : 'KW' '3279';\n");
+		grammarBuilder.append("KW3280 : 'KW' '3280';\n");
+		grammarBuilder.append("KW3281 : 'KW' '3281';\n");
+		grammarBuilder.append("KW3282 : 'KW' '3282';\n");
+		grammarBuilder.append("KW3283 : 'KW' '3283';\n");
+		grammarBuilder.append("KW3284 : 'KW' '3284';\n");
+		grammarBuilder.append("KW3285 : 'KW' '3285';\n");
+		grammarBuilder.append("KW3286 : 'KW' '3286';\n");
+		grammarBuilder.append("KW3287 : 'KW' '3287';\n");
+		grammarBuilder.append("KW3288 : 'KW' '3288';\n");
+		grammarBuilder.append("KW3289 : 'KW' '3289';\n");
+		grammarBuilder.append("KW3290 : 'KW' '3290';\n");
+		grammarBuilder.append("KW3291 : 'KW' '3291';\n");
+		grammarBuilder.append("KW3292 : 'KW' '3292';\n");
+		grammarBuilder.append("KW3293 : 'KW' '3293';\n");
+		grammarBuilder.append("KW3294 : 'KW' '3294';\n");
+		grammarBuilder.append("KW3295 : 'KW' '3295';\n");
+		grammarBuilder.append("KW3296 : 'KW' '3296';\n");
+		grammarBuilder.append("KW3297 : 'KW' '3297';\n");
+		grammarBuilder.append("KW3298 : 'KW' '3298';\n");
+		grammarBuilder.append("KW3299 : 'KW' '3299';\n");
+		grammarBuilder.append("KW3300 : 'KW' '3300';\n");
+		grammarBuilder.append("KW3301 : 'KW' '3301';\n");
+		grammarBuilder.append("KW3302 : 'KW' '3302';\n");
+		grammarBuilder.append("KW3303 : 'KW' '3303';\n");
+		grammarBuilder.append("KW3304 : 'KW' '3304';\n");
+		grammarBuilder.append("KW3305 : 'KW' '3305';\n");
+		grammarBuilder.append("KW3306 : 'KW' '3306';\n");
+		grammarBuilder.append("KW3307 : 'KW' '3307';\n");
+		grammarBuilder.append("KW3308 : 'KW' '3308';\n");
+		grammarBuilder.append("KW3309 : 'KW' '3309';\n");
+		grammarBuilder.append("KW3310 : 'KW' '3310';\n");
+		grammarBuilder.append("KW3311 : 'KW' '3311';\n");
+		grammarBuilder.append("KW3312 : 'KW' '3312';\n");
+		grammarBuilder.append("KW3313 : 'KW' '3313';\n");
+		grammarBuilder.append("KW3314 : 'KW' '3314';\n");
+		grammarBuilder.append("KW3315 : 'KW' '3315';\n");
+		grammarBuilder.append("KW3316 : 'KW' '3316';\n");
+		grammarBuilder.append("KW3317 : 'KW' '3317';\n");
+		grammarBuilder.append("KW3318 : 'KW' '3318';\n");
+		grammarBuilder.append("KW3319 : 'KW' '3319';\n");
+		grammarBuilder.append("KW3320 : 'KW' '3320';\n");
+		grammarBuilder.append("KW3321 : 'KW' '3321';\n");
+		grammarBuilder.append("KW3322 : 'KW' '3322';\n");
+		grammarBuilder.append("KW3323 : 'KW' '3323';\n");
+		grammarBuilder.append("KW3324 : 'KW' '3324';\n");
+		grammarBuilder.append("KW3325 : 'KW' '3325';\n");
+		grammarBuilder.append("KW3326 : 'KW' '3326';\n");
+		grammarBuilder.append("KW3327 : 'KW' '3327';\n");
+		grammarBuilder.append("KW3328 : 'KW' '3328';\n");
+		grammarBuilder.append("KW3329 : 'KW' '3329';\n");
+		grammarBuilder.append("KW3330 : 'KW' '3330';\n");
+		grammarBuilder.append("KW3331 : 'KW' '3331';\n");
+		grammarBuilder.append("KW3332 : 'KW' '3332';\n");
+		grammarBuilder.append("KW3333 : 'KW' '3333';\n");
+		grammarBuilder.append("KW3334 : 'KW' '3334';\n");
+		grammarBuilder.append("KW3335 : 'KW' '3335';\n");
+		grammarBuilder.append("KW3336 : 'KW' '3336';\n");
+		grammarBuilder.append("KW3337 : 'KW' '3337';\n");
+		grammarBuilder.append("KW3338 : 'KW' '3338';\n");
+		grammarBuilder.append("KW3339 : 'KW' '3339';\n");
+		grammarBuilder.append("KW3340 : 'KW' '3340';\n");
+		grammarBuilder.append("KW3341 : 'KW' '3341';\n");
+		grammarBuilder.append("KW3342 : 'KW' '3342';\n");
+		grammarBuilder.append("KW3343 : 'KW' '3343';\n");
+		grammarBuilder.append("KW3344 : 'KW' '3344';\n");
+		grammarBuilder.append("KW3345 : 'KW' '3345';\n");
+		grammarBuilder.append("KW3346 : 'KW' '3346';\n");
+		grammarBuilder.append("KW3347 : 'KW' '3347';\n");
+		grammarBuilder.append("KW3348 : 'KW' '3348';\n");
+		grammarBuilder.append("KW3349 : 'KW' '3349';\n");
+		grammarBuilder.append("KW3350 : 'KW' '3350';\n");
+		grammarBuilder.append("KW3351 : 'KW' '3351';\n");
+		grammarBuilder.append("KW3352 : 'KW' '3352';\n");
+		grammarBuilder.append("KW3353 : 'KW' '3353';\n");
+		grammarBuilder.append("KW3354 : 'KW' '3354';\n");
+		grammarBuilder.append("KW3355 : 'KW' '3355';\n");
+		grammarBuilder.append("KW3356 : 'KW' '3356';\n");
+		grammarBuilder.append("KW3357 : 'KW' '3357';\n");
+		grammarBuilder.append("KW3358 : 'KW' '3358';\n");
+		grammarBuilder.append("KW3359 : 'KW' '3359';\n");
+		grammarBuilder.append("KW3360 : 'KW' '3360';\n");
+		grammarBuilder.append("KW3361 : 'KW' '3361';\n");
+		grammarBuilder.append("KW3362 : 'KW' '3362';\n");
+		grammarBuilder.append("KW3363 : 'KW' '3363';\n");
+		grammarBuilder.append("KW3364 : 'KW' '3364';\n");
+		grammarBuilder.append("KW3365 : 'KW' '3365';\n");
+		grammarBuilder.append("KW3366 : 'KW' '3366';\n");
+		grammarBuilder.append("KW3367 : 'KW' '3367';\n");
+		grammarBuilder.append("KW3368 : 'KW' '3368';\n");
+		grammarBuilder.append("KW3369 : 'KW' '3369';\n");
+		grammarBuilder.append("KW3370 : 'KW' '3370';\n");
+		grammarBuilder.append("KW3371 : 'KW' '3371';\n");
+		grammarBuilder.append("KW3372 : 'KW' '3372';\n");
+		grammarBuilder.append("KW3373 : 'KW' '3373';\n");
+		grammarBuilder.append("KW3374 : 'KW' '3374';\n");
+		grammarBuilder.append("KW3375 : 'KW' '3375';\n");
+		grammarBuilder.append("KW3376 : 'KW' '3376';\n");
+		grammarBuilder.append("KW3377 : 'KW' '3377';\n");
+		grammarBuilder.append("KW3378 : 'KW' '3378';\n");
+		grammarBuilder.append("KW3379 : 'KW' '3379';\n");
+		grammarBuilder.append("KW3380 : 'KW' '3380';\n");
+		grammarBuilder.append("KW3381 : 'KW' '3381';\n");
+		grammarBuilder.append("KW3382 : 'KW' '3382';\n");
+		grammarBuilder.append("KW3383 : 'KW' '3383';\n");
+		grammarBuilder.append("KW3384 : 'KW' '3384';\n");
+		grammarBuilder.append("KW3385 : 'KW' '3385';\n");
+		grammarBuilder.append("KW3386 : 'KW' '3386';\n");
+		grammarBuilder.append("KW3387 : 'KW' '3387';\n");
+		grammarBuilder.append("KW3388 : 'KW' '3388';\n");
+		grammarBuilder.append("KW3389 : 'KW' '3389';\n");
+		grammarBuilder.append("KW3390 : 'KW' '3390';\n");
+		grammarBuilder.append("KW3391 : 'KW' '3391';\n");
+		grammarBuilder.append("KW3392 : 'KW' '3392';\n");
+		grammarBuilder.append("KW3393 : 'KW' '3393';\n");
+		grammarBuilder.append("KW3394 : 'KW' '3394';\n");
+		grammarBuilder.append("KW3395 : 'KW' '3395';\n");
+		grammarBuilder.append("KW3396 : 'KW' '3396';\n");
+		grammarBuilder.append("KW3397 : 'KW' '3397';\n");
+		grammarBuilder.append("KW3398 : 'KW' '3398';\n");
+		grammarBuilder.append("KW3399 : 'KW' '3399';\n");
+		grammarBuilder.append("KW3400 : 'KW' '3400';\n");
+		grammarBuilder.append("KW3401 : 'KW' '3401';\n");
+		grammarBuilder.append("KW3402 : 'KW' '3402';\n");
+		grammarBuilder.append("KW3403 : 'KW' '3403';\n");
+		grammarBuilder.append("KW3404 : 'KW' '3404';\n");
+		grammarBuilder.append("KW3405 : 'KW' '3405';\n");
+		grammarBuilder.append("KW3406 : 'KW' '3406';\n");
+		grammarBuilder.append("KW3407 : 'KW' '3407';\n");
+		grammarBuilder.append("KW3408 : 'KW' '3408';\n");
+		grammarBuilder.append("KW3409 : 'KW' '3409';\n");
+		grammarBuilder.append("KW3410 : 'KW' '3410';\n");
+		grammarBuilder.append("KW3411 : 'KW' '3411';\n");
+		grammarBuilder.append("KW3412 : 'KW' '3412';\n");
+		grammarBuilder.append("KW3413 : 'KW' '3413';\n");
+		grammarBuilder.append("KW3414 : 'KW' '3414';\n");
+		grammarBuilder.append("KW3415 : 'KW' '3415';\n");
+		grammarBuilder.append("KW3416 : 'KW' '3416';\n");
+		grammarBuilder.append("KW3417 : 'KW' '3417';\n");
+		grammarBuilder.append("KW3418 : 'KW' '3418';\n");
+		grammarBuilder.append("KW3419 : 'KW' '3419';\n");
+		grammarBuilder.append("KW3420 : 'KW' '3420';\n");
+		grammarBuilder.append("KW3421 : 'KW' '3421';\n");
+		grammarBuilder.append("KW3422 : 'KW' '3422';\n");
+		grammarBuilder.append("KW3423 : 'KW' '3423';\n");
+		grammarBuilder.append("KW3424 : 'KW' '3424';\n");
+		grammarBuilder.append("KW3425 : 'KW' '3425';\n");
+		grammarBuilder.append("KW3426 : 'KW' '3426';\n");
+		grammarBuilder.append("KW3427 : 'KW' '3427';\n");
+		grammarBuilder.append("KW3428 : 'KW' '3428';\n");
+		grammarBuilder.append("KW3429 : 'KW' '3429';\n");
+		grammarBuilder.append("KW3430 : 'KW' '3430';\n");
+		grammarBuilder.append("KW3431 : 'KW' '3431';\n");
+		grammarBuilder.append("KW3432 : 'KW' '3432';\n");
+		grammarBuilder.append("KW3433 : 'KW' '3433';\n");
+		grammarBuilder.append("KW3434 : 'KW' '3434';\n");
+		grammarBuilder.append("KW3435 : 'KW' '3435';\n");
+		grammarBuilder.append("KW3436 : 'KW' '3436';\n");
+		grammarBuilder.append("KW3437 : 'KW' '3437';\n");
+		grammarBuilder.append("KW3438 : 'KW' '3438';\n");
+		grammarBuilder.append("KW3439 : 'KW' '3439';\n");
+		grammarBuilder.append("KW3440 : 'KW' '3440';\n");
+		grammarBuilder.append("KW3441 : 'KW' '3441';\n");
+		grammarBuilder.append("KW3442 : 'KW' '3442';\n");
+		grammarBuilder.append("KW3443 : 'KW' '3443';\n");
+		grammarBuilder.append("KW3444 : 'KW' '3444';\n");
+		grammarBuilder.append("KW3445 : 'KW' '3445';\n");
+		grammarBuilder.append("KW3446 : 'KW' '3446';\n");
+		grammarBuilder.append("KW3447 : 'KW' '3447';\n");
+		grammarBuilder.append("KW3448 : 'KW' '3448';\n");
+		grammarBuilder.append("KW3449 : 'KW' '3449';\n");
+		grammarBuilder.append("KW3450 : 'KW' '3450';\n");
+		grammarBuilder.append("KW3451 : 'KW' '3451';\n");
+		grammarBuilder.append("KW3452 : 'KW' '3452';\n");
+		grammarBuilder.append("KW3453 : 'KW' '3453';\n");
+		grammarBuilder.append("KW3454 : 'KW' '3454';\n");
+		grammarBuilder.append("KW3455 : 'KW' '3455';\n");
+		grammarBuilder.append("KW3456 : 'KW' '3456';\n");
+		grammarBuilder.append("KW3457 : 'KW' '3457';\n");
+		grammarBuilder.append("KW3458 : 'KW' '3458';\n");
+		grammarBuilder.append("KW3459 : 'KW' '3459';\n");
+		grammarBuilder.append("KW3460 : 'KW' '3460';\n");
+		grammarBuilder.append("KW3461 : 'KW' '3461';\n");
+		grammarBuilder.append("KW3462 : 'KW' '3462';\n");
+		grammarBuilder.append("KW3463 : 'KW' '3463';\n");
+		grammarBuilder.append("KW3464 : 'KW' '3464';\n");
+		grammarBuilder.append("KW3465 : 'KW' '3465';\n");
+		grammarBuilder.append("KW3466 : 'KW' '3466';\n");
+		grammarBuilder.append("KW3467 : 'KW' '3467';\n");
+		grammarBuilder.append("KW3468 : 'KW' '3468';\n");
+		grammarBuilder.append("KW3469 : 'KW' '3469';\n");
+		grammarBuilder.append("KW3470 : 'KW' '3470';\n");
+		grammarBuilder.append("KW3471 : 'KW' '3471';\n");
+		grammarBuilder.append("KW3472 : 'KW' '3472';\n");
+		grammarBuilder.append("KW3473 : 'KW' '3473';\n");
+		grammarBuilder.append("KW3474 : 'KW' '3474';\n");
+		grammarBuilder.append("KW3475 : 'KW' '3475';\n");
+		grammarBuilder.append("KW3476 : 'KW' '3476';\n");
+		grammarBuilder.append("KW3477 : 'KW' '3477';\n");
+		grammarBuilder.append("KW3478 : 'KW' '3478';\n");
+		grammarBuilder.append("KW3479 : 'KW' '3479';\n");
+		grammarBuilder.append("KW3480 : 'KW' '3480';\n");
+		grammarBuilder.append("KW3481 : 'KW' '3481';\n");
+		grammarBuilder.append("KW3482 : 'KW' '3482';\n");
+		grammarBuilder.append("KW3483 : 'KW' '3483';\n");
+		grammarBuilder.append("KW3484 : 'KW' '3484';\n");
+		grammarBuilder.append("KW3485 : 'KW' '3485';\n");
+		grammarBuilder.append("KW3486 : 'KW' '3486';\n");
+		grammarBuilder.append("KW3487 : 'KW' '3487';\n");
+		grammarBuilder.append("KW3488 : 'KW' '3488';\n");
+		grammarBuilder.append("KW3489 : 'KW' '3489';\n");
+		grammarBuilder.append("KW3490 : 'KW' '3490';\n");
+		grammarBuilder.append("KW3491 : 'KW' '3491';\n");
+		grammarBuilder.append("KW3492 : 'KW' '3492';\n");
+		grammarBuilder.append("KW3493 : 'KW' '3493';\n");
+		grammarBuilder.append("KW3494 : 'KW' '3494';\n");
+		grammarBuilder.append("KW3495 : 'KW' '3495';\n");
+		grammarBuilder.append("KW3496 : 'KW' '3496';\n");
+		grammarBuilder.append("KW3497 : 'KW' '3497';\n");
+		grammarBuilder.append("KW3498 : 'KW' '3498';\n");
+		grammarBuilder.append("KW3499 : 'KW' '3499';\n");
+		grammarBuilder.append("KW3500 : 'KW' '3500';\n");
+		grammarBuilder.append("KW3501 : 'KW' '3501';\n");
+		grammarBuilder.append("KW3502 : 'KW' '3502';\n");
+		grammarBuilder.append("KW3503 : 'KW' '3503';\n");
+		grammarBuilder.append("KW3504 : 'KW' '3504';\n");
+		grammarBuilder.append("KW3505 : 'KW' '3505';\n");
+		grammarBuilder.append("KW3506 : 'KW' '3506';\n");
+		grammarBuilder.append("KW3507 : 'KW' '3507';\n");
+		grammarBuilder.append("KW3508 : 'KW' '3508';\n");
+		grammarBuilder.append("KW3509 : 'KW' '3509';\n");
+		grammarBuilder.append("KW3510 : 'KW' '3510';\n");
+		grammarBuilder.append("KW3511 : 'KW' '3511';\n");
+		grammarBuilder.append("KW3512 : 'KW' '3512';\n");
+		grammarBuilder.append("KW3513 : 'KW' '3513';\n");
+		grammarBuilder.append("KW3514 : 'KW' '3514';\n");
+		grammarBuilder.append("KW3515 : 'KW' '3515';\n");
+		grammarBuilder.append("KW3516 : 'KW' '3516';\n");
+		grammarBuilder.append("KW3517 : 'KW' '3517';\n");
+		grammarBuilder.append("KW3518 : 'KW' '3518';\n");
+		grammarBuilder.append("KW3519 : 'KW' '3519';\n");
+		grammarBuilder.append("KW3520 : 'KW' '3520';\n");
+		grammarBuilder.append("KW3521 : 'KW' '3521';\n");
+		grammarBuilder.append("KW3522 : 'KW' '3522';\n");
+		grammarBuilder.append("KW3523 : 'KW' '3523';\n");
+		grammarBuilder.append("KW3524 : 'KW' '3524';\n");
+		grammarBuilder.append("KW3525 : 'KW' '3525';\n");
+		grammarBuilder.append("KW3526 : 'KW' '3526';\n");
+		grammarBuilder.append("KW3527 : 'KW' '3527';\n");
+		grammarBuilder.append("KW3528 : 'KW' '3528';\n");
+		grammarBuilder.append("KW3529 : 'KW' '3529';\n");
+		grammarBuilder.append("KW3530 : 'KW' '3530';\n");
+		grammarBuilder.append("KW3531 : 'KW' '3531';\n");
+		grammarBuilder.append("KW3532 : 'KW' '3532';\n");
+		grammarBuilder.append("KW3533 : 'KW' '3533';\n");
+		grammarBuilder.append("KW3534 : 'KW' '3534';\n");
+		grammarBuilder.append("KW3535 : 'KW' '3535';\n");
+		grammarBuilder.append("KW3536 : 'KW' '3536';\n");
+		grammarBuilder.append("KW3537 : 'KW' '3537';\n");
+		grammarBuilder.append("KW3538 : 'KW' '3538';\n");
+		grammarBuilder.append("KW3539 : 'KW' '3539';\n");
+		grammarBuilder.append("KW3540 : 'KW' '3540';\n");
+		grammarBuilder.append("KW3541 : 'KW' '3541';\n");
+		grammarBuilder.append("KW3542 : 'KW' '3542';\n");
+		grammarBuilder.append("KW3543 : 'KW' '3543';\n");
+		grammarBuilder.append("KW3544 : 'KW' '3544';\n");
+		grammarBuilder.append("KW3545 : 'KW' '3545';\n");
+		grammarBuilder.append("KW3546 : 'KW' '3546';\n");
+		grammarBuilder.append("KW3547 : 'KW' '3547';\n");
+		grammarBuilder.append("KW3548 : 'KW' '3548';\n");
+		grammarBuilder.append("KW3549 : 'KW' '3549';\n");
+		grammarBuilder.append("KW3550 : 'KW' '3550';\n");
+		grammarBuilder.append("KW3551 : 'KW' '3551';\n");
+		grammarBuilder.append("KW3552 : 'KW' '3552';\n");
+		grammarBuilder.append("KW3553 : 'KW' '3553';\n");
+		grammarBuilder.append("KW3554 : 'KW' '3554';\n");
+		grammarBuilder.append("KW3555 : 'KW' '3555';\n");
+		grammarBuilder.append("KW3556 : 'KW' '3556';\n");
+		grammarBuilder.append("KW3557 : 'KW' '3557';\n");
+		grammarBuilder.append("KW3558 : 'KW' '3558';\n");
+		grammarBuilder.append("KW3559 : 'KW' '3559';\n");
+		grammarBuilder.append("KW3560 : 'KW' '3560';\n");
+		grammarBuilder.append("KW3561 : 'KW' '3561';\n");
+		grammarBuilder.append("KW3562 : 'KW' '3562';\n");
+		grammarBuilder.append("KW3563 : 'KW' '3563';\n");
+		grammarBuilder.append("KW3564 : 'KW' '3564';\n");
+		grammarBuilder.append("KW3565 : 'KW' '3565';\n");
+		grammarBuilder.append("KW3566 : 'KW' '3566';\n");
+		grammarBuilder.append("KW3567 : 'KW' '3567';\n");
+		grammarBuilder.append("KW3568 : 'KW' '3568';\n");
+		grammarBuilder.append("KW3569 : 'KW' '3569';\n");
+		grammarBuilder.append("KW3570 : 'KW' '3570';\n");
+		grammarBuilder.append("KW3571 : 'KW' '3571';\n");
+		grammarBuilder.append("KW3572 : 'KW' '3572';\n");
+		grammarBuilder.append("KW3573 : 'KW' '3573';\n");
+		grammarBuilder.append("KW3574 : 'KW' '3574';\n");
+		grammarBuilder.append("KW3575 : 'KW' '3575';\n");
+		grammarBuilder.append("KW3576 : 'KW' '3576';\n");
+		grammarBuilder.append("KW3577 : 'KW' '3577';\n");
+		grammarBuilder.append("KW3578 : 'KW' '3578';\n");
+		grammarBuilder.append("KW3579 : 'KW' '3579';\n");
+		grammarBuilder.append("KW3580 : 'KW' '3580';\n");
+		grammarBuilder.append("KW3581 : 'KW' '3581';\n");
+		grammarBuilder.append("KW3582 : 'KW' '3582';\n");
+		grammarBuilder.append("KW3583 : 'KW' '3583';\n");
+		grammarBuilder.append("KW3584 : 'KW' '3584';\n");
+		grammarBuilder.append("KW3585 : 'KW' '3585';\n");
+		grammarBuilder.append("KW3586 : 'KW' '3586';\n");
+		grammarBuilder.append("KW3587 : 'KW' '3587';\n");
+		grammarBuilder.append("KW3588 : 'KW' '3588';\n");
+		grammarBuilder.append("KW3589 : 'KW' '3589';\n");
+		grammarBuilder.append("KW3590 : 'KW' '3590';\n");
+		grammarBuilder.append("KW3591 : 'KW' '3591';\n");
+		grammarBuilder.append("KW3592 : 'KW' '3592';\n");
+		grammarBuilder.append("KW3593 : 'KW' '3593';\n");
+		grammarBuilder.append("KW3594 : 'KW' '3594';\n");
+		grammarBuilder.append("KW3595 : 'KW' '3595';\n");
+		grammarBuilder.append("KW3596 : 'KW' '3596';\n");
+		grammarBuilder.append("KW3597 : 'KW' '3597';\n");
+		grammarBuilder.append("KW3598 : 'KW' '3598';\n");
+		grammarBuilder.append("KW3599 : 'KW' '3599';\n");
+		grammarBuilder.append("KW3600 : 'KW' '3600';\n");
+		grammarBuilder.append("KW3601 : 'KW' '3601';\n");
+		grammarBuilder.append("KW3602 : 'KW' '3602';\n");
+		grammarBuilder.append("KW3603 : 'KW' '3603';\n");
+		grammarBuilder.append("KW3604 : 'KW' '3604';\n");
+		grammarBuilder.append("KW3605 : 'KW' '3605';\n");
+		grammarBuilder.append("KW3606 : 'KW' '3606';\n");
+		grammarBuilder.append("KW3607 : 'KW' '3607';\n");
+		grammarBuilder.append("KW3608 : 'KW' '3608';\n");
+		grammarBuilder.append("KW3609 : 'KW' '3609';\n");
+		grammarBuilder.append("KW3610 : 'KW' '3610';\n");
+		grammarBuilder.append("KW3611 : 'KW' '3611';\n");
+		grammarBuilder.append("KW3612 : 'KW' '3612';\n");
+		grammarBuilder.append("KW3613 : 'KW' '3613';\n");
+		grammarBuilder.append("KW3614 : 'KW' '3614';\n");
+		grammarBuilder.append("KW3615 : 'KW' '3615';\n");
+		grammarBuilder.append("KW3616 : 'KW' '3616';\n");
+		grammarBuilder.append("KW3617 : 'KW' '3617';\n");
+		grammarBuilder.append("KW3618 : 'KW' '3618';\n");
+		grammarBuilder.append("KW3619 : 'KW' '3619';\n");
+		grammarBuilder.append("KW3620 : 'KW' '3620';\n");
+		grammarBuilder.append("KW3621 : 'KW' '3621';\n");
+		grammarBuilder.append("KW3622 : 'KW' '3622';\n");
+		grammarBuilder.append("KW3623 : 'KW' '3623';\n");
+		grammarBuilder.append("KW3624 : 'KW' '3624';\n");
+		grammarBuilder.append("KW3625 : 'KW' '3625';\n");
+		grammarBuilder.append("KW3626 : 'KW' '3626';\n");
+		grammarBuilder.append("KW3627 : 'KW' '3627';\n");
+		grammarBuilder.append("KW3628 : 'KW' '3628';\n");
+		grammarBuilder.append("KW3629 : 'KW' '3629';\n");
+		grammarBuilder.append("KW3630 : 'KW' '3630';\n");
+		grammarBuilder.append("KW3631 : 'KW' '3631';\n");
+		grammarBuilder.append("KW3632 : 'KW' '3632';\n");
+		grammarBuilder.append("KW3633 : 'KW' '3633';\n");
+		grammarBuilder.append("KW3634 : 'KW' '3634';\n");
+		grammarBuilder.append("KW3635 : 'KW' '3635';\n");
+		grammarBuilder.append("KW3636 : 'KW' '3636';\n");
+		grammarBuilder.append("KW3637 : 'KW' '3637';\n");
+		grammarBuilder.append("KW3638 : 'KW' '3638';\n");
+		grammarBuilder.append("KW3639 : 'KW' '3639';\n");
+		grammarBuilder.append("KW3640 : 'KW' '3640';\n");
+		grammarBuilder.append("KW3641 : 'KW' '3641';\n");
+		grammarBuilder.append("KW3642 : 'KW' '3642';\n");
+		grammarBuilder.append("KW3643 : 'KW' '3643';\n");
+		grammarBuilder.append("KW3644 : 'KW' '3644';\n");
+		grammarBuilder.append("KW3645 : 'KW' '3645';\n");
+		grammarBuilder.append("KW3646 : 'KW' '3646';\n");
+		grammarBuilder.append("KW3647 : 'KW' '3647';\n");
+		grammarBuilder.append("KW3648 : 'KW' '3648';\n");
+		grammarBuilder.append("KW3649 : 'KW' '3649';\n");
+		grammarBuilder.append("KW3650 : 'KW' '3650';\n");
+		grammarBuilder.append("KW3651 : 'KW' '3651';\n");
+		grammarBuilder.append("KW3652 : 'KW' '3652';\n");
+		grammarBuilder.append("KW3653 : 'KW' '3653';\n");
+		grammarBuilder.append("KW3654 : 'KW' '3654';\n");
+		grammarBuilder.append("KW3655 : 'KW' '3655';\n");
+		grammarBuilder.append("KW3656 : 'KW' '3656';\n");
+		grammarBuilder.append("KW3657 : 'KW' '3657';\n");
+		grammarBuilder.append("KW3658 : 'KW' '3658';\n");
+		grammarBuilder.append("KW3659 : 'KW' '3659';\n");
+		grammarBuilder.append("KW3660 : 'KW' '3660';\n");
+		grammarBuilder.append("KW3661 : 'KW' '3661';\n");
+		grammarBuilder.append("KW3662 : 'KW' '3662';\n");
+		grammarBuilder.append("KW3663 : 'KW' '3663';\n");
+		grammarBuilder.append("KW3664 : 'KW' '3664';\n");
+		grammarBuilder.append("KW3665 : 'KW' '3665';\n");
+		grammarBuilder.append("KW3666 : 'KW' '3666';\n");
+		grammarBuilder.append("KW3667 : 'KW' '3667';\n");
+		grammarBuilder.append("KW3668 : 'KW' '3668';\n");
+		grammarBuilder.append("KW3669 : 'KW' '3669';\n");
+		grammarBuilder.append("KW3670 : 'KW' '3670';\n");
+		grammarBuilder.append("KW3671 : 'KW' '3671';\n");
+		grammarBuilder.append("KW3672 : 'KW' '3672';\n");
+		grammarBuilder.append("KW3673 : 'KW' '3673';\n");
+		grammarBuilder.append("KW3674 : 'KW' '3674';\n");
+		grammarBuilder.append("KW3675 : 'KW' '3675';\n");
+		grammarBuilder.append("KW3676 : 'KW' '3676';\n");
+		grammarBuilder.append("KW3677 : 'KW' '3677';\n");
+		grammarBuilder.append("KW3678 : 'KW' '3678';\n");
+		grammarBuilder.append("KW3679 : 'KW' '3679';\n");
+		grammarBuilder.append("KW3680 : 'KW' '3680';\n");
+		grammarBuilder.append("KW3681 : 'KW' '3681';\n");
+		grammarBuilder.append("KW3682 : 'KW' '3682';\n");
+		grammarBuilder.append("KW3683 : 'KW' '3683';\n");
+		grammarBuilder.append("KW3684 : 'KW' '3684';\n");
+		grammarBuilder.append("KW3685 : 'KW' '3685';\n");
+		grammarBuilder.append("KW3686 : 'KW' '3686';\n");
+		grammarBuilder.append("KW3687 : 'KW' '3687';\n");
+		grammarBuilder.append("KW3688 : 'KW' '3688';\n");
+		grammarBuilder.append("KW3689 : 'KW' '3689';\n");
+		grammarBuilder.append("KW3690 : 'KW' '3690';\n");
+		grammarBuilder.append("KW3691 : 'KW' '3691';\n");
+		grammarBuilder.append("KW3692 : 'KW' '3692';\n");
+		grammarBuilder.append("KW3693 : 'KW' '3693';\n");
+		grammarBuilder.append("KW3694 : 'KW' '3694';\n");
+		grammarBuilder.append("KW3695 : 'KW' '3695';\n");
+		grammarBuilder.append("KW3696 : 'KW' '3696';\n");
+		grammarBuilder.append("KW3697 : 'KW' '3697';\n");
+		grammarBuilder.append("KW3698 : 'KW' '3698';\n");
+		grammarBuilder.append("KW3699 : 'KW' '3699';\n");
+		grammarBuilder.append("KW3700 : 'KW' '3700';\n");
+		grammarBuilder.append("KW3701 : 'KW' '3701';\n");
+		grammarBuilder.append("KW3702 : 'KW' '3702';\n");
+		grammarBuilder.append("KW3703 : 'KW' '3703';\n");
+		grammarBuilder.append("KW3704 : 'KW' '3704';\n");
+		grammarBuilder.append("KW3705 : 'KW' '3705';\n");
+		grammarBuilder.append("KW3706 : 'KW' '3706';\n");
+		grammarBuilder.append("KW3707 : 'KW' '3707';\n");
+		grammarBuilder.append("KW3708 : 'KW' '3708';\n");
+		grammarBuilder.append("KW3709 : 'KW' '3709';\n");
+		grammarBuilder.append("KW3710 : 'KW' '3710';\n");
+		grammarBuilder.append("KW3711 : 'KW' '3711';\n");
+		grammarBuilder.append("KW3712 : 'KW' '3712';\n");
+		grammarBuilder.append("KW3713 : 'KW' '3713';\n");
+		grammarBuilder.append("KW3714 : 'KW' '3714';\n");
+		grammarBuilder.append("KW3715 : 'KW' '3715';\n");
+		grammarBuilder.append("KW3716 : 'KW' '3716';\n");
+		grammarBuilder.append("KW3717 : 'KW' '3717';\n");
+		grammarBuilder.append("KW3718 : 'KW' '3718';\n");
+		grammarBuilder.append("KW3719 : 'KW' '3719';\n");
+		grammarBuilder.append("KW3720 : 'KW' '3720';\n");
+		grammarBuilder.append("KW3721 : 'KW' '3721';\n");
+		grammarBuilder.append("KW3722 : 'KW' '3722';\n");
+		grammarBuilder.append("KW3723 : 'KW' '3723';\n");
+		grammarBuilder.append("KW3724 : 'KW' '3724';\n");
+		grammarBuilder.append("KW3725 : 'KW' '3725';\n");
+		grammarBuilder.append("KW3726 : 'KW' '3726';\n");
+		grammarBuilder.append("KW3727 : 'KW' '3727';\n");
+		grammarBuilder.append("KW3728 : 'KW' '3728';\n");
+		grammarBuilder.append("KW3729 : 'KW' '3729';\n");
+		grammarBuilder.append("KW3730 : 'KW' '3730';\n");
+		grammarBuilder.append("KW3731 : 'KW' '3731';\n");
+		grammarBuilder.append("KW3732 : 'KW' '3732';\n");
+		grammarBuilder.append("KW3733 : 'KW' '3733';\n");
+		grammarBuilder.append("KW3734 : 'KW' '3734';\n");
+		grammarBuilder.append("KW3735 : 'KW' '3735';\n");
+		grammarBuilder.append("KW3736 : 'KW' '3736';\n");
+		grammarBuilder.append("KW3737 : 'KW' '3737';\n");
+		grammarBuilder.append("KW3738 : 'KW' '3738';\n");
+		grammarBuilder.append("KW3739 : 'KW' '3739';\n");
+		grammarBuilder.append("KW3740 : 'KW' '3740';\n");
+		grammarBuilder.append("KW3741 : 'KW' '3741';\n");
+		grammarBuilder.append("KW3742 : 'KW' '3742';\n");
+		grammarBuilder.append("KW3743 : 'KW' '3743';\n");
+		grammarBuilder.append("KW3744 : 'KW' '3744';\n");
+		grammarBuilder.append("KW3745 : 'KW' '3745';\n");
+		grammarBuilder.append("KW3746 : 'KW' '3746';\n");
+		grammarBuilder.append("KW3747 : 'KW' '3747';\n");
+		grammarBuilder.append("KW3748 : 'KW' '3748';\n");
+		grammarBuilder.append("KW3749 : 'KW' '3749';\n");
+		grammarBuilder.append("KW3750 : 'KW' '3750';\n");
+		grammarBuilder.append("KW3751 : 'KW' '3751';\n");
+		grammarBuilder.append("KW3752 : 'KW' '3752';\n");
+		grammarBuilder.append("KW3753 : 'KW' '3753';\n");
+		grammarBuilder.append("KW3754 : 'KW' '3754';\n");
+		grammarBuilder.append("KW3755 : 'KW' '3755';\n");
+		grammarBuilder.append("KW3756 : 'KW' '3756';\n");
+		grammarBuilder.append("KW3757 : 'KW' '3757';\n");
+		grammarBuilder.append("KW3758 : 'KW' '3758';\n");
+		grammarBuilder.append("KW3759 : 'KW' '3759';\n");
+		grammarBuilder.append("KW3760 : 'KW' '3760';\n");
+		grammarBuilder.append("KW3761 : 'KW' '3761';\n");
+		grammarBuilder.append("KW3762 : 'KW' '3762';\n");
+		grammarBuilder.append("KW3763 : 'KW' '3763';\n");
+		grammarBuilder.append("KW3764 : 'KW' '3764';\n");
+		grammarBuilder.append("KW3765 : 'KW' '3765';\n");
+		grammarBuilder.append("KW3766 : 'KW' '3766';\n");
+		grammarBuilder.append("KW3767 : 'KW' '3767';\n");
+		grammarBuilder.append("KW3768 : 'KW' '3768';\n");
+		grammarBuilder.append("KW3769 : 'KW' '3769';\n");
+		grammarBuilder.append("KW3770 : 'KW' '3770';\n");
+		grammarBuilder.append("KW3771 : 'KW' '3771';\n");
+		grammarBuilder.append("KW3772 : 'KW' '3772';\n");
+		grammarBuilder.append("KW3773 : 'KW' '3773';\n");
+		grammarBuilder.append("KW3774 : 'KW' '3774';\n");
+		grammarBuilder.append("KW3775 : 'KW' '3775';\n");
+		grammarBuilder.append("KW3776 : 'KW' '3776';\n");
+		grammarBuilder.append("KW3777 : 'KW' '3777';\n");
+		grammarBuilder.append("KW3778 : 'KW' '3778';\n");
+		grammarBuilder.append("KW3779 : 'KW' '3779';\n");
+		grammarBuilder.append("KW3780 : 'KW' '3780';\n");
+		grammarBuilder.append("KW3781 : 'KW' '3781';\n");
+		grammarBuilder.append("KW3782 : 'KW' '3782';\n");
+		grammarBuilder.append("KW3783 : 'KW' '3783';\n");
+		grammarBuilder.append("KW3784 : 'KW' '3784';\n");
+		grammarBuilder.append("KW3785 : 'KW' '3785';\n");
+		grammarBuilder.append("KW3786 : 'KW' '3786';\n");
+		grammarBuilder.append("KW3787 : 'KW' '3787';\n");
+		grammarBuilder.append("KW3788 : 'KW' '3788';\n");
+		grammarBuilder.append("KW3789 : 'KW' '3789';\n");
+		grammarBuilder.append("KW3790 : 'KW' '3790';\n");
+		grammarBuilder.append("KW3791 : 'KW' '3791';\n");
+		grammarBuilder.append("KW3792 : 'KW' '3792';\n");
+		grammarBuilder.append("KW3793 : 'KW' '3793';\n");
+		grammarBuilder.append("KW3794 : 'KW' '3794';\n");
+		grammarBuilder.append("KW3795 : 'KW' '3795';\n");
+		grammarBuilder.append("KW3796 : 'KW' '3796';\n");
+		grammarBuilder.append("KW3797 : 'KW' '3797';\n");
+		grammarBuilder.append("KW3798 : 'KW' '3798';\n");
+		grammarBuilder.append("KW3799 : 'KW' '3799';\n");
+		grammarBuilder.append("KW3800 : 'KW' '3800';\n");
+		grammarBuilder.append("KW3801 : 'KW' '3801';\n");
+		grammarBuilder.append("KW3802 : 'KW' '3802';\n");
+		grammarBuilder.append("KW3803 : 'KW' '3803';\n");
+		grammarBuilder.append("KW3804 : 'KW' '3804';\n");
+		grammarBuilder.append("KW3805 : 'KW' '3805';\n");
+		grammarBuilder.append("KW3806 : 'KW' '3806';\n");
+		grammarBuilder.append("KW3807 : 'KW' '3807';\n");
+		grammarBuilder.append("KW3808 : 'KW' '3808';\n");
+		grammarBuilder.append("KW3809 : 'KW' '3809';\n");
+		grammarBuilder.append("KW3810 : 'KW' '3810';\n");
+		grammarBuilder.append("KW3811 : 'KW' '3811';\n");
+		grammarBuilder.append("KW3812 : 'KW' '3812';\n");
+		grammarBuilder.append("KW3813 : 'KW' '3813';\n");
+		grammarBuilder.append("KW3814 : 'KW' '3814';\n");
+		grammarBuilder.append("KW3815 : 'KW' '3815';\n");
+		grammarBuilder.append("KW3816 : 'KW' '3816';\n");
+		grammarBuilder.append("KW3817 : 'KW' '3817';\n");
+		grammarBuilder.append("KW3818 : 'KW' '3818';\n");
+		grammarBuilder.append("KW3819 : 'KW' '3819';\n");
+		grammarBuilder.append("KW3820 : 'KW' '3820';\n");
+		grammarBuilder.append("KW3821 : 'KW' '3821';\n");
+		grammarBuilder.append("KW3822 : 'KW' '3822';\n");
+		grammarBuilder.append("KW3823 : 'KW' '3823';\n");
+		grammarBuilder.append("KW3824 : 'KW' '3824';\n");
+		grammarBuilder.append("KW3825 : 'KW' '3825';\n");
+		grammarBuilder.append("KW3826 : 'KW' '3826';\n");
+		grammarBuilder.append("KW3827 : 'KW' '3827';\n");
+		grammarBuilder.append("KW3828 : 'KW' '3828';\n");
+		grammarBuilder.append("KW3829 : 'KW' '3829';\n");
+		grammarBuilder.append("KW3830 : 'KW' '3830';\n");
+		grammarBuilder.append("KW3831 : 'KW' '3831';\n");
+		grammarBuilder.append("KW3832 : 'KW' '3832';\n");
+		grammarBuilder.append("KW3833 : 'KW' '3833';\n");
+		grammarBuilder.append("KW3834 : 'KW' '3834';\n");
+		grammarBuilder.append("KW3835 : 'KW' '3835';\n");
+		grammarBuilder.append("KW3836 : 'KW' '3836';\n");
+		grammarBuilder.append("KW3837 : 'KW' '3837';\n");
+		grammarBuilder.append("KW3838 : 'KW' '3838';\n");
+		grammarBuilder.append("KW3839 : 'KW' '3839';\n");
+		grammarBuilder.append("KW3840 : 'KW' '3840';\n");
+		grammarBuilder.append("KW3841 : 'KW' '3841';\n");
+		grammarBuilder.append("KW3842 : 'KW' '3842';\n");
+		grammarBuilder.append("KW3843 : 'KW' '3843';\n");
+		grammarBuilder.append("KW3844 : 'KW' '3844';\n");
+		grammarBuilder.append("KW3845 : 'KW' '3845';\n");
+		grammarBuilder.append("KW3846 : 'KW' '3846';\n");
+		grammarBuilder.append("KW3847 : 'KW' '3847';\n");
+		grammarBuilder.append("KW3848 : 'KW' '3848';\n");
+		grammarBuilder.append("KW3849 : 'KW' '3849';\n");
+		grammarBuilder.append("KW3850 : 'KW' '3850';\n");
+		grammarBuilder.append("KW3851 : 'KW' '3851';\n");
+		grammarBuilder.append("KW3852 : 'KW' '3852';\n");
+		grammarBuilder.append("KW3853 : 'KW' '3853';\n");
+		grammarBuilder.append("KW3854 : 'KW' '3854';\n");
+		grammarBuilder.append("KW3855 : 'KW' '3855';\n");
+		grammarBuilder.append("KW3856 : 'KW' '3856';\n");
+		grammarBuilder.append("KW3857 : 'KW' '3857';\n");
+		grammarBuilder.append("KW3858 : 'KW' '3858';\n");
+		grammarBuilder.append("KW3859 : 'KW' '3859';\n");
+		grammarBuilder.append("KW3860 : 'KW' '3860';\n");
+		grammarBuilder.append("KW3861 : 'KW' '3861';\n");
+		grammarBuilder.append("KW3862 : 'KW' '3862';\n");
+		grammarBuilder.append("KW3863 : 'KW' '3863';\n");
+		grammarBuilder.append("KW3864 : 'KW' '3864';\n");
+		grammarBuilder.append("KW3865 : 'KW' '3865';\n");
+		grammarBuilder.append("KW3866 : 'KW' '3866';\n");
+		grammarBuilder.append("KW3867 : 'KW' '3867';\n");
+		grammarBuilder.append("KW3868 : 'KW' '3868';\n");
+		grammarBuilder.append("KW3869 : 'KW' '3869';\n");
+		grammarBuilder.append("KW3870 : 'KW' '3870';\n");
+		grammarBuilder.append("KW3871 : 'KW' '3871';\n");
+		grammarBuilder.append("KW3872 : 'KW' '3872';\n");
+		grammarBuilder.append("KW3873 : 'KW' '3873';\n");
+		grammarBuilder.append("KW3874 : 'KW' '3874';\n");
+		grammarBuilder.append("KW3875 : 'KW' '3875';\n");
+		grammarBuilder.append("KW3876 : 'KW' '3876';\n");
+		grammarBuilder.append("KW3877 : 'KW' '3877';\n");
+		grammarBuilder.append("KW3878 : 'KW' '3878';\n");
+		grammarBuilder.append("KW3879 : 'KW' '3879';\n");
+		grammarBuilder.append("KW3880 : 'KW' '3880';\n");
+		grammarBuilder.append("KW3881 : 'KW' '3881';\n");
+		grammarBuilder.append("KW3882 : 'KW' '3882';\n");
+		grammarBuilder.append("KW3883 : 'KW' '3883';\n");
+		grammarBuilder.append("KW3884 : 'KW' '3884';\n");
+		grammarBuilder.append("KW3885 : 'KW' '3885';\n");
+		grammarBuilder.append("KW3886 : 'KW' '3886';\n");
+		grammarBuilder.append("KW3887 : 'KW' '3887';\n");
+		grammarBuilder.append("KW3888 : 'KW' '3888';\n");
+		grammarBuilder.append("KW3889 : 'KW' '3889';\n");
+		grammarBuilder.append("KW3890 : 'KW' '3890';\n");
+		grammarBuilder.append("KW3891 : 'KW' '3891';\n");
+		grammarBuilder.append("KW3892 : 'KW' '3892';\n");
+		grammarBuilder.append("KW3893 : 'KW' '3893';\n");
+		grammarBuilder.append("KW3894 : 'KW' '3894';\n");
+		grammarBuilder.append("KW3895 : 'KW' '3895';\n");
+		grammarBuilder.append("KW3896 : 'KW' '3896';\n");
+		grammarBuilder.append("KW3897 : 'KW' '3897';\n");
+		grammarBuilder.append("KW3898 : 'KW' '3898';\n");
+		grammarBuilder.append("KW3899 : 'KW' '3899';\n");
+		grammarBuilder.append("KW3900 : 'KW' '3900';\n");
+		grammarBuilder.append("KW3901 : 'KW' '3901';\n");
+		grammarBuilder.append("KW3902 : 'KW' '3902';\n");
+		grammarBuilder.append("KW3903 : 'KW' '3903';\n");
+		grammarBuilder.append("KW3904 : 'KW' '3904';\n");
+		grammarBuilder.append("KW3905 : 'KW' '3905';\n");
+		grammarBuilder.append("KW3906 : 'KW' '3906';\n");
+		grammarBuilder.append("KW3907 : 'KW' '3907';\n");
+		grammarBuilder.append("KW3908 : 'KW' '3908';\n");
+		grammarBuilder.append("KW3909 : 'KW' '3909';\n");
+		grammarBuilder.append("KW3910 : 'KW' '3910';\n");
+		grammarBuilder.append("KW3911 : 'KW' '3911';\n");
+		grammarBuilder.append("KW3912 : 'KW' '3912';\n");
+		grammarBuilder.append("KW3913 : 'KW' '3913';\n");
+		grammarBuilder.append("KW3914 : 'KW' '3914';\n");
+		grammarBuilder.append("KW3915 : 'KW' '3915';\n");
+		grammarBuilder.append("KW3916 : 'KW' '3916';\n");
+		grammarBuilder.append("KW3917 : 'KW' '3917';\n");
+		grammarBuilder.append("KW3918 : 'KW' '3918';\n");
+		grammarBuilder.append("KW3919 : 'KW' '3919';\n");
+		grammarBuilder.append("KW3920 : 'KW' '3920';\n");
+		grammarBuilder.append("KW3921 : 'KW' '3921';\n");
+		grammarBuilder.append("KW3922 : 'KW' '3922';\n");
+		grammarBuilder.append("KW3923 : 'KW' '3923';\n");
+		grammarBuilder.append("KW3924 : 'KW' '3924';\n");
+		grammarBuilder.append("KW3925 : 'KW' '3925';\n");
+		grammarBuilder.append("KW3926 : 'KW' '3926';\n");
+		grammarBuilder.append("KW3927 : 'KW' '3927';\n");
+		grammarBuilder.append("KW3928 : 'KW' '3928';\n");
+		grammarBuilder.append("KW3929 : 'KW' '3929';\n");
+		grammarBuilder.append("KW3930 : 'KW' '3930';\n");
+		grammarBuilder.append("KW3931 : 'KW' '3931';\n");
+		grammarBuilder.append("KW3932 : 'KW' '3932';\n");
+		grammarBuilder.append("KW3933 : 'KW' '3933';\n");
+		grammarBuilder.append("KW3934 : 'KW' '3934';\n");
+		grammarBuilder.append("KW3935 : 'KW' '3935';\n");
+		grammarBuilder.append("KW3936 : 'KW' '3936';\n");
+		grammarBuilder.append("KW3937 : 'KW' '3937';\n");
+		grammarBuilder.append("KW3938 : 'KW' '3938';\n");
+		grammarBuilder.append("KW3939 : 'KW' '3939';\n");
+		grammarBuilder.append("KW3940 : 'KW' '3940';\n");
+		grammarBuilder.append("KW3941 : 'KW' '3941';\n");
+		grammarBuilder.append("KW3942 : 'KW' '3942';\n");
+		grammarBuilder.append("KW3943 : 'KW' '3943';\n");
+		grammarBuilder.append("KW3944 : 'KW' '3944';\n");
+		grammarBuilder.append("KW3945 : 'KW' '3945';\n");
+		grammarBuilder.append("KW3946 : 'KW' '3946';\n");
+		grammarBuilder.append("KW3947 : 'KW' '3947';\n");
+		grammarBuilder.append("KW3948 : 'KW' '3948';\n");
+		grammarBuilder.append("KW3949 : 'KW' '3949';\n");
+		grammarBuilder.append("KW3950 : 'KW' '3950';\n");
+		grammarBuilder.append("KW3951 : 'KW' '3951';\n");
+		grammarBuilder.append("KW3952 : 'KW' '3952';\n");
+		grammarBuilder.append("KW3953 : 'KW' '3953';\n");
+		grammarBuilder.append("KW3954 : 'KW' '3954';\n");
+		grammarBuilder.append("KW3955 : 'KW' '3955';\n");
+		grammarBuilder.append("KW3956 : 'KW' '3956';\n");
+		grammarBuilder.append("KW3957 : 'KW' '3957';\n");
+		grammarBuilder.append("KW3958 : 'KW' '3958';\n");
+		grammarBuilder.append("KW3959 : 'KW' '3959';\n");
+		grammarBuilder.append("KW3960 : 'KW' '3960';\n");
+		grammarBuilder.append("KW3961 : 'KW' '3961';\n");
+		grammarBuilder.append("KW3962 : 'KW' '3962';\n");
+		grammarBuilder.append("KW3963 : 'KW' '3963';\n");
+		grammarBuilder.append("KW3964 : 'KW' '3964';\n");
+		grammarBuilder.append("KW3965 : 'KW' '3965';\n");
+		grammarBuilder.append("KW3966 : 'KW' '3966';\n");
+		grammarBuilder.append("KW3967 : 'KW' '3967';\n");
+		grammarBuilder.append("KW3968 : 'KW' '3968';\n");
+		grammarBuilder.append("KW3969 : 'KW' '3969';\n");
+		grammarBuilder.append("KW3970 : 'KW' '3970';\n");
+		grammarBuilder.append("KW3971 : 'KW' '3971';\n");
+		grammarBuilder.append("KW3972 : 'KW' '3972';\n");
+		grammarBuilder.append("KW3973 : 'KW' '3973';\n");
+		grammarBuilder.append("KW3974 : 'KW' '3974';\n");
+		grammarBuilder.append("KW3975 : 'KW' '3975';\n");
+		grammarBuilder.append("KW3976 : 'KW' '3976';\n");
+		grammarBuilder.append("KW3977 : 'KW' '3977';\n");
+		grammarBuilder.append("KW3978 : 'KW' '3978';\n");
+		grammarBuilder.append("KW3979 : 'KW' '3979';\n");
+		grammarBuilder.append("KW3980 : 'KW' '3980';\n");
+		grammarBuilder.append("KW3981 : 'KW' '3981';\n");
+		grammarBuilder.append("KW3982 : 'KW' '3982';\n");
+		grammarBuilder.append("KW3983 : 'KW' '3983';\n");
+		grammarBuilder.append("KW3984 : 'KW' '3984';\n");
+		grammarBuilder.append("KW3985 : 'KW' '3985';\n");
+		grammarBuilder.append("KW3986 : 'KW' '3986';\n");
+		grammarBuilder.append("KW3987 : 'KW' '3987';\n");
+		grammarBuilder.append("KW3988 : 'KW' '3988';\n");
+		grammarBuilder.append("KW3989 : 'KW' '3989';\n");
+		grammarBuilder.append("KW3990 : 'KW' '3990';\n");
+		grammarBuilder.append("KW3991 : 'KW' '3991';\n");
+		grammarBuilder.append("KW3992 : 'KW' '3992';\n");
+		grammarBuilder.append("KW3993 : 'KW' '3993';\n");
+		grammarBuilder.append("KW3994 : 'KW' '3994';\n");
+		grammarBuilder.append("KW3995 : 'KW' '3995';\n");
+		grammarBuilder.append("KW3996 : 'KW' '3996';\n");
+		grammarBuilder.append("KW3997 : 'KW' '3997';\n");
+		grammarBuilder.append("KW3998 : 'KW' '3998';\n");
+		grammarBuilder.append("KW3999 : 'KW' '3999';");
+		String grammar = grammarBuilder.toString();
+		String input ="KW400";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:4='KW400',<402>,1:0]\n" +
+			"[@1,5:4='<EOF>',<-1>,1:5]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNonGreedyClosure() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(61);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("CMT : '//' .*? '\\n' CMT*?;\n");
+		grammarBuilder.append("WS : (' '|'\\t')+;");
+		String grammar = grammarBuilder.toString();
+		String input =
+			"//blah\n" +
+			"//blah\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:6='//blah\\n',<1>,1:0]\n" +
+			"[@1,7:13='//blah\\n',<1>,2:0]\n" +
+			"[@2,14:13='<EOF>',<-1>,3:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNonGreedyConfigs() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(124);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("I : .*? ('a' | 'ab') {console.log(this.text);} ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;\n");
+		grammarBuilder.append("J : . {console.log(this.text);};");
+		String grammar = grammarBuilder.toString();
+		String input ="ab";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"a\n" +
+			"b\n" +
+			"[@0,0:0='a',<1>,1:0]\n" +
+			"[@1,1:1='b',<3>,1:1]\n" +
+			"[@2,2:1='<EOF>',<-1>,1:2]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNonGreedyOptional() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(61);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("CMT : '//' .*? '\\n' CMT??;\n");
+		grammarBuilder.append("WS : (' '|'\\t')+;");
+		String grammar = grammarBuilder.toString();
+		String input =
+			"//blah\n" +
+			"//blah\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:6='//blah\\n',<1>,1:0]\n" +
+			"[@1,7:13='//blah\\n',<1>,2:0]\n" +
+			"[@2,14:13='<EOF>',<-1>,3:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNonGreedyPositiveClosure() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(59);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("CMT : ('//' .*? '\\n')+?;\n");
+		grammarBuilder.append("WS : (' '|'\\t')+;");
+		String grammar = grammarBuilder.toString();
+		String input =
+			"//blah\n" +
+			"//blah\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:6='//blah\\n',<1>,1:0]\n" +
+			"[@1,7:13='//blah\\n',<1>,2:0]\n" +
+			"[@2,14:13='<EOF>',<-1>,3:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNonGreedyTermination1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(47);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("STRING : '\"' ('\"\"' | .)*? '\"';");
+		String grammar = grammarBuilder.toString();
+		String input ="\"hi\"\"mom\"";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:3='\"hi\"',<1>,1:0]\n" +
+			"[@1,4:8='\"mom\"',<1>,1:4]\n" +
+			"[@2,9:8='<EOF>',<-1>,1:9]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNonGreedyTermination2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(47);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("STRING : '\"' ('\"\"' | .)+? '\"';");
+		String grammar = grammarBuilder.toString();
+		String input ="\"\"\"mom\"";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:6='\"\"\"mom\"',<1>,1:0]\n" +
+			"[@1,7:6='<EOF>',<-1>,1:7]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testParentheses() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(166);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("START_BLOCK: '-.-.-';\n");
+		grammarBuilder.append("ID : (LETTER SEPARATOR) (LETTER SEPARATOR)+;\n");
+		grammarBuilder.append("fragment LETTER: L_A|L_K;\n");
+		grammarBuilder.append("fragment L_A: '.-';\n");
+		grammarBuilder.append("fragment L_K: '-.-';\n");
+		grammarBuilder.append("SEPARATOR: '!';");
+		String grammar = grammarBuilder.toString();
+		String input ="-.-.-!";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:4='-.-.-',<1>,1:0]\n" +
+			"[@1,5:5='!',<3>,1:5]\n" +
+			"[@2,6:5='<EOF>',<-1>,1:6]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPositionAdjustingLexer() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(2231);
+		grammarBuilder.append("lexer grammar PositionAdjustingLexer;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("@members {\n");
+		grammarBuilder.append("PositionAdjustingLexer.prototype.resetAcceptPosition = function(index, line, column) {\n");
+		grammarBuilder.append("	this._input.seek(index);\n");
+		grammarBuilder.append("	this.line = line;\n");
+		grammarBuilder.append("	this.column = column;\n");
+		grammarBuilder.append("	this._interp.consume(this._input);\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("PositionAdjustingLexer.prototype.nextToken = function() {\n");
+		grammarBuilder.append("	if (!(\"resetAcceptPosition\" in this._interp)) {\n");
+		grammarBuilder.append("		var lexer = this;\n");
+		grammarBuilder.append("		this._interp.resetAcceptPosition = function(index, line, column) { lexer.resetAcceptPosition(index, line, column); };\n");
+		grammarBuilder.append("	}\n");
+		grammarBuilder.append("	return antlr4.Lexer.prototype.nextToken.call(this);\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("PositionAdjustingLexer.prototype.emit = function() {\n");
+		grammarBuilder.append("	switch(this._type) {\n");
+		grammarBuilder.append("	case PositionAdjustingLexer.TOKENS:\n");
+		grammarBuilder.append("		this.handleAcceptPositionForKeyword(\"tokens\");\n");
+		grammarBuilder.append("		break;\n");
+		grammarBuilder.append("	case PositionAdjustingLexer.LABEL:\n");
+		grammarBuilder.append("		this.handleAcceptPositionForIdentifier();\n");
+		grammarBuilder.append("		break;\n");
+		grammarBuilder.append("	}\n");
+		grammarBuilder.append("	return antlr4.Lexer.prototype.emit.call(this);\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("PositionAdjustingLexer.prototype.handleAcceptPositionForIdentifier = function() {\n");
+		grammarBuilder.append("	var tokenText = this.text;\n");
+		grammarBuilder.append("	var identifierLength = 0;\n");
+		grammarBuilder.append("	while (identifierLength < tokenText.length &&\n");
+		grammarBuilder.append("		PositionAdjustingLexer.isIdentifierChar(tokenText[identifierLength])\n");
+		grammarBuilder.append("	) {\n");
+		grammarBuilder.append("		identifierLength += 1;\n");
+		grammarBuilder.append("	}\n");
+		grammarBuilder.append("	if (this._input.index > this._tokenStartCharIndex + identifierLength) {\n");
+		grammarBuilder.append("		var offset = identifierLength - 1;\n");
+		grammarBuilder.append("		this._interp.resetAcceptPosition(this._tokenStartCharIndex + offset,\n");
+		grammarBuilder.append("				this._tokenStartLine, this._tokenStartColumn + offset);\n");
+		grammarBuilder.append("		return true;\n");
+		grammarBuilder.append("	} else {\n");
+		grammarBuilder.append("		return false;\n");
+		grammarBuilder.append("	}\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("PositionAdjustingLexer.prototype.handleAcceptPositionForKeyword = function(keyword) {\n");
+		grammarBuilder.append("	if (this._input.index > this._tokenStartCharIndex + keyword.length) {\n");
+		grammarBuilder.append("		var offset = keyword.length - 1;\n");
+		grammarBuilder.append("		this._interp.resetAcceptPosition(this._tokenStartCharIndex + offset,\n");
+		grammarBuilder.append("			this._tokenStartLine, this._tokenStartColumn + offset);\n");
+		grammarBuilder.append("		return true;\n");
+		grammarBuilder.append("	} else {\n");
+		grammarBuilder.append("		return false;\n");
+		grammarBuilder.append("	}\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("PositionAdjustingLexer.isIdentifierChar = function(c) {\n");
+		grammarBuilder.append("	return c.match(/^[0-9a-zA-Z_]+$/);\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("ASSIGN : '=' ;\n");
+		grammarBuilder.append("PLUS_ASSIGN : '+=' ;\n");
+		grammarBuilder.append("LCURLY:	'{';\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("// 'tokens' followed by '{'\n");
+		grammarBuilder.append("TOKENS : 'tokens' IGNORED '{';\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("// IDENTIFIER followed by '+=' or '='\n");
+		grammarBuilder.append("LABEL\n");
+		grammarBuilder.append("	:	IDENTIFIER IGNORED '+'? '='\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("IDENTIFIER\n");
+		grammarBuilder.append("	:	[a-zA-Z_] [a-zA-Z0-9_]*\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("fragment\n");
+		grammarBuilder.append("IGNORED\n");
+		grammarBuilder.append("	:	[ \\t\\r\\n]*\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("NEWLINE\n");
+		grammarBuilder.append("	:	[\\r\\n]+ -> skip\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("WS\n");
+		grammarBuilder.append("	:	[ \\t]+ -> skip\n");
+		grammarBuilder.append("	;");
+		String grammar = grammarBuilder.toString();
+		String input =
+			"tokens\n" +
+			"tokens {\n" +
+			"notLabel\n" +
+			"label1 =\n" +
+			"label2 +=\n" +
+			"notLabel\n";
+		String found = execLexer("PositionAdjustingLexer.g4", grammar, "PositionAdjustingLexer", input, false);
+		assertEquals(
+			"[@0,0:5='tokens',<6>,1:0]\n" +
+			"[@1,7:12='tokens',<4>,2:0]\n" +
+			"[@2,14:14='{',<3>,2:7]\n" +
+			"[@3,16:23='notLabel',<6>,3:0]\n" +
+			"[@4,25:30='label1',<5>,4:0]\n" +
+			"[@5,32:32='=',<1>,4:7]\n" +
+			"[@6,34:39='label2',<5>,5:0]\n" +
+			"[@7,41:42='+=',<2>,5:7]\n" +
+			"[@8,44:51='notLabel',<6>,6:0]\n" +
+			"[@9,53:52='<EOF>',<-1>,7:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testQuoteTranslation() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(57);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("QUOTE : '\"' ; // make sure this compiles");
+		String grammar = grammarBuilder.toString();
+		String input ="\"";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:0='\"',<1>,1:0]\n" +
+			"[@1,1:0='<EOF>',<-1>,1:1]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testRecursiveLexerRuleRefWithWildcardPlus_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(64);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("CMT : '/*' (CMT | .)+? '*/' ;\n");
+		grammarBuilder.append("WS : (' '|'\\n')+;");
+		String grammar = grammarBuilder.toString();
+		String input =
+			"/* ick */\n" +
+			"/* /* */\n" +
+			"/* /*nested*/ */\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:8='/* ick */',<1>,1:0]\n" +
+			"[@1,9:9='\\n',<2>,1:9]\n" +
+			"[@2,10:34='/* /* */\\n/* /*nested*/ */',<1>,2:0]\n" +
+			"[@3,35:35='\\n',<2>,3:16]\n" +
+			"[@4,36:35='<EOF>',<-1>,4:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testRecursiveLexerRuleRefWithWildcardPlus_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(64);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("CMT : '/*' (CMT | .)+? '*/' ;\n");
+		grammarBuilder.append("WS : (' '|'\\n')+;");
+		String grammar = grammarBuilder.toString();
+		String input =
+			"/* ick */x\n" +
+			"/* /* */x\n" +
+			"/* /*nested*/ */x\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:8='/* ick */',<1>,1:0]\n" +
+			"[@1,10:10='\\n',<2>,1:10]\n" +
+			"[@2,11:36='/* /* */x\\n/* /*nested*/ */',<1>,2:0]\n" +
+			"[@3,38:38='\\n',<2>,3:17]\n" +
+			"[@4,39:38='<EOF>',<-1>,4:0]\n", found);
+
+		assertEquals(
+			"line 1:9 token recognition error at: 'x'\n" +
+			"line 3:16 token recognition error at: 'x'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testRecursiveLexerRuleRefWithWildcardStar_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(64);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("CMT : '/*' (CMT | .)*? '*/' ;\n");
+		grammarBuilder.append("WS : (' '|'\\n')+;");
+		String grammar = grammarBuilder.toString();
+		String input =
+			"/* ick */\n" +
+			"/* /* */\n" +
+			"/* /*nested*/ */\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:8='/* ick */',<1>,1:0]\n" +
+			"[@1,9:9='\\n',<2>,1:9]\n" +
+			"[@2,10:34='/* /* */\\n/* /*nested*/ */',<1>,2:0]\n" +
+			"[@3,35:35='\\n',<2>,3:16]\n" +
+			"[@4,36:35='<EOF>',<-1>,4:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testRecursiveLexerRuleRefWithWildcardStar_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(64);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("CMT : '/*' (CMT | .)*? '*/' ;\n");
+		grammarBuilder.append("WS : (' '|'\\n')+;");
+		String grammar = grammarBuilder.toString();
+		String input =
+			"/* ick */x\n" +
+			"/* /* */x\n" +
+			"/* /*nested*/ */x\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:8='/* ick */',<1>,1:0]\n" +
+			"[@1,10:10='\\n',<2>,1:10]\n" +
+			"[@2,11:36='/* /* */x\\n/* /*nested*/ */',<1>,2:0]\n" +
+			"[@3,38:38='\\n',<2>,3:17]\n" +
+			"[@4,39:38='<EOF>',<-1>,4:0]\n", found);
+
+		assertEquals(
+			"line 1:9 token recognition error at: 'x'\n" +
+			"line 3:16 token recognition error at: 'x'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testRefToRuleDoesNotSetTokenNorEmitAnother() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(70);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : '-' I ;\n");
+		grammarBuilder.append("I : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="34 -21 3";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:1='34',<2>,1:0]\n" +
+			"[@1,3:5='-21',<1>,1:3]\n" +
+			"[@2,7:7='3',<2>,1:7]\n" +
+			"[@3,8:7='<EOF>',<-1>,1:8]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSlashes() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(95);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("Backslash : '\\\\';\n");
+		grammarBuilder.append("Slash : '/';\n");
+		grammarBuilder.append("Vee : '\\\\/';\n");
+		grammarBuilder.append("Wedge : '/\\\\';\n");
+		grammarBuilder.append("WS : [ \\t] -> skip;");
+		String grammar = grammarBuilder.toString();
+		String input ="\\ / \\/ /\\";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:0='\\',<1>,1:0]\n" +
+			"[@1,2:2='/',<2>,1:2]\n" +
+			"[@2,4:5='\\/',<3>,1:4]\n" +
+			"[@3,7:8='/\\',<4>,1:7]\n" +
+			"[@4,9:8='<EOF>',<-1>,1:9]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testZeroLengthToken() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(215);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("BeginString\n");
+		grammarBuilder.append("	:	'\\'' -> more, pushMode(StringMode)\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("mode StringMode;\n");
+		grammarBuilder.append("	StringMode_X : 'x' -> more;\n");
+		grammarBuilder.append("	StringMode_Done : -> more, mode(EndStringMode);\n");
+		grammarBuilder.append("mode EndStringMode;	\n");
+		grammarBuilder.append("	EndString : '\\'' -> popMode;");
+		String grammar = grammarBuilder.toString();
+		String input ="'xxx'";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:4=''xxx'',<1>,1:0]\n" +
+			"[@1,5:4='<EOF>',<-1>,1:5]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+}
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/node/TestListeners.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/node/TestListeners.java
new file mode 100644
index 000000000..79006182d
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/node/TestListeners.java
@@ -0,0 +1,396 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.javascript.node;
+
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+@SuppressWarnings("unused")
+public class TestListeners extends BaseTest {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testBasic() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(633);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@parser::header {\n");
+		grammarBuilder.append("var TListener = require('./TListener').TListener;\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("@parser::members {\n");
+		grammarBuilder.append("this.LeafListener = function() {\n");
+		grammarBuilder.append("    this.visitTerminal = function(node) {\n");
+		grammarBuilder.append("    	console.log(node.symbol.text);\n");
+		grammarBuilder.append("    };\n");
+		grammarBuilder.append("    return this;\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("this.LeafListener.prototype = Object.create(TListener.prototype);\n");
+		grammarBuilder.append("this.LeafListener.prototype.constructor = this.LeafListener;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("console.log($ctx.r.toStringTree(null, this));\n");
+		grammarBuilder.append("var walker = new antlr4.tree.ParseTreeWalker();\n");
+		grammarBuilder.append("walker.walk(new this.LeafListener(), $ctx.r);\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : INT INT\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("MULT: '*' ;\n");
+		grammarBuilder.append("ADD : '+' ;\n");
+		grammarBuilder.append("INT : [0-9]+ ;\n");
+		grammarBuilder.append("ID  : [a-z]+ ;\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="1 2";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals(
+			"(a 1 2)\n" +
+			"1\n" +
+			"2\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLR() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(843);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@parser::header {\n");
+		grammarBuilder.append("var TListener = require('./TListener').TListener;\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("@parser::members {\n");
+		grammarBuilder.append("this.LeafListener = function() {\n");
+		grammarBuilder.append("    this.exitE = function(ctx) {\n");
+		grammarBuilder.append("    	var str;\n");
+		grammarBuilder.append("        if(ctx.getChildCount()===3) {\n");
+		grammarBuilder.append("            str = ctx.e(0).start.text + ' ' + ctx.e(1).start.text + ' ' + ctx.e()[0].start.text;\n");
+		grammarBuilder.append("        } else {\n");
+		grammarBuilder.append("            str = ctx.INT().symbol.text;\n");
+		grammarBuilder.append("        }\n");
+		grammarBuilder.append("    	console.log(str);\n");
+		grammarBuilder.append("    };\n");
+		grammarBuilder.append("    return this;\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("this.LeafListener.prototype = Object.create(TListener.prototype);\n");
+		grammarBuilder.append("this.LeafListener.prototype.constructor = this.LeafListener;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("console.log($ctx.r.toStringTree(null, this));\n");
+		grammarBuilder.append("var walker = new antlr4.tree.ParseTreeWalker();\n");
+		grammarBuilder.append("walker.walk(new this.LeafListener(), $ctx.r);\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("	: r=e ;\n");
+		grammarBuilder.append("e : e op='*' e\n");
+		grammarBuilder.append("	| e op='+' e\n");
+		grammarBuilder.append("	| INT\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("MULT: '*' ;\n");
+		grammarBuilder.append("ADD : '+' ;\n");
+		grammarBuilder.append("INT : [0-9]+ ;\n");
+		grammarBuilder.append("ID  : [a-z]+ ;\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="1+2*3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals(
+			"(e (e 1) + (e (e 2) * (e 3)))\n" +
+			"1\n" +
+			"2\n" +
+			"3\n" +
+			"2 3 2\n" +
+			"1 2 1\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLRWithLabels() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(833);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@parser::header {\n");
+		grammarBuilder.append("var TListener = require('./TListener').TListener;\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("@parser::members {\n");
+		grammarBuilder.append("this.LeafListener = function() {\n");
+		grammarBuilder.append("    this.exitCall = function(ctx) {\n");
+		grammarBuilder.append("    	var str = ctx.e().start.text + ' ' + ctx.eList();\n");
+		grammarBuilder.append("    	console.log(str);\n");
+		grammarBuilder.append("    };\n");
+		grammarBuilder.append("    this.exitInt = function(ctx) {\n");
+		grammarBuilder.append("        var str = ctx.INT().symbol.text;\n");
+		grammarBuilder.append("        console.log(str);\n");
+		grammarBuilder.append("    };\n");
+		grammarBuilder.append("    return this;\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("this.LeafListener.prototype = Object.create(TListener.prototype);\n");
+		grammarBuilder.append("this.LeafListener.prototype.constructor = this.LeafListener;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("console.log($ctx.r.toStringTree(null, this));\n");
+		grammarBuilder.append("var walker = new antlr4.tree.ParseTreeWalker();\n");
+		grammarBuilder.append("walker.walk(new this.LeafListener(), $ctx.r);\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=e ;\n");
+		grammarBuilder.append("e : e '(' eList ')' # Call\n");
+		grammarBuilder.append("  | INT             # Int\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("eList : e (',' e)* ;\n");
+		grammarBuilder.append("MULT: '*' ;\n");
+		grammarBuilder.append("ADD : '+' ;\n");
+		grammarBuilder.append("INT : [0-9]+ ;\n");
+		grammarBuilder.append("ID  : [a-z]+ ;\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="1(2,3)";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals(
+			"(e (e 1) ( (eList (e 2) , (e 3)) ))\n" +
+			"1\n" +
+			"2\n" +
+			"3\n" +
+			"1 [13 6]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testRuleGetters_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(868);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@parser::header {\n");
+		grammarBuilder.append("var TListener = require('./TListener').TListener;\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("@parser::members {\n");
+		grammarBuilder.append("this.LeafListener = function() {\n");
+		grammarBuilder.append("    this.exitA = function(ctx) {\n");
+		grammarBuilder.append("    	var str;\n");
+		grammarBuilder.append("        if(ctx.getChildCount()===2) {\n");
+		grammarBuilder.append("            str = ctx.b(0).start.text + ' ' + ctx.b(1).start.text + ' ' + ctx.b()[0].start.text;\n");
+		grammarBuilder.append("        } else {\n");
+		grammarBuilder.append("            str = ctx.b(0).start.text;\n");
+		grammarBuilder.append("        }\n");
+		grammarBuilder.append("    	console.log(str);\n");
+		grammarBuilder.append("    };\n");
+		grammarBuilder.append("    return this;\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("this.LeafListener.prototype = Object.create(TListener.prototype);\n");
+		grammarBuilder.append("this.LeafListener.prototype.constructor = this.LeafListener;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("console.log($ctx.r.toStringTree(null, this));\n");
+		grammarBuilder.append("var walker = new antlr4.tree.ParseTreeWalker();\n");
+		grammarBuilder.append("walker.walk(new this.LeafListener(), $ctx.r);\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : b b		// forces list\n");
+		grammarBuilder.append("  | b		// a list still\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("b : ID | INT;\n");
+		grammarBuilder.append("MULT: '*' ;\n");
+		grammarBuilder.append("ADD : '+' ;\n");
+		grammarBuilder.append("INT : [0-9]+ ;\n");
+		grammarBuilder.append("ID  : [a-z]+ ;\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="1 2";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals(
+			"(a (b 1) (b 2))\n" +
+			"1 2 1\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testRuleGetters_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(868);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@parser::header {\n");
+		grammarBuilder.append("var TListener = require('./TListener').TListener;\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("@parser::members {\n");
+		grammarBuilder.append("this.LeafListener = function() {\n");
+		grammarBuilder.append("    this.exitA = function(ctx) {\n");
+		grammarBuilder.append("    	var str;\n");
+		grammarBuilder.append("        if(ctx.getChildCount()===2) {\n");
+		grammarBuilder.append("            str = ctx.b(0).start.text + ' ' + ctx.b(1).start.text + ' ' + ctx.b()[0].start.text;\n");
+		grammarBuilder.append("        } else {\n");
+		grammarBuilder.append("            str = ctx.b(0).start.text;\n");
+		grammarBuilder.append("        }\n");
+		grammarBuilder.append("    	console.log(str);\n");
+		grammarBuilder.append("    };\n");
+		grammarBuilder.append("    return this;\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("this.LeafListener.prototype = Object.create(TListener.prototype);\n");
+		grammarBuilder.append("this.LeafListener.prototype.constructor = this.LeafListener;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("console.log($ctx.r.toStringTree(null, this));\n");
+		grammarBuilder.append("var walker = new antlr4.tree.ParseTreeWalker();\n");
+		grammarBuilder.append("walker.walk(new this.LeafListener(), $ctx.r);\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : b b		// forces list\n");
+		grammarBuilder.append("  | b		// a list still\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("b : ID | INT;\n");
+		grammarBuilder.append("MULT: '*' ;\n");
+		grammarBuilder.append("ADD : '+' ;\n");
+		grammarBuilder.append("INT : [0-9]+ ;\n");
+		grammarBuilder.append("ID  : [a-z]+ ;\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="abc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals(
+			"(a (b abc))\n" +
+			"abc\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTokenGetters_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(855);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@parser::header {\n");
+		grammarBuilder.append("var TListener = require('./TListener').TListener;\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("@parser::members {\n");
+		grammarBuilder.append("this.LeafListener = function() {\n");
+		grammarBuilder.append("    this.exitA = function(ctx) {\n");
+		grammarBuilder.append("    	var str;\n");
+		grammarBuilder.append("        if(ctx.getChildCount()===2) {\n");
+		grammarBuilder.append("            str = ctx.INT(0).symbol.text + ' ' + ctx.INT(1).symbol.text + ' ' + antlr4.Utils.arrayToString(ctx.INT());\n");
+		grammarBuilder.append("        } else {\n");
+		grammarBuilder.append("            str = ctx.ID().symbol.toString();\n");
+		grammarBuilder.append("        }\n");
+		grammarBuilder.append("    	console.log(str);\n");
+		grammarBuilder.append("    };\n");
+		grammarBuilder.append("    return this;\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("this.LeafListener.prototype = Object.create(TListener.prototype);\n");
+		grammarBuilder.append("this.LeafListener.prototype.constructor = this.LeafListener;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("console.log($ctx.r.toStringTree(null, this));\n");
+		grammarBuilder.append("var walker = new antlr4.tree.ParseTreeWalker();\n");
+		grammarBuilder.append("walker.walk(new this.LeafListener(), $ctx.r);\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : INT INT\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("MULT: '*' ;\n");
+		grammarBuilder.append("ADD : '+' ;\n");
+		grammarBuilder.append("INT : [0-9]+ ;\n");
+		grammarBuilder.append("ID  : [a-z]+ ;\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="1 2";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals(
+			"(a 1 2)\n" +
+			"1 2 [1, 2]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTokenGetters_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(855);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@parser::header {\n");
+		grammarBuilder.append("var TListener = require('./TListener').TListener;\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("@parser::members {\n");
+		grammarBuilder.append("this.LeafListener = function() {\n");
+		grammarBuilder.append("    this.exitA = function(ctx) {\n");
+		grammarBuilder.append("    	var str;\n");
+		grammarBuilder.append("        if(ctx.getChildCount()===2) {\n");
+		grammarBuilder.append("            str = ctx.INT(0).symbol.text + ' ' + ctx.INT(1).symbol.text + ' ' + antlr4.Utils.arrayToString(ctx.INT());\n");
+		grammarBuilder.append("        } else {\n");
+		grammarBuilder.append("            str = ctx.ID().symbol.toString();\n");
+		grammarBuilder.append("        }\n");
+		grammarBuilder.append("    	console.log(str);\n");
+		grammarBuilder.append("    };\n");
+		grammarBuilder.append("    return this;\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("this.LeafListener.prototype = Object.create(TListener.prototype);\n");
+		grammarBuilder.append("this.LeafListener.prototype.constructor = this.LeafListener;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("console.log($ctx.r.toStringTree(null, this));\n");
+		grammarBuilder.append("var walker = new antlr4.tree.ParseTreeWalker();\n");
+		grammarBuilder.append("walker.walk(new this.LeafListener(), $ctx.r);\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : INT INT\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("MULT: '*' ;\n");
+		grammarBuilder.append("ADD : '+' ;\n");
+		grammarBuilder.append("INT : [0-9]+ ;\n");
+		grammarBuilder.append("ID  : [a-z]+ ;\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="abc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals(
+			"(a abc)\n" +
+			"[@0,0:2='abc',<4>,1:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+}
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/node/TestParseTrees.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/node/TestParseTrees.java
new file mode 100644
index 000000000..2dd5b992d
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/node/TestParseTrees.java
@@ -0,0 +1,278 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.javascript.node;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
+@SuppressWarnings("unused")
+public class TestParseTrees extends BaseTest {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void test2AltLoop() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(143);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {\n");
+		grammarBuilder.append("this.buildParseTrees = true;\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("console.log($r.ctx.toStringTree(null, this));\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : ('x' | 'y')* 'z'\n");
+		grammarBuilder.append("  ;");
+		String grammar = grammarBuilder.toString();
+		String input ="xyyxyxz";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(a x y y x y x z)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void test2Alts() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(136);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {\n");
+		grammarBuilder.append("this.buildParseTrees = true;\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("console.log($r.ctx.toStringTree(null, this));\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : 'x' | 'y'\n");
+		grammarBuilder.append("  ;");
+		String grammar = grammarBuilder.toString();
+		String input ="y";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(a y)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAltNum() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(663);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("options { contextSuperClass=MyRuleNode; }\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("@parser::header {\n");
+		grammarBuilder.append("MyRuleNode = function(parent, invokingState) {\n");
+		grammarBuilder.append("	antlr4.ParserRuleContext.call(this, parent, invokingState);\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("	this.altNum = 0;\n");
+		grammarBuilder.append("	return this;\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("MyRuleNode.prototype = Object.create(antlr4.ParserRuleContext.prototype);\n");
+		grammarBuilder.append("MyRuleNode.prototype.constructor = MyRuleNode;\n");
+		grammarBuilder.append("MyRuleNode.prototype.getAltNumber = function() { return this.altNum; }\n");
+		grammarBuilder.append("MyRuleNode.prototype.setAltNumber = function(altNumber) { this.altNum = altNumber; }\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {\n");
+		grammarBuilder.append("this.buildParseTrees = true;\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("console.log($r.ctx.toStringTree(null, this));\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("a : 'f'\n");
+		grammarBuilder.append("  | 'g'\n");
+		grammarBuilder.append("  | 'x' b 'z'\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("b : 'e' {} | 'y'\n");
+		grammarBuilder.append("  ;");
+		String grammar = grammarBuilder.toString();
+		String input ="xyz";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(a:3 x (b:2 y) z)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExtraToken() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(149);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {\n");
+		grammarBuilder.append("this.buildParseTrees = true;\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("console.log($r.ctx.toStringTree(null, this));\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : 'x' 'y'\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("Z : 'z' \n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append(" ");
+		String grammar = grammarBuilder.toString();
+		String input ="xzy";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(a x z y)\n", found);
+
+		assertEquals("line 1:1 extraneous input 'z' expecting 'y'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNoViableAlt() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(151);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {\n");
+		grammarBuilder.append("this.buildParseTrees = true;\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("console.log($r.ctx.toStringTree(null, this));\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : 'x' | 'y'\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("Z : 'z' \n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append(" ");
+		String grammar = grammarBuilder.toString();
+		String input ="z";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(a z)\n", found);
+
+		assertEquals("line 1:0 mismatched input 'z' expecting {'x', 'y'}\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testRuleRef() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(145);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {\n");
+		grammarBuilder.append("this.buildParseTrees = true;\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("console.log($r.ctx.toStringTree(null, this));\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : b 'x'\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("b : 'y' \n");
+		grammarBuilder.append("  ;");
+		String grammar = grammarBuilder.toString();
+		String input ="yx";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(a (b y) x)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSync() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(152);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {\n");
+		grammarBuilder.append("this.buildParseTrees = true;\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("console.log($r.ctx.toStringTree(null, this));\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : 'x' 'y'* '!'\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("Z : 'z' \n");
+		grammarBuilder.append("  ;");
+		String grammar = grammarBuilder.toString();
+		String input ="xzyy!";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(a x z y y !)\n", found);
+
+		assertEquals("line 1:1 extraneous input 'z' expecting {'y', '!'}\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testToken2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(134);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {\n");
+		grammarBuilder.append("this.buildParseTrees = true;\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("console.log($r.ctx.toStringTree(null, this));\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : 'x' 'y'\n");
+		grammarBuilder.append("  ;");
+		String grammar = grammarBuilder.toString();
+		String input ="xy";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("(a x y)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTokenAndRuleContextString() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(205);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {\n");
+		grammarBuilder.append("this.buildParseTrees = true;\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("console.log($r.ctx.toStringTree(null, this));\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : 'x' { \n");
+		grammarBuilder.append("console.log(antlr4.Utils.arrayToString(this.getRuleInvocationStack()));\n");
+		grammarBuilder.append("} ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals(
+			"[a, s]\n" +
+			"(a x)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+}
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/node/TestParserErrors.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/node/TestParserErrors.java
new file mode 100644
index 000000000..ec893e13c
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/node/TestParserErrors.java
@@ -0,0 +1,624 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.javascript.node;
+
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+@SuppressWarnings("unused")
+public class TestParserErrors extends BaseTest {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testConjuringUpToken() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(63);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' x='b' {console.log(\"conjured=\" + $x);} 'c' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="ac";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("conjured=[@-1,-1:-1='<missing 'b'>',<2>,1:1]\n", found);
+
+		assertEquals("line 1:1 missing 'b' at 'c'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testConjuringUpTokenFromSet() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(69);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' x=('b'|'c') {console.log(\"conjured=\" + $x);} 'd' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="ad";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("conjured=[@-1,-1:-1='<missing 'b'>',<2>,1:1]\n", found);
+
+		assertEquals("line 1:1 missing {'b', 'c'} at 'd'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testContextListGetters() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(211);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@parser::members{\n");
+		grammarBuilder.append("	function foo() {\n");
+		grammarBuilder.append("		var s = new SContext();\n");
+		grammarBuilder.append("	    var a = s.a();\n");
+		grammarBuilder.append("	    var b = s.b();\n");
+		grammarBuilder.append("    };\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("s : (a | b)+;\n");
+		grammarBuilder.append("a : 'a' {process.stdout.write('a');};\n");
+		grammarBuilder.append("b : 'b' {process.stdout.write('b');};");
+		String grammar = grammarBuilder.toString();
+		String input ="abab";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, true);
+		assertEquals("abab\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDuplicatedLeftRecursiveCall_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(63);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : expr EOF;\n");
+		grammarBuilder.append("expr : 'x'\n");
+		grammarBuilder.append("     | expr expr\n");
+		grammarBuilder.append("     ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "start", input, true);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDuplicatedLeftRecursiveCall_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(63);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : expr EOF;\n");
+		grammarBuilder.append("expr : 'x'\n");
+		grammarBuilder.append("     | expr expr\n");
+		grammarBuilder.append("     ;");
+		String grammar = grammarBuilder.toString();
+		String input ="xx";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "start", input, true);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDuplicatedLeftRecursiveCall_3() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(63);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : expr EOF;\n");
+		grammarBuilder.append("expr : 'x'\n");
+		grammarBuilder.append("     | expr expr\n");
+		grammarBuilder.append("     ;");
+		String grammar = grammarBuilder.toString();
+		String input ="xxx";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "start", input, true);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDuplicatedLeftRecursiveCall_4() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(63);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : expr EOF;\n");
+		grammarBuilder.append("expr : 'x'\n");
+		grammarBuilder.append("     | expr expr\n");
+		grammarBuilder.append("     ;");
+		String grammar = grammarBuilder.toString();
+		String input ="xxxx";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "start", input, true);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testInvalidATNStateRemoval() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(98);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : ID ':' expr;\n");
+		grammarBuilder.append("expr : primary expr? {} | expr '->' ID;\n");
+		grammarBuilder.append("primary : ID;\n");
+		grammarBuilder.append("ID : [a-z]+;");
+		String grammar = grammarBuilder.toString();
+		String input ="x:x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "start", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testInvalidEmptyInput() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(36);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : ID+;\n");
+		grammarBuilder.append("ID : [a-z]+;");
+		String grammar = grammarBuilder.toString();
+		String input ="";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "start", input, true);
+		assertEquals("", found);
+
+		assertEquals("line 1:0 missing ID at '<EOF>'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLL1ErrorInfo() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(301);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : animal (AND acClass)? service EOF;\n");
+		grammarBuilder.append("animal : (DOG | CAT );\n");
+		grammarBuilder.append("service : (HARDWARE | SOFTWARE) ;\n");
+		grammarBuilder.append("AND : 'and';\n");
+		grammarBuilder.append("DOG : 'dog';\n");
+		grammarBuilder.append("CAT : 'cat';\n");
+		grammarBuilder.append("HARDWARE: 'hardware';\n");
+		grammarBuilder.append("SOFTWARE: 'software';\n");
+		grammarBuilder.append("WS : ' ' -> skip ;\n");
+		grammarBuilder.append("acClass\n");
+		grammarBuilder.append("@init\n");
+		grammarBuilder.append("{console.log(this.getExpectedTokens().toString(this.literalNames));}\n");
+		grammarBuilder.append("  : ;");
+		String grammar = grammarBuilder.toString();
+		String input ="dog and software";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "start", input, false);
+		assertEquals("{'hardware', 'software'}\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLL2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(46);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' 'b'\n");
+		grammarBuilder.append("  | 'a' 'c'\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("q : 'e' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="ae";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:1 no viable alternative at input 'ae'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLL3() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(55);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' 'b'* 'c'\n");
+		grammarBuilder.append("  | 'a' 'b' 'd'\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("q : 'e' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="abe";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:2 no viable alternative at input 'abe'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLLStar() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(48);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a'+ 'b'\n");
+		grammarBuilder.append("  | 'a'+ 'c'\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("q : 'e' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="aaae";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:3 no viable alternative at input 'aaae'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultiTokenDeletionBeforeLoop() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(28);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' 'b'* 'c';");
+		String grammar = grammarBuilder.toString();
+		String input ="aacabc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:1 extraneous input 'a' expecting {'b', 'c'}\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultiTokenDeletionBeforeLoop2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(36);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' ('b'|'z'{})* 'c';");
+		String grammar = grammarBuilder.toString();
+		String input ="aacabc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:1 extraneous input 'a' expecting {'b', 'z', 'c'}\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultiTokenDeletionDuringLoop() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(29);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' 'b'* 'c' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="abaaababc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("", found);
+
+		assertEquals(
+			"line 1:2 extraneous input 'a' expecting {'b', 'c'}\n" +
+			"line 1:6 extraneous input 'a' expecting {'b', 'c'}\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultiTokenDeletionDuringLoop2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(37);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' ('b'|'z'{})* 'c' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="abaaababc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("", found);
+
+		assertEquals(
+			"line 1:2 extraneous input 'a' expecting {'b', 'z', 'c'}\n" +
+			"line 1:6 extraneous input 'a' expecting {'b', 'z', 'c'}\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNoViableAltAvoidance() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(83);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e '!' ;\n");
+		grammarBuilder.append("e : 'a' 'b'\n");
+		grammarBuilder.append("  | 'a'\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("DOT : '.' ;\n");
+		grammarBuilder.append("WS : [ \\t\\r\\n]+ -> skip;");
+		String grammar = grammarBuilder.toString();
+		String input ="a.";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:1 mismatched input '.' expecting '!'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleSetInsertion() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(34);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' ('b'|'c') 'd' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="ad";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:1 missing {'b', 'c'} at 'd'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleSetInsertionConsumption() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(82);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("myset: ('b'|'c') ;\n");
+		grammarBuilder.append("a: 'a' myset 'd' {console.log(\"\" + $myset.stop);} ; ");
+		String grammar = grammarBuilder.toString();
+		String input ="ad";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("[@0,0:0='a',<3>,1:0]\n", found);
+
+		assertEquals("line 1:1 missing {'b', 'c'} at 'd'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleTokenDeletion() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(24);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' 'b' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="aab";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:1 extraneous input 'a' expecting 'b'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleTokenDeletionBeforeAlt() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(38);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : ('b' | 'c')\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("q : 'a'\n");
+		grammarBuilder.append(";");
+		String grammar = grammarBuilder.toString();
+		String input ="ac";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:0 extraneous input 'a' expecting {'b', 'c'}\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleTokenDeletionBeforeLoop() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(25);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' 'b'* ;");
+		String grammar = grammarBuilder.toString();
+		String input ="aabc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("", found);
+
+		assertEquals(
+			"line 1:1 extraneous input 'a' expecting {<EOF>, 'b'}\n" +
+			"line 1:3 token recognition error at: 'c'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleTokenDeletionBeforeLoop2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(32);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' ('b'|'z'{})*;");
+		String grammar = grammarBuilder.toString();
+		String input ="aabc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("", found);
+
+		assertEquals(
+			"line 1:1 extraneous input 'a' expecting {<EOF>, 'b', 'z'}\n" +
+			"line 1:3 token recognition error at: 'c'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleTokenDeletionBeforePredict() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(48);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a'+ 'b'\n");
+		grammarBuilder.append("  | 'a'+ 'c'\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("q : 'e' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="caaab";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:0 extraneous input 'c' expecting 'a'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleTokenDeletionConsumption() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(82);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("myset: ('b'|'c') ;\n");
+		grammarBuilder.append("a: 'a' myset 'd' {console.log(\"\" + $myset.stop);} ; ");
+		String grammar = grammarBuilder.toString();
+		String input ="aabd";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("[@2,2:2='b',<1>,1:2]\n", found);
+
+		assertEquals("line 1:1 extraneous input 'a' expecting {'b', 'c'}\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleTokenDeletionDuringLoop() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(29);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' 'b'* 'c' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="ababbc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:2 extraneous input 'a' expecting {'b', 'c'}\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleTokenDeletionDuringLoop2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(37);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' ('b'|'z'{})* 'c' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="ababbc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:2 extraneous input 'a' expecting {'b', 'z', 'c'}\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleTokenDeletionExpectingSet() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(30);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' ('b'|'c') ;");
+		String grammar = grammarBuilder.toString();
+		String input ="aab";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:1 extraneous input 'a' expecting {'b', 'c'}\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleTokenInsertion() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(28);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' 'b' 'c' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="ac";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:1 missing 'b' at 'c'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTokenMismatch() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(24);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' 'b' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="aa";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:1 mismatched input 'a' expecting 'b'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTokenMismatch2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(165);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("stat:   ( '(' expr? ')' )? EOF ;\n");
+		grammarBuilder.append("expr:   ID '=' STR ;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("ERR :   '~FORCE_ERROR~' ;\n");
+		grammarBuilder.append("ID  :   [a-zA-Z]+ ;\n");
+		grammarBuilder.append("STR :   '\"' ~[\"]* '\"' ;\n");
+		grammarBuilder.append("WS  :   [ \\t\\r\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="( ~FORCE_ERROR~ ";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "stat", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:2 mismatched input '~FORCE_ERROR~' expecting ')'\n", this.stderrDuringParse);
+
+	}
+
+}
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/node/TestParserExec.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/node/TestParserExec.java
new file mode 100644
index 000000000..c466ab588
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/node/TestParserExec.java
@@ -0,0 +1,695 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.javascript.node;
+
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+@SuppressWarnings("unused")
+public class TestParserExec extends BaseTest {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAPlus() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(84);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : ID+ {\n");
+		grammarBuilder.append("console.log($text);\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+		String input ="a b c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("abc\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAStar_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(84);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : ID* {\n");
+		grammarBuilder.append("console.log($text);\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+		String input ="";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAStar_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(84);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : ID* {\n");
+		grammarBuilder.append("console.log($text);\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+		String input ="a b c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("abc\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAorAPlus() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(89);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (ID|ID)+ {\n");
+		grammarBuilder.append("console.log($text);\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+		String input ="a b c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("abc\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAorAStar_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(89);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (ID|ID)* {\n");
+		grammarBuilder.append("console.log($text);\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+		String input ="";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAorAStar_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(89);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (ID|ID)* {\n");
+		grammarBuilder.append("console.log($text);\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+		String input ="a b c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("abc\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAorB() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(136);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : ID {\n");
+		grammarBuilder.append("console.log(\"alt 1\");\n");
+		grammarBuilder.append("} | INT {\n");
+		grammarBuilder.append("console.log(\"alt 2\");\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="34";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("alt 2\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAorBPlus() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(112);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (ID|INT{\n");
+		grammarBuilder.append("})+ {\n");
+		grammarBuilder.append("console.log($text);\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a 34 c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("a34c\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAorBStar_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(112);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (ID|INT{\n");
+		grammarBuilder.append("})* {\n");
+		grammarBuilder.append("console.log($text);\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAorBStar_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(112);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (ID|INT{\n");
+		grammarBuilder.append("})* {\n");
+		grammarBuilder.append("console.log($text);\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a 34 c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("a34c\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testBasic() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(105);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : ID INT {\n");
+		grammarBuilder.append("console.log($text);\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+		String input ="abc 34";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("abc34\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testEOFInClosure() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(53);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("prog : stat EOF;\n");
+		grammarBuilder.append("stat : 'x' ('y' | EOF)*?;");
+		String grammar = grammarBuilder.toString();
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "prog", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testIfIfElseGreedyBinding1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(193);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : statement+ ;\n");
+		grammarBuilder.append("statement : 'x' | ifStatement;\n");
+		grammarBuilder.append("ifStatement : 'if' 'y' statement ('else' statement)? {\n");
+		grammarBuilder.append("console.log($text);\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> channel(HIDDEN);");
+		String grammar = grammarBuilder.toString();
+		String input ="if y if y x else x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "start", input, false);
+		assertEquals(
+			"if y x else x\n" +
+			"if y if y x else x\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testIfIfElseGreedyBinding2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(193);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : statement+ ;\n");
+		grammarBuilder.append("statement : 'x' | ifStatement;\n");
+		grammarBuilder.append("ifStatement : 'if' 'y' statement ('else' statement|) {\n");
+		grammarBuilder.append("console.log($text);\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> channel(HIDDEN);");
+		String grammar = grammarBuilder.toString();
+		String input ="if y if y x else x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "start", input, false);
+		assertEquals(
+			"if y x else x\n" +
+			"if y if y x else x\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testIfIfElseNonGreedyBinding1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(194);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : statement+ ;\n");
+		grammarBuilder.append("statement : 'x' | ifStatement;\n");
+		grammarBuilder.append("ifStatement : 'if' 'y' statement ('else' statement)?? {\n");
+		grammarBuilder.append("console.log($text);\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> channel(HIDDEN);");
+		String grammar = grammarBuilder.toString();
+		String input ="if y if y x else x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "start", input, false);
+		assertEquals(
+			"if y x\n" +
+			"if y if y x else x\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testIfIfElseNonGreedyBinding2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(193);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : statement+ ;\n");
+		grammarBuilder.append("statement : 'x' | ifStatement;\n");
+		grammarBuilder.append("ifStatement : 'if' 'y' statement (|'else' statement) {\n");
+		grammarBuilder.append("console.log($text);\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> channel(HIDDEN);");
+		String grammar = grammarBuilder.toString();
+		String input ="if y if y x else x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "start", input, false);
+		assertEquals(
+			"if y x\n" +
+			"if y if y x else x\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLL1OptionalBlock_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(110);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (ID|{}INT)? {\n");
+		grammarBuilder.append("console.log($text);\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+		String input ="";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLL1OptionalBlock_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(110);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (ID|{}INT)? {\n");
+		grammarBuilder.append("console.log($text);\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+		String input ="a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("a\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLabelAliasingAcrossLabeledAlternatives() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(171);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : a* EOF;\n");
+		grammarBuilder.append("a\n");
+		grammarBuilder.append("  : label=subrule {console.log($label.text);} #One\n");
+		grammarBuilder.append("  | label='y' {console.log($label.text);} #Two\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("subrule : 'x';\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="xy";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "start", input, false);
+		assertEquals(
+			"x\n" +
+			"y\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLabels() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(118);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : b1=b b2+=b* b3+=';' ;\n");
+		grammarBuilder.append("b : id_=ID val+=INT*;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="abc 34;";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testListLabelForClosureContext() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(482);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("ifStatement\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("if ( !(v instanceof Array) ) {throw \"value is not an array\";}\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("    : 'if' expression\n");
+		grammarBuilder.append("      ( ( 'then'\n");
+		grammarBuilder.append("          executableStatement*\n");
+		grammarBuilder.append("          elseIfStatement*  // <--- problem is here; should yield a list not node\n");
+		grammarBuilder.append("          elseStatement?\n");
+		grammarBuilder.append("          'end' 'if'\n");
+		grammarBuilder.append("        ) | executableStatement )\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("elseIfStatement\n");
+		grammarBuilder.append("    : 'else' 'if' expression 'then' executableStatement*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("expression : 'a' ;\n");
+		grammarBuilder.append("executableStatement : 'a' ;\n");
+		grammarBuilder.append("elseStatement : 'a' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "expression", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testListLabelsOnSet() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(140);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : b b* ';' ;\n");
+		grammarBuilder.append("b : ID val+=(INT | FLOAT)*;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("FLOAT : [0-9]+ '.' [0-9]+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="abc 34;";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleEOFHandling() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(42);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("prog : ('x' | 'x' 'y') EOF EOF;");
+		String grammar = grammarBuilder.toString();
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "prog", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testOptional_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(90);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("stat : ifstat | 'x';\n");
+		grammarBuilder.append("ifstat : 'if' stat ('else' stat)?;\n");
+		grammarBuilder.append("WS : [ \\n\\t]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "stat", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testOptional_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(90);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("stat : ifstat | 'x';\n");
+		grammarBuilder.append("ifstat : 'if' stat ('else' stat)?;\n");
+		grammarBuilder.append("WS : [ \\n\\t]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="if x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "stat", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testOptional_3() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(90);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("stat : ifstat | 'x';\n");
+		grammarBuilder.append("ifstat : 'if' stat ('else' stat)?;\n");
+		grammarBuilder.append("WS : [ \\n\\t]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="if x else x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "stat", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testOptional_4() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(90);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("stat : ifstat | 'x';\n");
+		grammarBuilder.append("ifstat : 'if' stat ('else' stat)?;\n");
+		grammarBuilder.append("WS : [ \\n\\t]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="if if x else x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "stat", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testParserProperty() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(171);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@members {\n");
+		grammarBuilder.append("this.Property = function() {\n");
+		grammarBuilder.append("    return true;\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("a : {$parser.Property()}? ID {console.log(\"valid\");}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="abc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("valid\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPredicatedIfIfElse() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(175);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : stmt EOF ;\n");
+		grammarBuilder.append("stmt : ifStmt | ID;\n");
+		grammarBuilder.append("ifStmt : 'if' ID stmt ('else' stmt | { this._input.LA(1)!=TParser.ELSE }?);\n");
+		grammarBuilder.append("ELSE : 'else';\n");
+		grammarBuilder.append("ID : [a-zA-Z]+;\n");
+		grammarBuilder.append("WS : [ \\n\\t]+ -> skip;");
+		String grammar = grammarBuilder.toString();
+		String input ="if x if x a else b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, true);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPredictionIssue334() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(269);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("file_ @init{\n");
+		grammarBuilder.append("this._errHandler = new antlr4.error.BailErrorStrategy();\n");
+		grammarBuilder.append("} \n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("console.log($ctx.toStringTree(null, this));\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  :   item (SEMICOLON item)* SEMICOLON? EOF ;\n");
+		grammarBuilder.append("item : A B?;\n");
+		grammarBuilder.append("SEMICOLON: ';';\n");
+		grammarBuilder.append("A : 'a'|'A';\n");
+		grammarBuilder.append("B : 'b'|'B';\n");
+		grammarBuilder.append("WS      : [ \\r\\t\\n]+ -> skip;");
+		String grammar = grammarBuilder.toString();
+		String input ="a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "file_", input, false);
+		assertEquals("(file_ (item a) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReferenceToATN_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(113);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (ID|ATN)* ATN? {console.log($text);} ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("ATN : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReferenceToATN_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(113);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (ID|ATN)* ATN? {console.log($text);} ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("ATN : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a 34 c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("a34c\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+}
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/node/TestPerformance.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/node/TestPerformance.java
new file mode 100644
index 000000000..8fe24376c
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/node/TestPerformance.java
@@ -0,0 +1,212 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.javascript.node;
+
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+@SuppressWarnings("unused")
+public class TestPerformance extends BaseTest {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExpressionGrammar_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(164);
+		grammarBuilder.append("grammar Expr;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("program: expr EOF;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("expr\n");
+		grammarBuilder.append("	: ID\n");
+		grammarBuilder.append("	| 'not' expr\n");
+		grammarBuilder.append("	| expr 'and' expr\n");
+		grammarBuilder.append("	| expr 'or' expr\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("ID: [a-zA-Z_][a-zA-Z_0-9]*;\n");
+		grammarBuilder.append("WS: [ \\t\\n\\r\\f]+ -> skip;\n");
+		grammarBuilder.append("ERROR: .;");
+		String grammar = grammarBuilder.toString();
+		String input =
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12";
+		String found = execParser("Expr.g4", grammar, "ExprParser", "ExprLexer",
+		                          "ExprListener", "ExprVisitor",
+		                          "program", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExpressionGrammar_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(164);
+		grammarBuilder.append("grammar Expr;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("program: expr EOF;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("expr\n");
+		grammarBuilder.append("	: ID\n");
+		grammarBuilder.append("	| 'not' expr\n");
+		grammarBuilder.append("	| expr 'and' expr\n");
+		grammarBuilder.append("	| expr 'or' expr\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("ID: [a-zA-Z_][a-zA-Z_0-9]*;\n");
+		grammarBuilder.append("WS: [ \\t\\n\\r\\f]+ -> skip;\n");
+		grammarBuilder.append("ERROR: .;");
+		String grammar = grammarBuilder.toString();
+		String input =
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12";
+		String found = execParser("Expr.g4", grammar, "ExprParser", "ExprLexer",
+		                          "ExprListener", "ExprVisitor",
+		                          "program", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+}
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/node/TestSemPredEvalLexer.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/node/TestSemPredEvalLexer.java
new file mode 100644
index 000000000..055adabe8
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/node/TestSemPredEvalLexer.java
@@ -0,0 +1,204 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.javascript.node;
+
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+@SuppressWarnings("unused")
+public class TestSemPredEvalLexer extends BaseTest {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDisableRule() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(131);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("E1 : 'enum' { false }? ;\n");
+		grammarBuilder.append("E2 : 'enum' { true }? ;  // winner not E1 or ID\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+		String input ="enum abc";
+		String found = execLexer("L.g4", grammar, "L", input, true);
+		assertEquals(
+			"[@0,0:3='enum',<2>,1:0]\n" +
+			"[@1,5:7='abc',<3>,1:5]\n" +
+			"[@2,8:7='<EOF>',<-1>,1:8]\n" +
+			"s0-' '->:s5=>4\n" +
+			"s0-'a'->:s6=>3\n" +
+			"s0-'e'->:s1=>3\n" +
+			":s1=>3-'n'->:s2=>3\n" +
+			":s2=>3-'u'->:s3=>3\n" +
+			":s6=>3-'b'->:s6=>3\n" +
+			":s6=>3-'c'->:s6=>3\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testEnumNotID() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(97);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("ENUM : [a-z]+  { this.text===\"enum\" }? ;\n");
+		grammarBuilder.append("ID : [a-z]+  ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+		String input ="enum abc enum";
+		String found = execLexer("L.g4", grammar, "L", input, true);
+		assertEquals(
+			"[@0,0:3='enum',<1>,1:0]\n" +
+			"[@1,5:7='abc',<2>,1:5]\n" +
+			"[@2,9:12='enum',<1>,1:9]\n" +
+			"[@3,13:12='<EOF>',<-1>,1:13]\n" +
+			"s0-' '->:s3=>3\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testIDnotEnum() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(84);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("ENUM : [a-z]+  { false }? ;\n");
+		grammarBuilder.append("ID : [a-z]+  ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+		String input ="enum abc enum";
+		String found = execLexer("L.g4", grammar, "L", input, true);
+		assertEquals(
+			"[@0,0:3='enum',<2>,1:0]\n" +
+			"[@1,5:7='abc',<2>,1:5]\n" +
+			"[@2,9:12='enum',<2>,1:9]\n" +
+			"[@3,13:12='<EOF>',<-1>,1:13]\n" +
+			"s0-' '->:s2=>3\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testIDvsEnum() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(85);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("ENUM : 'enum' { false }? ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+		String input ="enum abc enum";
+		String found = execLexer("L.g4", grammar, "L", input, true);
+		assertEquals(
+			"[@0,0:3='enum',<2>,1:0]\n" +
+			"[@1,5:7='abc',<2>,1:5]\n" +
+			"[@2,9:12='enum',<2>,1:9]\n" +
+			"[@3,13:12='<EOF>',<-1>,1:13]\n" +
+			"s0-' '->:s5=>3\n" +
+			"s0-'a'->:s4=>2\n" +
+			"s0-'e'->:s1=>2\n" +
+			":s1=>2-'n'->:s2=>2\n" +
+			":s2=>2-'u'->:s3=>2\n" +
+			":s4=>2-'b'->:s4=>2\n" +
+			":s4=>2-'c'->:s4=>2\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testIndent() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(143);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("ID : [a-z]+  ;\n");
+		grammarBuilder.append("INDENT : [ \\t]+ { this._tokenStartColumn===0 }?\n");
+		grammarBuilder.append("         { console.log(\"INDENT\"); }  ;\n");
+		grammarBuilder.append("NL : '\\n';\n");
+		grammarBuilder.append("WS : [ \\t]+ ;");
+		String grammar = grammarBuilder.toString();
+		String input =
+			"abc\n" +
+			"  def  \n";
+		String found = execLexer("L.g4", grammar, "L", input, true);
+		assertEquals(
+			"INDENT\n" +
+			"[@0,0:2='abc',<1>,1:0]\n" +
+			"[@1,3:3='\\n',<3>,1:3]\n" +
+			"[@2,4:5='  ',<2>,2:0]\n" +
+			"[@3,6:8='def',<1>,2:2]\n" +
+			"[@4,9:10='  ',<4>,2:5]\n" +
+			"[@5,11:11='\\n',<3>,2:7]\n" +
+			"[@6,12:11='<EOF>',<-1>,3:0]\n" +
+			"s0-'\n" +
+			"'->:s2=>3\n" +
+			"s0-'a'->:s1=>1\n" +
+			"s0-'d'->:s1=>1\n" +
+			":s1=>1-'b'->:s1=>1\n" +
+			":s1=>1-'c'->:s1=>1\n" +
+			":s1=>1-'e'->:s1=>1\n" +
+			":s1=>1-'f'->:s1=>1\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLexerInputPositionSensitivePredicates() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(220);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("WORD1 : ID1+ { console.log(this.text); } ;\n");
+		grammarBuilder.append("WORD2 : ID2+ { console.log(this.text); } ;\n");
+		grammarBuilder.append("fragment ID1 : { this.column < 2 }? [a-zA-Z];\n");
+		grammarBuilder.append("fragment ID2 : { this.column >= 2 }? [a-zA-Z];\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+		String input =
+			"a cde\n" +
+			"abcde\n";
+		String found = execLexer("L.g4", grammar, "L", input, true);
+		assertEquals(
+			"a\n" +
+			"cde\n" +
+			"ab\n" +
+			"cde\n" +
+			"[@0,0:0='a',<1>,1:0]\n" +
+			"[@1,2:4='cde',<2>,1:2]\n" +
+			"[@2,6:7='ab',<1>,2:0]\n" +
+			"[@3,8:10='cde',<2>,2:2]\n" +
+			"[@4,12:11='<EOF>',<-1>,3:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPredicatedKeywords() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(157);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("ENUM : [a-z]+ { this.text===\"enum\" }? { console.log(\"enum!\"); } ;\n");
+		grammarBuilder.append("ID   : [a-z]+ { console.log(\"ID \" + this.text); } ;\n");
+		grammarBuilder.append("WS   : [ \\n] -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="enum enu a";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"enum!\n" +
+			"ID enu\n" +
+			"ID a\n" +
+			"[@0,0:3='enum',<1>,1:0]\n" +
+			"[@1,5:7='enu',<2>,1:5]\n" +
+			"[@2,9:9='a',<2>,1:9]\n" +
+			"[@3,10:9='<EOF>',<-1>,1:10]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+}
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/node/TestSemPredEvalParser.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/node/TestSemPredEvalParser.java
new file mode 100644
index 000000000..652159bc4
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/node/TestSemPredEvalParser.java
@@ -0,0 +1,684 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.javascript.node;
+
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+@SuppressWarnings("unused")
+public class TestSemPredEvalParser extends BaseTest {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void test2UnpredicatedAlts() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(308);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : {this._interp.predictionMode = antlr4.atn.PredictionMode.LL_EXACT_AMBIG_DETECTION;} a ';' a; // do 2x: once in ATN, next in DFA\n");
+		grammarBuilder.append("a : ID {console.log(\"alt 1\");}\n");
+		grammarBuilder.append("  | ID {console.log(\"alt 2\");}\n");
+		grammarBuilder.append("  | {false}? ID {console.log(\"alt 3\");}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x; y";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, true);
+		assertEquals(
+			"alt 1\n" +
+			"alt 1\n", found);
+
+		assertEquals(
+			"line 1:0 reportAttemptingFullContext d=0 (a), input='x'\n" +
+			"line 1:0 reportAmbiguity d=0 (a): ambigAlts={1, 2}, input='x'\n" +
+			"line 1:3 reportAttemptingFullContext d=0 (a), input='y'\n" +
+			"line 1:3 reportAmbiguity d=0 (a): ambigAlts={1, 2}, input='y'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void test2UnpredicatedAltsAndOneOrthogonalAlt() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(360);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : {this._interp.predictionMode = antlr4.atn.PredictionMode.LL_EXACT_AMBIG_DETECTION;} a ';' a ';' a;\n");
+		grammarBuilder.append("a : INT {console.log(\"alt 1\");}\n");
+		grammarBuilder.append("  | ID {console.log(\"alt 2\");} // must pick this one for ID since pred is false\n");
+		grammarBuilder.append("  | ID {console.log(\"alt 3\");}\n");
+		grammarBuilder.append("  | {false}? ID {console.log(\"alt 4\");}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="34; x; y";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, true);
+		assertEquals(
+			"alt 1\n" +
+			"alt 2\n" +
+			"alt 2\n", found);
+
+		assertEquals(
+			"line 1:4 reportAttemptingFullContext d=0 (a), input='x'\n" +
+			"line 1:4 reportAmbiguity d=0 (a): ambigAlts={2, 3}, input='x'\n" +
+			"line 1:7 reportAttemptingFullContext d=0 (a), input='y'\n" +
+			"line 1:7 reportAmbiguity d=0 (a): ambigAlts={2, 3}, input='y'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testActionHidesPreds() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(228);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@members {this.i = 0;}\n");
+		grammarBuilder.append("s : a+ ;\n");
+		grammarBuilder.append("a : {this.i = 1;} ID {this.i === 1}? {console.log(\"alt 1\");}\n");
+		grammarBuilder.append("  | {this.i = 2;} ID {this.i === 2}? {console.log(\"alt 2\");}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x x y";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals(
+			"alt 1\n" +
+			"alt 1\n" +
+			"alt 1\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testActionsHidePredsInGlobalFOLLOW() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(291);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@members {\n");
+		grammarBuilder.append("this.pred = function(v) {\n");
+		grammarBuilder.append("	console.log(\"eval=\" + v.toString());\n");
+		grammarBuilder.append("	return v;\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("s : e {} {this.pred(true)}? {console.log(\"parse\");} '!' ;\n");
+		grammarBuilder.append("t : e {} {this.pred(false)}? ID ;\n");
+		grammarBuilder.append("e : ID | ; // non-LL(1) so we use ATN\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a!";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals(
+			"eval=true\n" +
+			"parse\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAtomWithClosureInTranslatedLRRule() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(94);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : e[0] EOF;\n");
+		grammarBuilder.append("e[int _p]\n");
+		grammarBuilder.append("    :   ( 'a' | 'b'+ ) ( {3 >= $_p}? '+' e[4] )*\n");
+		grammarBuilder.append("    ;\n");
+		String grammar = grammarBuilder.toString();
+		String input ="a+b+a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "start", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDepedentPredsInGlobalFOLLOW() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(316);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@members {\n");
+		grammarBuilder.append("this.pred = function(v) {\n");
+		grammarBuilder.append("	console.log(\"eval=\" + v.toString());\n");
+		grammarBuilder.append("	return v;\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("s : a[99] ;\n");
+		grammarBuilder.append("a[int i] : e {this.pred($i===99)}? {console.log(\"parse\");} '!' ;\n");
+		grammarBuilder.append("b[int i] : e {this.pred($i===99)}? ID ;\n");
+		grammarBuilder.append("e : ID | ; // non-LL(1) so we use ATN\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a!";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals(
+			"eval=true\n" +
+			"parse\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDependentPredNotInOuterCtxShouldBeIgnored() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(272);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : b[2] ';' |  b[2] '.' ; // decision in s drills down to ctx-dependent pred in a;\n");
+		grammarBuilder.append("b[int i] : a[i] ;\n");
+		grammarBuilder.append("a[int i]\n");
+		grammarBuilder.append("  : {$i===1}? ID {console.log(\"alt 1\");}\n");
+		grammarBuilder.append("    | {$i===2}? ID {console.log(\"alt 2\");}\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;\n");
+		String grammar = grammarBuilder.toString();
+		String input ="a;";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("alt 2\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDisabledAlternative() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(121);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("cppCompilationUnit : content+ EOF;\n");
+		grammarBuilder.append("content: anything | {false}? .;\n");
+		grammarBuilder.append("anything: ANY_CHAR;\n");
+		grammarBuilder.append("ANY_CHAR: [_a-zA-Z0-9];");
+		String grammar = grammarBuilder.toString();
+		String input ="hello";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "cppCompilationUnit", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testIndependentPredNotPassedOuterCtxToAvoidCastException() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(183);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : b ';' |  b '.' ;\n");
+		grammarBuilder.append("b : a ;\n");
+		grammarBuilder.append("a\n");
+		grammarBuilder.append("  : {false}? ID {console.log(\"alt 1\");}\n");
+		grammarBuilder.append("  | {true}? ID {console.log(\"alt 2\");}\n");
+		grammarBuilder.append(" ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a;";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("alt 2\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNoTruePredsThrowsNoViableAlt() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(171);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : a a;\n");
+		grammarBuilder.append("a : {false}? ID INT {console.log(\"alt 1\");}\n");
+		grammarBuilder.append("  | {false}? ID INT {console.log(\"alt 2\");}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="y 3 x 4";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:0 no viable alternative at input 'y'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testOrder() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(297);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : a {} a; // do 2x: once in ATN, next in DFA;\n");
+		grammarBuilder.append("// action blocks lookahead from falling off of 'a'\n");
+		grammarBuilder.append("// and looking into 2nd 'a' ref. !ctx dependent pred\n");
+		grammarBuilder.append("a : ID {console.log(\"alt 1\");}\n");
+		grammarBuilder.append("  | {true}?  ID {console.log(\"alt 2\");}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x y";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals(
+			"alt 1\n" +
+			"alt 1\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPredFromAltTestedInLoopBack_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(210);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("file_\n");
+		grammarBuilder.append("@after {console.log($ctx.toStringTree(null, this));}\n");
+		grammarBuilder.append("  : para para EOF ;\n");
+		grammarBuilder.append("para: paraContent NL NL ;\n");
+		grammarBuilder.append("paraContent : ('s'|'x'|{this._input.LA(2)!=TParser.NL}? NL)+ ;\n");
+		grammarBuilder.append("NL : '\\n' ;\n");
+		grammarBuilder.append("s : 's' ;\n");
+		grammarBuilder.append("X : 'x' ;");
+		String grammar = grammarBuilder.toString();
+		String input =
+			"s\n" +
+			"\n" +
+			"\n" +
+			"x\n";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "file_", input, true);
+		assertEquals("(file_ (para (paraContent s) \\n \\n) (para (paraContent \\n x \\n)) <EOF>)\n", found);
+
+		assertEquals(
+			"line 5:0 mismatched input '<EOF>' expecting '\n" +
+			"'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPredFromAltTestedInLoopBack_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(210);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("file_\n");
+		grammarBuilder.append("@after {console.log($ctx.toStringTree(null, this));}\n");
+		grammarBuilder.append("  : para para EOF ;\n");
+		grammarBuilder.append("para: paraContent NL NL ;\n");
+		grammarBuilder.append("paraContent : ('s'|'x'|{this._input.LA(2)!=TParser.NL}? NL)+ ;\n");
+		grammarBuilder.append("NL : '\\n' ;\n");
+		grammarBuilder.append("s : 's' ;\n");
+		grammarBuilder.append("X : 'x' ;");
+		String grammar = grammarBuilder.toString();
+		String input =
+			"s\n" +
+			"\n" +
+			"\n" +
+			"x\n" +
+			"\n";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "file_", input, true);
+		assertEquals("(file_ (para (paraContent s) \\n \\n) (para (paraContent \\n x) \\n \\n) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPredTestedEvenWhenUnAmbig_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(201);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@members {this.enumKeyword = true;}\n");
+		grammarBuilder.append("primary\n");
+		grammarBuilder.append("    :   ID {console.log(\"ID \"+$ID.text);}\n");
+		grammarBuilder.append("    |   {!this.enumKeyword}? 'enum' {console.log(\"enum\");}\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : [a-z]+ ;\n");
+		grammarBuilder.append("WS : [ \\t\\n\\r]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="abc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "primary", input, false);
+		assertEquals("ID abc\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPredTestedEvenWhenUnAmbig_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(201);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@members {this.enumKeyword = true;}\n");
+		grammarBuilder.append("primary\n");
+		grammarBuilder.append("    :   ID {console.log(\"ID \"+$ID.text);}\n");
+		grammarBuilder.append("    |   {!this.enumKeyword}? 'enum' {console.log(\"enum\");}\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : [a-z]+ ;\n");
+		grammarBuilder.append("WS : [ \\t\\n\\r]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="enum";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "primary", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:0 no viable alternative at input 'enum'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPredicateDependentOnArg() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(203);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@members {this.i = 0;}\n");
+		grammarBuilder.append("s : a[2] a[1];\n");
+		grammarBuilder.append("a[int i]\n");
+		grammarBuilder.append("  : {$i===1}? ID {console.log(\"alt 1\");}\n");
+		grammarBuilder.append("  | {$i===2}? ID {console.log(\"alt 2\");}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals(
+			"alt 2\n" +
+			"alt 1\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPredicateDependentOnArg2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(157);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@members {this.i = 0;}\n");
+		grammarBuilder.append("s : a[2] a[1];\n");
+		grammarBuilder.append("a[int i]\n");
+		grammarBuilder.append("  : {$i===1}? ID \n");
+		grammarBuilder.append("  | {$i===2}? ID \n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPredsInGlobalFOLLOW() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(285);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@members {\n");
+		grammarBuilder.append("this.pred = function(v) {\n");
+		grammarBuilder.append("	console.log(\"eval=\" + v.toString());\n");
+		grammarBuilder.append("	return v;\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("s : e {this.pred(true)}? {console.log(\"parse\");} '!' ;\n");
+		grammarBuilder.append("t : e {this.pred(false)}? ID ;\n");
+		grammarBuilder.append("e : ID | ; // non-LL(1) so we use ATN\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="a!";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals(
+			"eval=true\n" +
+			"parse\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testRewindBeforePredEval() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(217);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : a a;\n");
+		grammarBuilder.append("a : {this._input.LT(1).text===\"x\"}? ID INT {console.log(\"alt 1\");}\n");
+		grammarBuilder.append("  | {this._input.LT(1).text===\"y\"}? ID INT {console.log(\"alt 2\");}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="y 3 x 4";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals(
+			"alt 2\n" +
+			"alt 1\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSimple() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(256);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : a a a; // do 3x: once in ATN, next in DFA then INT in ATN\n");
+		grammarBuilder.append("a : {false}? ID {console.log(\"alt 1\");}\n");
+		grammarBuilder.append("  | {true}?  ID {console.log(\"alt 2\");}\n");
+		grammarBuilder.append("  | INT         {console.log(\"alt 3\");}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x y 3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals(
+			"alt 2\n" +
+			"alt 2\n" +
+			"alt 3\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSimpleValidate() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(164);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : a ;\n");
+		grammarBuilder.append("a : {false}? ID  {console.log(\"alt 1\");}\n");
+		grammarBuilder.append("  | {true}?  INT {console.log(\"alt 2\");}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("", found);
+
+		assertEquals("line 1:0 no viable alternative at input 'x'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSimpleValidate2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(167);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : a a a;\n");
+		grammarBuilder.append("a : {false}? ID  {console.log(\"alt 1\");}\n");
+		grammarBuilder.append("  | {true}?  INT {console.log(\"alt 2\");}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="3 4 x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals(
+			"alt 2\n" +
+			"alt 2\n", found);
+
+		assertEquals("line 1:4 no viable alternative at input 'x'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testToLeft() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(164);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("	s : a+ ;\n");
+		grammarBuilder.append("a : {false}? ID {console.log(\"alt 1\");}\n");
+		grammarBuilder.append("  | {true}?  ID {console.log(\"alt 2\");}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x x y";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals(
+			"alt 2\n" +
+			"alt 2\n" +
+			"alt 2\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testToLeftWithVaryingPredicate() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(252);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@members {this.i = 0;}\n");
+		grammarBuilder.append("s : ({this.i += 1;\n");
+		grammarBuilder.append("console.log(\"i=\" + this.i);} a)+ ;\n");
+		grammarBuilder.append("a : {this.i % 2 === 0}? ID {console.log(\"alt 1\");}\n");
+		grammarBuilder.append("  | {this.i % 2 != 0}? ID {console.log(\"alt 2\");}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x x y";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals(
+			"i=1\n" +
+			"alt 2\n" +
+			"i=2\n" +
+			"alt 1\n" +
+			"i=3\n" +
+			"alt 2\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testUnpredicatedPathsInAlt() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(183);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : a {console.log(\"alt 1\");}\n");
+		grammarBuilder.append("  | b {console.log(\"alt 2\");}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("a : {false}? ID INT\n");
+		grammarBuilder.append("  | ID INT\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("b : ID ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x 4";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("alt 1\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testValidateInDFA() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(332);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : a ';' a;\n");
+		grammarBuilder.append("// ';' helps us to resynchronize without consuming\n");
+		grammarBuilder.append("// 2nd 'a' reference. We our testing that the DFA also\n");
+		grammarBuilder.append("// throws an exception if the validating predicate fails\n");
+		grammarBuilder.append("a : {false}? ID  {console.log(\"alt 1\");}\n");
+		grammarBuilder.append("  | {true}?  INT {console.log(\"alt 2\");}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x ; y";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "s", input, false);
+		assertEquals("", found);
+
+		assertEquals(
+			"line 1:0 no viable alternative at input 'x'\n" +
+			"line 1:4 no viable alternative at input 'y'\n", this.stderrDuringParse);
+
+	}
+
+}
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/node/TestSets.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/node/TestSets.java
new file mode 100644
index 000000000..98ab83a51
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/node/TestSets.java
@@ -0,0 +1,408 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.javascript.node;
+
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+@SuppressWarnings("unused")
+public class TestSets extends BaseTest {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetLiteral() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(85);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (A {console.log($A.text);})+ ;\n");
+		grammarBuilder.append("A : [AaBb] ;\n");
+		grammarBuilder.append("WS : (' '|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+		String input ="A a B b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals(
+			"A\n" +
+			"a\n" +
+			"B\n" +
+			"b\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testComplementSet() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(51);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("parse : ~NEW_LINE;\n");
+		grammarBuilder.append("NEW_LINE: '\\r'? '\\n';");
+		String grammar = grammarBuilder.toString();
+		String input ="a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "parse", input, false);
+		assertEquals("", found);
+
+		assertEquals(
+			"line 1:0 token recognition error at: 'a'\n" +
+			"line 1:1 missing {} at '<EOF>'\n", this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLexerOptionalSet() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(77);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {console.log(this._input.getText());} ;\n");
+		grammarBuilder.append("A : ('a'|'b')? 'c' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="ac";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("ac\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLexerPlusSet() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(77);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {console.log(this._input.getText());} ;\n");
+		grammarBuilder.append("A : ('a'|'b')+ 'c' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="abaac";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("abaac\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLexerStarSet() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(77);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {console.log(this._input.getText());} ;\n");
+		grammarBuilder.append("A : ('a'|'b')* 'c' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="abaac";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("abaac\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNotChar() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(53);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {console.log($A.text);} ;\n");
+		grammarBuilder.append("A : ~'b' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("x\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNotCharSet() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(59);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {console.log($A.text);} ;\n");
+		grammarBuilder.append("A : ~('b'|'c') ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("x\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNotCharSetWithLabel() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(61);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {console.log($A.text);} ;\n");
+		grammarBuilder.append("A : h=~('b'|'c') ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("x\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNotCharSetWithRuleRef3() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(125);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {console.log($A.text);} ;\n");
+		grammarBuilder.append("A : ('a'|B) ;  // this doesn't collapse to set but works\n");
+		grammarBuilder.append("fragment\n");
+		grammarBuilder.append("B : ~('a'|'c') ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("x\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testOptionalLexerSingleElement() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(71);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {console.log(this._input.getText());} ;\n");
+		grammarBuilder.append("A : 'b'? 'c' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="bc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("bc\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testOptionalSet() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(69);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : ('a'|'b')? 'c' {console.log(this._input.getText());} ;");
+		String grammar = grammarBuilder.toString();
+		String input ="ac";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("ac\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testOptionalSingleElement() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(71);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A? 'c' {console.log(this._input.getText());} ;\n");
+		grammarBuilder.append("A : 'b' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="bc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("bc\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testParserNotSet() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(57);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : t=~('x'|'y') 'z' {console.log($t.text);} ;");
+		String grammar = grammarBuilder.toString();
+		String input ="zz";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("z\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testParserNotToken() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(63);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : ~'x' 'z' {console.log(this._input.getText());} ;");
+		String grammar = grammarBuilder.toString();
+		String input ="zz";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("zz\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testParserNotTokenWithLabel() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(51);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : t=~'x' 'z' {console.log($t.text);} ;");
+		String grammar = grammarBuilder.toString();
+		String input ="zz";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("z\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testParserSet() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(52);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : t=('x'|'y') {console.log($t.text);} ;");
+		String grammar = grammarBuilder.toString();
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("x\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPlusLexerSingleElement() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(71);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {console.log(this._input.getText());} ;\n");
+		grammarBuilder.append("A : 'b'+ 'c' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="bbbbc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("bbbbc\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPlusSet() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(69);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : ('a'|'b')+ 'c' {console.log(this._input.getText());} ;");
+		String grammar = grammarBuilder.toString();
+		String input ="abaac";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("abaac\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testRuleAsSet() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(76);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a @after {console.log(this._input.getText());} : 'a' | 'b' |'c' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("b\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSeqDoesNotBecomeSet() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(113);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : C {console.log(this._input.getText());} ;\n");
+		grammarBuilder.append("fragment A : '1' | '2';\n");
+		grammarBuilder.append("fragment B : '3' '4';\n");
+		grammarBuilder.append("C : A | B;");
+		String grammar = grammarBuilder.toString();
+		String input ="34";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("34\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testStarLexerSingleElement_1() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(71);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {console.log(this._input.getText());} ;\n");
+		grammarBuilder.append("A : 'b'* 'c' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="bbbbc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("bbbbc\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testStarLexerSingleElement_2() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(71);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {console.log(this._input.getText());} ;\n");
+		grammarBuilder.append("A : 'b'* 'c' ;");
+		String grammar = grammarBuilder.toString();
+		String input ="c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("c\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testStarSet() throws Exception {
+		mkdir(tmpdir);
+		StringBuilder grammarBuilder = new StringBuilder(69);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : ('a'|'b')* 'c' {console.log(this._input.getText());} ;");
+		String grammar = grammarBuilder.toString();
+		String input ="abaac";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer",
+		                          "TListener", "TVisitor",
+		                          "a", input, false);
+		assertEquals("abaac\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+}
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/safari/BaseTest.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/safari/BaseTest.java
new file mode 100644
index 000000000..4e043c86b
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/safari/BaseTest.java
@@ -0,0 +1,48 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2012 Terence Parr
+ *  Copyright (c) 2012 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.
+ */
+package org.antlr.v4.test.runtime.javascript.safari;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+
+/* see https://code.google.com/p/selenium/wiki/SafariDriver for instructions */
+public abstract class BaseTest extends org.antlr.v4.test.runtime.javascript.browser.BaseBrowserTest {
+
+	@BeforeClass
+	public static void initWebDriver() {
+		driver = SharedWebDriver.init();
+	}
+
+	@AfterClass
+	public static void closeWebDriver() {
+		SharedWebDriver.close();
+	}
+
+}
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/safari/SharedWebDriver.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/safari/SharedWebDriver.java
new file mode 100644
index 000000000..4e45a594b
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/javascript/safari/SharedWebDriver.java
@@ -0,0 +1,42 @@
+package org.antlr.v4.test.runtime.javascript.safari;
+
+import org.openqa.selenium.WebDriver;
+import org.openqa.selenium.safari.SafariDriver;
+
+import java.util.Timer;
+import java.util.TimerTask;
+
+public class SharedWebDriver {
+
+	static WebDriver driver;
+	static Timer timer;
+
+	public static WebDriver init() {
+		if(driver==null) {
+			System.setProperty("webdriver.safari.noinstall", "true");
+			driver = new SafariDriver();
+		} else if(timer!=null) {
+			timer.cancel();
+			timer = null;
+		}
+
+		return driver;
+	}
+
+	public static void close() {
+		if(driver!=null) {
+			if(timer!=null) {
+				timer.cancel();
+				timer = null;
+			}
+			timer = new Timer();
+			timer.schedule(new TimerTask() {
+				@Override public void run() {
+					driver.quit();
+					driver = null;
+				}
+			}, 2000); // close with delay to allow next Test to start
+		}
+	}
+
+}
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/python/BasePythonTest.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/python/BasePythonTest.java
new file mode 100644
index 000000000..ab91d9b02
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/python/BasePythonTest.java
@@ -0,0 +1,1072 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2012 Terence Parr
+ *  Copyright (c) 2012 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.
+ */
+package org.antlr.v4.test.runtime.python;
+
+import org.antlr.v4.Tool;
+import org.antlr.v4.automata.ATNFactory;
+import org.antlr.v4.automata.ATNPrinter;
+import org.antlr.v4.automata.LexerATNFactory;
+import org.antlr.v4.automata.ParserATNFactory;
+import org.antlr.v4.codegen.CodeGenerator;
+import org.antlr.v4.runtime.ANTLRInputStream;
+import org.antlr.v4.runtime.CharStream;
+import org.antlr.v4.runtime.CommonToken;
+import org.antlr.v4.runtime.CommonTokenStream;
+import org.antlr.v4.runtime.IntStream;
+import org.antlr.v4.runtime.Lexer;
+import org.antlr.v4.runtime.Parser;
+import org.antlr.v4.runtime.RuleContext;
+import org.antlr.v4.runtime.Token;
+import org.antlr.v4.runtime.TokenSource;
+import org.antlr.v4.runtime.TokenStream;
+import org.antlr.v4.runtime.WritableToken;
+import org.antlr.v4.runtime.atn.ATN;
+import org.antlr.v4.runtime.atn.ATNDeserializer;
+import org.antlr.v4.runtime.atn.ATNSerializer;
+import org.antlr.v4.runtime.atn.ATNState;
+import org.antlr.v4.runtime.atn.DecisionState;
+import org.antlr.v4.runtime.atn.LexerATNSimulator;
+import org.antlr.v4.runtime.dfa.DFA;
+import org.antlr.v4.runtime.misc.IntegerList;
+import org.antlr.v4.runtime.misc.Interval;
+import org.antlr.v4.runtime.tree.ParseTree;
+import org.antlr.v4.semantics.SemanticPipeline;
+import org.antlr.v4.test.runtime.java.ErrorQueue;
+import org.antlr.v4.tool.ANTLRMessage;
+import org.antlr.v4.tool.DOTGenerator;
+import org.antlr.v4.tool.DefaultToolListener;
+import org.antlr.v4.tool.Grammar;
+import org.antlr.v4.tool.GrammarSemanticsMessage;
+import org.antlr.v4.tool.LexerGrammar;
+import org.antlr.v4.tool.Rule;
+import org.junit.Before;
+import org.junit.rules.TestRule;
+import org.junit.rules.TestWatcher;
+import org.junit.runner.Description;
+import org.stringtemplate.v4.ST;
+import org.stringtemplate.v4.STGroup;
+import org.stringtemplate.v4.STGroupString;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+public abstract class BasePythonTest {
+	// -J-Dorg.antlr.v4.test.BaseTest.level=FINE
+	// private static final Logger LOGGER = Logger.getLogger(BaseTest.class.getName());
+	public static final String newline = System.getProperty("line.separator");
+	public static final String pathSep = System.getProperty("path.separator");
+
+	public String tmpdir = null;
+
+	/** If error during parser execution, store stderr here; can't return
+     *  stdout and stderr.  This doesn't trap errors from running antlr.
+     */
+	protected String stderrDuringParse;
+
+	@org.junit.Rule
+	public final TestRule testWatcher = new TestWatcher() {
+
+		@Override
+		protected void succeeded(Description description) {
+			// remove tmpdir if no error.
+			eraseTempPyCache();
+			eraseTempDir();
+		}
+
+	};
+
+	private String getPropertyPrefix() {
+		return "antlr-" + getLanguage().toLowerCase();
+	}
+
+    @Before
+	public void setUp() throws Exception {
+        // new output dir for each test
+    	String propName = getPropertyPrefix() + "-test-dir";
+    	String prop = System.getProperty(propName);
+    	if(prop!=null && prop.length()>0)
+    		tmpdir = prop;
+    	else
+    		tmpdir = new File(System.getProperty("java.io.tmpdir"), getClass().getSimpleName()+"-"+System.currentTimeMillis()).getAbsolutePath();
+    }
+
+    protected org.antlr.v4.Tool newTool(String[] args) {
+		Tool tool = new Tool(args);
+		return tool;
+	}
+
+	protected Tool newTool() {
+		org.antlr.v4.Tool tool = new Tool(new String[] {"-o", tmpdir});
+		return tool;
+	}
+
+	protected ATN createATN(Grammar g, boolean useSerializer) {
+		if ( g.atn==null ) {
+			semanticProcess(g);
+			assertEquals(0, g.tool.getNumErrors());
+
+			ParserATNFactory f;
+			if ( g.isLexer() ) {
+				f = new LexerATNFactory((LexerGrammar)g);
+			}
+			else {
+				f = new ParserATNFactory(g);
+			}
+
+			g.atn = f.createATN();
+			assertEquals(0, g.tool.getNumErrors());
+		}
+
+		ATN atn = g.atn;
+		if (useSerializer) {
+			char[] serialized = ATNSerializer.getSerializedAsChars(atn);
+			return new ATNDeserializer().deserialize(serialized);
+		}
+
+		return atn;
+	}
+
+	protected void semanticProcess(Grammar g) {
+		if ( g.ast!=null && !g.ast.hasErrors ) {
+			System.out.println(g.ast.toStringTree());
+			Tool antlr = new Tool();
+			SemanticPipeline sem = new SemanticPipeline(g);
+			sem.process();
+			if ( g.getImportedGrammars()!=null ) { // process imported grammars (if any)
+				for (Grammar imp : g.getImportedGrammars()) {
+					antlr.processNonCombinedGrammar(imp, false);
+				}
+			}
+		}
+	}
+
+	public DFA createDFA(Grammar g, DecisionState s) {
+//		PredictionDFAFactory conv = new PredictionDFAFactory(g, s);
+//		DFA dfa = conv.createDFA();
+//		conv.issueAmbiguityWarnings();
+//		System.out.print("DFA="+dfa);
+//		return dfa;
+		return null;
+	}
+
+//	public void minimizeDFA(DFA dfa) {
+//		DFAMinimizer dmin = new DFAMinimizer(dfa);
+//		dfa.minimized = dmin.minimize();
+//	}
+
+	IntegerList getTypesFromString(Grammar g, String expecting) {
+		IntegerList expectingTokenTypes = new IntegerList();
+		if ( expecting!=null && !expecting.trim().isEmpty() ) {
+			for (String tname : expecting.replace(" ", "").split(",")) {
+				int ttype = g.getTokenType(tname);
+				expectingTokenTypes.add(ttype);
+			}
+		}
+		return expectingTokenTypes;
+	}
+
+	public IntegerList getTokenTypesViaATN(String input, LexerATNSimulator lexerATN) {
+		ANTLRInputStream in = new ANTLRInputStream(input);
+		IntegerList tokenTypes = new IntegerList();
+		int ttype;
+		do {
+			ttype = lexerATN.match(in, Lexer.DEFAULT_MODE);
+			tokenTypes.add(ttype);
+		} while ( ttype!= Token.EOF );
+		return tokenTypes;
+	}
+
+	public List<String> getTokenTypes(LexerGrammar lg,
+									  ATN atn,
+									  CharStream input)
+	{
+		LexerATNSimulator interp = new LexerATNSimulator(atn,new DFA[] { new DFA(atn.modeToStartState.get(Lexer.DEFAULT_MODE)) },null);
+		List<String> tokenTypes = new ArrayList<String>();
+		int ttype;
+		boolean hitEOF = false;
+		do {
+			if ( hitEOF ) {
+				tokenTypes.add("EOF");
+				break;
+			}
+			int t = input.LA(1);
+			ttype = interp.match(input, Lexer.DEFAULT_MODE);
+			if ( ttype == Token.EOF ) {
+				tokenTypes.add("EOF");
+			}
+			else {
+				tokenTypes.add(lg.typeToTokenList.get(ttype));
+			}
+
+			if ( t== IntStream.EOF ) {
+				hitEOF = true;
+			}
+		} while ( ttype!=Token.EOF );
+		return tokenTypes;
+	}
+
+	List<ANTLRMessage> checkRuleDFA(String gtext, String ruleName, String expecting)
+		throws Exception
+	{
+		ErrorQueue equeue = new ErrorQueue();
+		Grammar g = new Grammar(gtext, equeue);
+		ATN atn = createATN(g, false);
+		ATNState s = atn.ruleToStartState[g.getRule(ruleName).index];
+		if ( s==null ) {
+			System.err.println("no such rule: "+ruleName);
+			return null;
+		}
+		ATNState t = s.transition(0).target;
+		if ( !(t instanceof DecisionState) ) {
+			System.out.println(ruleName+" has no decision");
+			return null;
+		}
+		DecisionState blk = (DecisionState)t;
+		checkRuleDFA(g, blk, expecting);
+		return equeue.all;
+	}
+
+	List<ANTLRMessage> checkRuleDFA(String gtext, int decision, String expecting)
+		throws Exception
+	{
+		ErrorQueue equeue = new ErrorQueue();
+		Grammar g = new Grammar(gtext, equeue);
+		ATN atn = createATN(g, false);
+		DecisionState blk = atn.decisionToState.get(decision);
+		checkRuleDFA(g, blk, expecting);
+		return equeue.all;
+	}
+
+	void checkRuleDFA(Grammar g, DecisionState blk, String expecting)
+		throws Exception
+	{
+		DFA dfa = createDFA(g, blk);
+		String result = null;
+		if ( dfa!=null ) result = dfa.toString();
+		assertEquals(expecting, result);
+	}
+
+	List<ANTLRMessage> checkLexerDFA(String gtext, String expecting)
+		throws Exception
+	{
+		return checkLexerDFA(gtext, LexerGrammar.DEFAULT_MODE_NAME, expecting);
+	}
+
+	List<ANTLRMessage> checkLexerDFA(String gtext, String modeName, String expecting)
+		throws Exception
+	{
+		ErrorQueue equeue = new ErrorQueue();
+		LexerGrammar g = new LexerGrammar(gtext, equeue);
+		g.atn = createATN(g, false);
+//		LexerATNToDFAConverter conv = new LexerATNToDFAConverter(g);
+//		DFA dfa = conv.createDFA(modeName);
+//		g.setLookaheadDFA(0, dfa); // only one decision to worry about
+//
+//		String result = null;
+//		if ( dfa!=null ) result = dfa.toString();
+//		assertEquals(expecting, result);
+//
+//		return equeue.all;
+		return null;
+	}
+
+	protected abstract String getLanguage();
+
+	/** Return true if all is ok, no errors */
+	protected ErrorQueue antlr(String fileName, String grammarFileName, String grammarStr, boolean defaultListener, String... extraOptions) {
+		System.out.println("dir "+tmpdir);
+		mkdir(tmpdir);
+		writeFile(tmpdir, fileName, grammarStr);
+		final List<String> options = new ArrayList<String>();
+		Collections.addAll(options, extraOptions);
+		options.add("-Dlanguage=" + getLanguage());
+		options.add("-o");
+		options.add(tmpdir);
+		options.add("-lib");
+		options.add(tmpdir);
+		options.add(new File(tmpdir,grammarFileName).toString());
+
+		final String[] optionsA = new String[options.size()];
+		options.toArray(optionsA);
+		Tool antlr = newTool(optionsA);
+		ErrorQueue equeue = new ErrorQueue(antlr);
+		antlr.addListener(equeue);
+		if (defaultListener) {
+			antlr.addListener(new DefaultToolListener(antlr));
+		}
+		antlr.processGrammarsOnCommandLine();
+
+		if ( !defaultListener && !equeue.errors.isEmpty() ) {
+			System.err.println("antlr reports errors from "+options);
+			for (int i = 0; i < equeue.errors.size(); i++) {
+				ANTLRMessage msg = equeue.errors.get(i);
+				System.err.println(msg);
+			}
+			System.out.println("!!!\ngrammar:");
+			System.out.println(grammarStr);
+			System.out.println("###");
+		}
+		if ( !defaultListener && !equeue.warnings.isEmpty() ) {
+			System.err.println("antlr reports warnings from "+options);
+			for (int i = 0; i < equeue.warnings.size(); i++) {
+				ANTLRMessage msg = equeue.warnings.get(i);
+				System.err.println(msg);
+			}
+		}
+
+		return equeue;
+	}
+
+	protected String execLexer(String grammarFileName,
+							   String grammarStr,
+							   String lexerName,
+							   String input)
+	{
+		return execLexer(grammarFileName, grammarStr, lexerName, input, false);
+	}
+
+	protected String execLexer(String grammarFileName,
+							   String grammarStr,
+							   String lexerName,
+							   String input,
+							   boolean showDFA)
+	{
+		boolean success = rawGenerateAndBuildRecognizer(grammarFileName,
+									  grammarStr,
+									  null,
+									  lexerName,"-no-listener");
+		assertTrue(success);
+		writeFile(tmpdir, "input", input);
+		writeLexerTestFile(lexerName, showDFA);
+		String output = execModule("Test.py");
+		if ( stderrDuringParse!=null && stderrDuringParse.length()>0 ) {
+			System.err.println(stderrDuringParse);
+		}
+		return output;
+	}
+
+	public ParseTree execStartRule(String startRuleName, Parser parser)
+		throws IllegalAccessException, InvocationTargetException,
+			   NoSuchMethodException
+	{
+		Method startRule = null;
+		Object[] args = null;
+		try {
+			startRule = parser.getClass().getMethod(startRuleName);
+		}
+		catch (NoSuchMethodException nsme) {
+			// try with int _p arg for recursive func
+			startRule = parser.getClass().getMethod(startRuleName, int.class);
+			args = new Integer[] {0};
+		}
+		ParseTree result = (ParseTree)startRule.invoke(parser, args);
+//		System.out.println("parse tree = "+result.toStringTree(parser));
+		return result;
+	}
+
+	protected String execParser(String grammarFileName,
+			String grammarStr,
+			String parserName,
+			String lexerName,
+			String listenerName,
+			String visitorName,
+			String startRuleName,
+			String input,
+			boolean debug) {
+		return execParser(grammarFileName, grammarStr, parserName, lexerName,
+				listenerName, visitorName, startRuleName, input, debug, false);
+	}
+
+	protected String execParser(String grammarFileName,
+								String grammarStr,
+								String parserName,
+								String lexerName,
+								String listenerName,
+								String visitorName,
+								String startRuleName,
+								String input,
+								boolean debug,
+								boolean trace)
+	{
+		boolean success = rawGenerateAndBuildRecognizer(grammarFileName,
+														grammarStr,
+														parserName,
+														lexerName,
+														"-visitor");
+		assertTrue(success);
+		writeFile(tmpdir, "input", input);
+		rawBuildRecognizerTestFile(parserName,
+								 lexerName,
+								 listenerName,
+								 visitorName,
+								 startRuleName,
+								 debug,
+								 trace);
+		return execRecognizer();
+	}
+
+	/** Return true if all is well */
+	protected boolean rawGenerateAndBuildRecognizer(String grammarFileName,
+													String grammarStr,
+													String parserName,
+													String lexerName,
+													String... extraOptions)
+	{
+		return rawGenerateAndBuildRecognizer(grammarFileName, grammarStr, parserName, lexerName, false, extraOptions);
+	}
+
+	/** Return true if all is well */
+	protected boolean rawGenerateAndBuildRecognizer(String grammarFileName,
+													String grammarStr,
+													String parserName,
+													String lexerName,
+													boolean defaultListener,
+													String... extraOptions)
+	{
+		ErrorQueue equeue =
+			antlr(grammarFileName, grammarFileName, grammarStr, defaultListener, extraOptions);
+		if (!equeue.errors.isEmpty()) {
+			return false;
+		}
+
+		List<String> files = new ArrayList<String>();
+		if ( lexerName!=null ) {
+			files.add(lexerName+".py");
+		}
+		if ( parserName!=null ) {
+			files.add(parserName+".py");
+			Set<String> optionsSet = new HashSet<String>(Arrays.asList(extraOptions));
+			if (!optionsSet.contains("-no-listener")) {
+				files.add(grammarFileName.substring(0, grammarFileName.lastIndexOf('.'))+"Listener.py");
+			}
+			if (optionsSet.contains("-visitor")) {
+				files.add(grammarFileName.substring(0, grammarFileName.lastIndexOf('.'))+"Visitor.py");
+			}
+		}
+		return true; // allIsWell: no compile
+	}
+
+	protected void rawBuildRecognizerTestFile(String parserName,
+									   String lexerName,
+									   String listenerName,
+									   String visitorName,
+									   String parserStartRuleName,
+									   boolean debug,
+									   boolean trace)
+	{
+        this.stderrDuringParse = null;
+		if ( parserName==null ) {
+			writeLexerTestFile(lexerName, false);
+		}
+		else {
+			writeParserTestFile(parserName,
+						  lexerName,
+						  listenerName,
+						  visitorName,
+						  parserStartRuleName,
+						  debug, trace);
+		}
+	}
+
+	public String execRecognizer() {
+		return execModule("Test.py");
+	}
+
+	public String execModule(String fileName) {
+		String pythonPath = locatePython();
+		String runtimePath = locateRuntime();
+		String modulePath = new File(new File(tmpdir), fileName).getAbsolutePath();
+		String inputPath = new File(new File(tmpdir), "input").getAbsolutePath();
+		try {
+			ProcessBuilder builder = new ProcessBuilder( pythonPath, modulePath, inputPath );
+			builder.environment().put("PYTHONPATH",runtimePath);
+			builder.directory(new File(tmpdir));
+			Process process = builder.start();
+			StreamVacuum stdoutVacuum = new StreamVacuum(process.getInputStream());
+			StreamVacuum stderrVacuum = new StreamVacuum(process.getErrorStream());
+			stdoutVacuum.start();
+			stderrVacuum.start();
+			process.waitFor();
+			stdoutVacuum.join();
+			stderrVacuum.join();
+			String output = stdoutVacuum.toString();
+			if ( stderrVacuum.toString().length()>0 ) {
+				this.stderrDuringParse = stderrVacuum.toString();
+				System.err.println("exec stderrVacuum: "+ stderrVacuum);
+			}
+			return output;
+		}
+		catch (Exception e) {
+			System.err.println("can't exec recognizer");
+			e.printStackTrace(System.err);
+		}
+		return null;
+	}
+
+	private String locateTool(String tool) {
+		String[] roots = { "/usr/bin/", "/usr/local/bin/" };
+		for(String root : roots) {
+			if(new File(root + tool).exists())
+				return root + tool;
+		}
+		throw new RuntimeException("Could not locate " + tool);
+	}
+
+	protected String locatePython() {
+		String propName = getPropertyPrefix() + "-python";
+    	String prop = System.getProperty(propName);
+    	if(prop==null || prop.length()==0)
+    		prop = locateTool(getPythonExecutable());
+		File file = new File(prop);
+		if(!file.exists())
+			throw new RuntimeException("Missing system property:" + propName);
+		return file.getAbsolutePath();
+	}
+
+	protected abstract String getPythonExecutable();
+
+	protected String locateRuntime() { return locateRuntime(getLanguage()); }
+
+	protected String locateRuntime(String targetName) {
+		final ClassLoader loader = Thread.currentThread().getContextClassLoader();
+		final URL runtimeSrc = loader.getResource(targetName+"/src");
+		if ( runtimeSrc==null ) {
+			throw new RuntimeException("Cannot find "+targetName+" runtime");
+		}
+		return runtimeSrc.getPath();
+	}
+
+	public void testErrors(String[] pairs, boolean printTree) {
+        for (int i = 0; i < pairs.length; i+=2) {
+            String input = pairs[i];
+            String expect = pairs[i+1];
+
+			String[] lines = input.split("\n");
+			String fileName = getFilenameFromFirstLineOfGrammar(lines[0]);
+			ErrorQueue equeue = antlr(fileName, fileName, input, false);
+
+			String actual = equeue.toString(true);
+			actual = actual.replace(tmpdir + File.separator, "");
+			System.err.println(actual);
+			String msg = input;
+			msg = msg.replace("\n","\\n");
+			msg = msg.replace("\r","\\r");
+			msg = msg.replace("\t","\\t");
+
+            assertEquals("error in: "+msg,expect,actual);
+        }
+    }
+
+	public String getFilenameFromFirstLineOfGrammar(String line) {
+		String fileName = "A" + Tool.GRAMMAR_EXTENSION;
+		int grIndex = line.lastIndexOf("grammar");
+		int semi = line.lastIndexOf(';');
+		if ( grIndex>=0 && semi>=0 ) {
+			int space = line.indexOf(' ', grIndex);
+			fileName = line.substring(space+1, semi)+Tool.GRAMMAR_EXTENSION;
+		}
+		if ( fileName.length()==Tool.GRAMMAR_EXTENSION.length() ) fileName = "A" + Tool.GRAMMAR_EXTENSION;
+		return fileName;
+	}
+
+//	void ambig(List<Message> msgs, int[] expectedAmbigAlts, String expectedAmbigInput)
+//		throws Exception
+//	{
+//		ambig(msgs, 0, expectedAmbigAlts, expectedAmbigInput);
+//	}
+
+//	void ambig(List<Message> msgs, int i, int[] expectedAmbigAlts, String expectedAmbigInput)
+//		throws Exception
+//	{
+//		List<Message> amsgs = getMessagesOfType(msgs, AmbiguityMessage.class);
+//		AmbiguityMessage a = (AmbiguityMessage)amsgs.get(i);
+//		if ( a==null ) assertNull(expectedAmbigAlts);
+//		else {
+//			assertEquals(a.conflictingAlts.toString(), Arrays.toString(expectedAmbigAlts));
+//		}
+//		assertEquals(expectedAmbigInput, a.input);
+//	}
+
+//	void unreachable(List<Message> msgs, int[] expectedUnreachableAlts)
+//		throws Exception
+//	{
+//		unreachable(msgs, 0, expectedUnreachableAlts);
+//	}
+
+//	void unreachable(List<Message> msgs, int i, int[] expectedUnreachableAlts)
+//		throws Exception
+//	{
+//		List<Message> amsgs = getMessagesOfType(msgs, UnreachableAltsMessage.class);
+//		UnreachableAltsMessage u = (UnreachableAltsMessage)amsgs.get(i);
+//		if ( u==null ) assertNull(expectedUnreachableAlts);
+//		else {
+//			assertEquals(u.conflictingAlts.toString(), Arrays.toString(expectedUnreachableAlts));
+//		}
+//	}
+
+	List<ANTLRMessage> getMessagesOfType(List<ANTLRMessage> msgs, Class<? extends ANTLRMessage> c) {
+		List<ANTLRMessage> filtered = new ArrayList<ANTLRMessage>();
+		for (ANTLRMessage m : msgs) {
+			if ( m.getClass() == c ) filtered.add(m);
+		}
+		return filtered;
+	}
+
+	void checkRuleATN(Grammar g, String ruleName, String expecting) {
+		ParserATNFactory f = new ParserATNFactory(g);
+		ATN atn = f.createATN();
+
+		DOTGenerator dot = new DOTGenerator(g);
+		System.out.println(dot.getDOT(atn.ruleToStartState[g.getRule(ruleName).index]));
+
+		Rule r = g.getRule(ruleName);
+		ATNState startState = atn.ruleToStartState[r.index];
+		ATNPrinter serializer = new ATNPrinter(g, startState);
+		String result = serializer.asString();
+
+		//System.out.print(result);
+		assertEquals(expecting, result);
+	}
+
+	public void testActions(String templates, String actionName, String action, String expected) throws org.antlr.runtime.RecognitionException {
+		int lp = templates.indexOf('(');
+		String name = templates.substring(0, lp);
+		STGroup group = new STGroupString(templates);
+		ST st = group.getInstanceOf(name);
+		st.add(actionName, action);
+		String grammar = st.render();
+		ErrorQueue equeue = new ErrorQueue();
+		Grammar g = new Grammar(grammar, equeue);
+		if ( g.ast!=null && !g.ast.hasErrors ) {
+			SemanticPipeline sem = new SemanticPipeline(g);
+			sem.process();
+
+			ATNFactory factory = new ParserATNFactory(g);
+			if ( g.isLexer() ) factory = new LexerATNFactory((LexerGrammar)g);
+			g.atn = factory.createATN();
+
+			CodeGenerator gen = new CodeGenerator(g);
+			ST outputFileST = gen.generateParser();
+			String output = outputFileST.render();
+			//System.out.println(output);
+			String b = "#" + actionName + "#";
+			int start = output.indexOf(b);
+			String e = "#end-" + actionName + "#";
+			int end = output.indexOf(e);
+			String snippet = output.substring(start+b.length(),end);
+			assertEquals(expected, snippet);
+		}
+		if ( equeue.size()>0 ) {
+			System.err.println(equeue.toString());
+		}
+	}
+
+	public static class StreamVacuum implements Runnable {
+		StringBuilder buf = new StringBuilder();
+		BufferedReader in;
+		Thread sucker;
+		public StreamVacuum(InputStream in) {
+			this.in = new BufferedReader( new InputStreamReader(in) );
+		}
+		public void start() {
+			sucker = new Thread(this);
+			sucker.start();
+		}
+		@Override
+		public void run() {
+			try {
+				String line = in.readLine();
+				while (line!=null) {
+					buf.append(line);
+					buf.append('\n');
+					line = in.readLine();
+				}
+			}
+			catch (IOException ioe) {
+				System.err.println("can't read output from process");
+			}
+		}
+		/** wait for the thread to finish */
+		public void join() throws InterruptedException {
+			sucker.join();
+		}
+		@Override
+		public String toString() {
+			return buf.toString();
+		}
+	}
+
+	protected void checkGrammarSemanticsError(ErrorQueue equeue,
+											  GrammarSemanticsMessage expectedMessage)
+		throws Exception
+	{
+		ANTLRMessage foundMsg = null;
+		for (int i = 0; i < equeue.errors.size(); i++) {
+			ANTLRMessage m = equeue.errors.get(i);
+			if (m.getErrorType()==expectedMessage.getErrorType() ) {
+				foundMsg = m;
+			}
+		}
+		assertNotNull("no error; "+expectedMessage.getErrorType()+" expected", foundMsg);
+		assertTrue("error is not a GrammarSemanticsMessage",
+				   foundMsg instanceof GrammarSemanticsMessage);
+		assertEquals(Arrays.toString(expectedMessage.getArgs()), Arrays.toString(foundMsg.getArgs()));
+		if ( equeue.size()!=1 ) {
+			System.err.println(equeue);
+		}
+	}
+
+	protected void checkGrammarSemanticsWarning(ErrorQueue equeue,
+											    GrammarSemanticsMessage expectedMessage)
+		throws Exception
+	{
+		ANTLRMessage foundMsg = null;
+		for (int i = 0; i < equeue.warnings.size(); i++) {
+			ANTLRMessage m = equeue.warnings.get(i);
+			if (m.getErrorType()==expectedMessage.getErrorType() ) {
+				foundMsg = m;
+			}
+		}
+		assertNotNull("no error; "+expectedMessage.getErrorType()+" expected", foundMsg);
+		assertTrue("error is not a GrammarSemanticsMessage",
+				   foundMsg instanceof GrammarSemanticsMessage);
+		assertEquals(Arrays.toString(expectedMessage.getArgs()), Arrays.toString(foundMsg.getArgs()));
+		if ( equeue.size()!=1 ) {
+			System.err.println(equeue);
+		}
+	}
+
+	protected void checkError(ErrorQueue equeue,
+							  ANTLRMessage expectedMessage)
+		throws Exception
+	{
+		//System.out.println("errors="+equeue);
+		ANTLRMessage foundMsg = null;
+		for (int i = 0; i < equeue.errors.size(); i++) {
+			ANTLRMessage m = equeue.errors.get(i);
+			if (m.getErrorType()==expectedMessage.getErrorType() ) {
+				foundMsg = m;
+			}
+		}
+		assertTrue("no error; "+expectedMessage.getErrorType()+" expected", !equeue.errors.isEmpty());
+		assertTrue("too many errors; "+equeue.errors, equeue.errors.size()<=1);
+		assertNotNull("couldn't find expected error: "+expectedMessage.getErrorType(), foundMsg);
+		/*
+		assertTrue("error is not a GrammarSemanticsMessage",
+				   foundMsg instanceof GrammarSemanticsMessage);
+		 */
+		assertArrayEquals(expectedMessage.getArgs(), foundMsg.getArgs());
+	}
+
+    public static class FilteringTokenStream extends CommonTokenStream {
+        public FilteringTokenStream(TokenSource src) { super(src); }
+        Set<Integer> hide = new HashSet<Integer>();
+        @Override
+        protected boolean sync(int i) {
+            if (!super.sync(i)) {
+				return false;
+			}
+
+			Token t = get(i);
+			if ( hide.contains(t.getType()) ) {
+				((WritableToken)t).setChannel(Token.HIDDEN_CHANNEL);
+			}
+
+			return true;
+        }
+        public void setTokenTypeChannel(int ttype, int channel) {
+            hide.add(ttype);
+        }
+    }
+
+	public static void writeFile(String dir, String fileName, String content) {
+		try {
+			File f = new File(dir, fileName);
+			FileWriter w = new FileWriter(f);
+			BufferedWriter bw = new BufferedWriter(w);
+			bw.write(content);
+			bw.close();
+			w.close();
+		}
+		catch (IOException ioe) {
+			System.err.println("can't write file");
+			ioe.printStackTrace(System.err);
+		}
+	}
+
+	protected void mkdir(String dir) {
+		File f = new File(dir);
+		f.mkdirs();
+	}
+
+	protected abstract void writeParserTestFile(String parserName,
+			 String lexerName,
+			 String listenerName,
+			 String visitorName,
+			 String parserStartRuleName,
+			 boolean debug,
+			 boolean setTrace);
+
+
+
+	protected abstract void writeLexerTestFile(String lexerName, boolean showDFA);
+
+	public void writeRecognizer(String parserName, String lexerName,
+								String listenerName, String visitorName,
+								String parserStartRuleName, boolean debug, boolean trace) {
+		if ( parserName==null ) {
+			writeLexerTestFile(lexerName, debug);
+		}
+		else {
+			writeParserTestFile(parserName,
+						  lexerName,
+						  listenerName,
+						  visitorName,
+						  parserStartRuleName,
+						  debug,
+						  trace);
+		}
+	}
+
+
+    protected void eraseFiles(final String filesEndingWith) {
+        File tmpdirF = new File(tmpdir);
+        String[] files = tmpdirF.list();
+        for(int i = 0; files!=null && i < files.length; i++) {
+            if ( files[i].endsWith(filesEndingWith) ) {
+                new File(tmpdir+"/"+files[i]).delete();
+            }
+        }
+    }
+
+    protected void eraseFiles(File dir) {
+       String[] files = dir.list();
+        for(int i = 0; files!=null && i < files.length; i++) {
+            new File(dir,files[i]).delete();
+        }
+    }
+
+    protected void eraseTempDir() {
+    	boolean doErase = true;
+    	String propName = getPropertyPrefix() + "-erase-test-dir";
+    	String prop = System.getProperty(propName);
+    	if(prop!=null && prop.length()>0)
+    		doErase = Boolean.getBoolean(prop);
+        if(doErase) {
+        	File tmpdirF = new File(tmpdir);
+	        if ( tmpdirF.exists() ) {
+	            eraseFiles(tmpdirF);
+	            tmpdirF.delete();
+	        }
+        }
+    }
+
+    protected void eraseTempPyCache() {
+        File tmpdirF = new File(tmpdir+"/__pycache__");
+        if ( tmpdirF.exists() ) {
+            eraseFiles(tmpdirF);
+            tmpdirF.delete();
+        }
+    }
+
+    public String getFirstLineOfException() {
+		if ( this.stderrDuringParse ==null ) {
+			return null;
+		}
+		String[] lines = this.stderrDuringParse.split("\n");
+		String prefix="Exception in thread \"main\" ";
+		return lines[0].substring(prefix.length(),lines[0].length());
+	}
+
+    /**
+     * When looking at a result set that consists of a Map/HashTable
+     * we cannot rely on the output order, as the hashing algorithm or other aspects
+     * of the implementation may be different on differnt JDKs or platforms. Hence
+     * we take the Map, convert the keys to a List, sort them and Stringify the Map, which is a
+     * bit of a hack, but guarantees that we get the same order on all systems. We assume that
+     * the keys are strings.
+     *
+     * @param m The Map that contains keys we wish to return in sorted order
+     * @return A string that represents all the keys in sorted order.
+     */
+    public <K, V> String sortMapToString(Map<K, V> m) {
+        // Pass in crap, and get nothing back
+        //
+        if  (m == null) {
+            return null;
+        }
+
+        System.out.println("Map toString looks like: " + m.toString());
+
+        // Sort the keys in the Map
+        //
+        TreeMap<K, V> nset = new TreeMap<K, V>(m);
+
+        System.out.println("Tree map looks like: " + nset.toString());
+        return nset.toString();
+    }
+
+	public List<String> realElements(List<String> elements) {
+		return elements.subList(Token.MIN_USER_TOKEN_TYPE, elements.size());
+	}
+
+	public void assertNotNullOrEmpty(String message, String text) {
+		assertNotNull(message, text);
+		assertFalse(message, text.isEmpty());
+	}
+
+	public void assertNotNullOrEmpty(String text) {
+		assertNotNull(text);
+		assertFalse(text.isEmpty());
+	}
+
+	public static class IntTokenStream implements TokenStream {
+		IntegerList types;
+		int p=0;
+		public IntTokenStream(IntegerList types) { this.types = types; }
+
+		@Override
+		public void consume() { p++; }
+
+		@Override
+		public int LA(int i) { return LT(i).getType(); }
+
+		@Override
+		public int mark() {
+			return index();
+		}
+
+		@Override
+		public int index() { return p; }
+
+		@Override
+		public void release(int marker) {
+			seek(marker);
+		}
+
+		@Override
+		public void seek(int index) {
+			p = index;
+		}
+
+		@Override
+		public int size() {
+			return types.size();
+		}
+
+		@Override
+		public String getSourceName() {
+			return null;
+		}
+
+		@Override
+		public Token LT(int i) {
+			CommonToken t;
+			int rawIndex = p + i - 1;
+			if ( rawIndex>=types.size() ) t = new CommonToken(Token.EOF);
+			else t = new CommonToken(types.get(rawIndex));
+			t.setTokenIndex(rawIndex);
+			return t;
+		}
+
+		@Override
+		public Token get(int i) {
+			return new org.antlr.v4.runtime.CommonToken(types.get(i));
+		}
+
+		@Override
+		public TokenSource getTokenSource() {
+			return null;
+		}
+
+		@Override
+		public String getText() {
+			throw new UnsupportedOperationException("can't give strings");
+		}
+
+		@Override
+		public String getText(Interval interval) {
+			throw new UnsupportedOperationException("can't give strings");
+		}
+
+		@Override
+		public String getText(RuleContext ctx) {
+			throw new UnsupportedOperationException("can't give strings");
+		}
+
+		@Override
+		public String getText(Token start, Token stop) {
+			throw new UnsupportedOperationException("can't give strings");
+		}
+	}
+
+	/** Sort a list */
+	public <T extends Comparable<? super T>> List<T> sort(List<T> data) {
+		List<T> dup = new ArrayList<T>();
+		dup.addAll(data);
+		Collections.sort(dup);
+		return dup;
+	}
+
+	/** Return map sorted by key */
+	public <K extends Comparable<? super K>,V> LinkedHashMap<K,V> sort(Map<K,V> data) {
+		LinkedHashMap<K,V> dup = new LinkedHashMap<K, V>();
+		List<K> keys = new ArrayList<K>();
+		keys.addAll(data.keySet());
+		Collections.sort(keys);
+		for (K k : keys) {
+			dup.put(k, data.get(k));
+		}
+		return dup;
+	}
+}
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/python2/BasePython2Test.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/python2/BasePython2Test.java
new file mode 100644
index 000000000..d461d8040
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/python2/BasePython2Test.java
@@ -0,0 +1,94 @@
+package org.antlr.v4.test.runtime.python2;
+
+import org.antlr.v4.test.runtime.python.BasePythonTest;
+import org.stringtemplate.v4.ST;
+
+public abstract class BasePython2Test extends BasePythonTest {
+
+	@Override
+	protected String getLanguage() {
+		return "Python2";
+	}
+
+	@Override
+	protected String getPythonExecutable() {
+		return "python2.7";
+	}
+
+	@Override
+	protected void writeLexerTestFile(String lexerName, boolean showDFA) {
+		ST outputFileST = new ST(
+				"from __future__ import print_function\n"
+						+ "import sys\n"
+						+ "from antlr4 import *\n"
+						+ "from <lexerName> import <lexerName>\n"
+						+ "\n"
+						+ "def main(argv):\n"
+						+ "    input = FileStream(argv[1])\n"
+						+ "    lexer = <lexerName>(input)\n"
+						+ "    stream = CommonTokenStream(lexer)\n"
+						+ "    stream.fill()\n"
+						+ "    [ print(str(t)) for t in stream.tokens ]\n"
+						+ (showDFA ? "    print(lexer._interp.decisionToDFA[Lexer.DEFAULT_MODE].toLexerString(), end='')\n"
+								: "") + "\n" + "if __name__ == '__main__':\n"
+						+ "    main(sys.argv)\n" + "\n");
+		outputFileST.add("lexerName", lexerName);
+		writeFile(tmpdir, "Test.py", outputFileST.render());
+	}
+
+	@Override
+	protected void writeParserTestFile(String parserName, String lexerName,
+			String listenerName, String visitorName,
+			String parserStartRuleName, boolean debug, boolean trace) {
+		if(!parserStartRuleName.endsWith(")"))
+			parserStartRuleName += "()";
+		ST outputFileST = new ST(
+				"import sys\n"
+						+ "from antlr4 import *\n"
+						+ "from <lexerName> import <lexerName>\n"
+						+ "from <parserName> import <parserName>\n"
+						+ "from <listenerName> import <listenerName>\n"
+						+ "from <visitorName> import <visitorName>\n"
+						+ "\n"
+						+ "class TreeShapeListener(ParseTreeListener):\n"
+						+ "\n"
+						+ "    def visitTerminal(self, node):\n"
+						+ "        pass\n"
+						+ "\n"
+						+ "    def visitErrorNode(self, node):\n"
+						+ "        pass\n"
+						+ "\n"
+						+ "    def exitEveryRule(self, ctx):\n"
+						+ "        pass\n"
+						+ "\n"
+						+ "    def enterEveryRule(self, ctx):\n"
+						+ "        for child in ctx.getChildren():\n"
+						+ "            parent = child.parentCtx\n"
+						+ "            if not isinstance(parent, RuleNode) or parent.getRuleContext() != ctx:\n"
+						+ "                raise IllegalStateException(\"Invalid parse tree shape detected.\")\n"
+						+ "\n"
+						+ "def main(argv):\n"
+						+ "    input = FileStream(argv[1])\n"
+						+ "    lexer = <lexerName>(input)\n"
+						+ "    stream = CommonTokenStream(lexer)\n"
+						+ "<createParser>"
+						+ "    parser.buildParseTrees = True\n"
+						+ "    tree = parser.<parserStartRuleName>\n"
+						+ "    ParseTreeWalker.DEFAULT.walk(TreeShapeListener(), tree)\n"
+						+ "\n" + "if __name__ == '__main__':\n"
+						+ "    main(sys.argv)\n" + "\n");
+		String stSource = "    parser = <parserName>(stream)\n";
+		if(debug)
+			stSource += "    parser.addErrorListener(DiagnosticErrorListener())\n";
+		if(trace)
+			stSource += "    parser.setTrace(True)\n";
+		ST createParserST = new ST(stSource);
+		outputFileST.add("createParser", createParserST);
+		outputFileST.add("parserName", parserName);
+		outputFileST.add("lexerName", lexerName);
+		outputFileST.add("listenerName", listenerName);
+		outputFileST.add("visitorName", visitorName);
+		outputFileST.add("parserStartRuleName", parserStartRuleName);
+		writeFile(tmpdir, "Test.py", outputFileST.render());
+	}
+}
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/python2/TestCompositeLexers.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/python2/TestCompositeLexers.java
new file mode 100644
index 000000000..f636cc079
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/python2/TestCompositeLexers.java
@@ -0,0 +1,70 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.python2;
+
+import org.junit.Ignore;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+@SuppressWarnings("unused")
+public class TestCompositeLexers extends BasePython2Test {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLexerDelegatorInvokesDelegateRule() throws Exception {
+		mkdir(tmpdir);
+
+		String slave_S =
+			"lexer grammar S;\n" +
+			"A : 'a' {print(\"S.A\")};\n" +
+			"C : 'c' ;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(61);
+		grammarBuilder.append("lexer grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("B : 'b';\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="abc";
+		String found = execLexer("M.g4", grammar, "M", input, false);
+		assertEquals(
+			"S.A\n" +
+			"[@0,0:0='a',<3>,1:0]\n" +
+			"[@1,1:1='b',<1>,1:1]\n" +
+			"[@2,2:2='c',<4>,1:2]\n" +
+			"[@3,3:2='<EOF>',<-1>,1:3]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLexerDelegatorRuleOverridesDelegate() throws Exception {
+		mkdir(tmpdir);
+
+		String slave_S =
+			"lexer grammar S;\n" +
+			"A : 'a' {print(\"S.A\")} ;\n" +
+			"B : 'b' {print(\"S.B\")} ;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(79);
+		grammarBuilder.append("lexer grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("A : 'a' B {print(\"M.A\")} ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="ab";
+		String found = execLexer("M.g4", grammar, "M", input, false);
+		assertEquals(
+			"M.A\n" +
+			"[@0,0:1='ab',<1>,1:0]\n" +
+			"[@1,2:1='<EOF>',<-1>,1:2]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+
+}
\ No newline at end of file
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/python2/TestCompositeParsers.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/python2/TestCompositeParsers.java
new file mode 100644
index 000000000..ab43c72bd
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/python2/TestCompositeParsers.java
@@ -0,0 +1,488 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.python2;
+
+import org.junit.Ignore;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+import org.antlr.v4.test.runtime.java.ErrorQueue;
+import org.antlr.v4.tool.Grammar;
+
+@SuppressWarnings("unused")
+public class TestCompositeParsers extends BasePython2Test {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testBringInLiteralsFromDelegate() throws Exception {
+		mkdir(tmpdir);
+
+		String slave_S =
+			"parser grammar S;\n" +
+			"a : '=' 'a' {print(\"S.a\",end='')};";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(54);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("s : a ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="=a";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "MListener", "MVisitor", "s", input, false);
+
+		assertEquals("S.a\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCombinedImportsCombined() throws Exception {
+		mkdir(tmpdir);
+
+		String slave_S =
+			"parser grammar S;\n" +
+			"tokens { A, B, C }\n" +
+			"x : 'x' INT {print(\"S.x\")};\n" +
+			"INT : '0'..'9'+ ;\n" +
+			"WS : (' '|'\\n') -> skip ;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(31);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("s : x INT;");
+		String grammar = grammarBuilder.toString();
+
+		writeFile(tmpdir, "M.g4", grammar);
+		ErrorQueue equeue = new ErrorQueue();
+		new Grammar(tmpdir+"/M.g4", grammar, equeue);
+		assertEquals("unexpected errors: " + equeue, 0, equeue.errors.size());
+
+
+		String input ="x 34 9";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "MListener", "MVisitor", "s", input, false);
+
+		assertEquals("S.x\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDelegatesSeeSameTokenType() throws Exception {
+		mkdir(tmpdir);
+
+		String slave_S =
+			"parser grammar S;\n" +
+			"tokens { A, B, C }\n" +
+			"x : A {print(\"S.x\")};";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		String slave_T =
+			"parser grammar T;\n" +
+			"tokens { C, B, A } // reverse order\n" +
+			"y : A {print(\"T.y\")};";
+		writeFile(tmpdir, "T.g4", slave_T);
+
+		StringBuilder grammarBuilder = new StringBuilder(598);
+		grammarBuilder.append("// The lexer will create rules to match letters a, b, c.\n");
+		grammarBuilder.append("// The associated token types A, B, C must have the same value\n");
+		grammarBuilder.append("// and all import'd parsers.  Since ANTLR regenerates all imports\n");
+		grammarBuilder.append("// for use with the delegator M, it can generate the same token type\n");
+		grammarBuilder.append("// mapping in each parser:\n");
+		grammarBuilder.append("// public static final int C=6;\n");
+		grammarBuilder.append("// public static final int EOF=-1;\n");
+		grammarBuilder.append("// public static final int B=5;\n");
+		grammarBuilder.append("// public static final int WS=7;\n");
+		grammarBuilder.append("// public static final int A=4;\n");
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S,T;\n");
+		grammarBuilder.append("s : x y ; // matches AA, which should be 'aa'\n");
+		grammarBuilder.append("B : 'b' ; // another order: B, A, C\n");
+		grammarBuilder.append("A : 'a' ; \n");
+		grammarBuilder.append("C : 'c' ; \n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+		writeFile(tmpdir, "M.g4", grammar);
+		ErrorQueue equeue = new ErrorQueue();
+		Grammar g = new Grammar(tmpdir+"/M.g4", grammar, equeue);
+		String expectedTokenIDToTypeMap = "{EOF=-1, B=1, A=2, C=3, WS=4}";
+		String expectedStringLiteralToTypeMap = "{'a'=2, 'b'=1, 'c'=3}";
+		String expectedTypeToTokenList = "[B, A, C, WS]";
+		assertEquals(expectedTokenIDToTypeMap, g.tokenNameToTypeMap.toString());
+		assertEquals(expectedStringLiteralToTypeMap, sort(g.stringLiteralToTypeMap).toString());
+		assertEquals(expectedTypeToTokenList, realElements(g.typeToTokenList).toString());
+		assertEquals("unexpected errors: "+equeue, 0, equeue.errors.size());
+
+
+		String input ="aa";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "MListener", "MVisitor", "s", input, false);
+
+		assertEquals(
+			"S.x\n" +
+			"T.y\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDelegatorAccessesDelegateMembers() throws Exception {
+		mkdir(tmpdir);
+
+		String slave_S =
+			"parser grammar S;\n" +
+			"@parser::members {\n" +
+			"def foo(self):\n" +
+			"	print('foo')\n" +
+			"}\n" +
+			"a : B;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(126);
+		grammarBuilder.append("grammar M; // uses no rules from the import\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("s : 'b' {self.foo()} ; // gS is import pointer\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="b";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "MListener", "MVisitor", "s", input, false);
+
+		assertEquals("foo\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDelegatorInvokesDelegateRule() throws Exception {
+		mkdir(tmpdir);
+
+		String slave_S =
+			"parser grammar S;\n" +
+			"a : B {print(\"S.a\")};";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(104);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("s : a ;\n");
+		grammarBuilder.append("B : 'b' ; // defines B from inherited token space\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="b";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "MListener", "MVisitor", "s", input, false);
+
+		assertEquals("S.a\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDelegatorInvokesDelegateRuleWithArgs() throws Exception {
+		mkdir(tmpdir);
+
+		String slave_S =
+			"parser grammar S;\n" +
+			"a[int x] returns [int y] : B {print(\"S.a\",end='')} {$y=1000;} ;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(131);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("s : label=a[3] {print($label.y)} ;\n");
+		grammarBuilder.append("B : 'b' ; // defines B from inherited token space\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="b";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "MListener", "MVisitor", "s", input, false);
+
+		assertEquals("S.a1000\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDelegatorInvokesDelegateRuleWithReturnStruct() throws Exception {
+		mkdir(tmpdir);
+
+		String slave_S =
+			"parser grammar S;\n" +
+			"a : B {print(\"S.a\",end='')} ;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(128);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("s : a {print($a.text,end='')} ;\n");
+		grammarBuilder.append("B : 'b' ; // defines B from inherited token space\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="b";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "MListener", "MVisitor", "s", input, false);
+
+		assertEquals("S.ab\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDelegatorInvokesFirstVersionOfDelegateRule() throws Exception {
+		mkdir(tmpdir);
+
+		String slave_S =
+			"parser grammar S;\n" +
+			"a : b {print(\"S.a\")};\n" +
+			"b : B;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		String slave_T =
+			"parser grammar T;\n" +
+			"a : B {print(\"T.a\")};";
+		writeFile(tmpdir, "T.g4", slave_T);
+
+		StringBuilder grammarBuilder = new StringBuilder(106);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S,T;\n");
+		grammarBuilder.append("s : a ;\n");
+		grammarBuilder.append("B : 'b' ; // defines B from inherited token space\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="b";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "MListener", "MVisitor", "s", input, false);
+
+		assertEquals("S.a\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDelegatorRuleOverridesDelegate() throws Exception {
+		mkdir(tmpdir);
+
+		String slave_S =
+			"parser grammar S;\n" +
+			"a : b {print(\"S.a\",end='')};\n" +
+			"b : B ;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(59);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("b : 'b'|'c';\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="c";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "MListener", "MVisitor", "a", input, false);
+
+		assertEquals("S.a\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDelegatorRuleOverridesDelegates() throws Exception {
+		mkdir(tmpdir);
+
+		String slave_S =
+			"parser grammar S;\n" +
+			"a : b {print(\"S.a\")};\n" +
+			"b : 'b' ;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		String slave_T =
+			"parser grammar T;\n" +
+			"tokens { A }\n" +
+			"b : 'b' {print(\"T.b\")};";
+		writeFile(tmpdir, "T.g4", slave_T);
+
+		StringBuilder grammarBuilder = new StringBuilder(81);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S, T;\n");
+		grammarBuilder.append("b : 'b'|'c' {print(\"M.b\")}|B|A;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="c";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "MListener", "MVisitor", "a", input, false);
+
+		assertEquals(
+			"M.b\n" +
+			"S.a\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDelegatorRuleOverridesLookaheadInDelegate() throws Exception {
+		mkdir(tmpdir);
+
+		String slave_S =
+			"parser grammar S;\n" +
+			"type_ : 'int' ;\n" +
+			"decl : type_ ID ';'\n" +
+			"	| type_ ID init ';' {print(\"JavaDecl: \" + $text,end='')};\n" +
+			"init : '=' INT;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(121);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("prog : decl ;\n");
+		grammarBuilder.append("type_ : 'int' | 'float' ;\n");
+		grammarBuilder.append("ID  : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="float x = 3;";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "MListener", "MVisitor", "prog", input, false);
+
+		assertEquals("JavaDecl: floatx=3;\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testImportLexerWithOnlyFragmentRules() throws Exception {
+		mkdir(tmpdir);
+
+		String slave_Unicode =
+			"lexer grammar Unicode;\n" +
+			"\n" +
+			"fragment\n" +
+			"UNICODE_CLASS_Zs    : '\\u0020' | '\\u00A0' | '\\u1680' | '\\u180E'\n" +
+			"                    | '\\u2000'..'\\u200A'\n" +
+			"                    | '\\u202F' | '\\u205F' | '\\u3000'\n" +
+			"                    ;\n";
+		writeFile(tmpdir, "Unicode.g4", slave_Unicode);
+
+		StringBuilder grammarBuilder = new StringBuilder(91);
+		grammarBuilder.append("grammar Test;\n");
+		grammarBuilder.append("import Unicode;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("program : 'test' 'test';\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("WS : (UNICODE_CLASS_Zs)+ -> skip;\n");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="test test";
+		String found = execParser("Test.g4", grammar, "TestParser", "TestLexer", "TestListener", "TestVisitor", "program", input, false);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testImportedGrammarWithEmptyOptions() throws Exception {
+		mkdir(tmpdir);
+
+		String slave_S =
+			"parser grammar S;\n" +
+			"options {}\n" +
+			"a : B ;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(64);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("s : a ;\n");
+		grammarBuilder.append("B : 'b' ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="b";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "MListener", "MVisitor", "s", input, false);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testImportedRuleWithAction() throws Exception {
+		mkdir(tmpdir);
+
+		String slave_S =
+			"parser grammar S;\n" +
+			"a @after {x = 0} : B;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(62);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("s : a;\n");
+		grammarBuilder.append("B : 'b';\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="b";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "MListener", "MVisitor", "s", input, false);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testKeywordVSIDOrder() throws Exception {
+		mkdir(tmpdir);
+
+		String slave_S =
+			"lexer grammar S;\n" +
+			"ID : 'a'..'z'+;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(106);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("a : A {print(\"M.a: \" + str($A))};\n");
+		grammarBuilder.append("A : 'abc' {print(\"M.A\")};\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="abc";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "MListener", "MVisitor", "a", input, false);
+
+		assertEquals(
+			"M.A\n" +
+			"M.a: [@0,0:2='abc',<1>,1:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+
+}
\ No newline at end of file
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/python2/TestFullContextParsing.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/python2/TestFullContextParsing.java
new file mode 100644
index 000000000..6d89d90a1
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/python2/TestFullContextParsing.java
@@ -0,0 +1,506 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.python2;
+
+import org.junit.Ignore;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+@SuppressWarnings("unused")
+public class TestFullContextParsing extends BasePython2Test {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAmbigYieldsCtxSensitiveDFA() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(100);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {self.dumpDFA()}\n");
+		grammarBuilder.append("	: ID | ID {} ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="abc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, true);
+
+		assertEquals(
+			"Decision 0:\n" +
+			"s0-ID->:s1^=>1\n", found);
+
+		assertEquals("line 1:0 reportAttemptingFullContext d=0 (s), input='abc'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAmbiguityNoLoop() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(206);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("prog\n");
+		grammarBuilder.append("@init {self._interp.predictionMode =  PredictionMode.LL_EXACT_AMBIG_DETECTION}\n");
+		grammarBuilder.append("	: expr expr {print(\"alt 1\")}\n");
+		grammarBuilder.append("	| expr\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("expr: '@'\n");
+		grammarBuilder.append("	| ID '@'\n");
+		grammarBuilder.append("	| ID\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("ID  : [a-z]+ ;\n");
+		grammarBuilder.append("WS  : [ \\r\\n\\t]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a@";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "prog", input, true);
+
+		assertEquals("alt 1\n", found);
+
+		assertEquals(
+			"line 1:2 reportAttemptingFullContext d=0 (prog), input='a@'\n" +
+			"line 1:2 reportAmbiguity d=0 (prog): ambigAlts={1, 2}, input='a@'\n" +
+			"line 1:2 reportAttemptingFullContext d=1 (expr), input='a@'\n" +
+			"line 1:2 reportContextSensitivity d=1 (expr), input='a@'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCtxSensitiveDFATwoDiffInput() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(164);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {self.dumpDFA()}\n");
+		grammarBuilder.append("  : ('$' a | '@' b)+ ;\n");
+		grammarBuilder.append("a : e ID ;\n");
+		grammarBuilder.append("b : e INT ID ;\n");
+		grammarBuilder.append("e : INT | ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="$ 34 abc @ 34 abc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, true);
+
+		assertEquals(
+			"Decision 2:\n" +
+			"s0-INT->s1\n" +
+			"s1-ID->:s2^=>1\n", found);
+
+		assertEquals(
+			"line 1:5 reportAttemptingFullContext d=2 (e), input='34abc'\n" +
+			"line 1:2 reportContextSensitivity d=2 (e), input='34'\n" +
+			"line 1:14 reportAttemptingFullContext d=2 (e), input='34abc'\n" +
+			"line 1:14 reportContextSensitivity d=2 (e), input='34abc'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCtxSensitiveDFA_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(161);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {self.dumpDFA()}\n");
+		grammarBuilder.append("  : '$' a | '@' b ;\n");
+		grammarBuilder.append("a : e ID ;\n");
+		grammarBuilder.append("b : e INT ID ;\n");
+		grammarBuilder.append("e : INT | ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="$ 34 abc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, true);
+
+		assertEquals(
+			"Decision 1:\n" +
+			"s0-INT->s1\n" +
+			"s1-ID->:s2^=>1\n", found);
+
+		assertEquals(
+			"line 1:5 reportAttemptingFullContext d=1 (e), input='34abc'\n" +
+			"line 1:2 reportContextSensitivity d=1 (e), input='34'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCtxSensitiveDFA_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(161);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {self.dumpDFA()}\n");
+		grammarBuilder.append("  : '$' a | '@' b ;\n");
+		grammarBuilder.append("a : e ID ;\n");
+		grammarBuilder.append("b : e INT ID ;\n");
+		grammarBuilder.append("e : INT | ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="@ 34 abc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, true);
+
+		assertEquals(
+			"Decision 1:\n" +
+			"s0-INT->s1\n" +
+			"s1-ID->:s2^=>1\n", found);
+
+		assertEquals(
+			"line 1:5 reportAttemptingFullContext d=1 (e), input='34abc'\n" +
+			"line 1:5 reportContextSensitivity d=1 (e), input='34abc'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExprAmbiguity_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(286);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {self._interp.predictionMode =  PredictionMode.LL_EXACT_AMBIG_DETECTION}\n");
+		grammarBuilder.append(":   expr[0] {print($expr.ctx.toStringTree(recog=self))};\n");
+		grammarBuilder.append("	expr[int _p]\n");
+		grammarBuilder.append("		: ID \n");
+		grammarBuilder.append("		( \n");
+		grammarBuilder.append("			{5 >= $_p}? '*' expr[6]\n");
+		grammarBuilder.append("			| {4 >= $_p}? '+' expr[5]\n");
+		grammarBuilder.append("		)*\n");
+		grammarBuilder.append("		;\n");
+		grammarBuilder.append("ID  : [a-zA-Z]+ ;\n");
+		grammarBuilder.append("WS  : [ \\r\\n\\t]+ -> skip ;\n");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a+b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, true);
+
+		assertEquals("(expr a + (expr b))\n", found);
+
+		assertEquals(
+			"line 1:1 reportAttemptingFullContext d=1 (expr), input='+'\n" +
+			"line 1:2 reportContextSensitivity d=1 (expr), input='+b'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExprAmbiguity_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(286);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {self._interp.predictionMode =  PredictionMode.LL_EXACT_AMBIG_DETECTION}\n");
+		grammarBuilder.append(":   expr[0] {print($expr.ctx.toStringTree(recog=self))};\n");
+		grammarBuilder.append("	expr[int _p]\n");
+		grammarBuilder.append("		: ID \n");
+		grammarBuilder.append("		( \n");
+		grammarBuilder.append("			{5 >= $_p}? '*' expr[6]\n");
+		grammarBuilder.append("			| {4 >= $_p}? '+' expr[5]\n");
+		grammarBuilder.append("		)*\n");
+		grammarBuilder.append("		;\n");
+		grammarBuilder.append("ID  : [a-zA-Z]+ ;\n");
+		grammarBuilder.append("WS  : [ \\r\\n\\t]+ -> skip ;\n");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a+b*c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, true);
+
+		assertEquals("(expr a + (expr b * (expr c)))\n", found);
+
+		assertEquals(
+			"line 1:1 reportAttemptingFullContext d=1 (expr), input='+'\n" +
+			"line 1:2 reportContextSensitivity d=1 (expr), input='+b'\n" +
+			"line 1:3 reportAttemptingFullContext d=1 (expr), input='*'\n" +
+			"line 1:5 reportAmbiguity d=1 (expr): ambigAlts={1, 2}, input='*c'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testFullContextIF_THEN_ELSEParse_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(240);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s \n");
+		grammarBuilder.append("@init {self._interp.predictionMode =  PredictionMode.LL_EXACT_AMBIG_DETECTION}\n");
+		grammarBuilder.append("@after {self.dumpDFA()}\n");
+		grammarBuilder.append("	: '{' stat* '}' ;\n");
+		grammarBuilder.append("stat: 'if' ID 'then' stat ('else' ID)?\n");
+		grammarBuilder.append("		| 'return'\n");
+		grammarBuilder.append("		;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="{ if x then return }";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, true);
+
+		assertEquals(
+			"Decision 1:\n" +
+			"s0-'}'->:s1=>2\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testFullContextIF_THEN_ELSEParse_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(240);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s \n");
+		grammarBuilder.append("@init {self._interp.predictionMode =  PredictionMode.LL_EXACT_AMBIG_DETECTION}\n");
+		grammarBuilder.append("@after {self.dumpDFA()}\n");
+		grammarBuilder.append("	: '{' stat* '}' ;\n");
+		grammarBuilder.append("stat: 'if' ID 'then' stat ('else' ID)?\n");
+		grammarBuilder.append("		| 'return'\n");
+		grammarBuilder.append("		;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="{ if x then return else foo }";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, true);
+
+		assertEquals(
+			"Decision 1:\n" +
+			"s0-'else'->:s1^=>1\n", found);
+
+		assertEquals(
+			"line 1:19 reportAttemptingFullContext d=1 (stat), input='else'\n" +
+			"line 1:19 reportContextSensitivity d=1 (stat), input='else'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testFullContextIF_THEN_ELSEParse_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(240);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s \n");
+		grammarBuilder.append("@init {self._interp.predictionMode =  PredictionMode.LL_EXACT_AMBIG_DETECTION}\n");
+		grammarBuilder.append("@after {self.dumpDFA()}\n");
+		grammarBuilder.append("	: '{' stat* '}' ;\n");
+		grammarBuilder.append("stat: 'if' ID 'then' stat ('else' ID)?\n");
+		grammarBuilder.append("		| 'return'\n");
+		grammarBuilder.append("		;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="{ if x then if y then return else foo }";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, true);
+
+		assertEquals(
+			"Decision 1:\n" +
+			"s0-'}'->:s2=>2\n" +
+			"s0-'else'->:s1^=>1\n", found);
+
+		assertEquals(
+			"line 1:29 reportAttemptingFullContext d=1 (stat), input='else'\n" +
+			"line 1:38 reportAmbiguity d=1 (stat): ambigAlts={1, 2}, input='elsefoo}'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testFullContextIF_THEN_ELSEParse_4() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(240);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s \n");
+		grammarBuilder.append("@init {self._interp.predictionMode =  PredictionMode.LL_EXACT_AMBIG_DETECTION}\n");
+		grammarBuilder.append("@after {self.dumpDFA()}\n");
+		grammarBuilder.append("	: '{' stat* '}' ;\n");
+		grammarBuilder.append("stat: 'if' ID 'then' stat ('else' ID)?\n");
+		grammarBuilder.append("		| 'return'\n");
+		grammarBuilder.append("		;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="{ if x then if y then return else foo else bar }";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, true);
+
+		assertEquals(
+			"Decision 1:\n" +
+			"s0-'else'->:s1^=>1\n", found);
+
+		assertEquals(
+			"line 1:29 reportAttemptingFullContext d=1 (stat), input='else'\n" +
+			"line 1:38 reportContextSensitivity d=1 (stat), input='elsefooelse'\n" +
+			"line 1:38 reportAttemptingFullContext d=1 (stat), input='else'\n" +
+			"line 1:38 reportContextSensitivity d=1 (stat), input='else'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testFullContextIF_THEN_ELSEParse_5() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(240);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s \n");
+		grammarBuilder.append("@init {self._interp.predictionMode =  PredictionMode.LL_EXACT_AMBIG_DETECTION}\n");
+		grammarBuilder.append("@after {self.dumpDFA()}\n");
+		grammarBuilder.append("	: '{' stat* '}' ;\n");
+		grammarBuilder.append("stat: 'if' ID 'then' stat ('else' ID)?\n");
+		grammarBuilder.append("		| 'return'\n");
+		grammarBuilder.append("		;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input =
+			"{ if x then return else foo\n" +
+			"if x then if y then return else foo }";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, true);
+
+		assertEquals(
+			"Decision 1:\n" +
+			"s0-'}'->:s2=>2\n" +
+			"s0-'else'->:s1^=>1\n", found);
+
+		assertEquals(
+			"line 1:19 reportAttemptingFullContext d=1 (stat), input='else'\n" +
+			"line 1:19 reportContextSensitivity d=1 (stat), input='else'\n" +
+			"line 2:27 reportAttemptingFullContext d=1 (stat), input='else'\n" +
+			"line 2:36 reportAmbiguity d=1 (stat): ambigAlts={1, 2}, input='elsefoo}'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testFullContextIF_THEN_ELSEParse_6() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(240);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s \n");
+		grammarBuilder.append("@init {self._interp.predictionMode =  PredictionMode.LL_EXACT_AMBIG_DETECTION}\n");
+		grammarBuilder.append("@after {self.dumpDFA()}\n");
+		grammarBuilder.append("	: '{' stat* '}' ;\n");
+		grammarBuilder.append("stat: 'if' ID 'then' stat ('else' ID)?\n");
+		grammarBuilder.append("		| 'return'\n");
+		grammarBuilder.append("		;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input =
+			"{ if x then return else foo\n" +
+			"if x then if y then return else foo }";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, true);
+
+		assertEquals(
+			"Decision 1:\n" +
+			"s0-'}'->:s2=>2\n" +
+			"s0-'else'->:s1^=>1\n", found);
+
+		assertEquals(
+			"line 1:19 reportAttemptingFullContext d=1 (stat), input='else'\n" +
+			"line 1:19 reportContextSensitivity d=1 (stat), input='else'\n" +
+			"line 2:27 reportAttemptingFullContext d=1 (stat), input='else'\n" +
+			"line 2:36 reportAmbiguity d=1 (stat): ambigAlts={1, 2}, input='elsefoo}'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLoopsSimulateTailRecursion() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(299);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("prog\n");
+		grammarBuilder.append("@init {self._interp.predictionMode =  PredictionMode.LL_EXACT_AMBIG_DETECTION}\n");
+		grammarBuilder.append("	: expr_or_assign*;\n");
+		grammarBuilder.append("expr_or_assign\n");
+		grammarBuilder.append("	: expr '++' {print(\"fail.\")}\n");
+		grammarBuilder.append("	|  expr {print(\"pass: \"+$expr.text)}\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("expr: expr_primary ('<-' ID)?;\n");
+		grammarBuilder.append("expr_primary\n");
+		grammarBuilder.append("	: '(' ID ')'\n");
+		grammarBuilder.append("	| ID '(' ID ')'\n");
+		grammarBuilder.append("	| ID\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("ID  : [a-z]+ ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a(i)<-x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "prog", input, true);
+
+		assertEquals("pass: a(i)<-x\n", found);
+
+		assertEquals(
+			"line 1:3 reportAttemptingFullContext d=3 (expr_primary), input='a(i)'\n" +
+			"line 1:7 reportAmbiguity d=3 (expr_primary): ambigAlts={2, 3}, input='a(i)<-x'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSLLSeesEOFInLLGrammar() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(148);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {self.dumpDFA()}\n");
+		grammarBuilder.append("  : a;\n");
+		grammarBuilder.append("a : e ID ;\n");
+		grammarBuilder.append("b : e INT ID ;\n");
+		grammarBuilder.append("e : INT | ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="34 abc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, true);
+
+		assertEquals(
+			"Decision 0:\n" +
+			"s0-INT->s1\n" +
+			"s1-ID->:s2^=>1\n", found);
+
+		assertEquals(
+			"line 1:3 reportAttemptingFullContext d=0 (e), input='34abc'\n" +
+			"line 1:0 reportContextSensitivity d=0 (e), input='34'\n", this.stderrDuringParse);
+
+	}
+
+
+}
\ No newline at end of file
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/python2/TestLeftRecursion.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/python2/TestLeftRecursion.java
new file mode 100644
index 000000000..d65523920
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/python2/TestLeftRecursion.java
@@ -0,0 +1,3404 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.python2;
+
+import org.junit.Ignore;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+@SuppressWarnings("unused")
+public class TestLeftRecursion extends BasePython2Test {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAmbigLR_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(705);
+		grammarBuilder.append("grammar Expr;\n");
+		grammarBuilder.append("prog:   stat ;\n");
+		grammarBuilder.append("stat:   expr NEWLINE                # printExpr\n");
+		grammarBuilder.append("    |   ID '=' expr NEWLINE         # assign\n");
+		grammarBuilder.append("    |   NEWLINE                     # blank\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("expr:   expr ('*'|'/') expr      # MulDiv\n");
+		grammarBuilder.append("    |   expr ('+'|'-') expr      # AddSub\n");
+		grammarBuilder.append("    |   INT                      # int\n");
+		grammarBuilder.append("    |   ID                       # id\n");
+		grammarBuilder.append("    |   '(' expr ')'             # parens\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("MUL :   '*' ; // assigns token name to '*' used above in grammar\n");
+		grammarBuilder.append("DIV :   '/' ;\n");
+		grammarBuilder.append("ADD :   '+' ;\n");
+		grammarBuilder.append("SUB :   '-' ;\n");
+		grammarBuilder.append("ID  :   [a-zA-Z]+ ;      // match identifiers\n");
+		grammarBuilder.append("INT :   [0-9]+ ;         // match integers\n");
+		grammarBuilder.append("NEWLINE:'\\r'? '\\n' ;     // return newlines to parser (is end-statement signal)\n");
+		grammarBuilder.append("WS  :   [ \\t]+ -> skip ; // toss out whitespace");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="1\n";
+		String found = execParser("Expr.g4", grammar, "ExprParser", "ExprLexer", "ExprListener", "ExprVisitor", "prog", input, true);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAmbigLR_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(705);
+		grammarBuilder.append("grammar Expr;\n");
+		grammarBuilder.append("prog:   stat ;\n");
+		grammarBuilder.append("stat:   expr NEWLINE                # printExpr\n");
+		grammarBuilder.append("    |   ID '=' expr NEWLINE         # assign\n");
+		grammarBuilder.append("    |   NEWLINE                     # blank\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("expr:   expr ('*'|'/') expr      # MulDiv\n");
+		grammarBuilder.append("    |   expr ('+'|'-') expr      # AddSub\n");
+		grammarBuilder.append("    |   INT                      # int\n");
+		grammarBuilder.append("    |   ID                       # id\n");
+		grammarBuilder.append("    |   '(' expr ')'             # parens\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("MUL :   '*' ; // assigns token name to '*' used above in grammar\n");
+		grammarBuilder.append("DIV :   '/' ;\n");
+		grammarBuilder.append("ADD :   '+' ;\n");
+		grammarBuilder.append("SUB :   '-' ;\n");
+		grammarBuilder.append("ID  :   [a-zA-Z]+ ;      // match identifiers\n");
+		grammarBuilder.append("INT :   [0-9]+ ;         // match integers\n");
+		grammarBuilder.append("NEWLINE:'\\r'? '\\n' ;     // return newlines to parser (is end-statement signal)\n");
+		grammarBuilder.append("WS  :   [ \\t]+ -> skip ; // toss out whitespace");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a = 5\n";
+		String found = execParser("Expr.g4", grammar, "ExprParser", "ExprLexer", "ExprListener", "ExprVisitor", "prog", input, true);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAmbigLR_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(705);
+		grammarBuilder.append("grammar Expr;\n");
+		grammarBuilder.append("prog:   stat ;\n");
+		grammarBuilder.append("stat:   expr NEWLINE                # printExpr\n");
+		grammarBuilder.append("    |   ID '=' expr NEWLINE         # assign\n");
+		grammarBuilder.append("    |   NEWLINE                     # blank\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("expr:   expr ('*'|'/') expr      # MulDiv\n");
+		grammarBuilder.append("    |   expr ('+'|'-') expr      # AddSub\n");
+		grammarBuilder.append("    |   INT                      # int\n");
+		grammarBuilder.append("    |   ID                       # id\n");
+		grammarBuilder.append("    |   '(' expr ')'             # parens\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("MUL :   '*' ; // assigns token name to '*' used above in grammar\n");
+		grammarBuilder.append("DIV :   '/' ;\n");
+		grammarBuilder.append("ADD :   '+' ;\n");
+		grammarBuilder.append("SUB :   '-' ;\n");
+		grammarBuilder.append("ID  :   [a-zA-Z]+ ;      // match identifiers\n");
+		grammarBuilder.append("INT :   [0-9]+ ;         // match integers\n");
+		grammarBuilder.append("NEWLINE:'\\r'? '\\n' ;     // return newlines to parser (is end-statement signal)\n");
+		grammarBuilder.append("WS  :   [ \\t]+ -> skip ; // toss out whitespace");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="b = 6\n";
+		String found = execParser("Expr.g4", grammar, "ExprParser", "ExprLexer", "ExprListener", "ExprVisitor", "prog", input, true);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAmbigLR_4() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(705);
+		grammarBuilder.append("grammar Expr;\n");
+		grammarBuilder.append("prog:   stat ;\n");
+		grammarBuilder.append("stat:   expr NEWLINE                # printExpr\n");
+		grammarBuilder.append("    |   ID '=' expr NEWLINE         # assign\n");
+		grammarBuilder.append("    |   NEWLINE                     # blank\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("expr:   expr ('*'|'/') expr      # MulDiv\n");
+		grammarBuilder.append("    |   expr ('+'|'-') expr      # AddSub\n");
+		grammarBuilder.append("    |   INT                      # int\n");
+		grammarBuilder.append("    |   ID                       # id\n");
+		grammarBuilder.append("    |   '(' expr ')'             # parens\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("MUL :   '*' ; // assigns token name to '*' used above in grammar\n");
+		grammarBuilder.append("DIV :   '/' ;\n");
+		grammarBuilder.append("ADD :   '+' ;\n");
+		grammarBuilder.append("SUB :   '-' ;\n");
+		grammarBuilder.append("ID  :   [a-zA-Z]+ ;      // match identifiers\n");
+		grammarBuilder.append("INT :   [0-9]+ ;         // match integers\n");
+		grammarBuilder.append("NEWLINE:'\\r'? '\\n' ;     // return newlines to parser (is end-statement signal)\n");
+		grammarBuilder.append("WS  :   [ \\t]+ -> skip ; // toss out whitespace");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a+b*2\n";
+		String found = execParser("Expr.g4", grammar, "ExprParser", "ExprLexer", "ExprListener", "ExprVisitor", "prog", input, true);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAmbigLR_5() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(705);
+		grammarBuilder.append("grammar Expr;\n");
+		grammarBuilder.append("prog:   stat ;\n");
+		grammarBuilder.append("stat:   expr NEWLINE                # printExpr\n");
+		grammarBuilder.append("    |   ID '=' expr NEWLINE         # assign\n");
+		grammarBuilder.append("    |   NEWLINE                     # blank\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("expr:   expr ('*'|'/') expr      # MulDiv\n");
+		grammarBuilder.append("    |   expr ('+'|'-') expr      # AddSub\n");
+		grammarBuilder.append("    |   INT                      # int\n");
+		grammarBuilder.append("    |   ID                       # id\n");
+		grammarBuilder.append("    |   '(' expr ')'             # parens\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("MUL :   '*' ; // assigns token name to '*' used above in grammar\n");
+		grammarBuilder.append("DIV :   '/' ;\n");
+		grammarBuilder.append("ADD :   '+' ;\n");
+		grammarBuilder.append("SUB :   '-' ;\n");
+		grammarBuilder.append("ID  :   [a-zA-Z]+ ;      // match identifiers\n");
+		grammarBuilder.append("INT :   [0-9]+ ;         // match integers\n");
+		grammarBuilder.append("NEWLINE:'\\r'? '\\n' ;     // return newlines to parser (is end-statement signal)\n");
+		grammarBuilder.append("WS  :   [ \\t]+ -> skip ; // toss out whitespace");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="(1+2)*3\n";
+		String found = execParser("Expr.g4", grammar, "ExprParser", "ExprLexer", "ExprListener", "ExprVisitor", "prog", input, true);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDeclarations_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(391);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : declarator EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("declarator\n");
+		grammarBuilder.append("        : declarator '[' e ']'\n");
+		grammarBuilder.append("        | declarator '[' ']'\n");
+		grammarBuilder.append("        | declarator '(' ')'\n");
+		grammarBuilder.append("        | '*' declarator // binds less tight than suffixes\n");
+		grammarBuilder.append("        | '(' declarator ')'\n");
+		grammarBuilder.append("        | ID\n");
+		grammarBuilder.append("        ;\n");
+		grammarBuilder.append("e : INT ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (declarator a) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDeclarations_10() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(391);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : declarator EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("declarator\n");
+		grammarBuilder.append("        : declarator '[' e ']'\n");
+		grammarBuilder.append("        | declarator '[' ']'\n");
+		grammarBuilder.append("        | declarator '(' ')'\n");
+		grammarBuilder.append("        | '*' declarator // binds less tight than suffixes\n");
+		grammarBuilder.append("        | '(' declarator ')'\n");
+		grammarBuilder.append("        | ID\n");
+		grammarBuilder.append("        ;\n");
+		grammarBuilder.append("e : INT ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="(*a)[]";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (declarator (declarator ( (declarator * (declarator a)) )) [ ]) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDeclarations_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(391);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : declarator EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("declarator\n");
+		grammarBuilder.append("        : declarator '[' e ']'\n");
+		grammarBuilder.append("        | declarator '[' ']'\n");
+		grammarBuilder.append("        | declarator '(' ')'\n");
+		grammarBuilder.append("        | '*' declarator // binds less tight than suffixes\n");
+		grammarBuilder.append("        | '(' declarator ')'\n");
+		grammarBuilder.append("        | ID\n");
+		grammarBuilder.append("        ;\n");
+		grammarBuilder.append("e : INT ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="*a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (declarator * (declarator a)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDeclarations_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(391);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : declarator EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("declarator\n");
+		grammarBuilder.append("        : declarator '[' e ']'\n");
+		grammarBuilder.append("        | declarator '[' ']'\n");
+		grammarBuilder.append("        | declarator '(' ')'\n");
+		grammarBuilder.append("        | '*' declarator // binds less tight than suffixes\n");
+		grammarBuilder.append("        | '(' declarator ')'\n");
+		grammarBuilder.append("        | ID\n");
+		grammarBuilder.append("        ;\n");
+		grammarBuilder.append("e : INT ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="**a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (declarator * (declarator * (declarator a))) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDeclarations_4() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(391);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : declarator EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("declarator\n");
+		grammarBuilder.append("        : declarator '[' e ']'\n");
+		grammarBuilder.append("        | declarator '[' ']'\n");
+		grammarBuilder.append("        | declarator '(' ')'\n");
+		grammarBuilder.append("        | '*' declarator // binds less tight than suffixes\n");
+		grammarBuilder.append("        | '(' declarator ')'\n");
+		grammarBuilder.append("        | ID\n");
+		grammarBuilder.append("        ;\n");
+		grammarBuilder.append("e : INT ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a[3]";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (declarator (declarator a) [ (e 3) ]) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDeclarations_5() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(391);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : declarator EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("declarator\n");
+		grammarBuilder.append("        : declarator '[' e ']'\n");
+		grammarBuilder.append("        | declarator '[' ']'\n");
+		grammarBuilder.append("        | declarator '(' ')'\n");
+		grammarBuilder.append("        | '*' declarator // binds less tight than suffixes\n");
+		grammarBuilder.append("        | '(' declarator ')'\n");
+		grammarBuilder.append("        | ID\n");
+		grammarBuilder.append("        ;\n");
+		grammarBuilder.append("e : INT ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="b[]";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (declarator (declarator b) [ ]) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDeclarations_6() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(391);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : declarator EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("declarator\n");
+		grammarBuilder.append("        : declarator '[' e ']'\n");
+		grammarBuilder.append("        | declarator '[' ']'\n");
+		grammarBuilder.append("        | declarator '(' ')'\n");
+		grammarBuilder.append("        | '*' declarator // binds less tight than suffixes\n");
+		grammarBuilder.append("        | '(' declarator ')'\n");
+		grammarBuilder.append("        | ID\n");
+		grammarBuilder.append("        ;\n");
+		grammarBuilder.append("e : INT ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="(a)";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (declarator ( (declarator a) )) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDeclarations_7() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(391);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : declarator EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("declarator\n");
+		grammarBuilder.append("        : declarator '[' e ']'\n");
+		grammarBuilder.append("        | declarator '[' ']'\n");
+		grammarBuilder.append("        | declarator '(' ')'\n");
+		grammarBuilder.append("        | '*' declarator // binds less tight than suffixes\n");
+		grammarBuilder.append("        | '(' declarator ')'\n");
+		grammarBuilder.append("        | ID\n");
+		grammarBuilder.append("        ;\n");
+		grammarBuilder.append("e : INT ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a[]()";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (declarator (declarator (declarator a) [ ]) ( )) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDeclarations_8() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(391);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : declarator EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("declarator\n");
+		grammarBuilder.append("        : declarator '[' e ']'\n");
+		grammarBuilder.append("        | declarator '[' ']'\n");
+		grammarBuilder.append("        | declarator '(' ')'\n");
+		grammarBuilder.append("        | '*' declarator // binds less tight than suffixes\n");
+		grammarBuilder.append("        | '(' declarator ')'\n");
+		grammarBuilder.append("        | ID\n");
+		grammarBuilder.append("        ;\n");
+		grammarBuilder.append("e : INT ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a[][]";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (declarator (declarator (declarator a) [ ]) [ ]) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDeclarations_9() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(391);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : declarator EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("declarator\n");
+		grammarBuilder.append("        : declarator '[' e ']'\n");
+		grammarBuilder.append("        | declarator '[' ']'\n");
+		grammarBuilder.append("        | declarator '(' ')'\n");
+		grammarBuilder.append("        | '*' declarator // binds less tight than suffixes\n");
+		grammarBuilder.append("        | '(' declarator ')'\n");
+		grammarBuilder.append("        | ID\n");
+		grammarBuilder.append("        ;\n");
+		grammarBuilder.append("e : INT ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="*a[]";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (declarator * (declarator (declarator a) [ ])) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDirectCallToLeftRecursiveRule_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(119);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a @after {print($ctx.toStringTree(recog=self))} : a ID\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("(a x)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDirectCallToLeftRecursiveRule_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(119);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a @after {print($ctx.toStringTree(recog=self))} : a ID\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x y";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("(a (a x) y)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDirectCallToLeftRecursiveRule_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(119);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a @after {print($ctx.toStringTree(recog=self))} : a ID\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x y z";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("(a (a (a x) y) z)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExpressions_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(250);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("e : e '.' ID\n");
+		grammarBuilder.append("  | e '.' 'this'\n");
+		grammarBuilder.append("  | '-' e\n");
+		grammarBuilder.append("  | e '*' e\n");
+		grammarBuilder.append("  | e ('+'|'-') e\n");
+		grammarBuilder.append("  | INT\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e a) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExpressions_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(250);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("e : e '.' ID\n");
+		grammarBuilder.append("  | e '.' 'this'\n");
+		grammarBuilder.append("  | '-' e\n");
+		grammarBuilder.append("  | e '*' e\n");
+		grammarBuilder.append("  | e ('+'|'-') e\n");
+		grammarBuilder.append("  | INT\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="1";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e 1) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExpressions_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(250);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("e : e '.' ID\n");
+		grammarBuilder.append("  | e '.' 'this'\n");
+		grammarBuilder.append("  | '-' e\n");
+		grammarBuilder.append("  | e '*' e\n");
+		grammarBuilder.append("  | e ('+'|'-') e\n");
+		grammarBuilder.append("  | INT\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a-1";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e a) - (e 1)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExpressions_4() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(250);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("e : e '.' ID\n");
+		grammarBuilder.append("  | e '.' 'this'\n");
+		grammarBuilder.append("  | '-' e\n");
+		grammarBuilder.append("  | e '*' e\n");
+		grammarBuilder.append("  | e ('+'|'-') e\n");
+		grammarBuilder.append("  | INT\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a.b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e a) . b) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExpressions_5() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(250);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("e : e '.' ID\n");
+		grammarBuilder.append("  | e '.' 'this'\n");
+		grammarBuilder.append("  | '-' e\n");
+		grammarBuilder.append("  | e '*' e\n");
+		grammarBuilder.append("  | e ('+'|'-') e\n");
+		grammarBuilder.append("  | INT\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a.this";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e a) . this) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExpressions_6() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(250);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("e : e '.' ID\n");
+		grammarBuilder.append("  | e '.' 'this'\n");
+		grammarBuilder.append("  | '-' e\n");
+		grammarBuilder.append("  | e '*' e\n");
+		grammarBuilder.append("  | e ('+'|'-') e\n");
+		grammarBuilder.append("  | INT\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="-a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e - (e a)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExpressions_7() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(250);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("e : e '.' ID\n");
+		grammarBuilder.append("  | e '.' 'this'\n");
+		grammarBuilder.append("  | '-' e\n");
+		grammarBuilder.append("  | e '*' e\n");
+		grammarBuilder.append("  | e ('+'|'-') e\n");
+		grammarBuilder.append("  | INT\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="-a+b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e - (e a)) + (e b)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(1247);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a|b&c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e a) | (e (e b) & (e c))) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_10() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(1247);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a.f(x)==T.c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e (e (e a) . f) ( (expressionList (e x)) )) == (e (e T) . c)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_11() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(1247);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a.f().g(x,1)";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e (e (e (e a) . f) ( )) . g) ( (expressionList (e x) , (e 1)) )) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_12() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(1247);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="new T[((n-1) * x) + 1]";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e new (typespec T) [ (e (e ( (e (e ( (e (e n) - (e 1)) )) * (e x)) )) + (e 1)) ]) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(1247);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="(a|b)&c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e ( (e (e a) | (e b)) )) & (e c)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(1247);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a > b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e a) > (e b)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_4() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(1247);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a >> b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e a) >> (e b)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_5() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(1247);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a=b=c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e a) = (e (e b) = (e c))) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_6() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(1247);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a^b^c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e a) ^ (e (e b) ^ (e c))) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_7() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(1247);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="(T)x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e ( (typespec T) ) (e x)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_8() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(1247);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="new A().b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e new (typespec A) ( )) . b) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_9() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(1247);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="(T)t.f()";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e ( (typespec T) ) (e (e t) . f)) ( )) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLabelsOnOpSubrule_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(170);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e;\n");
+		grammarBuilder.append("e : a=e op=('*'|'/') b=e  {}\n");
+		grammarBuilder.append("  | INT {}\n");
+		grammarBuilder.append("  | '(' x=e ')' {}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="4";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e 4))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLabelsOnOpSubrule_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(170);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e;\n");
+		grammarBuilder.append("e : a=e op=('*'|'/') b=e  {}\n");
+		grammarBuilder.append("  | INT {}\n");
+		grammarBuilder.append("  | '(' x=e ')' {}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="1*2/3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e (e 1) * (e 2)) / (e 3)))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLabelsOnOpSubrule_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(170);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e;\n");
+		grammarBuilder.append("e : a=e op=('*'|'/') b=e  {}\n");
+		grammarBuilder.append("  | INT {}\n");
+		grammarBuilder.append("  | '(' x=e ')' {}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="(1/2)*3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e ( (e (e 1) / (e 2)) )) * (e 3)))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleActionsPredicatesOptions_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(239);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e ;\n");
+		grammarBuilder.append("e : a=e op=('*'|'/') b=e  {}{True}?\n");
+		grammarBuilder.append("  | a=e op=('+'|'-') b=e  {}<p=3>{True}?<fail='Message'>\n");
+		grammarBuilder.append("  | INT {}{}\n");
+		grammarBuilder.append("  | '(' x=e ')' {}{}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="4";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e 4))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleActionsPredicatesOptions_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(239);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e ;\n");
+		grammarBuilder.append("e : a=e op=('*'|'/') b=e  {}{True}?\n");
+		grammarBuilder.append("  | a=e op=('+'|'-') b=e  {}<p=3>{True}?<fail='Message'>\n");
+		grammarBuilder.append("  | INT {}{}\n");
+		grammarBuilder.append("  | '(' x=e ')' {}{}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="1*2/3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e (e 1) * (e 2)) / (e 3)))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleActionsPredicatesOptions_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(239);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e ;\n");
+		grammarBuilder.append("e : a=e op=('*'|'/') b=e  {}{True}?\n");
+		grammarBuilder.append("  | a=e op=('+'|'-') b=e  {}<p=3>{True}?<fail='Message'>\n");
+		grammarBuilder.append("  | INT {}{}\n");
+		grammarBuilder.append("  | '(' x=e ')' {}{}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="(1/2)*3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e ( (e (e 1) / (e 2)) )) * (e 3)))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleActions_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(177);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e ;\n");
+		grammarBuilder.append("e : a=e op=('*'|'/') b=e  {}{}\n");
+		grammarBuilder.append("  | INT {}{}\n");
+		grammarBuilder.append("  | '(' x=e ')' {}{}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="4";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e 4))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleActions_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(177);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e ;\n");
+		grammarBuilder.append("e : a=e op=('*'|'/') b=e  {}{}\n");
+		grammarBuilder.append("  | INT {}{}\n");
+		grammarBuilder.append("  | '(' x=e ')' {}{}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="1*2/3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e (e 1) * (e 2)) / (e 3)))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleActions_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(177);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e ;\n");
+		grammarBuilder.append("e : a=e op=('*'|'/') b=e  {}{}\n");
+		grammarBuilder.append("  | INT {}{}\n");
+		grammarBuilder.append("  | '(' x=e ')' {}{}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="(1/2)*3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e ( (e (e 1) / (e 2)) )) * (e 3)))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleAlternativesWithCommonLabel_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(561);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {print($e.v)};\n");
+		grammarBuilder.append("e returns [int v]\n");
+		grammarBuilder.append("  : e '*' e     {$v = $ctx.e(0).v * $ctx.e(1).v;}  # binary\n");
+		grammarBuilder.append("  | e '+' e     {$v = $ctx.e(0).v + $ctx.e(1).v;}  # binary\n");
+		grammarBuilder.append("  | INT         {$v = $INT.int;}                   # anInt\n");
+		grammarBuilder.append("  | '(' e ')'   {$v = $e.v;}                       # parens\n");
+		grammarBuilder.append("  | left=e INC  {$v = $left.v + 1;}      # unary\n");
+		grammarBuilder.append("  | left=e DEC  {$v = $left.v - 1;}      # unary\n");
+		grammarBuilder.append("  | ID          {$v = 3}                                                     # anID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("INC : '++' ;\n");
+		grammarBuilder.append("DEC : '--' ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="4";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("4\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleAlternativesWithCommonLabel_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(561);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {print($e.v)};\n");
+		grammarBuilder.append("e returns [int v]\n");
+		grammarBuilder.append("  : e '*' e     {$v = $ctx.e(0).v * $ctx.e(1).v;}  # binary\n");
+		grammarBuilder.append("  | e '+' e     {$v = $ctx.e(0).v + $ctx.e(1).v;}  # binary\n");
+		grammarBuilder.append("  | INT         {$v = $INT.int;}                   # anInt\n");
+		grammarBuilder.append("  | '(' e ')'   {$v = $e.v;}                       # parens\n");
+		grammarBuilder.append("  | left=e INC  {$v = $left.v + 1;}      # unary\n");
+		grammarBuilder.append("  | left=e DEC  {$v = $left.v - 1;}      # unary\n");
+		grammarBuilder.append("  | ID          {$v = 3}                                                     # anID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("INC : '++' ;\n");
+		grammarBuilder.append("DEC : '--' ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="1+2";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("3\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleAlternativesWithCommonLabel_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(561);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {print($e.v)};\n");
+		grammarBuilder.append("e returns [int v]\n");
+		grammarBuilder.append("  : e '*' e     {$v = $ctx.e(0).v * $ctx.e(1).v;}  # binary\n");
+		grammarBuilder.append("  | e '+' e     {$v = $ctx.e(0).v + $ctx.e(1).v;}  # binary\n");
+		grammarBuilder.append("  | INT         {$v = $INT.int;}                   # anInt\n");
+		grammarBuilder.append("  | '(' e ')'   {$v = $e.v;}                       # parens\n");
+		grammarBuilder.append("  | left=e INC  {$v = $left.v + 1;}      # unary\n");
+		grammarBuilder.append("  | left=e DEC  {$v = $left.v - 1;}      # unary\n");
+		grammarBuilder.append("  | ID          {$v = 3}                                                     # anID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("INC : '++' ;\n");
+		grammarBuilder.append("DEC : '--' ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="1+2*3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("7\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleAlternativesWithCommonLabel_4() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(561);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {print($e.v)};\n");
+		grammarBuilder.append("e returns [int v]\n");
+		grammarBuilder.append("  : e '*' e     {$v = $ctx.e(0).v * $ctx.e(1).v;}  # binary\n");
+		grammarBuilder.append("  | e '+' e     {$v = $ctx.e(0).v + $ctx.e(1).v;}  # binary\n");
+		grammarBuilder.append("  | INT         {$v = $INT.int;}                   # anInt\n");
+		grammarBuilder.append("  | '(' e ')'   {$v = $e.v;}                       # parens\n");
+		grammarBuilder.append("  | left=e INC  {$v = $left.v + 1;}      # unary\n");
+		grammarBuilder.append("  | left=e DEC  {$v = $left.v - 1;}      # unary\n");
+		grammarBuilder.append("  | ID          {$v = 3}                                                     # anID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("INC : '++' ;\n");
+		grammarBuilder.append("DEC : '--' ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="i++*3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("12\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPrecedenceFilterConsidersContext() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(142);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("prog \n");
+		grammarBuilder.append("@after {print($ctx.toStringTree(recog=self))}\n");
+		grammarBuilder.append(": statement* EOF {};\n");
+		grammarBuilder.append("statement: letterA | statement letterA 'b' ;\n");
+		grammarBuilder.append("letterA: 'a';");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="aa";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "prog", input, false);
+
+		assertEquals("(prog (statement (letterA a)) (statement (letterA a)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPrefixAndOtherAlt_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(216);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : expr EOF ; \n");
+		grammarBuilder.append("expr : literal\n");
+		grammarBuilder.append("     | op expr\n");
+		grammarBuilder.append("     | expr op expr\n");
+		grammarBuilder.append("     ;\n");
+		grammarBuilder.append("literal : '-'? Integer ;\n");
+		grammarBuilder.append("op : '+' | '-' ;\n");
+		grammarBuilder.append("Integer : [0-9]+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="-1";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (expr (literal - 1)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPrefixAndOtherAlt_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(216);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : expr EOF ; \n");
+		grammarBuilder.append("expr : literal\n");
+		grammarBuilder.append("     | op expr\n");
+		grammarBuilder.append("     | expr op expr\n");
+		grammarBuilder.append("     ;\n");
+		grammarBuilder.append("literal : '-'? Integer ;\n");
+		grammarBuilder.append("op : '+' | '-' ;\n");
+		grammarBuilder.append("Integer : [0-9]+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="-1 + -1";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (expr (expr (literal - 1)) (op +) (expr (literal - 1))) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPrefixOpWithActionAndLabel_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(329);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {print($e.result)} ;\n");
+		grammarBuilder.append("e returns [String result]\n");
+		grammarBuilder.append("    :   ID '=' e1=e    {$result = \"(\" + $ID.text + \"=\" + $e1.result + \")\";}\n");
+		grammarBuilder.append("    |   ID             {$result = $ID.text;}\n");
+		grammarBuilder.append("    |   e1=e '+' e2=e  {$result = \"(\" + $e1.result + \"+\" + $e2.result + \")\";}\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("a\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPrefixOpWithActionAndLabel_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(329);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {print($e.result)} ;\n");
+		grammarBuilder.append("e returns [String result]\n");
+		grammarBuilder.append("    :   ID '=' e1=e    {$result = \"(\" + $ID.text + \"=\" + $e1.result + \")\";}\n");
+		grammarBuilder.append("    |   ID             {$result = $ID.text;}\n");
+		grammarBuilder.append("    |   e1=e '+' e2=e  {$result = \"(\" + $e1.result + \"+\" + $e2.result + \")\";}\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a+b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(a+b)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPrefixOpWithActionAndLabel_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(329);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {print($e.result)} ;\n");
+		grammarBuilder.append("e returns [String result]\n");
+		grammarBuilder.append("    :   ID '=' e1=e    {$result = \"(\" + $ID.text + \"=\" + $e1.result + \")\";}\n");
+		grammarBuilder.append("    |   ID             {$result = $ID.text;}\n");
+		grammarBuilder.append("    |   e1=e '+' e2=e  {$result = \"(\" + $e1.result + \"+\" + $e2.result + \")\";}\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a=b+c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("((a=b)+c)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsAndLabels_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(447);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : q=e {print($e.v)}; \n");
+		grammarBuilder.append("e returns [int v]\n");
+		grammarBuilder.append("  : a=e op='*' b=e {$v = $a.v * $b.v;}  # mult\n");
+		grammarBuilder.append("  | a=e '+' b=e {$v = $a.v + $b.v;}     # add\n");
+		grammarBuilder.append("  | INT         {$v = $INT.int;}        # anInt\n");
+		grammarBuilder.append("  | '(' x=e ')' {$v = $x.v;}            # parens\n");
+		grammarBuilder.append("  | x=e '++'    {$v = $x.v+1;}          # inc\n");
+		grammarBuilder.append("  | e '--'                              # dec\n");
+		grammarBuilder.append("  | ID          {$v = 3;}               # anID\n");
+		grammarBuilder.append("  ; \n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="4";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("4\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsAndLabels_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(447);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : q=e {print($e.v)}; \n");
+		grammarBuilder.append("e returns [int v]\n");
+		grammarBuilder.append("  : a=e op='*' b=e {$v = $a.v * $b.v;}  # mult\n");
+		grammarBuilder.append("  | a=e '+' b=e {$v = $a.v + $b.v;}     # add\n");
+		grammarBuilder.append("  | INT         {$v = $INT.int;}        # anInt\n");
+		grammarBuilder.append("  | '(' x=e ')' {$v = $x.v;}            # parens\n");
+		grammarBuilder.append("  | x=e '++'    {$v = $x.v+1;}          # inc\n");
+		grammarBuilder.append("  | e '--'                              # dec\n");
+		grammarBuilder.append("  | ID          {$v = 3;}               # anID\n");
+		grammarBuilder.append("  ; \n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="1+2";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("3\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsAndLabels_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(447);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : q=e {print($e.v)}; \n");
+		grammarBuilder.append("e returns [int v]\n");
+		grammarBuilder.append("  : a=e op='*' b=e {$v = $a.v * $b.v;}  # mult\n");
+		grammarBuilder.append("  | a=e '+' b=e {$v = $a.v + $b.v;}     # add\n");
+		grammarBuilder.append("  | INT         {$v = $INT.int;}        # anInt\n");
+		grammarBuilder.append("  | '(' x=e ')' {$v = $x.v;}            # parens\n");
+		grammarBuilder.append("  | x=e '++'    {$v = $x.v+1;}          # inc\n");
+		grammarBuilder.append("  | e '--'                              # dec\n");
+		grammarBuilder.append("  | ID          {$v = 3;}               # anID\n");
+		grammarBuilder.append("  ; \n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="1+2*3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("7\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsAndLabels_4() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(447);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : q=e {print($e.v)}; \n");
+		grammarBuilder.append("e returns [int v]\n");
+		grammarBuilder.append("  : a=e op='*' b=e {$v = $a.v * $b.v;}  # mult\n");
+		grammarBuilder.append("  | a=e '+' b=e {$v = $a.v + $b.v;}     # add\n");
+		grammarBuilder.append("  | INT         {$v = $INT.int;}        # anInt\n");
+		grammarBuilder.append("  | '(' x=e ')' {$v = $x.v;}            # parens\n");
+		grammarBuilder.append("  | x=e '++'    {$v = $x.v+1;}          # inc\n");
+		grammarBuilder.append("  | e '--'                              # dec\n");
+		grammarBuilder.append("  | ID          {$v = 3;}               # anID\n");
+		grammarBuilder.append("  ; \n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="i++*3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("12\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsList1_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(300);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : expr EOF;\n");
+		grammarBuilder.append("expr:\n");
+		grammarBuilder.append("    a=expr '*' a=expr #Factor\n");
+		grammarBuilder.append("    | b+=expr (',' b+=expr)* '>>' c=expr #Send\n");
+		grammarBuilder.append("    | ID #JustId //semantic check on modifiers\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("ID  : ('a'..'z'|'A'..'Z'|'_')\n");
+		grammarBuilder.append("      ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a*b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (expr (expr a) * (expr b)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsList1_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(300);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : expr EOF;\n");
+		grammarBuilder.append("expr:\n");
+		grammarBuilder.append("    a=expr '*' a=expr #Factor\n");
+		grammarBuilder.append("    | b+=expr (',' b+=expr)* '>>' c=expr #Send\n");
+		grammarBuilder.append("    | ID #JustId //semantic check on modifiers\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("ID  : ('a'..'z'|'A'..'Z'|'_')\n");
+		grammarBuilder.append("      ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a,c>>x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (expr (expr a) , (expr c) >> (expr x)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsList1_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(300);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : expr EOF;\n");
+		grammarBuilder.append("expr:\n");
+		grammarBuilder.append("    a=expr '*' a=expr #Factor\n");
+		grammarBuilder.append("    | b+=expr (',' b+=expr)* '>>' c=expr #Send\n");
+		grammarBuilder.append("    | ID #JustId //semantic check on modifiers\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("ID  : ('a'..'z'|'A'..'Z'|'_')\n");
+		grammarBuilder.append("      ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (expr x) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsList1_4() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(300);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : expr EOF;\n");
+		grammarBuilder.append("expr:\n");
+		grammarBuilder.append("    a=expr '*' a=expr #Factor\n");
+		grammarBuilder.append("    | b+=expr (',' b+=expr)* '>>' c=expr #Send\n");
+		grammarBuilder.append("    | ID #JustId //semantic check on modifiers\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("ID  : ('a'..'z'|'A'..'Z'|'_')\n");
+		grammarBuilder.append("      ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a*b,c,x*y>>r";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (expr (expr (expr a) * (expr b)) , (expr c) , (expr (expr x) * (expr y)) >> (expr r)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsList2_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(317);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : expr EOF;\n");
+		grammarBuilder.append("expr:\n");
+		grammarBuilder.append("    a=expr '*' a=expr #Factor\n");
+		grammarBuilder.append("    | b+=expr ',' b+=expr #Comma\n");
+		grammarBuilder.append("    | b+=expr '>>' c=expr #Send\n");
+		grammarBuilder.append("    | ID #JustId //semantic check on modifiers\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("ID  : ('a'..'z'|'A'..'Z'|'_')\n");
+		grammarBuilder.append("      ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a*b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (expr (expr a) * (expr b)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsList2_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(317);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : expr EOF;\n");
+		grammarBuilder.append("expr:\n");
+		grammarBuilder.append("    a=expr '*' a=expr #Factor\n");
+		grammarBuilder.append("    | b+=expr ',' b+=expr #Comma\n");
+		grammarBuilder.append("    | b+=expr '>>' c=expr #Send\n");
+		grammarBuilder.append("    | ID #JustId //semantic check on modifiers\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("ID  : ('a'..'z'|'A'..'Z'|'_')\n");
+		grammarBuilder.append("      ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a,c>>x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (expr (expr (expr a) , (expr c)) >> (expr x)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsList2_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(317);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : expr EOF;\n");
+		grammarBuilder.append("expr:\n");
+		grammarBuilder.append("    a=expr '*' a=expr #Factor\n");
+		grammarBuilder.append("    | b+=expr ',' b+=expr #Comma\n");
+		grammarBuilder.append("    | b+=expr '>>' c=expr #Send\n");
+		grammarBuilder.append("    | ID #JustId //semantic check on modifiers\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("ID  : ('a'..'z'|'A'..'Z'|'_')\n");
+		grammarBuilder.append("      ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (expr x) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsList2_4() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(317);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : expr EOF;\n");
+		grammarBuilder.append("expr:\n");
+		grammarBuilder.append("    a=expr '*' a=expr #Factor\n");
+		grammarBuilder.append("    | b+=expr ',' b+=expr #Comma\n");
+		grammarBuilder.append("    | b+=expr '>>' c=expr #Send\n");
+		grammarBuilder.append("    | ID #JustId //semantic check on modifiers\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("ID  : ('a'..'z'|'A'..'Z'|'_')\n");
+		grammarBuilder.append("      ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a*b,c,x*y>>r";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (expr (expr (expr (expr (expr a) * (expr b)) , (expr c)) , (expr (expr x) * (expr y))) >> (expr r)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActions_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(235);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {print($e.v)}; \n");
+		grammarBuilder.append("e returns [int v,  ignored]\n");
+		grammarBuilder.append("  : a=e '*' b=e {$v = $a.v * $b.v;}\n");
+		grammarBuilder.append("  | a=e '+' b=e {$v = $a.v + $b.v;}\n");
+		grammarBuilder.append("  | INT {$v = $INT.int;}\n");
+		grammarBuilder.append("  | '(' x=e ')' {$v = $x.v;}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;\n");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="4";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("4\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActions_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(235);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {print($e.v)}; \n");
+		grammarBuilder.append("e returns [int v,  ignored]\n");
+		grammarBuilder.append("  : a=e '*' b=e {$v = $a.v * $b.v;}\n");
+		grammarBuilder.append("  | a=e '+' b=e {$v = $a.v + $b.v;}\n");
+		grammarBuilder.append("  | INT {$v = $INT.int;}\n");
+		grammarBuilder.append("  | '(' x=e ')' {$v = $x.v;}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;\n");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="1+2";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("3\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActions_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(235);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {print($e.v)}; \n");
+		grammarBuilder.append("e returns [int v,  ignored]\n");
+		grammarBuilder.append("  : a=e '*' b=e {$v = $a.v * $b.v;}\n");
+		grammarBuilder.append("  | a=e '+' b=e {$v = $a.v + $b.v;}\n");
+		grammarBuilder.append("  | INT {$v = $INT.int;}\n");
+		grammarBuilder.append("  | '(' x=e ')' {$v = $x.v;}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;\n");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="1+2*3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("7\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActions_4() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(235);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {print($e.v)}; \n");
+		grammarBuilder.append("e returns [int v,  ignored]\n");
+		grammarBuilder.append("  : a=e '*' b=e {$v = $a.v * $b.v;}\n");
+		grammarBuilder.append("  | a=e '+' b=e {$v = $a.v + $b.v;}\n");
+		grammarBuilder.append("  | INT {$v = $INT.int;}\n");
+		grammarBuilder.append("  | '(' x=e ')' {$v = $x.v;}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;\n");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="(1+2)*3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("9\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSemPred() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(135);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : a ;\n");
+		grammarBuilder.append("a : a {True}? ID\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x y z";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (a (a (a x) y) z))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSemPredFailOption() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(159);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : a ;\n");
+		grammarBuilder.append("a : a ID {False}?<fail='custom message'>\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x y z";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (a (a x) y z))\n", found);
+
+		assertEquals("line 1:4 rule a custom message\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSimple_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(127);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : a ;\n");
+		grammarBuilder.append("a : a ID\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (a x))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSimple_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(127);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : a ;\n");
+		grammarBuilder.append("a : a ID\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x y";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (a (a x) y))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSimple_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(127);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : a ;\n");
+		grammarBuilder.append("a : a ID\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x y z";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (a (a (a x) y) z))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExprExplicitAssociativity_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(283);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e :<assoc=right> e '*' e\n");
+		grammarBuilder.append("  |<assoc=right> e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e a) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExprExplicitAssociativity_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(283);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e :<assoc=right> e '*' e\n");
+		grammarBuilder.append("  |<assoc=right> e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a+b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e a) + (e b)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExprExplicitAssociativity_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(283);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e :<assoc=right> e '*' e\n");
+		grammarBuilder.append("  |<assoc=right> e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a*b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e a) * (e b)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExprExplicitAssociativity_4() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(283);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e :<assoc=right> e '*' e\n");
+		grammarBuilder.append("  |<assoc=right> e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a?b:c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e a) ? (e b) : (e c)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExprExplicitAssociativity_5() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(283);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e :<assoc=right> e '*' e\n");
+		grammarBuilder.append("  |<assoc=right> e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a=b=c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e a) = (e (e b) = (e c))) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExprExplicitAssociativity_6() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(283);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e :<assoc=right> e '*' e\n");
+		grammarBuilder.append("  |<assoc=right> e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a?b+c:d";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e a) ? (e (e b) + (e c)) : (e d)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExprExplicitAssociativity_7() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(283);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e :<assoc=right> e '*' e\n");
+		grammarBuilder.append("  |<assoc=right> e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a?b=c:d";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e a) ? (e (e b) = (e c)) : (e d)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExprExplicitAssociativity_8() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(283);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e :<assoc=right> e '*' e\n");
+		grammarBuilder.append("  |<assoc=right> e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a? b?c:d : e";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e a) ? (e (e b) ? (e c) : (e d)) : (e e)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExprExplicitAssociativity_9() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(283);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e :<assoc=right> e '*' e\n");
+		grammarBuilder.append("  |<assoc=right> e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a?b: c?d:e";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e a) ? (e b) : (e (e c) ? (e d) : (e e))) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExpr_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(258);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e : e '*' e\n");
+		grammarBuilder.append("  | e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e a) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExpr_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(258);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e : e '*' e\n");
+		grammarBuilder.append("  | e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a+b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e a) + (e b)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExpr_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(258);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e : e '*' e\n");
+		grammarBuilder.append("  | e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a*b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e a) * (e b)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExpr_4() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(258);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e : e '*' e\n");
+		grammarBuilder.append("  | e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a?b:c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e a) ? (e b) : (e c)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExpr_5() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(258);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e : e '*' e\n");
+		grammarBuilder.append("  | e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a=b=c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e a) = (e (e b) = (e c))) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExpr_6() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(258);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e : e '*' e\n");
+		grammarBuilder.append("  | e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a?b+c:d";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e a) ? (e (e b) + (e c)) : (e d)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExpr_7() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(258);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e : e '*' e\n");
+		grammarBuilder.append("  | e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a?b=c:d";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e a) ? (e (e b) = (e c)) : (e d)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExpr_8() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(258);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e : e '*' e\n");
+		grammarBuilder.append("  | e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a? b?c:d : e";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e a) ? (e (e b) ? (e c) : (e d)) : (e e)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExpr_9() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(258);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e : e '*' e\n");
+		grammarBuilder.append("  | e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a?b: c?d:e";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e a) ? (e b) : (e (e c) ? (e d) : (e e))) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testWhitespaceInfluence_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(2763);
+		grammarBuilder.append("grammar Expr;\n");
+		grammarBuilder.append("prog : expression EOF;\n");
+		grammarBuilder.append("expression\n");
+		grammarBuilder.append("    : ID '(' expression (',' expression)* ')'               # doFunction\n");
+		grammarBuilder.append("    | '(' expression ')'                                    # doParenthesis\n");
+		grammarBuilder.append("    | '!' expression                                        # doNot\n");
+		grammarBuilder.append("    | '-' expression                                        # doNegate\n");
+		grammarBuilder.append("    | '+' expression                                        # doPositiv\n");
+		grammarBuilder.append("    | expression '^' expression                             # doPower\n");
+		grammarBuilder.append("    | expression '*' expression                             # doMultipy\n");
+		grammarBuilder.append("    | expression '/' expression                             # doDivide\n");
+		grammarBuilder.append("    | expression '%' expression                             # doModulo\n");
+		grammarBuilder.append("    | expression '-' expression                             # doMinus\n");
+		grammarBuilder.append("    | expression '+' expression                             # doPlus\n");
+		grammarBuilder.append("    | expression '=' expression                             # doEqual\n");
+		grammarBuilder.append("    | expression '!=' expression                            # doNotEqual\n");
+		grammarBuilder.append("    | expression '>' expression                             # doGreather\n");
+		grammarBuilder.append("    | expression '>=' expression                            # doGreatherEqual\n");
+		grammarBuilder.append("    | expression '<' expression                             # doLesser\n");
+		grammarBuilder.append("    | expression '<=' expression                            # doLesserEqual\n");
+		grammarBuilder.append("    | expression K_IN '(' expression (',' expression)* ')'  # doIn\n");
+		grammarBuilder.append("    | expression ( '&' | K_AND) expression                  # doAnd\n");
+		grammarBuilder.append("    | expression ( '|' | K_OR) expression                   # doOr\n");
+		grammarBuilder.append("    | '[' expression (',' expression)* ']'                  # newArray\n");
+		grammarBuilder.append("    | K_TRUE                                                # newTrueBoolean\n");
+		grammarBuilder.append("    | K_FALSE                                               # newFalseBoolean\n");
+		grammarBuilder.append("    | NUMBER                                                # newNumber\n");
+		grammarBuilder.append("    | DATE                                                  # newDateTime\n");
+		grammarBuilder.append("    | ID                                                    # newIdentifier\n");
+		grammarBuilder.append("    | SQ_STRING                                             # newString\n");
+		grammarBuilder.append("    | K_NULL                                                # newNull\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("// Fragments\n");
+		grammarBuilder.append("fragment DIGIT    : '0' .. '9';  \n");
+		grammarBuilder.append("fragment UPPER    : 'A' .. 'Z';\n");
+		grammarBuilder.append("fragment LOWER    : 'a' .. 'z';\n");
+		grammarBuilder.append("fragment LETTER   : LOWER | UPPER;\n");
+		grammarBuilder.append("fragment WORD     : LETTER | '_' | '$' | '#' | '.';\n");
+		grammarBuilder.append("fragment ALPHANUM : WORD | DIGIT;  \n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("// Tokens\n");
+		grammarBuilder.append("ID              : LETTER ALPHANUM*;\n");
+		grammarBuilder.append("NUMBER          : DIGIT+ ('.' DIGIT+)? (('e'|'E')('+'|'-')? DIGIT+)?;\n");
+		grammarBuilder.append("DATE            : '\\'' DIGIT DIGIT DIGIT DIGIT '-' DIGIT DIGIT '-' DIGIT DIGIT (' ' DIGIT DIGIT ':' DIGIT DIGIT ':' DIGIT DIGIT ('.' DIGIT+)?)? '\\'';\n");
+		grammarBuilder.append("SQ_STRING       : '\\'' ('\\'\\'' | ~'\\'')* '\\'';\n");
+		grammarBuilder.append("DQ_STRING       : '\"' ('\\\\\"' | ~'\"')* '\"';\n");
+		grammarBuilder.append("WS              : [ \\t\\n\\r]+ -> skip ;\n");
+		grammarBuilder.append("COMMENTS        : ('/*' .*? '*/' | '//' ~'\\n'* '\\n' ) -> skip;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="Test(1,3)";
+		String found = execParser("Expr.g4", grammar, "ExprParser", "ExprLexer", "ExprListener", "ExprVisitor", "prog", input, false);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testWhitespaceInfluence_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(2763);
+		grammarBuilder.append("grammar Expr;\n");
+		grammarBuilder.append("prog : expression EOF;\n");
+		grammarBuilder.append("expression\n");
+		grammarBuilder.append("    : ID '(' expression (',' expression)* ')'               # doFunction\n");
+		grammarBuilder.append("    | '(' expression ')'                                    # doParenthesis\n");
+		grammarBuilder.append("    | '!' expression                                        # doNot\n");
+		grammarBuilder.append("    | '-' expression                                        # doNegate\n");
+		grammarBuilder.append("    | '+' expression                                        # doPositiv\n");
+		grammarBuilder.append("    | expression '^' expression                             # doPower\n");
+		grammarBuilder.append("    | expression '*' expression                             # doMultipy\n");
+		grammarBuilder.append("    | expression '/' expression                             # doDivide\n");
+		grammarBuilder.append("    | expression '%' expression                             # doModulo\n");
+		grammarBuilder.append("    | expression '-' expression                             # doMinus\n");
+		grammarBuilder.append("    | expression '+' expression                             # doPlus\n");
+		grammarBuilder.append("    | expression '=' expression                             # doEqual\n");
+		grammarBuilder.append("    | expression '!=' expression                            # doNotEqual\n");
+		grammarBuilder.append("    | expression '>' expression                             # doGreather\n");
+		grammarBuilder.append("    | expression '>=' expression                            # doGreatherEqual\n");
+		grammarBuilder.append("    | expression '<' expression                             # doLesser\n");
+		grammarBuilder.append("    | expression '<=' expression                            # doLesserEqual\n");
+		grammarBuilder.append("    | expression K_IN '(' expression (',' expression)* ')'  # doIn\n");
+		grammarBuilder.append("    | expression ( '&' | K_AND) expression                  # doAnd\n");
+		grammarBuilder.append("    | expression ( '|' | K_OR) expression                   # doOr\n");
+		grammarBuilder.append("    | '[' expression (',' expression)* ']'                  # newArray\n");
+		grammarBuilder.append("    | K_TRUE                                                # newTrueBoolean\n");
+		grammarBuilder.append("    | K_FALSE                                               # newFalseBoolean\n");
+		grammarBuilder.append("    | NUMBER                                                # newNumber\n");
+		grammarBuilder.append("    | DATE                                                  # newDateTime\n");
+		grammarBuilder.append("    | ID                                                    # newIdentifier\n");
+		grammarBuilder.append("    | SQ_STRING                                             # newString\n");
+		grammarBuilder.append("    | K_NULL                                                # newNull\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("// Fragments\n");
+		grammarBuilder.append("fragment DIGIT    : '0' .. '9';  \n");
+		grammarBuilder.append("fragment UPPER    : 'A' .. 'Z';\n");
+		grammarBuilder.append("fragment LOWER    : 'a' .. 'z';\n");
+		grammarBuilder.append("fragment LETTER   : LOWER | UPPER;\n");
+		grammarBuilder.append("fragment WORD     : LETTER | '_' | '$' | '#' | '.';\n");
+		grammarBuilder.append("fragment ALPHANUM : WORD | DIGIT;  \n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("// Tokens\n");
+		grammarBuilder.append("ID              : LETTER ALPHANUM*;\n");
+		grammarBuilder.append("NUMBER          : DIGIT+ ('.' DIGIT+)? (('e'|'E')('+'|'-')? DIGIT+)?;\n");
+		grammarBuilder.append("DATE            : '\\'' DIGIT DIGIT DIGIT DIGIT '-' DIGIT DIGIT '-' DIGIT DIGIT (' ' DIGIT DIGIT ':' DIGIT DIGIT ':' DIGIT DIGIT ('.' DIGIT+)?)? '\\'';\n");
+		grammarBuilder.append("SQ_STRING       : '\\'' ('\\'\\'' | ~'\\'')* '\\'';\n");
+		grammarBuilder.append("DQ_STRING       : '\"' ('\\\\\"' | ~'\"')* '\"';\n");
+		grammarBuilder.append("WS              : [ \\t\\n\\r]+ -> skip ;\n");
+		grammarBuilder.append("COMMENTS        : ('/*' .*? '*/' | '//' ~'\\n'* '\\n' ) -> skip;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="Test(1, 3)";
+		String found = execParser("Expr.g4", grammar, "ExprParser", "ExprLexer", "ExprListener", "ExprVisitor", "prog", input, false);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+
+}
\ No newline at end of file
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/python2/TestLexerErrors.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/python2/TestLexerErrors.java
new file mode 100644
index 000000000..f95ddd109
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/python2/TestLexerErrors.java
@@ -0,0 +1,258 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.python2;
+
+import org.junit.Ignore;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+@SuppressWarnings("unused")
+public class TestLexerErrors extends BasePython2Test {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDFAToATNThatFailsBackToDFA() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(39);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : 'ab' ;\n");
+		grammarBuilder.append("B : 'abc' ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="ababx";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:1='ab',<1>,1:0]\n" +
+			"[@1,2:3='ab',<1>,1:2]\n" +
+			"[@2,5:4='<EOF>',<-1>,1:5]\n", found);
+
+		assertEquals("line 1:4 token recognition error at: 'x'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDFAToATNThatMatchesThenFailsInATN() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(52);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : 'ab' ;\n");
+		grammarBuilder.append("B : 'abc' ;\n");
+		grammarBuilder.append("C : 'abcd' ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="ababcx";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:1='ab',<1>,1:0]\n" +
+			"[@1,2:4='abc',<2>,1:2]\n" +
+			"[@2,6:5='<EOF>',<-1>,1:6]\n", found);
+
+		assertEquals("line 1:5 token recognition error at: 'x'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testEnforcedGreedyNestedBrances_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(77);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("ACTION : '{' (ACTION | ~[{}])* '}';\n");
+		grammarBuilder.append("WS : [ \\r\\n\\t]+ -> skip;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="{ { } }";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:6='{ { } }',<1>,1:0]\n" +
+			"[@1,7:6='<EOF>',<-1>,1:7]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testEnforcedGreedyNestedBrances_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(77);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("ACTION : '{' (ACTION | ~[{}])* '}';\n");
+		grammarBuilder.append("WS : [ \\r\\n\\t]+ -> skip;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="{ { }";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals("[@0,5:4='<EOF>',<-1>,1:5]\n", found);
+
+		assertEquals("line 1:0 token recognition error at: '{ { }'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testErrorInMiddle() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(28);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : 'abc' ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="abx";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals("[@0,3:2='<EOF>',<-1>,1:3]\n", found);
+
+		assertEquals("line 1:0 token recognition error at: 'abx'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testInvalidCharAtStart() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(30);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : 'a' 'b' ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="x";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals("[@0,1:0='<EOF>',<-1>,1:1]\n", found);
+
+		assertEquals("line 1:0 token recognition error at: 'x'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testInvalidCharAtStartAfterDFACache() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(30);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : 'a' 'b' ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="abx";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:1='ab',<1>,1:0]\n" +
+			"[@1,3:2='<EOF>',<-1>,1:3]\n", found);
+
+		assertEquals("line 1:2 token recognition error at: 'x'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testInvalidCharInToken() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(30);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : 'a' 'b' ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="ax";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals("[@0,2:1='<EOF>',<-1>,1:2]\n", found);
+
+		assertEquals("line 1:0 token recognition error at: 'ax'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testInvalidCharInTokenAfterDFACache() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(30);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : 'a' 'b' ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="abax";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:1='ab',<1>,1:0]\n" +
+			"[@1,4:3='<EOF>',<-1>,1:4]\n", found);
+
+		assertEquals("line 1:2 token recognition error at: 'ax'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLexerExecDFA() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(98);
+		grammarBuilder.append("grammar L;\n");
+		grammarBuilder.append("start : ID ':' expr;\n");
+		grammarBuilder.append("expr : primary expr? {} | expr '->' ID;\n");
+		grammarBuilder.append("primary : ID;\n");
+		grammarBuilder.append("ID : [a-z]+;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="x : x";
+		String found = execLexer("L.g4", grammar, "LLexer", input, false);
+		assertEquals(
+			"[@0,0:0='x',<3>,1:0]\n" +
+			"[@1,2:2=':',<1>,1:2]\n" +
+			"[@2,4:4='x',<3>,1:4]\n" +
+			"[@3,5:4='<EOF>',<-1>,1:5]\n", found);
+
+		assertEquals(
+			"line 1:1 token recognition error at: ' '\n" +
+			"line 1:3 token recognition error at: ' '\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testStringsEmbeddedInActions_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(109);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("ACTION2 : '[' (STRING | ~'\"')*? ']';\n");
+		grammarBuilder.append("STRING : '\"' ('\\\"' | .)*? '\"';\n");
+		grammarBuilder.append("WS : [ \\t\\r\\n]+ -> skip;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="[\"foo\"]";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:6='[\"foo\"]',<1>,1:0]\n" +
+			"[@1,7:6='<EOF>',<-1>,1:7]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testStringsEmbeddedInActions_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(109);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("ACTION2 : '[' (STRING | ~'\"')*? ']';\n");
+		grammarBuilder.append("STRING : '\"' ('\\\"' | .)*? '\"';\n");
+		grammarBuilder.append("WS : [ \\t\\r\\n]+ -> skip;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="[\"foo]";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals("[@0,6:5='<EOF>',<-1>,1:6]\n", found);
+
+		assertEquals("line 1:0 token recognition error at: '[\"foo]'\n", this.stderrDuringParse);
+
+	}
+
+
+}
\ No newline at end of file
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/python2/TestLexerExec.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/python2/TestLexerExec.java
new file mode 100644
index 000000000..b9b1186e8
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/python2/TestLexerExec.java
@@ -0,0 +1,4996 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.python2;
+
+import org.junit.Ignore;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+@SuppressWarnings("unused")
+public class TestLexerExec extends BasePython2Test {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testActionPlacement() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(228);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("I : ({print(\"stuff fail: \" + self.text)} 'a'\n");
+		grammarBuilder.append("| {print(\"stuff0: \" + self.text)}\n");
+		grammarBuilder.append("		'a' {print(\"stuff1: \" + self.text)}\n");
+		grammarBuilder.append("		'b' {print(\"stuff2: \" + self.text)})\n");
+		grammarBuilder.append("		{print(self.text)} ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;\n");
+		grammarBuilder.append("J : .;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="ab";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"stuff0: \n" +
+			"stuff1: a\n" +
+			"stuff2: ab\n" +
+			"ab\n" +
+			"[@0,0:1='ab',<1>,1:0]\n" +
+			"[@1,2:1='<EOF>',<-1>,1:2]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(72);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("I : '0'..'9'+ {print(\"I\")} ;\n");
+		grammarBuilder.append("WS : [ \\n\\u000D] -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+		String input =
+			"34\n" +
+			" 34";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"I\n" +
+			"I\n" +
+			"[@0,0:1='34',<1>,1:0]\n" +
+			"[@1,4:5='34',<1>,2:1]\n" +
+			"[@2,6:5='<EOF>',<-1>,2:3]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetInSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(79);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("I : (~[ab \\n]|'a')  {print(\"I\")} ;\n");
+		grammarBuilder.append("WS : [ \\n\\u000D]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="a x";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"I\n" +
+			"I\n" +
+			"[@0,0:0='a',<1>,1:0]\n" +
+			"[@1,2:2='x',<1>,1:2]\n" +
+			"[@2,3:2='<EOF>',<-1>,1:3]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetNot() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(82);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("I : ~[ab \\n] ~[ \\ncd]* {print(\"I\")} ;\n");
+		grammarBuilder.append("WS : [ \\n\\u000D]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="xaf";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"I\n" +
+			"[@0,0:2='xaf',<1>,1:0]\n" +
+			"[@1,3:2='<EOF>',<-1>,1:3]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetPlus() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(73);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("I : '0'..'9'+ {print(\"I\")} ;\n");
+		grammarBuilder.append("WS : [ \\n\\u000D]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+		String input =
+			"34\n" +
+			" 34";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"I\n" +
+			"I\n" +
+			"[@0,0:1='34',<1>,1:0]\n" +
+			"[@1,4:5='34',<1>,2:1]\n" +
+			"[@2,6:5='<EOF>',<-1>,2:3]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetRange() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(115);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("I : [0-9]+ {print(\"I\")} ;\n");
+		grammarBuilder.append("ID : [a-zA-Z] [a-zA-Z0-9]* {print(\"ID\")} ;\n");
+		grammarBuilder.append("WS : [ \\n\\u0009\\r]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+		String input =
+			"34\n" +
+			" 34 a2 abc \n" +
+			"   ";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"I\n" +
+			"I\n" +
+			"ID\n" +
+			"ID\n" +
+			"[@0,0:1='34',<1>,1:0]\n" +
+			"[@1,4:5='34',<1>,2:1]\n" +
+			"[@2,7:8='a2',<2>,2:4]\n" +
+			"[@3,10:12='abc',<2>,2:7]\n" +
+			"[@4,18:17='<EOF>',<-1>,3:3]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetWithEscapedChar() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(81);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("DASHBRACK : [\\-\\]]+ {print(\"DASHBRACK\")} ;\n");
+		grammarBuilder.append("WS : [ \\u]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="- ] ";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"DASHBRACK\n" +
+			"DASHBRACK\n" +
+			"[@0,0:0='-',<1>,1:0]\n" +
+			"[@1,2:2=']',<1>,1:2]\n" +
+			"[@2,4:3='<EOF>',<-1>,1:4]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetWithMissingEndRange() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(69);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("I : [0-]+ {print(\"I\")} ;\n");
+		grammarBuilder.append("WS : [ \\n\\u000D]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="00\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"I\n" +
+			"[@0,0:1='00',<1>,1:0]\n" +
+			"[@1,3:2='<EOF>',<-1>,2:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetWithMissingEscapeChar() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(64);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("I : [0-9]+ {print(\"I\")} ;\n");
+		grammarBuilder.append("WS : [ \\u]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="34 ";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"I\n" +
+			"[@0,0:1='34',<1>,1:0]\n" +
+			"[@1,3:2='<EOF>',<-1>,1:3]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetWithQuote1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(67);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : [\"a-z]+ {print(\"A\")} ;\n");
+		grammarBuilder.append("WS : [ \\n\\t]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="b\"a";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"A\n" +
+			"[@0,0:2='b\"a',<1>,1:0]\n" +
+			"[@1,3:2='<EOF>',<-1>,1:3]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetWithQuote2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(68);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : [\"\\\\ab]+ {print(\"A\")} ;\n");
+		grammarBuilder.append("WS : [ \\n\\t]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="b\"\\a";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"A\n" +
+			"[@0,0:3='b\"\\a',<1>,1:0]\n" +
+			"[@1,4:3='<EOF>',<-1>,1:4]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetWithReversedRange() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(65);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : [z-a9]+ {print(\"A\")} ;\n");
+		grammarBuilder.append("WS : [ \\u]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="9";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"A\n" +
+			"[@0,0:0='9',<1>,1:0]\n" +
+			"[@1,1:0='<EOF>',<-1>,1:1]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testEOFByItself() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(38);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("DONE : EOF ;\n");
+		grammarBuilder.append("A : 'a';");
+		String grammar = grammarBuilder.toString();
+
+		String input ="";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:-1='<EOF>',<1>,1:0]\n" +
+			"[@1,0:-1='<EOF>',<-1>,1:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testEOFSuffixInFirstRule_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(48);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : 'a' EOF ;\n");
+		grammarBuilder.append("B : 'a';\n");
+		grammarBuilder.append("C : 'c';");
+		String grammar = grammarBuilder.toString();
+
+		String input ="";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals("[@0,0:-1='<EOF>',<-1>,1:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testEOFSuffixInFirstRule_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(48);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : 'a' EOF ;\n");
+		grammarBuilder.append("B : 'a';\n");
+		grammarBuilder.append("C : 'c';");
+		String grammar = grammarBuilder.toString();
+
+		String input ="a";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:0='a',<1>,1:0]\n" +
+			"[@1,1:0='<EOF>',<-1>,1:1]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testGreedyClosure() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(60);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("CMT : '//' .*? '\\n' CMT*;\n");
+		grammarBuilder.append("WS : (' '|'\\t')+;");
+		String grammar = grammarBuilder.toString();
+
+		String input =
+			"//blah\n" +
+			"//blah\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:13='//blah\\n//blah\\n',<1>,1:0]\n" +
+			"[@1,14:13='<EOF>',<-1>,3:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testGreedyConfigs() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(87);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("I : ('a' | 'ab') {print(self.text)} ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;\n");
+		grammarBuilder.append("J : .;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="ab";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"ab\n" +
+			"[@0,0:1='ab',<1>,1:0]\n" +
+			"[@1,2:1='<EOF>',<-1>,1:2]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testGreedyOptional() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(60);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("CMT : '//' .*? '\\n' CMT?;\n");
+		grammarBuilder.append("WS : (' '|'\\t')+;");
+		String grammar = grammarBuilder.toString();
+
+		String input =
+			"//blah\n" +
+			"//blah\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:13='//blah\\n//blah\\n',<1>,1:0]\n" +
+			"[@1,14:13='<EOF>',<-1>,3:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testGreedyPositiveClosure() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(58);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("CMT : ('//' .*? '\\n')+;\n");
+		grammarBuilder.append("WS : (' '|'\\t')+;");
+		String grammar = grammarBuilder.toString();
+
+		String input =
+			"//blah\n" +
+			"//blah\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:13='//blah\\n//blah\\n',<1>,1:0]\n" +
+			"[@1,14:13='<EOF>',<-1>,3:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testHexVsID() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(265);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("HexLiteral : '0' ('x'|'X') HexDigit+ ;\n");
+		grammarBuilder.append("DecimalLiteral : ('0' | '1'..'9' '0'..'9'*) ;\n");
+		grammarBuilder.append("FloatingPointLiteral : ('0x' | '0X') HexDigit* ('.' HexDigit*)? ;\n");
+		grammarBuilder.append("DOT : '.' ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("fragment HexDigit : ('0'..'9'|'a'..'f'|'A'..'F') ;\n");
+		grammarBuilder.append("WS : (' '|'\\n')+;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="x 0 1 a.b a.l";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:0='x',<5>,1:0]\n" +
+			"[@1,1:1=' ',<6>,1:1]\n" +
+			"[@2,2:2='0',<2>,1:2]\n" +
+			"[@3,3:3=' ',<6>,1:3]\n" +
+			"[@4,4:4='1',<2>,1:4]\n" +
+			"[@5,5:5=' ',<6>,1:5]\n" +
+			"[@6,6:6='a',<5>,1:6]\n" +
+			"[@7,7:7='.',<4>,1:7]\n" +
+			"[@8,8:8='b',<5>,1:8]\n" +
+			"[@9,9:9=' ',<6>,1:9]\n" +
+			"[@10,10:10='a',<5>,1:10]\n" +
+			"[@11,11:11='.',<4>,1:11]\n" +
+			"[@12,12:12='l',<5>,1:12]\n" +
+			"[@13,13:12='<EOF>',<-1>,1:13]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testKeywordID() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(82);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("KEND : 'end' ; // has priority\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n')+;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="end eend ending a";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:2='end',<1>,1:0]\n" +
+			"[@1,3:3=' ',<3>,1:3]\n" +
+			"[@2,4:7='eend',<2>,1:4]\n" +
+			"[@3,8:8=' ',<3>,1:8]\n" +
+			"[@4,9:14='ending',<2>,1:9]\n" +
+			"[@5,15:15=' ',<3>,1:15]\n" +
+			"[@6,16:16='a',<2>,1:16]\n" +
+			"[@7,17:16='<EOF>',<-1>,1:17]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLargeLexer() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(85821);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("WS : [ \\t\\r\\n]+ -> skip;\n");
+		grammarBuilder.append("KW0 : 'KW' '0';\n");
+		grammarBuilder.append("KW1 : 'KW' '1';\n");
+		grammarBuilder.append("KW2 : 'KW' '2';\n");
+		grammarBuilder.append("KW3 : 'KW' '3';\n");
+		grammarBuilder.append("KW4 : 'KW' '4';\n");
+		grammarBuilder.append("KW5 : 'KW' '5';\n");
+		grammarBuilder.append("KW6 : 'KW' '6';\n");
+		grammarBuilder.append("KW7 : 'KW' '7';\n");
+		grammarBuilder.append("KW8 : 'KW' '8';\n");
+		grammarBuilder.append("KW9 : 'KW' '9';\n");
+		grammarBuilder.append("KW10 : 'KW' '10';\n");
+		grammarBuilder.append("KW11 : 'KW' '11';\n");
+		grammarBuilder.append("KW12 : 'KW' '12';\n");
+		grammarBuilder.append("KW13 : 'KW' '13';\n");
+		grammarBuilder.append("KW14 : 'KW' '14';\n");
+		grammarBuilder.append("KW15 : 'KW' '15';\n");
+		grammarBuilder.append("KW16 : 'KW' '16';\n");
+		grammarBuilder.append("KW17 : 'KW' '17';\n");
+		grammarBuilder.append("KW18 : 'KW' '18';\n");
+		grammarBuilder.append("KW19 : 'KW' '19';\n");
+		grammarBuilder.append("KW20 : 'KW' '20';\n");
+		grammarBuilder.append("KW21 : 'KW' '21';\n");
+		grammarBuilder.append("KW22 : 'KW' '22';\n");
+		grammarBuilder.append("KW23 : 'KW' '23';\n");
+		grammarBuilder.append("KW24 : 'KW' '24';\n");
+		grammarBuilder.append("KW25 : 'KW' '25';\n");
+		grammarBuilder.append("KW26 : 'KW' '26';\n");
+		grammarBuilder.append("KW27 : 'KW' '27';\n");
+		grammarBuilder.append("KW28 : 'KW' '28';\n");
+		grammarBuilder.append("KW29 : 'KW' '29';\n");
+		grammarBuilder.append("KW30 : 'KW' '30';\n");
+		grammarBuilder.append("KW31 : 'KW' '31';\n");
+		grammarBuilder.append("KW32 : 'KW' '32';\n");
+		grammarBuilder.append("KW33 : 'KW' '33';\n");
+		grammarBuilder.append("KW34 : 'KW' '34';\n");
+		grammarBuilder.append("KW35 : 'KW' '35';\n");
+		grammarBuilder.append("KW36 : 'KW' '36';\n");
+		grammarBuilder.append("KW37 : 'KW' '37';\n");
+		grammarBuilder.append("KW38 : 'KW' '38';\n");
+		grammarBuilder.append("KW39 : 'KW' '39';\n");
+		grammarBuilder.append("KW40 : 'KW' '40';\n");
+		grammarBuilder.append("KW41 : 'KW' '41';\n");
+		grammarBuilder.append("KW42 : 'KW' '42';\n");
+		grammarBuilder.append("KW43 : 'KW' '43';\n");
+		grammarBuilder.append("KW44 : 'KW' '44';\n");
+		grammarBuilder.append("KW45 : 'KW' '45';\n");
+		grammarBuilder.append("KW46 : 'KW' '46';\n");
+		grammarBuilder.append("KW47 : 'KW' '47';\n");
+		grammarBuilder.append("KW48 : 'KW' '48';\n");
+		grammarBuilder.append("KW49 : 'KW' '49';\n");
+		grammarBuilder.append("KW50 : 'KW' '50';\n");
+		grammarBuilder.append("KW51 : 'KW' '51';\n");
+		grammarBuilder.append("KW52 : 'KW' '52';\n");
+		grammarBuilder.append("KW53 : 'KW' '53';\n");
+		grammarBuilder.append("KW54 : 'KW' '54';\n");
+		grammarBuilder.append("KW55 : 'KW' '55';\n");
+		grammarBuilder.append("KW56 : 'KW' '56';\n");
+		grammarBuilder.append("KW57 : 'KW' '57';\n");
+		grammarBuilder.append("KW58 : 'KW' '58';\n");
+		grammarBuilder.append("KW59 : 'KW' '59';\n");
+		grammarBuilder.append("KW60 : 'KW' '60';\n");
+		grammarBuilder.append("KW61 : 'KW' '61';\n");
+		grammarBuilder.append("KW62 : 'KW' '62';\n");
+		grammarBuilder.append("KW63 : 'KW' '63';\n");
+		grammarBuilder.append("KW64 : 'KW' '64';\n");
+		grammarBuilder.append("KW65 : 'KW' '65';\n");
+		grammarBuilder.append("KW66 : 'KW' '66';\n");
+		grammarBuilder.append("KW67 : 'KW' '67';\n");
+		grammarBuilder.append("KW68 : 'KW' '68';\n");
+		grammarBuilder.append("KW69 : 'KW' '69';\n");
+		grammarBuilder.append("KW70 : 'KW' '70';\n");
+		grammarBuilder.append("KW71 : 'KW' '71';\n");
+		grammarBuilder.append("KW72 : 'KW' '72';\n");
+		grammarBuilder.append("KW73 : 'KW' '73';\n");
+		grammarBuilder.append("KW74 : 'KW' '74';\n");
+		grammarBuilder.append("KW75 : 'KW' '75';\n");
+		grammarBuilder.append("KW76 : 'KW' '76';\n");
+		grammarBuilder.append("KW77 : 'KW' '77';\n");
+		grammarBuilder.append("KW78 : 'KW' '78';\n");
+		grammarBuilder.append("KW79 : 'KW' '79';\n");
+		grammarBuilder.append("KW80 : 'KW' '80';\n");
+		grammarBuilder.append("KW81 : 'KW' '81';\n");
+		grammarBuilder.append("KW82 : 'KW' '82';\n");
+		grammarBuilder.append("KW83 : 'KW' '83';\n");
+		grammarBuilder.append("KW84 : 'KW' '84';\n");
+		grammarBuilder.append("KW85 : 'KW' '85';\n");
+		grammarBuilder.append("KW86 : 'KW' '86';\n");
+		grammarBuilder.append("KW87 : 'KW' '87';\n");
+		grammarBuilder.append("KW88 : 'KW' '88';\n");
+		grammarBuilder.append("KW89 : 'KW' '89';\n");
+		grammarBuilder.append("KW90 : 'KW' '90';\n");
+		grammarBuilder.append("KW91 : 'KW' '91';\n");
+		grammarBuilder.append("KW92 : 'KW' '92';\n");
+		grammarBuilder.append("KW93 : 'KW' '93';\n");
+		grammarBuilder.append("KW94 : 'KW' '94';\n");
+		grammarBuilder.append("KW95 : 'KW' '95';\n");
+		grammarBuilder.append("KW96 : 'KW' '96';\n");
+		grammarBuilder.append("KW97 : 'KW' '97';\n");
+		grammarBuilder.append("KW98 : 'KW' '98';\n");
+		grammarBuilder.append("KW99 : 'KW' '99';\n");
+		grammarBuilder.append("KW100 : 'KW' '100';\n");
+		grammarBuilder.append("KW101 : 'KW' '101';\n");
+		grammarBuilder.append("KW102 : 'KW' '102';\n");
+		grammarBuilder.append("KW103 : 'KW' '103';\n");
+		grammarBuilder.append("KW104 : 'KW' '104';\n");
+		grammarBuilder.append("KW105 : 'KW' '105';\n");
+		grammarBuilder.append("KW106 : 'KW' '106';\n");
+		grammarBuilder.append("KW107 : 'KW' '107';\n");
+		grammarBuilder.append("KW108 : 'KW' '108';\n");
+		grammarBuilder.append("KW109 : 'KW' '109';\n");
+		grammarBuilder.append("KW110 : 'KW' '110';\n");
+		grammarBuilder.append("KW111 : 'KW' '111';\n");
+		grammarBuilder.append("KW112 : 'KW' '112';\n");
+		grammarBuilder.append("KW113 : 'KW' '113';\n");
+		grammarBuilder.append("KW114 : 'KW' '114';\n");
+		grammarBuilder.append("KW115 : 'KW' '115';\n");
+		grammarBuilder.append("KW116 : 'KW' '116';\n");
+		grammarBuilder.append("KW117 : 'KW' '117';\n");
+		grammarBuilder.append("KW118 : 'KW' '118';\n");
+		grammarBuilder.append("KW119 : 'KW' '119';\n");
+		grammarBuilder.append("KW120 : 'KW' '120';\n");
+		grammarBuilder.append("KW121 : 'KW' '121';\n");
+		grammarBuilder.append("KW122 : 'KW' '122';\n");
+		grammarBuilder.append("KW123 : 'KW' '123';\n");
+		grammarBuilder.append("KW124 : 'KW' '124';\n");
+		grammarBuilder.append("KW125 : 'KW' '125';\n");
+		grammarBuilder.append("KW126 : 'KW' '126';\n");
+		grammarBuilder.append("KW127 : 'KW' '127';\n");
+		grammarBuilder.append("KW128 : 'KW' '128';\n");
+		grammarBuilder.append("KW129 : 'KW' '129';\n");
+		grammarBuilder.append("KW130 : 'KW' '130';\n");
+		grammarBuilder.append("KW131 : 'KW' '131';\n");
+		grammarBuilder.append("KW132 : 'KW' '132';\n");
+		grammarBuilder.append("KW133 : 'KW' '133';\n");
+		grammarBuilder.append("KW134 : 'KW' '134';\n");
+		grammarBuilder.append("KW135 : 'KW' '135';\n");
+		grammarBuilder.append("KW136 : 'KW' '136';\n");
+		grammarBuilder.append("KW137 : 'KW' '137';\n");
+		grammarBuilder.append("KW138 : 'KW' '138';\n");
+		grammarBuilder.append("KW139 : 'KW' '139';\n");
+		grammarBuilder.append("KW140 : 'KW' '140';\n");
+		grammarBuilder.append("KW141 : 'KW' '141';\n");
+		grammarBuilder.append("KW142 : 'KW' '142';\n");
+		grammarBuilder.append("KW143 : 'KW' '143';\n");
+		grammarBuilder.append("KW144 : 'KW' '144';\n");
+		grammarBuilder.append("KW145 : 'KW' '145';\n");
+		grammarBuilder.append("KW146 : 'KW' '146';\n");
+		grammarBuilder.append("KW147 : 'KW' '147';\n");
+		grammarBuilder.append("KW148 : 'KW' '148';\n");
+		grammarBuilder.append("KW149 : 'KW' '149';\n");
+		grammarBuilder.append("KW150 : 'KW' '150';\n");
+		grammarBuilder.append("KW151 : 'KW' '151';\n");
+		grammarBuilder.append("KW152 : 'KW' '152';\n");
+		grammarBuilder.append("KW153 : 'KW' '153';\n");
+		grammarBuilder.append("KW154 : 'KW' '154';\n");
+		grammarBuilder.append("KW155 : 'KW' '155';\n");
+		grammarBuilder.append("KW156 : 'KW' '156';\n");
+		grammarBuilder.append("KW157 : 'KW' '157';\n");
+		grammarBuilder.append("KW158 : 'KW' '158';\n");
+		grammarBuilder.append("KW159 : 'KW' '159';\n");
+		grammarBuilder.append("KW160 : 'KW' '160';\n");
+		grammarBuilder.append("KW161 : 'KW' '161';\n");
+		grammarBuilder.append("KW162 : 'KW' '162';\n");
+		grammarBuilder.append("KW163 : 'KW' '163';\n");
+		grammarBuilder.append("KW164 : 'KW' '164';\n");
+		grammarBuilder.append("KW165 : 'KW' '165';\n");
+		grammarBuilder.append("KW166 : 'KW' '166';\n");
+		grammarBuilder.append("KW167 : 'KW' '167';\n");
+		grammarBuilder.append("KW168 : 'KW' '168';\n");
+		grammarBuilder.append("KW169 : 'KW' '169';\n");
+		grammarBuilder.append("KW170 : 'KW' '170';\n");
+		grammarBuilder.append("KW171 : 'KW' '171';\n");
+		grammarBuilder.append("KW172 : 'KW' '172';\n");
+		grammarBuilder.append("KW173 : 'KW' '173';\n");
+		grammarBuilder.append("KW174 : 'KW' '174';\n");
+		grammarBuilder.append("KW175 : 'KW' '175';\n");
+		grammarBuilder.append("KW176 : 'KW' '176';\n");
+		grammarBuilder.append("KW177 : 'KW' '177';\n");
+		grammarBuilder.append("KW178 : 'KW' '178';\n");
+		grammarBuilder.append("KW179 : 'KW' '179';\n");
+		grammarBuilder.append("KW180 : 'KW' '180';\n");
+		grammarBuilder.append("KW181 : 'KW' '181';\n");
+		grammarBuilder.append("KW182 : 'KW' '182';\n");
+		grammarBuilder.append("KW183 : 'KW' '183';\n");
+		grammarBuilder.append("KW184 : 'KW' '184';\n");
+		grammarBuilder.append("KW185 : 'KW' '185';\n");
+		grammarBuilder.append("KW186 : 'KW' '186';\n");
+		grammarBuilder.append("KW187 : 'KW' '187';\n");
+		grammarBuilder.append("KW188 : 'KW' '188';\n");
+		grammarBuilder.append("KW189 : 'KW' '189';\n");
+		grammarBuilder.append("KW190 : 'KW' '190';\n");
+		grammarBuilder.append("KW191 : 'KW' '191';\n");
+		grammarBuilder.append("KW192 : 'KW' '192';\n");
+		grammarBuilder.append("KW193 : 'KW' '193';\n");
+		grammarBuilder.append("KW194 : 'KW' '194';\n");
+		grammarBuilder.append("KW195 : 'KW' '195';\n");
+		grammarBuilder.append("KW196 : 'KW' '196';\n");
+		grammarBuilder.append("KW197 : 'KW' '197';\n");
+		grammarBuilder.append("KW198 : 'KW' '198';\n");
+		grammarBuilder.append("KW199 : 'KW' '199';\n");
+		grammarBuilder.append("KW200 : 'KW' '200';\n");
+		grammarBuilder.append("KW201 : 'KW' '201';\n");
+		grammarBuilder.append("KW202 : 'KW' '202';\n");
+		grammarBuilder.append("KW203 : 'KW' '203';\n");
+		grammarBuilder.append("KW204 : 'KW' '204';\n");
+		grammarBuilder.append("KW205 : 'KW' '205';\n");
+		grammarBuilder.append("KW206 : 'KW' '206';\n");
+		grammarBuilder.append("KW207 : 'KW' '207';\n");
+		grammarBuilder.append("KW208 : 'KW' '208';\n");
+		grammarBuilder.append("KW209 : 'KW' '209';\n");
+		grammarBuilder.append("KW210 : 'KW' '210';\n");
+		grammarBuilder.append("KW211 : 'KW' '211';\n");
+		grammarBuilder.append("KW212 : 'KW' '212';\n");
+		grammarBuilder.append("KW213 : 'KW' '213';\n");
+		grammarBuilder.append("KW214 : 'KW' '214';\n");
+		grammarBuilder.append("KW215 : 'KW' '215';\n");
+		grammarBuilder.append("KW216 : 'KW' '216';\n");
+		grammarBuilder.append("KW217 : 'KW' '217';\n");
+		grammarBuilder.append("KW218 : 'KW' '218';\n");
+		grammarBuilder.append("KW219 : 'KW' '219';\n");
+		grammarBuilder.append("KW220 : 'KW' '220';\n");
+		grammarBuilder.append("KW221 : 'KW' '221';\n");
+		grammarBuilder.append("KW222 : 'KW' '222';\n");
+		grammarBuilder.append("KW223 : 'KW' '223';\n");
+		grammarBuilder.append("KW224 : 'KW' '224';\n");
+		grammarBuilder.append("KW225 : 'KW' '225';\n");
+		grammarBuilder.append("KW226 : 'KW' '226';\n");
+		grammarBuilder.append("KW227 : 'KW' '227';\n");
+		grammarBuilder.append("KW228 : 'KW' '228';\n");
+		grammarBuilder.append("KW229 : 'KW' '229';\n");
+		grammarBuilder.append("KW230 : 'KW' '230';\n");
+		grammarBuilder.append("KW231 : 'KW' '231';\n");
+		grammarBuilder.append("KW232 : 'KW' '232';\n");
+		grammarBuilder.append("KW233 : 'KW' '233';\n");
+		grammarBuilder.append("KW234 : 'KW' '234';\n");
+		grammarBuilder.append("KW235 : 'KW' '235';\n");
+		grammarBuilder.append("KW236 : 'KW' '236';\n");
+		grammarBuilder.append("KW237 : 'KW' '237';\n");
+		grammarBuilder.append("KW238 : 'KW' '238';\n");
+		grammarBuilder.append("KW239 : 'KW' '239';\n");
+		grammarBuilder.append("KW240 : 'KW' '240';\n");
+		grammarBuilder.append("KW241 : 'KW' '241';\n");
+		grammarBuilder.append("KW242 : 'KW' '242';\n");
+		grammarBuilder.append("KW243 : 'KW' '243';\n");
+		grammarBuilder.append("KW244 : 'KW' '244';\n");
+		grammarBuilder.append("KW245 : 'KW' '245';\n");
+		grammarBuilder.append("KW246 : 'KW' '246';\n");
+		grammarBuilder.append("KW247 : 'KW' '247';\n");
+		grammarBuilder.append("KW248 : 'KW' '248';\n");
+		grammarBuilder.append("KW249 : 'KW' '249';\n");
+		grammarBuilder.append("KW250 : 'KW' '250';\n");
+		grammarBuilder.append("KW251 : 'KW' '251';\n");
+		grammarBuilder.append("KW252 : 'KW' '252';\n");
+		grammarBuilder.append("KW253 : 'KW' '253';\n");
+		grammarBuilder.append("KW254 : 'KW' '254';\n");
+		grammarBuilder.append("KW255 : 'KW' '255';\n");
+		grammarBuilder.append("KW256 : 'KW' '256';\n");
+		grammarBuilder.append("KW257 : 'KW' '257';\n");
+		grammarBuilder.append("KW258 : 'KW' '258';\n");
+		grammarBuilder.append("KW259 : 'KW' '259';\n");
+		grammarBuilder.append("KW260 : 'KW' '260';\n");
+		grammarBuilder.append("KW261 : 'KW' '261';\n");
+		grammarBuilder.append("KW262 : 'KW' '262';\n");
+		grammarBuilder.append("KW263 : 'KW' '263';\n");
+		grammarBuilder.append("KW264 : 'KW' '264';\n");
+		grammarBuilder.append("KW265 : 'KW' '265';\n");
+		grammarBuilder.append("KW266 : 'KW' '266';\n");
+		grammarBuilder.append("KW267 : 'KW' '267';\n");
+		grammarBuilder.append("KW268 : 'KW' '268';\n");
+		grammarBuilder.append("KW269 : 'KW' '269';\n");
+		grammarBuilder.append("KW270 : 'KW' '270';\n");
+		grammarBuilder.append("KW271 : 'KW' '271';\n");
+		grammarBuilder.append("KW272 : 'KW' '272';\n");
+		grammarBuilder.append("KW273 : 'KW' '273';\n");
+		grammarBuilder.append("KW274 : 'KW' '274';\n");
+		grammarBuilder.append("KW275 : 'KW' '275';\n");
+		grammarBuilder.append("KW276 : 'KW' '276';\n");
+		grammarBuilder.append("KW277 : 'KW' '277';\n");
+		grammarBuilder.append("KW278 : 'KW' '278';\n");
+		grammarBuilder.append("KW279 : 'KW' '279';\n");
+		grammarBuilder.append("KW280 : 'KW' '280';\n");
+		grammarBuilder.append("KW281 : 'KW' '281';\n");
+		grammarBuilder.append("KW282 : 'KW' '282';\n");
+		grammarBuilder.append("KW283 : 'KW' '283';\n");
+		grammarBuilder.append("KW284 : 'KW' '284';\n");
+		grammarBuilder.append("KW285 : 'KW' '285';\n");
+		grammarBuilder.append("KW286 : 'KW' '286';\n");
+		grammarBuilder.append("KW287 : 'KW' '287';\n");
+		grammarBuilder.append("KW288 : 'KW' '288';\n");
+		grammarBuilder.append("KW289 : 'KW' '289';\n");
+		grammarBuilder.append("KW290 : 'KW' '290';\n");
+		grammarBuilder.append("KW291 : 'KW' '291';\n");
+		grammarBuilder.append("KW292 : 'KW' '292';\n");
+		grammarBuilder.append("KW293 : 'KW' '293';\n");
+		grammarBuilder.append("KW294 : 'KW' '294';\n");
+		grammarBuilder.append("KW295 : 'KW' '295';\n");
+		grammarBuilder.append("KW296 : 'KW' '296';\n");
+		grammarBuilder.append("KW297 : 'KW' '297';\n");
+		grammarBuilder.append("KW298 : 'KW' '298';\n");
+		grammarBuilder.append("KW299 : 'KW' '299';\n");
+		grammarBuilder.append("KW300 : 'KW' '300';\n");
+		grammarBuilder.append("KW301 : 'KW' '301';\n");
+		grammarBuilder.append("KW302 : 'KW' '302';\n");
+		grammarBuilder.append("KW303 : 'KW' '303';\n");
+		grammarBuilder.append("KW304 : 'KW' '304';\n");
+		grammarBuilder.append("KW305 : 'KW' '305';\n");
+		grammarBuilder.append("KW306 : 'KW' '306';\n");
+		grammarBuilder.append("KW307 : 'KW' '307';\n");
+		grammarBuilder.append("KW308 : 'KW' '308';\n");
+		grammarBuilder.append("KW309 : 'KW' '309';\n");
+		grammarBuilder.append("KW310 : 'KW' '310';\n");
+		grammarBuilder.append("KW311 : 'KW' '311';\n");
+		grammarBuilder.append("KW312 : 'KW' '312';\n");
+		grammarBuilder.append("KW313 : 'KW' '313';\n");
+		grammarBuilder.append("KW314 : 'KW' '314';\n");
+		grammarBuilder.append("KW315 : 'KW' '315';\n");
+		grammarBuilder.append("KW316 : 'KW' '316';\n");
+		grammarBuilder.append("KW317 : 'KW' '317';\n");
+		grammarBuilder.append("KW318 : 'KW' '318';\n");
+		grammarBuilder.append("KW319 : 'KW' '319';\n");
+		grammarBuilder.append("KW320 : 'KW' '320';\n");
+		grammarBuilder.append("KW321 : 'KW' '321';\n");
+		grammarBuilder.append("KW322 : 'KW' '322';\n");
+		grammarBuilder.append("KW323 : 'KW' '323';\n");
+		grammarBuilder.append("KW324 : 'KW' '324';\n");
+		grammarBuilder.append("KW325 : 'KW' '325';\n");
+		grammarBuilder.append("KW326 : 'KW' '326';\n");
+		grammarBuilder.append("KW327 : 'KW' '327';\n");
+		grammarBuilder.append("KW328 : 'KW' '328';\n");
+		grammarBuilder.append("KW329 : 'KW' '329';\n");
+		grammarBuilder.append("KW330 : 'KW' '330';\n");
+		grammarBuilder.append("KW331 : 'KW' '331';\n");
+		grammarBuilder.append("KW332 : 'KW' '332';\n");
+		grammarBuilder.append("KW333 : 'KW' '333';\n");
+		grammarBuilder.append("KW334 : 'KW' '334';\n");
+		grammarBuilder.append("KW335 : 'KW' '335';\n");
+		grammarBuilder.append("KW336 : 'KW' '336';\n");
+		grammarBuilder.append("KW337 : 'KW' '337';\n");
+		grammarBuilder.append("KW338 : 'KW' '338';\n");
+		grammarBuilder.append("KW339 : 'KW' '339';\n");
+		grammarBuilder.append("KW340 : 'KW' '340';\n");
+		grammarBuilder.append("KW341 : 'KW' '341';\n");
+		grammarBuilder.append("KW342 : 'KW' '342';\n");
+		grammarBuilder.append("KW343 : 'KW' '343';\n");
+		grammarBuilder.append("KW344 : 'KW' '344';\n");
+		grammarBuilder.append("KW345 : 'KW' '345';\n");
+		grammarBuilder.append("KW346 : 'KW' '346';\n");
+		grammarBuilder.append("KW347 : 'KW' '347';\n");
+		grammarBuilder.append("KW348 : 'KW' '348';\n");
+		grammarBuilder.append("KW349 : 'KW' '349';\n");
+		grammarBuilder.append("KW350 : 'KW' '350';\n");
+		grammarBuilder.append("KW351 : 'KW' '351';\n");
+		grammarBuilder.append("KW352 : 'KW' '352';\n");
+		grammarBuilder.append("KW353 : 'KW' '353';\n");
+		grammarBuilder.append("KW354 : 'KW' '354';\n");
+		grammarBuilder.append("KW355 : 'KW' '355';\n");
+		grammarBuilder.append("KW356 : 'KW' '356';\n");
+		grammarBuilder.append("KW357 : 'KW' '357';\n");
+		grammarBuilder.append("KW358 : 'KW' '358';\n");
+		grammarBuilder.append("KW359 : 'KW' '359';\n");
+		grammarBuilder.append("KW360 : 'KW' '360';\n");
+		grammarBuilder.append("KW361 : 'KW' '361';\n");
+		grammarBuilder.append("KW362 : 'KW' '362';\n");
+		grammarBuilder.append("KW363 : 'KW' '363';\n");
+		grammarBuilder.append("KW364 : 'KW' '364';\n");
+		grammarBuilder.append("KW365 : 'KW' '365';\n");
+		grammarBuilder.append("KW366 : 'KW' '366';\n");
+		grammarBuilder.append("KW367 : 'KW' '367';\n");
+		grammarBuilder.append("KW368 : 'KW' '368';\n");
+		grammarBuilder.append("KW369 : 'KW' '369';\n");
+		grammarBuilder.append("KW370 : 'KW' '370';\n");
+		grammarBuilder.append("KW371 : 'KW' '371';\n");
+		grammarBuilder.append("KW372 : 'KW' '372';\n");
+		grammarBuilder.append("KW373 : 'KW' '373';\n");
+		grammarBuilder.append("KW374 : 'KW' '374';\n");
+		grammarBuilder.append("KW375 : 'KW' '375';\n");
+		grammarBuilder.append("KW376 : 'KW' '376';\n");
+		grammarBuilder.append("KW377 : 'KW' '377';\n");
+		grammarBuilder.append("KW378 : 'KW' '378';\n");
+		grammarBuilder.append("KW379 : 'KW' '379';\n");
+		grammarBuilder.append("KW380 : 'KW' '380';\n");
+		grammarBuilder.append("KW381 : 'KW' '381';\n");
+		grammarBuilder.append("KW382 : 'KW' '382';\n");
+		grammarBuilder.append("KW383 : 'KW' '383';\n");
+		grammarBuilder.append("KW384 : 'KW' '384';\n");
+		grammarBuilder.append("KW385 : 'KW' '385';\n");
+		grammarBuilder.append("KW386 : 'KW' '386';\n");
+		grammarBuilder.append("KW387 : 'KW' '387';\n");
+		grammarBuilder.append("KW388 : 'KW' '388';\n");
+		grammarBuilder.append("KW389 : 'KW' '389';\n");
+		grammarBuilder.append("KW390 : 'KW' '390';\n");
+		grammarBuilder.append("KW391 : 'KW' '391';\n");
+		grammarBuilder.append("KW392 : 'KW' '392';\n");
+		grammarBuilder.append("KW393 : 'KW' '393';\n");
+		grammarBuilder.append("KW394 : 'KW' '394';\n");
+		grammarBuilder.append("KW395 : 'KW' '395';\n");
+		grammarBuilder.append("KW396 : 'KW' '396';\n");
+		grammarBuilder.append("KW397 : 'KW' '397';\n");
+		grammarBuilder.append("KW398 : 'KW' '398';\n");
+		grammarBuilder.append("KW399 : 'KW' '399';\n");
+		grammarBuilder.append("KW400 : 'KW' '400';\n");
+		grammarBuilder.append("KW401 : 'KW' '401';\n");
+		grammarBuilder.append("KW402 : 'KW' '402';\n");
+		grammarBuilder.append("KW403 : 'KW' '403';\n");
+		grammarBuilder.append("KW404 : 'KW' '404';\n");
+		grammarBuilder.append("KW405 : 'KW' '405';\n");
+		grammarBuilder.append("KW406 : 'KW' '406';\n");
+		grammarBuilder.append("KW407 : 'KW' '407';\n");
+		grammarBuilder.append("KW408 : 'KW' '408';\n");
+		grammarBuilder.append("KW409 : 'KW' '409';\n");
+		grammarBuilder.append("KW410 : 'KW' '410';\n");
+		grammarBuilder.append("KW411 : 'KW' '411';\n");
+		grammarBuilder.append("KW412 : 'KW' '412';\n");
+		grammarBuilder.append("KW413 : 'KW' '413';\n");
+		grammarBuilder.append("KW414 : 'KW' '414';\n");
+		grammarBuilder.append("KW415 : 'KW' '415';\n");
+		grammarBuilder.append("KW416 : 'KW' '416';\n");
+		grammarBuilder.append("KW417 : 'KW' '417';\n");
+		grammarBuilder.append("KW418 : 'KW' '418';\n");
+		grammarBuilder.append("KW419 : 'KW' '419';\n");
+		grammarBuilder.append("KW420 : 'KW' '420';\n");
+		grammarBuilder.append("KW421 : 'KW' '421';\n");
+		grammarBuilder.append("KW422 : 'KW' '422';\n");
+		grammarBuilder.append("KW423 : 'KW' '423';\n");
+		grammarBuilder.append("KW424 : 'KW' '424';\n");
+		grammarBuilder.append("KW425 : 'KW' '425';\n");
+		grammarBuilder.append("KW426 : 'KW' '426';\n");
+		grammarBuilder.append("KW427 : 'KW' '427';\n");
+		grammarBuilder.append("KW428 : 'KW' '428';\n");
+		grammarBuilder.append("KW429 : 'KW' '429';\n");
+		grammarBuilder.append("KW430 : 'KW' '430';\n");
+		grammarBuilder.append("KW431 : 'KW' '431';\n");
+		grammarBuilder.append("KW432 : 'KW' '432';\n");
+		grammarBuilder.append("KW433 : 'KW' '433';\n");
+		grammarBuilder.append("KW434 : 'KW' '434';\n");
+		grammarBuilder.append("KW435 : 'KW' '435';\n");
+		grammarBuilder.append("KW436 : 'KW' '436';\n");
+		grammarBuilder.append("KW437 : 'KW' '437';\n");
+		grammarBuilder.append("KW438 : 'KW' '438';\n");
+		grammarBuilder.append("KW439 : 'KW' '439';\n");
+		grammarBuilder.append("KW440 : 'KW' '440';\n");
+		grammarBuilder.append("KW441 : 'KW' '441';\n");
+		grammarBuilder.append("KW442 : 'KW' '442';\n");
+		grammarBuilder.append("KW443 : 'KW' '443';\n");
+		grammarBuilder.append("KW444 : 'KW' '444';\n");
+		grammarBuilder.append("KW445 : 'KW' '445';\n");
+		grammarBuilder.append("KW446 : 'KW' '446';\n");
+		grammarBuilder.append("KW447 : 'KW' '447';\n");
+		grammarBuilder.append("KW448 : 'KW' '448';\n");
+		grammarBuilder.append("KW449 : 'KW' '449';\n");
+		grammarBuilder.append("KW450 : 'KW' '450';\n");
+		grammarBuilder.append("KW451 : 'KW' '451';\n");
+		grammarBuilder.append("KW452 : 'KW' '452';\n");
+		grammarBuilder.append("KW453 : 'KW' '453';\n");
+		grammarBuilder.append("KW454 : 'KW' '454';\n");
+		grammarBuilder.append("KW455 : 'KW' '455';\n");
+		grammarBuilder.append("KW456 : 'KW' '456';\n");
+		grammarBuilder.append("KW457 : 'KW' '457';\n");
+		grammarBuilder.append("KW458 : 'KW' '458';\n");
+		grammarBuilder.append("KW459 : 'KW' '459';\n");
+		grammarBuilder.append("KW460 : 'KW' '460';\n");
+		grammarBuilder.append("KW461 : 'KW' '461';\n");
+		grammarBuilder.append("KW462 : 'KW' '462';\n");
+		grammarBuilder.append("KW463 : 'KW' '463';\n");
+		grammarBuilder.append("KW464 : 'KW' '464';\n");
+		grammarBuilder.append("KW465 : 'KW' '465';\n");
+		grammarBuilder.append("KW466 : 'KW' '466';\n");
+		grammarBuilder.append("KW467 : 'KW' '467';\n");
+		grammarBuilder.append("KW468 : 'KW' '468';\n");
+		grammarBuilder.append("KW469 : 'KW' '469';\n");
+		grammarBuilder.append("KW470 : 'KW' '470';\n");
+		grammarBuilder.append("KW471 : 'KW' '471';\n");
+		grammarBuilder.append("KW472 : 'KW' '472';\n");
+		grammarBuilder.append("KW473 : 'KW' '473';\n");
+		grammarBuilder.append("KW474 : 'KW' '474';\n");
+		grammarBuilder.append("KW475 : 'KW' '475';\n");
+		grammarBuilder.append("KW476 : 'KW' '476';\n");
+		grammarBuilder.append("KW477 : 'KW' '477';\n");
+		grammarBuilder.append("KW478 : 'KW' '478';\n");
+		grammarBuilder.append("KW479 : 'KW' '479';\n");
+		grammarBuilder.append("KW480 : 'KW' '480';\n");
+		grammarBuilder.append("KW481 : 'KW' '481';\n");
+		grammarBuilder.append("KW482 : 'KW' '482';\n");
+		grammarBuilder.append("KW483 : 'KW' '483';\n");
+		grammarBuilder.append("KW484 : 'KW' '484';\n");
+		grammarBuilder.append("KW485 : 'KW' '485';\n");
+		grammarBuilder.append("KW486 : 'KW' '486';\n");
+		grammarBuilder.append("KW487 : 'KW' '487';\n");
+		grammarBuilder.append("KW488 : 'KW' '488';\n");
+		grammarBuilder.append("KW489 : 'KW' '489';\n");
+		grammarBuilder.append("KW490 : 'KW' '490';\n");
+		grammarBuilder.append("KW491 : 'KW' '491';\n");
+		grammarBuilder.append("KW492 : 'KW' '492';\n");
+		grammarBuilder.append("KW493 : 'KW' '493';\n");
+		grammarBuilder.append("KW494 : 'KW' '494';\n");
+		grammarBuilder.append("KW495 : 'KW' '495';\n");
+		grammarBuilder.append("KW496 : 'KW' '496';\n");
+		grammarBuilder.append("KW497 : 'KW' '497';\n");
+		grammarBuilder.append("KW498 : 'KW' '498';\n");
+		grammarBuilder.append("KW499 : 'KW' '499';\n");
+		grammarBuilder.append("KW500 : 'KW' '500';\n");
+		grammarBuilder.append("KW501 : 'KW' '501';\n");
+		grammarBuilder.append("KW502 : 'KW' '502';\n");
+		grammarBuilder.append("KW503 : 'KW' '503';\n");
+		grammarBuilder.append("KW504 : 'KW' '504';\n");
+		grammarBuilder.append("KW505 : 'KW' '505';\n");
+		grammarBuilder.append("KW506 : 'KW' '506';\n");
+		grammarBuilder.append("KW507 : 'KW' '507';\n");
+		grammarBuilder.append("KW508 : 'KW' '508';\n");
+		grammarBuilder.append("KW509 : 'KW' '509';\n");
+		grammarBuilder.append("KW510 : 'KW' '510';\n");
+		grammarBuilder.append("KW511 : 'KW' '511';\n");
+		grammarBuilder.append("KW512 : 'KW' '512';\n");
+		grammarBuilder.append("KW513 : 'KW' '513';\n");
+		grammarBuilder.append("KW514 : 'KW' '514';\n");
+		grammarBuilder.append("KW515 : 'KW' '515';\n");
+		grammarBuilder.append("KW516 : 'KW' '516';\n");
+		grammarBuilder.append("KW517 : 'KW' '517';\n");
+		grammarBuilder.append("KW518 : 'KW' '518';\n");
+		grammarBuilder.append("KW519 : 'KW' '519';\n");
+		grammarBuilder.append("KW520 : 'KW' '520';\n");
+		grammarBuilder.append("KW521 : 'KW' '521';\n");
+		grammarBuilder.append("KW522 : 'KW' '522';\n");
+		grammarBuilder.append("KW523 : 'KW' '523';\n");
+		grammarBuilder.append("KW524 : 'KW' '524';\n");
+		grammarBuilder.append("KW525 : 'KW' '525';\n");
+		grammarBuilder.append("KW526 : 'KW' '526';\n");
+		grammarBuilder.append("KW527 : 'KW' '527';\n");
+		grammarBuilder.append("KW528 : 'KW' '528';\n");
+		grammarBuilder.append("KW529 : 'KW' '529';\n");
+		grammarBuilder.append("KW530 : 'KW' '530';\n");
+		grammarBuilder.append("KW531 : 'KW' '531';\n");
+		grammarBuilder.append("KW532 : 'KW' '532';\n");
+		grammarBuilder.append("KW533 : 'KW' '533';\n");
+		grammarBuilder.append("KW534 : 'KW' '534';\n");
+		grammarBuilder.append("KW535 : 'KW' '535';\n");
+		grammarBuilder.append("KW536 : 'KW' '536';\n");
+		grammarBuilder.append("KW537 : 'KW' '537';\n");
+		grammarBuilder.append("KW538 : 'KW' '538';\n");
+		grammarBuilder.append("KW539 : 'KW' '539';\n");
+		grammarBuilder.append("KW540 : 'KW' '540';\n");
+		grammarBuilder.append("KW541 : 'KW' '541';\n");
+		grammarBuilder.append("KW542 : 'KW' '542';\n");
+		grammarBuilder.append("KW543 : 'KW' '543';\n");
+		grammarBuilder.append("KW544 : 'KW' '544';\n");
+		grammarBuilder.append("KW545 : 'KW' '545';\n");
+		grammarBuilder.append("KW546 : 'KW' '546';\n");
+		grammarBuilder.append("KW547 : 'KW' '547';\n");
+		grammarBuilder.append("KW548 : 'KW' '548';\n");
+		grammarBuilder.append("KW549 : 'KW' '549';\n");
+		grammarBuilder.append("KW550 : 'KW' '550';\n");
+		grammarBuilder.append("KW551 : 'KW' '551';\n");
+		grammarBuilder.append("KW552 : 'KW' '552';\n");
+		grammarBuilder.append("KW553 : 'KW' '553';\n");
+		grammarBuilder.append("KW554 : 'KW' '554';\n");
+		grammarBuilder.append("KW555 : 'KW' '555';\n");
+		grammarBuilder.append("KW556 : 'KW' '556';\n");
+		grammarBuilder.append("KW557 : 'KW' '557';\n");
+		grammarBuilder.append("KW558 : 'KW' '558';\n");
+		grammarBuilder.append("KW559 : 'KW' '559';\n");
+		grammarBuilder.append("KW560 : 'KW' '560';\n");
+		grammarBuilder.append("KW561 : 'KW' '561';\n");
+		grammarBuilder.append("KW562 : 'KW' '562';\n");
+		grammarBuilder.append("KW563 : 'KW' '563';\n");
+		grammarBuilder.append("KW564 : 'KW' '564';\n");
+		grammarBuilder.append("KW565 : 'KW' '565';\n");
+		grammarBuilder.append("KW566 : 'KW' '566';\n");
+		grammarBuilder.append("KW567 : 'KW' '567';\n");
+		grammarBuilder.append("KW568 : 'KW' '568';\n");
+		grammarBuilder.append("KW569 : 'KW' '569';\n");
+		grammarBuilder.append("KW570 : 'KW' '570';\n");
+		grammarBuilder.append("KW571 : 'KW' '571';\n");
+		grammarBuilder.append("KW572 : 'KW' '572';\n");
+		grammarBuilder.append("KW573 : 'KW' '573';\n");
+		grammarBuilder.append("KW574 : 'KW' '574';\n");
+		grammarBuilder.append("KW575 : 'KW' '575';\n");
+		grammarBuilder.append("KW576 : 'KW' '576';\n");
+		grammarBuilder.append("KW577 : 'KW' '577';\n");
+		grammarBuilder.append("KW578 : 'KW' '578';\n");
+		grammarBuilder.append("KW579 : 'KW' '579';\n");
+		grammarBuilder.append("KW580 : 'KW' '580';\n");
+		grammarBuilder.append("KW581 : 'KW' '581';\n");
+		grammarBuilder.append("KW582 : 'KW' '582';\n");
+		grammarBuilder.append("KW583 : 'KW' '583';\n");
+		grammarBuilder.append("KW584 : 'KW' '584';\n");
+		grammarBuilder.append("KW585 : 'KW' '585';\n");
+		grammarBuilder.append("KW586 : 'KW' '586';\n");
+		grammarBuilder.append("KW587 : 'KW' '587';\n");
+		grammarBuilder.append("KW588 : 'KW' '588';\n");
+		grammarBuilder.append("KW589 : 'KW' '589';\n");
+		grammarBuilder.append("KW590 : 'KW' '590';\n");
+		grammarBuilder.append("KW591 : 'KW' '591';\n");
+		grammarBuilder.append("KW592 : 'KW' '592';\n");
+		grammarBuilder.append("KW593 : 'KW' '593';\n");
+		grammarBuilder.append("KW594 : 'KW' '594';\n");
+		grammarBuilder.append("KW595 : 'KW' '595';\n");
+		grammarBuilder.append("KW596 : 'KW' '596';\n");
+		grammarBuilder.append("KW597 : 'KW' '597';\n");
+		grammarBuilder.append("KW598 : 'KW' '598';\n");
+		grammarBuilder.append("KW599 : 'KW' '599';\n");
+		grammarBuilder.append("KW600 : 'KW' '600';\n");
+		grammarBuilder.append("KW601 : 'KW' '601';\n");
+		grammarBuilder.append("KW602 : 'KW' '602';\n");
+		grammarBuilder.append("KW603 : 'KW' '603';\n");
+		grammarBuilder.append("KW604 : 'KW' '604';\n");
+		grammarBuilder.append("KW605 : 'KW' '605';\n");
+		grammarBuilder.append("KW606 : 'KW' '606';\n");
+		grammarBuilder.append("KW607 : 'KW' '607';\n");
+		grammarBuilder.append("KW608 : 'KW' '608';\n");
+		grammarBuilder.append("KW609 : 'KW' '609';\n");
+		grammarBuilder.append("KW610 : 'KW' '610';\n");
+		grammarBuilder.append("KW611 : 'KW' '611';\n");
+		grammarBuilder.append("KW612 : 'KW' '612';\n");
+		grammarBuilder.append("KW613 : 'KW' '613';\n");
+		grammarBuilder.append("KW614 : 'KW' '614';\n");
+		grammarBuilder.append("KW615 : 'KW' '615';\n");
+		grammarBuilder.append("KW616 : 'KW' '616';\n");
+		grammarBuilder.append("KW617 : 'KW' '617';\n");
+		grammarBuilder.append("KW618 : 'KW' '618';\n");
+		grammarBuilder.append("KW619 : 'KW' '619';\n");
+		grammarBuilder.append("KW620 : 'KW' '620';\n");
+		grammarBuilder.append("KW621 : 'KW' '621';\n");
+		grammarBuilder.append("KW622 : 'KW' '622';\n");
+		grammarBuilder.append("KW623 : 'KW' '623';\n");
+		grammarBuilder.append("KW624 : 'KW' '624';\n");
+		grammarBuilder.append("KW625 : 'KW' '625';\n");
+		grammarBuilder.append("KW626 : 'KW' '626';\n");
+		grammarBuilder.append("KW627 : 'KW' '627';\n");
+		grammarBuilder.append("KW628 : 'KW' '628';\n");
+		grammarBuilder.append("KW629 : 'KW' '629';\n");
+		grammarBuilder.append("KW630 : 'KW' '630';\n");
+		grammarBuilder.append("KW631 : 'KW' '631';\n");
+		grammarBuilder.append("KW632 : 'KW' '632';\n");
+		grammarBuilder.append("KW633 : 'KW' '633';\n");
+		grammarBuilder.append("KW634 : 'KW' '634';\n");
+		grammarBuilder.append("KW635 : 'KW' '635';\n");
+		grammarBuilder.append("KW636 : 'KW' '636';\n");
+		grammarBuilder.append("KW637 : 'KW' '637';\n");
+		grammarBuilder.append("KW638 : 'KW' '638';\n");
+		grammarBuilder.append("KW639 : 'KW' '639';\n");
+		grammarBuilder.append("KW640 : 'KW' '640';\n");
+		grammarBuilder.append("KW641 : 'KW' '641';\n");
+		grammarBuilder.append("KW642 : 'KW' '642';\n");
+		grammarBuilder.append("KW643 : 'KW' '643';\n");
+		grammarBuilder.append("KW644 : 'KW' '644';\n");
+		grammarBuilder.append("KW645 : 'KW' '645';\n");
+		grammarBuilder.append("KW646 : 'KW' '646';\n");
+		grammarBuilder.append("KW647 : 'KW' '647';\n");
+		grammarBuilder.append("KW648 : 'KW' '648';\n");
+		grammarBuilder.append("KW649 : 'KW' '649';\n");
+		grammarBuilder.append("KW650 : 'KW' '650';\n");
+		grammarBuilder.append("KW651 : 'KW' '651';\n");
+		grammarBuilder.append("KW652 : 'KW' '652';\n");
+		grammarBuilder.append("KW653 : 'KW' '653';\n");
+		grammarBuilder.append("KW654 : 'KW' '654';\n");
+		grammarBuilder.append("KW655 : 'KW' '655';\n");
+		grammarBuilder.append("KW656 : 'KW' '656';\n");
+		grammarBuilder.append("KW657 : 'KW' '657';\n");
+		grammarBuilder.append("KW658 : 'KW' '658';\n");
+		grammarBuilder.append("KW659 : 'KW' '659';\n");
+		grammarBuilder.append("KW660 : 'KW' '660';\n");
+		grammarBuilder.append("KW661 : 'KW' '661';\n");
+		grammarBuilder.append("KW662 : 'KW' '662';\n");
+		grammarBuilder.append("KW663 : 'KW' '663';\n");
+		grammarBuilder.append("KW664 : 'KW' '664';\n");
+		grammarBuilder.append("KW665 : 'KW' '665';\n");
+		grammarBuilder.append("KW666 : 'KW' '666';\n");
+		grammarBuilder.append("KW667 : 'KW' '667';\n");
+		grammarBuilder.append("KW668 : 'KW' '668';\n");
+		grammarBuilder.append("KW669 : 'KW' '669';\n");
+		grammarBuilder.append("KW670 : 'KW' '670';\n");
+		grammarBuilder.append("KW671 : 'KW' '671';\n");
+		grammarBuilder.append("KW672 : 'KW' '672';\n");
+		grammarBuilder.append("KW673 : 'KW' '673';\n");
+		grammarBuilder.append("KW674 : 'KW' '674';\n");
+		grammarBuilder.append("KW675 : 'KW' '675';\n");
+		grammarBuilder.append("KW676 : 'KW' '676';\n");
+		grammarBuilder.append("KW677 : 'KW' '677';\n");
+		grammarBuilder.append("KW678 : 'KW' '678';\n");
+		grammarBuilder.append("KW679 : 'KW' '679';\n");
+		grammarBuilder.append("KW680 : 'KW' '680';\n");
+		grammarBuilder.append("KW681 : 'KW' '681';\n");
+		grammarBuilder.append("KW682 : 'KW' '682';\n");
+		grammarBuilder.append("KW683 : 'KW' '683';\n");
+		grammarBuilder.append("KW684 : 'KW' '684';\n");
+		grammarBuilder.append("KW685 : 'KW' '685';\n");
+		grammarBuilder.append("KW686 : 'KW' '686';\n");
+		grammarBuilder.append("KW687 : 'KW' '687';\n");
+		grammarBuilder.append("KW688 : 'KW' '688';\n");
+		grammarBuilder.append("KW689 : 'KW' '689';\n");
+		grammarBuilder.append("KW690 : 'KW' '690';\n");
+		grammarBuilder.append("KW691 : 'KW' '691';\n");
+		grammarBuilder.append("KW692 : 'KW' '692';\n");
+		grammarBuilder.append("KW693 : 'KW' '693';\n");
+		grammarBuilder.append("KW694 : 'KW' '694';\n");
+		grammarBuilder.append("KW695 : 'KW' '695';\n");
+		grammarBuilder.append("KW696 : 'KW' '696';\n");
+		grammarBuilder.append("KW697 : 'KW' '697';\n");
+		grammarBuilder.append("KW698 : 'KW' '698';\n");
+		grammarBuilder.append("KW699 : 'KW' '699';\n");
+		grammarBuilder.append("KW700 : 'KW' '700';\n");
+		grammarBuilder.append("KW701 : 'KW' '701';\n");
+		grammarBuilder.append("KW702 : 'KW' '702';\n");
+		grammarBuilder.append("KW703 : 'KW' '703';\n");
+		grammarBuilder.append("KW704 : 'KW' '704';\n");
+		grammarBuilder.append("KW705 : 'KW' '705';\n");
+		grammarBuilder.append("KW706 : 'KW' '706';\n");
+		grammarBuilder.append("KW707 : 'KW' '707';\n");
+		grammarBuilder.append("KW708 : 'KW' '708';\n");
+		grammarBuilder.append("KW709 : 'KW' '709';\n");
+		grammarBuilder.append("KW710 : 'KW' '710';\n");
+		grammarBuilder.append("KW711 : 'KW' '711';\n");
+		grammarBuilder.append("KW712 : 'KW' '712';\n");
+		grammarBuilder.append("KW713 : 'KW' '713';\n");
+		grammarBuilder.append("KW714 : 'KW' '714';\n");
+		grammarBuilder.append("KW715 : 'KW' '715';\n");
+		grammarBuilder.append("KW716 : 'KW' '716';\n");
+		grammarBuilder.append("KW717 : 'KW' '717';\n");
+		grammarBuilder.append("KW718 : 'KW' '718';\n");
+		grammarBuilder.append("KW719 : 'KW' '719';\n");
+		grammarBuilder.append("KW720 : 'KW' '720';\n");
+		grammarBuilder.append("KW721 : 'KW' '721';\n");
+		grammarBuilder.append("KW722 : 'KW' '722';\n");
+		grammarBuilder.append("KW723 : 'KW' '723';\n");
+		grammarBuilder.append("KW724 : 'KW' '724';\n");
+		grammarBuilder.append("KW725 : 'KW' '725';\n");
+		grammarBuilder.append("KW726 : 'KW' '726';\n");
+		grammarBuilder.append("KW727 : 'KW' '727';\n");
+		grammarBuilder.append("KW728 : 'KW' '728';\n");
+		grammarBuilder.append("KW729 : 'KW' '729';\n");
+		grammarBuilder.append("KW730 : 'KW' '730';\n");
+		grammarBuilder.append("KW731 : 'KW' '731';\n");
+		grammarBuilder.append("KW732 : 'KW' '732';\n");
+		grammarBuilder.append("KW733 : 'KW' '733';\n");
+		grammarBuilder.append("KW734 : 'KW' '734';\n");
+		grammarBuilder.append("KW735 : 'KW' '735';\n");
+		grammarBuilder.append("KW736 : 'KW' '736';\n");
+		grammarBuilder.append("KW737 : 'KW' '737';\n");
+		grammarBuilder.append("KW738 : 'KW' '738';\n");
+		grammarBuilder.append("KW739 : 'KW' '739';\n");
+		grammarBuilder.append("KW740 : 'KW' '740';\n");
+		grammarBuilder.append("KW741 : 'KW' '741';\n");
+		grammarBuilder.append("KW742 : 'KW' '742';\n");
+		grammarBuilder.append("KW743 : 'KW' '743';\n");
+		grammarBuilder.append("KW744 : 'KW' '744';\n");
+		grammarBuilder.append("KW745 : 'KW' '745';\n");
+		grammarBuilder.append("KW746 : 'KW' '746';\n");
+		grammarBuilder.append("KW747 : 'KW' '747';\n");
+		grammarBuilder.append("KW748 : 'KW' '748';\n");
+		grammarBuilder.append("KW749 : 'KW' '749';\n");
+		grammarBuilder.append("KW750 : 'KW' '750';\n");
+		grammarBuilder.append("KW751 : 'KW' '751';\n");
+		grammarBuilder.append("KW752 : 'KW' '752';\n");
+		grammarBuilder.append("KW753 : 'KW' '753';\n");
+		grammarBuilder.append("KW754 : 'KW' '754';\n");
+		grammarBuilder.append("KW755 : 'KW' '755';\n");
+		grammarBuilder.append("KW756 : 'KW' '756';\n");
+		grammarBuilder.append("KW757 : 'KW' '757';\n");
+		grammarBuilder.append("KW758 : 'KW' '758';\n");
+		grammarBuilder.append("KW759 : 'KW' '759';\n");
+		grammarBuilder.append("KW760 : 'KW' '760';\n");
+		grammarBuilder.append("KW761 : 'KW' '761';\n");
+		grammarBuilder.append("KW762 : 'KW' '762';\n");
+		grammarBuilder.append("KW763 : 'KW' '763';\n");
+		grammarBuilder.append("KW764 : 'KW' '764';\n");
+		grammarBuilder.append("KW765 : 'KW' '765';\n");
+		grammarBuilder.append("KW766 : 'KW' '766';\n");
+		grammarBuilder.append("KW767 : 'KW' '767';\n");
+		grammarBuilder.append("KW768 : 'KW' '768';\n");
+		grammarBuilder.append("KW769 : 'KW' '769';\n");
+		grammarBuilder.append("KW770 : 'KW' '770';\n");
+		grammarBuilder.append("KW771 : 'KW' '771';\n");
+		grammarBuilder.append("KW772 : 'KW' '772';\n");
+		grammarBuilder.append("KW773 : 'KW' '773';\n");
+		grammarBuilder.append("KW774 : 'KW' '774';\n");
+		grammarBuilder.append("KW775 : 'KW' '775';\n");
+		grammarBuilder.append("KW776 : 'KW' '776';\n");
+		grammarBuilder.append("KW777 : 'KW' '777';\n");
+		grammarBuilder.append("KW778 : 'KW' '778';\n");
+		grammarBuilder.append("KW779 : 'KW' '779';\n");
+		grammarBuilder.append("KW780 : 'KW' '780';\n");
+		grammarBuilder.append("KW781 : 'KW' '781';\n");
+		grammarBuilder.append("KW782 : 'KW' '782';\n");
+		grammarBuilder.append("KW783 : 'KW' '783';\n");
+		grammarBuilder.append("KW784 : 'KW' '784';\n");
+		grammarBuilder.append("KW785 : 'KW' '785';\n");
+		grammarBuilder.append("KW786 : 'KW' '786';\n");
+		grammarBuilder.append("KW787 : 'KW' '787';\n");
+		grammarBuilder.append("KW788 : 'KW' '788';\n");
+		grammarBuilder.append("KW789 : 'KW' '789';\n");
+		grammarBuilder.append("KW790 : 'KW' '790';\n");
+		grammarBuilder.append("KW791 : 'KW' '791';\n");
+		grammarBuilder.append("KW792 : 'KW' '792';\n");
+		grammarBuilder.append("KW793 : 'KW' '793';\n");
+		grammarBuilder.append("KW794 : 'KW' '794';\n");
+		grammarBuilder.append("KW795 : 'KW' '795';\n");
+		grammarBuilder.append("KW796 : 'KW' '796';\n");
+		grammarBuilder.append("KW797 : 'KW' '797';\n");
+		grammarBuilder.append("KW798 : 'KW' '798';\n");
+		grammarBuilder.append("KW799 : 'KW' '799';\n");
+		grammarBuilder.append("KW800 : 'KW' '800';\n");
+		grammarBuilder.append("KW801 : 'KW' '801';\n");
+		grammarBuilder.append("KW802 : 'KW' '802';\n");
+		grammarBuilder.append("KW803 : 'KW' '803';\n");
+		grammarBuilder.append("KW804 : 'KW' '804';\n");
+		grammarBuilder.append("KW805 : 'KW' '805';\n");
+		grammarBuilder.append("KW806 : 'KW' '806';\n");
+		grammarBuilder.append("KW807 : 'KW' '807';\n");
+		grammarBuilder.append("KW808 : 'KW' '808';\n");
+		grammarBuilder.append("KW809 : 'KW' '809';\n");
+		grammarBuilder.append("KW810 : 'KW' '810';\n");
+		grammarBuilder.append("KW811 : 'KW' '811';\n");
+		grammarBuilder.append("KW812 : 'KW' '812';\n");
+		grammarBuilder.append("KW813 : 'KW' '813';\n");
+		grammarBuilder.append("KW814 : 'KW' '814';\n");
+		grammarBuilder.append("KW815 : 'KW' '815';\n");
+		grammarBuilder.append("KW816 : 'KW' '816';\n");
+		grammarBuilder.append("KW817 : 'KW' '817';\n");
+		grammarBuilder.append("KW818 : 'KW' '818';\n");
+		grammarBuilder.append("KW819 : 'KW' '819';\n");
+		grammarBuilder.append("KW820 : 'KW' '820';\n");
+		grammarBuilder.append("KW821 : 'KW' '821';\n");
+		grammarBuilder.append("KW822 : 'KW' '822';\n");
+		grammarBuilder.append("KW823 : 'KW' '823';\n");
+		grammarBuilder.append("KW824 : 'KW' '824';\n");
+		grammarBuilder.append("KW825 : 'KW' '825';\n");
+		grammarBuilder.append("KW826 : 'KW' '826';\n");
+		grammarBuilder.append("KW827 : 'KW' '827';\n");
+		grammarBuilder.append("KW828 : 'KW' '828';\n");
+		grammarBuilder.append("KW829 : 'KW' '829';\n");
+		grammarBuilder.append("KW830 : 'KW' '830';\n");
+		grammarBuilder.append("KW831 : 'KW' '831';\n");
+		grammarBuilder.append("KW832 : 'KW' '832';\n");
+		grammarBuilder.append("KW833 : 'KW' '833';\n");
+		grammarBuilder.append("KW834 : 'KW' '834';\n");
+		grammarBuilder.append("KW835 : 'KW' '835';\n");
+		grammarBuilder.append("KW836 : 'KW' '836';\n");
+		grammarBuilder.append("KW837 : 'KW' '837';\n");
+		grammarBuilder.append("KW838 : 'KW' '838';\n");
+		grammarBuilder.append("KW839 : 'KW' '839';\n");
+		grammarBuilder.append("KW840 : 'KW' '840';\n");
+		grammarBuilder.append("KW841 : 'KW' '841';\n");
+		grammarBuilder.append("KW842 : 'KW' '842';\n");
+		grammarBuilder.append("KW843 : 'KW' '843';\n");
+		grammarBuilder.append("KW844 : 'KW' '844';\n");
+		grammarBuilder.append("KW845 : 'KW' '845';\n");
+		grammarBuilder.append("KW846 : 'KW' '846';\n");
+		grammarBuilder.append("KW847 : 'KW' '847';\n");
+		grammarBuilder.append("KW848 : 'KW' '848';\n");
+		grammarBuilder.append("KW849 : 'KW' '849';\n");
+		grammarBuilder.append("KW850 : 'KW' '850';\n");
+		grammarBuilder.append("KW851 : 'KW' '851';\n");
+		grammarBuilder.append("KW852 : 'KW' '852';\n");
+		grammarBuilder.append("KW853 : 'KW' '853';\n");
+		grammarBuilder.append("KW854 : 'KW' '854';\n");
+		grammarBuilder.append("KW855 : 'KW' '855';\n");
+		grammarBuilder.append("KW856 : 'KW' '856';\n");
+		grammarBuilder.append("KW857 : 'KW' '857';\n");
+		grammarBuilder.append("KW858 : 'KW' '858';\n");
+		grammarBuilder.append("KW859 : 'KW' '859';\n");
+		grammarBuilder.append("KW860 : 'KW' '860';\n");
+		grammarBuilder.append("KW861 : 'KW' '861';\n");
+		grammarBuilder.append("KW862 : 'KW' '862';\n");
+		grammarBuilder.append("KW863 : 'KW' '863';\n");
+		grammarBuilder.append("KW864 : 'KW' '864';\n");
+		grammarBuilder.append("KW865 : 'KW' '865';\n");
+		grammarBuilder.append("KW866 : 'KW' '866';\n");
+		grammarBuilder.append("KW867 : 'KW' '867';\n");
+		grammarBuilder.append("KW868 : 'KW' '868';\n");
+		grammarBuilder.append("KW869 : 'KW' '869';\n");
+		grammarBuilder.append("KW870 : 'KW' '870';\n");
+		grammarBuilder.append("KW871 : 'KW' '871';\n");
+		grammarBuilder.append("KW872 : 'KW' '872';\n");
+		grammarBuilder.append("KW873 : 'KW' '873';\n");
+		grammarBuilder.append("KW874 : 'KW' '874';\n");
+		grammarBuilder.append("KW875 : 'KW' '875';\n");
+		grammarBuilder.append("KW876 : 'KW' '876';\n");
+		grammarBuilder.append("KW877 : 'KW' '877';\n");
+		grammarBuilder.append("KW878 : 'KW' '878';\n");
+		grammarBuilder.append("KW879 : 'KW' '879';\n");
+		grammarBuilder.append("KW880 : 'KW' '880';\n");
+		grammarBuilder.append("KW881 : 'KW' '881';\n");
+		grammarBuilder.append("KW882 : 'KW' '882';\n");
+		grammarBuilder.append("KW883 : 'KW' '883';\n");
+		grammarBuilder.append("KW884 : 'KW' '884';\n");
+		grammarBuilder.append("KW885 : 'KW' '885';\n");
+		grammarBuilder.append("KW886 : 'KW' '886';\n");
+		grammarBuilder.append("KW887 : 'KW' '887';\n");
+		grammarBuilder.append("KW888 : 'KW' '888';\n");
+		grammarBuilder.append("KW889 : 'KW' '889';\n");
+		grammarBuilder.append("KW890 : 'KW' '890';\n");
+		grammarBuilder.append("KW891 : 'KW' '891';\n");
+		grammarBuilder.append("KW892 : 'KW' '892';\n");
+		grammarBuilder.append("KW893 : 'KW' '893';\n");
+		grammarBuilder.append("KW894 : 'KW' '894';\n");
+		grammarBuilder.append("KW895 : 'KW' '895';\n");
+		grammarBuilder.append("KW896 : 'KW' '896';\n");
+		grammarBuilder.append("KW897 : 'KW' '897';\n");
+		grammarBuilder.append("KW898 : 'KW' '898';\n");
+		grammarBuilder.append("KW899 : 'KW' '899';\n");
+		grammarBuilder.append("KW900 : 'KW' '900';\n");
+		grammarBuilder.append("KW901 : 'KW' '901';\n");
+		grammarBuilder.append("KW902 : 'KW' '902';\n");
+		grammarBuilder.append("KW903 : 'KW' '903';\n");
+		grammarBuilder.append("KW904 : 'KW' '904';\n");
+		grammarBuilder.append("KW905 : 'KW' '905';\n");
+		grammarBuilder.append("KW906 : 'KW' '906';\n");
+		grammarBuilder.append("KW907 : 'KW' '907';\n");
+		grammarBuilder.append("KW908 : 'KW' '908';\n");
+		grammarBuilder.append("KW909 : 'KW' '909';\n");
+		grammarBuilder.append("KW910 : 'KW' '910';\n");
+		grammarBuilder.append("KW911 : 'KW' '911';\n");
+		grammarBuilder.append("KW912 : 'KW' '912';\n");
+		grammarBuilder.append("KW913 : 'KW' '913';\n");
+		grammarBuilder.append("KW914 : 'KW' '914';\n");
+		grammarBuilder.append("KW915 : 'KW' '915';\n");
+		grammarBuilder.append("KW916 : 'KW' '916';\n");
+		grammarBuilder.append("KW917 : 'KW' '917';\n");
+		grammarBuilder.append("KW918 : 'KW' '918';\n");
+		grammarBuilder.append("KW919 : 'KW' '919';\n");
+		grammarBuilder.append("KW920 : 'KW' '920';\n");
+		grammarBuilder.append("KW921 : 'KW' '921';\n");
+		grammarBuilder.append("KW922 : 'KW' '922';\n");
+		grammarBuilder.append("KW923 : 'KW' '923';\n");
+		grammarBuilder.append("KW924 : 'KW' '924';\n");
+		grammarBuilder.append("KW925 : 'KW' '925';\n");
+		grammarBuilder.append("KW926 : 'KW' '926';\n");
+		grammarBuilder.append("KW927 : 'KW' '927';\n");
+		grammarBuilder.append("KW928 : 'KW' '928';\n");
+		grammarBuilder.append("KW929 : 'KW' '929';\n");
+		grammarBuilder.append("KW930 : 'KW' '930';\n");
+		grammarBuilder.append("KW931 : 'KW' '931';\n");
+		grammarBuilder.append("KW932 : 'KW' '932';\n");
+		grammarBuilder.append("KW933 : 'KW' '933';\n");
+		grammarBuilder.append("KW934 : 'KW' '934';\n");
+		grammarBuilder.append("KW935 : 'KW' '935';\n");
+		grammarBuilder.append("KW936 : 'KW' '936';\n");
+		grammarBuilder.append("KW937 : 'KW' '937';\n");
+		grammarBuilder.append("KW938 : 'KW' '938';\n");
+		grammarBuilder.append("KW939 : 'KW' '939';\n");
+		grammarBuilder.append("KW940 : 'KW' '940';\n");
+		grammarBuilder.append("KW941 : 'KW' '941';\n");
+		grammarBuilder.append("KW942 : 'KW' '942';\n");
+		grammarBuilder.append("KW943 : 'KW' '943';\n");
+		grammarBuilder.append("KW944 : 'KW' '944';\n");
+		grammarBuilder.append("KW945 : 'KW' '945';\n");
+		grammarBuilder.append("KW946 : 'KW' '946';\n");
+		grammarBuilder.append("KW947 : 'KW' '947';\n");
+		grammarBuilder.append("KW948 : 'KW' '948';\n");
+		grammarBuilder.append("KW949 : 'KW' '949';\n");
+		grammarBuilder.append("KW950 : 'KW' '950';\n");
+		grammarBuilder.append("KW951 : 'KW' '951';\n");
+		grammarBuilder.append("KW952 : 'KW' '952';\n");
+		grammarBuilder.append("KW953 : 'KW' '953';\n");
+		grammarBuilder.append("KW954 : 'KW' '954';\n");
+		grammarBuilder.append("KW955 : 'KW' '955';\n");
+		grammarBuilder.append("KW956 : 'KW' '956';\n");
+		grammarBuilder.append("KW957 : 'KW' '957';\n");
+		grammarBuilder.append("KW958 : 'KW' '958';\n");
+		grammarBuilder.append("KW959 : 'KW' '959';\n");
+		grammarBuilder.append("KW960 : 'KW' '960';\n");
+		grammarBuilder.append("KW961 : 'KW' '961';\n");
+		grammarBuilder.append("KW962 : 'KW' '962';\n");
+		grammarBuilder.append("KW963 : 'KW' '963';\n");
+		grammarBuilder.append("KW964 : 'KW' '964';\n");
+		grammarBuilder.append("KW965 : 'KW' '965';\n");
+		grammarBuilder.append("KW966 : 'KW' '966';\n");
+		grammarBuilder.append("KW967 : 'KW' '967';\n");
+		grammarBuilder.append("KW968 : 'KW' '968';\n");
+		grammarBuilder.append("KW969 : 'KW' '969';\n");
+		grammarBuilder.append("KW970 : 'KW' '970';\n");
+		grammarBuilder.append("KW971 : 'KW' '971';\n");
+		grammarBuilder.append("KW972 : 'KW' '972';\n");
+		grammarBuilder.append("KW973 : 'KW' '973';\n");
+		grammarBuilder.append("KW974 : 'KW' '974';\n");
+		grammarBuilder.append("KW975 : 'KW' '975';\n");
+		grammarBuilder.append("KW976 : 'KW' '976';\n");
+		grammarBuilder.append("KW977 : 'KW' '977';\n");
+		grammarBuilder.append("KW978 : 'KW' '978';\n");
+		grammarBuilder.append("KW979 : 'KW' '979';\n");
+		grammarBuilder.append("KW980 : 'KW' '980';\n");
+		grammarBuilder.append("KW981 : 'KW' '981';\n");
+		grammarBuilder.append("KW982 : 'KW' '982';\n");
+		grammarBuilder.append("KW983 : 'KW' '983';\n");
+		grammarBuilder.append("KW984 : 'KW' '984';\n");
+		grammarBuilder.append("KW985 : 'KW' '985';\n");
+		grammarBuilder.append("KW986 : 'KW' '986';\n");
+		grammarBuilder.append("KW987 : 'KW' '987';\n");
+		grammarBuilder.append("KW988 : 'KW' '988';\n");
+		grammarBuilder.append("KW989 : 'KW' '989';\n");
+		grammarBuilder.append("KW990 : 'KW' '990';\n");
+		grammarBuilder.append("KW991 : 'KW' '991';\n");
+		grammarBuilder.append("KW992 : 'KW' '992';\n");
+		grammarBuilder.append("KW993 : 'KW' '993';\n");
+		grammarBuilder.append("KW994 : 'KW' '994';\n");
+		grammarBuilder.append("KW995 : 'KW' '995';\n");
+		grammarBuilder.append("KW996 : 'KW' '996';\n");
+		grammarBuilder.append("KW997 : 'KW' '997';\n");
+		grammarBuilder.append("KW998 : 'KW' '998';\n");
+		grammarBuilder.append("KW999 : 'KW' '999';\n");
+		grammarBuilder.append("KW1000 : 'KW' '1000';\n");
+		grammarBuilder.append("KW1001 : 'KW' '1001';\n");
+		grammarBuilder.append("KW1002 : 'KW' '1002';\n");
+		grammarBuilder.append("KW1003 : 'KW' '1003';\n");
+		grammarBuilder.append("KW1004 : 'KW' '1004';\n");
+		grammarBuilder.append("KW1005 : 'KW' '1005';\n");
+		grammarBuilder.append("KW1006 : 'KW' '1006';\n");
+		grammarBuilder.append("KW1007 : 'KW' '1007';\n");
+		grammarBuilder.append("KW1008 : 'KW' '1008';\n");
+		grammarBuilder.append("KW1009 : 'KW' '1009';\n");
+		grammarBuilder.append("KW1010 : 'KW' '1010';\n");
+		grammarBuilder.append("KW1011 : 'KW' '1011';\n");
+		grammarBuilder.append("KW1012 : 'KW' '1012';\n");
+		grammarBuilder.append("KW1013 : 'KW' '1013';\n");
+		grammarBuilder.append("KW1014 : 'KW' '1014';\n");
+		grammarBuilder.append("KW1015 : 'KW' '1015';\n");
+		grammarBuilder.append("KW1016 : 'KW' '1016';\n");
+		grammarBuilder.append("KW1017 : 'KW' '1017';\n");
+		grammarBuilder.append("KW1018 : 'KW' '1018';\n");
+		grammarBuilder.append("KW1019 : 'KW' '1019';\n");
+		grammarBuilder.append("KW1020 : 'KW' '1020';\n");
+		grammarBuilder.append("KW1021 : 'KW' '1021';\n");
+		grammarBuilder.append("KW1022 : 'KW' '1022';\n");
+		grammarBuilder.append("KW1023 : 'KW' '1023';\n");
+		grammarBuilder.append("KW1024 : 'KW' '1024';\n");
+		grammarBuilder.append("KW1025 : 'KW' '1025';\n");
+		grammarBuilder.append("KW1026 : 'KW' '1026';\n");
+		grammarBuilder.append("KW1027 : 'KW' '1027';\n");
+		grammarBuilder.append("KW1028 : 'KW' '1028';\n");
+		grammarBuilder.append("KW1029 : 'KW' '1029';\n");
+		grammarBuilder.append("KW1030 : 'KW' '1030';\n");
+		grammarBuilder.append("KW1031 : 'KW' '1031';\n");
+		grammarBuilder.append("KW1032 : 'KW' '1032';\n");
+		grammarBuilder.append("KW1033 : 'KW' '1033';\n");
+		grammarBuilder.append("KW1034 : 'KW' '1034';\n");
+		grammarBuilder.append("KW1035 : 'KW' '1035';\n");
+		grammarBuilder.append("KW1036 : 'KW' '1036';\n");
+		grammarBuilder.append("KW1037 : 'KW' '1037';\n");
+		grammarBuilder.append("KW1038 : 'KW' '1038';\n");
+		grammarBuilder.append("KW1039 : 'KW' '1039';\n");
+		grammarBuilder.append("KW1040 : 'KW' '1040';\n");
+		grammarBuilder.append("KW1041 : 'KW' '1041';\n");
+		grammarBuilder.append("KW1042 : 'KW' '1042';\n");
+		grammarBuilder.append("KW1043 : 'KW' '1043';\n");
+		grammarBuilder.append("KW1044 : 'KW' '1044';\n");
+		grammarBuilder.append("KW1045 : 'KW' '1045';\n");
+		grammarBuilder.append("KW1046 : 'KW' '1046';\n");
+		grammarBuilder.append("KW1047 : 'KW' '1047';\n");
+		grammarBuilder.append("KW1048 : 'KW' '1048';\n");
+		grammarBuilder.append("KW1049 : 'KW' '1049';\n");
+		grammarBuilder.append("KW1050 : 'KW' '1050';\n");
+		grammarBuilder.append("KW1051 : 'KW' '1051';\n");
+		grammarBuilder.append("KW1052 : 'KW' '1052';\n");
+		grammarBuilder.append("KW1053 : 'KW' '1053';\n");
+		grammarBuilder.append("KW1054 : 'KW' '1054';\n");
+		grammarBuilder.append("KW1055 : 'KW' '1055';\n");
+		grammarBuilder.append("KW1056 : 'KW' '1056';\n");
+		grammarBuilder.append("KW1057 : 'KW' '1057';\n");
+		grammarBuilder.append("KW1058 : 'KW' '1058';\n");
+		grammarBuilder.append("KW1059 : 'KW' '1059';\n");
+		grammarBuilder.append("KW1060 : 'KW' '1060';\n");
+		grammarBuilder.append("KW1061 : 'KW' '1061';\n");
+		grammarBuilder.append("KW1062 : 'KW' '1062';\n");
+		grammarBuilder.append("KW1063 : 'KW' '1063';\n");
+		grammarBuilder.append("KW1064 : 'KW' '1064';\n");
+		grammarBuilder.append("KW1065 : 'KW' '1065';\n");
+		grammarBuilder.append("KW1066 : 'KW' '1066';\n");
+		grammarBuilder.append("KW1067 : 'KW' '1067';\n");
+		grammarBuilder.append("KW1068 : 'KW' '1068';\n");
+		grammarBuilder.append("KW1069 : 'KW' '1069';\n");
+		grammarBuilder.append("KW1070 : 'KW' '1070';\n");
+		grammarBuilder.append("KW1071 : 'KW' '1071';\n");
+		grammarBuilder.append("KW1072 : 'KW' '1072';\n");
+		grammarBuilder.append("KW1073 : 'KW' '1073';\n");
+		grammarBuilder.append("KW1074 : 'KW' '1074';\n");
+		grammarBuilder.append("KW1075 : 'KW' '1075';\n");
+		grammarBuilder.append("KW1076 : 'KW' '1076';\n");
+		grammarBuilder.append("KW1077 : 'KW' '1077';\n");
+		grammarBuilder.append("KW1078 : 'KW' '1078';\n");
+		grammarBuilder.append("KW1079 : 'KW' '1079';\n");
+		grammarBuilder.append("KW1080 : 'KW' '1080';\n");
+		grammarBuilder.append("KW1081 : 'KW' '1081';\n");
+		grammarBuilder.append("KW1082 : 'KW' '1082';\n");
+		grammarBuilder.append("KW1083 : 'KW' '1083';\n");
+		grammarBuilder.append("KW1084 : 'KW' '1084';\n");
+		grammarBuilder.append("KW1085 : 'KW' '1085';\n");
+		grammarBuilder.append("KW1086 : 'KW' '1086';\n");
+		grammarBuilder.append("KW1087 : 'KW' '1087';\n");
+		grammarBuilder.append("KW1088 : 'KW' '1088';\n");
+		grammarBuilder.append("KW1089 : 'KW' '1089';\n");
+		grammarBuilder.append("KW1090 : 'KW' '1090';\n");
+		grammarBuilder.append("KW1091 : 'KW' '1091';\n");
+		grammarBuilder.append("KW1092 : 'KW' '1092';\n");
+		grammarBuilder.append("KW1093 : 'KW' '1093';\n");
+		grammarBuilder.append("KW1094 : 'KW' '1094';\n");
+		grammarBuilder.append("KW1095 : 'KW' '1095';\n");
+		grammarBuilder.append("KW1096 : 'KW' '1096';\n");
+		grammarBuilder.append("KW1097 : 'KW' '1097';\n");
+		grammarBuilder.append("KW1098 : 'KW' '1098';\n");
+		grammarBuilder.append("KW1099 : 'KW' '1099';\n");
+		grammarBuilder.append("KW1100 : 'KW' '1100';\n");
+		grammarBuilder.append("KW1101 : 'KW' '1101';\n");
+		grammarBuilder.append("KW1102 : 'KW' '1102';\n");
+		grammarBuilder.append("KW1103 : 'KW' '1103';\n");
+		grammarBuilder.append("KW1104 : 'KW' '1104';\n");
+		grammarBuilder.append("KW1105 : 'KW' '1105';\n");
+		grammarBuilder.append("KW1106 : 'KW' '1106';\n");
+		grammarBuilder.append("KW1107 : 'KW' '1107';\n");
+		grammarBuilder.append("KW1108 : 'KW' '1108';\n");
+		grammarBuilder.append("KW1109 : 'KW' '1109';\n");
+		grammarBuilder.append("KW1110 : 'KW' '1110';\n");
+		grammarBuilder.append("KW1111 : 'KW' '1111';\n");
+		grammarBuilder.append("KW1112 : 'KW' '1112';\n");
+		grammarBuilder.append("KW1113 : 'KW' '1113';\n");
+		grammarBuilder.append("KW1114 : 'KW' '1114';\n");
+		grammarBuilder.append("KW1115 : 'KW' '1115';\n");
+		grammarBuilder.append("KW1116 : 'KW' '1116';\n");
+		grammarBuilder.append("KW1117 : 'KW' '1117';\n");
+		grammarBuilder.append("KW1118 : 'KW' '1118';\n");
+		grammarBuilder.append("KW1119 : 'KW' '1119';\n");
+		grammarBuilder.append("KW1120 : 'KW' '1120';\n");
+		grammarBuilder.append("KW1121 : 'KW' '1121';\n");
+		grammarBuilder.append("KW1122 : 'KW' '1122';\n");
+		grammarBuilder.append("KW1123 : 'KW' '1123';\n");
+		grammarBuilder.append("KW1124 : 'KW' '1124';\n");
+		grammarBuilder.append("KW1125 : 'KW' '1125';\n");
+		grammarBuilder.append("KW1126 : 'KW' '1126';\n");
+		grammarBuilder.append("KW1127 : 'KW' '1127';\n");
+		grammarBuilder.append("KW1128 : 'KW' '1128';\n");
+		grammarBuilder.append("KW1129 : 'KW' '1129';\n");
+		grammarBuilder.append("KW1130 : 'KW' '1130';\n");
+		grammarBuilder.append("KW1131 : 'KW' '1131';\n");
+		grammarBuilder.append("KW1132 : 'KW' '1132';\n");
+		grammarBuilder.append("KW1133 : 'KW' '1133';\n");
+		grammarBuilder.append("KW1134 : 'KW' '1134';\n");
+		grammarBuilder.append("KW1135 : 'KW' '1135';\n");
+		grammarBuilder.append("KW1136 : 'KW' '1136';\n");
+		grammarBuilder.append("KW1137 : 'KW' '1137';\n");
+		grammarBuilder.append("KW1138 : 'KW' '1138';\n");
+		grammarBuilder.append("KW1139 : 'KW' '1139';\n");
+		grammarBuilder.append("KW1140 : 'KW' '1140';\n");
+		grammarBuilder.append("KW1141 : 'KW' '1141';\n");
+		grammarBuilder.append("KW1142 : 'KW' '1142';\n");
+		grammarBuilder.append("KW1143 : 'KW' '1143';\n");
+		grammarBuilder.append("KW1144 : 'KW' '1144';\n");
+		grammarBuilder.append("KW1145 : 'KW' '1145';\n");
+		grammarBuilder.append("KW1146 : 'KW' '1146';\n");
+		grammarBuilder.append("KW1147 : 'KW' '1147';\n");
+		grammarBuilder.append("KW1148 : 'KW' '1148';\n");
+		grammarBuilder.append("KW1149 : 'KW' '1149';\n");
+		grammarBuilder.append("KW1150 : 'KW' '1150';\n");
+		grammarBuilder.append("KW1151 : 'KW' '1151';\n");
+		grammarBuilder.append("KW1152 : 'KW' '1152';\n");
+		grammarBuilder.append("KW1153 : 'KW' '1153';\n");
+		grammarBuilder.append("KW1154 : 'KW' '1154';\n");
+		grammarBuilder.append("KW1155 : 'KW' '1155';\n");
+		grammarBuilder.append("KW1156 : 'KW' '1156';\n");
+		grammarBuilder.append("KW1157 : 'KW' '1157';\n");
+		grammarBuilder.append("KW1158 : 'KW' '1158';\n");
+		grammarBuilder.append("KW1159 : 'KW' '1159';\n");
+		grammarBuilder.append("KW1160 : 'KW' '1160';\n");
+		grammarBuilder.append("KW1161 : 'KW' '1161';\n");
+		grammarBuilder.append("KW1162 : 'KW' '1162';\n");
+		grammarBuilder.append("KW1163 : 'KW' '1163';\n");
+		grammarBuilder.append("KW1164 : 'KW' '1164';\n");
+		grammarBuilder.append("KW1165 : 'KW' '1165';\n");
+		grammarBuilder.append("KW1166 : 'KW' '1166';\n");
+		grammarBuilder.append("KW1167 : 'KW' '1167';\n");
+		grammarBuilder.append("KW1168 : 'KW' '1168';\n");
+		grammarBuilder.append("KW1169 : 'KW' '1169';\n");
+		grammarBuilder.append("KW1170 : 'KW' '1170';\n");
+		grammarBuilder.append("KW1171 : 'KW' '1171';\n");
+		grammarBuilder.append("KW1172 : 'KW' '1172';\n");
+		grammarBuilder.append("KW1173 : 'KW' '1173';\n");
+		grammarBuilder.append("KW1174 : 'KW' '1174';\n");
+		grammarBuilder.append("KW1175 : 'KW' '1175';\n");
+		grammarBuilder.append("KW1176 : 'KW' '1176';\n");
+		grammarBuilder.append("KW1177 : 'KW' '1177';\n");
+		grammarBuilder.append("KW1178 : 'KW' '1178';\n");
+		grammarBuilder.append("KW1179 : 'KW' '1179';\n");
+		grammarBuilder.append("KW1180 : 'KW' '1180';\n");
+		grammarBuilder.append("KW1181 : 'KW' '1181';\n");
+		grammarBuilder.append("KW1182 : 'KW' '1182';\n");
+		grammarBuilder.append("KW1183 : 'KW' '1183';\n");
+		grammarBuilder.append("KW1184 : 'KW' '1184';\n");
+		grammarBuilder.append("KW1185 : 'KW' '1185';\n");
+		grammarBuilder.append("KW1186 : 'KW' '1186';\n");
+		grammarBuilder.append("KW1187 : 'KW' '1187';\n");
+		grammarBuilder.append("KW1188 : 'KW' '1188';\n");
+		grammarBuilder.append("KW1189 : 'KW' '1189';\n");
+		grammarBuilder.append("KW1190 : 'KW' '1190';\n");
+		grammarBuilder.append("KW1191 : 'KW' '1191';\n");
+		grammarBuilder.append("KW1192 : 'KW' '1192';\n");
+		grammarBuilder.append("KW1193 : 'KW' '1193';\n");
+		grammarBuilder.append("KW1194 : 'KW' '1194';\n");
+		grammarBuilder.append("KW1195 : 'KW' '1195';\n");
+		grammarBuilder.append("KW1196 : 'KW' '1196';\n");
+		grammarBuilder.append("KW1197 : 'KW' '1197';\n");
+		grammarBuilder.append("KW1198 : 'KW' '1198';\n");
+		grammarBuilder.append("KW1199 : 'KW' '1199';\n");
+		grammarBuilder.append("KW1200 : 'KW' '1200';\n");
+		grammarBuilder.append("KW1201 : 'KW' '1201';\n");
+		grammarBuilder.append("KW1202 : 'KW' '1202';\n");
+		grammarBuilder.append("KW1203 : 'KW' '1203';\n");
+		grammarBuilder.append("KW1204 : 'KW' '1204';\n");
+		grammarBuilder.append("KW1205 : 'KW' '1205';\n");
+		grammarBuilder.append("KW1206 : 'KW' '1206';\n");
+		grammarBuilder.append("KW1207 : 'KW' '1207';\n");
+		grammarBuilder.append("KW1208 : 'KW' '1208';\n");
+		grammarBuilder.append("KW1209 : 'KW' '1209';\n");
+		grammarBuilder.append("KW1210 : 'KW' '1210';\n");
+		grammarBuilder.append("KW1211 : 'KW' '1211';\n");
+		grammarBuilder.append("KW1212 : 'KW' '1212';\n");
+		grammarBuilder.append("KW1213 : 'KW' '1213';\n");
+		grammarBuilder.append("KW1214 : 'KW' '1214';\n");
+		grammarBuilder.append("KW1215 : 'KW' '1215';\n");
+		grammarBuilder.append("KW1216 : 'KW' '1216';\n");
+		grammarBuilder.append("KW1217 : 'KW' '1217';\n");
+		grammarBuilder.append("KW1218 : 'KW' '1218';\n");
+		grammarBuilder.append("KW1219 : 'KW' '1219';\n");
+		grammarBuilder.append("KW1220 : 'KW' '1220';\n");
+		grammarBuilder.append("KW1221 : 'KW' '1221';\n");
+		grammarBuilder.append("KW1222 : 'KW' '1222';\n");
+		grammarBuilder.append("KW1223 : 'KW' '1223';\n");
+		grammarBuilder.append("KW1224 : 'KW' '1224';\n");
+		grammarBuilder.append("KW1225 : 'KW' '1225';\n");
+		grammarBuilder.append("KW1226 : 'KW' '1226';\n");
+		grammarBuilder.append("KW1227 : 'KW' '1227';\n");
+		grammarBuilder.append("KW1228 : 'KW' '1228';\n");
+		grammarBuilder.append("KW1229 : 'KW' '1229';\n");
+		grammarBuilder.append("KW1230 : 'KW' '1230';\n");
+		grammarBuilder.append("KW1231 : 'KW' '1231';\n");
+		grammarBuilder.append("KW1232 : 'KW' '1232';\n");
+		grammarBuilder.append("KW1233 : 'KW' '1233';\n");
+		grammarBuilder.append("KW1234 : 'KW' '1234';\n");
+		grammarBuilder.append("KW1235 : 'KW' '1235';\n");
+		grammarBuilder.append("KW1236 : 'KW' '1236';\n");
+		grammarBuilder.append("KW1237 : 'KW' '1237';\n");
+		grammarBuilder.append("KW1238 : 'KW' '1238';\n");
+		grammarBuilder.append("KW1239 : 'KW' '1239';\n");
+		grammarBuilder.append("KW1240 : 'KW' '1240';\n");
+		grammarBuilder.append("KW1241 : 'KW' '1241';\n");
+		grammarBuilder.append("KW1242 : 'KW' '1242';\n");
+		grammarBuilder.append("KW1243 : 'KW' '1243';\n");
+		grammarBuilder.append("KW1244 : 'KW' '1244';\n");
+		grammarBuilder.append("KW1245 : 'KW' '1245';\n");
+		grammarBuilder.append("KW1246 : 'KW' '1246';\n");
+		grammarBuilder.append("KW1247 : 'KW' '1247';\n");
+		grammarBuilder.append("KW1248 : 'KW' '1248';\n");
+		grammarBuilder.append("KW1249 : 'KW' '1249';\n");
+		grammarBuilder.append("KW1250 : 'KW' '1250';\n");
+		grammarBuilder.append("KW1251 : 'KW' '1251';\n");
+		grammarBuilder.append("KW1252 : 'KW' '1252';\n");
+		grammarBuilder.append("KW1253 : 'KW' '1253';\n");
+		grammarBuilder.append("KW1254 : 'KW' '1254';\n");
+		grammarBuilder.append("KW1255 : 'KW' '1255';\n");
+		grammarBuilder.append("KW1256 : 'KW' '1256';\n");
+		grammarBuilder.append("KW1257 : 'KW' '1257';\n");
+		grammarBuilder.append("KW1258 : 'KW' '1258';\n");
+		grammarBuilder.append("KW1259 : 'KW' '1259';\n");
+		grammarBuilder.append("KW1260 : 'KW' '1260';\n");
+		grammarBuilder.append("KW1261 : 'KW' '1261';\n");
+		grammarBuilder.append("KW1262 : 'KW' '1262';\n");
+		grammarBuilder.append("KW1263 : 'KW' '1263';\n");
+		grammarBuilder.append("KW1264 : 'KW' '1264';\n");
+		grammarBuilder.append("KW1265 : 'KW' '1265';\n");
+		grammarBuilder.append("KW1266 : 'KW' '1266';\n");
+		grammarBuilder.append("KW1267 : 'KW' '1267';\n");
+		grammarBuilder.append("KW1268 : 'KW' '1268';\n");
+		grammarBuilder.append("KW1269 : 'KW' '1269';\n");
+		grammarBuilder.append("KW1270 : 'KW' '1270';\n");
+		grammarBuilder.append("KW1271 : 'KW' '1271';\n");
+		grammarBuilder.append("KW1272 : 'KW' '1272';\n");
+		grammarBuilder.append("KW1273 : 'KW' '1273';\n");
+		grammarBuilder.append("KW1274 : 'KW' '1274';\n");
+		grammarBuilder.append("KW1275 : 'KW' '1275';\n");
+		grammarBuilder.append("KW1276 : 'KW' '1276';\n");
+		grammarBuilder.append("KW1277 : 'KW' '1277';\n");
+		grammarBuilder.append("KW1278 : 'KW' '1278';\n");
+		grammarBuilder.append("KW1279 : 'KW' '1279';\n");
+		grammarBuilder.append("KW1280 : 'KW' '1280';\n");
+		grammarBuilder.append("KW1281 : 'KW' '1281';\n");
+		grammarBuilder.append("KW1282 : 'KW' '1282';\n");
+		grammarBuilder.append("KW1283 : 'KW' '1283';\n");
+		grammarBuilder.append("KW1284 : 'KW' '1284';\n");
+		grammarBuilder.append("KW1285 : 'KW' '1285';\n");
+		grammarBuilder.append("KW1286 : 'KW' '1286';\n");
+		grammarBuilder.append("KW1287 : 'KW' '1287';\n");
+		grammarBuilder.append("KW1288 : 'KW' '1288';\n");
+		grammarBuilder.append("KW1289 : 'KW' '1289';\n");
+		grammarBuilder.append("KW1290 : 'KW' '1290';\n");
+		grammarBuilder.append("KW1291 : 'KW' '1291';\n");
+		grammarBuilder.append("KW1292 : 'KW' '1292';\n");
+		grammarBuilder.append("KW1293 : 'KW' '1293';\n");
+		grammarBuilder.append("KW1294 : 'KW' '1294';\n");
+		grammarBuilder.append("KW1295 : 'KW' '1295';\n");
+		grammarBuilder.append("KW1296 : 'KW' '1296';\n");
+		grammarBuilder.append("KW1297 : 'KW' '1297';\n");
+		grammarBuilder.append("KW1298 : 'KW' '1298';\n");
+		grammarBuilder.append("KW1299 : 'KW' '1299';\n");
+		grammarBuilder.append("KW1300 : 'KW' '1300';\n");
+		grammarBuilder.append("KW1301 : 'KW' '1301';\n");
+		grammarBuilder.append("KW1302 : 'KW' '1302';\n");
+		grammarBuilder.append("KW1303 : 'KW' '1303';\n");
+		grammarBuilder.append("KW1304 : 'KW' '1304';\n");
+		grammarBuilder.append("KW1305 : 'KW' '1305';\n");
+		grammarBuilder.append("KW1306 : 'KW' '1306';\n");
+		grammarBuilder.append("KW1307 : 'KW' '1307';\n");
+		grammarBuilder.append("KW1308 : 'KW' '1308';\n");
+		grammarBuilder.append("KW1309 : 'KW' '1309';\n");
+		grammarBuilder.append("KW1310 : 'KW' '1310';\n");
+		grammarBuilder.append("KW1311 : 'KW' '1311';\n");
+		grammarBuilder.append("KW1312 : 'KW' '1312';\n");
+		grammarBuilder.append("KW1313 : 'KW' '1313';\n");
+		grammarBuilder.append("KW1314 : 'KW' '1314';\n");
+		grammarBuilder.append("KW1315 : 'KW' '1315';\n");
+		grammarBuilder.append("KW1316 : 'KW' '1316';\n");
+		grammarBuilder.append("KW1317 : 'KW' '1317';\n");
+		grammarBuilder.append("KW1318 : 'KW' '1318';\n");
+		grammarBuilder.append("KW1319 : 'KW' '1319';\n");
+		grammarBuilder.append("KW1320 : 'KW' '1320';\n");
+		grammarBuilder.append("KW1321 : 'KW' '1321';\n");
+		grammarBuilder.append("KW1322 : 'KW' '1322';\n");
+		grammarBuilder.append("KW1323 : 'KW' '1323';\n");
+		grammarBuilder.append("KW1324 : 'KW' '1324';\n");
+		grammarBuilder.append("KW1325 : 'KW' '1325';\n");
+		grammarBuilder.append("KW1326 : 'KW' '1326';\n");
+		grammarBuilder.append("KW1327 : 'KW' '1327';\n");
+		grammarBuilder.append("KW1328 : 'KW' '1328';\n");
+		grammarBuilder.append("KW1329 : 'KW' '1329';\n");
+		grammarBuilder.append("KW1330 : 'KW' '1330';\n");
+		grammarBuilder.append("KW1331 : 'KW' '1331';\n");
+		grammarBuilder.append("KW1332 : 'KW' '1332';\n");
+		grammarBuilder.append("KW1333 : 'KW' '1333';\n");
+		grammarBuilder.append("KW1334 : 'KW' '1334';\n");
+		grammarBuilder.append("KW1335 : 'KW' '1335';\n");
+		grammarBuilder.append("KW1336 : 'KW' '1336';\n");
+		grammarBuilder.append("KW1337 : 'KW' '1337';\n");
+		grammarBuilder.append("KW1338 : 'KW' '1338';\n");
+		grammarBuilder.append("KW1339 : 'KW' '1339';\n");
+		grammarBuilder.append("KW1340 : 'KW' '1340';\n");
+		grammarBuilder.append("KW1341 : 'KW' '1341';\n");
+		grammarBuilder.append("KW1342 : 'KW' '1342';\n");
+		grammarBuilder.append("KW1343 : 'KW' '1343';\n");
+		grammarBuilder.append("KW1344 : 'KW' '1344';\n");
+		grammarBuilder.append("KW1345 : 'KW' '1345';\n");
+		grammarBuilder.append("KW1346 : 'KW' '1346';\n");
+		grammarBuilder.append("KW1347 : 'KW' '1347';\n");
+		grammarBuilder.append("KW1348 : 'KW' '1348';\n");
+		grammarBuilder.append("KW1349 : 'KW' '1349';\n");
+		grammarBuilder.append("KW1350 : 'KW' '1350';\n");
+		grammarBuilder.append("KW1351 : 'KW' '1351';\n");
+		grammarBuilder.append("KW1352 : 'KW' '1352';\n");
+		grammarBuilder.append("KW1353 : 'KW' '1353';\n");
+		grammarBuilder.append("KW1354 : 'KW' '1354';\n");
+		grammarBuilder.append("KW1355 : 'KW' '1355';\n");
+		grammarBuilder.append("KW1356 : 'KW' '1356';\n");
+		grammarBuilder.append("KW1357 : 'KW' '1357';\n");
+		grammarBuilder.append("KW1358 : 'KW' '1358';\n");
+		grammarBuilder.append("KW1359 : 'KW' '1359';\n");
+		grammarBuilder.append("KW1360 : 'KW' '1360';\n");
+		grammarBuilder.append("KW1361 : 'KW' '1361';\n");
+		grammarBuilder.append("KW1362 : 'KW' '1362';\n");
+		grammarBuilder.append("KW1363 : 'KW' '1363';\n");
+		grammarBuilder.append("KW1364 : 'KW' '1364';\n");
+		grammarBuilder.append("KW1365 : 'KW' '1365';\n");
+		grammarBuilder.append("KW1366 : 'KW' '1366';\n");
+		grammarBuilder.append("KW1367 : 'KW' '1367';\n");
+		grammarBuilder.append("KW1368 : 'KW' '1368';\n");
+		grammarBuilder.append("KW1369 : 'KW' '1369';\n");
+		grammarBuilder.append("KW1370 : 'KW' '1370';\n");
+		grammarBuilder.append("KW1371 : 'KW' '1371';\n");
+		grammarBuilder.append("KW1372 : 'KW' '1372';\n");
+		grammarBuilder.append("KW1373 : 'KW' '1373';\n");
+		grammarBuilder.append("KW1374 : 'KW' '1374';\n");
+		grammarBuilder.append("KW1375 : 'KW' '1375';\n");
+		grammarBuilder.append("KW1376 : 'KW' '1376';\n");
+		grammarBuilder.append("KW1377 : 'KW' '1377';\n");
+		grammarBuilder.append("KW1378 : 'KW' '1378';\n");
+		grammarBuilder.append("KW1379 : 'KW' '1379';\n");
+		grammarBuilder.append("KW1380 : 'KW' '1380';\n");
+		grammarBuilder.append("KW1381 : 'KW' '1381';\n");
+		grammarBuilder.append("KW1382 : 'KW' '1382';\n");
+		grammarBuilder.append("KW1383 : 'KW' '1383';\n");
+		grammarBuilder.append("KW1384 : 'KW' '1384';\n");
+		grammarBuilder.append("KW1385 : 'KW' '1385';\n");
+		grammarBuilder.append("KW1386 : 'KW' '1386';\n");
+		grammarBuilder.append("KW1387 : 'KW' '1387';\n");
+		grammarBuilder.append("KW1388 : 'KW' '1388';\n");
+		grammarBuilder.append("KW1389 : 'KW' '1389';\n");
+		grammarBuilder.append("KW1390 : 'KW' '1390';\n");
+		grammarBuilder.append("KW1391 : 'KW' '1391';\n");
+		grammarBuilder.append("KW1392 : 'KW' '1392';\n");
+		grammarBuilder.append("KW1393 : 'KW' '1393';\n");
+		grammarBuilder.append("KW1394 : 'KW' '1394';\n");
+		grammarBuilder.append("KW1395 : 'KW' '1395';\n");
+		grammarBuilder.append("KW1396 : 'KW' '1396';\n");
+		grammarBuilder.append("KW1397 : 'KW' '1397';\n");
+		grammarBuilder.append("KW1398 : 'KW' '1398';\n");
+		grammarBuilder.append("KW1399 : 'KW' '1399';\n");
+		grammarBuilder.append("KW1400 : 'KW' '1400';\n");
+		grammarBuilder.append("KW1401 : 'KW' '1401';\n");
+		grammarBuilder.append("KW1402 : 'KW' '1402';\n");
+		grammarBuilder.append("KW1403 : 'KW' '1403';\n");
+		grammarBuilder.append("KW1404 : 'KW' '1404';\n");
+		grammarBuilder.append("KW1405 : 'KW' '1405';\n");
+		grammarBuilder.append("KW1406 : 'KW' '1406';\n");
+		grammarBuilder.append("KW1407 : 'KW' '1407';\n");
+		grammarBuilder.append("KW1408 : 'KW' '1408';\n");
+		grammarBuilder.append("KW1409 : 'KW' '1409';\n");
+		grammarBuilder.append("KW1410 : 'KW' '1410';\n");
+		grammarBuilder.append("KW1411 : 'KW' '1411';\n");
+		grammarBuilder.append("KW1412 : 'KW' '1412';\n");
+		grammarBuilder.append("KW1413 : 'KW' '1413';\n");
+		grammarBuilder.append("KW1414 : 'KW' '1414';\n");
+		grammarBuilder.append("KW1415 : 'KW' '1415';\n");
+		grammarBuilder.append("KW1416 : 'KW' '1416';\n");
+		grammarBuilder.append("KW1417 : 'KW' '1417';\n");
+		grammarBuilder.append("KW1418 : 'KW' '1418';\n");
+		grammarBuilder.append("KW1419 : 'KW' '1419';\n");
+		grammarBuilder.append("KW1420 : 'KW' '1420';\n");
+		grammarBuilder.append("KW1421 : 'KW' '1421';\n");
+		grammarBuilder.append("KW1422 : 'KW' '1422';\n");
+		grammarBuilder.append("KW1423 : 'KW' '1423';\n");
+		grammarBuilder.append("KW1424 : 'KW' '1424';\n");
+		grammarBuilder.append("KW1425 : 'KW' '1425';\n");
+		grammarBuilder.append("KW1426 : 'KW' '1426';\n");
+		grammarBuilder.append("KW1427 : 'KW' '1427';\n");
+		grammarBuilder.append("KW1428 : 'KW' '1428';\n");
+		grammarBuilder.append("KW1429 : 'KW' '1429';\n");
+		grammarBuilder.append("KW1430 : 'KW' '1430';\n");
+		grammarBuilder.append("KW1431 : 'KW' '1431';\n");
+		grammarBuilder.append("KW1432 : 'KW' '1432';\n");
+		grammarBuilder.append("KW1433 : 'KW' '1433';\n");
+		grammarBuilder.append("KW1434 : 'KW' '1434';\n");
+		grammarBuilder.append("KW1435 : 'KW' '1435';\n");
+		grammarBuilder.append("KW1436 : 'KW' '1436';\n");
+		grammarBuilder.append("KW1437 : 'KW' '1437';\n");
+		grammarBuilder.append("KW1438 : 'KW' '1438';\n");
+		grammarBuilder.append("KW1439 : 'KW' '1439';\n");
+		grammarBuilder.append("KW1440 : 'KW' '1440';\n");
+		grammarBuilder.append("KW1441 : 'KW' '1441';\n");
+		grammarBuilder.append("KW1442 : 'KW' '1442';\n");
+		grammarBuilder.append("KW1443 : 'KW' '1443';\n");
+		grammarBuilder.append("KW1444 : 'KW' '1444';\n");
+		grammarBuilder.append("KW1445 : 'KW' '1445';\n");
+		grammarBuilder.append("KW1446 : 'KW' '1446';\n");
+		grammarBuilder.append("KW1447 : 'KW' '1447';\n");
+		grammarBuilder.append("KW1448 : 'KW' '1448';\n");
+		grammarBuilder.append("KW1449 : 'KW' '1449';\n");
+		grammarBuilder.append("KW1450 : 'KW' '1450';\n");
+		grammarBuilder.append("KW1451 : 'KW' '1451';\n");
+		grammarBuilder.append("KW1452 : 'KW' '1452';\n");
+		grammarBuilder.append("KW1453 : 'KW' '1453';\n");
+		grammarBuilder.append("KW1454 : 'KW' '1454';\n");
+		grammarBuilder.append("KW1455 : 'KW' '1455';\n");
+		grammarBuilder.append("KW1456 : 'KW' '1456';\n");
+		grammarBuilder.append("KW1457 : 'KW' '1457';\n");
+		grammarBuilder.append("KW1458 : 'KW' '1458';\n");
+		grammarBuilder.append("KW1459 : 'KW' '1459';\n");
+		grammarBuilder.append("KW1460 : 'KW' '1460';\n");
+		grammarBuilder.append("KW1461 : 'KW' '1461';\n");
+		grammarBuilder.append("KW1462 : 'KW' '1462';\n");
+		grammarBuilder.append("KW1463 : 'KW' '1463';\n");
+		grammarBuilder.append("KW1464 : 'KW' '1464';\n");
+		grammarBuilder.append("KW1465 : 'KW' '1465';\n");
+		grammarBuilder.append("KW1466 : 'KW' '1466';\n");
+		grammarBuilder.append("KW1467 : 'KW' '1467';\n");
+		grammarBuilder.append("KW1468 : 'KW' '1468';\n");
+		grammarBuilder.append("KW1469 : 'KW' '1469';\n");
+		grammarBuilder.append("KW1470 : 'KW' '1470';\n");
+		grammarBuilder.append("KW1471 : 'KW' '1471';\n");
+		grammarBuilder.append("KW1472 : 'KW' '1472';\n");
+		grammarBuilder.append("KW1473 : 'KW' '1473';\n");
+		grammarBuilder.append("KW1474 : 'KW' '1474';\n");
+		grammarBuilder.append("KW1475 : 'KW' '1475';\n");
+		grammarBuilder.append("KW1476 : 'KW' '1476';\n");
+		grammarBuilder.append("KW1477 : 'KW' '1477';\n");
+		grammarBuilder.append("KW1478 : 'KW' '1478';\n");
+		grammarBuilder.append("KW1479 : 'KW' '1479';\n");
+		grammarBuilder.append("KW1480 : 'KW' '1480';\n");
+		grammarBuilder.append("KW1481 : 'KW' '1481';\n");
+		grammarBuilder.append("KW1482 : 'KW' '1482';\n");
+		grammarBuilder.append("KW1483 : 'KW' '1483';\n");
+		grammarBuilder.append("KW1484 : 'KW' '1484';\n");
+		grammarBuilder.append("KW1485 : 'KW' '1485';\n");
+		grammarBuilder.append("KW1486 : 'KW' '1486';\n");
+		grammarBuilder.append("KW1487 : 'KW' '1487';\n");
+		grammarBuilder.append("KW1488 : 'KW' '1488';\n");
+		grammarBuilder.append("KW1489 : 'KW' '1489';\n");
+		grammarBuilder.append("KW1490 : 'KW' '1490';\n");
+		grammarBuilder.append("KW1491 : 'KW' '1491';\n");
+		grammarBuilder.append("KW1492 : 'KW' '1492';\n");
+		grammarBuilder.append("KW1493 : 'KW' '1493';\n");
+		grammarBuilder.append("KW1494 : 'KW' '1494';\n");
+		grammarBuilder.append("KW1495 : 'KW' '1495';\n");
+		grammarBuilder.append("KW1496 : 'KW' '1496';\n");
+		grammarBuilder.append("KW1497 : 'KW' '1497';\n");
+		grammarBuilder.append("KW1498 : 'KW' '1498';\n");
+		grammarBuilder.append("KW1499 : 'KW' '1499';\n");
+		grammarBuilder.append("KW1500 : 'KW' '1500';\n");
+		grammarBuilder.append("KW1501 : 'KW' '1501';\n");
+		grammarBuilder.append("KW1502 : 'KW' '1502';\n");
+		grammarBuilder.append("KW1503 : 'KW' '1503';\n");
+		grammarBuilder.append("KW1504 : 'KW' '1504';\n");
+		grammarBuilder.append("KW1505 : 'KW' '1505';\n");
+		grammarBuilder.append("KW1506 : 'KW' '1506';\n");
+		grammarBuilder.append("KW1507 : 'KW' '1507';\n");
+		grammarBuilder.append("KW1508 : 'KW' '1508';\n");
+		grammarBuilder.append("KW1509 : 'KW' '1509';\n");
+		grammarBuilder.append("KW1510 : 'KW' '1510';\n");
+		grammarBuilder.append("KW1511 : 'KW' '1511';\n");
+		grammarBuilder.append("KW1512 : 'KW' '1512';\n");
+		grammarBuilder.append("KW1513 : 'KW' '1513';\n");
+		grammarBuilder.append("KW1514 : 'KW' '1514';\n");
+		grammarBuilder.append("KW1515 : 'KW' '1515';\n");
+		grammarBuilder.append("KW1516 : 'KW' '1516';\n");
+		grammarBuilder.append("KW1517 : 'KW' '1517';\n");
+		grammarBuilder.append("KW1518 : 'KW' '1518';\n");
+		grammarBuilder.append("KW1519 : 'KW' '1519';\n");
+		grammarBuilder.append("KW1520 : 'KW' '1520';\n");
+		grammarBuilder.append("KW1521 : 'KW' '1521';\n");
+		grammarBuilder.append("KW1522 : 'KW' '1522';\n");
+		grammarBuilder.append("KW1523 : 'KW' '1523';\n");
+		grammarBuilder.append("KW1524 : 'KW' '1524';\n");
+		grammarBuilder.append("KW1525 : 'KW' '1525';\n");
+		grammarBuilder.append("KW1526 : 'KW' '1526';\n");
+		grammarBuilder.append("KW1527 : 'KW' '1527';\n");
+		grammarBuilder.append("KW1528 : 'KW' '1528';\n");
+		grammarBuilder.append("KW1529 : 'KW' '1529';\n");
+		grammarBuilder.append("KW1530 : 'KW' '1530';\n");
+		grammarBuilder.append("KW1531 : 'KW' '1531';\n");
+		grammarBuilder.append("KW1532 : 'KW' '1532';\n");
+		grammarBuilder.append("KW1533 : 'KW' '1533';\n");
+		grammarBuilder.append("KW1534 : 'KW' '1534';\n");
+		grammarBuilder.append("KW1535 : 'KW' '1535';\n");
+		grammarBuilder.append("KW1536 : 'KW' '1536';\n");
+		grammarBuilder.append("KW1537 : 'KW' '1537';\n");
+		grammarBuilder.append("KW1538 : 'KW' '1538';\n");
+		grammarBuilder.append("KW1539 : 'KW' '1539';\n");
+		grammarBuilder.append("KW1540 : 'KW' '1540';\n");
+		grammarBuilder.append("KW1541 : 'KW' '1541';\n");
+		grammarBuilder.append("KW1542 : 'KW' '1542';\n");
+		grammarBuilder.append("KW1543 : 'KW' '1543';\n");
+		grammarBuilder.append("KW1544 : 'KW' '1544';\n");
+		grammarBuilder.append("KW1545 : 'KW' '1545';\n");
+		grammarBuilder.append("KW1546 : 'KW' '1546';\n");
+		grammarBuilder.append("KW1547 : 'KW' '1547';\n");
+		grammarBuilder.append("KW1548 : 'KW' '1548';\n");
+		grammarBuilder.append("KW1549 : 'KW' '1549';\n");
+		grammarBuilder.append("KW1550 : 'KW' '1550';\n");
+		grammarBuilder.append("KW1551 : 'KW' '1551';\n");
+		grammarBuilder.append("KW1552 : 'KW' '1552';\n");
+		grammarBuilder.append("KW1553 : 'KW' '1553';\n");
+		grammarBuilder.append("KW1554 : 'KW' '1554';\n");
+		grammarBuilder.append("KW1555 : 'KW' '1555';\n");
+		grammarBuilder.append("KW1556 : 'KW' '1556';\n");
+		grammarBuilder.append("KW1557 : 'KW' '1557';\n");
+		grammarBuilder.append("KW1558 : 'KW' '1558';\n");
+		grammarBuilder.append("KW1559 : 'KW' '1559';\n");
+		grammarBuilder.append("KW1560 : 'KW' '1560';\n");
+		grammarBuilder.append("KW1561 : 'KW' '1561';\n");
+		grammarBuilder.append("KW1562 : 'KW' '1562';\n");
+		grammarBuilder.append("KW1563 : 'KW' '1563';\n");
+		grammarBuilder.append("KW1564 : 'KW' '1564';\n");
+		grammarBuilder.append("KW1565 : 'KW' '1565';\n");
+		grammarBuilder.append("KW1566 : 'KW' '1566';\n");
+		grammarBuilder.append("KW1567 : 'KW' '1567';\n");
+		grammarBuilder.append("KW1568 : 'KW' '1568';\n");
+		grammarBuilder.append("KW1569 : 'KW' '1569';\n");
+		grammarBuilder.append("KW1570 : 'KW' '1570';\n");
+		grammarBuilder.append("KW1571 : 'KW' '1571';\n");
+		grammarBuilder.append("KW1572 : 'KW' '1572';\n");
+		grammarBuilder.append("KW1573 : 'KW' '1573';\n");
+		grammarBuilder.append("KW1574 : 'KW' '1574';\n");
+		grammarBuilder.append("KW1575 : 'KW' '1575';\n");
+		grammarBuilder.append("KW1576 : 'KW' '1576';\n");
+		grammarBuilder.append("KW1577 : 'KW' '1577';\n");
+		grammarBuilder.append("KW1578 : 'KW' '1578';\n");
+		grammarBuilder.append("KW1579 : 'KW' '1579';\n");
+		grammarBuilder.append("KW1580 : 'KW' '1580';\n");
+		grammarBuilder.append("KW1581 : 'KW' '1581';\n");
+		grammarBuilder.append("KW1582 : 'KW' '1582';\n");
+		grammarBuilder.append("KW1583 : 'KW' '1583';\n");
+		grammarBuilder.append("KW1584 : 'KW' '1584';\n");
+		grammarBuilder.append("KW1585 : 'KW' '1585';\n");
+		grammarBuilder.append("KW1586 : 'KW' '1586';\n");
+		grammarBuilder.append("KW1587 : 'KW' '1587';\n");
+		grammarBuilder.append("KW1588 : 'KW' '1588';\n");
+		grammarBuilder.append("KW1589 : 'KW' '1589';\n");
+		grammarBuilder.append("KW1590 : 'KW' '1590';\n");
+		grammarBuilder.append("KW1591 : 'KW' '1591';\n");
+		grammarBuilder.append("KW1592 : 'KW' '1592';\n");
+		grammarBuilder.append("KW1593 : 'KW' '1593';\n");
+		grammarBuilder.append("KW1594 : 'KW' '1594';\n");
+		grammarBuilder.append("KW1595 : 'KW' '1595';\n");
+		grammarBuilder.append("KW1596 : 'KW' '1596';\n");
+		grammarBuilder.append("KW1597 : 'KW' '1597';\n");
+		grammarBuilder.append("KW1598 : 'KW' '1598';\n");
+		grammarBuilder.append("KW1599 : 'KW' '1599';\n");
+		grammarBuilder.append("KW1600 : 'KW' '1600';\n");
+		grammarBuilder.append("KW1601 : 'KW' '1601';\n");
+		grammarBuilder.append("KW1602 : 'KW' '1602';\n");
+		grammarBuilder.append("KW1603 : 'KW' '1603';\n");
+		grammarBuilder.append("KW1604 : 'KW' '1604';\n");
+		grammarBuilder.append("KW1605 : 'KW' '1605';\n");
+		grammarBuilder.append("KW1606 : 'KW' '1606';\n");
+		grammarBuilder.append("KW1607 : 'KW' '1607';\n");
+		grammarBuilder.append("KW1608 : 'KW' '1608';\n");
+		grammarBuilder.append("KW1609 : 'KW' '1609';\n");
+		grammarBuilder.append("KW1610 : 'KW' '1610';\n");
+		grammarBuilder.append("KW1611 : 'KW' '1611';\n");
+		grammarBuilder.append("KW1612 : 'KW' '1612';\n");
+		grammarBuilder.append("KW1613 : 'KW' '1613';\n");
+		grammarBuilder.append("KW1614 : 'KW' '1614';\n");
+		grammarBuilder.append("KW1615 : 'KW' '1615';\n");
+		grammarBuilder.append("KW1616 : 'KW' '1616';\n");
+		grammarBuilder.append("KW1617 : 'KW' '1617';\n");
+		grammarBuilder.append("KW1618 : 'KW' '1618';\n");
+		grammarBuilder.append("KW1619 : 'KW' '1619';\n");
+		grammarBuilder.append("KW1620 : 'KW' '1620';\n");
+		grammarBuilder.append("KW1621 : 'KW' '1621';\n");
+		grammarBuilder.append("KW1622 : 'KW' '1622';\n");
+		grammarBuilder.append("KW1623 : 'KW' '1623';\n");
+		grammarBuilder.append("KW1624 : 'KW' '1624';\n");
+		grammarBuilder.append("KW1625 : 'KW' '1625';\n");
+		grammarBuilder.append("KW1626 : 'KW' '1626';\n");
+		grammarBuilder.append("KW1627 : 'KW' '1627';\n");
+		grammarBuilder.append("KW1628 : 'KW' '1628';\n");
+		grammarBuilder.append("KW1629 : 'KW' '1629';\n");
+		grammarBuilder.append("KW1630 : 'KW' '1630';\n");
+		grammarBuilder.append("KW1631 : 'KW' '1631';\n");
+		grammarBuilder.append("KW1632 : 'KW' '1632';\n");
+		grammarBuilder.append("KW1633 : 'KW' '1633';\n");
+		grammarBuilder.append("KW1634 : 'KW' '1634';\n");
+		grammarBuilder.append("KW1635 : 'KW' '1635';\n");
+		grammarBuilder.append("KW1636 : 'KW' '1636';\n");
+		grammarBuilder.append("KW1637 : 'KW' '1637';\n");
+		grammarBuilder.append("KW1638 : 'KW' '1638';\n");
+		grammarBuilder.append("KW1639 : 'KW' '1639';\n");
+		grammarBuilder.append("KW1640 : 'KW' '1640';\n");
+		grammarBuilder.append("KW1641 : 'KW' '1641';\n");
+		grammarBuilder.append("KW1642 : 'KW' '1642';\n");
+		grammarBuilder.append("KW1643 : 'KW' '1643';\n");
+		grammarBuilder.append("KW1644 : 'KW' '1644';\n");
+		grammarBuilder.append("KW1645 : 'KW' '1645';\n");
+		grammarBuilder.append("KW1646 : 'KW' '1646';\n");
+		grammarBuilder.append("KW1647 : 'KW' '1647';\n");
+		grammarBuilder.append("KW1648 : 'KW' '1648';\n");
+		grammarBuilder.append("KW1649 : 'KW' '1649';\n");
+		grammarBuilder.append("KW1650 : 'KW' '1650';\n");
+		grammarBuilder.append("KW1651 : 'KW' '1651';\n");
+		grammarBuilder.append("KW1652 : 'KW' '1652';\n");
+		grammarBuilder.append("KW1653 : 'KW' '1653';\n");
+		grammarBuilder.append("KW1654 : 'KW' '1654';\n");
+		grammarBuilder.append("KW1655 : 'KW' '1655';\n");
+		grammarBuilder.append("KW1656 : 'KW' '1656';\n");
+		grammarBuilder.append("KW1657 : 'KW' '1657';\n");
+		grammarBuilder.append("KW1658 : 'KW' '1658';\n");
+		grammarBuilder.append("KW1659 : 'KW' '1659';\n");
+		grammarBuilder.append("KW1660 : 'KW' '1660';\n");
+		grammarBuilder.append("KW1661 : 'KW' '1661';\n");
+		grammarBuilder.append("KW1662 : 'KW' '1662';\n");
+		grammarBuilder.append("KW1663 : 'KW' '1663';\n");
+		grammarBuilder.append("KW1664 : 'KW' '1664';\n");
+		grammarBuilder.append("KW1665 : 'KW' '1665';\n");
+		grammarBuilder.append("KW1666 : 'KW' '1666';\n");
+		grammarBuilder.append("KW1667 : 'KW' '1667';\n");
+		grammarBuilder.append("KW1668 : 'KW' '1668';\n");
+		grammarBuilder.append("KW1669 : 'KW' '1669';\n");
+		grammarBuilder.append("KW1670 : 'KW' '1670';\n");
+		grammarBuilder.append("KW1671 : 'KW' '1671';\n");
+		grammarBuilder.append("KW1672 : 'KW' '1672';\n");
+		grammarBuilder.append("KW1673 : 'KW' '1673';\n");
+		grammarBuilder.append("KW1674 : 'KW' '1674';\n");
+		grammarBuilder.append("KW1675 : 'KW' '1675';\n");
+		grammarBuilder.append("KW1676 : 'KW' '1676';\n");
+		grammarBuilder.append("KW1677 : 'KW' '1677';\n");
+		grammarBuilder.append("KW1678 : 'KW' '1678';\n");
+		grammarBuilder.append("KW1679 : 'KW' '1679';\n");
+		grammarBuilder.append("KW1680 : 'KW' '1680';\n");
+		grammarBuilder.append("KW1681 : 'KW' '1681';\n");
+		grammarBuilder.append("KW1682 : 'KW' '1682';\n");
+		grammarBuilder.append("KW1683 : 'KW' '1683';\n");
+		grammarBuilder.append("KW1684 : 'KW' '1684';\n");
+		grammarBuilder.append("KW1685 : 'KW' '1685';\n");
+		grammarBuilder.append("KW1686 : 'KW' '1686';\n");
+		grammarBuilder.append("KW1687 : 'KW' '1687';\n");
+		grammarBuilder.append("KW1688 : 'KW' '1688';\n");
+		grammarBuilder.append("KW1689 : 'KW' '1689';\n");
+		grammarBuilder.append("KW1690 : 'KW' '1690';\n");
+		grammarBuilder.append("KW1691 : 'KW' '1691';\n");
+		grammarBuilder.append("KW1692 : 'KW' '1692';\n");
+		grammarBuilder.append("KW1693 : 'KW' '1693';\n");
+		grammarBuilder.append("KW1694 : 'KW' '1694';\n");
+		grammarBuilder.append("KW1695 : 'KW' '1695';\n");
+		grammarBuilder.append("KW1696 : 'KW' '1696';\n");
+		grammarBuilder.append("KW1697 : 'KW' '1697';\n");
+		grammarBuilder.append("KW1698 : 'KW' '1698';\n");
+		grammarBuilder.append("KW1699 : 'KW' '1699';\n");
+		grammarBuilder.append("KW1700 : 'KW' '1700';\n");
+		grammarBuilder.append("KW1701 : 'KW' '1701';\n");
+		grammarBuilder.append("KW1702 : 'KW' '1702';\n");
+		grammarBuilder.append("KW1703 : 'KW' '1703';\n");
+		grammarBuilder.append("KW1704 : 'KW' '1704';\n");
+		grammarBuilder.append("KW1705 : 'KW' '1705';\n");
+		grammarBuilder.append("KW1706 : 'KW' '1706';\n");
+		grammarBuilder.append("KW1707 : 'KW' '1707';\n");
+		grammarBuilder.append("KW1708 : 'KW' '1708';\n");
+		grammarBuilder.append("KW1709 : 'KW' '1709';\n");
+		grammarBuilder.append("KW1710 : 'KW' '1710';\n");
+		grammarBuilder.append("KW1711 : 'KW' '1711';\n");
+		grammarBuilder.append("KW1712 : 'KW' '1712';\n");
+		grammarBuilder.append("KW1713 : 'KW' '1713';\n");
+		grammarBuilder.append("KW1714 : 'KW' '1714';\n");
+		grammarBuilder.append("KW1715 : 'KW' '1715';\n");
+		grammarBuilder.append("KW1716 : 'KW' '1716';\n");
+		grammarBuilder.append("KW1717 : 'KW' '1717';\n");
+		grammarBuilder.append("KW1718 : 'KW' '1718';\n");
+		grammarBuilder.append("KW1719 : 'KW' '1719';\n");
+		grammarBuilder.append("KW1720 : 'KW' '1720';\n");
+		grammarBuilder.append("KW1721 : 'KW' '1721';\n");
+		grammarBuilder.append("KW1722 : 'KW' '1722';\n");
+		grammarBuilder.append("KW1723 : 'KW' '1723';\n");
+		grammarBuilder.append("KW1724 : 'KW' '1724';\n");
+		grammarBuilder.append("KW1725 : 'KW' '1725';\n");
+		grammarBuilder.append("KW1726 : 'KW' '1726';\n");
+		grammarBuilder.append("KW1727 : 'KW' '1727';\n");
+		grammarBuilder.append("KW1728 : 'KW' '1728';\n");
+		grammarBuilder.append("KW1729 : 'KW' '1729';\n");
+		grammarBuilder.append("KW1730 : 'KW' '1730';\n");
+		grammarBuilder.append("KW1731 : 'KW' '1731';\n");
+		grammarBuilder.append("KW1732 : 'KW' '1732';\n");
+		grammarBuilder.append("KW1733 : 'KW' '1733';\n");
+		grammarBuilder.append("KW1734 : 'KW' '1734';\n");
+		grammarBuilder.append("KW1735 : 'KW' '1735';\n");
+		grammarBuilder.append("KW1736 : 'KW' '1736';\n");
+		grammarBuilder.append("KW1737 : 'KW' '1737';\n");
+		grammarBuilder.append("KW1738 : 'KW' '1738';\n");
+		grammarBuilder.append("KW1739 : 'KW' '1739';\n");
+		grammarBuilder.append("KW1740 : 'KW' '1740';\n");
+		grammarBuilder.append("KW1741 : 'KW' '1741';\n");
+		grammarBuilder.append("KW1742 : 'KW' '1742';\n");
+		grammarBuilder.append("KW1743 : 'KW' '1743';\n");
+		grammarBuilder.append("KW1744 : 'KW' '1744';\n");
+		grammarBuilder.append("KW1745 : 'KW' '1745';\n");
+		grammarBuilder.append("KW1746 : 'KW' '1746';\n");
+		grammarBuilder.append("KW1747 : 'KW' '1747';\n");
+		grammarBuilder.append("KW1748 : 'KW' '1748';\n");
+		grammarBuilder.append("KW1749 : 'KW' '1749';\n");
+		grammarBuilder.append("KW1750 : 'KW' '1750';\n");
+		grammarBuilder.append("KW1751 : 'KW' '1751';\n");
+		grammarBuilder.append("KW1752 : 'KW' '1752';\n");
+		grammarBuilder.append("KW1753 : 'KW' '1753';\n");
+		grammarBuilder.append("KW1754 : 'KW' '1754';\n");
+		grammarBuilder.append("KW1755 : 'KW' '1755';\n");
+		grammarBuilder.append("KW1756 : 'KW' '1756';\n");
+		grammarBuilder.append("KW1757 : 'KW' '1757';\n");
+		grammarBuilder.append("KW1758 : 'KW' '1758';\n");
+		grammarBuilder.append("KW1759 : 'KW' '1759';\n");
+		grammarBuilder.append("KW1760 : 'KW' '1760';\n");
+		grammarBuilder.append("KW1761 : 'KW' '1761';\n");
+		grammarBuilder.append("KW1762 : 'KW' '1762';\n");
+		grammarBuilder.append("KW1763 : 'KW' '1763';\n");
+		grammarBuilder.append("KW1764 : 'KW' '1764';\n");
+		grammarBuilder.append("KW1765 : 'KW' '1765';\n");
+		grammarBuilder.append("KW1766 : 'KW' '1766';\n");
+		grammarBuilder.append("KW1767 : 'KW' '1767';\n");
+		grammarBuilder.append("KW1768 : 'KW' '1768';\n");
+		grammarBuilder.append("KW1769 : 'KW' '1769';\n");
+		grammarBuilder.append("KW1770 : 'KW' '1770';\n");
+		grammarBuilder.append("KW1771 : 'KW' '1771';\n");
+		grammarBuilder.append("KW1772 : 'KW' '1772';\n");
+		grammarBuilder.append("KW1773 : 'KW' '1773';\n");
+		grammarBuilder.append("KW1774 : 'KW' '1774';\n");
+		grammarBuilder.append("KW1775 : 'KW' '1775';\n");
+		grammarBuilder.append("KW1776 : 'KW' '1776';\n");
+		grammarBuilder.append("KW1777 : 'KW' '1777';\n");
+		grammarBuilder.append("KW1778 : 'KW' '1778';\n");
+		grammarBuilder.append("KW1779 : 'KW' '1779';\n");
+		grammarBuilder.append("KW1780 : 'KW' '1780';\n");
+		grammarBuilder.append("KW1781 : 'KW' '1781';\n");
+		grammarBuilder.append("KW1782 : 'KW' '1782';\n");
+		grammarBuilder.append("KW1783 : 'KW' '1783';\n");
+		grammarBuilder.append("KW1784 : 'KW' '1784';\n");
+		grammarBuilder.append("KW1785 : 'KW' '1785';\n");
+		grammarBuilder.append("KW1786 : 'KW' '1786';\n");
+		grammarBuilder.append("KW1787 : 'KW' '1787';\n");
+		grammarBuilder.append("KW1788 : 'KW' '1788';\n");
+		grammarBuilder.append("KW1789 : 'KW' '1789';\n");
+		grammarBuilder.append("KW1790 : 'KW' '1790';\n");
+		grammarBuilder.append("KW1791 : 'KW' '1791';\n");
+		grammarBuilder.append("KW1792 : 'KW' '1792';\n");
+		grammarBuilder.append("KW1793 : 'KW' '1793';\n");
+		grammarBuilder.append("KW1794 : 'KW' '1794';\n");
+		grammarBuilder.append("KW1795 : 'KW' '1795';\n");
+		grammarBuilder.append("KW1796 : 'KW' '1796';\n");
+		grammarBuilder.append("KW1797 : 'KW' '1797';\n");
+		grammarBuilder.append("KW1798 : 'KW' '1798';\n");
+		grammarBuilder.append("KW1799 : 'KW' '1799';\n");
+		grammarBuilder.append("KW1800 : 'KW' '1800';\n");
+		grammarBuilder.append("KW1801 : 'KW' '1801';\n");
+		grammarBuilder.append("KW1802 : 'KW' '1802';\n");
+		grammarBuilder.append("KW1803 : 'KW' '1803';\n");
+		grammarBuilder.append("KW1804 : 'KW' '1804';\n");
+		grammarBuilder.append("KW1805 : 'KW' '1805';\n");
+		grammarBuilder.append("KW1806 : 'KW' '1806';\n");
+		grammarBuilder.append("KW1807 : 'KW' '1807';\n");
+		grammarBuilder.append("KW1808 : 'KW' '1808';\n");
+		grammarBuilder.append("KW1809 : 'KW' '1809';\n");
+		grammarBuilder.append("KW1810 : 'KW' '1810';\n");
+		grammarBuilder.append("KW1811 : 'KW' '1811';\n");
+		grammarBuilder.append("KW1812 : 'KW' '1812';\n");
+		grammarBuilder.append("KW1813 : 'KW' '1813';\n");
+		grammarBuilder.append("KW1814 : 'KW' '1814';\n");
+		grammarBuilder.append("KW1815 : 'KW' '1815';\n");
+		grammarBuilder.append("KW1816 : 'KW' '1816';\n");
+		grammarBuilder.append("KW1817 : 'KW' '1817';\n");
+		grammarBuilder.append("KW1818 : 'KW' '1818';\n");
+		grammarBuilder.append("KW1819 : 'KW' '1819';\n");
+		grammarBuilder.append("KW1820 : 'KW' '1820';\n");
+		grammarBuilder.append("KW1821 : 'KW' '1821';\n");
+		grammarBuilder.append("KW1822 : 'KW' '1822';\n");
+		grammarBuilder.append("KW1823 : 'KW' '1823';\n");
+		grammarBuilder.append("KW1824 : 'KW' '1824';\n");
+		grammarBuilder.append("KW1825 : 'KW' '1825';\n");
+		grammarBuilder.append("KW1826 : 'KW' '1826';\n");
+		grammarBuilder.append("KW1827 : 'KW' '1827';\n");
+		grammarBuilder.append("KW1828 : 'KW' '1828';\n");
+		grammarBuilder.append("KW1829 : 'KW' '1829';\n");
+		grammarBuilder.append("KW1830 : 'KW' '1830';\n");
+		grammarBuilder.append("KW1831 : 'KW' '1831';\n");
+		grammarBuilder.append("KW1832 : 'KW' '1832';\n");
+		grammarBuilder.append("KW1833 : 'KW' '1833';\n");
+		grammarBuilder.append("KW1834 : 'KW' '1834';\n");
+		grammarBuilder.append("KW1835 : 'KW' '1835';\n");
+		grammarBuilder.append("KW1836 : 'KW' '1836';\n");
+		grammarBuilder.append("KW1837 : 'KW' '1837';\n");
+		grammarBuilder.append("KW1838 : 'KW' '1838';\n");
+		grammarBuilder.append("KW1839 : 'KW' '1839';\n");
+		grammarBuilder.append("KW1840 : 'KW' '1840';\n");
+		grammarBuilder.append("KW1841 : 'KW' '1841';\n");
+		grammarBuilder.append("KW1842 : 'KW' '1842';\n");
+		grammarBuilder.append("KW1843 : 'KW' '1843';\n");
+		grammarBuilder.append("KW1844 : 'KW' '1844';\n");
+		grammarBuilder.append("KW1845 : 'KW' '1845';\n");
+		grammarBuilder.append("KW1846 : 'KW' '1846';\n");
+		grammarBuilder.append("KW1847 : 'KW' '1847';\n");
+		grammarBuilder.append("KW1848 : 'KW' '1848';\n");
+		grammarBuilder.append("KW1849 : 'KW' '1849';\n");
+		grammarBuilder.append("KW1850 : 'KW' '1850';\n");
+		grammarBuilder.append("KW1851 : 'KW' '1851';\n");
+		grammarBuilder.append("KW1852 : 'KW' '1852';\n");
+		grammarBuilder.append("KW1853 : 'KW' '1853';\n");
+		grammarBuilder.append("KW1854 : 'KW' '1854';\n");
+		grammarBuilder.append("KW1855 : 'KW' '1855';\n");
+		grammarBuilder.append("KW1856 : 'KW' '1856';\n");
+		grammarBuilder.append("KW1857 : 'KW' '1857';\n");
+		grammarBuilder.append("KW1858 : 'KW' '1858';\n");
+		grammarBuilder.append("KW1859 : 'KW' '1859';\n");
+		grammarBuilder.append("KW1860 : 'KW' '1860';\n");
+		grammarBuilder.append("KW1861 : 'KW' '1861';\n");
+		grammarBuilder.append("KW1862 : 'KW' '1862';\n");
+		grammarBuilder.append("KW1863 : 'KW' '1863';\n");
+		grammarBuilder.append("KW1864 : 'KW' '1864';\n");
+		grammarBuilder.append("KW1865 : 'KW' '1865';\n");
+		grammarBuilder.append("KW1866 : 'KW' '1866';\n");
+		grammarBuilder.append("KW1867 : 'KW' '1867';\n");
+		grammarBuilder.append("KW1868 : 'KW' '1868';\n");
+		grammarBuilder.append("KW1869 : 'KW' '1869';\n");
+		grammarBuilder.append("KW1870 : 'KW' '1870';\n");
+		grammarBuilder.append("KW1871 : 'KW' '1871';\n");
+		grammarBuilder.append("KW1872 : 'KW' '1872';\n");
+		grammarBuilder.append("KW1873 : 'KW' '1873';\n");
+		grammarBuilder.append("KW1874 : 'KW' '1874';\n");
+		grammarBuilder.append("KW1875 : 'KW' '1875';\n");
+		grammarBuilder.append("KW1876 : 'KW' '1876';\n");
+		grammarBuilder.append("KW1877 : 'KW' '1877';\n");
+		grammarBuilder.append("KW1878 : 'KW' '1878';\n");
+		grammarBuilder.append("KW1879 : 'KW' '1879';\n");
+		grammarBuilder.append("KW1880 : 'KW' '1880';\n");
+		grammarBuilder.append("KW1881 : 'KW' '1881';\n");
+		grammarBuilder.append("KW1882 : 'KW' '1882';\n");
+		grammarBuilder.append("KW1883 : 'KW' '1883';\n");
+		grammarBuilder.append("KW1884 : 'KW' '1884';\n");
+		grammarBuilder.append("KW1885 : 'KW' '1885';\n");
+		grammarBuilder.append("KW1886 : 'KW' '1886';\n");
+		grammarBuilder.append("KW1887 : 'KW' '1887';\n");
+		grammarBuilder.append("KW1888 : 'KW' '1888';\n");
+		grammarBuilder.append("KW1889 : 'KW' '1889';\n");
+		grammarBuilder.append("KW1890 : 'KW' '1890';\n");
+		grammarBuilder.append("KW1891 : 'KW' '1891';\n");
+		grammarBuilder.append("KW1892 : 'KW' '1892';\n");
+		grammarBuilder.append("KW1893 : 'KW' '1893';\n");
+		grammarBuilder.append("KW1894 : 'KW' '1894';\n");
+		grammarBuilder.append("KW1895 : 'KW' '1895';\n");
+		grammarBuilder.append("KW1896 : 'KW' '1896';\n");
+		grammarBuilder.append("KW1897 : 'KW' '1897';\n");
+		grammarBuilder.append("KW1898 : 'KW' '1898';\n");
+		grammarBuilder.append("KW1899 : 'KW' '1899';\n");
+		grammarBuilder.append("KW1900 : 'KW' '1900';\n");
+		grammarBuilder.append("KW1901 : 'KW' '1901';\n");
+		grammarBuilder.append("KW1902 : 'KW' '1902';\n");
+		grammarBuilder.append("KW1903 : 'KW' '1903';\n");
+		grammarBuilder.append("KW1904 : 'KW' '1904';\n");
+		grammarBuilder.append("KW1905 : 'KW' '1905';\n");
+		grammarBuilder.append("KW1906 : 'KW' '1906';\n");
+		grammarBuilder.append("KW1907 : 'KW' '1907';\n");
+		grammarBuilder.append("KW1908 : 'KW' '1908';\n");
+		grammarBuilder.append("KW1909 : 'KW' '1909';\n");
+		grammarBuilder.append("KW1910 : 'KW' '1910';\n");
+		grammarBuilder.append("KW1911 : 'KW' '1911';\n");
+		grammarBuilder.append("KW1912 : 'KW' '1912';\n");
+		grammarBuilder.append("KW1913 : 'KW' '1913';\n");
+		grammarBuilder.append("KW1914 : 'KW' '1914';\n");
+		grammarBuilder.append("KW1915 : 'KW' '1915';\n");
+		grammarBuilder.append("KW1916 : 'KW' '1916';\n");
+		grammarBuilder.append("KW1917 : 'KW' '1917';\n");
+		grammarBuilder.append("KW1918 : 'KW' '1918';\n");
+		grammarBuilder.append("KW1919 : 'KW' '1919';\n");
+		grammarBuilder.append("KW1920 : 'KW' '1920';\n");
+		grammarBuilder.append("KW1921 : 'KW' '1921';\n");
+		grammarBuilder.append("KW1922 : 'KW' '1922';\n");
+		grammarBuilder.append("KW1923 : 'KW' '1923';\n");
+		grammarBuilder.append("KW1924 : 'KW' '1924';\n");
+		grammarBuilder.append("KW1925 : 'KW' '1925';\n");
+		grammarBuilder.append("KW1926 : 'KW' '1926';\n");
+		grammarBuilder.append("KW1927 : 'KW' '1927';\n");
+		grammarBuilder.append("KW1928 : 'KW' '1928';\n");
+		grammarBuilder.append("KW1929 : 'KW' '1929';\n");
+		grammarBuilder.append("KW1930 : 'KW' '1930';\n");
+		grammarBuilder.append("KW1931 : 'KW' '1931';\n");
+		grammarBuilder.append("KW1932 : 'KW' '1932';\n");
+		grammarBuilder.append("KW1933 : 'KW' '1933';\n");
+		grammarBuilder.append("KW1934 : 'KW' '1934';\n");
+		grammarBuilder.append("KW1935 : 'KW' '1935';\n");
+		grammarBuilder.append("KW1936 : 'KW' '1936';\n");
+		grammarBuilder.append("KW1937 : 'KW' '1937';\n");
+		grammarBuilder.append("KW1938 : 'KW' '1938';\n");
+		grammarBuilder.append("KW1939 : 'KW' '1939';\n");
+		grammarBuilder.append("KW1940 : 'KW' '1940';\n");
+		grammarBuilder.append("KW1941 : 'KW' '1941';\n");
+		grammarBuilder.append("KW1942 : 'KW' '1942';\n");
+		grammarBuilder.append("KW1943 : 'KW' '1943';\n");
+		grammarBuilder.append("KW1944 : 'KW' '1944';\n");
+		grammarBuilder.append("KW1945 : 'KW' '1945';\n");
+		grammarBuilder.append("KW1946 : 'KW' '1946';\n");
+		grammarBuilder.append("KW1947 : 'KW' '1947';\n");
+		grammarBuilder.append("KW1948 : 'KW' '1948';\n");
+		grammarBuilder.append("KW1949 : 'KW' '1949';\n");
+		grammarBuilder.append("KW1950 : 'KW' '1950';\n");
+		grammarBuilder.append("KW1951 : 'KW' '1951';\n");
+		grammarBuilder.append("KW1952 : 'KW' '1952';\n");
+		grammarBuilder.append("KW1953 : 'KW' '1953';\n");
+		grammarBuilder.append("KW1954 : 'KW' '1954';\n");
+		grammarBuilder.append("KW1955 : 'KW' '1955';\n");
+		grammarBuilder.append("KW1956 : 'KW' '1956';\n");
+		grammarBuilder.append("KW1957 : 'KW' '1957';\n");
+		grammarBuilder.append("KW1958 : 'KW' '1958';\n");
+		grammarBuilder.append("KW1959 : 'KW' '1959';\n");
+		grammarBuilder.append("KW1960 : 'KW' '1960';\n");
+		grammarBuilder.append("KW1961 : 'KW' '1961';\n");
+		grammarBuilder.append("KW1962 : 'KW' '1962';\n");
+		grammarBuilder.append("KW1963 : 'KW' '1963';\n");
+		grammarBuilder.append("KW1964 : 'KW' '1964';\n");
+		grammarBuilder.append("KW1965 : 'KW' '1965';\n");
+		grammarBuilder.append("KW1966 : 'KW' '1966';\n");
+		grammarBuilder.append("KW1967 : 'KW' '1967';\n");
+		grammarBuilder.append("KW1968 : 'KW' '1968';\n");
+		grammarBuilder.append("KW1969 : 'KW' '1969';\n");
+		grammarBuilder.append("KW1970 : 'KW' '1970';\n");
+		grammarBuilder.append("KW1971 : 'KW' '1971';\n");
+		grammarBuilder.append("KW1972 : 'KW' '1972';\n");
+		grammarBuilder.append("KW1973 : 'KW' '1973';\n");
+		grammarBuilder.append("KW1974 : 'KW' '1974';\n");
+		grammarBuilder.append("KW1975 : 'KW' '1975';\n");
+		grammarBuilder.append("KW1976 : 'KW' '1976';\n");
+		grammarBuilder.append("KW1977 : 'KW' '1977';\n");
+		grammarBuilder.append("KW1978 : 'KW' '1978';\n");
+		grammarBuilder.append("KW1979 : 'KW' '1979';\n");
+		grammarBuilder.append("KW1980 : 'KW' '1980';\n");
+		grammarBuilder.append("KW1981 : 'KW' '1981';\n");
+		grammarBuilder.append("KW1982 : 'KW' '1982';\n");
+		grammarBuilder.append("KW1983 : 'KW' '1983';\n");
+		grammarBuilder.append("KW1984 : 'KW' '1984';\n");
+		grammarBuilder.append("KW1985 : 'KW' '1985';\n");
+		grammarBuilder.append("KW1986 : 'KW' '1986';\n");
+		grammarBuilder.append("KW1987 : 'KW' '1987';\n");
+		grammarBuilder.append("KW1988 : 'KW' '1988';\n");
+		grammarBuilder.append("KW1989 : 'KW' '1989';\n");
+		grammarBuilder.append("KW1990 : 'KW' '1990';\n");
+		grammarBuilder.append("KW1991 : 'KW' '1991';\n");
+		grammarBuilder.append("KW1992 : 'KW' '1992';\n");
+		grammarBuilder.append("KW1993 : 'KW' '1993';\n");
+		grammarBuilder.append("KW1994 : 'KW' '1994';\n");
+		grammarBuilder.append("KW1995 : 'KW' '1995';\n");
+		grammarBuilder.append("KW1996 : 'KW' '1996';\n");
+		grammarBuilder.append("KW1997 : 'KW' '1997';\n");
+		grammarBuilder.append("KW1998 : 'KW' '1998';\n");
+		grammarBuilder.append("KW1999 : 'KW' '1999';\n");
+		grammarBuilder.append("KW2000 : 'KW' '2000';\n");
+		grammarBuilder.append("KW2001 : 'KW' '2001';\n");
+		grammarBuilder.append("KW2002 : 'KW' '2002';\n");
+		grammarBuilder.append("KW2003 : 'KW' '2003';\n");
+		grammarBuilder.append("KW2004 : 'KW' '2004';\n");
+		grammarBuilder.append("KW2005 : 'KW' '2005';\n");
+		grammarBuilder.append("KW2006 : 'KW' '2006';\n");
+		grammarBuilder.append("KW2007 : 'KW' '2007';\n");
+		grammarBuilder.append("KW2008 : 'KW' '2008';\n");
+		grammarBuilder.append("KW2009 : 'KW' '2009';\n");
+		grammarBuilder.append("KW2010 : 'KW' '2010';\n");
+		grammarBuilder.append("KW2011 : 'KW' '2011';\n");
+		grammarBuilder.append("KW2012 : 'KW' '2012';\n");
+		grammarBuilder.append("KW2013 : 'KW' '2013';\n");
+		grammarBuilder.append("KW2014 : 'KW' '2014';\n");
+		grammarBuilder.append("KW2015 : 'KW' '2015';\n");
+		grammarBuilder.append("KW2016 : 'KW' '2016';\n");
+		grammarBuilder.append("KW2017 : 'KW' '2017';\n");
+		grammarBuilder.append("KW2018 : 'KW' '2018';\n");
+		grammarBuilder.append("KW2019 : 'KW' '2019';\n");
+		grammarBuilder.append("KW2020 : 'KW' '2020';\n");
+		grammarBuilder.append("KW2021 : 'KW' '2021';\n");
+		grammarBuilder.append("KW2022 : 'KW' '2022';\n");
+		grammarBuilder.append("KW2023 : 'KW' '2023';\n");
+		grammarBuilder.append("KW2024 : 'KW' '2024';\n");
+		grammarBuilder.append("KW2025 : 'KW' '2025';\n");
+		grammarBuilder.append("KW2026 : 'KW' '2026';\n");
+		grammarBuilder.append("KW2027 : 'KW' '2027';\n");
+		grammarBuilder.append("KW2028 : 'KW' '2028';\n");
+		grammarBuilder.append("KW2029 : 'KW' '2029';\n");
+		grammarBuilder.append("KW2030 : 'KW' '2030';\n");
+		grammarBuilder.append("KW2031 : 'KW' '2031';\n");
+		grammarBuilder.append("KW2032 : 'KW' '2032';\n");
+		grammarBuilder.append("KW2033 : 'KW' '2033';\n");
+		grammarBuilder.append("KW2034 : 'KW' '2034';\n");
+		grammarBuilder.append("KW2035 : 'KW' '2035';\n");
+		grammarBuilder.append("KW2036 : 'KW' '2036';\n");
+		grammarBuilder.append("KW2037 : 'KW' '2037';\n");
+		grammarBuilder.append("KW2038 : 'KW' '2038';\n");
+		grammarBuilder.append("KW2039 : 'KW' '2039';\n");
+		grammarBuilder.append("KW2040 : 'KW' '2040';\n");
+		grammarBuilder.append("KW2041 : 'KW' '2041';\n");
+		grammarBuilder.append("KW2042 : 'KW' '2042';\n");
+		grammarBuilder.append("KW2043 : 'KW' '2043';\n");
+		grammarBuilder.append("KW2044 : 'KW' '2044';\n");
+		grammarBuilder.append("KW2045 : 'KW' '2045';\n");
+		grammarBuilder.append("KW2046 : 'KW' '2046';\n");
+		grammarBuilder.append("KW2047 : 'KW' '2047';\n");
+		grammarBuilder.append("KW2048 : 'KW' '2048';\n");
+		grammarBuilder.append("KW2049 : 'KW' '2049';\n");
+		grammarBuilder.append("KW2050 : 'KW' '2050';\n");
+		grammarBuilder.append("KW2051 : 'KW' '2051';\n");
+		grammarBuilder.append("KW2052 : 'KW' '2052';\n");
+		grammarBuilder.append("KW2053 : 'KW' '2053';\n");
+		grammarBuilder.append("KW2054 : 'KW' '2054';\n");
+		grammarBuilder.append("KW2055 : 'KW' '2055';\n");
+		grammarBuilder.append("KW2056 : 'KW' '2056';\n");
+		grammarBuilder.append("KW2057 : 'KW' '2057';\n");
+		grammarBuilder.append("KW2058 : 'KW' '2058';\n");
+		grammarBuilder.append("KW2059 : 'KW' '2059';\n");
+		grammarBuilder.append("KW2060 : 'KW' '2060';\n");
+		grammarBuilder.append("KW2061 : 'KW' '2061';\n");
+		grammarBuilder.append("KW2062 : 'KW' '2062';\n");
+		grammarBuilder.append("KW2063 : 'KW' '2063';\n");
+		grammarBuilder.append("KW2064 : 'KW' '2064';\n");
+		grammarBuilder.append("KW2065 : 'KW' '2065';\n");
+		grammarBuilder.append("KW2066 : 'KW' '2066';\n");
+		grammarBuilder.append("KW2067 : 'KW' '2067';\n");
+		grammarBuilder.append("KW2068 : 'KW' '2068';\n");
+		grammarBuilder.append("KW2069 : 'KW' '2069';\n");
+		grammarBuilder.append("KW2070 : 'KW' '2070';\n");
+		grammarBuilder.append("KW2071 : 'KW' '2071';\n");
+		grammarBuilder.append("KW2072 : 'KW' '2072';\n");
+		grammarBuilder.append("KW2073 : 'KW' '2073';\n");
+		grammarBuilder.append("KW2074 : 'KW' '2074';\n");
+		grammarBuilder.append("KW2075 : 'KW' '2075';\n");
+		grammarBuilder.append("KW2076 : 'KW' '2076';\n");
+		grammarBuilder.append("KW2077 : 'KW' '2077';\n");
+		grammarBuilder.append("KW2078 : 'KW' '2078';\n");
+		grammarBuilder.append("KW2079 : 'KW' '2079';\n");
+		grammarBuilder.append("KW2080 : 'KW' '2080';\n");
+		grammarBuilder.append("KW2081 : 'KW' '2081';\n");
+		grammarBuilder.append("KW2082 : 'KW' '2082';\n");
+		grammarBuilder.append("KW2083 : 'KW' '2083';\n");
+		grammarBuilder.append("KW2084 : 'KW' '2084';\n");
+		grammarBuilder.append("KW2085 : 'KW' '2085';\n");
+		grammarBuilder.append("KW2086 : 'KW' '2086';\n");
+		grammarBuilder.append("KW2087 : 'KW' '2087';\n");
+		grammarBuilder.append("KW2088 : 'KW' '2088';\n");
+		grammarBuilder.append("KW2089 : 'KW' '2089';\n");
+		grammarBuilder.append("KW2090 : 'KW' '2090';\n");
+		grammarBuilder.append("KW2091 : 'KW' '2091';\n");
+		grammarBuilder.append("KW2092 : 'KW' '2092';\n");
+		grammarBuilder.append("KW2093 : 'KW' '2093';\n");
+		grammarBuilder.append("KW2094 : 'KW' '2094';\n");
+		grammarBuilder.append("KW2095 : 'KW' '2095';\n");
+		grammarBuilder.append("KW2096 : 'KW' '2096';\n");
+		grammarBuilder.append("KW2097 : 'KW' '2097';\n");
+		grammarBuilder.append("KW2098 : 'KW' '2098';\n");
+		grammarBuilder.append("KW2099 : 'KW' '2099';\n");
+		grammarBuilder.append("KW2100 : 'KW' '2100';\n");
+		grammarBuilder.append("KW2101 : 'KW' '2101';\n");
+		grammarBuilder.append("KW2102 : 'KW' '2102';\n");
+		grammarBuilder.append("KW2103 : 'KW' '2103';\n");
+		grammarBuilder.append("KW2104 : 'KW' '2104';\n");
+		grammarBuilder.append("KW2105 : 'KW' '2105';\n");
+		grammarBuilder.append("KW2106 : 'KW' '2106';\n");
+		grammarBuilder.append("KW2107 : 'KW' '2107';\n");
+		grammarBuilder.append("KW2108 : 'KW' '2108';\n");
+		grammarBuilder.append("KW2109 : 'KW' '2109';\n");
+		grammarBuilder.append("KW2110 : 'KW' '2110';\n");
+		grammarBuilder.append("KW2111 : 'KW' '2111';\n");
+		grammarBuilder.append("KW2112 : 'KW' '2112';\n");
+		grammarBuilder.append("KW2113 : 'KW' '2113';\n");
+		grammarBuilder.append("KW2114 : 'KW' '2114';\n");
+		grammarBuilder.append("KW2115 : 'KW' '2115';\n");
+		grammarBuilder.append("KW2116 : 'KW' '2116';\n");
+		grammarBuilder.append("KW2117 : 'KW' '2117';\n");
+		grammarBuilder.append("KW2118 : 'KW' '2118';\n");
+		grammarBuilder.append("KW2119 : 'KW' '2119';\n");
+		grammarBuilder.append("KW2120 : 'KW' '2120';\n");
+		grammarBuilder.append("KW2121 : 'KW' '2121';\n");
+		grammarBuilder.append("KW2122 : 'KW' '2122';\n");
+		grammarBuilder.append("KW2123 : 'KW' '2123';\n");
+		grammarBuilder.append("KW2124 : 'KW' '2124';\n");
+		grammarBuilder.append("KW2125 : 'KW' '2125';\n");
+		grammarBuilder.append("KW2126 : 'KW' '2126';\n");
+		grammarBuilder.append("KW2127 : 'KW' '2127';\n");
+		grammarBuilder.append("KW2128 : 'KW' '2128';\n");
+		grammarBuilder.append("KW2129 : 'KW' '2129';\n");
+		grammarBuilder.append("KW2130 : 'KW' '2130';\n");
+		grammarBuilder.append("KW2131 : 'KW' '2131';\n");
+		grammarBuilder.append("KW2132 : 'KW' '2132';\n");
+		grammarBuilder.append("KW2133 : 'KW' '2133';\n");
+		grammarBuilder.append("KW2134 : 'KW' '2134';\n");
+		grammarBuilder.append("KW2135 : 'KW' '2135';\n");
+		grammarBuilder.append("KW2136 : 'KW' '2136';\n");
+		grammarBuilder.append("KW2137 : 'KW' '2137';\n");
+		grammarBuilder.append("KW2138 : 'KW' '2138';\n");
+		grammarBuilder.append("KW2139 : 'KW' '2139';\n");
+		grammarBuilder.append("KW2140 : 'KW' '2140';\n");
+		grammarBuilder.append("KW2141 : 'KW' '2141';\n");
+		grammarBuilder.append("KW2142 : 'KW' '2142';\n");
+		grammarBuilder.append("KW2143 : 'KW' '2143';\n");
+		grammarBuilder.append("KW2144 : 'KW' '2144';\n");
+		grammarBuilder.append("KW2145 : 'KW' '2145';\n");
+		grammarBuilder.append("KW2146 : 'KW' '2146';\n");
+		grammarBuilder.append("KW2147 : 'KW' '2147';\n");
+		grammarBuilder.append("KW2148 : 'KW' '2148';\n");
+		grammarBuilder.append("KW2149 : 'KW' '2149';\n");
+		grammarBuilder.append("KW2150 : 'KW' '2150';\n");
+		grammarBuilder.append("KW2151 : 'KW' '2151';\n");
+		grammarBuilder.append("KW2152 : 'KW' '2152';\n");
+		grammarBuilder.append("KW2153 : 'KW' '2153';\n");
+		grammarBuilder.append("KW2154 : 'KW' '2154';\n");
+		grammarBuilder.append("KW2155 : 'KW' '2155';\n");
+		grammarBuilder.append("KW2156 : 'KW' '2156';\n");
+		grammarBuilder.append("KW2157 : 'KW' '2157';\n");
+		grammarBuilder.append("KW2158 : 'KW' '2158';\n");
+		grammarBuilder.append("KW2159 : 'KW' '2159';\n");
+		grammarBuilder.append("KW2160 : 'KW' '2160';\n");
+		grammarBuilder.append("KW2161 : 'KW' '2161';\n");
+		grammarBuilder.append("KW2162 : 'KW' '2162';\n");
+		grammarBuilder.append("KW2163 : 'KW' '2163';\n");
+		grammarBuilder.append("KW2164 : 'KW' '2164';\n");
+		grammarBuilder.append("KW2165 : 'KW' '2165';\n");
+		grammarBuilder.append("KW2166 : 'KW' '2166';\n");
+		grammarBuilder.append("KW2167 : 'KW' '2167';\n");
+		grammarBuilder.append("KW2168 : 'KW' '2168';\n");
+		grammarBuilder.append("KW2169 : 'KW' '2169';\n");
+		grammarBuilder.append("KW2170 : 'KW' '2170';\n");
+		grammarBuilder.append("KW2171 : 'KW' '2171';\n");
+		grammarBuilder.append("KW2172 : 'KW' '2172';\n");
+		grammarBuilder.append("KW2173 : 'KW' '2173';\n");
+		grammarBuilder.append("KW2174 : 'KW' '2174';\n");
+		grammarBuilder.append("KW2175 : 'KW' '2175';\n");
+		grammarBuilder.append("KW2176 : 'KW' '2176';\n");
+		grammarBuilder.append("KW2177 : 'KW' '2177';\n");
+		grammarBuilder.append("KW2178 : 'KW' '2178';\n");
+		grammarBuilder.append("KW2179 : 'KW' '2179';\n");
+		grammarBuilder.append("KW2180 : 'KW' '2180';\n");
+		grammarBuilder.append("KW2181 : 'KW' '2181';\n");
+		grammarBuilder.append("KW2182 : 'KW' '2182';\n");
+		grammarBuilder.append("KW2183 : 'KW' '2183';\n");
+		grammarBuilder.append("KW2184 : 'KW' '2184';\n");
+		grammarBuilder.append("KW2185 : 'KW' '2185';\n");
+		grammarBuilder.append("KW2186 : 'KW' '2186';\n");
+		grammarBuilder.append("KW2187 : 'KW' '2187';\n");
+		grammarBuilder.append("KW2188 : 'KW' '2188';\n");
+		grammarBuilder.append("KW2189 : 'KW' '2189';\n");
+		grammarBuilder.append("KW2190 : 'KW' '2190';\n");
+		grammarBuilder.append("KW2191 : 'KW' '2191';\n");
+		grammarBuilder.append("KW2192 : 'KW' '2192';\n");
+		grammarBuilder.append("KW2193 : 'KW' '2193';\n");
+		grammarBuilder.append("KW2194 : 'KW' '2194';\n");
+		grammarBuilder.append("KW2195 : 'KW' '2195';\n");
+		grammarBuilder.append("KW2196 : 'KW' '2196';\n");
+		grammarBuilder.append("KW2197 : 'KW' '2197';\n");
+		grammarBuilder.append("KW2198 : 'KW' '2198';\n");
+		grammarBuilder.append("KW2199 : 'KW' '2199';\n");
+		grammarBuilder.append("KW2200 : 'KW' '2200';\n");
+		grammarBuilder.append("KW2201 : 'KW' '2201';\n");
+		grammarBuilder.append("KW2202 : 'KW' '2202';\n");
+		grammarBuilder.append("KW2203 : 'KW' '2203';\n");
+		grammarBuilder.append("KW2204 : 'KW' '2204';\n");
+		grammarBuilder.append("KW2205 : 'KW' '2205';\n");
+		grammarBuilder.append("KW2206 : 'KW' '2206';\n");
+		grammarBuilder.append("KW2207 : 'KW' '2207';\n");
+		grammarBuilder.append("KW2208 : 'KW' '2208';\n");
+		grammarBuilder.append("KW2209 : 'KW' '2209';\n");
+		grammarBuilder.append("KW2210 : 'KW' '2210';\n");
+		grammarBuilder.append("KW2211 : 'KW' '2211';\n");
+		grammarBuilder.append("KW2212 : 'KW' '2212';\n");
+		grammarBuilder.append("KW2213 : 'KW' '2213';\n");
+		grammarBuilder.append("KW2214 : 'KW' '2214';\n");
+		grammarBuilder.append("KW2215 : 'KW' '2215';\n");
+		grammarBuilder.append("KW2216 : 'KW' '2216';\n");
+		grammarBuilder.append("KW2217 : 'KW' '2217';\n");
+		grammarBuilder.append("KW2218 : 'KW' '2218';\n");
+		grammarBuilder.append("KW2219 : 'KW' '2219';\n");
+		grammarBuilder.append("KW2220 : 'KW' '2220';\n");
+		grammarBuilder.append("KW2221 : 'KW' '2221';\n");
+		grammarBuilder.append("KW2222 : 'KW' '2222';\n");
+		grammarBuilder.append("KW2223 : 'KW' '2223';\n");
+		grammarBuilder.append("KW2224 : 'KW' '2224';\n");
+		grammarBuilder.append("KW2225 : 'KW' '2225';\n");
+		grammarBuilder.append("KW2226 : 'KW' '2226';\n");
+		grammarBuilder.append("KW2227 : 'KW' '2227';\n");
+		grammarBuilder.append("KW2228 : 'KW' '2228';\n");
+		grammarBuilder.append("KW2229 : 'KW' '2229';\n");
+		grammarBuilder.append("KW2230 : 'KW' '2230';\n");
+		grammarBuilder.append("KW2231 : 'KW' '2231';\n");
+		grammarBuilder.append("KW2232 : 'KW' '2232';\n");
+		grammarBuilder.append("KW2233 : 'KW' '2233';\n");
+		grammarBuilder.append("KW2234 : 'KW' '2234';\n");
+		grammarBuilder.append("KW2235 : 'KW' '2235';\n");
+		grammarBuilder.append("KW2236 : 'KW' '2236';\n");
+		grammarBuilder.append("KW2237 : 'KW' '2237';\n");
+		grammarBuilder.append("KW2238 : 'KW' '2238';\n");
+		grammarBuilder.append("KW2239 : 'KW' '2239';\n");
+		grammarBuilder.append("KW2240 : 'KW' '2240';\n");
+		grammarBuilder.append("KW2241 : 'KW' '2241';\n");
+		grammarBuilder.append("KW2242 : 'KW' '2242';\n");
+		grammarBuilder.append("KW2243 : 'KW' '2243';\n");
+		grammarBuilder.append("KW2244 : 'KW' '2244';\n");
+		grammarBuilder.append("KW2245 : 'KW' '2245';\n");
+		grammarBuilder.append("KW2246 : 'KW' '2246';\n");
+		grammarBuilder.append("KW2247 : 'KW' '2247';\n");
+		grammarBuilder.append("KW2248 : 'KW' '2248';\n");
+		grammarBuilder.append("KW2249 : 'KW' '2249';\n");
+		grammarBuilder.append("KW2250 : 'KW' '2250';\n");
+		grammarBuilder.append("KW2251 : 'KW' '2251';\n");
+		grammarBuilder.append("KW2252 : 'KW' '2252';\n");
+		grammarBuilder.append("KW2253 : 'KW' '2253';\n");
+		grammarBuilder.append("KW2254 : 'KW' '2254';\n");
+		grammarBuilder.append("KW2255 : 'KW' '2255';\n");
+		grammarBuilder.append("KW2256 : 'KW' '2256';\n");
+		grammarBuilder.append("KW2257 : 'KW' '2257';\n");
+		grammarBuilder.append("KW2258 : 'KW' '2258';\n");
+		grammarBuilder.append("KW2259 : 'KW' '2259';\n");
+		grammarBuilder.append("KW2260 : 'KW' '2260';\n");
+		grammarBuilder.append("KW2261 : 'KW' '2261';\n");
+		grammarBuilder.append("KW2262 : 'KW' '2262';\n");
+		grammarBuilder.append("KW2263 : 'KW' '2263';\n");
+		grammarBuilder.append("KW2264 : 'KW' '2264';\n");
+		grammarBuilder.append("KW2265 : 'KW' '2265';\n");
+		grammarBuilder.append("KW2266 : 'KW' '2266';\n");
+		grammarBuilder.append("KW2267 : 'KW' '2267';\n");
+		grammarBuilder.append("KW2268 : 'KW' '2268';\n");
+		grammarBuilder.append("KW2269 : 'KW' '2269';\n");
+		grammarBuilder.append("KW2270 : 'KW' '2270';\n");
+		grammarBuilder.append("KW2271 : 'KW' '2271';\n");
+		grammarBuilder.append("KW2272 : 'KW' '2272';\n");
+		grammarBuilder.append("KW2273 : 'KW' '2273';\n");
+		grammarBuilder.append("KW2274 : 'KW' '2274';\n");
+		grammarBuilder.append("KW2275 : 'KW' '2275';\n");
+		grammarBuilder.append("KW2276 : 'KW' '2276';\n");
+		grammarBuilder.append("KW2277 : 'KW' '2277';\n");
+		grammarBuilder.append("KW2278 : 'KW' '2278';\n");
+		grammarBuilder.append("KW2279 : 'KW' '2279';\n");
+		grammarBuilder.append("KW2280 : 'KW' '2280';\n");
+		grammarBuilder.append("KW2281 : 'KW' '2281';\n");
+		grammarBuilder.append("KW2282 : 'KW' '2282';\n");
+		grammarBuilder.append("KW2283 : 'KW' '2283';\n");
+		grammarBuilder.append("KW2284 : 'KW' '2284';\n");
+		grammarBuilder.append("KW2285 : 'KW' '2285';\n");
+		grammarBuilder.append("KW2286 : 'KW' '2286';\n");
+		grammarBuilder.append("KW2287 : 'KW' '2287';\n");
+		grammarBuilder.append("KW2288 : 'KW' '2288';\n");
+		grammarBuilder.append("KW2289 : 'KW' '2289';\n");
+		grammarBuilder.append("KW2290 : 'KW' '2290';\n");
+		grammarBuilder.append("KW2291 : 'KW' '2291';\n");
+		grammarBuilder.append("KW2292 : 'KW' '2292';\n");
+		grammarBuilder.append("KW2293 : 'KW' '2293';\n");
+		grammarBuilder.append("KW2294 : 'KW' '2294';\n");
+		grammarBuilder.append("KW2295 : 'KW' '2295';\n");
+		grammarBuilder.append("KW2296 : 'KW' '2296';\n");
+		grammarBuilder.append("KW2297 : 'KW' '2297';\n");
+		grammarBuilder.append("KW2298 : 'KW' '2298';\n");
+		grammarBuilder.append("KW2299 : 'KW' '2299';\n");
+		grammarBuilder.append("KW2300 : 'KW' '2300';\n");
+		grammarBuilder.append("KW2301 : 'KW' '2301';\n");
+		grammarBuilder.append("KW2302 : 'KW' '2302';\n");
+		grammarBuilder.append("KW2303 : 'KW' '2303';\n");
+		grammarBuilder.append("KW2304 : 'KW' '2304';\n");
+		grammarBuilder.append("KW2305 : 'KW' '2305';\n");
+		grammarBuilder.append("KW2306 : 'KW' '2306';\n");
+		grammarBuilder.append("KW2307 : 'KW' '2307';\n");
+		grammarBuilder.append("KW2308 : 'KW' '2308';\n");
+		grammarBuilder.append("KW2309 : 'KW' '2309';\n");
+		grammarBuilder.append("KW2310 : 'KW' '2310';\n");
+		grammarBuilder.append("KW2311 : 'KW' '2311';\n");
+		grammarBuilder.append("KW2312 : 'KW' '2312';\n");
+		grammarBuilder.append("KW2313 : 'KW' '2313';\n");
+		grammarBuilder.append("KW2314 : 'KW' '2314';\n");
+		grammarBuilder.append("KW2315 : 'KW' '2315';\n");
+		grammarBuilder.append("KW2316 : 'KW' '2316';\n");
+		grammarBuilder.append("KW2317 : 'KW' '2317';\n");
+		grammarBuilder.append("KW2318 : 'KW' '2318';\n");
+		grammarBuilder.append("KW2319 : 'KW' '2319';\n");
+		grammarBuilder.append("KW2320 : 'KW' '2320';\n");
+		grammarBuilder.append("KW2321 : 'KW' '2321';\n");
+		grammarBuilder.append("KW2322 : 'KW' '2322';\n");
+		grammarBuilder.append("KW2323 : 'KW' '2323';\n");
+		grammarBuilder.append("KW2324 : 'KW' '2324';\n");
+		grammarBuilder.append("KW2325 : 'KW' '2325';\n");
+		grammarBuilder.append("KW2326 : 'KW' '2326';\n");
+		grammarBuilder.append("KW2327 : 'KW' '2327';\n");
+		grammarBuilder.append("KW2328 : 'KW' '2328';\n");
+		grammarBuilder.append("KW2329 : 'KW' '2329';\n");
+		grammarBuilder.append("KW2330 : 'KW' '2330';\n");
+		grammarBuilder.append("KW2331 : 'KW' '2331';\n");
+		grammarBuilder.append("KW2332 : 'KW' '2332';\n");
+		grammarBuilder.append("KW2333 : 'KW' '2333';\n");
+		grammarBuilder.append("KW2334 : 'KW' '2334';\n");
+		grammarBuilder.append("KW2335 : 'KW' '2335';\n");
+		grammarBuilder.append("KW2336 : 'KW' '2336';\n");
+		grammarBuilder.append("KW2337 : 'KW' '2337';\n");
+		grammarBuilder.append("KW2338 : 'KW' '2338';\n");
+		grammarBuilder.append("KW2339 : 'KW' '2339';\n");
+		grammarBuilder.append("KW2340 : 'KW' '2340';\n");
+		grammarBuilder.append("KW2341 : 'KW' '2341';\n");
+		grammarBuilder.append("KW2342 : 'KW' '2342';\n");
+		grammarBuilder.append("KW2343 : 'KW' '2343';\n");
+		grammarBuilder.append("KW2344 : 'KW' '2344';\n");
+		grammarBuilder.append("KW2345 : 'KW' '2345';\n");
+		grammarBuilder.append("KW2346 : 'KW' '2346';\n");
+		grammarBuilder.append("KW2347 : 'KW' '2347';\n");
+		grammarBuilder.append("KW2348 : 'KW' '2348';\n");
+		grammarBuilder.append("KW2349 : 'KW' '2349';\n");
+		grammarBuilder.append("KW2350 : 'KW' '2350';\n");
+		grammarBuilder.append("KW2351 : 'KW' '2351';\n");
+		grammarBuilder.append("KW2352 : 'KW' '2352';\n");
+		grammarBuilder.append("KW2353 : 'KW' '2353';\n");
+		grammarBuilder.append("KW2354 : 'KW' '2354';\n");
+		grammarBuilder.append("KW2355 : 'KW' '2355';\n");
+		grammarBuilder.append("KW2356 : 'KW' '2356';\n");
+		grammarBuilder.append("KW2357 : 'KW' '2357';\n");
+		grammarBuilder.append("KW2358 : 'KW' '2358';\n");
+		grammarBuilder.append("KW2359 : 'KW' '2359';\n");
+		grammarBuilder.append("KW2360 : 'KW' '2360';\n");
+		grammarBuilder.append("KW2361 : 'KW' '2361';\n");
+		grammarBuilder.append("KW2362 : 'KW' '2362';\n");
+		grammarBuilder.append("KW2363 : 'KW' '2363';\n");
+		grammarBuilder.append("KW2364 : 'KW' '2364';\n");
+		grammarBuilder.append("KW2365 : 'KW' '2365';\n");
+		grammarBuilder.append("KW2366 : 'KW' '2366';\n");
+		grammarBuilder.append("KW2367 : 'KW' '2367';\n");
+		grammarBuilder.append("KW2368 : 'KW' '2368';\n");
+		grammarBuilder.append("KW2369 : 'KW' '2369';\n");
+		grammarBuilder.append("KW2370 : 'KW' '2370';\n");
+		grammarBuilder.append("KW2371 : 'KW' '2371';\n");
+		grammarBuilder.append("KW2372 : 'KW' '2372';\n");
+		grammarBuilder.append("KW2373 : 'KW' '2373';\n");
+		grammarBuilder.append("KW2374 : 'KW' '2374';\n");
+		grammarBuilder.append("KW2375 : 'KW' '2375';\n");
+		grammarBuilder.append("KW2376 : 'KW' '2376';\n");
+		grammarBuilder.append("KW2377 : 'KW' '2377';\n");
+		grammarBuilder.append("KW2378 : 'KW' '2378';\n");
+		grammarBuilder.append("KW2379 : 'KW' '2379';\n");
+		grammarBuilder.append("KW2380 : 'KW' '2380';\n");
+		grammarBuilder.append("KW2381 : 'KW' '2381';\n");
+		grammarBuilder.append("KW2382 : 'KW' '2382';\n");
+		grammarBuilder.append("KW2383 : 'KW' '2383';\n");
+		grammarBuilder.append("KW2384 : 'KW' '2384';\n");
+		grammarBuilder.append("KW2385 : 'KW' '2385';\n");
+		grammarBuilder.append("KW2386 : 'KW' '2386';\n");
+		grammarBuilder.append("KW2387 : 'KW' '2387';\n");
+		grammarBuilder.append("KW2388 : 'KW' '2388';\n");
+		grammarBuilder.append("KW2389 : 'KW' '2389';\n");
+		grammarBuilder.append("KW2390 : 'KW' '2390';\n");
+		grammarBuilder.append("KW2391 : 'KW' '2391';\n");
+		grammarBuilder.append("KW2392 : 'KW' '2392';\n");
+		grammarBuilder.append("KW2393 : 'KW' '2393';\n");
+		grammarBuilder.append("KW2394 : 'KW' '2394';\n");
+		grammarBuilder.append("KW2395 : 'KW' '2395';\n");
+		grammarBuilder.append("KW2396 : 'KW' '2396';\n");
+		grammarBuilder.append("KW2397 : 'KW' '2397';\n");
+		grammarBuilder.append("KW2398 : 'KW' '2398';\n");
+		grammarBuilder.append("KW2399 : 'KW' '2399';\n");
+		grammarBuilder.append("KW2400 : 'KW' '2400';\n");
+		grammarBuilder.append("KW2401 : 'KW' '2401';\n");
+		grammarBuilder.append("KW2402 : 'KW' '2402';\n");
+		grammarBuilder.append("KW2403 : 'KW' '2403';\n");
+		grammarBuilder.append("KW2404 : 'KW' '2404';\n");
+		grammarBuilder.append("KW2405 : 'KW' '2405';\n");
+		grammarBuilder.append("KW2406 : 'KW' '2406';\n");
+		grammarBuilder.append("KW2407 : 'KW' '2407';\n");
+		grammarBuilder.append("KW2408 : 'KW' '2408';\n");
+		grammarBuilder.append("KW2409 : 'KW' '2409';\n");
+		grammarBuilder.append("KW2410 : 'KW' '2410';\n");
+		grammarBuilder.append("KW2411 : 'KW' '2411';\n");
+		grammarBuilder.append("KW2412 : 'KW' '2412';\n");
+		grammarBuilder.append("KW2413 : 'KW' '2413';\n");
+		grammarBuilder.append("KW2414 : 'KW' '2414';\n");
+		grammarBuilder.append("KW2415 : 'KW' '2415';\n");
+		grammarBuilder.append("KW2416 : 'KW' '2416';\n");
+		grammarBuilder.append("KW2417 : 'KW' '2417';\n");
+		grammarBuilder.append("KW2418 : 'KW' '2418';\n");
+		grammarBuilder.append("KW2419 : 'KW' '2419';\n");
+		grammarBuilder.append("KW2420 : 'KW' '2420';\n");
+		grammarBuilder.append("KW2421 : 'KW' '2421';\n");
+		grammarBuilder.append("KW2422 : 'KW' '2422';\n");
+		grammarBuilder.append("KW2423 : 'KW' '2423';\n");
+		grammarBuilder.append("KW2424 : 'KW' '2424';\n");
+		grammarBuilder.append("KW2425 : 'KW' '2425';\n");
+		grammarBuilder.append("KW2426 : 'KW' '2426';\n");
+		grammarBuilder.append("KW2427 : 'KW' '2427';\n");
+		grammarBuilder.append("KW2428 : 'KW' '2428';\n");
+		grammarBuilder.append("KW2429 : 'KW' '2429';\n");
+		grammarBuilder.append("KW2430 : 'KW' '2430';\n");
+		grammarBuilder.append("KW2431 : 'KW' '2431';\n");
+		grammarBuilder.append("KW2432 : 'KW' '2432';\n");
+		grammarBuilder.append("KW2433 : 'KW' '2433';\n");
+		grammarBuilder.append("KW2434 : 'KW' '2434';\n");
+		grammarBuilder.append("KW2435 : 'KW' '2435';\n");
+		grammarBuilder.append("KW2436 : 'KW' '2436';\n");
+		grammarBuilder.append("KW2437 : 'KW' '2437';\n");
+		grammarBuilder.append("KW2438 : 'KW' '2438';\n");
+		grammarBuilder.append("KW2439 : 'KW' '2439';\n");
+		grammarBuilder.append("KW2440 : 'KW' '2440';\n");
+		grammarBuilder.append("KW2441 : 'KW' '2441';\n");
+		grammarBuilder.append("KW2442 : 'KW' '2442';\n");
+		grammarBuilder.append("KW2443 : 'KW' '2443';\n");
+		grammarBuilder.append("KW2444 : 'KW' '2444';\n");
+		grammarBuilder.append("KW2445 : 'KW' '2445';\n");
+		grammarBuilder.append("KW2446 : 'KW' '2446';\n");
+		grammarBuilder.append("KW2447 : 'KW' '2447';\n");
+		grammarBuilder.append("KW2448 : 'KW' '2448';\n");
+		grammarBuilder.append("KW2449 : 'KW' '2449';\n");
+		grammarBuilder.append("KW2450 : 'KW' '2450';\n");
+		grammarBuilder.append("KW2451 : 'KW' '2451';\n");
+		grammarBuilder.append("KW2452 : 'KW' '2452';\n");
+		grammarBuilder.append("KW2453 : 'KW' '2453';\n");
+		grammarBuilder.append("KW2454 : 'KW' '2454';\n");
+		grammarBuilder.append("KW2455 : 'KW' '2455';\n");
+		grammarBuilder.append("KW2456 : 'KW' '2456';\n");
+		grammarBuilder.append("KW2457 : 'KW' '2457';\n");
+		grammarBuilder.append("KW2458 : 'KW' '2458';\n");
+		grammarBuilder.append("KW2459 : 'KW' '2459';\n");
+		grammarBuilder.append("KW2460 : 'KW' '2460';\n");
+		grammarBuilder.append("KW2461 : 'KW' '2461';\n");
+		grammarBuilder.append("KW2462 : 'KW' '2462';\n");
+		grammarBuilder.append("KW2463 : 'KW' '2463';\n");
+		grammarBuilder.append("KW2464 : 'KW' '2464';\n");
+		grammarBuilder.append("KW2465 : 'KW' '2465';\n");
+		grammarBuilder.append("KW2466 : 'KW' '2466';\n");
+		grammarBuilder.append("KW2467 : 'KW' '2467';\n");
+		grammarBuilder.append("KW2468 : 'KW' '2468';\n");
+		grammarBuilder.append("KW2469 : 'KW' '2469';\n");
+		grammarBuilder.append("KW2470 : 'KW' '2470';\n");
+		grammarBuilder.append("KW2471 : 'KW' '2471';\n");
+		grammarBuilder.append("KW2472 : 'KW' '2472';\n");
+		grammarBuilder.append("KW2473 : 'KW' '2473';\n");
+		grammarBuilder.append("KW2474 : 'KW' '2474';\n");
+		grammarBuilder.append("KW2475 : 'KW' '2475';\n");
+		grammarBuilder.append("KW2476 : 'KW' '2476';\n");
+		grammarBuilder.append("KW2477 : 'KW' '2477';\n");
+		grammarBuilder.append("KW2478 : 'KW' '2478';\n");
+		grammarBuilder.append("KW2479 : 'KW' '2479';\n");
+		grammarBuilder.append("KW2480 : 'KW' '2480';\n");
+		grammarBuilder.append("KW2481 : 'KW' '2481';\n");
+		grammarBuilder.append("KW2482 : 'KW' '2482';\n");
+		grammarBuilder.append("KW2483 : 'KW' '2483';\n");
+		grammarBuilder.append("KW2484 : 'KW' '2484';\n");
+		grammarBuilder.append("KW2485 : 'KW' '2485';\n");
+		grammarBuilder.append("KW2486 : 'KW' '2486';\n");
+		grammarBuilder.append("KW2487 : 'KW' '2487';\n");
+		grammarBuilder.append("KW2488 : 'KW' '2488';\n");
+		grammarBuilder.append("KW2489 : 'KW' '2489';\n");
+		grammarBuilder.append("KW2490 : 'KW' '2490';\n");
+		grammarBuilder.append("KW2491 : 'KW' '2491';\n");
+		grammarBuilder.append("KW2492 : 'KW' '2492';\n");
+		grammarBuilder.append("KW2493 : 'KW' '2493';\n");
+		grammarBuilder.append("KW2494 : 'KW' '2494';\n");
+		grammarBuilder.append("KW2495 : 'KW' '2495';\n");
+		grammarBuilder.append("KW2496 : 'KW' '2496';\n");
+		grammarBuilder.append("KW2497 : 'KW' '2497';\n");
+		grammarBuilder.append("KW2498 : 'KW' '2498';\n");
+		grammarBuilder.append("KW2499 : 'KW' '2499';\n");
+		grammarBuilder.append("KW2500 : 'KW' '2500';\n");
+		grammarBuilder.append("KW2501 : 'KW' '2501';\n");
+		grammarBuilder.append("KW2502 : 'KW' '2502';\n");
+		grammarBuilder.append("KW2503 : 'KW' '2503';\n");
+		grammarBuilder.append("KW2504 : 'KW' '2504';\n");
+		grammarBuilder.append("KW2505 : 'KW' '2505';\n");
+		grammarBuilder.append("KW2506 : 'KW' '2506';\n");
+		grammarBuilder.append("KW2507 : 'KW' '2507';\n");
+		grammarBuilder.append("KW2508 : 'KW' '2508';\n");
+		grammarBuilder.append("KW2509 : 'KW' '2509';\n");
+		grammarBuilder.append("KW2510 : 'KW' '2510';\n");
+		grammarBuilder.append("KW2511 : 'KW' '2511';\n");
+		grammarBuilder.append("KW2512 : 'KW' '2512';\n");
+		grammarBuilder.append("KW2513 : 'KW' '2513';\n");
+		grammarBuilder.append("KW2514 : 'KW' '2514';\n");
+		grammarBuilder.append("KW2515 : 'KW' '2515';\n");
+		grammarBuilder.append("KW2516 : 'KW' '2516';\n");
+		grammarBuilder.append("KW2517 : 'KW' '2517';\n");
+		grammarBuilder.append("KW2518 : 'KW' '2518';\n");
+		grammarBuilder.append("KW2519 : 'KW' '2519';\n");
+		grammarBuilder.append("KW2520 : 'KW' '2520';\n");
+		grammarBuilder.append("KW2521 : 'KW' '2521';\n");
+		grammarBuilder.append("KW2522 : 'KW' '2522';\n");
+		grammarBuilder.append("KW2523 : 'KW' '2523';\n");
+		grammarBuilder.append("KW2524 : 'KW' '2524';\n");
+		grammarBuilder.append("KW2525 : 'KW' '2525';\n");
+		grammarBuilder.append("KW2526 : 'KW' '2526';\n");
+		grammarBuilder.append("KW2527 : 'KW' '2527';\n");
+		grammarBuilder.append("KW2528 : 'KW' '2528';\n");
+		grammarBuilder.append("KW2529 : 'KW' '2529';\n");
+		grammarBuilder.append("KW2530 : 'KW' '2530';\n");
+		grammarBuilder.append("KW2531 : 'KW' '2531';\n");
+		grammarBuilder.append("KW2532 : 'KW' '2532';\n");
+		grammarBuilder.append("KW2533 : 'KW' '2533';\n");
+		grammarBuilder.append("KW2534 : 'KW' '2534';\n");
+		grammarBuilder.append("KW2535 : 'KW' '2535';\n");
+		grammarBuilder.append("KW2536 : 'KW' '2536';\n");
+		grammarBuilder.append("KW2537 : 'KW' '2537';\n");
+		grammarBuilder.append("KW2538 : 'KW' '2538';\n");
+		grammarBuilder.append("KW2539 : 'KW' '2539';\n");
+		grammarBuilder.append("KW2540 : 'KW' '2540';\n");
+		grammarBuilder.append("KW2541 : 'KW' '2541';\n");
+		grammarBuilder.append("KW2542 : 'KW' '2542';\n");
+		grammarBuilder.append("KW2543 : 'KW' '2543';\n");
+		grammarBuilder.append("KW2544 : 'KW' '2544';\n");
+		grammarBuilder.append("KW2545 : 'KW' '2545';\n");
+		grammarBuilder.append("KW2546 : 'KW' '2546';\n");
+		grammarBuilder.append("KW2547 : 'KW' '2547';\n");
+		grammarBuilder.append("KW2548 : 'KW' '2548';\n");
+		grammarBuilder.append("KW2549 : 'KW' '2549';\n");
+		grammarBuilder.append("KW2550 : 'KW' '2550';\n");
+		grammarBuilder.append("KW2551 : 'KW' '2551';\n");
+		grammarBuilder.append("KW2552 : 'KW' '2552';\n");
+		grammarBuilder.append("KW2553 : 'KW' '2553';\n");
+		grammarBuilder.append("KW2554 : 'KW' '2554';\n");
+		grammarBuilder.append("KW2555 : 'KW' '2555';\n");
+		grammarBuilder.append("KW2556 : 'KW' '2556';\n");
+		grammarBuilder.append("KW2557 : 'KW' '2557';\n");
+		grammarBuilder.append("KW2558 : 'KW' '2558';\n");
+		grammarBuilder.append("KW2559 : 'KW' '2559';\n");
+		grammarBuilder.append("KW2560 : 'KW' '2560';\n");
+		grammarBuilder.append("KW2561 : 'KW' '2561';\n");
+		grammarBuilder.append("KW2562 : 'KW' '2562';\n");
+		grammarBuilder.append("KW2563 : 'KW' '2563';\n");
+		grammarBuilder.append("KW2564 : 'KW' '2564';\n");
+		grammarBuilder.append("KW2565 : 'KW' '2565';\n");
+		grammarBuilder.append("KW2566 : 'KW' '2566';\n");
+		grammarBuilder.append("KW2567 : 'KW' '2567';\n");
+		grammarBuilder.append("KW2568 : 'KW' '2568';\n");
+		grammarBuilder.append("KW2569 : 'KW' '2569';\n");
+		grammarBuilder.append("KW2570 : 'KW' '2570';\n");
+		grammarBuilder.append("KW2571 : 'KW' '2571';\n");
+		grammarBuilder.append("KW2572 : 'KW' '2572';\n");
+		grammarBuilder.append("KW2573 : 'KW' '2573';\n");
+		grammarBuilder.append("KW2574 : 'KW' '2574';\n");
+		grammarBuilder.append("KW2575 : 'KW' '2575';\n");
+		grammarBuilder.append("KW2576 : 'KW' '2576';\n");
+		grammarBuilder.append("KW2577 : 'KW' '2577';\n");
+		grammarBuilder.append("KW2578 : 'KW' '2578';\n");
+		grammarBuilder.append("KW2579 : 'KW' '2579';\n");
+		grammarBuilder.append("KW2580 : 'KW' '2580';\n");
+		grammarBuilder.append("KW2581 : 'KW' '2581';\n");
+		grammarBuilder.append("KW2582 : 'KW' '2582';\n");
+		grammarBuilder.append("KW2583 : 'KW' '2583';\n");
+		grammarBuilder.append("KW2584 : 'KW' '2584';\n");
+		grammarBuilder.append("KW2585 : 'KW' '2585';\n");
+		grammarBuilder.append("KW2586 : 'KW' '2586';\n");
+		grammarBuilder.append("KW2587 : 'KW' '2587';\n");
+		grammarBuilder.append("KW2588 : 'KW' '2588';\n");
+		grammarBuilder.append("KW2589 : 'KW' '2589';\n");
+		grammarBuilder.append("KW2590 : 'KW' '2590';\n");
+		grammarBuilder.append("KW2591 : 'KW' '2591';\n");
+		grammarBuilder.append("KW2592 : 'KW' '2592';\n");
+		grammarBuilder.append("KW2593 : 'KW' '2593';\n");
+		grammarBuilder.append("KW2594 : 'KW' '2594';\n");
+		grammarBuilder.append("KW2595 : 'KW' '2595';\n");
+		grammarBuilder.append("KW2596 : 'KW' '2596';\n");
+		grammarBuilder.append("KW2597 : 'KW' '2597';\n");
+		grammarBuilder.append("KW2598 : 'KW' '2598';\n");
+		grammarBuilder.append("KW2599 : 'KW' '2599';\n");
+		grammarBuilder.append("KW2600 : 'KW' '2600';\n");
+		grammarBuilder.append("KW2601 : 'KW' '2601';\n");
+		grammarBuilder.append("KW2602 : 'KW' '2602';\n");
+		grammarBuilder.append("KW2603 : 'KW' '2603';\n");
+		grammarBuilder.append("KW2604 : 'KW' '2604';\n");
+		grammarBuilder.append("KW2605 : 'KW' '2605';\n");
+		grammarBuilder.append("KW2606 : 'KW' '2606';\n");
+		grammarBuilder.append("KW2607 : 'KW' '2607';\n");
+		grammarBuilder.append("KW2608 : 'KW' '2608';\n");
+		grammarBuilder.append("KW2609 : 'KW' '2609';\n");
+		grammarBuilder.append("KW2610 : 'KW' '2610';\n");
+		grammarBuilder.append("KW2611 : 'KW' '2611';\n");
+		grammarBuilder.append("KW2612 : 'KW' '2612';\n");
+		grammarBuilder.append("KW2613 : 'KW' '2613';\n");
+		grammarBuilder.append("KW2614 : 'KW' '2614';\n");
+		grammarBuilder.append("KW2615 : 'KW' '2615';\n");
+		grammarBuilder.append("KW2616 : 'KW' '2616';\n");
+		grammarBuilder.append("KW2617 : 'KW' '2617';\n");
+		grammarBuilder.append("KW2618 : 'KW' '2618';\n");
+		grammarBuilder.append("KW2619 : 'KW' '2619';\n");
+		grammarBuilder.append("KW2620 : 'KW' '2620';\n");
+		grammarBuilder.append("KW2621 : 'KW' '2621';\n");
+		grammarBuilder.append("KW2622 : 'KW' '2622';\n");
+		grammarBuilder.append("KW2623 : 'KW' '2623';\n");
+		grammarBuilder.append("KW2624 : 'KW' '2624';\n");
+		grammarBuilder.append("KW2625 : 'KW' '2625';\n");
+		grammarBuilder.append("KW2626 : 'KW' '2626';\n");
+		grammarBuilder.append("KW2627 : 'KW' '2627';\n");
+		grammarBuilder.append("KW2628 : 'KW' '2628';\n");
+		grammarBuilder.append("KW2629 : 'KW' '2629';\n");
+		grammarBuilder.append("KW2630 : 'KW' '2630';\n");
+		grammarBuilder.append("KW2631 : 'KW' '2631';\n");
+		grammarBuilder.append("KW2632 : 'KW' '2632';\n");
+		grammarBuilder.append("KW2633 : 'KW' '2633';\n");
+		grammarBuilder.append("KW2634 : 'KW' '2634';\n");
+		grammarBuilder.append("KW2635 : 'KW' '2635';\n");
+		grammarBuilder.append("KW2636 : 'KW' '2636';\n");
+		grammarBuilder.append("KW2637 : 'KW' '2637';\n");
+		grammarBuilder.append("KW2638 : 'KW' '2638';\n");
+		grammarBuilder.append("KW2639 : 'KW' '2639';\n");
+		grammarBuilder.append("KW2640 : 'KW' '2640';\n");
+		grammarBuilder.append("KW2641 : 'KW' '2641';\n");
+		grammarBuilder.append("KW2642 : 'KW' '2642';\n");
+		grammarBuilder.append("KW2643 : 'KW' '2643';\n");
+		grammarBuilder.append("KW2644 : 'KW' '2644';\n");
+		grammarBuilder.append("KW2645 : 'KW' '2645';\n");
+		grammarBuilder.append("KW2646 : 'KW' '2646';\n");
+		grammarBuilder.append("KW2647 : 'KW' '2647';\n");
+		grammarBuilder.append("KW2648 : 'KW' '2648';\n");
+		grammarBuilder.append("KW2649 : 'KW' '2649';\n");
+		grammarBuilder.append("KW2650 : 'KW' '2650';\n");
+		grammarBuilder.append("KW2651 : 'KW' '2651';\n");
+		grammarBuilder.append("KW2652 : 'KW' '2652';\n");
+		grammarBuilder.append("KW2653 : 'KW' '2653';\n");
+		grammarBuilder.append("KW2654 : 'KW' '2654';\n");
+		grammarBuilder.append("KW2655 : 'KW' '2655';\n");
+		grammarBuilder.append("KW2656 : 'KW' '2656';\n");
+		grammarBuilder.append("KW2657 : 'KW' '2657';\n");
+		grammarBuilder.append("KW2658 : 'KW' '2658';\n");
+		grammarBuilder.append("KW2659 : 'KW' '2659';\n");
+		grammarBuilder.append("KW2660 : 'KW' '2660';\n");
+		grammarBuilder.append("KW2661 : 'KW' '2661';\n");
+		grammarBuilder.append("KW2662 : 'KW' '2662';\n");
+		grammarBuilder.append("KW2663 : 'KW' '2663';\n");
+		grammarBuilder.append("KW2664 : 'KW' '2664';\n");
+		grammarBuilder.append("KW2665 : 'KW' '2665';\n");
+		grammarBuilder.append("KW2666 : 'KW' '2666';\n");
+		grammarBuilder.append("KW2667 : 'KW' '2667';\n");
+		grammarBuilder.append("KW2668 : 'KW' '2668';\n");
+		grammarBuilder.append("KW2669 : 'KW' '2669';\n");
+		grammarBuilder.append("KW2670 : 'KW' '2670';\n");
+		grammarBuilder.append("KW2671 : 'KW' '2671';\n");
+		grammarBuilder.append("KW2672 : 'KW' '2672';\n");
+		grammarBuilder.append("KW2673 : 'KW' '2673';\n");
+		grammarBuilder.append("KW2674 : 'KW' '2674';\n");
+		grammarBuilder.append("KW2675 : 'KW' '2675';\n");
+		grammarBuilder.append("KW2676 : 'KW' '2676';\n");
+		grammarBuilder.append("KW2677 : 'KW' '2677';\n");
+		grammarBuilder.append("KW2678 : 'KW' '2678';\n");
+		grammarBuilder.append("KW2679 : 'KW' '2679';\n");
+		grammarBuilder.append("KW2680 : 'KW' '2680';\n");
+		grammarBuilder.append("KW2681 : 'KW' '2681';\n");
+		grammarBuilder.append("KW2682 : 'KW' '2682';\n");
+		grammarBuilder.append("KW2683 : 'KW' '2683';\n");
+		grammarBuilder.append("KW2684 : 'KW' '2684';\n");
+		grammarBuilder.append("KW2685 : 'KW' '2685';\n");
+		grammarBuilder.append("KW2686 : 'KW' '2686';\n");
+		grammarBuilder.append("KW2687 : 'KW' '2687';\n");
+		grammarBuilder.append("KW2688 : 'KW' '2688';\n");
+		grammarBuilder.append("KW2689 : 'KW' '2689';\n");
+		grammarBuilder.append("KW2690 : 'KW' '2690';\n");
+		grammarBuilder.append("KW2691 : 'KW' '2691';\n");
+		grammarBuilder.append("KW2692 : 'KW' '2692';\n");
+		grammarBuilder.append("KW2693 : 'KW' '2693';\n");
+		grammarBuilder.append("KW2694 : 'KW' '2694';\n");
+		grammarBuilder.append("KW2695 : 'KW' '2695';\n");
+		grammarBuilder.append("KW2696 : 'KW' '2696';\n");
+		grammarBuilder.append("KW2697 : 'KW' '2697';\n");
+		grammarBuilder.append("KW2698 : 'KW' '2698';\n");
+		grammarBuilder.append("KW2699 : 'KW' '2699';\n");
+		grammarBuilder.append("KW2700 : 'KW' '2700';\n");
+		grammarBuilder.append("KW2701 : 'KW' '2701';\n");
+		grammarBuilder.append("KW2702 : 'KW' '2702';\n");
+		grammarBuilder.append("KW2703 : 'KW' '2703';\n");
+		grammarBuilder.append("KW2704 : 'KW' '2704';\n");
+		grammarBuilder.append("KW2705 : 'KW' '2705';\n");
+		grammarBuilder.append("KW2706 : 'KW' '2706';\n");
+		grammarBuilder.append("KW2707 : 'KW' '2707';\n");
+		grammarBuilder.append("KW2708 : 'KW' '2708';\n");
+		grammarBuilder.append("KW2709 : 'KW' '2709';\n");
+		grammarBuilder.append("KW2710 : 'KW' '2710';\n");
+		grammarBuilder.append("KW2711 : 'KW' '2711';\n");
+		grammarBuilder.append("KW2712 : 'KW' '2712';\n");
+		grammarBuilder.append("KW2713 : 'KW' '2713';\n");
+		grammarBuilder.append("KW2714 : 'KW' '2714';\n");
+		grammarBuilder.append("KW2715 : 'KW' '2715';\n");
+		grammarBuilder.append("KW2716 : 'KW' '2716';\n");
+		grammarBuilder.append("KW2717 : 'KW' '2717';\n");
+		grammarBuilder.append("KW2718 : 'KW' '2718';\n");
+		grammarBuilder.append("KW2719 : 'KW' '2719';\n");
+		grammarBuilder.append("KW2720 : 'KW' '2720';\n");
+		grammarBuilder.append("KW2721 : 'KW' '2721';\n");
+		grammarBuilder.append("KW2722 : 'KW' '2722';\n");
+		grammarBuilder.append("KW2723 : 'KW' '2723';\n");
+		grammarBuilder.append("KW2724 : 'KW' '2724';\n");
+		grammarBuilder.append("KW2725 : 'KW' '2725';\n");
+		grammarBuilder.append("KW2726 : 'KW' '2726';\n");
+		grammarBuilder.append("KW2727 : 'KW' '2727';\n");
+		grammarBuilder.append("KW2728 : 'KW' '2728';\n");
+		grammarBuilder.append("KW2729 : 'KW' '2729';\n");
+		grammarBuilder.append("KW2730 : 'KW' '2730';\n");
+		grammarBuilder.append("KW2731 : 'KW' '2731';\n");
+		grammarBuilder.append("KW2732 : 'KW' '2732';\n");
+		grammarBuilder.append("KW2733 : 'KW' '2733';\n");
+		grammarBuilder.append("KW2734 : 'KW' '2734';\n");
+		grammarBuilder.append("KW2735 : 'KW' '2735';\n");
+		grammarBuilder.append("KW2736 : 'KW' '2736';\n");
+		grammarBuilder.append("KW2737 : 'KW' '2737';\n");
+		grammarBuilder.append("KW2738 : 'KW' '2738';\n");
+		grammarBuilder.append("KW2739 : 'KW' '2739';\n");
+		grammarBuilder.append("KW2740 : 'KW' '2740';\n");
+		grammarBuilder.append("KW2741 : 'KW' '2741';\n");
+		grammarBuilder.append("KW2742 : 'KW' '2742';\n");
+		grammarBuilder.append("KW2743 : 'KW' '2743';\n");
+		grammarBuilder.append("KW2744 : 'KW' '2744';\n");
+		grammarBuilder.append("KW2745 : 'KW' '2745';\n");
+		grammarBuilder.append("KW2746 : 'KW' '2746';\n");
+		grammarBuilder.append("KW2747 : 'KW' '2747';\n");
+		grammarBuilder.append("KW2748 : 'KW' '2748';\n");
+		grammarBuilder.append("KW2749 : 'KW' '2749';\n");
+		grammarBuilder.append("KW2750 : 'KW' '2750';\n");
+		grammarBuilder.append("KW2751 : 'KW' '2751';\n");
+		grammarBuilder.append("KW2752 : 'KW' '2752';\n");
+		grammarBuilder.append("KW2753 : 'KW' '2753';\n");
+		grammarBuilder.append("KW2754 : 'KW' '2754';\n");
+		grammarBuilder.append("KW2755 : 'KW' '2755';\n");
+		grammarBuilder.append("KW2756 : 'KW' '2756';\n");
+		grammarBuilder.append("KW2757 : 'KW' '2757';\n");
+		grammarBuilder.append("KW2758 : 'KW' '2758';\n");
+		grammarBuilder.append("KW2759 : 'KW' '2759';\n");
+		grammarBuilder.append("KW2760 : 'KW' '2760';\n");
+		grammarBuilder.append("KW2761 : 'KW' '2761';\n");
+		grammarBuilder.append("KW2762 : 'KW' '2762';\n");
+		grammarBuilder.append("KW2763 : 'KW' '2763';\n");
+		grammarBuilder.append("KW2764 : 'KW' '2764';\n");
+		grammarBuilder.append("KW2765 : 'KW' '2765';\n");
+		grammarBuilder.append("KW2766 : 'KW' '2766';\n");
+		grammarBuilder.append("KW2767 : 'KW' '2767';\n");
+		grammarBuilder.append("KW2768 : 'KW' '2768';\n");
+		grammarBuilder.append("KW2769 : 'KW' '2769';\n");
+		grammarBuilder.append("KW2770 : 'KW' '2770';\n");
+		grammarBuilder.append("KW2771 : 'KW' '2771';\n");
+		grammarBuilder.append("KW2772 : 'KW' '2772';\n");
+		grammarBuilder.append("KW2773 : 'KW' '2773';\n");
+		grammarBuilder.append("KW2774 : 'KW' '2774';\n");
+		grammarBuilder.append("KW2775 : 'KW' '2775';\n");
+		grammarBuilder.append("KW2776 : 'KW' '2776';\n");
+		grammarBuilder.append("KW2777 : 'KW' '2777';\n");
+		grammarBuilder.append("KW2778 : 'KW' '2778';\n");
+		grammarBuilder.append("KW2779 : 'KW' '2779';\n");
+		grammarBuilder.append("KW2780 : 'KW' '2780';\n");
+		grammarBuilder.append("KW2781 : 'KW' '2781';\n");
+		grammarBuilder.append("KW2782 : 'KW' '2782';\n");
+		grammarBuilder.append("KW2783 : 'KW' '2783';\n");
+		grammarBuilder.append("KW2784 : 'KW' '2784';\n");
+		grammarBuilder.append("KW2785 : 'KW' '2785';\n");
+		grammarBuilder.append("KW2786 : 'KW' '2786';\n");
+		grammarBuilder.append("KW2787 : 'KW' '2787';\n");
+		grammarBuilder.append("KW2788 : 'KW' '2788';\n");
+		grammarBuilder.append("KW2789 : 'KW' '2789';\n");
+		grammarBuilder.append("KW2790 : 'KW' '2790';\n");
+		grammarBuilder.append("KW2791 : 'KW' '2791';\n");
+		grammarBuilder.append("KW2792 : 'KW' '2792';\n");
+		grammarBuilder.append("KW2793 : 'KW' '2793';\n");
+		grammarBuilder.append("KW2794 : 'KW' '2794';\n");
+		grammarBuilder.append("KW2795 : 'KW' '2795';\n");
+		grammarBuilder.append("KW2796 : 'KW' '2796';\n");
+		grammarBuilder.append("KW2797 : 'KW' '2797';\n");
+		grammarBuilder.append("KW2798 : 'KW' '2798';\n");
+		grammarBuilder.append("KW2799 : 'KW' '2799';\n");
+		grammarBuilder.append("KW2800 : 'KW' '2800';\n");
+		grammarBuilder.append("KW2801 : 'KW' '2801';\n");
+		grammarBuilder.append("KW2802 : 'KW' '2802';\n");
+		grammarBuilder.append("KW2803 : 'KW' '2803';\n");
+		grammarBuilder.append("KW2804 : 'KW' '2804';\n");
+		grammarBuilder.append("KW2805 : 'KW' '2805';\n");
+		grammarBuilder.append("KW2806 : 'KW' '2806';\n");
+		grammarBuilder.append("KW2807 : 'KW' '2807';\n");
+		grammarBuilder.append("KW2808 : 'KW' '2808';\n");
+		grammarBuilder.append("KW2809 : 'KW' '2809';\n");
+		grammarBuilder.append("KW2810 : 'KW' '2810';\n");
+		grammarBuilder.append("KW2811 : 'KW' '2811';\n");
+		grammarBuilder.append("KW2812 : 'KW' '2812';\n");
+		grammarBuilder.append("KW2813 : 'KW' '2813';\n");
+		grammarBuilder.append("KW2814 : 'KW' '2814';\n");
+		grammarBuilder.append("KW2815 : 'KW' '2815';\n");
+		grammarBuilder.append("KW2816 : 'KW' '2816';\n");
+		grammarBuilder.append("KW2817 : 'KW' '2817';\n");
+		grammarBuilder.append("KW2818 : 'KW' '2818';\n");
+		grammarBuilder.append("KW2819 : 'KW' '2819';\n");
+		grammarBuilder.append("KW2820 : 'KW' '2820';\n");
+		grammarBuilder.append("KW2821 : 'KW' '2821';\n");
+		grammarBuilder.append("KW2822 : 'KW' '2822';\n");
+		grammarBuilder.append("KW2823 : 'KW' '2823';\n");
+		grammarBuilder.append("KW2824 : 'KW' '2824';\n");
+		grammarBuilder.append("KW2825 : 'KW' '2825';\n");
+		grammarBuilder.append("KW2826 : 'KW' '2826';\n");
+		grammarBuilder.append("KW2827 : 'KW' '2827';\n");
+		grammarBuilder.append("KW2828 : 'KW' '2828';\n");
+		grammarBuilder.append("KW2829 : 'KW' '2829';\n");
+		grammarBuilder.append("KW2830 : 'KW' '2830';\n");
+		grammarBuilder.append("KW2831 : 'KW' '2831';\n");
+		grammarBuilder.append("KW2832 : 'KW' '2832';\n");
+		grammarBuilder.append("KW2833 : 'KW' '2833';\n");
+		grammarBuilder.append("KW2834 : 'KW' '2834';\n");
+		grammarBuilder.append("KW2835 : 'KW' '2835';\n");
+		grammarBuilder.append("KW2836 : 'KW' '2836';\n");
+		grammarBuilder.append("KW2837 : 'KW' '2837';\n");
+		grammarBuilder.append("KW2838 : 'KW' '2838';\n");
+		grammarBuilder.append("KW2839 : 'KW' '2839';\n");
+		grammarBuilder.append("KW2840 : 'KW' '2840';\n");
+		grammarBuilder.append("KW2841 : 'KW' '2841';\n");
+		grammarBuilder.append("KW2842 : 'KW' '2842';\n");
+		grammarBuilder.append("KW2843 : 'KW' '2843';\n");
+		grammarBuilder.append("KW2844 : 'KW' '2844';\n");
+		grammarBuilder.append("KW2845 : 'KW' '2845';\n");
+		grammarBuilder.append("KW2846 : 'KW' '2846';\n");
+		grammarBuilder.append("KW2847 : 'KW' '2847';\n");
+		grammarBuilder.append("KW2848 : 'KW' '2848';\n");
+		grammarBuilder.append("KW2849 : 'KW' '2849';\n");
+		grammarBuilder.append("KW2850 : 'KW' '2850';\n");
+		grammarBuilder.append("KW2851 : 'KW' '2851';\n");
+		grammarBuilder.append("KW2852 : 'KW' '2852';\n");
+		grammarBuilder.append("KW2853 : 'KW' '2853';\n");
+		grammarBuilder.append("KW2854 : 'KW' '2854';\n");
+		grammarBuilder.append("KW2855 : 'KW' '2855';\n");
+		grammarBuilder.append("KW2856 : 'KW' '2856';\n");
+		grammarBuilder.append("KW2857 : 'KW' '2857';\n");
+		grammarBuilder.append("KW2858 : 'KW' '2858';\n");
+		grammarBuilder.append("KW2859 : 'KW' '2859';\n");
+		grammarBuilder.append("KW2860 : 'KW' '2860';\n");
+		grammarBuilder.append("KW2861 : 'KW' '2861';\n");
+		grammarBuilder.append("KW2862 : 'KW' '2862';\n");
+		grammarBuilder.append("KW2863 : 'KW' '2863';\n");
+		grammarBuilder.append("KW2864 : 'KW' '2864';\n");
+		grammarBuilder.append("KW2865 : 'KW' '2865';\n");
+		grammarBuilder.append("KW2866 : 'KW' '2866';\n");
+		grammarBuilder.append("KW2867 : 'KW' '2867';\n");
+		grammarBuilder.append("KW2868 : 'KW' '2868';\n");
+		grammarBuilder.append("KW2869 : 'KW' '2869';\n");
+		grammarBuilder.append("KW2870 : 'KW' '2870';\n");
+		grammarBuilder.append("KW2871 : 'KW' '2871';\n");
+		grammarBuilder.append("KW2872 : 'KW' '2872';\n");
+		grammarBuilder.append("KW2873 : 'KW' '2873';\n");
+		grammarBuilder.append("KW2874 : 'KW' '2874';\n");
+		grammarBuilder.append("KW2875 : 'KW' '2875';\n");
+		grammarBuilder.append("KW2876 : 'KW' '2876';\n");
+		grammarBuilder.append("KW2877 : 'KW' '2877';\n");
+		grammarBuilder.append("KW2878 : 'KW' '2878';\n");
+		grammarBuilder.append("KW2879 : 'KW' '2879';\n");
+		grammarBuilder.append("KW2880 : 'KW' '2880';\n");
+		grammarBuilder.append("KW2881 : 'KW' '2881';\n");
+		grammarBuilder.append("KW2882 : 'KW' '2882';\n");
+		grammarBuilder.append("KW2883 : 'KW' '2883';\n");
+		grammarBuilder.append("KW2884 : 'KW' '2884';\n");
+		grammarBuilder.append("KW2885 : 'KW' '2885';\n");
+		grammarBuilder.append("KW2886 : 'KW' '2886';\n");
+		grammarBuilder.append("KW2887 : 'KW' '2887';\n");
+		grammarBuilder.append("KW2888 : 'KW' '2888';\n");
+		grammarBuilder.append("KW2889 : 'KW' '2889';\n");
+		grammarBuilder.append("KW2890 : 'KW' '2890';\n");
+		grammarBuilder.append("KW2891 : 'KW' '2891';\n");
+		grammarBuilder.append("KW2892 : 'KW' '2892';\n");
+		grammarBuilder.append("KW2893 : 'KW' '2893';\n");
+		grammarBuilder.append("KW2894 : 'KW' '2894';\n");
+		grammarBuilder.append("KW2895 : 'KW' '2895';\n");
+		grammarBuilder.append("KW2896 : 'KW' '2896';\n");
+		grammarBuilder.append("KW2897 : 'KW' '2897';\n");
+		grammarBuilder.append("KW2898 : 'KW' '2898';\n");
+		grammarBuilder.append("KW2899 : 'KW' '2899';\n");
+		grammarBuilder.append("KW2900 : 'KW' '2900';\n");
+		grammarBuilder.append("KW2901 : 'KW' '2901';\n");
+		grammarBuilder.append("KW2902 : 'KW' '2902';\n");
+		grammarBuilder.append("KW2903 : 'KW' '2903';\n");
+		grammarBuilder.append("KW2904 : 'KW' '2904';\n");
+		grammarBuilder.append("KW2905 : 'KW' '2905';\n");
+		grammarBuilder.append("KW2906 : 'KW' '2906';\n");
+		grammarBuilder.append("KW2907 : 'KW' '2907';\n");
+		grammarBuilder.append("KW2908 : 'KW' '2908';\n");
+		grammarBuilder.append("KW2909 : 'KW' '2909';\n");
+		grammarBuilder.append("KW2910 : 'KW' '2910';\n");
+		grammarBuilder.append("KW2911 : 'KW' '2911';\n");
+		grammarBuilder.append("KW2912 : 'KW' '2912';\n");
+		grammarBuilder.append("KW2913 : 'KW' '2913';\n");
+		grammarBuilder.append("KW2914 : 'KW' '2914';\n");
+		grammarBuilder.append("KW2915 : 'KW' '2915';\n");
+		grammarBuilder.append("KW2916 : 'KW' '2916';\n");
+		grammarBuilder.append("KW2917 : 'KW' '2917';\n");
+		grammarBuilder.append("KW2918 : 'KW' '2918';\n");
+		grammarBuilder.append("KW2919 : 'KW' '2919';\n");
+		grammarBuilder.append("KW2920 : 'KW' '2920';\n");
+		grammarBuilder.append("KW2921 : 'KW' '2921';\n");
+		grammarBuilder.append("KW2922 : 'KW' '2922';\n");
+		grammarBuilder.append("KW2923 : 'KW' '2923';\n");
+		grammarBuilder.append("KW2924 : 'KW' '2924';\n");
+		grammarBuilder.append("KW2925 : 'KW' '2925';\n");
+		grammarBuilder.append("KW2926 : 'KW' '2926';\n");
+		grammarBuilder.append("KW2927 : 'KW' '2927';\n");
+		grammarBuilder.append("KW2928 : 'KW' '2928';\n");
+		grammarBuilder.append("KW2929 : 'KW' '2929';\n");
+		grammarBuilder.append("KW2930 : 'KW' '2930';\n");
+		grammarBuilder.append("KW2931 : 'KW' '2931';\n");
+		grammarBuilder.append("KW2932 : 'KW' '2932';\n");
+		grammarBuilder.append("KW2933 : 'KW' '2933';\n");
+		grammarBuilder.append("KW2934 : 'KW' '2934';\n");
+		grammarBuilder.append("KW2935 : 'KW' '2935';\n");
+		grammarBuilder.append("KW2936 : 'KW' '2936';\n");
+		grammarBuilder.append("KW2937 : 'KW' '2937';\n");
+		grammarBuilder.append("KW2938 : 'KW' '2938';\n");
+		grammarBuilder.append("KW2939 : 'KW' '2939';\n");
+		grammarBuilder.append("KW2940 : 'KW' '2940';\n");
+		grammarBuilder.append("KW2941 : 'KW' '2941';\n");
+		grammarBuilder.append("KW2942 : 'KW' '2942';\n");
+		grammarBuilder.append("KW2943 : 'KW' '2943';\n");
+		grammarBuilder.append("KW2944 : 'KW' '2944';\n");
+		grammarBuilder.append("KW2945 : 'KW' '2945';\n");
+		grammarBuilder.append("KW2946 : 'KW' '2946';\n");
+		grammarBuilder.append("KW2947 : 'KW' '2947';\n");
+		grammarBuilder.append("KW2948 : 'KW' '2948';\n");
+		grammarBuilder.append("KW2949 : 'KW' '2949';\n");
+		grammarBuilder.append("KW2950 : 'KW' '2950';\n");
+		grammarBuilder.append("KW2951 : 'KW' '2951';\n");
+		grammarBuilder.append("KW2952 : 'KW' '2952';\n");
+		grammarBuilder.append("KW2953 : 'KW' '2953';\n");
+		grammarBuilder.append("KW2954 : 'KW' '2954';\n");
+		grammarBuilder.append("KW2955 : 'KW' '2955';\n");
+		grammarBuilder.append("KW2956 : 'KW' '2956';\n");
+		grammarBuilder.append("KW2957 : 'KW' '2957';\n");
+		grammarBuilder.append("KW2958 : 'KW' '2958';\n");
+		grammarBuilder.append("KW2959 : 'KW' '2959';\n");
+		grammarBuilder.append("KW2960 : 'KW' '2960';\n");
+		grammarBuilder.append("KW2961 : 'KW' '2961';\n");
+		grammarBuilder.append("KW2962 : 'KW' '2962';\n");
+		grammarBuilder.append("KW2963 : 'KW' '2963';\n");
+		grammarBuilder.append("KW2964 : 'KW' '2964';\n");
+		grammarBuilder.append("KW2965 : 'KW' '2965';\n");
+		grammarBuilder.append("KW2966 : 'KW' '2966';\n");
+		grammarBuilder.append("KW2967 : 'KW' '2967';\n");
+		grammarBuilder.append("KW2968 : 'KW' '2968';\n");
+		grammarBuilder.append("KW2969 : 'KW' '2969';\n");
+		grammarBuilder.append("KW2970 : 'KW' '2970';\n");
+		grammarBuilder.append("KW2971 : 'KW' '2971';\n");
+		grammarBuilder.append("KW2972 : 'KW' '2972';\n");
+		grammarBuilder.append("KW2973 : 'KW' '2973';\n");
+		grammarBuilder.append("KW2974 : 'KW' '2974';\n");
+		grammarBuilder.append("KW2975 : 'KW' '2975';\n");
+		grammarBuilder.append("KW2976 : 'KW' '2976';\n");
+		grammarBuilder.append("KW2977 : 'KW' '2977';\n");
+		grammarBuilder.append("KW2978 : 'KW' '2978';\n");
+		grammarBuilder.append("KW2979 : 'KW' '2979';\n");
+		grammarBuilder.append("KW2980 : 'KW' '2980';\n");
+		grammarBuilder.append("KW2981 : 'KW' '2981';\n");
+		grammarBuilder.append("KW2982 : 'KW' '2982';\n");
+		grammarBuilder.append("KW2983 : 'KW' '2983';\n");
+		grammarBuilder.append("KW2984 : 'KW' '2984';\n");
+		grammarBuilder.append("KW2985 : 'KW' '2985';\n");
+		grammarBuilder.append("KW2986 : 'KW' '2986';\n");
+		grammarBuilder.append("KW2987 : 'KW' '2987';\n");
+		grammarBuilder.append("KW2988 : 'KW' '2988';\n");
+		grammarBuilder.append("KW2989 : 'KW' '2989';\n");
+		grammarBuilder.append("KW2990 : 'KW' '2990';\n");
+		grammarBuilder.append("KW2991 : 'KW' '2991';\n");
+		grammarBuilder.append("KW2992 : 'KW' '2992';\n");
+		grammarBuilder.append("KW2993 : 'KW' '2993';\n");
+		grammarBuilder.append("KW2994 : 'KW' '2994';\n");
+		grammarBuilder.append("KW2995 : 'KW' '2995';\n");
+		grammarBuilder.append("KW2996 : 'KW' '2996';\n");
+		grammarBuilder.append("KW2997 : 'KW' '2997';\n");
+		grammarBuilder.append("KW2998 : 'KW' '2998';\n");
+		grammarBuilder.append("KW2999 : 'KW' '2999';\n");
+		grammarBuilder.append("KW3000 : 'KW' '3000';\n");
+		grammarBuilder.append("KW3001 : 'KW' '3001';\n");
+		grammarBuilder.append("KW3002 : 'KW' '3002';\n");
+		grammarBuilder.append("KW3003 : 'KW' '3003';\n");
+		grammarBuilder.append("KW3004 : 'KW' '3004';\n");
+		grammarBuilder.append("KW3005 : 'KW' '3005';\n");
+		grammarBuilder.append("KW3006 : 'KW' '3006';\n");
+		grammarBuilder.append("KW3007 : 'KW' '3007';\n");
+		grammarBuilder.append("KW3008 : 'KW' '3008';\n");
+		grammarBuilder.append("KW3009 : 'KW' '3009';\n");
+		grammarBuilder.append("KW3010 : 'KW' '3010';\n");
+		grammarBuilder.append("KW3011 : 'KW' '3011';\n");
+		grammarBuilder.append("KW3012 : 'KW' '3012';\n");
+		grammarBuilder.append("KW3013 : 'KW' '3013';\n");
+		grammarBuilder.append("KW3014 : 'KW' '3014';\n");
+		grammarBuilder.append("KW3015 : 'KW' '3015';\n");
+		grammarBuilder.append("KW3016 : 'KW' '3016';\n");
+		grammarBuilder.append("KW3017 : 'KW' '3017';\n");
+		grammarBuilder.append("KW3018 : 'KW' '3018';\n");
+		grammarBuilder.append("KW3019 : 'KW' '3019';\n");
+		grammarBuilder.append("KW3020 : 'KW' '3020';\n");
+		grammarBuilder.append("KW3021 : 'KW' '3021';\n");
+		grammarBuilder.append("KW3022 : 'KW' '3022';\n");
+		grammarBuilder.append("KW3023 : 'KW' '3023';\n");
+		grammarBuilder.append("KW3024 : 'KW' '3024';\n");
+		grammarBuilder.append("KW3025 : 'KW' '3025';\n");
+		grammarBuilder.append("KW3026 : 'KW' '3026';\n");
+		grammarBuilder.append("KW3027 : 'KW' '3027';\n");
+		grammarBuilder.append("KW3028 : 'KW' '3028';\n");
+		grammarBuilder.append("KW3029 : 'KW' '3029';\n");
+		grammarBuilder.append("KW3030 : 'KW' '3030';\n");
+		grammarBuilder.append("KW3031 : 'KW' '3031';\n");
+		grammarBuilder.append("KW3032 : 'KW' '3032';\n");
+		grammarBuilder.append("KW3033 : 'KW' '3033';\n");
+		grammarBuilder.append("KW3034 : 'KW' '3034';\n");
+		grammarBuilder.append("KW3035 : 'KW' '3035';\n");
+		grammarBuilder.append("KW3036 : 'KW' '3036';\n");
+		grammarBuilder.append("KW3037 : 'KW' '3037';\n");
+		grammarBuilder.append("KW3038 : 'KW' '3038';\n");
+		grammarBuilder.append("KW3039 : 'KW' '3039';\n");
+		grammarBuilder.append("KW3040 : 'KW' '3040';\n");
+		grammarBuilder.append("KW3041 : 'KW' '3041';\n");
+		grammarBuilder.append("KW3042 : 'KW' '3042';\n");
+		grammarBuilder.append("KW3043 : 'KW' '3043';\n");
+		grammarBuilder.append("KW3044 : 'KW' '3044';\n");
+		grammarBuilder.append("KW3045 : 'KW' '3045';\n");
+		grammarBuilder.append("KW3046 : 'KW' '3046';\n");
+		grammarBuilder.append("KW3047 : 'KW' '3047';\n");
+		grammarBuilder.append("KW3048 : 'KW' '3048';\n");
+		grammarBuilder.append("KW3049 : 'KW' '3049';\n");
+		grammarBuilder.append("KW3050 : 'KW' '3050';\n");
+		grammarBuilder.append("KW3051 : 'KW' '3051';\n");
+		grammarBuilder.append("KW3052 : 'KW' '3052';\n");
+		grammarBuilder.append("KW3053 : 'KW' '3053';\n");
+		grammarBuilder.append("KW3054 : 'KW' '3054';\n");
+		grammarBuilder.append("KW3055 : 'KW' '3055';\n");
+		grammarBuilder.append("KW3056 : 'KW' '3056';\n");
+		grammarBuilder.append("KW3057 : 'KW' '3057';\n");
+		grammarBuilder.append("KW3058 : 'KW' '3058';\n");
+		grammarBuilder.append("KW3059 : 'KW' '3059';\n");
+		grammarBuilder.append("KW3060 : 'KW' '3060';\n");
+		grammarBuilder.append("KW3061 : 'KW' '3061';\n");
+		grammarBuilder.append("KW3062 : 'KW' '3062';\n");
+		grammarBuilder.append("KW3063 : 'KW' '3063';\n");
+		grammarBuilder.append("KW3064 : 'KW' '3064';\n");
+		grammarBuilder.append("KW3065 : 'KW' '3065';\n");
+		grammarBuilder.append("KW3066 : 'KW' '3066';\n");
+		grammarBuilder.append("KW3067 : 'KW' '3067';\n");
+		grammarBuilder.append("KW3068 : 'KW' '3068';\n");
+		grammarBuilder.append("KW3069 : 'KW' '3069';\n");
+		grammarBuilder.append("KW3070 : 'KW' '3070';\n");
+		grammarBuilder.append("KW3071 : 'KW' '3071';\n");
+		grammarBuilder.append("KW3072 : 'KW' '3072';\n");
+		grammarBuilder.append("KW3073 : 'KW' '3073';\n");
+		grammarBuilder.append("KW3074 : 'KW' '3074';\n");
+		grammarBuilder.append("KW3075 : 'KW' '3075';\n");
+		grammarBuilder.append("KW3076 : 'KW' '3076';\n");
+		grammarBuilder.append("KW3077 : 'KW' '3077';\n");
+		grammarBuilder.append("KW3078 : 'KW' '3078';\n");
+		grammarBuilder.append("KW3079 : 'KW' '3079';\n");
+		grammarBuilder.append("KW3080 : 'KW' '3080';\n");
+		grammarBuilder.append("KW3081 : 'KW' '3081';\n");
+		grammarBuilder.append("KW3082 : 'KW' '3082';\n");
+		grammarBuilder.append("KW3083 : 'KW' '3083';\n");
+		grammarBuilder.append("KW3084 : 'KW' '3084';\n");
+		grammarBuilder.append("KW3085 : 'KW' '3085';\n");
+		grammarBuilder.append("KW3086 : 'KW' '3086';\n");
+		grammarBuilder.append("KW3087 : 'KW' '3087';\n");
+		grammarBuilder.append("KW3088 : 'KW' '3088';\n");
+		grammarBuilder.append("KW3089 : 'KW' '3089';\n");
+		grammarBuilder.append("KW3090 : 'KW' '3090';\n");
+		grammarBuilder.append("KW3091 : 'KW' '3091';\n");
+		grammarBuilder.append("KW3092 : 'KW' '3092';\n");
+		grammarBuilder.append("KW3093 : 'KW' '3093';\n");
+		grammarBuilder.append("KW3094 : 'KW' '3094';\n");
+		grammarBuilder.append("KW3095 : 'KW' '3095';\n");
+		grammarBuilder.append("KW3096 : 'KW' '3096';\n");
+		grammarBuilder.append("KW3097 : 'KW' '3097';\n");
+		grammarBuilder.append("KW3098 : 'KW' '3098';\n");
+		grammarBuilder.append("KW3099 : 'KW' '3099';\n");
+		grammarBuilder.append("KW3100 : 'KW' '3100';\n");
+		grammarBuilder.append("KW3101 : 'KW' '3101';\n");
+		grammarBuilder.append("KW3102 : 'KW' '3102';\n");
+		grammarBuilder.append("KW3103 : 'KW' '3103';\n");
+		grammarBuilder.append("KW3104 : 'KW' '3104';\n");
+		grammarBuilder.append("KW3105 : 'KW' '3105';\n");
+		grammarBuilder.append("KW3106 : 'KW' '3106';\n");
+		grammarBuilder.append("KW3107 : 'KW' '3107';\n");
+		grammarBuilder.append("KW3108 : 'KW' '3108';\n");
+		grammarBuilder.append("KW3109 : 'KW' '3109';\n");
+		grammarBuilder.append("KW3110 : 'KW' '3110';\n");
+		grammarBuilder.append("KW3111 : 'KW' '3111';\n");
+		grammarBuilder.append("KW3112 : 'KW' '3112';\n");
+		grammarBuilder.append("KW3113 : 'KW' '3113';\n");
+		grammarBuilder.append("KW3114 : 'KW' '3114';\n");
+		grammarBuilder.append("KW3115 : 'KW' '3115';\n");
+		grammarBuilder.append("KW3116 : 'KW' '3116';\n");
+		grammarBuilder.append("KW3117 : 'KW' '3117';\n");
+		grammarBuilder.append("KW3118 : 'KW' '3118';\n");
+		grammarBuilder.append("KW3119 : 'KW' '3119';\n");
+		grammarBuilder.append("KW3120 : 'KW' '3120';\n");
+		grammarBuilder.append("KW3121 : 'KW' '3121';\n");
+		grammarBuilder.append("KW3122 : 'KW' '3122';\n");
+		grammarBuilder.append("KW3123 : 'KW' '3123';\n");
+		grammarBuilder.append("KW3124 : 'KW' '3124';\n");
+		grammarBuilder.append("KW3125 : 'KW' '3125';\n");
+		grammarBuilder.append("KW3126 : 'KW' '3126';\n");
+		grammarBuilder.append("KW3127 : 'KW' '3127';\n");
+		grammarBuilder.append("KW3128 : 'KW' '3128';\n");
+		grammarBuilder.append("KW3129 : 'KW' '3129';\n");
+		grammarBuilder.append("KW3130 : 'KW' '3130';\n");
+		grammarBuilder.append("KW3131 : 'KW' '3131';\n");
+		grammarBuilder.append("KW3132 : 'KW' '3132';\n");
+		grammarBuilder.append("KW3133 : 'KW' '3133';\n");
+		grammarBuilder.append("KW3134 : 'KW' '3134';\n");
+		grammarBuilder.append("KW3135 : 'KW' '3135';\n");
+		grammarBuilder.append("KW3136 : 'KW' '3136';\n");
+		grammarBuilder.append("KW3137 : 'KW' '3137';\n");
+		grammarBuilder.append("KW3138 : 'KW' '3138';\n");
+		grammarBuilder.append("KW3139 : 'KW' '3139';\n");
+		grammarBuilder.append("KW3140 : 'KW' '3140';\n");
+		grammarBuilder.append("KW3141 : 'KW' '3141';\n");
+		grammarBuilder.append("KW3142 : 'KW' '3142';\n");
+		grammarBuilder.append("KW3143 : 'KW' '3143';\n");
+		grammarBuilder.append("KW3144 : 'KW' '3144';\n");
+		grammarBuilder.append("KW3145 : 'KW' '3145';\n");
+		grammarBuilder.append("KW3146 : 'KW' '3146';\n");
+		grammarBuilder.append("KW3147 : 'KW' '3147';\n");
+		grammarBuilder.append("KW3148 : 'KW' '3148';\n");
+		grammarBuilder.append("KW3149 : 'KW' '3149';\n");
+		grammarBuilder.append("KW3150 : 'KW' '3150';\n");
+		grammarBuilder.append("KW3151 : 'KW' '3151';\n");
+		grammarBuilder.append("KW3152 : 'KW' '3152';\n");
+		grammarBuilder.append("KW3153 : 'KW' '3153';\n");
+		grammarBuilder.append("KW3154 : 'KW' '3154';\n");
+		grammarBuilder.append("KW3155 : 'KW' '3155';\n");
+		grammarBuilder.append("KW3156 : 'KW' '3156';\n");
+		grammarBuilder.append("KW3157 : 'KW' '3157';\n");
+		grammarBuilder.append("KW3158 : 'KW' '3158';\n");
+		grammarBuilder.append("KW3159 : 'KW' '3159';\n");
+		grammarBuilder.append("KW3160 : 'KW' '3160';\n");
+		grammarBuilder.append("KW3161 : 'KW' '3161';\n");
+		grammarBuilder.append("KW3162 : 'KW' '3162';\n");
+		grammarBuilder.append("KW3163 : 'KW' '3163';\n");
+		grammarBuilder.append("KW3164 : 'KW' '3164';\n");
+		grammarBuilder.append("KW3165 : 'KW' '3165';\n");
+		grammarBuilder.append("KW3166 : 'KW' '3166';\n");
+		grammarBuilder.append("KW3167 : 'KW' '3167';\n");
+		grammarBuilder.append("KW3168 : 'KW' '3168';\n");
+		grammarBuilder.append("KW3169 : 'KW' '3169';\n");
+		grammarBuilder.append("KW3170 : 'KW' '3170';\n");
+		grammarBuilder.append("KW3171 : 'KW' '3171';\n");
+		grammarBuilder.append("KW3172 : 'KW' '3172';\n");
+		grammarBuilder.append("KW3173 : 'KW' '3173';\n");
+		grammarBuilder.append("KW3174 : 'KW' '3174';\n");
+		grammarBuilder.append("KW3175 : 'KW' '3175';\n");
+		grammarBuilder.append("KW3176 : 'KW' '3176';\n");
+		grammarBuilder.append("KW3177 : 'KW' '3177';\n");
+		grammarBuilder.append("KW3178 : 'KW' '3178';\n");
+		grammarBuilder.append("KW3179 : 'KW' '3179';\n");
+		grammarBuilder.append("KW3180 : 'KW' '3180';\n");
+		grammarBuilder.append("KW3181 : 'KW' '3181';\n");
+		grammarBuilder.append("KW3182 : 'KW' '3182';\n");
+		grammarBuilder.append("KW3183 : 'KW' '3183';\n");
+		grammarBuilder.append("KW3184 : 'KW' '3184';\n");
+		grammarBuilder.append("KW3185 : 'KW' '3185';\n");
+		grammarBuilder.append("KW3186 : 'KW' '3186';\n");
+		grammarBuilder.append("KW3187 : 'KW' '3187';\n");
+		grammarBuilder.append("KW3188 : 'KW' '3188';\n");
+		grammarBuilder.append("KW3189 : 'KW' '3189';\n");
+		grammarBuilder.append("KW3190 : 'KW' '3190';\n");
+		grammarBuilder.append("KW3191 : 'KW' '3191';\n");
+		grammarBuilder.append("KW3192 : 'KW' '3192';\n");
+		grammarBuilder.append("KW3193 : 'KW' '3193';\n");
+		grammarBuilder.append("KW3194 : 'KW' '3194';\n");
+		grammarBuilder.append("KW3195 : 'KW' '3195';\n");
+		grammarBuilder.append("KW3196 : 'KW' '3196';\n");
+		grammarBuilder.append("KW3197 : 'KW' '3197';\n");
+		grammarBuilder.append("KW3198 : 'KW' '3198';\n");
+		grammarBuilder.append("KW3199 : 'KW' '3199';\n");
+		grammarBuilder.append("KW3200 : 'KW' '3200';\n");
+		grammarBuilder.append("KW3201 : 'KW' '3201';\n");
+		grammarBuilder.append("KW3202 : 'KW' '3202';\n");
+		grammarBuilder.append("KW3203 : 'KW' '3203';\n");
+		grammarBuilder.append("KW3204 : 'KW' '3204';\n");
+		grammarBuilder.append("KW3205 : 'KW' '3205';\n");
+		grammarBuilder.append("KW3206 : 'KW' '3206';\n");
+		grammarBuilder.append("KW3207 : 'KW' '3207';\n");
+		grammarBuilder.append("KW3208 : 'KW' '3208';\n");
+		grammarBuilder.append("KW3209 : 'KW' '3209';\n");
+		grammarBuilder.append("KW3210 : 'KW' '3210';\n");
+		grammarBuilder.append("KW3211 : 'KW' '3211';\n");
+		grammarBuilder.append("KW3212 : 'KW' '3212';\n");
+		grammarBuilder.append("KW3213 : 'KW' '3213';\n");
+		grammarBuilder.append("KW3214 : 'KW' '3214';\n");
+		grammarBuilder.append("KW3215 : 'KW' '3215';\n");
+		grammarBuilder.append("KW3216 : 'KW' '3216';\n");
+		grammarBuilder.append("KW3217 : 'KW' '3217';\n");
+		grammarBuilder.append("KW3218 : 'KW' '3218';\n");
+		grammarBuilder.append("KW3219 : 'KW' '3219';\n");
+		grammarBuilder.append("KW3220 : 'KW' '3220';\n");
+		grammarBuilder.append("KW3221 : 'KW' '3221';\n");
+		grammarBuilder.append("KW3222 : 'KW' '3222';\n");
+		grammarBuilder.append("KW3223 : 'KW' '3223';\n");
+		grammarBuilder.append("KW3224 : 'KW' '3224';\n");
+		grammarBuilder.append("KW3225 : 'KW' '3225';\n");
+		grammarBuilder.append("KW3226 : 'KW' '3226';\n");
+		grammarBuilder.append("KW3227 : 'KW' '3227';\n");
+		grammarBuilder.append("KW3228 : 'KW' '3228';\n");
+		grammarBuilder.append("KW3229 : 'KW' '3229';\n");
+		grammarBuilder.append("KW3230 : 'KW' '3230';\n");
+		grammarBuilder.append("KW3231 : 'KW' '3231';\n");
+		grammarBuilder.append("KW3232 : 'KW' '3232';\n");
+		grammarBuilder.append("KW3233 : 'KW' '3233';\n");
+		grammarBuilder.append("KW3234 : 'KW' '3234';\n");
+		grammarBuilder.append("KW3235 : 'KW' '3235';\n");
+		grammarBuilder.append("KW3236 : 'KW' '3236';\n");
+		grammarBuilder.append("KW3237 : 'KW' '3237';\n");
+		grammarBuilder.append("KW3238 : 'KW' '3238';\n");
+		grammarBuilder.append("KW3239 : 'KW' '3239';\n");
+		grammarBuilder.append("KW3240 : 'KW' '3240';\n");
+		grammarBuilder.append("KW3241 : 'KW' '3241';\n");
+		grammarBuilder.append("KW3242 : 'KW' '3242';\n");
+		grammarBuilder.append("KW3243 : 'KW' '3243';\n");
+		grammarBuilder.append("KW3244 : 'KW' '3244';\n");
+		grammarBuilder.append("KW3245 : 'KW' '3245';\n");
+		grammarBuilder.append("KW3246 : 'KW' '3246';\n");
+		grammarBuilder.append("KW3247 : 'KW' '3247';\n");
+		grammarBuilder.append("KW3248 : 'KW' '3248';\n");
+		grammarBuilder.append("KW3249 : 'KW' '3249';\n");
+		grammarBuilder.append("KW3250 : 'KW' '3250';\n");
+		grammarBuilder.append("KW3251 : 'KW' '3251';\n");
+		grammarBuilder.append("KW3252 : 'KW' '3252';\n");
+		grammarBuilder.append("KW3253 : 'KW' '3253';\n");
+		grammarBuilder.append("KW3254 : 'KW' '3254';\n");
+		grammarBuilder.append("KW3255 : 'KW' '3255';\n");
+		grammarBuilder.append("KW3256 : 'KW' '3256';\n");
+		grammarBuilder.append("KW3257 : 'KW' '3257';\n");
+		grammarBuilder.append("KW3258 : 'KW' '3258';\n");
+		grammarBuilder.append("KW3259 : 'KW' '3259';\n");
+		grammarBuilder.append("KW3260 : 'KW' '3260';\n");
+		grammarBuilder.append("KW3261 : 'KW' '3261';\n");
+		grammarBuilder.append("KW3262 : 'KW' '3262';\n");
+		grammarBuilder.append("KW3263 : 'KW' '3263';\n");
+		grammarBuilder.append("KW3264 : 'KW' '3264';\n");
+		grammarBuilder.append("KW3265 : 'KW' '3265';\n");
+		grammarBuilder.append("KW3266 : 'KW' '3266';\n");
+		grammarBuilder.append("KW3267 : 'KW' '3267';\n");
+		grammarBuilder.append("KW3268 : 'KW' '3268';\n");
+		grammarBuilder.append("KW3269 : 'KW' '3269';\n");
+		grammarBuilder.append("KW3270 : 'KW' '3270';\n");
+		grammarBuilder.append("KW3271 : 'KW' '3271';\n");
+		grammarBuilder.append("KW3272 : 'KW' '3272';\n");
+		grammarBuilder.append("KW3273 : 'KW' '3273';\n");
+		grammarBuilder.append("KW3274 : 'KW' '3274';\n");
+		grammarBuilder.append("KW3275 : 'KW' '3275';\n");
+		grammarBuilder.append("KW3276 : 'KW' '3276';\n");
+		grammarBuilder.append("KW3277 : 'KW' '3277';\n");
+		grammarBuilder.append("KW3278 : 'KW' '3278';\n");
+		grammarBuilder.append("KW3279 : 'KW' '3279';\n");
+		grammarBuilder.append("KW3280 : 'KW' '3280';\n");
+		grammarBuilder.append("KW3281 : 'KW' '3281';\n");
+		grammarBuilder.append("KW3282 : 'KW' '3282';\n");
+		grammarBuilder.append("KW3283 : 'KW' '3283';\n");
+		grammarBuilder.append("KW3284 : 'KW' '3284';\n");
+		grammarBuilder.append("KW3285 : 'KW' '3285';\n");
+		grammarBuilder.append("KW3286 : 'KW' '3286';\n");
+		grammarBuilder.append("KW3287 : 'KW' '3287';\n");
+		grammarBuilder.append("KW3288 : 'KW' '3288';\n");
+		grammarBuilder.append("KW3289 : 'KW' '3289';\n");
+		grammarBuilder.append("KW3290 : 'KW' '3290';\n");
+		grammarBuilder.append("KW3291 : 'KW' '3291';\n");
+		grammarBuilder.append("KW3292 : 'KW' '3292';\n");
+		grammarBuilder.append("KW3293 : 'KW' '3293';\n");
+		grammarBuilder.append("KW3294 : 'KW' '3294';\n");
+		grammarBuilder.append("KW3295 : 'KW' '3295';\n");
+		grammarBuilder.append("KW3296 : 'KW' '3296';\n");
+		grammarBuilder.append("KW3297 : 'KW' '3297';\n");
+		grammarBuilder.append("KW3298 : 'KW' '3298';\n");
+		grammarBuilder.append("KW3299 : 'KW' '3299';\n");
+		grammarBuilder.append("KW3300 : 'KW' '3300';\n");
+		grammarBuilder.append("KW3301 : 'KW' '3301';\n");
+		grammarBuilder.append("KW3302 : 'KW' '3302';\n");
+		grammarBuilder.append("KW3303 : 'KW' '3303';\n");
+		grammarBuilder.append("KW3304 : 'KW' '3304';\n");
+		grammarBuilder.append("KW3305 : 'KW' '3305';\n");
+		grammarBuilder.append("KW3306 : 'KW' '3306';\n");
+		grammarBuilder.append("KW3307 : 'KW' '3307';\n");
+		grammarBuilder.append("KW3308 : 'KW' '3308';\n");
+		grammarBuilder.append("KW3309 : 'KW' '3309';\n");
+		grammarBuilder.append("KW3310 : 'KW' '3310';\n");
+		grammarBuilder.append("KW3311 : 'KW' '3311';\n");
+		grammarBuilder.append("KW3312 : 'KW' '3312';\n");
+		grammarBuilder.append("KW3313 : 'KW' '3313';\n");
+		grammarBuilder.append("KW3314 : 'KW' '3314';\n");
+		grammarBuilder.append("KW3315 : 'KW' '3315';\n");
+		grammarBuilder.append("KW3316 : 'KW' '3316';\n");
+		grammarBuilder.append("KW3317 : 'KW' '3317';\n");
+		grammarBuilder.append("KW3318 : 'KW' '3318';\n");
+		grammarBuilder.append("KW3319 : 'KW' '3319';\n");
+		grammarBuilder.append("KW3320 : 'KW' '3320';\n");
+		grammarBuilder.append("KW3321 : 'KW' '3321';\n");
+		grammarBuilder.append("KW3322 : 'KW' '3322';\n");
+		grammarBuilder.append("KW3323 : 'KW' '3323';\n");
+		grammarBuilder.append("KW3324 : 'KW' '3324';\n");
+		grammarBuilder.append("KW3325 : 'KW' '3325';\n");
+		grammarBuilder.append("KW3326 : 'KW' '3326';\n");
+		grammarBuilder.append("KW3327 : 'KW' '3327';\n");
+		grammarBuilder.append("KW3328 : 'KW' '3328';\n");
+		grammarBuilder.append("KW3329 : 'KW' '3329';\n");
+		grammarBuilder.append("KW3330 : 'KW' '3330';\n");
+		grammarBuilder.append("KW3331 : 'KW' '3331';\n");
+		grammarBuilder.append("KW3332 : 'KW' '3332';\n");
+		grammarBuilder.append("KW3333 : 'KW' '3333';\n");
+		grammarBuilder.append("KW3334 : 'KW' '3334';\n");
+		grammarBuilder.append("KW3335 : 'KW' '3335';\n");
+		grammarBuilder.append("KW3336 : 'KW' '3336';\n");
+		grammarBuilder.append("KW3337 : 'KW' '3337';\n");
+		grammarBuilder.append("KW3338 : 'KW' '3338';\n");
+		grammarBuilder.append("KW3339 : 'KW' '3339';\n");
+		grammarBuilder.append("KW3340 : 'KW' '3340';\n");
+		grammarBuilder.append("KW3341 : 'KW' '3341';\n");
+		grammarBuilder.append("KW3342 : 'KW' '3342';\n");
+		grammarBuilder.append("KW3343 : 'KW' '3343';\n");
+		grammarBuilder.append("KW3344 : 'KW' '3344';\n");
+		grammarBuilder.append("KW3345 : 'KW' '3345';\n");
+		grammarBuilder.append("KW3346 : 'KW' '3346';\n");
+		grammarBuilder.append("KW3347 : 'KW' '3347';\n");
+		grammarBuilder.append("KW3348 : 'KW' '3348';\n");
+		grammarBuilder.append("KW3349 : 'KW' '3349';\n");
+		grammarBuilder.append("KW3350 : 'KW' '3350';\n");
+		grammarBuilder.append("KW3351 : 'KW' '3351';\n");
+		grammarBuilder.append("KW3352 : 'KW' '3352';\n");
+		grammarBuilder.append("KW3353 : 'KW' '3353';\n");
+		grammarBuilder.append("KW3354 : 'KW' '3354';\n");
+		grammarBuilder.append("KW3355 : 'KW' '3355';\n");
+		grammarBuilder.append("KW3356 : 'KW' '3356';\n");
+		grammarBuilder.append("KW3357 : 'KW' '3357';\n");
+		grammarBuilder.append("KW3358 : 'KW' '3358';\n");
+		grammarBuilder.append("KW3359 : 'KW' '3359';\n");
+		grammarBuilder.append("KW3360 : 'KW' '3360';\n");
+		grammarBuilder.append("KW3361 : 'KW' '3361';\n");
+		grammarBuilder.append("KW3362 : 'KW' '3362';\n");
+		grammarBuilder.append("KW3363 : 'KW' '3363';\n");
+		grammarBuilder.append("KW3364 : 'KW' '3364';\n");
+		grammarBuilder.append("KW3365 : 'KW' '3365';\n");
+		grammarBuilder.append("KW3366 : 'KW' '3366';\n");
+		grammarBuilder.append("KW3367 : 'KW' '3367';\n");
+		grammarBuilder.append("KW3368 : 'KW' '3368';\n");
+		grammarBuilder.append("KW3369 : 'KW' '3369';\n");
+		grammarBuilder.append("KW3370 : 'KW' '3370';\n");
+		grammarBuilder.append("KW3371 : 'KW' '3371';\n");
+		grammarBuilder.append("KW3372 : 'KW' '3372';\n");
+		grammarBuilder.append("KW3373 : 'KW' '3373';\n");
+		grammarBuilder.append("KW3374 : 'KW' '3374';\n");
+		grammarBuilder.append("KW3375 : 'KW' '3375';\n");
+		grammarBuilder.append("KW3376 : 'KW' '3376';\n");
+		grammarBuilder.append("KW3377 : 'KW' '3377';\n");
+		grammarBuilder.append("KW3378 : 'KW' '3378';\n");
+		grammarBuilder.append("KW3379 : 'KW' '3379';\n");
+		grammarBuilder.append("KW3380 : 'KW' '3380';\n");
+		grammarBuilder.append("KW3381 : 'KW' '3381';\n");
+		grammarBuilder.append("KW3382 : 'KW' '3382';\n");
+		grammarBuilder.append("KW3383 : 'KW' '3383';\n");
+		grammarBuilder.append("KW3384 : 'KW' '3384';\n");
+		grammarBuilder.append("KW3385 : 'KW' '3385';\n");
+		grammarBuilder.append("KW3386 : 'KW' '3386';\n");
+		grammarBuilder.append("KW3387 : 'KW' '3387';\n");
+		grammarBuilder.append("KW3388 : 'KW' '3388';\n");
+		grammarBuilder.append("KW3389 : 'KW' '3389';\n");
+		grammarBuilder.append("KW3390 : 'KW' '3390';\n");
+		grammarBuilder.append("KW3391 : 'KW' '3391';\n");
+		grammarBuilder.append("KW3392 : 'KW' '3392';\n");
+		grammarBuilder.append("KW3393 : 'KW' '3393';\n");
+		grammarBuilder.append("KW3394 : 'KW' '3394';\n");
+		grammarBuilder.append("KW3395 : 'KW' '3395';\n");
+		grammarBuilder.append("KW3396 : 'KW' '3396';\n");
+		grammarBuilder.append("KW3397 : 'KW' '3397';\n");
+		grammarBuilder.append("KW3398 : 'KW' '3398';\n");
+		grammarBuilder.append("KW3399 : 'KW' '3399';\n");
+		grammarBuilder.append("KW3400 : 'KW' '3400';\n");
+		grammarBuilder.append("KW3401 : 'KW' '3401';\n");
+		grammarBuilder.append("KW3402 : 'KW' '3402';\n");
+		grammarBuilder.append("KW3403 : 'KW' '3403';\n");
+		grammarBuilder.append("KW3404 : 'KW' '3404';\n");
+		grammarBuilder.append("KW3405 : 'KW' '3405';\n");
+		grammarBuilder.append("KW3406 : 'KW' '3406';\n");
+		grammarBuilder.append("KW3407 : 'KW' '3407';\n");
+		grammarBuilder.append("KW3408 : 'KW' '3408';\n");
+		grammarBuilder.append("KW3409 : 'KW' '3409';\n");
+		grammarBuilder.append("KW3410 : 'KW' '3410';\n");
+		grammarBuilder.append("KW3411 : 'KW' '3411';\n");
+		grammarBuilder.append("KW3412 : 'KW' '3412';\n");
+		grammarBuilder.append("KW3413 : 'KW' '3413';\n");
+		grammarBuilder.append("KW3414 : 'KW' '3414';\n");
+		grammarBuilder.append("KW3415 : 'KW' '3415';\n");
+		grammarBuilder.append("KW3416 : 'KW' '3416';\n");
+		grammarBuilder.append("KW3417 : 'KW' '3417';\n");
+		grammarBuilder.append("KW3418 : 'KW' '3418';\n");
+		grammarBuilder.append("KW3419 : 'KW' '3419';\n");
+		grammarBuilder.append("KW3420 : 'KW' '3420';\n");
+		grammarBuilder.append("KW3421 : 'KW' '3421';\n");
+		grammarBuilder.append("KW3422 : 'KW' '3422';\n");
+		grammarBuilder.append("KW3423 : 'KW' '3423';\n");
+		grammarBuilder.append("KW3424 : 'KW' '3424';\n");
+		grammarBuilder.append("KW3425 : 'KW' '3425';\n");
+		grammarBuilder.append("KW3426 : 'KW' '3426';\n");
+		grammarBuilder.append("KW3427 : 'KW' '3427';\n");
+		grammarBuilder.append("KW3428 : 'KW' '3428';\n");
+		grammarBuilder.append("KW3429 : 'KW' '3429';\n");
+		grammarBuilder.append("KW3430 : 'KW' '3430';\n");
+		grammarBuilder.append("KW3431 : 'KW' '3431';\n");
+		grammarBuilder.append("KW3432 : 'KW' '3432';\n");
+		grammarBuilder.append("KW3433 : 'KW' '3433';\n");
+		grammarBuilder.append("KW3434 : 'KW' '3434';\n");
+		grammarBuilder.append("KW3435 : 'KW' '3435';\n");
+		grammarBuilder.append("KW3436 : 'KW' '3436';\n");
+		grammarBuilder.append("KW3437 : 'KW' '3437';\n");
+		grammarBuilder.append("KW3438 : 'KW' '3438';\n");
+		grammarBuilder.append("KW3439 : 'KW' '3439';\n");
+		grammarBuilder.append("KW3440 : 'KW' '3440';\n");
+		grammarBuilder.append("KW3441 : 'KW' '3441';\n");
+		grammarBuilder.append("KW3442 : 'KW' '3442';\n");
+		grammarBuilder.append("KW3443 : 'KW' '3443';\n");
+		grammarBuilder.append("KW3444 : 'KW' '3444';\n");
+		grammarBuilder.append("KW3445 : 'KW' '3445';\n");
+		grammarBuilder.append("KW3446 : 'KW' '3446';\n");
+		grammarBuilder.append("KW3447 : 'KW' '3447';\n");
+		grammarBuilder.append("KW3448 : 'KW' '3448';\n");
+		grammarBuilder.append("KW3449 : 'KW' '3449';\n");
+		grammarBuilder.append("KW3450 : 'KW' '3450';\n");
+		grammarBuilder.append("KW3451 : 'KW' '3451';\n");
+		grammarBuilder.append("KW3452 : 'KW' '3452';\n");
+		grammarBuilder.append("KW3453 : 'KW' '3453';\n");
+		grammarBuilder.append("KW3454 : 'KW' '3454';\n");
+		grammarBuilder.append("KW3455 : 'KW' '3455';\n");
+		grammarBuilder.append("KW3456 : 'KW' '3456';\n");
+		grammarBuilder.append("KW3457 : 'KW' '3457';\n");
+		grammarBuilder.append("KW3458 : 'KW' '3458';\n");
+		grammarBuilder.append("KW3459 : 'KW' '3459';\n");
+		grammarBuilder.append("KW3460 : 'KW' '3460';\n");
+		grammarBuilder.append("KW3461 : 'KW' '3461';\n");
+		grammarBuilder.append("KW3462 : 'KW' '3462';\n");
+		grammarBuilder.append("KW3463 : 'KW' '3463';\n");
+		grammarBuilder.append("KW3464 : 'KW' '3464';\n");
+		grammarBuilder.append("KW3465 : 'KW' '3465';\n");
+		grammarBuilder.append("KW3466 : 'KW' '3466';\n");
+		grammarBuilder.append("KW3467 : 'KW' '3467';\n");
+		grammarBuilder.append("KW3468 : 'KW' '3468';\n");
+		grammarBuilder.append("KW3469 : 'KW' '3469';\n");
+		grammarBuilder.append("KW3470 : 'KW' '3470';\n");
+		grammarBuilder.append("KW3471 : 'KW' '3471';\n");
+		grammarBuilder.append("KW3472 : 'KW' '3472';\n");
+		grammarBuilder.append("KW3473 : 'KW' '3473';\n");
+		grammarBuilder.append("KW3474 : 'KW' '3474';\n");
+		grammarBuilder.append("KW3475 : 'KW' '3475';\n");
+		grammarBuilder.append("KW3476 : 'KW' '3476';\n");
+		grammarBuilder.append("KW3477 : 'KW' '3477';\n");
+		grammarBuilder.append("KW3478 : 'KW' '3478';\n");
+		grammarBuilder.append("KW3479 : 'KW' '3479';\n");
+		grammarBuilder.append("KW3480 : 'KW' '3480';\n");
+		grammarBuilder.append("KW3481 : 'KW' '3481';\n");
+		grammarBuilder.append("KW3482 : 'KW' '3482';\n");
+		grammarBuilder.append("KW3483 : 'KW' '3483';\n");
+		grammarBuilder.append("KW3484 : 'KW' '3484';\n");
+		grammarBuilder.append("KW3485 : 'KW' '3485';\n");
+		grammarBuilder.append("KW3486 : 'KW' '3486';\n");
+		grammarBuilder.append("KW3487 : 'KW' '3487';\n");
+		grammarBuilder.append("KW3488 : 'KW' '3488';\n");
+		grammarBuilder.append("KW3489 : 'KW' '3489';\n");
+		grammarBuilder.append("KW3490 : 'KW' '3490';\n");
+		grammarBuilder.append("KW3491 : 'KW' '3491';\n");
+		grammarBuilder.append("KW3492 : 'KW' '3492';\n");
+		grammarBuilder.append("KW3493 : 'KW' '3493';\n");
+		grammarBuilder.append("KW3494 : 'KW' '3494';\n");
+		grammarBuilder.append("KW3495 : 'KW' '3495';\n");
+		grammarBuilder.append("KW3496 : 'KW' '3496';\n");
+		grammarBuilder.append("KW3497 : 'KW' '3497';\n");
+		grammarBuilder.append("KW3498 : 'KW' '3498';\n");
+		grammarBuilder.append("KW3499 : 'KW' '3499';\n");
+		grammarBuilder.append("KW3500 : 'KW' '3500';\n");
+		grammarBuilder.append("KW3501 : 'KW' '3501';\n");
+		grammarBuilder.append("KW3502 : 'KW' '3502';\n");
+		grammarBuilder.append("KW3503 : 'KW' '3503';\n");
+		grammarBuilder.append("KW3504 : 'KW' '3504';\n");
+		grammarBuilder.append("KW3505 : 'KW' '3505';\n");
+		grammarBuilder.append("KW3506 : 'KW' '3506';\n");
+		grammarBuilder.append("KW3507 : 'KW' '3507';\n");
+		grammarBuilder.append("KW3508 : 'KW' '3508';\n");
+		grammarBuilder.append("KW3509 : 'KW' '3509';\n");
+		grammarBuilder.append("KW3510 : 'KW' '3510';\n");
+		grammarBuilder.append("KW3511 : 'KW' '3511';\n");
+		grammarBuilder.append("KW3512 : 'KW' '3512';\n");
+		grammarBuilder.append("KW3513 : 'KW' '3513';\n");
+		grammarBuilder.append("KW3514 : 'KW' '3514';\n");
+		grammarBuilder.append("KW3515 : 'KW' '3515';\n");
+		grammarBuilder.append("KW3516 : 'KW' '3516';\n");
+		grammarBuilder.append("KW3517 : 'KW' '3517';\n");
+		grammarBuilder.append("KW3518 : 'KW' '3518';\n");
+		grammarBuilder.append("KW3519 : 'KW' '3519';\n");
+		grammarBuilder.append("KW3520 : 'KW' '3520';\n");
+		grammarBuilder.append("KW3521 : 'KW' '3521';\n");
+		grammarBuilder.append("KW3522 : 'KW' '3522';\n");
+		grammarBuilder.append("KW3523 : 'KW' '3523';\n");
+		grammarBuilder.append("KW3524 : 'KW' '3524';\n");
+		grammarBuilder.append("KW3525 : 'KW' '3525';\n");
+		grammarBuilder.append("KW3526 : 'KW' '3526';\n");
+		grammarBuilder.append("KW3527 : 'KW' '3527';\n");
+		grammarBuilder.append("KW3528 : 'KW' '3528';\n");
+		grammarBuilder.append("KW3529 : 'KW' '3529';\n");
+		grammarBuilder.append("KW3530 : 'KW' '3530';\n");
+		grammarBuilder.append("KW3531 : 'KW' '3531';\n");
+		grammarBuilder.append("KW3532 : 'KW' '3532';\n");
+		grammarBuilder.append("KW3533 : 'KW' '3533';\n");
+		grammarBuilder.append("KW3534 : 'KW' '3534';\n");
+		grammarBuilder.append("KW3535 : 'KW' '3535';\n");
+		grammarBuilder.append("KW3536 : 'KW' '3536';\n");
+		grammarBuilder.append("KW3537 : 'KW' '3537';\n");
+		grammarBuilder.append("KW3538 : 'KW' '3538';\n");
+		grammarBuilder.append("KW3539 : 'KW' '3539';\n");
+		grammarBuilder.append("KW3540 : 'KW' '3540';\n");
+		grammarBuilder.append("KW3541 : 'KW' '3541';\n");
+		grammarBuilder.append("KW3542 : 'KW' '3542';\n");
+		grammarBuilder.append("KW3543 : 'KW' '3543';\n");
+		grammarBuilder.append("KW3544 : 'KW' '3544';\n");
+		grammarBuilder.append("KW3545 : 'KW' '3545';\n");
+		grammarBuilder.append("KW3546 : 'KW' '3546';\n");
+		grammarBuilder.append("KW3547 : 'KW' '3547';\n");
+		grammarBuilder.append("KW3548 : 'KW' '3548';\n");
+		grammarBuilder.append("KW3549 : 'KW' '3549';\n");
+		grammarBuilder.append("KW3550 : 'KW' '3550';\n");
+		grammarBuilder.append("KW3551 : 'KW' '3551';\n");
+		grammarBuilder.append("KW3552 : 'KW' '3552';\n");
+		grammarBuilder.append("KW3553 : 'KW' '3553';\n");
+		grammarBuilder.append("KW3554 : 'KW' '3554';\n");
+		grammarBuilder.append("KW3555 : 'KW' '3555';\n");
+		grammarBuilder.append("KW3556 : 'KW' '3556';\n");
+		grammarBuilder.append("KW3557 : 'KW' '3557';\n");
+		grammarBuilder.append("KW3558 : 'KW' '3558';\n");
+		grammarBuilder.append("KW3559 : 'KW' '3559';\n");
+		grammarBuilder.append("KW3560 : 'KW' '3560';\n");
+		grammarBuilder.append("KW3561 : 'KW' '3561';\n");
+		grammarBuilder.append("KW3562 : 'KW' '3562';\n");
+		grammarBuilder.append("KW3563 : 'KW' '3563';\n");
+		grammarBuilder.append("KW3564 : 'KW' '3564';\n");
+		grammarBuilder.append("KW3565 : 'KW' '3565';\n");
+		grammarBuilder.append("KW3566 : 'KW' '3566';\n");
+		grammarBuilder.append("KW3567 : 'KW' '3567';\n");
+		grammarBuilder.append("KW3568 : 'KW' '3568';\n");
+		grammarBuilder.append("KW3569 : 'KW' '3569';\n");
+		grammarBuilder.append("KW3570 : 'KW' '3570';\n");
+		grammarBuilder.append("KW3571 : 'KW' '3571';\n");
+		grammarBuilder.append("KW3572 : 'KW' '3572';\n");
+		grammarBuilder.append("KW3573 : 'KW' '3573';\n");
+		grammarBuilder.append("KW3574 : 'KW' '3574';\n");
+		grammarBuilder.append("KW3575 : 'KW' '3575';\n");
+		grammarBuilder.append("KW3576 : 'KW' '3576';\n");
+		grammarBuilder.append("KW3577 : 'KW' '3577';\n");
+		grammarBuilder.append("KW3578 : 'KW' '3578';\n");
+		grammarBuilder.append("KW3579 : 'KW' '3579';\n");
+		grammarBuilder.append("KW3580 : 'KW' '3580';\n");
+		grammarBuilder.append("KW3581 : 'KW' '3581';\n");
+		grammarBuilder.append("KW3582 : 'KW' '3582';\n");
+		grammarBuilder.append("KW3583 : 'KW' '3583';\n");
+		grammarBuilder.append("KW3584 : 'KW' '3584';\n");
+		grammarBuilder.append("KW3585 : 'KW' '3585';\n");
+		grammarBuilder.append("KW3586 : 'KW' '3586';\n");
+		grammarBuilder.append("KW3587 : 'KW' '3587';\n");
+		grammarBuilder.append("KW3588 : 'KW' '3588';\n");
+		grammarBuilder.append("KW3589 : 'KW' '3589';\n");
+		grammarBuilder.append("KW3590 : 'KW' '3590';\n");
+		grammarBuilder.append("KW3591 : 'KW' '3591';\n");
+		grammarBuilder.append("KW3592 : 'KW' '3592';\n");
+		grammarBuilder.append("KW3593 : 'KW' '3593';\n");
+		grammarBuilder.append("KW3594 : 'KW' '3594';\n");
+		grammarBuilder.append("KW3595 : 'KW' '3595';\n");
+		grammarBuilder.append("KW3596 : 'KW' '3596';\n");
+		grammarBuilder.append("KW3597 : 'KW' '3597';\n");
+		grammarBuilder.append("KW3598 : 'KW' '3598';\n");
+		grammarBuilder.append("KW3599 : 'KW' '3599';\n");
+		grammarBuilder.append("KW3600 : 'KW' '3600';\n");
+		grammarBuilder.append("KW3601 : 'KW' '3601';\n");
+		grammarBuilder.append("KW3602 : 'KW' '3602';\n");
+		grammarBuilder.append("KW3603 : 'KW' '3603';\n");
+		grammarBuilder.append("KW3604 : 'KW' '3604';\n");
+		grammarBuilder.append("KW3605 : 'KW' '3605';\n");
+		grammarBuilder.append("KW3606 : 'KW' '3606';\n");
+		grammarBuilder.append("KW3607 : 'KW' '3607';\n");
+		grammarBuilder.append("KW3608 : 'KW' '3608';\n");
+		grammarBuilder.append("KW3609 : 'KW' '3609';\n");
+		grammarBuilder.append("KW3610 : 'KW' '3610';\n");
+		grammarBuilder.append("KW3611 : 'KW' '3611';\n");
+		grammarBuilder.append("KW3612 : 'KW' '3612';\n");
+		grammarBuilder.append("KW3613 : 'KW' '3613';\n");
+		grammarBuilder.append("KW3614 : 'KW' '3614';\n");
+		grammarBuilder.append("KW3615 : 'KW' '3615';\n");
+		grammarBuilder.append("KW3616 : 'KW' '3616';\n");
+		grammarBuilder.append("KW3617 : 'KW' '3617';\n");
+		grammarBuilder.append("KW3618 : 'KW' '3618';\n");
+		grammarBuilder.append("KW3619 : 'KW' '3619';\n");
+		grammarBuilder.append("KW3620 : 'KW' '3620';\n");
+		grammarBuilder.append("KW3621 : 'KW' '3621';\n");
+		grammarBuilder.append("KW3622 : 'KW' '3622';\n");
+		grammarBuilder.append("KW3623 : 'KW' '3623';\n");
+		grammarBuilder.append("KW3624 : 'KW' '3624';\n");
+		grammarBuilder.append("KW3625 : 'KW' '3625';\n");
+		grammarBuilder.append("KW3626 : 'KW' '3626';\n");
+		grammarBuilder.append("KW3627 : 'KW' '3627';\n");
+		grammarBuilder.append("KW3628 : 'KW' '3628';\n");
+		grammarBuilder.append("KW3629 : 'KW' '3629';\n");
+		grammarBuilder.append("KW3630 : 'KW' '3630';\n");
+		grammarBuilder.append("KW3631 : 'KW' '3631';\n");
+		grammarBuilder.append("KW3632 : 'KW' '3632';\n");
+		grammarBuilder.append("KW3633 : 'KW' '3633';\n");
+		grammarBuilder.append("KW3634 : 'KW' '3634';\n");
+		grammarBuilder.append("KW3635 : 'KW' '3635';\n");
+		grammarBuilder.append("KW3636 : 'KW' '3636';\n");
+		grammarBuilder.append("KW3637 : 'KW' '3637';\n");
+		grammarBuilder.append("KW3638 : 'KW' '3638';\n");
+		grammarBuilder.append("KW3639 : 'KW' '3639';\n");
+		grammarBuilder.append("KW3640 : 'KW' '3640';\n");
+		grammarBuilder.append("KW3641 : 'KW' '3641';\n");
+		grammarBuilder.append("KW3642 : 'KW' '3642';\n");
+		grammarBuilder.append("KW3643 : 'KW' '3643';\n");
+		grammarBuilder.append("KW3644 : 'KW' '3644';\n");
+		grammarBuilder.append("KW3645 : 'KW' '3645';\n");
+		grammarBuilder.append("KW3646 : 'KW' '3646';\n");
+		grammarBuilder.append("KW3647 : 'KW' '3647';\n");
+		grammarBuilder.append("KW3648 : 'KW' '3648';\n");
+		grammarBuilder.append("KW3649 : 'KW' '3649';\n");
+		grammarBuilder.append("KW3650 : 'KW' '3650';\n");
+		grammarBuilder.append("KW3651 : 'KW' '3651';\n");
+		grammarBuilder.append("KW3652 : 'KW' '3652';\n");
+		grammarBuilder.append("KW3653 : 'KW' '3653';\n");
+		grammarBuilder.append("KW3654 : 'KW' '3654';\n");
+		grammarBuilder.append("KW3655 : 'KW' '3655';\n");
+		grammarBuilder.append("KW3656 : 'KW' '3656';\n");
+		grammarBuilder.append("KW3657 : 'KW' '3657';\n");
+		grammarBuilder.append("KW3658 : 'KW' '3658';\n");
+		grammarBuilder.append("KW3659 : 'KW' '3659';\n");
+		grammarBuilder.append("KW3660 : 'KW' '3660';\n");
+		grammarBuilder.append("KW3661 : 'KW' '3661';\n");
+		grammarBuilder.append("KW3662 : 'KW' '3662';\n");
+		grammarBuilder.append("KW3663 : 'KW' '3663';\n");
+		grammarBuilder.append("KW3664 : 'KW' '3664';\n");
+		grammarBuilder.append("KW3665 : 'KW' '3665';\n");
+		grammarBuilder.append("KW3666 : 'KW' '3666';\n");
+		grammarBuilder.append("KW3667 : 'KW' '3667';\n");
+		grammarBuilder.append("KW3668 : 'KW' '3668';\n");
+		grammarBuilder.append("KW3669 : 'KW' '3669';\n");
+		grammarBuilder.append("KW3670 : 'KW' '3670';\n");
+		grammarBuilder.append("KW3671 : 'KW' '3671';\n");
+		grammarBuilder.append("KW3672 : 'KW' '3672';\n");
+		grammarBuilder.append("KW3673 : 'KW' '3673';\n");
+		grammarBuilder.append("KW3674 : 'KW' '3674';\n");
+		grammarBuilder.append("KW3675 : 'KW' '3675';\n");
+		grammarBuilder.append("KW3676 : 'KW' '3676';\n");
+		grammarBuilder.append("KW3677 : 'KW' '3677';\n");
+		grammarBuilder.append("KW3678 : 'KW' '3678';\n");
+		grammarBuilder.append("KW3679 : 'KW' '3679';\n");
+		grammarBuilder.append("KW3680 : 'KW' '3680';\n");
+		grammarBuilder.append("KW3681 : 'KW' '3681';\n");
+		grammarBuilder.append("KW3682 : 'KW' '3682';\n");
+		grammarBuilder.append("KW3683 : 'KW' '3683';\n");
+		grammarBuilder.append("KW3684 : 'KW' '3684';\n");
+		grammarBuilder.append("KW3685 : 'KW' '3685';\n");
+		grammarBuilder.append("KW3686 : 'KW' '3686';\n");
+		grammarBuilder.append("KW3687 : 'KW' '3687';\n");
+		grammarBuilder.append("KW3688 : 'KW' '3688';\n");
+		grammarBuilder.append("KW3689 : 'KW' '3689';\n");
+		grammarBuilder.append("KW3690 : 'KW' '3690';\n");
+		grammarBuilder.append("KW3691 : 'KW' '3691';\n");
+		grammarBuilder.append("KW3692 : 'KW' '3692';\n");
+		grammarBuilder.append("KW3693 : 'KW' '3693';\n");
+		grammarBuilder.append("KW3694 : 'KW' '3694';\n");
+		grammarBuilder.append("KW3695 : 'KW' '3695';\n");
+		grammarBuilder.append("KW3696 : 'KW' '3696';\n");
+		grammarBuilder.append("KW3697 : 'KW' '3697';\n");
+		grammarBuilder.append("KW3698 : 'KW' '3698';\n");
+		grammarBuilder.append("KW3699 : 'KW' '3699';\n");
+		grammarBuilder.append("KW3700 : 'KW' '3700';\n");
+		grammarBuilder.append("KW3701 : 'KW' '3701';\n");
+		grammarBuilder.append("KW3702 : 'KW' '3702';\n");
+		grammarBuilder.append("KW3703 : 'KW' '3703';\n");
+		grammarBuilder.append("KW3704 : 'KW' '3704';\n");
+		grammarBuilder.append("KW3705 : 'KW' '3705';\n");
+		grammarBuilder.append("KW3706 : 'KW' '3706';\n");
+		grammarBuilder.append("KW3707 : 'KW' '3707';\n");
+		grammarBuilder.append("KW3708 : 'KW' '3708';\n");
+		grammarBuilder.append("KW3709 : 'KW' '3709';\n");
+		grammarBuilder.append("KW3710 : 'KW' '3710';\n");
+		grammarBuilder.append("KW3711 : 'KW' '3711';\n");
+		grammarBuilder.append("KW3712 : 'KW' '3712';\n");
+		grammarBuilder.append("KW3713 : 'KW' '3713';\n");
+		grammarBuilder.append("KW3714 : 'KW' '3714';\n");
+		grammarBuilder.append("KW3715 : 'KW' '3715';\n");
+		grammarBuilder.append("KW3716 : 'KW' '3716';\n");
+		grammarBuilder.append("KW3717 : 'KW' '3717';\n");
+		grammarBuilder.append("KW3718 : 'KW' '3718';\n");
+		grammarBuilder.append("KW3719 : 'KW' '3719';\n");
+		grammarBuilder.append("KW3720 : 'KW' '3720';\n");
+		grammarBuilder.append("KW3721 : 'KW' '3721';\n");
+		grammarBuilder.append("KW3722 : 'KW' '3722';\n");
+		grammarBuilder.append("KW3723 : 'KW' '3723';\n");
+		grammarBuilder.append("KW3724 : 'KW' '3724';\n");
+		grammarBuilder.append("KW3725 : 'KW' '3725';\n");
+		grammarBuilder.append("KW3726 : 'KW' '3726';\n");
+		grammarBuilder.append("KW3727 : 'KW' '3727';\n");
+		grammarBuilder.append("KW3728 : 'KW' '3728';\n");
+		grammarBuilder.append("KW3729 : 'KW' '3729';\n");
+		grammarBuilder.append("KW3730 : 'KW' '3730';\n");
+		grammarBuilder.append("KW3731 : 'KW' '3731';\n");
+		grammarBuilder.append("KW3732 : 'KW' '3732';\n");
+		grammarBuilder.append("KW3733 : 'KW' '3733';\n");
+		grammarBuilder.append("KW3734 : 'KW' '3734';\n");
+		grammarBuilder.append("KW3735 : 'KW' '3735';\n");
+		grammarBuilder.append("KW3736 : 'KW' '3736';\n");
+		grammarBuilder.append("KW3737 : 'KW' '3737';\n");
+		grammarBuilder.append("KW3738 : 'KW' '3738';\n");
+		grammarBuilder.append("KW3739 : 'KW' '3739';\n");
+		grammarBuilder.append("KW3740 : 'KW' '3740';\n");
+		grammarBuilder.append("KW3741 : 'KW' '3741';\n");
+		grammarBuilder.append("KW3742 : 'KW' '3742';\n");
+		grammarBuilder.append("KW3743 : 'KW' '3743';\n");
+		grammarBuilder.append("KW3744 : 'KW' '3744';\n");
+		grammarBuilder.append("KW3745 : 'KW' '3745';\n");
+		grammarBuilder.append("KW3746 : 'KW' '3746';\n");
+		grammarBuilder.append("KW3747 : 'KW' '3747';\n");
+		grammarBuilder.append("KW3748 : 'KW' '3748';\n");
+		grammarBuilder.append("KW3749 : 'KW' '3749';\n");
+		grammarBuilder.append("KW3750 : 'KW' '3750';\n");
+		grammarBuilder.append("KW3751 : 'KW' '3751';\n");
+		grammarBuilder.append("KW3752 : 'KW' '3752';\n");
+		grammarBuilder.append("KW3753 : 'KW' '3753';\n");
+		grammarBuilder.append("KW3754 : 'KW' '3754';\n");
+		grammarBuilder.append("KW3755 : 'KW' '3755';\n");
+		grammarBuilder.append("KW3756 : 'KW' '3756';\n");
+		grammarBuilder.append("KW3757 : 'KW' '3757';\n");
+		grammarBuilder.append("KW3758 : 'KW' '3758';\n");
+		grammarBuilder.append("KW3759 : 'KW' '3759';\n");
+		grammarBuilder.append("KW3760 : 'KW' '3760';\n");
+		grammarBuilder.append("KW3761 : 'KW' '3761';\n");
+		grammarBuilder.append("KW3762 : 'KW' '3762';\n");
+		grammarBuilder.append("KW3763 : 'KW' '3763';\n");
+		grammarBuilder.append("KW3764 : 'KW' '3764';\n");
+		grammarBuilder.append("KW3765 : 'KW' '3765';\n");
+		grammarBuilder.append("KW3766 : 'KW' '3766';\n");
+		grammarBuilder.append("KW3767 : 'KW' '3767';\n");
+		grammarBuilder.append("KW3768 : 'KW' '3768';\n");
+		grammarBuilder.append("KW3769 : 'KW' '3769';\n");
+		grammarBuilder.append("KW3770 : 'KW' '3770';\n");
+		grammarBuilder.append("KW3771 : 'KW' '3771';\n");
+		grammarBuilder.append("KW3772 : 'KW' '3772';\n");
+		grammarBuilder.append("KW3773 : 'KW' '3773';\n");
+		grammarBuilder.append("KW3774 : 'KW' '3774';\n");
+		grammarBuilder.append("KW3775 : 'KW' '3775';\n");
+		grammarBuilder.append("KW3776 : 'KW' '3776';\n");
+		grammarBuilder.append("KW3777 : 'KW' '3777';\n");
+		grammarBuilder.append("KW3778 : 'KW' '3778';\n");
+		grammarBuilder.append("KW3779 : 'KW' '3779';\n");
+		grammarBuilder.append("KW3780 : 'KW' '3780';\n");
+		grammarBuilder.append("KW3781 : 'KW' '3781';\n");
+		grammarBuilder.append("KW3782 : 'KW' '3782';\n");
+		grammarBuilder.append("KW3783 : 'KW' '3783';\n");
+		grammarBuilder.append("KW3784 : 'KW' '3784';\n");
+		grammarBuilder.append("KW3785 : 'KW' '3785';\n");
+		grammarBuilder.append("KW3786 : 'KW' '3786';\n");
+		grammarBuilder.append("KW3787 : 'KW' '3787';\n");
+		grammarBuilder.append("KW3788 : 'KW' '3788';\n");
+		grammarBuilder.append("KW3789 : 'KW' '3789';\n");
+		grammarBuilder.append("KW3790 : 'KW' '3790';\n");
+		grammarBuilder.append("KW3791 : 'KW' '3791';\n");
+		grammarBuilder.append("KW3792 : 'KW' '3792';\n");
+		grammarBuilder.append("KW3793 : 'KW' '3793';\n");
+		grammarBuilder.append("KW3794 : 'KW' '3794';\n");
+		grammarBuilder.append("KW3795 : 'KW' '3795';\n");
+		grammarBuilder.append("KW3796 : 'KW' '3796';\n");
+		grammarBuilder.append("KW3797 : 'KW' '3797';\n");
+		grammarBuilder.append("KW3798 : 'KW' '3798';\n");
+		grammarBuilder.append("KW3799 : 'KW' '3799';\n");
+		grammarBuilder.append("KW3800 : 'KW' '3800';\n");
+		grammarBuilder.append("KW3801 : 'KW' '3801';\n");
+		grammarBuilder.append("KW3802 : 'KW' '3802';\n");
+		grammarBuilder.append("KW3803 : 'KW' '3803';\n");
+		grammarBuilder.append("KW3804 : 'KW' '3804';\n");
+		grammarBuilder.append("KW3805 : 'KW' '3805';\n");
+		grammarBuilder.append("KW3806 : 'KW' '3806';\n");
+		grammarBuilder.append("KW3807 : 'KW' '3807';\n");
+		grammarBuilder.append("KW3808 : 'KW' '3808';\n");
+		grammarBuilder.append("KW3809 : 'KW' '3809';\n");
+		grammarBuilder.append("KW3810 : 'KW' '3810';\n");
+		grammarBuilder.append("KW3811 : 'KW' '3811';\n");
+		grammarBuilder.append("KW3812 : 'KW' '3812';\n");
+		grammarBuilder.append("KW3813 : 'KW' '3813';\n");
+		grammarBuilder.append("KW3814 : 'KW' '3814';\n");
+		grammarBuilder.append("KW3815 : 'KW' '3815';\n");
+		grammarBuilder.append("KW3816 : 'KW' '3816';\n");
+		grammarBuilder.append("KW3817 : 'KW' '3817';\n");
+		grammarBuilder.append("KW3818 : 'KW' '3818';\n");
+		grammarBuilder.append("KW3819 : 'KW' '3819';\n");
+		grammarBuilder.append("KW3820 : 'KW' '3820';\n");
+		grammarBuilder.append("KW3821 : 'KW' '3821';\n");
+		grammarBuilder.append("KW3822 : 'KW' '3822';\n");
+		grammarBuilder.append("KW3823 : 'KW' '3823';\n");
+		grammarBuilder.append("KW3824 : 'KW' '3824';\n");
+		grammarBuilder.append("KW3825 : 'KW' '3825';\n");
+		grammarBuilder.append("KW3826 : 'KW' '3826';\n");
+		grammarBuilder.append("KW3827 : 'KW' '3827';\n");
+		grammarBuilder.append("KW3828 : 'KW' '3828';\n");
+		grammarBuilder.append("KW3829 : 'KW' '3829';\n");
+		grammarBuilder.append("KW3830 : 'KW' '3830';\n");
+		grammarBuilder.append("KW3831 : 'KW' '3831';\n");
+		grammarBuilder.append("KW3832 : 'KW' '3832';\n");
+		grammarBuilder.append("KW3833 : 'KW' '3833';\n");
+		grammarBuilder.append("KW3834 : 'KW' '3834';\n");
+		grammarBuilder.append("KW3835 : 'KW' '3835';\n");
+		grammarBuilder.append("KW3836 : 'KW' '3836';\n");
+		grammarBuilder.append("KW3837 : 'KW' '3837';\n");
+		grammarBuilder.append("KW3838 : 'KW' '3838';\n");
+		grammarBuilder.append("KW3839 : 'KW' '3839';\n");
+		grammarBuilder.append("KW3840 : 'KW' '3840';\n");
+		grammarBuilder.append("KW3841 : 'KW' '3841';\n");
+		grammarBuilder.append("KW3842 : 'KW' '3842';\n");
+		grammarBuilder.append("KW3843 : 'KW' '3843';\n");
+		grammarBuilder.append("KW3844 : 'KW' '3844';\n");
+		grammarBuilder.append("KW3845 : 'KW' '3845';\n");
+		grammarBuilder.append("KW3846 : 'KW' '3846';\n");
+		grammarBuilder.append("KW3847 : 'KW' '3847';\n");
+		grammarBuilder.append("KW3848 : 'KW' '3848';\n");
+		grammarBuilder.append("KW3849 : 'KW' '3849';\n");
+		grammarBuilder.append("KW3850 : 'KW' '3850';\n");
+		grammarBuilder.append("KW3851 : 'KW' '3851';\n");
+		grammarBuilder.append("KW3852 : 'KW' '3852';\n");
+		grammarBuilder.append("KW3853 : 'KW' '3853';\n");
+		grammarBuilder.append("KW3854 : 'KW' '3854';\n");
+		grammarBuilder.append("KW3855 : 'KW' '3855';\n");
+		grammarBuilder.append("KW3856 : 'KW' '3856';\n");
+		grammarBuilder.append("KW3857 : 'KW' '3857';\n");
+		grammarBuilder.append("KW3858 : 'KW' '3858';\n");
+		grammarBuilder.append("KW3859 : 'KW' '3859';\n");
+		grammarBuilder.append("KW3860 : 'KW' '3860';\n");
+		grammarBuilder.append("KW3861 : 'KW' '3861';\n");
+		grammarBuilder.append("KW3862 : 'KW' '3862';\n");
+		grammarBuilder.append("KW3863 : 'KW' '3863';\n");
+		grammarBuilder.append("KW3864 : 'KW' '3864';\n");
+		grammarBuilder.append("KW3865 : 'KW' '3865';\n");
+		grammarBuilder.append("KW3866 : 'KW' '3866';\n");
+		grammarBuilder.append("KW3867 : 'KW' '3867';\n");
+		grammarBuilder.append("KW3868 : 'KW' '3868';\n");
+		grammarBuilder.append("KW3869 : 'KW' '3869';\n");
+		grammarBuilder.append("KW3870 : 'KW' '3870';\n");
+		grammarBuilder.append("KW3871 : 'KW' '3871';\n");
+		grammarBuilder.append("KW3872 : 'KW' '3872';\n");
+		grammarBuilder.append("KW3873 : 'KW' '3873';\n");
+		grammarBuilder.append("KW3874 : 'KW' '3874';\n");
+		grammarBuilder.append("KW3875 : 'KW' '3875';\n");
+		grammarBuilder.append("KW3876 : 'KW' '3876';\n");
+		grammarBuilder.append("KW3877 : 'KW' '3877';\n");
+		grammarBuilder.append("KW3878 : 'KW' '3878';\n");
+		grammarBuilder.append("KW3879 : 'KW' '3879';\n");
+		grammarBuilder.append("KW3880 : 'KW' '3880';\n");
+		grammarBuilder.append("KW3881 : 'KW' '3881';\n");
+		grammarBuilder.append("KW3882 : 'KW' '3882';\n");
+		grammarBuilder.append("KW3883 : 'KW' '3883';\n");
+		grammarBuilder.append("KW3884 : 'KW' '3884';\n");
+		grammarBuilder.append("KW3885 : 'KW' '3885';\n");
+		grammarBuilder.append("KW3886 : 'KW' '3886';\n");
+		grammarBuilder.append("KW3887 : 'KW' '3887';\n");
+		grammarBuilder.append("KW3888 : 'KW' '3888';\n");
+		grammarBuilder.append("KW3889 : 'KW' '3889';\n");
+		grammarBuilder.append("KW3890 : 'KW' '3890';\n");
+		grammarBuilder.append("KW3891 : 'KW' '3891';\n");
+		grammarBuilder.append("KW3892 : 'KW' '3892';\n");
+		grammarBuilder.append("KW3893 : 'KW' '3893';\n");
+		grammarBuilder.append("KW3894 : 'KW' '3894';\n");
+		grammarBuilder.append("KW3895 : 'KW' '3895';\n");
+		grammarBuilder.append("KW3896 : 'KW' '3896';\n");
+		grammarBuilder.append("KW3897 : 'KW' '3897';\n");
+		grammarBuilder.append("KW3898 : 'KW' '3898';\n");
+		grammarBuilder.append("KW3899 : 'KW' '3899';\n");
+		grammarBuilder.append("KW3900 : 'KW' '3900';\n");
+		grammarBuilder.append("KW3901 : 'KW' '3901';\n");
+		grammarBuilder.append("KW3902 : 'KW' '3902';\n");
+		grammarBuilder.append("KW3903 : 'KW' '3903';\n");
+		grammarBuilder.append("KW3904 : 'KW' '3904';\n");
+		grammarBuilder.append("KW3905 : 'KW' '3905';\n");
+		grammarBuilder.append("KW3906 : 'KW' '3906';\n");
+		grammarBuilder.append("KW3907 : 'KW' '3907';\n");
+		grammarBuilder.append("KW3908 : 'KW' '3908';\n");
+		grammarBuilder.append("KW3909 : 'KW' '3909';\n");
+		grammarBuilder.append("KW3910 : 'KW' '3910';\n");
+		grammarBuilder.append("KW3911 : 'KW' '3911';\n");
+		grammarBuilder.append("KW3912 : 'KW' '3912';\n");
+		grammarBuilder.append("KW3913 : 'KW' '3913';\n");
+		grammarBuilder.append("KW3914 : 'KW' '3914';\n");
+		grammarBuilder.append("KW3915 : 'KW' '3915';\n");
+		grammarBuilder.append("KW3916 : 'KW' '3916';\n");
+		grammarBuilder.append("KW3917 : 'KW' '3917';\n");
+		grammarBuilder.append("KW3918 : 'KW' '3918';\n");
+		grammarBuilder.append("KW3919 : 'KW' '3919';\n");
+		grammarBuilder.append("KW3920 : 'KW' '3920';\n");
+		grammarBuilder.append("KW3921 : 'KW' '3921';\n");
+		grammarBuilder.append("KW3922 : 'KW' '3922';\n");
+		grammarBuilder.append("KW3923 : 'KW' '3923';\n");
+		grammarBuilder.append("KW3924 : 'KW' '3924';\n");
+		grammarBuilder.append("KW3925 : 'KW' '3925';\n");
+		grammarBuilder.append("KW3926 : 'KW' '3926';\n");
+		grammarBuilder.append("KW3927 : 'KW' '3927';\n");
+		grammarBuilder.append("KW3928 : 'KW' '3928';\n");
+		grammarBuilder.append("KW3929 : 'KW' '3929';\n");
+		grammarBuilder.append("KW3930 : 'KW' '3930';\n");
+		grammarBuilder.append("KW3931 : 'KW' '3931';\n");
+		grammarBuilder.append("KW3932 : 'KW' '3932';\n");
+		grammarBuilder.append("KW3933 : 'KW' '3933';\n");
+		grammarBuilder.append("KW3934 : 'KW' '3934';\n");
+		grammarBuilder.append("KW3935 : 'KW' '3935';\n");
+		grammarBuilder.append("KW3936 : 'KW' '3936';\n");
+		grammarBuilder.append("KW3937 : 'KW' '3937';\n");
+		grammarBuilder.append("KW3938 : 'KW' '3938';\n");
+		grammarBuilder.append("KW3939 : 'KW' '3939';\n");
+		grammarBuilder.append("KW3940 : 'KW' '3940';\n");
+		grammarBuilder.append("KW3941 : 'KW' '3941';\n");
+		grammarBuilder.append("KW3942 : 'KW' '3942';\n");
+		grammarBuilder.append("KW3943 : 'KW' '3943';\n");
+		grammarBuilder.append("KW3944 : 'KW' '3944';\n");
+		grammarBuilder.append("KW3945 : 'KW' '3945';\n");
+		grammarBuilder.append("KW3946 : 'KW' '3946';\n");
+		grammarBuilder.append("KW3947 : 'KW' '3947';\n");
+		grammarBuilder.append("KW3948 : 'KW' '3948';\n");
+		grammarBuilder.append("KW3949 : 'KW' '3949';\n");
+		grammarBuilder.append("KW3950 : 'KW' '3950';\n");
+		grammarBuilder.append("KW3951 : 'KW' '3951';\n");
+		grammarBuilder.append("KW3952 : 'KW' '3952';\n");
+		grammarBuilder.append("KW3953 : 'KW' '3953';\n");
+		grammarBuilder.append("KW3954 : 'KW' '3954';\n");
+		grammarBuilder.append("KW3955 : 'KW' '3955';\n");
+		grammarBuilder.append("KW3956 : 'KW' '3956';\n");
+		grammarBuilder.append("KW3957 : 'KW' '3957';\n");
+		grammarBuilder.append("KW3958 : 'KW' '3958';\n");
+		grammarBuilder.append("KW3959 : 'KW' '3959';\n");
+		grammarBuilder.append("KW3960 : 'KW' '3960';\n");
+		grammarBuilder.append("KW3961 : 'KW' '3961';\n");
+		grammarBuilder.append("KW3962 : 'KW' '3962';\n");
+		grammarBuilder.append("KW3963 : 'KW' '3963';\n");
+		grammarBuilder.append("KW3964 : 'KW' '3964';\n");
+		grammarBuilder.append("KW3965 : 'KW' '3965';\n");
+		grammarBuilder.append("KW3966 : 'KW' '3966';\n");
+		grammarBuilder.append("KW3967 : 'KW' '3967';\n");
+		grammarBuilder.append("KW3968 : 'KW' '3968';\n");
+		grammarBuilder.append("KW3969 : 'KW' '3969';\n");
+		grammarBuilder.append("KW3970 : 'KW' '3970';\n");
+		grammarBuilder.append("KW3971 : 'KW' '3971';\n");
+		grammarBuilder.append("KW3972 : 'KW' '3972';\n");
+		grammarBuilder.append("KW3973 : 'KW' '3973';\n");
+		grammarBuilder.append("KW3974 : 'KW' '3974';\n");
+		grammarBuilder.append("KW3975 : 'KW' '3975';\n");
+		grammarBuilder.append("KW3976 : 'KW' '3976';\n");
+		grammarBuilder.append("KW3977 : 'KW' '3977';\n");
+		grammarBuilder.append("KW3978 : 'KW' '3978';\n");
+		grammarBuilder.append("KW3979 : 'KW' '3979';\n");
+		grammarBuilder.append("KW3980 : 'KW' '3980';\n");
+		grammarBuilder.append("KW3981 : 'KW' '3981';\n");
+		grammarBuilder.append("KW3982 : 'KW' '3982';\n");
+		grammarBuilder.append("KW3983 : 'KW' '3983';\n");
+		grammarBuilder.append("KW3984 : 'KW' '3984';\n");
+		grammarBuilder.append("KW3985 : 'KW' '3985';\n");
+		grammarBuilder.append("KW3986 : 'KW' '3986';\n");
+		grammarBuilder.append("KW3987 : 'KW' '3987';\n");
+		grammarBuilder.append("KW3988 : 'KW' '3988';\n");
+		grammarBuilder.append("KW3989 : 'KW' '3989';\n");
+		grammarBuilder.append("KW3990 : 'KW' '3990';\n");
+		grammarBuilder.append("KW3991 : 'KW' '3991';\n");
+		grammarBuilder.append("KW3992 : 'KW' '3992';\n");
+		grammarBuilder.append("KW3993 : 'KW' '3993';\n");
+		grammarBuilder.append("KW3994 : 'KW' '3994';\n");
+		grammarBuilder.append("KW3995 : 'KW' '3995';\n");
+		grammarBuilder.append("KW3996 : 'KW' '3996';\n");
+		grammarBuilder.append("KW3997 : 'KW' '3997';\n");
+		grammarBuilder.append("KW3998 : 'KW' '3998';\n");
+		grammarBuilder.append("KW3999 : 'KW' '3999';");
+		String grammar = grammarBuilder.toString();
+
+		String input ="KW400";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:4='KW400',<402>,1:0]\n" +
+			"[@1,5:4='<EOF>',<-1>,1:5]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNonGreedyClosure() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(61);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("CMT : '//' .*? '\\n' CMT*?;\n");
+		grammarBuilder.append("WS : (' '|'\\t')+;");
+		String grammar = grammarBuilder.toString();
+
+		String input =
+			"//blah\n" +
+			"//blah\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:6='//blah\\n',<1>,1:0]\n" +
+			"[@1,7:13='//blah\\n',<1>,2:0]\n" +
+			"[@2,14:13='<EOF>',<-1>,3:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNonGreedyConfigs() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(110);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("I : .*? ('a' | 'ab') {print(self.text)} ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;\n");
+		grammarBuilder.append("J : . {print(self.text)};");
+		String grammar = grammarBuilder.toString();
+
+		String input ="ab";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"a\n" +
+			"b\n" +
+			"[@0,0:0='a',<1>,1:0]\n" +
+			"[@1,1:1='b',<3>,1:1]\n" +
+			"[@2,2:1='<EOF>',<-1>,1:2]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNonGreedyOptional() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(61);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("CMT : '//' .*? '\\n' CMT??;\n");
+		grammarBuilder.append("WS : (' '|'\\t')+;");
+		String grammar = grammarBuilder.toString();
+
+		String input =
+			"//blah\n" +
+			"//blah\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:6='//blah\\n',<1>,1:0]\n" +
+			"[@1,7:13='//blah\\n',<1>,2:0]\n" +
+			"[@2,14:13='<EOF>',<-1>,3:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNonGreedyPositiveClosure() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(59);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("CMT : ('//' .*? '\\n')+?;\n");
+		grammarBuilder.append("WS : (' '|'\\t')+;");
+		String grammar = grammarBuilder.toString();
+
+		String input =
+			"//blah\n" +
+			"//blah\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:6='//blah\\n',<1>,1:0]\n" +
+			"[@1,7:13='//blah\\n',<1>,2:0]\n" +
+			"[@2,14:13='<EOF>',<-1>,3:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNonGreedyTermination1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(47);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("STRING : '\"' ('\"\"' | .)*? '\"';");
+		String grammar = grammarBuilder.toString();
+
+		String input ="\"hi\"\"mom\"";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:3='\"hi\"',<1>,1:0]\n" +
+			"[@1,4:8='\"mom\"',<1>,1:4]\n" +
+			"[@2,9:8='<EOF>',<-1>,1:9]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNonGreedyTermination2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(47);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("STRING : '\"' ('\"\"' | .)+? '\"';");
+		String grammar = grammarBuilder.toString();
+
+		String input ="\"\"\"mom\"";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:6='\"\"\"mom\"',<1>,1:0]\n" +
+			"[@1,7:6='<EOF>',<-1>,1:7]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testParentheses() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(166);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("START_BLOCK: '-.-.-';\n");
+		grammarBuilder.append("ID : (LETTER SEPARATOR) (LETTER SEPARATOR)+;\n");
+		grammarBuilder.append("fragment LETTER: L_A|L_K;\n");
+		grammarBuilder.append("fragment L_A: '.-';\n");
+		grammarBuilder.append("fragment L_K: '-.-';\n");
+		grammarBuilder.append("SEPARATOR: '!';");
+		String grammar = grammarBuilder.toString();
+
+		String input ="-.-.-!";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:4='-.-.-',<1>,1:0]\n" +
+			"[@1,5:5='!',<3>,1:5]\n" +
+			"[@2,6:5='<EOF>',<-1>,1:6]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPositionAdjustingLexer() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(1839);
+		grammarBuilder.append("lexer grammar PositionAdjustingLexer;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("@members {\n");
+		grammarBuilder.append("def resetAcceptPosition(self, index, line, column):\n");
+		grammarBuilder.append("	self._input.seek(index)\n");
+		grammarBuilder.append("	self.line = line\n");
+		grammarBuilder.append("	self.column = column\n");
+		grammarBuilder.append("	self._interp.consume(self._input)\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("def nextToken(self):\n");
+		grammarBuilder.append("	if self._interp.__dict__.get(\"resetAcceptPosition\", None) is None:\n");
+		grammarBuilder.append("		self._interp.__dict__[\"resetAcceptPosition\"] = self.resetAcceptPosition\n");
+		grammarBuilder.append("	return super(type(self),self).nextToken()\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("def emit(self):\n");
+		grammarBuilder.append("	if self._type==PositionAdjustingLexer.TOKENS:\n");
+		grammarBuilder.append("		self.handleAcceptPositionForKeyword(\"tokens\")\n");
+		grammarBuilder.append("	elif self._type==PositionAdjustingLexer.LABEL:\n");
+		grammarBuilder.append("		self.handleAcceptPositionForIdentifier()\n");
+		grammarBuilder.append("	return super(type(self),self).emit()\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("def handleAcceptPositionForIdentifier(self):\n");
+		grammarBuilder.append("	tokenText = self.text\n");
+		grammarBuilder.append("	identifierLength = 0\n");
+		grammarBuilder.append("	while identifierLength < len(tokenText) and self.isIdentifierChar(tokenText[identifierLength]):\n");
+		grammarBuilder.append("		identifierLength += 1\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("	if self._input.index > self._tokenStartCharIndex + identifierLength:\n");
+		grammarBuilder.append("		offset = identifierLength - 1\n");
+		grammarBuilder.append("		self._interp.resetAcceptPosition(self._tokenStartCharIndex + offset,\n");
+		grammarBuilder.append("				self._tokenStartLine, self._tokenStartColumn + offset)\n");
+		grammarBuilder.append("		return True\n");
+		grammarBuilder.append("	else:\n");
+		grammarBuilder.append("		return False\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("def handleAcceptPositionForKeyword(self, keyword):\n");
+		grammarBuilder.append("	if self._input.index > self._tokenStartCharIndex + len(keyword):\n");
+		grammarBuilder.append("		offset = len(keyword) - 1\n");
+		grammarBuilder.append("		self._interp.resetAcceptPosition(self._tokenStartCharIndex + offset,\n");
+		grammarBuilder.append("			self._tokenStartLine, self._tokenStartColumn + offset)\n");
+		grammarBuilder.append("		return True\n");
+		grammarBuilder.append("	else:\n");
+		grammarBuilder.append("		return False\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("@staticmethod\n");
+		grammarBuilder.append("def isIdentifierChar(c):\n");
+		grammarBuilder.append("	return c.isalnum() or c == '_'\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("ASSIGN : '=' ;\n");
+		grammarBuilder.append("PLUS_ASSIGN : '+=' ;\n");
+		grammarBuilder.append("LCURLY:	'{';\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("// 'tokens' followed by '{'\n");
+		grammarBuilder.append("TOKENS : 'tokens' IGNORED '{';\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("// IDENTIFIER followed by '+=' or '='\n");
+		grammarBuilder.append("LABEL\n");
+		grammarBuilder.append("	:	IDENTIFIER IGNORED '+'? '='\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("IDENTIFIER\n");
+		grammarBuilder.append("	:	[a-zA-Z_] [a-zA-Z0-9_]*\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("fragment\n");
+		grammarBuilder.append("IGNORED\n");
+		grammarBuilder.append("	:	[ \\t\\r\\n]*\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("NEWLINE\n");
+		grammarBuilder.append("	:	[\\r\\n]+ -> skip\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("WS\n");
+		grammarBuilder.append("	:	[ \\t]+ -> skip\n");
+		grammarBuilder.append("	;");
+		String grammar = grammarBuilder.toString();
+
+		String input =
+			"tokens\n" +
+			"tokens {\n" +
+			"notLabel\n" +
+			"label1 =\n" +
+			"label2 +=\n" +
+			"notLabel\n";
+		String found = execLexer("PositionAdjustingLexer.g4", grammar, "PositionAdjustingLexer", input, false);
+		assertEquals(
+			"[@0,0:5='tokens',<6>,1:0]\n" +
+			"[@1,7:12='tokens',<4>,2:0]\n" +
+			"[@2,14:14='{',<3>,2:7]\n" +
+			"[@3,16:23='notLabel',<6>,3:0]\n" +
+			"[@4,25:30='label1',<5>,4:0]\n" +
+			"[@5,32:32='=',<1>,4:7]\n" +
+			"[@6,34:39='label2',<5>,5:0]\n" +
+			"[@7,41:42='+=',<2>,5:7]\n" +
+			"[@8,44:51='notLabel',<6>,6:0]\n" +
+			"[@9,53:52='<EOF>',<-1>,7:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testQuoteTranslation() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(57);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("QUOTE : '\"' ; // make sure this compiles");
+		String grammar = grammarBuilder.toString();
+
+		String input ="\"";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:0='\"',<1>,1:0]\n" +
+			"[@1,1:0='<EOF>',<-1>,1:1]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testRecursiveLexerRuleRefWithWildcardPlus_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(64);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("CMT : '/*' (CMT | .)+? '*/' ;\n");
+		grammarBuilder.append("WS : (' '|'\\n')+;");
+		String grammar = grammarBuilder.toString();
+
+		String input =
+			"/* ick */\n" +
+			"/* /* */\n" +
+			"/* /*nested*/ */\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:8='/* ick */',<1>,1:0]\n" +
+			"[@1,9:9='\\n',<2>,1:9]\n" +
+			"[@2,10:34='/* /* */\\n/* /*nested*/ */',<1>,2:0]\n" +
+			"[@3,35:35='\\n',<2>,3:16]\n" +
+			"[@4,36:35='<EOF>',<-1>,4:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testRecursiveLexerRuleRefWithWildcardPlus_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(64);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("CMT : '/*' (CMT | .)+? '*/' ;\n");
+		grammarBuilder.append("WS : (' '|'\\n')+;");
+		String grammar = grammarBuilder.toString();
+
+		String input =
+			"/* ick */x\n" +
+			"/* /* */x\n" +
+			"/* /*nested*/ */x\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:8='/* ick */',<1>,1:0]\n" +
+			"[@1,10:10='\\n',<2>,1:10]\n" +
+			"[@2,11:36='/* /* */x\\n/* /*nested*/ */',<1>,2:0]\n" +
+			"[@3,38:38='\\n',<2>,3:17]\n" +
+			"[@4,39:38='<EOF>',<-1>,4:0]\n", found);
+
+		assertEquals(
+			"line 1:9 token recognition error at: 'x'\n" +
+			"line 3:16 token recognition error at: 'x'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testRecursiveLexerRuleRefWithWildcardStar_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(64);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("CMT : '/*' (CMT | .)*? '*/' ;\n");
+		grammarBuilder.append("WS : (' '|'\\n')+;");
+		String grammar = grammarBuilder.toString();
+
+		String input =
+			"/* ick */\n" +
+			"/* /* */\n" +
+			"/* /*nested*/ */\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:8='/* ick */',<1>,1:0]\n" +
+			"[@1,9:9='\\n',<2>,1:9]\n" +
+			"[@2,10:34='/* /* */\\n/* /*nested*/ */',<1>,2:0]\n" +
+			"[@3,35:35='\\n',<2>,3:16]\n" +
+			"[@4,36:35='<EOF>',<-1>,4:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testRecursiveLexerRuleRefWithWildcardStar_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(64);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("CMT : '/*' (CMT | .)*? '*/' ;\n");
+		grammarBuilder.append("WS : (' '|'\\n')+;");
+		String grammar = grammarBuilder.toString();
+
+		String input =
+			"/* ick */x\n" +
+			"/* /* */x\n" +
+			"/* /*nested*/ */x\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:8='/* ick */',<1>,1:0]\n" +
+			"[@1,10:10='\\n',<2>,1:10]\n" +
+			"[@2,11:36='/* /* */x\\n/* /*nested*/ */',<1>,2:0]\n" +
+			"[@3,38:38='\\n',<2>,3:17]\n" +
+			"[@4,39:38='<EOF>',<-1>,4:0]\n", found);
+
+		assertEquals(
+			"line 1:9 token recognition error at: 'x'\n" +
+			"line 3:16 token recognition error at: 'x'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testRefToRuleDoesNotSetTokenNorEmitAnother() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(70);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : '-' I ;\n");
+		grammarBuilder.append("I : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="34 -21 3";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:1='34',<2>,1:0]\n" +
+			"[@1,3:5='-21',<1>,1:3]\n" +
+			"[@2,7:7='3',<2>,1:7]\n" +
+			"[@3,8:7='<EOF>',<-1>,1:8]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSlashes() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(95);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("Backslash : '\\\\';\n");
+		grammarBuilder.append("Slash : '/';\n");
+		grammarBuilder.append("Vee : '\\\\/';\n");
+		grammarBuilder.append("Wedge : '/\\\\';\n");
+		grammarBuilder.append("WS : [ \\t] -> skip;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="\\ / \\/ /\\";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:0='\\',<1>,1:0]\n" +
+			"[@1,2:2='/',<2>,1:2]\n" +
+			"[@2,4:5='\\/',<3>,1:4]\n" +
+			"[@3,7:8='/\\',<4>,1:7]\n" +
+			"[@4,9:8='<EOF>',<-1>,1:9]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testZeroLengthToken() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(215);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("BeginString\n");
+		grammarBuilder.append("	:	'\\'' -> more, pushMode(StringMode)\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("mode StringMode;\n");
+		grammarBuilder.append("	StringMode_X : 'x' -> more;\n");
+		grammarBuilder.append("	StringMode_Done : -> more, mode(EndStringMode);\n");
+		grammarBuilder.append("mode EndStringMode;	\n");
+		grammarBuilder.append("	EndString : '\\'' -> popMode;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="'xxx'";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:4=''xxx'',<1>,1:0]\n" +
+			"[@1,5:4='<EOF>',<-1>,1:5]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+
+}
\ No newline at end of file
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/python2/TestListeners.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/python2/TestListeners.java
new file mode 100644
index 000000000..8e7a7f380
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/python2/TestListeners.java
@@ -0,0 +1,391 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.python2;
+
+import org.junit.Ignore;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+@SuppressWarnings("unused")
+public class TestListeners extends BasePython2Test {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testBasic() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(511);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@parser::header {\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("@parser::members {\n");
+		grammarBuilder.append("if __name__ is not None and \".\" in __name__:\n");
+		grammarBuilder.append("    from .TListener import TListener\n");
+		grammarBuilder.append("else:\n");
+		grammarBuilder.append("    from TListener import TListener\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("class LeafListener(TListener):\n");
+		grammarBuilder.append("    def visitTerminal(self, node):\n");
+		grammarBuilder.append("        print(node.symbol.text)\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("print($ctx.r.toStringTree(recog=self))\n");
+		grammarBuilder.append("walker = ParseTreeWalker()\n");
+		grammarBuilder.append("walker.walk(TParser.LeafListener(), $ctx.r)\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : INT INT\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("MULT: '*' ;\n");
+		grammarBuilder.append("ADD : '+' ;\n");
+		grammarBuilder.append("INT : [0-9]+ ;\n");
+		grammarBuilder.append("ID  : [a-z]+ ;\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="1 2";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals(
+			"(a 1 2)\n" +
+			"1\n" +
+			"2\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLR() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(672);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@parser::header {\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("@parser::members {\n");
+		grammarBuilder.append("if __name__ is not None and \".\" in __name__:\n");
+		grammarBuilder.append("    from .TListener import TListener\n");
+		grammarBuilder.append("else:\n");
+		grammarBuilder.append("    from TListener import TListener\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("class LeafListener(TListener):\n");
+		grammarBuilder.append("    def exitE(self, ctx):\n");
+		grammarBuilder.append("        if ctx.getChildCount()==3:\n");
+		grammarBuilder.append("            print(ctx.e(0).start.text + ' ' + ctx.e(1).start.text + ' ' + ctx.e()[0].start.text)\n");
+		grammarBuilder.append("        else:\n");
+		grammarBuilder.append("            print(ctx.INT().symbol.text)\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("print($ctx.r.toStringTree(recog=self))\n");
+		grammarBuilder.append("walker = ParseTreeWalker()\n");
+		grammarBuilder.append("walker.walk(TParser.LeafListener(), $ctx.r)\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("	: r=e ;\n");
+		grammarBuilder.append("e : e op='*' e\n");
+		grammarBuilder.append("	| e op='+' e\n");
+		grammarBuilder.append("	| INT\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("MULT: '*' ;\n");
+		grammarBuilder.append("ADD : '+' ;\n");
+		grammarBuilder.append("INT : [0-9]+ ;\n");
+		grammarBuilder.append("ID  : [a-z]+ ;\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="1+2*3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals(
+			"(e (e 1) + (e (e 2) * (e 3)))\n" +
+			"1\n" +
+			"2\n" +
+			"3\n" +
+			"2 3 2\n" +
+			"1 2 1\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLRWithLabels() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(652);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@parser::header {\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("@parser::members {\n");
+		grammarBuilder.append("if __name__ is not None and \".\" in __name__:\n");
+		grammarBuilder.append("    from .TListener import TListener\n");
+		grammarBuilder.append("else:\n");
+		grammarBuilder.append("    from TListener import TListener\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("class LeafListener(TListener):\n");
+		grammarBuilder.append("    def exitCall(self, ctx):\n");
+		grammarBuilder.append("        print(ctx.e().start.text + ' ' + str(ctx.eList()))\n");
+		grammarBuilder.append("    def exitInt(self, ctx):\n");
+		grammarBuilder.append("        print(ctx.INT().symbol.text)\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("print($ctx.r.toStringTree(recog=self))\n");
+		grammarBuilder.append("walker = ParseTreeWalker()\n");
+		grammarBuilder.append("walker.walk(TParser.LeafListener(), $ctx.r)\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=e ;\n");
+		grammarBuilder.append("e : e '(' eList ')' # Call\n");
+		grammarBuilder.append("  | INT             # Int\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("eList : e (',' e)* ;\n");
+		grammarBuilder.append("MULT: '*' ;\n");
+		grammarBuilder.append("ADD : '+' ;\n");
+		grammarBuilder.append("INT : [0-9]+ ;\n");
+		grammarBuilder.append("ID  : [a-z]+ ;\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="1(2,3)";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals(
+			"(e (e 1) ( (eList (e 2) , (e 3)) ))\n" +
+			"1\n" +
+			"2\n" +
+			"3\n" +
+			"1 [13 6]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testRuleGetters_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(697);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@parser::header {\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("@parser::members {\n");
+		grammarBuilder.append("if __name__ is not None and \".\" in __name__:\n");
+		grammarBuilder.append("    from .TListener import TListener\n");
+		grammarBuilder.append("else:\n");
+		grammarBuilder.append("    from TListener import TListener\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("class LeafListener(TListener):\n");
+		grammarBuilder.append("    def exitA(self, ctx):\n");
+		grammarBuilder.append("        if ctx.getChildCount()==2:\n");
+		grammarBuilder.append("            print(ctx.b(0).start.text + ' ' + ctx.b(1).start.text + ' ' + ctx.b()[0].start.text)\n");
+		grammarBuilder.append("        else:\n");
+		grammarBuilder.append("            print(ctx.b(0).start.text)\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("print($ctx.r.toStringTree(recog=self))\n");
+		grammarBuilder.append("walker = ParseTreeWalker()\n");
+		grammarBuilder.append("walker.walk(TParser.LeafListener(), $ctx.r)\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : b b		// forces list\n");
+		grammarBuilder.append("  | b		// a list still\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("b : ID | INT;\n");
+		grammarBuilder.append("MULT: '*' ;\n");
+		grammarBuilder.append("ADD : '+' ;\n");
+		grammarBuilder.append("INT : [0-9]+ ;\n");
+		grammarBuilder.append("ID  : [a-z]+ ;\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="1 2";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals(
+			"(a (b 1) (b 2))\n" +
+			"1 2 1\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testRuleGetters_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(697);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@parser::header {\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("@parser::members {\n");
+		grammarBuilder.append("if __name__ is not None and \".\" in __name__:\n");
+		grammarBuilder.append("    from .TListener import TListener\n");
+		grammarBuilder.append("else:\n");
+		grammarBuilder.append("    from TListener import TListener\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("class LeafListener(TListener):\n");
+		grammarBuilder.append("    def exitA(self, ctx):\n");
+		grammarBuilder.append("        if ctx.getChildCount()==2:\n");
+		grammarBuilder.append("            print(ctx.b(0).start.text + ' ' + ctx.b(1).start.text + ' ' + ctx.b()[0].start.text)\n");
+		grammarBuilder.append("        else:\n");
+		grammarBuilder.append("            print(ctx.b(0).start.text)\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("print($ctx.r.toStringTree(recog=self))\n");
+		grammarBuilder.append("walker = ParseTreeWalker()\n");
+		grammarBuilder.append("walker.walk(TParser.LeafListener(), $ctx.r)\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : b b		// forces list\n");
+		grammarBuilder.append("  | b		// a list still\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("b : ID | INT;\n");
+		grammarBuilder.append("MULT: '*' ;\n");
+		grammarBuilder.append("ADD : '+' ;\n");
+		grammarBuilder.append("INT : [0-9]+ ;\n");
+		grammarBuilder.append("ID  : [a-z]+ ;\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="abc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals(
+			"(a (b abc))\n" +
+			"abc\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTokenGetters_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(660);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@parser::header {\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("@parser::members {\n");
+		grammarBuilder.append("if __name__ is not None and \".\" in __name__:\n");
+		grammarBuilder.append("    from .TListener import TListener\n");
+		grammarBuilder.append("else:\n");
+		grammarBuilder.append("    from TListener import TListener\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("class LeafListener(TListener):\n");
+		grammarBuilder.append("    def exitA(self, ctx):\n");
+		grammarBuilder.append("        if ctx.getChildCount()==2:\n");
+		grammarBuilder.append("            print(ctx.INT(0).symbol.text + ' ' + ctx.INT(1).symbol.text + ' ' + str_list(ctx.INT()))\n");
+		grammarBuilder.append("        else:\n");
+		grammarBuilder.append("            print(str(ctx.ID().symbol))\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("print($ctx.r.toStringTree(recog=self))\n");
+		grammarBuilder.append("walker = ParseTreeWalker()\n");
+		grammarBuilder.append("walker.walk(TParser.LeafListener(), $ctx.r)\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : INT INT\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("MULT: '*' ;\n");
+		grammarBuilder.append("ADD : '+' ;\n");
+		grammarBuilder.append("INT : [0-9]+ ;\n");
+		grammarBuilder.append("ID  : [a-z]+ ;\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="1 2";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals(
+			"(a 1 2)\n" +
+			"1 2 [1, 2]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTokenGetters_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(660);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@parser::header {\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("@parser::members {\n");
+		grammarBuilder.append("if __name__ is not None and \".\" in __name__:\n");
+		grammarBuilder.append("    from .TListener import TListener\n");
+		grammarBuilder.append("else:\n");
+		grammarBuilder.append("    from TListener import TListener\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("class LeafListener(TListener):\n");
+		grammarBuilder.append("    def exitA(self, ctx):\n");
+		grammarBuilder.append("        if ctx.getChildCount()==2:\n");
+		grammarBuilder.append("            print(ctx.INT(0).symbol.text + ' ' + ctx.INT(1).symbol.text + ' ' + str_list(ctx.INT()))\n");
+		grammarBuilder.append("        else:\n");
+		grammarBuilder.append("            print(str(ctx.ID().symbol))\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("print($ctx.r.toStringTree(recog=self))\n");
+		grammarBuilder.append("walker = ParseTreeWalker()\n");
+		grammarBuilder.append("walker.walk(TParser.LeafListener(), $ctx.r)\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : INT INT\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("MULT: '*' ;\n");
+		grammarBuilder.append("ADD : '+' ;\n");
+		grammarBuilder.append("INT : [0-9]+ ;\n");
+		grammarBuilder.append("ID  : [a-z]+ ;\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="abc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals(
+			"(a abc)\n" +
+			"[@0,0:2='abc',<4>,1:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+
+}
\ No newline at end of file
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/python2/TestParseTrees.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/python2/TestParseTrees.java
new file mode 100644
index 000000000..da8e26f07
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/python2/TestParseTrees.java
@@ -0,0 +1,301 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.python2;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
+@SuppressWarnings("unused")
+public class TestParseTrees extends BasePython2Test {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void test2AltLoop() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(136);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {\n");
+		grammarBuilder.append("self._buildParseTrees = True\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("print($r.ctx.toStringTree(recog=self))\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : ('x' | 'y')* 'z'\n");
+		grammarBuilder.append("  ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="xyyxyxz";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(a x y y x y x z)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void test2Alts() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(129);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {\n");
+		grammarBuilder.append("self._buildParseTrees = True\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("print($r.ctx.toStringTree(recog=self))\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : 'x' | 'y'\n");
+		grammarBuilder.append("  ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="y";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(a y)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAltNum() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(562);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("options { contextSuperClass=MyRuleNode; }\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("@parser::members {\n");
+		grammarBuilder.append("class MyRuleNode(ParserRuleContext):\n");
+		grammarBuilder.append("    def __init__(self, parent = None, invokingStateNumber = None ):\n");
+		grammarBuilder.append("        super(TParser.MyRuleNode, self).__init__(parent, invokingStateNumber)\n");
+		grammarBuilder.append("        self.altNum = 0;\n");
+		grammarBuilder.append("    def getAltNumber(self):\n");
+		grammarBuilder.append("        return self.altNum\n");
+		grammarBuilder.append("    def setAltNumber(self, altNum):\n");
+		grammarBuilder.append("        self.altNum = altNum\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {\n");
+		grammarBuilder.append("self._buildParseTrees = True\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("print($r.ctx.toStringTree(recog=self))\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("a : 'f'\n");
+		grammarBuilder.append("  | 'g'\n");
+		grammarBuilder.append("  | 'x' b 'z'\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("b : 'e' {} | 'y'\n");
+		grammarBuilder.append("  ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="xyz";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(a:3 x (b:2 y) z)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExtraToken() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(142);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {\n");
+		grammarBuilder.append("self._buildParseTrees = True\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("print($r.ctx.toStringTree(recog=self))\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : 'x' 'y'\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("Z : 'z' \n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append(" ");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="xzy";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(a x z y)\n", found);
+
+		assertEquals("line 1:1 extraneous input 'z' expecting 'y'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNoViableAlt() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(144);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {\n");
+		grammarBuilder.append("self._buildParseTrees = True\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("print($r.ctx.toStringTree(recog=self))\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : 'x' | 'y'\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("Z : 'z' \n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append(" ");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="z";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(a z)\n", found);
+
+		assertEquals("line 1:0 mismatched input 'z' expecting {'x', 'y'}\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testRuleRef() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(138);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {\n");
+		grammarBuilder.append("self._buildParseTrees = True\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("print($r.ctx.toStringTree(recog=self))\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : b 'x'\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("b : 'y' \n");
+		grammarBuilder.append("  ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="yx";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(a (b y) x)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSync() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(145);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {\n");
+		grammarBuilder.append("self._buildParseTrees = True\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("print($r.ctx.toStringTree(recog=self))\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : 'x' 'y'* '!'\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("Z : 'z' \n");
+		grammarBuilder.append("  ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="xzyy!";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(a x z y y !)\n", found);
+
+		assertEquals("line 1:1 extraneous input 'z' expecting {'y', '!'}\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testToken2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(127);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {\n");
+		grammarBuilder.append("self._buildParseTrees = True\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("print($r.ctx.toStringTree(recog=self))\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : 'x' 'y'\n");
+		grammarBuilder.append("  ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="xy";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(a x y)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTokenAndRuleContextString() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(173);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {\n");
+		grammarBuilder.append("self._buildParseTrees = True\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("print($r.ctx.toStringTree(recog=self))\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : 'x' { \n");
+		grammarBuilder.append("print(str_list(self.getRuleInvocationStack()))\n");
+		grammarBuilder.append("} ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals(
+			"[a, s]\n" +
+			"(a x)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+
+}
\ No newline at end of file
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/python2/TestParserErrors.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/python2/TestParserErrors.java
new file mode 100644
index 000000000..787fc9f8e
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/python2/TestParserErrors.java
@@ -0,0 +1,718 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.python2;
+
+import org.junit.Ignore;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+@SuppressWarnings("unused")
+public class TestParserErrors extends BasePython2Test {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testConjuringUpToken() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(61);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' x='b' {print(\"conjured=\" + str($x))} 'c' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="ac";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("conjured=[@-1,-1:-1='<missing 'b'>',<2>,1:1]\n", found);
+
+		assertEquals("line 1:1 missing 'b' at 'c'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testConjuringUpTokenFromSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(67);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' x=('b'|'c') {print(\"conjured=\" + str($x))} 'd' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="ad";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("conjured=[@-1,-1:-1='<missing 'b'>',<2>,1:1]\n", found);
+
+		assertEquals("line 1:1 missing {'b', 'c'} at 'd'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testContextListGetters() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(160);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@parser::members{\n");
+		grammarBuilder.append("def foo():\n");
+		grammarBuilder.append("    s = SContext()\n");
+		grammarBuilder.append("    a = s.a()\n");
+		grammarBuilder.append("    b = s.b()\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("s : (a | b)+;\n");
+		grammarBuilder.append("a : 'a' {print('a',end='')};\n");
+		grammarBuilder.append("b : 'b' {print('b',end='')};");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="abab";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, true);
+
+		assertEquals("abab\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDuplicatedLeftRecursiveCall_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(63);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : expr EOF;\n");
+		grammarBuilder.append("expr : 'x'\n");
+		grammarBuilder.append("     | expr expr\n");
+		grammarBuilder.append("     ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "start", input, true);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDuplicatedLeftRecursiveCall_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(63);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : expr EOF;\n");
+		grammarBuilder.append("expr : 'x'\n");
+		grammarBuilder.append("     | expr expr\n");
+		grammarBuilder.append("     ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="xx";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "start", input, true);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDuplicatedLeftRecursiveCall_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(63);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : expr EOF;\n");
+		grammarBuilder.append("expr : 'x'\n");
+		grammarBuilder.append("     | expr expr\n");
+		grammarBuilder.append("     ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="xxx";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "start", input, true);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDuplicatedLeftRecursiveCall_4() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(63);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : expr EOF;\n");
+		grammarBuilder.append("expr : 'x'\n");
+		grammarBuilder.append("     | expr expr\n");
+		grammarBuilder.append("     ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="xxxx";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "start", input, true);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testInvalidATNStateRemoval() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(102);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : ID ':' expr;\n");
+		grammarBuilder.append("expr : primary expr? {pass} | expr '->' ID;\n");
+		grammarBuilder.append("primary : ID;\n");
+		grammarBuilder.append("ID : [a-z]+;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x:x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "start", input, false);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testInvalidEmptyInput() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(36);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : ID+;\n");
+		grammarBuilder.append("ID : [a-z]+;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "start", input, true);
+
+		assertEquals("", found);
+
+		assertEquals("line 1:0 missing ID at '<EOF>'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLL1ErrorInfo() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(314);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : animal (AND acClass)? service EOF;\n");
+		grammarBuilder.append("animal : (DOG | CAT );\n");
+		grammarBuilder.append("service : (HARDWARE | SOFTWARE) ;\n");
+		grammarBuilder.append("AND : 'and';\n");
+		grammarBuilder.append("DOG : 'dog';\n");
+		grammarBuilder.append("CAT : 'cat';\n");
+		grammarBuilder.append("HARDWARE: 'hardware';\n");
+		grammarBuilder.append("SOFTWARE: 'software';\n");
+		grammarBuilder.append("WS : ' ' -> skip ;\n");
+		grammarBuilder.append("acClass\n");
+		grammarBuilder.append("@init\n");
+		grammarBuilder.append("{print(self.getExpectedTokens().toString(self.literalNames, self.symbolicNames))}\n");
+		grammarBuilder.append("  : ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="dog and software";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "start", input, false);
+
+		assertEquals("{'hardware', 'software'}\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLL2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(46);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' 'b'\n");
+		grammarBuilder.append("  | 'a' 'c'\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("q : 'e' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="ae";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("", found);
+
+		assertEquals("line 1:1 no viable alternative at input 'ae'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLL3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(55);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' 'b'* 'c'\n");
+		grammarBuilder.append("  | 'a' 'b' 'd'\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("q : 'e' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="abe";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("", found);
+
+		assertEquals("line 1:2 no viable alternative at input 'abe'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLLStar() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(48);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a'+ 'b'\n");
+		grammarBuilder.append("  | 'a'+ 'c'\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("q : 'e' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="aaae";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("", found);
+
+		assertEquals("line 1:3 no viable alternative at input 'aaae'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultiTokenDeletionBeforeLoop() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(28);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' 'b'* 'c';");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="aacabc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("", found);
+
+		assertEquals("line 1:1 extraneous input 'a' expecting {'b', 'c'}\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultiTokenDeletionBeforeLoop2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(40);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' ('b'|'z'{pass})* 'c';");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="aacabc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("", found);
+
+		assertEquals("line 1:1 extraneous input 'a' expecting {'b', 'z', 'c'}\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultiTokenDeletionDuringLoop() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(29);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' 'b'* 'c' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="abaaababc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("", found);
+
+		assertEquals(
+			"line 1:2 extraneous input 'a' expecting {'b', 'c'}\n" +
+			"line 1:6 extraneous input 'a' expecting {'b', 'c'}\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultiTokenDeletionDuringLoop2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(41);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' ('b'|'z'{pass})* 'c' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="abaaababc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("", found);
+
+		assertEquals(
+			"line 1:2 extraneous input 'a' expecting {'b', 'z', 'c'}\n" +
+			"line 1:6 extraneous input 'a' expecting {'b', 'z', 'c'}\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNoViableAltAvoidance() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(83);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e '!' ;\n");
+		grammarBuilder.append("e : 'a' 'b'\n");
+		grammarBuilder.append("  | 'a'\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("DOT : '.' ;\n");
+		grammarBuilder.append("WS : [ \\t\\r\\n]+ -> skip;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a.";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("", found);
+
+		assertEquals("line 1:1 mismatched input '.' expecting '!'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleSetInsertion() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(34);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' ('b'|'c') 'd' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="ad";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("", found);
+
+		assertEquals("line 1:1 missing {'b', 'c'} at 'd'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleSetInsertionConsumption() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(80);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("myset: ('b'|'c') ;\n");
+		grammarBuilder.append("a: 'a' myset 'd' {print(\"\" + str($myset.stop))} ; ");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="ad";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("[@0,0:0='a',<3>,1:0]\n", found);
+
+		assertEquals("line 1:1 missing {'b', 'c'} at 'd'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleTokenDeletion() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(24);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' 'b' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="aab";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("", found);
+
+		assertEquals("line 1:1 extraneous input 'a' expecting 'b'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleTokenDeletionBeforeAlt() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(38);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : ('b' | 'c')\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("q : 'a'\n");
+		grammarBuilder.append(";");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="ac";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("", found);
+
+		assertEquals("line 1:0 extraneous input 'a' expecting {'b', 'c'}\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleTokenDeletionBeforeLoop() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(25);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' 'b'* ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="aabc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("", found);
+
+		assertEquals(
+			"line 1:1 extraneous input 'a' expecting {<EOF>, 'b'}\n" +
+			"line 1:3 token recognition error at: 'c'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleTokenDeletionBeforeLoop2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(36);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' ('b'|'z'{pass})*;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="aabc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("", found);
+
+		assertEquals(
+			"line 1:1 extraneous input 'a' expecting {<EOF>, 'b', 'z'}\n" +
+			"line 1:3 token recognition error at: 'c'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleTokenDeletionBeforePredict() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(48);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a'+ 'b'\n");
+		grammarBuilder.append("  | 'a'+ 'c'\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("q : 'e' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="caaab";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("", found);
+
+		assertEquals("line 1:0 extraneous input 'c' expecting 'a'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleTokenDeletionConsumption() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(80);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("myset: ('b'|'c') ;\n");
+		grammarBuilder.append("a: 'a' myset 'd' {print(\"\" + str($myset.stop))} ; ");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="aabd";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("[@2,2:2='b',<1>,1:2]\n", found);
+
+		assertEquals("line 1:1 extraneous input 'a' expecting {'b', 'c'}\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleTokenDeletionDuringLoop() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(29);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' 'b'* 'c' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="ababbc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("", found);
+
+		assertEquals("line 1:2 extraneous input 'a' expecting {'b', 'c'}\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleTokenDeletionDuringLoop2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(41);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' ('b'|'z'{pass})* 'c' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="ababbc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("", found);
+
+		assertEquals("line 1:2 extraneous input 'a' expecting {'b', 'z', 'c'}\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleTokenDeletionExpectingSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(30);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' ('b'|'c') ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="aab";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("", found);
+
+		assertEquals("line 1:1 extraneous input 'a' expecting {'b', 'c'}\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleTokenInsertion() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(28);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' 'b' 'c' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="ac";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("", found);
+
+		assertEquals("line 1:1 missing 'b' at 'c'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTokenMismatch() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(24);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' 'b' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="aa";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("", found);
+
+		assertEquals("line 1:1 mismatched input 'a' expecting 'b'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTokenMismatch2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(165);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("stat:   ( '(' expr? ')' )? EOF ;\n");
+		grammarBuilder.append("expr:   ID '=' STR ;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("ERR :   '~FORCE_ERROR~' ;\n");
+		grammarBuilder.append("ID  :   [a-zA-Z]+ ;\n");
+		grammarBuilder.append("STR :   '\"' ~[\"]* '\"' ;\n");
+		grammarBuilder.append("WS  :   [ \\t\\r\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="( ~FORCE_ERROR~ ";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "stat", input, false);
+
+		assertEquals("", found);
+
+		assertEquals("line 1:2 mismatched input '~FORCE_ERROR~' expecting ')'\n", this.stderrDuringParse);
+
+	}
+
+
+}
\ No newline at end of file
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/python2/TestParserExec.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/python2/TestParserExec.java
new file mode 100644
index 000000000..febfcf2a0
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/python2/TestParserExec.java
@@ -0,0 +1,790 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.python2;
+
+import org.junit.Ignore;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+@SuppressWarnings("unused")
+public class TestParserExec extends BasePython2Test {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAPlus() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(77);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : ID+ {\n");
+		grammarBuilder.append("print($text)\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a b c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("abc\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAStar_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(77);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : ID* {\n");
+		grammarBuilder.append("print($text)\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAStar_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(77);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : ID* {\n");
+		grammarBuilder.append("print($text)\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a b c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("abc\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAorAPlus() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(82);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (ID|ID)+ {\n");
+		grammarBuilder.append("print($text)\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a b c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("abc\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAorAStar_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(82);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (ID|ID)* {\n");
+		grammarBuilder.append("print($text)\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAorAStar_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(82);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (ID|ID)* {\n");
+		grammarBuilder.append("print($text)\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a b c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("abc\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAorB() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(122);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : ID {\n");
+		grammarBuilder.append("print(\"alt 1\")\n");
+		grammarBuilder.append("} | INT {\n");
+		grammarBuilder.append("print(\"alt 2\")\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="34";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("alt 2\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAorBPlus() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(105);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (ID|INT{\n");
+		grammarBuilder.append("})+ {\n");
+		grammarBuilder.append("print($text)\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a 34 c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("a34c\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAorBStar_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(105);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (ID|INT{\n");
+		grammarBuilder.append("})* {\n");
+		grammarBuilder.append("print($text)\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAorBStar_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(105);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (ID|INT{\n");
+		grammarBuilder.append("})* {\n");
+		grammarBuilder.append("print($text)\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a 34 c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("a34c\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testBasic() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(98);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : ID INT {\n");
+		grammarBuilder.append("print($text)\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="abc 34";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("abc34\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testEOFInClosure() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(53);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("prog : stat EOF;\n");
+		grammarBuilder.append("stat : 'x' ('y' | EOF)*?;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "prog", input, false);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testIfIfElseGreedyBinding1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(186);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : statement+ ;\n");
+		grammarBuilder.append("statement : 'x' | ifStatement;\n");
+		grammarBuilder.append("ifStatement : 'if' 'y' statement ('else' statement)? {\n");
+		grammarBuilder.append("print($text)\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> channel(HIDDEN);");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="if y if y x else x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "start", input, false);
+
+		assertEquals(
+			"if y x else x\n" +
+			"if y if y x else x\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testIfIfElseGreedyBinding2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(186);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : statement+ ;\n");
+		grammarBuilder.append("statement : 'x' | ifStatement;\n");
+		grammarBuilder.append("ifStatement : 'if' 'y' statement ('else' statement|) {\n");
+		grammarBuilder.append("print($text)\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> channel(HIDDEN);");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="if y if y x else x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "start", input, false);
+
+		assertEquals(
+			"if y x else x\n" +
+			"if y if y x else x\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testIfIfElseNonGreedyBinding1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(187);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : statement+ ;\n");
+		grammarBuilder.append("statement : 'x' | ifStatement;\n");
+		grammarBuilder.append("ifStatement : 'if' 'y' statement ('else' statement)?? {\n");
+		grammarBuilder.append("print($text)\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> channel(HIDDEN);");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="if y if y x else x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "start", input, false);
+
+		assertEquals(
+			"if y x\n" +
+			"if y if y x else x\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testIfIfElseNonGreedyBinding2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(186);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : statement+ ;\n");
+		grammarBuilder.append("statement : 'x' | ifStatement;\n");
+		grammarBuilder.append("ifStatement : 'if' 'y' statement (|'else' statement) {\n");
+		grammarBuilder.append("print($text)\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> channel(HIDDEN);");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="if y if y x else x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "start", input, false);
+
+		assertEquals(
+			"if y x\n" +
+			"if y if y x else x\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLL1OptionalBlock_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(103);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (ID|{}INT)? {\n");
+		grammarBuilder.append("print($text)\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLL1OptionalBlock_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(103);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (ID|{}INT)? {\n");
+		grammarBuilder.append("print($text)\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("a\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLabelAliasingAcrossLabeledAlternatives() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(157);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : a* EOF;\n");
+		grammarBuilder.append("a\n");
+		grammarBuilder.append("  : label=subrule {print($label.text)} #One\n");
+		grammarBuilder.append("  | label='y' {print($label.text)} #Two\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("subrule : 'x';\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="xy";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "start", input, false);
+
+		assertEquals(
+			"x\n" +
+			"y\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLabels() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(118);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : b1=b b2+=b* b3+=';' ;\n");
+		grammarBuilder.append("b : id_=ID val+=INT*;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="abc 34;";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testListLabelForClosureContext() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(456);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("ifStatement\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("assert isinstance(v, (list, tuple))\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("    : 'if' expression\n");
+		grammarBuilder.append("      ( ( 'then'\n");
+		grammarBuilder.append("          executableStatement*\n");
+		grammarBuilder.append("          elseIfStatement*  // <--- problem is here; should yield a list not node\n");
+		grammarBuilder.append("          elseStatement?\n");
+		grammarBuilder.append("          'end' 'if'\n");
+		grammarBuilder.append("        ) | executableStatement )\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("elseIfStatement\n");
+		grammarBuilder.append("    : 'else' 'if' expression 'then' executableStatement*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("expression : 'a' ;\n");
+		grammarBuilder.append("executableStatement : 'a' ;\n");
+		grammarBuilder.append("elseStatement : 'a' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "expression", input, false);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testListLabelsOnSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(140);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : b b* ';' ;\n");
+		grammarBuilder.append("b : ID val+=(INT | FLOAT)*;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("FLOAT : [0-9]+ '.' [0-9]+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="abc 34;";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleEOFHandling() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(42);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("prog : ('x' | 'x' 'y') EOF EOF;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "prog", input, false);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testOptional_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(90);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("stat : ifstat | 'x';\n");
+		grammarBuilder.append("ifstat : 'if' stat ('else' stat)?;\n");
+		grammarBuilder.append("WS : [ \\n\\t]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "stat", input, false);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testOptional_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(90);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("stat : ifstat | 'x';\n");
+		grammarBuilder.append("ifstat : 'if' stat ('else' stat)?;\n");
+		grammarBuilder.append("WS : [ \\n\\t]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="if x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "stat", input, false);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testOptional_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(90);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("stat : ifstat | 'x';\n");
+		grammarBuilder.append("ifstat : 'if' stat ('else' stat)?;\n");
+		grammarBuilder.append("WS : [ \\n\\t]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="if x else x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "stat", input, false);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testOptional_4() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(90);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("stat : ifstat | 'x';\n");
+		grammarBuilder.append("ifstat : 'if' stat ('else' stat)?;\n");
+		grammarBuilder.append("WS : [ \\n\\t]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="if if x else x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "stat", input, false);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testParserProperty() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(153);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@members {\n");
+		grammarBuilder.append("def Property(self):\n");
+		grammarBuilder.append("    return True\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("a : {$parser.Property()}? ID {print(\"valid\")}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="abc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("valid\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPredicatedIfIfElse() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(175);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : stmt EOF ;\n");
+		grammarBuilder.append("stmt : ifStmt | ID;\n");
+		grammarBuilder.append("ifStmt : 'if' ID stmt ('else' stmt | { self._input.LA(1)!=TParser.ELSE }?);\n");
+		grammarBuilder.append("ELSE : 'else';\n");
+		grammarBuilder.append("ID : [a-zA-Z]+;\n");
+		grammarBuilder.append("WS : [ \\n\\t]+ -> skip;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="if x if x a else b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, true);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPredictionIssue334() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(244);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("file_ @init{\n");
+		grammarBuilder.append("self._errHandler = BailErrorStrategy()\n");
+		grammarBuilder.append("} \n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("print($ctx.toStringTree(recog=self))\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  :   item (SEMICOLON item)* SEMICOLON? EOF ;\n");
+		grammarBuilder.append("item : A B?;\n");
+		grammarBuilder.append("SEMICOLON: ';';\n");
+		grammarBuilder.append("A : 'a'|'A';\n");
+		grammarBuilder.append("B : 'b'|'B';\n");
+		grammarBuilder.append("WS      : [ \\r\\t\\n]+ -> skip;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "file_", input, false);
+
+		assertEquals("(file_ (item a) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReferenceToATN_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(106);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (ID|ATN)* ATN? {print($text)} ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("ATN : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReferenceToATN_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(106);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (ID|ATN)* ATN? {print($text)} ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("ATN : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a 34 c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("a34c\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+
+}
\ No newline at end of file
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/python2/TestPerformance.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/python2/TestPerformance.java
new file mode 100644
index 000000000..3fcc9dad6
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/python2/TestPerformance.java
@@ -0,0 +1,217 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.python2;
+
+import org.junit.Ignore;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+@SuppressWarnings("unused")
+public class TestPerformance extends BasePython2Test {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExpressionGrammar_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(164);
+		grammarBuilder.append("grammar Expr;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("program: expr EOF;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("expr\n");
+		grammarBuilder.append("	: ID\n");
+		grammarBuilder.append("	| 'not' expr\n");
+		grammarBuilder.append("	| expr 'and' expr\n");
+		grammarBuilder.append("	| expr 'or' expr\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("ID: [a-zA-Z_][a-zA-Z_0-9]*;\n");
+		grammarBuilder.append("WS: [ \\t\\n\\r\\f]+ -> skip;\n");
+		grammarBuilder.append("ERROR: .;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input =
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12";
+		String found = execParser("Expr.g4", grammar, "ExprParser", "ExprLexer", "ExprListener", "ExprVisitor", "program", input, false);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExpressionGrammar_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(164);
+		grammarBuilder.append("grammar Expr;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("program: expr EOF;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("expr\n");
+		grammarBuilder.append("	: ID\n");
+		grammarBuilder.append("	| 'not' expr\n");
+		grammarBuilder.append("	| expr 'and' expr\n");
+		grammarBuilder.append("	| expr 'or' expr\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("ID: [a-zA-Z_][a-zA-Z_0-9]*;\n");
+		grammarBuilder.append("WS: [ \\t\\n\\r\\f]+ -> skip;\n");
+		grammarBuilder.append("ERROR: .;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input =
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12";
+		String found = execParser("Expr.g4", grammar, "ExprParser", "ExprLexer", "ExprListener", "ExprVisitor", "program", input, false);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+
+}
\ No newline at end of file
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/python2/TestSemPredEvalLexer.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/python2/TestSemPredEvalLexer.java
new file mode 100644
index 000000000..0896bf9cf
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/python2/TestSemPredEvalLexer.java
@@ -0,0 +1,217 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.python2;
+
+import org.junit.Ignore;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+@SuppressWarnings("unused")
+public class TestSemPredEvalLexer extends BasePython2Test {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDisableRule() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(131);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("E1 : 'enum' { False }? ;\n");
+		grammarBuilder.append("E2 : 'enum' { True }? ;  // winner not E1 or ID\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="enum abc";
+		String found = execLexer("L.g4", grammar, "L", input, true);
+		assertEquals(
+			"[@0,0:3='enum',<2>,1:0]\n" +
+			"[@1,5:7='abc',<3>,1:5]\n" +
+			"[@2,8:7='<EOF>',<-1>,1:8]\n" +
+			"s0-' '->:s5=>4\n" +
+			"s0-'a'->:s6=>3\n" +
+			"s0-'e'->:s1=>3\n" +
+			":s1=>3-'n'->:s2=>3\n" +
+			":s2=>3-'u'->:s3=>3\n" +
+			":s6=>3-'b'->:s6=>3\n" +
+			":s6=>3-'c'->:s6=>3\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testEnumNotID() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(96);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("ENUM : [a-z]+  { self.text==\"enum\" }? ;\n");
+		grammarBuilder.append("ID : [a-z]+  ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="enum abc enum";
+		String found = execLexer("L.g4", grammar, "L", input, true);
+		assertEquals(
+			"[@0,0:3='enum',<1>,1:0]\n" +
+			"[@1,5:7='abc',<2>,1:5]\n" +
+			"[@2,9:12='enum',<1>,1:9]\n" +
+			"[@3,13:12='<EOF>',<-1>,1:13]\n" +
+			"s0-' '->:s3=>3\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testIDnotEnum() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(84);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("ENUM : [a-z]+  { False }? ;\n");
+		grammarBuilder.append("ID : [a-z]+  ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="enum abc enum";
+		String found = execLexer("L.g4", grammar, "L", input, true);
+		assertEquals(
+			"[@0,0:3='enum',<2>,1:0]\n" +
+			"[@1,5:7='abc',<2>,1:5]\n" +
+			"[@2,9:12='enum',<2>,1:9]\n" +
+			"[@3,13:12='<EOF>',<-1>,1:13]\n" +
+			"s0-' '->:s2=>3\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testIDvsEnum() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(85);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("ENUM : 'enum' { False }? ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="enum abc enum";
+		String found = execLexer("L.g4", grammar, "L", input, true);
+		assertEquals(
+			"[@0,0:3='enum',<2>,1:0]\n" +
+			"[@1,5:7='abc',<2>,1:5]\n" +
+			"[@2,9:12='enum',<2>,1:9]\n" +
+			"[@3,13:12='<EOF>',<-1>,1:13]\n" +
+			"s0-' '->:s5=>3\n" +
+			"s0-'a'->:s4=>2\n" +
+			"s0-'e'->:s1=>2\n" +
+			":s1=>2-'n'->:s2=>2\n" +
+			":s2=>2-'u'->:s3=>2\n" +
+			":s4=>2-'b'->:s4=>2\n" +
+			":s4=>2-'c'->:s4=>2\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testIndent() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(135);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("ID : [a-z]+  ;\n");
+		grammarBuilder.append("INDENT : [ \\t]+ { self._tokenStartColumn==0 }?\n");
+		grammarBuilder.append("         { print(\"INDENT\") }  ;\n");
+		grammarBuilder.append("NL : '\\n';\n");
+		grammarBuilder.append("WS : [ \\t]+ ;");
+		String grammar = grammarBuilder.toString();
+
+		String input =
+			"abc\n" +
+			"  def  \n";
+		String found = execLexer("L.g4", grammar, "L", input, true);
+		assertEquals(
+			"INDENT\n" +
+			"[@0,0:2='abc',<1>,1:0]\n" +
+			"[@1,3:3='\\n',<3>,1:3]\n" +
+			"[@2,4:5='  ',<2>,2:0]\n" +
+			"[@3,6:8='def',<1>,2:2]\n" +
+			"[@4,9:10='  ',<4>,2:5]\n" +
+			"[@5,11:11='\\n',<3>,2:7]\n" +
+			"[@6,12:11='<EOF>',<-1>,3:0]\n" +
+			"s0-'\n" +
+			"'->:s2=>3\n" +
+			"s0-'a'->:s1=>1\n" +
+			"s0-'d'->:s1=>1\n" +
+			":s1=>1-'b'->:s1=>1\n" +
+			":s1=>1-'c'->:s1=>1\n" +
+			":s1=>1-'e'->:s1=>1\n" +
+			":s1=>1-'f'->:s1=>1\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLexerInputPositionSensitivePredicates() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(206);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("WORD1 : ID1+ { print(self.text) } ;\n");
+		grammarBuilder.append("WORD2 : ID2+ { print(self.text) } ;\n");
+		grammarBuilder.append("fragment ID1 : { self.column < 2 }? [a-zA-Z];\n");
+		grammarBuilder.append("fragment ID2 : { self.column >= 2 }? [a-zA-Z];\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+
+		String input =
+			"a cde\n" +
+			"abcde\n";
+		String found = execLexer("L.g4", grammar, "L", input, true);
+		assertEquals(
+			"a\n" +
+			"cde\n" +
+			"ab\n" +
+			"cde\n" +
+			"[@0,0:0='a',<1>,1:0]\n" +
+			"[@1,2:4='cde',<2>,1:2]\n" +
+			"[@2,6:7='ab',<1>,2:0]\n" +
+			"[@3,8:10='cde',<2>,2:2]\n" +
+			"[@4,12:11='<EOF>',<-1>,3:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPredicatedKeywords() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(142);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("ENUM : [a-z]+ { self.text==\"enum\" }? { print(\"enum!\") } ;\n");
+		grammarBuilder.append("ID   : [a-z]+ { print(\"ID \" + self.text) } ;\n");
+		grammarBuilder.append("WS   : [ \\n] -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="enum enu a";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"enum!\n" +
+			"ID enu\n" +
+			"ID a\n" +
+			"[@0,0:3='enum',<1>,1:0]\n" +
+			"[@1,5:7='enu',<2>,1:5]\n" +
+			"[@2,9:9='a',<2>,1:9]\n" +
+			"[@3,10:9='<EOF>',<-1>,1:10]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+
+}
\ No newline at end of file
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/python2/TestSemPredEvalParser.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/python2/TestSemPredEvalParser.java
new file mode 100644
index 000000000..3be34563e
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/python2/TestSemPredEvalParser.java
@@ -0,0 +1,761 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.python2;
+
+import org.junit.Ignore;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+@SuppressWarnings("unused")
+public class TestSemPredEvalParser extends BasePython2Test {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void test2UnpredicatedAlts() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(276);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : {self._interp.predictionMode =  PredictionMode.LL_EXACT_AMBIG_DETECTION} a ';' a; // do 2x: once in ATN, next in DFA\n");
+		grammarBuilder.append("a : ID {print(\"alt 1\")}\n");
+		grammarBuilder.append("  | ID {print(\"alt 2\")}\n");
+		grammarBuilder.append("  | {False}? ID {print(\"alt 3\")}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x; y";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, true);
+
+		assertEquals(
+			"alt 1\n" +
+			"alt 1\n", found);
+
+		assertEquals(
+			"line 1:0 reportAttemptingFullContext d=0 (a), input='x'\n" +
+			"line 1:0 reportAmbiguity d=0 (a): ambigAlts={1, 2}, input='x'\n" +
+			"line 1:3 reportAttemptingFullContext d=0 (a), input='y'\n" +
+			"line 1:3 reportAmbiguity d=0 (a): ambigAlts={1, 2}, input='y'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void test2UnpredicatedAltsAndOneOrthogonalAlt() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(321);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : {self._interp.predictionMode =  PredictionMode.LL_EXACT_AMBIG_DETECTION} a ';' a ';' a;\n");
+		grammarBuilder.append("a : INT {print(\"alt 1\")}\n");
+		grammarBuilder.append("  | ID {print(\"alt 2\")} // must pick this one for ID since pred is false\n");
+		grammarBuilder.append("  | ID {print(\"alt 3\")}\n");
+		grammarBuilder.append("  | {False}? ID {print(\"alt 4\")}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="34; x; y";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, true);
+
+		assertEquals(
+			"alt 1\n" +
+			"alt 2\n" +
+			"alt 2\n", found);
+
+		assertEquals(
+			"line 1:4 reportAttemptingFullContext d=0 (a), input='x'\n" +
+			"line 1:4 reportAmbiguity d=0 (a): ambigAlts={2, 3}, input='x'\n" +
+			"line 1:7 reportAttemptingFullContext d=0 (a), input='y'\n" +
+			"line 1:7 reportAmbiguity d=0 (a): ambigAlts={2, 3}, input='y'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testActionHidesPreds() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(204);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@members {i = 0}\n");
+		grammarBuilder.append("s : a+ ;\n");
+		grammarBuilder.append("a : {self.i = 1} ID {self.i == 1}? {print(\"alt 1\")}\n");
+		grammarBuilder.append("  | {self.i = 2} ID {self.i == 2}? {print(\"alt 2\")}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x x y";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals(
+			"alt 1\n" +
+			"alt 1\n" +
+			"alt 1\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testActionsHidePredsInGlobalFOLLOW() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(269);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@members {\n");
+		grammarBuilder.append("def pred(self, v):\n");
+		grammarBuilder.append("	print('eval=' + str(v).lower())\n");
+		grammarBuilder.append("	return v\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("s : e {} {self.pred(True)}? {print(\"parse\")} '!' ;\n");
+		grammarBuilder.append("t : e {} {self.pred(False)}? ID ;\n");
+		grammarBuilder.append("e : ID | ; // non-LL(1) so we use ATN\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a!";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals(
+			"eval=true\n" +
+			"parse\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAtomWithClosureInTranslatedLRRule() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(94);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : e[0] EOF;\n");
+		grammarBuilder.append("e[int _p]\n");
+		grammarBuilder.append("    :   ( 'a' | 'b'+ ) ( {3 >= $_p}? '+' e[4] )*\n");
+		grammarBuilder.append("    ;\n");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a+b+a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "start", input, false);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDepedentPredsInGlobalFOLLOW() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(292);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@members {\n");
+		grammarBuilder.append("def pred(self, v):\n");
+		grammarBuilder.append("	print('eval=' + str(v).lower())\n");
+		grammarBuilder.append("	return v\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("s : a[99] ;\n");
+		grammarBuilder.append("a[int i] : e {self.pred($i==99)}? {print(\"parse\")} '!' ;\n");
+		grammarBuilder.append("b[int i] : e {self.pred($i==99)}? ID ;\n");
+		grammarBuilder.append("e : ID | ; // non-LL(1) so we use ATN\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a!";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals(
+			"eval=true\n" +
+			"parse\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDependentPredNotInOuterCtxShouldBeIgnored() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(256);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : b[2] ';' |  b[2] '.' ; // decision in s drills down to ctx-dependent pred in a;\n");
+		grammarBuilder.append("b[int i] : a[i] ;\n");
+		grammarBuilder.append("a[int i]\n");
+		grammarBuilder.append("  : {$i==1}? ID {print(\"alt 1\")}\n");
+		grammarBuilder.append("    | {$i==2}? ID {print(\"alt 2\")}\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;\n");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a;";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("alt 2\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDisabledAlternative() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(121);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("cppCompilationUnit : content+ EOF;\n");
+		grammarBuilder.append("content: anything | {False}? .;\n");
+		grammarBuilder.append("anything: ANY_CHAR;\n");
+		grammarBuilder.append("ANY_CHAR: [_a-zA-Z0-9];");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="hello";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "cppCompilationUnit", input, false);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testIndependentPredNotPassedOuterCtxToAvoidCastException() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(169);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : b ';' |  b '.' ;\n");
+		grammarBuilder.append("b : a ;\n");
+		grammarBuilder.append("a\n");
+		grammarBuilder.append("  : {False}? ID {print(\"alt 1\")}\n");
+		grammarBuilder.append("  | {True}? ID {print(\"alt 2\")}\n");
+		grammarBuilder.append(" ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a;";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("alt 2\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNoTruePredsThrowsNoViableAlt() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(157);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : a a;\n");
+		grammarBuilder.append("a : {False}? ID INT {print(\"alt 1\")}\n");
+		grammarBuilder.append("  | {False}? ID INT {print(\"alt 2\")}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="y 3 x 4";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("", found);
+
+		assertEquals("line 1:0 no viable alternative at input 'y'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testOrder() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(283);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : a {} a; // do 2x: once in ATN, next in DFA;\n");
+		grammarBuilder.append("// action blocks lookahead from falling off of 'a'\n");
+		grammarBuilder.append("// and looking into 2nd 'a' ref. !ctx dependent pred\n");
+		grammarBuilder.append("a : ID {print(\"alt 1\")}\n");
+		grammarBuilder.append("  | {True}?  ID {print(\"alt 2\")}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x y";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals(
+			"alt 1\n" +
+			"alt 1\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPredFromAltTestedInLoopBack_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(203);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("file_\n");
+		grammarBuilder.append("@after {print($ctx.toStringTree(recog=self))}\n");
+		grammarBuilder.append("  : para para EOF ;\n");
+		grammarBuilder.append("para: paraContent NL NL ;\n");
+		grammarBuilder.append("paraContent : ('s'|'x'|{self._input.LA(2)!=TParser.NL}? NL)+ ;\n");
+		grammarBuilder.append("NL : '\\n' ;\n");
+		grammarBuilder.append("s : 's' ;\n");
+		grammarBuilder.append("X : 'x' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input =
+			"s\n" +
+			"\n" +
+			"\n" +
+			"x\n";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "file_", input, true);
+
+		assertEquals("(file_ (para (paraContent s) \\n \\n) (para (paraContent \\n x \\n)) <EOF>)\n", found);
+
+		assertEquals(
+			"line 5:0 mismatched input '<EOF>' expecting '\n" +
+			"'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPredFromAltTestedInLoopBack_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(203);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("file_\n");
+		grammarBuilder.append("@after {print($ctx.toStringTree(recog=self))}\n");
+		grammarBuilder.append("  : para para EOF ;\n");
+		grammarBuilder.append("para: paraContent NL NL ;\n");
+		grammarBuilder.append("paraContent : ('s'|'x'|{self._input.LA(2)!=TParser.NL}? NL)+ ;\n");
+		grammarBuilder.append("NL : '\\n' ;\n");
+		grammarBuilder.append("s : 's' ;\n");
+		grammarBuilder.append("X : 'x' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input =
+			"s\n" +
+			"\n" +
+			"\n" +
+			"x\n" +
+			"\n";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "file_", input, true);
+
+		assertEquals("(file_ (para (paraContent s) \\n \\n) (para (paraContent \\n x) \\n \\n) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPredTestedEvenWhenUnAmbig_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(184);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@members {enumKeyword = True}\n");
+		grammarBuilder.append("primary\n");
+		grammarBuilder.append("    :   ID {print(\"ID \"+$ID.text)}\n");
+		grammarBuilder.append("    |   {not self.enumKeyword}? 'enum' {print(\"enum\")}\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : [a-z]+ ;\n");
+		grammarBuilder.append("WS : [ \\t\\n\\r]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="abc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "primary", input, false);
+
+		assertEquals("ID abc\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPredTestedEvenWhenUnAmbig_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(184);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@members {enumKeyword = True}\n");
+		grammarBuilder.append("primary\n");
+		grammarBuilder.append("    :   ID {print(\"ID \"+$ID.text)}\n");
+		grammarBuilder.append("    |   {not self.enumKeyword}? 'enum' {print(\"enum\")}\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : [a-z]+ ;\n");
+		grammarBuilder.append("WS : [ \\t\\n\\r]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="enum";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "primary", input, false);
+
+		assertEquals("", found);
+
+		assertEquals("line 1:0 no viable alternative at input 'enum'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPredicateDependentOnArg() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(181);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@members {i = 0}\n");
+		grammarBuilder.append("s : a[2] a[1];\n");
+		grammarBuilder.append("a[int i]\n");
+		grammarBuilder.append("  : {$i==1}? ID {print(\"alt 1\")}\n");
+		grammarBuilder.append("  | {$i==2}? ID {print(\"alt 2\")}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals(
+			"alt 2\n" +
+			"alt 1\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPredicateDependentOnArg2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(149);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@members {i = 0}\n");
+		grammarBuilder.append("s : a[2] a[1];\n");
+		grammarBuilder.append("a[int i]\n");
+		grammarBuilder.append("  : {$i==1}? ID \n");
+		grammarBuilder.append("  | {$i==2}? ID \n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPredsInGlobalFOLLOW() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(263);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@members {\n");
+		grammarBuilder.append("def pred(self, v):\n");
+		grammarBuilder.append("	print('eval=' + str(v).lower())\n");
+		grammarBuilder.append("	return v\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("s : e {self.pred(True)}? {print(\"parse\")} '!' ;\n");
+		grammarBuilder.append("t : e {self.pred(False)}? ID ;\n");
+		grammarBuilder.append("e : ID | ; // non-LL(1) so we use ATN\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a!";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals(
+			"eval=true\n" +
+			"parse\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testRewindBeforePredEval() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(201);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : a a;\n");
+		grammarBuilder.append("a : {self._input.LT(1).text==\"x\"}? ID INT {print(\"alt 1\")}\n");
+		grammarBuilder.append("  | {self._input.LT(1).text==\"y\"}? ID INT {print(\"alt 2\")}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="y 3 x 4";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals(
+			"alt 2\n" +
+			"alt 1\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSimple() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(235);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : a a a; // do 3x: once in ATN, next in DFA then INT in ATN\n");
+		grammarBuilder.append("a : {False}? ID {print(\"alt 1\")}\n");
+		grammarBuilder.append("  | {True}?  ID {print(\"alt 2\")}\n");
+		grammarBuilder.append("  | INT         {print(\"alt 3\")}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x y 3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals(
+			"alt 2\n" +
+			"alt 2\n" +
+			"alt 3\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSimpleValidate() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(150);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : a ;\n");
+		grammarBuilder.append("a : {False}? ID  {print(\"alt 1\")}\n");
+		grammarBuilder.append("  | {True}?  INT {print(\"alt 2\")}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("", found);
+
+		assertEquals("line 1:0 no viable alternative at input 'x'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSimpleValidate2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(153);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : a a a;\n");
+		grammarBuilder.append("a : {False}? ID  {print(\"alt 1\")}\n");
+		grammarBuilder.append("  | {True}?  INT {print(\"alt 2\")}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="3 4 x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals(
+			"alt 2\n" +
+			"alt 2\n", found);
+
+		assertEquals("line 1:4 no viable alternative at input 'x'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testToLeft() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(150);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("	s : a+ ;\n");
+		grammarBuilder.append("a : {False}? ID {print(\"alt 1\")}\n");
+		grammarBuilder.append("  | {True}?  ID {print(\"alt 2\")}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x x y";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals(
+			"alt 2\n" +
+			"alt 2\n" +
+			"alt 2\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testToLeftWithVaryingPredicate() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(228);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@members {i = 0}\n");
+		grammarBuilder.append("s : ({self.i += 1\n");
+		grammarBuilder.append("print(\"i=\" + str(self.i))} a)+ ;\n");
+		grammarBuilder.append("a : {self.i % 2 == 0}? ID {print(\"alt 1\")}\n");
+		grammarBuilder.append("  | {self.i % 2 != 0}? ID {print(\"alt 2\")}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x x y";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals(
+			"i=1\n" +
+			"alt 2\n" +
+			"i=2\n" +
+			"alt 1\n" +
+			"i=3\n" +
+			"alt 2\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testUnpredicatedPathsInAlt() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(169);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : a {print(\"alt 1\")}\n");
+		grammarBuilder.append("  | b {print(\"alt 2\")}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("a : {False}? ID INT\n");
+		grammarBuilder.append("  | ID INT\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("b : ID ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x 4";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("alt 1\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testValidateInDFA() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(318);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : a ';' a;\n");
+		grammarBuilder.append("// ';' helps us to resynchronize without consuming\n");
+		grammarBuilder.append("// 2nd 'a' reference. We our testing that the DFA also\n");
+		grammarBuilder.append("// throws an exception if the validating predicate fails\n");
+		grammarBuilder.append("a : {False}? ID  {print(\"alt 1\")}\n");
+		grammarBuilder.append("  | {True}?  INT {print(\"alt 2\")}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x ; y";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("", found);
+
+		assertEquals(
+			"line 1:0 no viable alternative at input 'x'\n" +
+			"line 1:4 no viable alternative at input 'y'\n", this.stderrDuringParse);
+
+	}
+
+
+}
\ No newline at end of file
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/python2/TestSets.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/python2/TestSets.java
new file mode 100644
index 000000000..0f9a32f57
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/python2/TestSets.java
@@ -0,0 +1,476 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.python2;
+
+import org.junit.Ignore;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+@SuppressWarnings("unused")
+public class TestSets extends BasePython2Test {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetLiteral() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(78);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (A {print($A.text)})+ ;\n");
+		grammarBuilder.append("A : [AaBb] ;\n");
+		grammarBuilder.append("WS : (' '|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="A a B b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals(
+			"A\n" +
+			"a\n" +
+			"B\n" +
+			"b\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testComplementSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(51);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("parse : ~NEW_LINE;\n");
+		grammarBuilder.append("NEW_LINE: '\\r'? '\\n';");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "parse", input, false);
+
+		assertEquals("", found);
+
+		assertEquals(
+			"line 1:0 token recognition error at: 'a'\n" +
+			"line 1:1 missing {} at '<EOF>'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLexerOptionalSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(70);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {print(self._input.getText())} ;\n");
+		grammarBuilder.append("A : ('a'|'b')? 'c' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="ac";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("ac\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLexerPlusSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(70);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {print(self._input.getText())} ;\n");
+		grammarBuilder.append("A : ('a'|'b')+ 'c' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="abaac";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("abaac\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLexerStarSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(70);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {print(self._input.getText())} ;\n");
+		grammarBuilder.append("A : ('a'|'b')* 'c' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="abaac";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("abaac\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNotChar() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(46);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {print($A.text)} ;\n");
+		grammarBuilder.append("A : ~'b' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("x\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNotCharSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(52);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {print($A.text)} ;\n");
+		grammarBuilder.append("A : ~('b'|'c') ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("x\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNotCharSetWithLabel() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(54);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {print($A.text)} ;\n");
+		grammarBuilder.append("A : h=~('b'|'c') ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("x\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNotCharSetWithRuleRef3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(118);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {print($A.text)} ;\n");
+		grammarBuilder.append("A : ('a'|B) ;  // this doesn't collapse to set but works\n");
+		grammarBuilder.append("fragment\n");
+		grammarBuilder.append("B : ~('a'|'c') ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("x\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testOptionalLexerSingleElement() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(64);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {print(self._input.getText())} ;\n");
+		grammarBuilder.append("A : 'b'? 'c' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="bc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("bc\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testOptionalSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(62);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : ('a'|'b')? 'c' {print(self._input.getText())} ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="ac";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("ac\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testOptionalSingleElement() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(64);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A? 'c' {print(self._input.getText())} ;\n");
+		grammarBuilder.append("A : 'b' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="bc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("bc\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testParserNotSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(50);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : t=~('x'|'y') 'z' {print($t.text)} ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="zz";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("z\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testParserNotToken() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(56);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : ~'x' 'z' {print(self._input.getText())} ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="zz";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("zz\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testParserNotTokenWithLabel() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(44);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : t=~'x' 'z' {print($t.text)} ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="zz";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("z\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testParserSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(45);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : t=('x'|'y') {print($t.text)} ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("x\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPlusLexerSingleElement() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(64);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {print(self._input.getText())} ;\n");
+		grammarBuilder.append("A : 'b'+ 'c' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="bbbbc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("bbbbc\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPlusSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(62);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : ('a'|'b')+ 'c' {print(self._input.getText())} ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="abaac";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("abaac\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testRuleAsSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(69);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a @after {print(self._input.getText())} : 'a' | 'b' |'c' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("b\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSeqDoesNotBecomeSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(106);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : C {print(self._input.getText())} ;\n");
+		grammarBuilder.append("fragment A : '1' | '2';\n");
+		grammarBuilder.append("fragment B : '3' '4';\n");
+		grammarBuilder.append("C : A | B;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="34";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("34\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testStarLexerSingleElement_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(64);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {print(self._input.getText())} ;\n");
+		grammarBuilder.append("A : 'b'* 'c' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="bbbbc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("bbbbc\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testStarLexerSingleElement_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(64);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {print(self._input.getText())} ;\n");
+		grammarBuilder.append("A : 'b'* 'c' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("c\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testStarSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(62);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : ('a'|'b')* 'c' {print(self._input.getText())} ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="abaac";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("abaac\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+
+}
\ No newline at end of file
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/python3/BasePython3Test.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/python3/BasePython3Test.java
new file mode 100644
index 000000000..fdcbdabb4
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/python3/BasePython3Test.java
@@ -0,0 +1,122 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2012 Terence Parr
+ *  Copyright (c) 2012 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.
+ */
+package org.antlr.v4.test.runtime.python3;
+
+import org.antlr.v4.test.runtime.python.BasePythonTest;
+import org.stringtemplate.v4.ST;
+
+public abstract class BasePython3Test extends BasePythonTest {
+
+	@Override
+	protected String getLanguage() {
+		return "Python3";
+	}
+
+	@Override
+	protected String getPythonExecutable() {
+		return "python3.5";
+	} // force 3.5
+
+	@Override
+	protected void writeLexerTestFile(String lexerName, boolean showDFA) {
+		ST outputFileST = new ST(
+				"import sys\n"
+						+ "from antlr4 import *\n"
+						+ "from <lexerName> import <lexerName>\n"
+						+ "\n"
+						+ "def main(argv):\n"
+						+ "    input = FileStream(argv[1])\n"
+						+ "    lexer = <lexerName>(input)\n"
+						+ "    stream = CommonTokenStream(lexer)\n"
+						+ "    stream.fill()\n"
+						+ "    [ print(str(t)) for t in stream.tokens ]\n"
+						+ (showDFA ? "    print(lexer._interp.decisionToDFA[Lexer.DEFAULT_MODE].toLexerString(), end='')\n"
+								: "") + "\n" + "if __name__ == '__main__':\n"
+						+ "    main(sys.argv)\n" + "\n");
+		outputFileST.add("lexerName", lexerName);
+		writeFile(tmpdir, "Test.py", outputFileST.render());
+	}
+
+	@Override
+	protected void writeParserTestFile(String parserName, String lexerName,
+			String listenerName, String visitorName,
+			String parserStartRuleName, boolean debug, boolean trace) {
+		if(!parserStartRuleName.endsWith(")"))
+			parserStartRuleName += "()";
+		ST outputFileST = new ST(
+				"import sys\n"
+						+ "from antlr4 import *\n"
+						+ "from <lexerName> import <lexerName>\n"
+						+ "from <parserName> import <parserName>\n"
+						+ "from <listenerName> import <listenerName>\n"
+						+ "from <visitorName> import <visitorName>\n"
+						+ "\n"
+						+ "class TreeShapeListener(ParseTreeListener):\n"
+						+ "\n"
+						+ "    def visitTerminal(self, node:TerminalNode):\n"
+						+ "        pass\n"
+						+ "\n"
+						+ "    def visitErrorNode(self, node:ErrorNode):\n"
+						+ "        pass\n"
+						+ "\n"
+						+ "    def exitEveryRule(self, ctx:ParserRuleContext):\n"
+						+ "        pass\n"
+						+ "\n"
+						+ "    def enterEveryRule(self, ctx:ParserRuleContext):\n"
+						+ "        for child in ctx.getChildren():\n"
+						+ "            parent = child.parentCtx\n"
+						+ "            if not isinstance(parent, RuleNode) or parent.getRuleContext() != ctx:\n"
+						+ "                raise IllegalStateException(\"Invalid parse tree shape detected.\")\n"
+						+ "\n"
+						+ "def main(argv):\n"
+						+ "    input = FileStream(argv[1])\n"
+						+ "    lexer = <lexerName>(input)\n"
+						+ "    stream = CommonTokenStream(lexer)\n"
+						+ "<createParser>"
+						+ "    parser.buildParseTrees = True\n"
+						+ "    tree = parser.<parserStartRuleName>\n"
+						+ "    ParseTreeWalker.DEFAULT.walk(TreeShapeListener(), tree)\n"
+						+ "\n" + "if __name__ == '__main__':\n"
+						+ "    main(sys.argv)\n" + "\n");
+		String stSource = "    parser = <parserName>(stream)\n";
+		if (debug)
+			stSource += "    parser.addErrorListener(DiagnosticErrorListener())\n";
+		if (trace)
+			stSource += "    parser.setTrace(True)\n";
+		ST createParserST = new ST(stSource);
+		outputFileST.add("createParser", createParserST);
+		outputFileST.add("parserName", parserName);
+		outputFileST.add("lexerName", lexerName);
+		outputFileST.add("listenerName", listenerName);
+		outputFileST.add("visitorName", visitorName);
+		outputFileST.add("parserStartRuleName", parserStartRuleName);
+		writeFile(tmpdir, "Test.py", outputFileST.render());
+	}
+}
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/python3/TestCompositeLexers.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/python3/TestCompositeLexers.java
new file mode 100644
index 000000000..a665be9f5
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/python3/TestCompositeLexers.java
@@ -0,0 +1,70 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.python3;
+
+import org.junit.Ignore;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+@SuppressWarnings("unused")
+public class TestCompositeLexers extends BasePython3Test {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLexerDelegatorInvokesDelegateRule() throws Exception {
+		mkdir(tmpdir);
+
+		String slave_S =
+			"lexer grammar S;\n" +
+			"A : 'a' {print(\"S.A\")};\n" +
+			"C : 'c' ;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(61);
+		grammarBuilder.append("lexer grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("B : 'b';\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="abc";
+		String found = execLexer("M.g4", grammar, "M", input, false);
+		assertEquals(
+			"S.A\n" +
+			"[@0,0:0='a',<3>,1:0]\n" +
+			"[@1,1:1='b',<1>,1:1]\n" +
+			"[@2,2:2='c',<4>,1:2]\n" +
+			"[@3,3:2='<EOF>',<-1>,1:3]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLexerDelegatorRuleOverridesDelegate() throws Exception {
+		mkdir(tmpdir);
+
+		String slave_S =
+			"lexer grammar S;\n" +
+			"A : 'a' {print(\"S.A\")} ;\n" +
+			"B : 'b' {print(\"S.B\")} ;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(79);
+		grammarBuilder.append("lexer grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("A : 'a' B {print(\"M.A\")} ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="ab";
+		String found = execLexer("M.g4", grammar, "M", input, false);
+		assertEquals(
+			"M.A\n" +
+			"[@0,0:1='ab',<1>,1:0]\n" +
+			"[@1,2:1='<EOF>',<-1>,1:2]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+
+}
\ No newline at end of file
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/python3/TestCompositeParsers.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/python3/TestCompositeParsers.java
new file mode 100644
index 000000000..59d6a9f9c
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/python3/TestCompositeParsers.java
@@ -0,0 +1,488 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.python3;
+
+import org.junit.Ignore;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+import org.antlr.v4.test.runtime.java.ErrorQueue;
+import org.antlr.v4.tool.Grammar;
+
+@SuppressWarnings("unused")
+public class TestCompositeParsers extends BasePython3Test {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testBringInLiteralsFromDelegate() throws Exception {
+		mkdir(tmpdir);
+
+		String slave_S =
+			"parser grammar S;\n" +
+			"a : '=' 'a' {print(\"S.a\",end='')};";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(54);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("s : a ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="=a";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "MListener", "MVisitor", "s", input, false);
+
+		assertEquals("S.a\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCombinedImportsCombined() throws Exception {
+		mkdir(tmpdir);
+
+		String slave_S =
+			"parser grammar S;\n" +
+			"tokens { A, B, C }\n" +
+			"x : 'x' INT {print(\"S.x\")};\n" +
+			"INT : '0'..'9'+ ;\n" +
+			"WS : (' '|'\\n') -> skip ;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(31);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("s : x INT;");
+		String grammar = grammarBuilder.toString();
+
+		writeFile(tmpdir, "M.g4", grammar);
+		ErrorQueue equeue = new ErrorQueue();
+		new Grammar(tmpdir+"/M.g4", grammar, equeue);
+		assertEquals("unexpected errors: " + equeue, 0, equeue.errors.size());
+
+
+		String input ="x 34 9";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "MListener", "MVisitor", "s", input, false);
+
+		assertEquals("S.x\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDelegatesSeeSameTokenType() throws Exception {
+		mkdir(tmpdir);
+
+		String slave_S =
+			"parser grammar S;\n" +
+			"tokens { A, B, C }\n" +
+			"x : A {print(\"S.x\")};";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		String slave_T =
+			"parser grammar T;\n" +
+			"tokens { C, B, A } // reverse order\n" +
+			"y : A {print(\"T.y\")};";
+		writeFile(tmpdir, "T.g4", slave_T);
+
+		StringBuilder grammarBuilder = new StringBuilder(598);
+		grammarBuilder.append("// The lexer will create rules to match letters a, b, c.\n");
+		grammarBuilder.append("// The associated token types A, B, C must have the same value\n");
+		grammarBuilder.append("// and all import'd parsers.  Since ANTLR regenerates all imports\n");
+		grammarBuilder.append("// for use with the delegator M, it can generate the same token type\n");
+		grammarBuilder.append("// mapping in each parser:\n");
+		grammarBuilder.append("// public static final int C=6;\n");
+		grammarBuilder.append("// public static final int EOF=-1;\n");
+		grammarBuilder.append("// public static final int B=5;\n");
+		grammarBuilder.append("// public static final int WS=7;\n");
+		grammarBuilder.append("// public static final int A=4;\n");
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S,T;\n");
+		grammarBuilder.append("s : x y ; // matches AA, which should be 'aa'\n");
+		grammarBuilder.append("B : 'b' ; // another order: B, A, C\n");
+		grammarBuilder.append("A : 'a' ; \n");
+		grammarBuilder.append("C : 'c' ; \n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+		writeFile(tmpdir, "M.g4", grammar);
+		ErrorQueue equeue = new ErrorQueue();
+		Grammar g = new Grammar(tmpdir+"/M.g4", grammar, equeue);
+		String expectedTokenIDToTypeMap = "{EOF=-1, B=1, A=2, C=3, WS=4}";
+		String expectedStringLiteralToTypeMap = "{'a'=2, 'b'=1, 'c'=3}";
+		String expectedTypeToTokenList = "[B, A, C, WS]";
+		assertEquals(expectedTokenIDToTypeMap, g.tokenNameToTypeMap.toString());
+		assertEquals(expectedStringLiteralToTypeMap, sort(g.stringLiteralToTypeMap).toString());
+		assertEquals(expectedTypeToTokenList, realElements(g.typeToTokenList).toString());
+		assertEquals("unexpected errors: "+equeue, 0, equeue.errors.size());
+
+
+		String input ="aa";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "MListener", "MVisitor", "s", input, false);
+
+		assertEquals(
+			"S.x\n" +
+			"T.y\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDelegatorAccessesDelegateMembers() throws Exception {
+		mkdir(tmpdir);
+
+		String slave_S =
+			"parser grammar S;\n" +
+			"@parser::members {\n" +
+			"def foo(self):\n" +
+			"	print('foo')\n" +
+			"}\n" +
+			"a : B;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(126);
+		grammarBuilder.append("grammar M; // uses no rules from the import\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("s : 'b' {self.foo()} ; // gS is import pointer\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="b";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "MListener", "MVisitor", "s", input, false);
+
+		assertEquals("foo\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDelegatorInvokesDelegateRule() throws Exception {
+		mkdir(tmpdir);
+
+		String slave_S =
+			"parser grammar S;\n" +
+			"a : B {print(\"S.a\")};";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(104);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("s : a ;\n");
+		grammarBuilder.append("B : 'b' ; // defines B from inherited token space\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="b";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "MListener", "MVisitor", "s", input, false);
+
+		assertEquals("S.a\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDelegatorInvokesDelegateRuleWithArgs() throws Exception {
+		mkdir(tmpdir);
+
+		String slave_S =
+			"parser grammar S;\n" +
+			"a[int x] returns [int y] : B {print(\"S.a\",end='')} {$y=1000;} ;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(131);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("s : label=a[3] {print($label.y)} ;\n");
+		grammarBuilder.append("B : 'b' ; // defines B from inherited token space\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="b";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "MListener", "MVisitor", "s", input, false);
+
+		assertEquals("S.a1000\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDelegatorInvokesDelegateRuleWithReturnStruct() throws Exception {
+		mkdir(tmpdir);
+
+		String slave_S =
+			"parser grammar S;\n" +
+			"a : B {print(\"S.a\",end='')} ;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(128);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("s : a {print($a.text,end='')} ;\n");
+		grammarBuilder.append("B : 'b' ; // defines B from inherited token space\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="b";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "MListener", "MVisitor", "s", input, false);
+
+		assertEquals("S.ab\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDelegatorInvokesFirstVersionOfDelegateRule() throws Exception {
+		mkdir(tmpdir);
+
+		String slave_S =
+			"parser grammar S;\n" +
+			"a : b {print(\"S.a\")};\n" +
+			"b : B;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		String slave_T =
+			"parser grammar T;\n" +
+			"a : B {print(\"T.a\")};";
+		writeFile(tmpdir, "T.g4", slave_T);
+
+		StringBuilder grammarBuilder = new StringBuilder(106);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S,T;\n");
+		grammarBuilder.append("s : a ;\n");
+		grammarBuilder.append("B : 'b' ; // defines B from inherited token space\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="b";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "MListener", "MVisitor", "s", input, false);
+
+		assertEquals("S.a\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDelegatorRuleOverridesDelegate() throws Exception {
+		mkdir(tmpdir);
+
+		String slave_S =
+			"parser grammar S;\n" +
+			"a : b {print(\"S.a\",end='')};\n" +
+			"b : B ;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(59);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("b : 'b'|'c';\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="c";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "MListener", "MVisitor", "a", input, false);
+
+		assertEquals("S.a\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDelegatorRuleOverridesDelegates() throws Exception {
+		mkdir(tmpdir);
+
+		String slave_S =
+			"parser grammar S;\n" +
+			"a : b {print(\"S.a\")};\n" +
+			"b : 'b' ;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		String slave_T =
+			"parser grammar T;\n" +
+			"tokens { A }\n" +
+			"b : 'b' {print(\"T.b\")};";
+		writeFile(tmpdir, "T.g4", slave_T);
+
+		StringBuilder grammarBuilder = new StringBuilder(81);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S, T;\n");
+		grammarBuilder.append("b : 'b'|'c' {print(\"M.b\")}|B|A;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="c";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "MListener", "MVisitor", "a", input, false);
+
+		assertEquals(
+			"M.b\n" +
+			"S.a\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDelegatorRuleOverridesLookaheadInDelegate() throws Exception {
+		mkdir(tmpdir);
+
+		String slave_S =
+			"parser grammar S;\n" +
+			"type_ : 'int' ;\n" +
+			"decl : type_ ID ';'\n" +
+			"	| type_ ID init ';' {print(\"JavaDecl: \" + $text,end='')};\n" +
+			"init : '=' INT;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(121);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("prog : decl ;\n");
+		grammarBuilder.append("type_ : 'int' | 'float' ;\n");
+		grammarBuilder.append("ID  : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="float x = 3;";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "MListener", "MVisitor", "prog", input, false);
+
+		assertEquals("JavaDecl: floatx=3;\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testImportLexerWithOnlyFragmentRules() throws Exception {
+		mkdir(tmpdir);
+
+		String slave_Unicode =
+			"lexer grammar Unicode;\n" +
+			"\n" +
+			"fragment\n" +
+			"UNICODE_CLASS_Zs    : '\\u0020' | '\\u00A0' | '\\u1680' | '\\u180E'\n" +
+			"                    | '\\u2000'..'\\u200A'\n" +
+			"                    | '\\u202F' | '\\u205F' | '\\u3000'\n" +
+			"                    ;\n";
+		writeFile(tmpdir, "Unicode.g4", slave_Unicode);
+
+		StringBuilder grammarBuilder = new StringBuilder(91);
+		grammarBuilder.append("grammar Test;\n");
+		grammarBuilder.append("import Unicode;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("program : 'test' 'test';\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("WS : (UNICODE_CLASS_Zs)+ -> skip;\n");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="test test";
+		String found = execParser("Test.g4", grammar, "TestParser", "TestLexer", "TestListener", "TestVisitor", "program", input, false);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testImportedGrammarWithEmptyOptions() throws Exception {
+		mkdir(tmpdir);
+
+		String slave_S =
+			"parser grammar S;\n" +
+			"options {}\n" +
+			"a : B ;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(64);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("s : a ;\n");
+		grammarBuilder.append("B : 'b' ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="b";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "MListener", "MVisitor", "s", input, false);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testImportedRuleWithAction() throws Exception {
+		mkdir(tmpdir);
+
+		String slave_S =
+			"parser grammar S;\n" +
+			"a @after {x = 0} : B;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(62);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("s : a;\n");
+		grammarBuilder.append("B : 'b';\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="b";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "MListener", "MVisitor", "s", input, false);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testKeywordVSIDOrder() throws Exception {
+		mkdir(tmpdir);
+
+		String slave_S =
+			"lexer grammar S;\n" +
+			"ID : 'a'..'z'+;";
+		writeFile(tmpdir, "S.g4", slave_S);
+
+		StringBuilder grammarBuilder = new StringBuilder(106);
+		grammarBuilder.append("grammar M;\n");
+		grammarBuilder.append("import S;\n");
+		grammarBuilder.append("a : A {print(\"M.a: \" + str($A))};\n");
+		grammarBuilder.append("A : 'abc' {print(\"M.A\")};\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="abc";
+		String found = execParser("M.g4", grammar, "MParser", "MLexer", "MListener", "MVisitor", "a", input, false);
+
+		assertEquals(
+			"M.A\n" +
+			"M.a: [@0,0:2='abc',<1>,1:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+
+}
\ No newline at end of file
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/python3/TestFullContextParsing.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/python3/TestFullContextParsing.java
new file mode 100644
index 000000000..05a10ea12
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/python3/TestFullContextParsing.java
@@ -0,0 +1,506 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.python3;
+
+import org.junit.Ignore;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+@SuppressWarnings("unused")
+public class TestFullContextParsing extends BasePython3Test {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAmbigYieldsCtxSensitiveDFA() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(100);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {self.dumpDFA()}\n");
+		grammarBuilder.append("	: ID | ID {} ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="abc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, true);
+
+		assertEquals(
+			"Decision 0:\n" +
+			"s0-ID->:s1^=>1\n", found);
+
+		assertEquals("line 1:0 reportAttemptingFullContext d=0 (s), input='abc'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAmbiguityNoLoop() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(206);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("prog\n");
+		grammarBuilder.append("@init {self._interp.predictionMode =  PredictionMode.LL_EXACT_AMBIG_DETECTION}\n");
+		grammarBuilder.append("	: expr expr {print(\"alt 1\")}\n");
+		grammarBuilder.append("	| expr\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("expr: '@'\n");
+		grammarBuilder.append("	| ID '@'\n");
+		grammarBuilder.append("	| ID\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("ID  : [a-z]+ ;\n");
+		grammarBuilder.append("WS  : [ \\r\\n\\t]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a@";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "prog", input, true);
+
+		assertEquals("alt 1\n", found);
+
+		assertEquals(
+			"line 1:2 reportAttemptingFullContext d=0 (prog), input='a@'\n" +
+			"line 1:2 reportAmbiguity d=0 (prog): ambigAlts={1, 2}, input='a@'\n" +
+			"line 1:2 reportAttemptingFullContext d=1 (expr), input='a@'\n" +
+			"line 1:2 reportContextSensitivity d=1 (expr), input='a@'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCtxSensitiveDFATwoDiffInput() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(164);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {self.dumpDFA()}\n");
+		grammarBuilder.append("  : ('$' a | '@' b)+ ;\n");
+		grammarBuilder.append("a : e ID ;\n");
+		grammarBuilder.append("b : e INT ID ;\n");
+		grammarBuilder.append("e : INT | ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="$ 34 abc @ 34 abc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, true);
+
+		assertEquals(
+			"Decision 2:\n" +
+			"s0-INT->s1\n" +
+			"s1-ID->:s2^=>1\n", found);
+
+		assertEquals(
+			"line 1:5 reportAttemptingFullContext d=2 (e), input='34abc'\n" +
+			"line 1:2 reportContextSensitivity d=2 (e), input='34'\n" +
+			"line 1:14 reportAttemptingFullContext d=2 (e), input='34abc'\n" +
+			"line 1:14 reportContextSensitivity d=2 (e), input='34abc'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCtxSensitiveDFA_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(161);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {self.dumpDFA()}\n");
+		grammarBuilder.append("  : '$' a | '@' b ;\n");
+		grammarBuilder.append("a : e ID ;\n");
+		grammarBuilder.append("b : e INT ID ;\n");
+		grammarBuilder.append("e : INT | ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="$ 34 abc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, true);
+
+		assertEquals(
+			"Decision 1:\n" +
+			"s0-INT->s1\n" +
+			"s1-ID->:s2^=>1\n", found);
+
+		assertEquals(
+			"line 1:5 reportAttemptingFullContext d=1 (e), input='34abc'\n" +
+			"line 1:2 reportContextSensitivity d=1 (e), input='34'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCtxSensitiveDFA_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(161);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {self.dumpDFA()}\n");
+		grammarBuilder.append("  : '$' a | '@' b ;\n");
+		grammarBuilder.append("a : e ID ;\n");
+		grammarBuilder.append("b : e INT ID ;\n");
+		grammarBuilder.append("e : INT | ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="@ 34 abc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, true);
+
+		assertEquals(
+			"Decision 1:\n" +
+			"s0-INT->s1\n" +
+			"s1-ID->:s2^=>1\n", found);
+
+		assertEquals(
+			"line 1:5 reportAttemptingFullContext d=1 (e), input='34abc'\n" +
+			"line 1:5 reportContextSensitivity d=1 (e), input='34abc'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExprAmbiguity_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(286);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {self._interp.predictionMode =  PredictionMode.LL_EXACT_AMBIG_DETECTION}\n");
+		grammarBuilder.append(":   expr[0] {print($expr.ctx.toStringTree(recog=self))};\n");
+		grammarBuilder.append("	expr[int _p]\n");
+		grammarBuilder.append("		: ID \n");
+		grammarBuilder.append("		( \n");
+		grammarBuilder.append("			{5 >= $_p}? '*' expr[6]\n");
+		grammarBuilder.append("			| {4 >= $_p}? '+' expr[5]\n");
+		grammarBuilder.append("		)*\n");
+		grammarBuilder.append("		;\n");
+		grammarBuilder.append("ID  : [a-zA-Z]+ ;\n");
+		grammarBuilder.append("WS  : [ \\r\\n\\t]+ -> skip ;\n");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a+b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, true);
+
+		assertEquals("(expr a + (expr b))\n", found);
+
+		assertEquals(
+			"line 1:1 reportAttemptingFullContext d=1 (expr), input='+'\n" +
+			"line 1:2 reportContextSensitivity d=1 (expr), input='+b'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExprAmbiguity_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(286);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {self._interp.predictionMode =  PredictionMode.LL_EXACT_AMBIG_DETECTION}\n");
+		grammarBuilder.append(":   expr[0] {print($expr.ctx.toStringTree(recog=self))};\n");
+		grammarBuilder.append("	expr[int _p]\n");
+		grammarBuilder.append("		: ID \n");
+		grammarBuilder.append("		( \n");
+		grammarBuilder.append("			{5 >= $_p}? '*' expr[6]\n");
+		grammarBuilder.append("			| {4 >= $_p}? '+' expr[5]\n");
+		grammarBuilder.append("		)*\n");
+		grammarBuilder.append("		;\n");
+		grammarBuilder.append("ID  : [a-zA-Z]+ ;\n");
+		grammarBuilder.append("WS  : [ \\r\\n\\t]+ -> skip ;\n");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a+b*c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, true);
+
+		assertEquals("(expr a + (expr b * (expr c)))\n", found);
+
+		assertEquals(
+			"line 1:1 reportAttemptingFullContext d=1 (expr), input='+'\n" +
+			"line 1:2 reportContextSensitivity d=1 (expr), input='+b'\n" +
+			"line 1:3 reportAttemptingFullContext d=1 (expr), input='*'\n" +
+			"line 1:5 reportAmbiguity d=1 (expr): ambigAlts={1, 2}, input='*c'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testFullContextIF_THEN_ELSEParse_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(240);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s \n");
+		grammarBuilder.append("@init {self._interp.predictionMode =  PredictionMode.LL_EXACT_AMBIG_DETECTION}\n");
+		grammarBuilder.append("@after {self.dumpDFA()}\n");
+		grammarBuilder.append("	: '{' stat* '}' ;\n");
+		grammarBuilder.append("stat: 'if' ID 'then' stat ('else' ID)?\n");
+		grammarBuilder.append("		| 'return'\n");
+		grammarBuilder.append("		;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="{ if x then return }";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, true);
+
+		assertEquals(
+			"Decision 1:\n" +
+			"s0-'}'->:s1=>2\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testFullContextIF_THEN_ELSEParse_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(240);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s \n");
+		grammarBuilder.append("@init {self._interp.predictionMode =  PredictionMode.LL_EXACT_AMBIG_DETECTION}\n");
+		grammarBuilder.append("@after {self.dumpDFA()}\n");
+		grammarBuilder.append("	: '{' stat* '}' ;\n");
+		grammarBuilder.append("stat: 'if' ID 'then' stat ('else' ID)?\n");
+		grammarBuilder.append("		| 'return'\n");
+		grammarBuilder.append("		;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="{ if x then return else foo }";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, true);
+
+		assertEquals(
+			"Decision 1:\n" +
+			"s0-'else'->:s1^=>1\n", found);
+
+		assertEquals(
+			"line 1:19 reportAttemptingFullContext d=1 (stat), input='else'\n" +
+			"line 1:19 reportContextSensitivity d=1 (stat), input='else'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testFullContextIF_THEN_ELSEParse_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(240);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s \n");
+		grammarBuilder.append("@init {self._interp.predictionMode =  PredictionMode.LL_EXACT_AMBIG_DETECTION}\n");
+		grammarBuilder.append("@after {self.dumpDFA()}\n");
+		grammarBuilder.append("	: '{' stat* '}' ;\n");
+		grammarBuilder.append("stat: 'if' ID 'then' stat ('else' ID)?\n");
+		grammarBuilder.append("		| 'return'\n");
+		grammarBuilder.append("		;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="{ if x then if y then return else foo }";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, true);
+
+		assertEquals(
+			"Decision 1:\n" +
+			"s0-'}'->:s2=>2\n" +
+			"s0-'else'->:s1^=>1\n", found);
+
+		assertEquals(
+			"line 1:29 reportAttemptingFullContext d=1 (stat), input='else'\n" +
+			"line 1:38 reportAmbiguity d=1 (stat): ambigAlts={1, 2}, input='elsefoo}'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testFullContextIF_THEN_ELSEParse_4() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(240);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s \n");
+		grammarBuilder.append("@init {self._interp.predictionMode =  PredictionMode.LL_EXACT_AMBIG_DETECTION}\n");
+		grammarBuilder.append("@after {self.dumpDFA()}\n");
+		grammarBuilder.append("	: '{' stat* '}' ;\n");
+		grammarBuilder.append("stat: 'if' ID 'then' stat ('else' ID)?\n");
+		grammarBuilder.append("		| 'return'\n");
+		grammarBuilder.append("		;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="{ if x then if y then return else foo else bar }";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, true);
+
+		assertEquals(
+			"Decision 1:\n" +
+			"s0-'else'->:s1^=>1\n", found);
+
+		assertEquals(
+			"line 1:29 reportAttemptingFullContext d=1 (stat), input='else'\n" +
+			"line 1:38 reportContextSensitivity d=1 (stat), input='elsefooelse'\n" +
+			"line 1:38 reportAttemptingFullContext d=1 (stat), input='else'\n" +
+			"line 1:38 reportContextSensitivity d=1 (stat), input='else'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testFullContextIF_THEN_ELSEParse_5() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(240);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s \n");
+		grammarBuilder.append("@init {self._interp.predictionMode =  PredictionMode.LL_EXACT_AMBIG_DETECTION}\n");
+		grammarBuilder.append("@after {self.dumpDFA()}\n");
+		grammarBuilder.append("	: '{' stat* '}' ;\n");
+		grammarBuilder.append("stat: 'if' ID 'then' stat ('else' ID)?\n");
+		grammarBuilder.append("		| 'return'\n");
+		grammarBuilder.append("		;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input =
+			"{ if x then return else foo\n" +
+			"if x then if y then return else foo }";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, true);
+
+		assertEquals(
+			"Decision 1:\n" +
+			"s0-'}'->:s2=>2\n" +
+			"s0-'else'->:s1^=>1\n", found);
+
+		assertEquals(
+			"line 1:19 reportAttemptingFullContext d=1 (stat), input='else'\n" +
+			"line 1:19 reportContextSensitivity d=1 (stat), input='else'\n" +
+			"line 2:27 reportAttemptingFullContext d=1 (stat), input='else'\n" +
+			"line 2:36 reportAmbiguity d=1 (stat): ambigAlts={1, 2}, input='elsefoo}'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testFullContextIF_THEN_ELSEParse_6() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(240);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s \n");
+		grammarBuilder.append("@init {self._interp.predictionMode =  PredictionMode.LL_EXACT_AMBIG_DETECTION}\n");
+		grammarBuilder.append("@after {self.dumpDFA()}\n");
+		grammarBuilder.append("	: '{' stat* '}' ;\n");
+		grammarBuilder.append("stat: 'if' ID 'then' stat ('else' ID)?\n");
+		grammarBuilder.append("		| 'return'\n");
+		grammarBuilder.append("		;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input =
+			"{ if x then return else foo\n" +
+			"if x then if y then return else foo }";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, true);
+
+		assertEquals(
+			"Decision 1:\n" +
+			"s0-'}'->:s2=>2\n" +
+			"s0-'else'->:s1^=>1\n", found);
+
+		assertEquals(
+			"line 1:19 reportAttemptingFullContext d=1 (stat), input='else'\n" +
+			"line 1:19 reportContextSensitivity d=1 (stat), input='else'\n" +
+			"line 2:27 reportAttemptingFullContext d=1 (stat), input='else'\n" +
+			"line 2:36 reportAmbiguity d=1 (stat): ambigAlts={1, 2}, input='elsefoo}'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLoopsSimulateTailRecursion() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(299);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("prog\n");
+		grammarBuilder.append("@init {self._interp.predictionMode =  PredictionMode.LL_EXACT_AMBIG_DETECTION}\n");
+		grammarBuilder.append("	: expr_or_assign*;\n");
+		grammarBuilder.append("expr_or_assign\n");
+		grammarBuilder.append("	: expr '++' {print(\"fail.\")}\n");
+		grammarBuilder.append("	|  expr {print(\"pass: \"+$expr.text)}\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("expr: expr_primary ('<-' ID)?;\n");
+		grammarBuilder.append("expr_primary\n");
+		grammarBuilder.append("	: '(' ID ')'\n");
+		grammarBuilder.append("	| ID '(' ID ')'\n");
+		grammarBuilder.append("	| ID\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("ID  : [a-z]+ ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a(i)<-x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "prog", input, true);
+
+		assertEquals("pass: a(i)<-x\n", found);
+
+		assertEquals(
+			"line 1:3 reportAttemptingFullContext d=3 (expr_primary), input='a(i)'\n" +
+			"line 1:7 reportAmbiguity d=3 (expr_primary): ambigAlts={2, 3}, input='a(i)<-x'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSLLSeesEOFInLLGrammar() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(148);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {self.dumpDFA()}\n");
+		grammarBuilder.append("  : a;\n");
+		grammarBuilder.append("a : e ID ;\n");
+		grammarBuilder.append("b : e INT ID ;\n");
+		grammarBuilder.append("e : INT | ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\t'|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="34 abc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, true);
+
+		assertEquals(
+			"Decision 0:\n" +
+			"s0-INT->s1\n" +
+			"s1-ID->:s2^=>1\n", found);
+
+		assertEquals(
+			"line 1:3 reportAttemptingFullContext d=0 (e), input='34abc'\n" +
+			"line 1:0 reportContextSensitivity d=0 (e), input='34'\n", this.stderrDuringParse);
+
+	}
+
+
+}
\ No newline at end of file
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/python3/TestLeftRecursion.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/python3/TestLeftRecursion.java
new file mode 100644
index 000000000..72e8341a7
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/python3/TestLeftRecursion.java
@@ -0,0 +1,3404 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.python3;
+
+import org.junit.Ignore;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+@SuppressWarnings("unused")
+public class TestLeftRecursion extends BasePython3Test {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAmbigLR_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(705);
+		grammarBuilder.append("grammar Expr;\n");
+		grammarBuilder.append("prog:   stat ;\n");
+		grammarBuilder.append("stat:   expr NEWLINE                # printExpr\n");
+		grammarBuilder.append("    |   ID '=' expr NEWLINE         # assign\n");
+		grammarBuilder.append("    |   NEWLINE                     # blank\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("expr:   expr ('*'|'/') expr      # MulDiv\n");
+		grammarBuilder.append("    |   expr ('+'|'-') expr      # AddSub\n");
+		grammarBuilder.append("    |   INT                      # int\n");
+		grammarBuilder.append("    |   ID                       # id\n");
+		grammarBuilder.append("    |   '(' expr ')'             # parens\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("MUL :   '*' ; // assigns token name to '*' used above in grammar\n");
+		grammarBuilder.append("DIV :   '/' ;\n");
+		grammarBuilder.append("ADD :   '+' ;\n");
+		grammarBuilder.append("SUB :   '-' ;\n");
+		grammarBuilder.append("ID  :   [a-zA-Z]+ ;      // match identifiers\n");
+		grammarBuilder.append("INT :   [0-9]+ ;         // match integers\n");
+		grammarBuilder.append("NEWLINE:'\\r'? '\\n' ;     // return newlines to parser (is end-statement signal)\n");
+		grammarBuilder.append("WS  :   [ \\t]+ -> skip ; // toss out whitespace");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="1\n";
+		String found = execParser("Expr.g4", grammar, "ExprParser", "ExprLexer", "ExprListener", "ExprVisitor", "prog", input, true);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAmbigLR_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(705);
+		grammarBuilder.append("grammar Expr;\n");
+		grammarBuilder.append("prog:   stat ;\n");
+		grammarBuilder.append("stat:   expr NEWLINE                # printExpr\n");
+		grammarBuilder.append("    |   ID '=' expr NEWLINE         # assign\n");
+		grammarBuilder.append("    |   NEWLINE                     # blank\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("expr:   expr ('*'|'/') expr      # MulDiv\n");
+		grammarBuilder.append("    |   expr ('+'|'-') expr      # AddSub\n");
+		grammarBuilder.append("    |   INT                      # int\n");
+		grammarBuilder.append("    |   ID                       # id\n");
+		grammarBuilder.append("    |   '(' expr ')'             # parens\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("MUL :   '*' ; // assigns token name to '*' used above in grammar\n");
+		grammarBuilder.append("DIV :   '/' ;\n");
+		grammarBuilder.append("ADD :   '+' ;\n");
+		grammarBuilder.append("SUB :   '-' ;\n");
+		grammarBuilder.append("ID  :   [a-zA-Z]+ ;      // match identifiers\n");
+		grammarBuilder.append("INT :   [0-9]+ ;         // match integers\n");
+		grammarBuilder.append("NEWLINE:'\\r'? '\\n' ;     // return newlines to parser (is end-statement signal)\n");
+		grammarBuilder.append("WS  :   [ \\t]+ -> skip ; // toss out whitespace");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a = 5\n";
+		String found = execParser("Expr.g4", grammar, "ExprParser", "ExprLexer", "ExprListener", "ExprVisitor", "prog", input, true);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAmbigLR_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(705);
+		grammarBuilder.append("grammar Expr;\n");
+		grammarBuilder.append("prog:   stat ;\n");
+		grammarBuilder.append("stat:   expr NEWLINE                # printExpr\n");
+		grammarBuilder.append("    |   ID '=' expr NEWLINE         # assign\n");
+		grammarBuilder.append("    |   NEWLINE                     # blank\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("expr:   expr ('*'|'/') expr      # MulDiv\n");
+		grammarBuilder.append("    |   expr ('+'|'-') expr      # AddSub\n");
+		grammarBuilder.append("    |   INT                      # int\n");
+		grammarBuilder.append("    |   ID                       # id\n");
+		grammarBuilder.append("    |   '(' expr ')'             # parens\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("MUL :   '*' ; // assigns token name to '*' used above in grammar\n");
+		grammarBuilder.append("DIV :   '/' ;\n");
+		grammarBuilder.append("ADD :   '+' ;\n");
+		grammarBuilder.append("SUB :   '-' ;\n");
+		grammarBuilder.append("ID  :   [a-zA-Z]+ ;      // match identifiers\n");
+		grammarBuilder.append("INT :   [0-9]+ ;         // match integers\n");
+		grammarBuilder.append("NEWLINE:'\\r'? '\\n' ;     // return newlines to parser (is end-statement signal)\n");
+		grammarBuilder.append("WS  :   [ \\t]+ -> skip ; // toss out whitespace");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="b = 6\n";
+		String found = execParser("Expr.g4", grammar, "ExprParser", "ExprLexer", "ExprListener", "ExprVisitor", "prog", input, true);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAmbigLR_4() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(705);
+		grammarBuilder.append("grammar Expr;\n");
+		grammarBuilder.append("prog:   stat ;\n");
+		grammarBuilder.append("stat:   expr NEWLINE                # printExpr\n");
+		grammarBuilder.append("    |   ID '=' expr NEWLINE         # assign\n");
+		grammarBuilder.append("    |   NEWLINE                     # blank\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("expr:   expr ('*'|'/') expr      # MulDiv\n");
+		grammarBuilder.append("    |   expr ('+'|'-') expr      # AddSub\n");
+		grammarBuilder.append("    |   INT                      # int\n");
+		grammarBuilder.append("    |   ID                       # id\n");
+		grammarBuilder.append("    |   '(' expr ')'             # parens\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("MUL :   '*' ; // assigns token name to '*' used above in grammar\n");
+		grammarBuilder.append("DIV :   '/' ;\n");
+		grammarBuilder.append("ADD :   '+' ;\n");
+		grammarBuilder.append("SUB :   '-' ;\n");
+		grammarBuilder.append("ID  :   [a-zA-Z]+ ;      // match identifiers\n");
+		grammarBuilder.append("INT :   [0-9]+ ;         // match integers\n");
+		grammarBuilder.append("NEWLINE:'\\r'? '\\n' ;     // return newlines to parser (is end-statement signal)\n");
+		grammarBuilder.append("WS  :   [ \\t]+ -> skip ; // toss out whitespace");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a+b*2\n";
+		String found = execParser("Expr.g4", grammar, "ExprParser", "ExprLexer", "ExprListener", "ExprVisitor", "prog", input, true);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAmbigLR_5() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(705);
+		grammarBuilder.append("grammar Expr;\n");
+		grammarBuilder.append("prog:   stat ;\n");
+		grammarBuilder.append("stat:   expr NEWLINE                # printExpr\n");
+		grammarBuilder.append("    |   ID '=' expr NEWLINE         # assign\n");
+		grammarBuilder.append("    |   NEWLINE                     # blank\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("expr:   expr ('*'|'/') expr      # MulDiv\n");
+		grammarBuilder.append("    |   expr ('+'|'-') expr      # AddSub\n");
+		grammarBuilder.append("    |   INT                      # int\n");
+		grammarBuilder.append("    |   ID                       # id\n");
+		grammarBuilder.append("    |   '(' expr ')'             # parens\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("MUL :   '*' ; // assigns token name to '*' used above in grammar\n");
+		grammarBuilder.append("DIV :   '/' ;\n");
+		grammarBuilder.append("ADD :   '+' ;\n");
+		grammarBuilder.append("SUB :   '-' ;\n");
+		grammarBuilder.append("ID  :   [a-zA-Z]+ ;      // match identifiers\n");
+		grammarBuilder.append("INT :   [0-9]+ ;         // match integers\n");
+		grammarBuilder.append("NEWLINE:'\\r'? '\\n' ;     // return newlines to parser (is end-statement signal)\n");
+		grammarBuilder.append("WS  :   [ \\t]+ -> skip ; // toss out whitespace");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="(1+2)*3\n";
+		String found = execParser("Expr.g4", grammar, "ExprParser", "ExprLexer", "ExprListener", "ExprVisitor", "prog", input, true);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDeclarations_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(391);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : declarator EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("declarator\n");
+		grammarBuilder.append("        : declarator '[' e ']'\n");
+		grammarBuilder.append("        | declarator '[' ']'\n");
+		grammarBuilder.append("        | declarator '(' ')'\n");
+		grammarBuilder.append("        | '*' declarator // binds less tight than suffixes\n");
+		grammarBuilder.append("        | '(' declarator ')'\n");
+		grammarBuilder.append("        | ID\n");
+		grammarBuilder.append("        ;\n");
+		grammarBuilder.append("e : INT ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (declarator a) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDeclarations_10() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(391);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : declarator EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("declarator\n");
+		grammarBuilder.append("        : declarator '[' e ']'\n");
+		grammarBuilder.append("        | declarator '[' ']'\n");
+		grammarBuilder.append("        | declarator '(' ')'\n");
+		grammarBuilder.append("        | '*' declarator // binds less tight than suffixes\n");
+		grammarBuilder.append("        | '(' declarator ')'\n");
+		grammarBuilder.append("        | ID\n");
+		grammarBuilder.append("        ;\n");
+		grammarBuilder.append("e : INT ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="(*a)[]";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (declarator (declarator ( (declarator * (declarator a)) )) [ ]) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDeclarations_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(391);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : declarator EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("declarator\n");
+		grammarBuilder.append("        : declarator '[' e ']'\n");
+		grammarBuilder.append("        | declarator '[' ']'\n");
+		grammarBuilder.append("        | declarator '(' ')'\n");
+		grammarBuilder.append("        | '*' declarator // binds less tight than suffixes\n");
+		grammarBuilder.append("        | '(' declarator ')'\n");
+		grammarBuilder.append("        | ID\n");
+		grammarBuilder.append("        ;\n");
+		grammarBuilder.append("e : INT ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="*a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (declarator * (declarator a)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDeclarations_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(391);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : declarator EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("declarator\n");
+		grammarBuilder.append("        : declarator '[' e ']'\n");
+		grammarBuilder.append("        | declarator '[' ']'\n");
+		grammarBuilder.append("        | declarator '(' ')'\n");
+		grammarBuilder.append("        | '*' declarator // binds less tight than suffixes\n");
+		grammarBuilder.append("        | '(' declarator ')'\n");
+		grammarBuilder.append("        | ID\n");
+		grammarBuilder.append("        ;\n");
+		grammarBuilder.append("e : INT ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="**a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (declarator * (declarator * (declarator a))) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDeclarations_4() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(391);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : declarator EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("declarator\n");
+		grammarBuilder.append("        : declarator '[' e ']'\n");
+		grammarBuilder.append("        | declarator '[' ']'\n");
+		grammarBuilder.append("        | declarator '(' ')'\n");
+		grammarBuilder.append("        | '*' declarator // binds less tight than suffixes\n");
+		grammarBuilder.append("        | '(' declarator ')'\n");
+		grammarBuilder.append("        | ID\n");
+		grammarBuilder.append("        ;\n");
+		grammarBuilder.append("e : INT ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a[3]";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (declarator (declarator a) [ (e 3) ]) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDeclarations_5() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(391);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : declarator EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("declarator\n");
+		grammarBuilder.append("        : declarator '[' e ']'\n");
+		grammarBuilder.append("        | declarator '[' ']'\n");
+		grammarBuilder.append("        | declarator '(' ')'\n");
+		grammarBuilder.append("        | '*' declarator // binds less tight than suffixes\n");
+		grammarBuilder.append("        | '(' declarator ')'\n");
+		grammarBuilder.append("        | ID\n");
+		grammarBuilder.append("        ;\n");
+		grammarBuilder.append("e : INT ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="b[]";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (declarator (declarator b) [ ]) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDeclarations_6() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(391);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : declarator EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("declarator\n");
+		grammarBuilder.append("        : declarator '[' e ']'\n");
+		grammarBuilder.append("        | declarator '[' ']'\n");
+		grammarBuilder.append("        | declarator '(' ')'\n");
+		grammarBuilder.append("        | '*' declarator // binds less tight than suffixes\n");
+		grammarBuilder.append("        | '(' declarator ')'\n");
+		grammarBuilder.append("        | ID\n");
+		grammarBuilder.append("        ;\n");
+		grammarBuilder.append("e : INT ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="(a)";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (declarator ( (declarator a) )) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDeclarations_7() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(391);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : declarator EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("declarator\n");
+		grammarBuilder.append("        : declarator '[' e ']'\n");
+		grammarBuilder.append("        | declarator '[' ']'\n");
+		grammarBuilder.append("        | declarator '(' ')'\n");
+		grammarBuilder.append("        | '*' declarator // binds less tight than suffixes\n");
+		grammarBuilder.append("        | '(' declarator ')'\n");
+		grammarBuilder.append("        | ID\n");
+		grammarBuilder.append("        ;\n");
+		grammarBuilder.append("e : INT ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a[]()";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (declarator (declarator (declarator a) [ ]) ( )) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDeclarations_8() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(391);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : declarator EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("declarator\n");
+		grammarBuilder.append("        : declarator '[' e ']'\n");
+		grammarBuilder.append("        | declarator '[' ']'\n");
+		grammarBuilder.append("        | declarator '(' ')'\n");
+		grammarBuilder.append("        | '*' declarator // binds less tight than suffixes\n");
+		grammarBuilder.append("        | '(' declarator ')'\n");
+		grammarBuilder.append("        | ID\n");
+		grammarBuilder.append("        ;\n");
+		grammarBuilder.append("e : INT ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a[][]";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (declarator (declarator (declarator a) [ ]) [ ]) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDeclarations_9() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(391);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : declarator EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("declarator\n");
+		grammarBuilder.append("        : declarator '[' e ']'\n");
+		grammarBuilder.append("        | declarator '[' ']'\n");
+		grammarBuilder.append("        | declarator '(' ')'\n");
+		grammarBuilder.append("        | '*' declarator // binds less tight than suffixes\n");
+		grammarBuilder.append("        | '(' declarator ')'\n");
+		grammarBuilder.append("        | ID\n");
+		grammarBuilder.append("        ;\n");
+		grammarBuilder.append("e : INT ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="*a[]";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (declarator * (declarator (declarator a) [ ])) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDirectCallToLeftRecursiveRule_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(119);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a @after {print($ctx.toStringTree(recog=self))} : a ID\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("(a x)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDirectCallToLeftRecursiveRule_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(119);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a @after {print($ctx.toStringTree(recog=self))} : a ID\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x y";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("(a (a x) y)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDirectCallToLeftRecursiveRule_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(119);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a @after {print($ctx.toStringTree(recog=self))} : a ID\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x y z";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("(a (a (a x) y) z)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExpressions_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(250);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("e : e '.' ID\n");
+		grammarBuilder.append("  | e '.' 'this'\n");
+		grammarBuilder.append("  | '-' e\n");
+		grammarBuilder.append("  | e '*' e\n");
+		grammarBuilder.append("  | e ('+'|'-') e\n");
+		grammarBuilder.append("  | INT\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e a) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExpressions_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(250);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("e : e '.' ID\n");
+		grammarBuilder.append("  | e '.' 'this'\n");
+		grammarBuilder.append("  | '-' e\n");
+		grammarBuilder.append("  | e '*' e\n");
+		grammarBuilder.append("  | e ('+'|'-') e\n");
+		grammarBuilder.append("  | INT\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="1";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e 1) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExpressions_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(250);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("e : e '.' ID\n");
+		grammarBuilder.append("  | e '.' 'this'\n");
+		grammarBuilder.append("  | '-' e\n");
+		grammarBuilder.append("  | e '*' e\n");
+		grammarBuilder.append("  | e ('+'|'-') e\n");
+		grammarBuilder.append("  | INT\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a-1";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e a) - (e 1)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExpressions_4() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(250);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("e : e '.' ID\n");
+		grammarBuilder.append("  | e '.' 'this'\n");
+		grammarBuilder.append("  | '-' e\n");
+		grammarBuilder.append("  | e '*' e\n");
+		grammarBuilder.append("  | e ('+'|'-') e\n");
+		grammarBuilder.append("  | INT\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a.b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e a) . b) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExpressions_5() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(250);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("e : e '.' ID\n");
+		grammarBuilder.append("  | e '.' 'this'\n");
+		grammarBuilder.append("  | '-' e\n");
+		grammarBuilder.append("  | e '*' e\n");
+		grammarBuilder.append("  | e ('+'|'-') e\n");
+		grammarBuilder.append("  | INT\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a.this";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e a) . this) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExpressions_6() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(250);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("e : e '.' ID\n");
+		grammarBuilder.append("  | e '.' 'this'\n");
+		grammarBuilder.append("  | '-' e\n");
+		grammarBuilder.append("  | e '*' e\n");
+		grammarBuilder.append("  | e ('+'|'-') e\n");
+		grammarBuilder.append("  | INT\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="-a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e - (e a)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExpressions_7() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(250);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("e : e '.' ID\n");
+		grammarBuilder.append("  | e '.' 'this'\n");
+		grammarBuilder.append("  | '-' e\n");
+		grammarBuilder.append("  | e '*' e\n");
+		grammarBuilder.append("  | e ('+'|'-') e\n");
+		grammarBuilder.append("  | INT\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="-a+b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e - (e a)) + (e b)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(1247);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a|b&c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e a) | (e (e b) & (e c))) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_10() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(1247);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a.f(x)==T.c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e (e (e a) . f) ( (expressionList (e x)) )) == (e (e T) . c)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_11() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(1247);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a.f().g(x,1)";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e (e (e (e a) . f) ( )) . g) ( (expressionList (e x) , (e 1)) )) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_12() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(1247);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="new T[((n-1) * x) + 1]";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e new (typespec T) [ (e (e ( (e (e ( (e (e n) - (e 1)) )) * (e x)) )) + (e 1)) ]) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(1247);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="(a|b)&c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e ( (e (e a) | (e b)) )) & (e c)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(1247);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a > b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e a) > (e b)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_4() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(1247);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a >> b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e a) >> (e b)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_5() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(1247);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a=b=c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e a) = (e (e b) = (e c))) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_6() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(1247);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a^b^c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e a) ^ (e (e b) ^ (e c))) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_7() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(1247);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="(T)x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e ( (typespec T) ) (e x)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_8() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(1247);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="new A().b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e new (typespec A) ( )) . b) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testJavaExpressions_9() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(1247);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow\n");
+		grammarBuilder.append("expressionList\n");
+		grammarBuilder.append("    :   e (',' e)*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("e   :   '(' e ')'\n");
+		grammarBuilder.append("    |   'this'\n");
+		grammarBuilder.append("    |   'super'\n");
+		grammarBuilder.append("    |   INT\n");
+		grammarBuilder.append("    |   ID\n");
+		grammarBuilder.append("    |   typespec '.' 'class'\n");
+		grammarBuilder.append("    |   e '.' ID\n");
+		grammarBuilder.append("    |   e '.' 'this'\n");
+		grammarBuilder.append("    |   e '.' 'super' '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   e '.' 'new' ID '(' expressionList? ')'\n");
+		grammarBuilder.append("	|   'new' typespec ( '(' expressionList? ')' | ('[' e ']')+)\n");
+		grammarBuilder.append("    |   e '[' e ']'\n");
+		grammarBuilder.append("    |   '(' typespec ')' e\n");
+		grammarBuilder.append("    |   e ('++' | '--')\n");
+		grammarBuilder.append("    |   e '(' expressionList? ')'\n");
+		grammarBuilder.append("    |   ('+'|'-'|'++'|'--') e\n");
+		grammarBuilder.append("    |   ('~'|'!') e\n");
+		grammarBuilder.append("    |   e ('*'|'/'|'%') e\n");
+		grammarBuilder.append("    |   e ('+'|'-') e\n");
+		grammarBuilder.append("    |   e ('<<' | '>>>' | '>>') e\n");
+		grammarBuilder.append("    |   e ('<=' | '>=' | '>' | '<') e\n");
+		grammarBuilder.append("    |   e 'instanceof' e\n");
+		grammarBuilder.append("    |   e ('==' | '!=') e\n");
+		grammarBuilder.append("    |   e '&' e\n");
+		grammarBuilder.append("    |<assoc=right> e '^' e\n");
+		grammarBuilder.append("    |   e '|' e\n");
+		grammarBuilder.append("    |   e '&&' e\n");
+		grammarBuilder.append("    |   e '||' e\n");
+		grammarBuilder.append("    |   e '?' e ':' e\n");
+		grammarBuilder.append("    |<assoc=right>\n");
+		grammarBuilder.append("        e ('='\n");
+		grammarBuilder.append("          |'+='\n");
+		grammarBuilder.append("          |'-='\n");
+		grammarBuilder.append("          |'*='\n");
+		grammarBuilder.append("          |'/='\n");
+		grammarBuilder.append("          |'&='\n");
+		grammarBuilder.append("          |'|='\n");
+		grammarBuilder.append("          |'^='\n");
+		grammarBuilder.append("          |'>>='\n");
+		grammarBuilder.append("          |'>>>='\n");
+		grammarBuilder.append("          |'<<='\n");
+		grammarBuilder.append("          |'%=') e\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("typespec\n");
+		grammarBuilder.append("    : ID\n");
+		grammarBuilder.append("    | ID '[' ']'\n");
+		grammarBuilder.append("    | 'int'\n");
+		grammarBuilder.append("	| 'int' '[' ']'\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="(T)t.f()";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e ( (typespec T) ) (e (e t) . f)) ( )) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLabelsOnOpSubrule_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(170);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e;\n");
+		grammarBuilder.append("e : a=e op=('*'|'/') b=e  {}\n");
+		grammarBuilder.append("  | INT {}\n");
+		grammarBuilder.append("  | '(' x=e ')' {}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="4";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e 4))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLabelsOnOpSubrule_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(170);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e;\n");
+		grammarBuilder.append("e : a=e op=('*'|'/') b=e  {}\n");
+		grammarBuilder.append("  | INT {}\n");
+		grammarBuilder.append("  | '(' x=e ')' {}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="1*2/3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e (e 1) * (e 2)) / (e 3)))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLabelsOnOpSubrule_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(170);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e;\n");
+		grammarBuilder.append("e : a=e op=('*'|'/') b=e  {}\n");
+		grammarBuilder.append("  | INT {}\n");
+		grammarBuilder.append("  | '(' x=e ')' {}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="(1/2)*3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e ( (e (e 1) / (e 2)) )) * (e 3)))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleActionsPredicatesOptions_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(239);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e ;\n");
+		grammarBuilder.append("e : a=e op=('*'|'/') b=e  {}{True}?\n");
+		grammarBuilder.append("  | a=e op=('+'|'-') b=e  {}<p=3>{True}?<fail='Message'>\n");
+		grammarBuilder.append("  | INT {}{}\n");
+		grammarBuilder.append("  | '(' x=e ')' {}{}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="4";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e 4))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleActionsPredicatesOptions_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(239);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e ;\n");
+		grammarBuilder.append("e : a=e op=('*'|'/') b=e  {}{True}?\n");
+		grammarBuilder.append("  | a=e op=('+'|'-') b=e  {}<p=3>{True}?<fail='Message'>\n");
+		grammarBuilder.append("  | INT {}{}\n");
+		grammarBuilder.append("  | '(' x=e ')' {}{}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="1*2/3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e (e 1) * (e 2)) / (e 3)))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleActionsPredicatesOptions_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(239);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e ;\n");
+		grammarBuilder.append("e : a=e op=('*'|'/') b=e  {}{True}?\n");
+		grammarBuilder.append("  | a=e op=('+'|'-') b=e  {}<p=3>{True}?<fail='Message'>\n");
+		grammarBuilder.append("  | INT {}{}\n");
+		grammarBuilder.append("  | '(' x=e ')' {}{}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="(1/2)*3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e ( (e (e 1) / (e 2)) )) * (e 3)))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleActions_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(177);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e ;\n");
+		grammarBuilder.append("e : a=e op=('*'|'/') b=e  {}{}\n");
+		grammarBuilder.append("  | INT {}{}\n");
+		grammarBuilder.append("  | '(' x=e ')' {}{}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="4";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e 4))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleActions_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(177);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e ;\n");
+		grammarBuilder.append("e : a=e op=('*'|'/') b=e  {}{}\n");
+		grammarBuilder.append("  | INT {}{}\n");
+		grammarBuilder.append("  | '(' x=e ')' {}{}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="1*2/3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e (e 1) * (e 2)) / (e 3)))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleActions_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(177);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e ;\n");
+		grammarBuilder.append("e : a=e op=('*'|'/') b=e  {}{}\n");
+		grammarBuilder.append("  | INT {}{}\n");
+		grammarBuilder.append("  | '(' x=e ')' {}{}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="(1/2)*3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e ( (e (e 1) / (e 2)) )) * (e 3)))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleAlternativesWithCommonLabel_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(561);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {print($e.v)};\n");
+		grammarBuilder.append("e returns [int v]\n");
+		grammarBuilder.append("  : e '*' e     {$v = $ctx.e(0).v * $ctx.e(1).v;}  # binary\n");
+		grammarBuilder.append("  | e '+' e     {$v = $ctx.e(0).v + $ctx.e(1).v;}  # binary\n");
+		grammarBuilder.append("  | INT         {$v = $INT.int;}                   # anInt\n");
+		grammarBuilder.append("  | '(' e ')'   {$v = $e.v;}                       # parens\n");
+		grammarBuilder.append("  | left=e INC  {$v = $left.v + 1;}      # unary\n");
+		grammarBuilder.append("  | left=e DEC  {$v = $left.v - 1;}      # unary\n");
+		grammarBuilder.append("  | ID          {$v = 3}                                                     # anID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("INC : '++' ;\n");
+		grammarBuilder.append("DEC : '--' ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="4";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("4\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleAlternativesWithCommonLabel_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(561);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {print($e.v)};\n");
+		grammarBuilder.append("e returns [int v]\n");
+		grammarBuilder.append("  : e '*' e     {$v = $ctx.e(0).v * $ctx.e(1).v;}  # binary\n");
+		grammarBuilder.append("  | e '+' e     {$v = $ctx.e(0).v + $ctx.e(1).v;}  # binary\n");
+		grammarBuilder.append("  | INT         {$v = $INT.int;}                   # anInt\n");
+		grammarBuilder.append("  | '(' e ')'   {$v = $e.v;}                       # parens\n");
+		grammarBuilder.append("  | left=e INC  {$v = $left.v + 1;}      # unary\n");
+		grammarBuilder.append("  | left=e DEC  {$v = $left.v - 1;}      # unary\n");
+		grammarBuilder.append("  | ID          {$v = 3}                                                     # anID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("INC : '++' ;\n");
+		grammarBuilder.append("DEC : '--' ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="1+2";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("3\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleAlternativesWithCommonLabel_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(561);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {print($e.v)};\n");
+		grammarBuilder.append("e returns [int v]\n");
+		grammarBuilder.append("  : e '*' e     {$v = $ctx.e(0).v * $ctx.e(1).v;}  # binary\n");
+		grammarBuilder.append("  | e '+' e     {$v = $ctx.e(0).v + $ctx.e(1).v;}  # binary\n");
+		grammarBuilder.append("  | INT         {$v = $INT.int;}                   # anInt\n");
+		grammarBuilder.append("  | '(' e ')'   {$v = $e.v;}                       # parens\n");
+		grammarBuilder.append("  | left=e INC  {$v = $left.v + 1;}      # unary\n");
+		grammarBuilder.append("  | left=e DEC  {$v = $left.v - 1;}      # unary\n");
+		grammarBuilder.append("  | ID          {$v = 3}                                                     # anID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("INC : '++' ;\n");
+		grammarBuilder.append("DEC : '--' ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="1+2*3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("7\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleAlternativesWithCommonLabel_4() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(561);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {print($e.v)};\n");
+		grammarBuilder.append("e returns [int v]\n");
+		grammarBuilder.append("  : e '*' e     {$v = $ctx.e(0).v * $ctx.e(1).v;}  # binary\n");
+		grammarBuilder.append("  | e '+' e     {$v = $ctx.e(0).v + $ctx.e(1).v;}  # binary\n");
+		grammarBuilder.append("  | INT         {$v = $INT.int;}                   # anInt\n");
+		grammarBuilder.append("  | '(' e ')'   {$v = $e.v;}                       # parens\n");
+		grammarBuilder.append("  | left=e INC  {$v = $left.v + 1;}      # unary\n");
+		grammarBuilder.append("  | left=e DEC  {$v = $left.v - 1;}      # unary\n");
+		grammarBuilder.append("  | ID          {$v = 3}                                                     # anID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("INC : '++' ;\n");
+		grammarBuilder.append("DEC : '--' ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="i++*3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("12\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPrecedenceFilterConsidersContext() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(142);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("prog \n");
+		grammarBuilder.append("@after {print($ctx.toStringTree(recog=self))}\n");
+		grammarBuilder.append(": statement* EOF {};\n");
+		grammarBuilder.append("statement: letterA | statement letterA 'b' ;\n");
+		grammarBuilder.append("letterA: 'a';");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="aa";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "prog", input, false);
+
+		assertEquals("(prog (statement (letterA a)) (statement (letterA a)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPrefixAndOtherAlt_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(216);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : expr EOF ; \n");
+		grammarBuilder.append("expr : literal\n");
+		grammarBuilder.append("     | op expr\n");
+		grammarBuilder.append("     | expr op expr\n");
+		grammarBuilder.append("     ;\n");
+		grammarBuilder.append("literal : '-'? Integer ;\n");
+		grammarBuilder.append("op : '+' | '-' ;\n");
+		grammarBuilder.append("Integer : [0-9]+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="-1";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (expr (literal - 1)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPrefixAndOtherAlt_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(216);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : expr EOF ; \n");
+		grammarBuilder.append("expr : literal\n");
+		grammarBuilder.append("     | op expr\n");
+		grammarBuilder.append("     | expr op expr\n");
+		grammarBuilder.append("     ;\n");
+		grammarBuilder.append("literal : '-'? Integer ;\n");
+		grammarBuilder.append("op : '+' | '-' ;\n");
+		grammarBuilder.append("Integer : [0-9]+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="-1 + -1";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (expr (expr (literal - 1)) (op +) (expr (literal - 1))) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPrefixOpWithActionAndLabel_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(329);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {print($e.result)} ;\n");
+		grammarBuilder.append("e returns [String result]\n");
+		grammarBuilder.append("    :   ID '=' e1=e    {$result = \"(\" + $ID.text + \"=\" + $e1.result + \")\";}\n");
+		grammarBuilder.append("    |   ID             {$result = $ID.text;}\n");
+		grammarBuilder.append("    |   e1=e '+' e2=e  {$result = \"(\" + $e1.result + \"+\" + $e2.result + \")\";}\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("a\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPrefixOpWithActionAndLabel_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(329);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {print($e.result)} ;\n");
+		grammarBuilder.append("e returns [String result]\n");
+		grammarBuilder.append("    :   ID '=' e1=e    {$result = \"(\" + $ID.text + \"=\" + $e1.result + \")\";}\n");
+		grammarBuilder.append("    |   ID             {$result = $ID.text;}\n");
+		grammarBuilder.append("    |   e1=e '+' e2=e  {$result = \"(\" + $e1.result + \"+\" + $e2.result + \")\";}\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a+b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(a+b)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPrefixOpWithActionAndLabel_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(329);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {print($e.result)} ;\n");
+		grammarBuilder.append("e returns [String result]\n");
+		grammarBuilder.append("    :   ID '=' e1=e    {$result = \"(\" + $ID.text + \"=\" + $e1.result + \")\";}\n");
+		grammarBuilder.append("    |   ID             {$result = $ID.text;}\n");
+		grammarBuilder.append("    |   e1=e '+' e2=e  {$result = \"(\" + $e1.result + \"+\" + $e2.result + \")\";}\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a=b+c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("((a=b)+c)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsAndLabels_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(447);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : q=e {print($e.v)}; \n");
+		grammarBuilder.append("e returns [int v]\n");
+		grammarBuilder.append("  : a=e op='*' b=e {$v = $a.v * $b.v;}  # mult\n");
+		grammarBuilder.append("  | a=e '+' b=e {$v = $a.v + $b.v;}     # add\n");
+		grammarBuilder.append("  | INT         {$v = $INT.int;}        # anInt\n");
+		grammarBuilder.append("  | '(' x=e ')' {$v = $x.v;}            # parens\n");
+		grammarBuilder.append("  | x=e '++'    {$v = $x.v+1;}          # inc\n");
+		grammarBuilder.append("  | e '--'                              # dec\n");
+		grammarBuilder.append("  | ID          {$v = 3;}               # anID\n");
+		grammarBuilder.append("  ; \n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="4";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("4\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsAndLabels_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(447);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : q=e {print($e.v)}; \n");
+		grammarBuilder.append("e returns [int v]\n");
+		grammarBuilder.append("  : a=e op='*' b=e {$v = $a.v * $b.v;}  # mult\n");
+		grammarBuilder.append("  | a=e '+' b=e {$v = $a.v + $b.v;}     # add\n");
+		grammarBuilder.append("  | INT         {$v = $INT.int;}        # anInt\n");
+		grammarBuilder.append("  | '(' x=e ')' {$v = $x.v;}            # parens\n");
+		grammarBuilder.append("  | x=e '++'    {$v = $x.v+1;}          # inc\n");
+		grammarBuilder.append("  | e '--'                              # dec\n");
+		grammarBuilder.append("  | ID          {$v = 3;}               # anID\n");
+		grammarBuilder.append("  ; \n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="1+2";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("3\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsAndLabels_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(447);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : q=e {print($e.v)}; \n");
+		grammarBuilder.append("e returns [int v]\n");
+		grammarBuilder.append("  : a=e op='*' b=e {$v = $a.v * $b.v;}  # mult\n");
+		grammarBuilder.append("  | a=e '+' b=e {$v = $a.v + $b.v;}     # add\n");
+		grammarBuilder.append("  | INT         {$v = $INT.int;}        # anInt\n");
+		grammarBuilder.append("  | '(' x=e ')' {$v = $x.v;}            # parens\n");
+		grammarBuilder.append("  | x=e '++'    {$v = $x.v+1;}          # inc\n");
+		grammarBuilder.append("  | e '--'                              # dec\n");
+		grammarBuilder.append("  | ID          {$v = 3;}               # anID\n");
+		grammarBuilder.append("  ; \n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="1+2*3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("7\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsAndLabels_4() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(447);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : q=e {print($e.v)}; \n");
+		grammarBuilder.append("e returns [int v]\n");
+		grammarBuilder.append("  : a=e op='*' b=e {$v = $a.v * $b.v;}  # mult\n");
+		grammarBuilder.append("  | a=e '+' b=e {$v = $a.v + $b.v;}     # add\n");
+		grammarBuilder.append("  | INT         {$v = $INT.int;}        # anInt\n");
+		grammarBuilder.append("  | '(' x=e ')' {$v = $x.v;}            # parens\n");
+		grammarBuilder.append("  | x=e '++'    {$v = $x.v+1;}          # inc\n");
+		grammarBuilder.append("  | e '--'                              # dec\n");
+		grammarBuilder.append("  | ID          {$v = 3;}               # anID\n");
+		grammarBuilder.append("  ; \n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="i++*3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("12\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsList1_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(300);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : expr EOF;\n");
+		grammarBuilder.append("expr:\n");
+		grammarBuilder.append("    a=expr '*' a=expr #Factor\n");
+		grammarBuilder.append("    | b+=expr (',' b+=expr)* '>>' c=expr #Send\n");
+		grammarBuilder.append("    | ID #JustId //semantic check on modifiers\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("ID  : ('a'..'z'|'A'..'Z'|'_')\n");
+		grammarBuilder.append("      ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a*b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (expr (expr a) * (expr b)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsList1_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(300);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : expr EOF;\n");
+		grammarBuilder.append("expr:\n");
+		grammarBuilder.append("    a=expr '*' a=expr #Factor\n");
+		grammarBuilder.append("    | b+=expr (',' b+=expr)* '>>' c=expr #Send\n");
+		grammarBuilder.append("    | ID #JustId //semantic check on modifiers\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("ID  : ('a'..'z'|'A'..'Z'|'_')\n");
+		grammarBuilder.append("      ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a,c>>x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (expr (expr a) , (expr c) >> (expr x)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsList1_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(300);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : expr EOF;\n");
+		grammarBuilder.append("expr:\n");
+		grammarBuilder.append("    a=expr '*' a=expr #Factor\n");
+		grammarBuilder.append("    | b+=expr (',' b+=expr)* '>>' c=expr #Send\n");
+		grammarBuilder.append("    | ID #JustId //semantic check on modifiers\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("ID  : ('a'..'z'|'A'..'Z'|'_')\n");
+		grammarBuilder.append("      ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (expr x) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsList1_4() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(300);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : expr EOF;\n");
+		grammarBuilder.append("expr:\n");
+		grammarBuilder.append("    a=expr '*' a=expr #Factor\n");
+		grammarBuilder.append("    | b+=expr (',' b+=expr)* '>>' c=expr #Send\n");
+		grammarBuilder.append("    | ID #JustId //semantic check on modifiers\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("ID  : ('a'..'z'|'A'..'Z'|'_')\n");
+		grammarBuilder.append("      ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a*b,c,x*y>>r";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (expr (expr (expr a) * (expr b)) , (expr c) , (expr (expr x) * (expr y)) >> (expr r)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsList2_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(317);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : expr EOF;\n");
+		grammarBuilder.append("expr:\n");
+		grammarBuilder.append("    a=expr '*' a=expr #Factor\n");
+		grammarBuilder.append("    | b+=expr ',' b+=expr #Comma\n");
+		grammarBuilder.append("    | b+=expr '>>' c=expr #Send\n");
+		grammarBuilder.append("    | ID #JustId //semantic check on modifiers\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("ID  : ('a'..'z'|'A'..'Z'|'_')\n");
+		grammarBuilder.append("      ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a*b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (expr (expr a) * (expr b)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsList2_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(317);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : expr EOF;\n");
+		grammarBuilder.append("expr:\n");
+		grammarBuilder.append("    a=expr '*' a=expr #Factor\n");
+		grammarBuilder.append("    | b+=expr ',' b+=expr #Comma\n");
+		grammarBuilder.append("    | b+=expr '>>' c=expr #Send\n");
+		grammarBuilder.append("    | ID #JustId //semantic check on modifiers\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("ID  : ('a'..'z'|'A'..'Z'|'_')\n");
+		grammarBuilder.append("      ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a,c>>x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (expr (expr (expr a) , (expr c)) >> (expr x)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsList2_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(317);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : expr EOF;\n");
+		grammarBuilder.append("expr:\n");
+		grammarBuilder.append("    a=expr '*' a=expr #Factor\n");
+		grammarBuilder.append("    | b+=expr ',' b+=expr #Comma\n");
+		grammarBuilder.append("    | b+=expr '>>' c=expr #Send\n");
+		grammarBuilder.append("    | ID #JustId //semantic check on modifiers\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("ID  : ('a'..'z'|'A'..'Z'|'_')\n");
+		grammarBuilder.append("      ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (expr x) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActionsList2_4() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(317);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : expr EOF;\n");
+		grammarBuilder.append("expr:\n");
+		grammarBuilder.append("    a=expr '*' a=expr #Factor\n");
+		grammarBuilder.append("    | b+=expr ',' b+=expr #Comma\n");
+		grammarBuilder.append("    | b+=expr '>>' c=expr #Send\n");
+		grammarBuilder.append("    | ID #JustId //semantic check on modifiers\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("ID  : ('a'..'z'|'A'..'Z'|'_')\n");
+		grammarBuilder.append("      ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a*b,c,x*y>>r";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (expr (expr (expr (expr (expr a) * (expr b)) , (expr c)) , (expr (expr x) * (expr y))) >> (expr r)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActions_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(235);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {print($e.v)}; \n");
+		grammarBuilder.append("e returns [int v,  ignored]\n");
+		grammarBuilder.append("  : a=e '*' b=e {$v = $a.v * $b.v;}\n");
+		grammarBuilder.append("  | a=e '+' b=e {$v = $a.v + $b.v;}\n");
+		grammarBuilder.append("  | INT {$v = $INT.int;}\n");
+		grammarBuilder.append("  | '(' x=e ')' {$v = $x.v;}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;\n");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="4";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("4\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActions_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(235);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {print($e.v)}; \n");
+		grammarBuilder.append("e returns [int v,  ignored]\n");
+		grammarBuilder.append("  : a=e '*' b=e {$v = $a.v * $b.v;}\n");
+		grammarBuilder.append("  | a=e '+' b=e {$v = $a.v + $b.v;}\n");
+		grammarBuilder.append("  | INT {$v = $INT.int;}\n");
+		grammarBuilder.append("  | '(' x=e ')' {$v = $x.v;}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;\n");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="1+2";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("3\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActions_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(235);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {print($e.v)}; \n");
+		grammarBuilder.append("e returns [int v,  ignored]\n");
+		grammarBuilder.append("  : a=e '*' b=e {$v = $a.v * $b.v;}\n");
+		grammarBuilder.append("  | a=e '+' b=e {$v = $a.v + $b.v;}\n");
+		grammarBuilder.append("  | INT {$v = $INT.int;}\n");
+		grammarBuilder.append("  | '(' x=e ')' {$v = $x.v;}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;\n");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="1+2*3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("7\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReturnValueAndActions_4() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(235);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e {print($e.v)}; \n");
+		grammarBuilder.append("e returns [int v,  ignored]\n");
+		grammarBuilder.append("  : a=e '*' b=e {$v = $a.v * $b.v;}\n");
+		grammarBuilder.append("  | a=e '+' b=e {$v = $a.v + $b.v;}\n");
+		grammarBuilder.append("  | INT {$v = $INT.int;}\n");
+		grammarBuilder.append("  | '(' x=e ')' {$v = $x.v;}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;\n");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="(1+2)*3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("9\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSemPred() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(135);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : a ;\n");
+		grammarBuilder.append("a : a {True}? ID\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x y z";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (a (a (a x) y) z))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSemPredFailOption() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(159);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : a ;\n");
+		grammarBuilder.append("a : a ID {False}?<fail='custom message'>\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x y z";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (a (a x) y z))\n", found);
+
+		assertEquals("line 1:4 rule a custom message\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSimple_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(127);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : a ;\n");
+		grammarBuilder.append("a : a ID\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (a x))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSimple_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(127);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : a ;\n");
+		grammarBuilder.append("a : a ID\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x y";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (a (a x) y))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSimple_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(127);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : a ;\n");
+		grammarBuilder.append("a : a ID\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x y z";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (a (a (a x) y) z))\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExprExplicitAssociativity_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(283);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e :<assoc=right> e '*' e\n");
+		grammarBuilder.append("  |<assoc=right> e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e a) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExprExplicitAssociativity_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(283);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e :<assoc=right> e '*' e\n");
+		grammarBuilder.append("  |<assoc=right> e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a+b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e a) + (e b)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExprExplicitAssociativity_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(283);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e :<assoc=right> e '*' e\n");
+		grammarBuilder.append("  |<assoc=right> e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a*b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e a) * (e b)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExprExplicitAssociativity_4() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(283);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e :<assoc=right> e '*' e\n");
+		grammarBuilder.append("  |<assoc=right> e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a?b:c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e a) ? (e b) : (e c)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExprExplicitAssociativity_5() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(283);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e :<assoc=right> e '*' e\n");
+		grammarBuilder.append("  |<assoc=right> e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a=b=c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e a) = (e (e b) = (e c))) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExprExplicitAssociativity_6() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(283);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e :<assoc=right> e '*' e\n");
+		grammarBuilder.append("  |<assoc=right> e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a?b+c:d";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e a) ? (e (e b) + (e c)) : (e d)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExprExplicitAssociativity_7() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(283);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e :<assoc=right> e '*' e\n");
+		grammarBuilder.append("  |<assoc=right> e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a?b=c:d";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e a) ? (e (e b) = (e c)) : (e d)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExprExplicitAssociativity_8() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(283);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e :<assoc=right> e '*' e\n");
+		grammarBuilder.append("  |<assoc=right> e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a? b?c:d : e";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e a) ? (e (e b) ? (e c) : (e d)) : (e e)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExprExplicitAssociativity_9() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(283);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e :<assoc=right> e '*' e\n");
+		grammarBuilder.append("  |<assoc=right> e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a?b: c?d:e";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e a) ? (e b) : (e (e c) ? (e d) : (e e))) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExpr_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(258);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e : e '*' e\n");
+		grammarBuilder.append("  | e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e a) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExpr_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(258);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e : e '*' e\n");
+		grammarBuilder.append("  | e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a+b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e a) + (e b)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExpr_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(258);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e : e '*' e\n");
+		grammarBuilder.append("  | e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a*b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e a) * (e b)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExpr_4() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(258);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e : e '*' e\n");
+		grammarBuilder.append("  | e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a?b:c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e a) ? (e b) : (e c)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExpr_5() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(258);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e : e '*' e\n");
+		grammarBuilder.append("  | e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a=b=c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e a) = (e (e b) = (e c))) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExpr_6() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(258);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e : e '*' e\n");
+		grammarBuilder.append("  | e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a?b+c:d";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e a) ? (e (e b) + (e c)) : (e d)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExpr_7() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(258);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e : e '*' e\n");
+		grammarBuilder.append("  | e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a?b=c:d";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e a) ? (e (e b) = (e c)) : (e d)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExpr_8() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(258);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e : e '*' e\n");
+		grammarBuilder.append("  | e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a? b?c:d : e";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e a) ? (e (e b) ? (e c) : (e d)) : (e e)) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTernaryExpr_9() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(258);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s @after {print($ctx.toStringTree(recog=self))} : e EOF ; // must indicate EOF can follow or 'a<EOF>' won't match\n");
+		grammarBuilder.append("e : e '*' e\n");
+		grammarBuilder.append("  | e '+' e\n");
+		grammarBuilder.append("  |<assoc=right> e '?' e ':' e\n");
+		grammarBuilder.append("  |<assoc=right> e '=' e\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a?b: c?d:e";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(s (e (e a) ? (e b) : (e (e c) ? (e d) : (e e))) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testWhitespaceInfluence_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(2763);
+		grammarBuilder.append("grammar Expr;\n");
+		grammarBuilder.append("prog : expression EOF;\n");
+		grammarBuilder.append("expression\n");
+		grammarBuilder.append("    : ID '(' expression (',' expression)* ')'               # doFunction\n");
+		grammarBuilder.append("    | '(' expression ')'                                    # doParenthesis\n");
+		grammarBuilder.append("    | '!' expression                                        # doNot\n");
+		grammarBuilder.append("    | '-' expression                                        # doNegate\n");
+		grammarBuilder.append("    | '+' expression                                        # doPositiv\n");
+		grammarBuilder.append("    | expression '^' expression                             # doPower\n");
+		grammarBuilder.append("    | expression '*' expression                             # doMultipy\n");
+		grammarBuilder.append("    | expression '/' expression                             # doDivide\n");
+		grammarBuilder.append("    | expression '%' expression                             # doModulo\n");
+		grammarBuilder.append("    | expression '-' expression                             # doMinus\n");
+		grammarBuilder.append("    | expression '+' expression                             # doPlus\n");
+		grammarBuilder.append("    | expression '=' expression                             # doEqual\n");
+		grammarBuilder.append("    | expression '!=' expression                            # doNotEqual\n");
+		grammarBuilder.append("    | expression '>' expression                             # doGreather\n");
+		grammarBuilder.append("    | expression '>=' expression                            # doGreatherEqual\n");
+		grammarBuilder.append("    | expression '<' expression                             # doLesser\n");
+		grammarBuilder.append("    | expression '<=' expression                            # doLesserEqual\n");
+		grammarBuilder.append("    | expression K_IN '(' expression (',' expression)* ')'  # doIn\n");
+		grammarBuilder.append("    | expression ( '&' | K_AND) expression                  # doAnd\n");
+		grammarBuilder.append("    | expression ( '|' | K_OR) expression                   # doOr\n");
+		grammarBuilder.append("    | '[' expression (',' expression)* ']'                  # newArray\n");
+		grammarBuilder.append("    | K_TRUE                                                # newTrueBoolean\n");
+		grammarBuilder.append("    | K_FALSE                                               # newFalseBoolean\n");
+		grammarBuilder.append("    | NUMBER                                                # newNumber\n");
+		grammarBuilder.append("    | DATE                                                  # newDateTime\n");
+		grammarBuilder.append("    | ID                                                    # newIdentifier\n");
+		grammarBuilder.append("    | SQ_STRING                                             # newString\n");
+		grammarBuilder.append("    | K_NULL                                                # newNull\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("// Fragments\n");
+		grammarBuilder.append("fragment DIGIT    : '0' .. '9';  \n");
+		grammarBuilder.append("fragment UPPER    : 'A' .. 'Z';\n");
+		grammarBuilder.append("fragment LOWER    : 'a' .. 'z';\n");
+		grammarBuilder.append("fragment LETTER   : LOWER | UPPER;\n");
+		grammarBuilder.append("fragment WORD     : LETTER | '_' | '$' | '#' | '.';\n");
+		grammarBuilder.append("fragment ALPHANUM : WORD | DIGIT;  \n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("// Tokens\n");
+		grammarBuilder.append("ID              : LETTER ALPHANUM*;\n");
+		grammarBuilder.append("NUMBER          : DIGIT+ ('.' DIGIT+)? (('e'|'E')('+'|'-')? DIGIT+)?;\n");
+		grammarBuilder.append("DATE            : '\\'' DIGIT DIGIT DIGIT DIGIT '-' DIGIT DIGIT '-' DIGIT DIGIT (' ' DIGIT DIGIT ':' DIGIT DIGIT ':' DIGIT DIGIT ('.' DIGIT+)?)? '\\'';\n");
+		grammarBuilder.append("SQ_STRING       : '\\'' ('\\'\\'' | ~'\\'')* '\\'';\n");
+		grammarBuilder.append("DQ_STRING       : '\"' ('\\\\\"' | ~'\"')* '\"';\n");
+		grammarBuilder.append("WS              : [ \\t\\n\\r]+ -> skip ;\n");
+		grammarBuilder.append("COMMENTS        : ('/*' .*? '*/' | '//' ~'\\n'* '\\n' ) -> skip;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="Test(1,3)";
+		String found = execParser("Expr.g4", grammar, "ExprParser", "ExprLexer", "ExprListener", "ExprVisitor", "prog", input, false);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testWhitespaceInfluence_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(2763);
+		grammarBuilder.append("grammar Expr;\n");
+		grammarBuilder.append("prog : expression EOF;\n");
+		grammarBuilder.append("expression\n");
+		grammarBuilder.append("    : ID '(' expression (',' expression)* ')'               # doFunction\n");
+		grammarBuilder.append("    | '(' expression ')'                                    # doParenthesis\n");
+		grammarBuilder.append("    | '!' expression                                        # doNot\n");
+		grammarBuilder.append("    | '-' expression                                        # doNegate\n");
+		grammarBuilder.append("    | '+' expression                                        # doPositiv\n");
+		grammarBuilder.append("    | expression '^' expression                             # doPower\n");
+		grammarBuilder.append("    | expression '*' expression                             # doMultipy\n");
+		grammarBuilder.append("    | expression '/' expression                             # doDivide\n");
+		grammarBuilder.append("    | expression '%' expression                             # doModulo\n");
+		grammarBuilder.append("    | expression '-' expression                             # doMinus\n");
+		grammarBuilder.append("    | expression '+' expression                             # doPlus\n");
+		grammarBuilder.append("    | expression '=' expression                             # doEqual\n");
+		grammarBuilder.append("    | expression '!=' expression                            # doNotEqual\n");
+		grammarBuilder.append("    | expression '>' expression                             # doGreather\n");
+		grammarBuilder.append("    | expression '>=' expression                            # doGreatherEqual\n");
+		grammarBuilder.append("    | expression '<' expression                             # doLesser\n");
+		grammarBuilder.append("    | expression '<=' expression                            # doLesserEqual\n");
+		grammarBuilder.append("    | expression K_IN '(' expression (',' expression)* ')'  # doIn\n");
+		grammarBuilder.append("    | expression ( '&' | K_AND) expression                  # doAnd\n");
+		grammarBuilder.append("    | expression ( '|' | K_OR) expression                   # doOr\n");
+		grammarBuilder.append("    | '[' expression (',' expression)* ']'                  # newArray\n");
+		grammarBuilder.append("    | K_TRUE                                                # newTrueBoolean\n");
+		grammarBuilder.append("    | K_FALSE                                               # newFalseBoolean\n");
+		grammarBuilder.append("    | NUMBER                                                # newNumber\n");
+		grammarBuilder.append("    | DATE                                                  # newDateTime\n");
+		grammarBuilder.append("    | ID                                                    # newIdentifier\n");
+		grammarBuilder.append("    | SQ_STRING                                             # newString\n");
+		grammarBuilder.append("    | K_NULL                                                # newNull\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("// Fragments\n");
+		grammarBuilder.append("fragment DIGIT    : '0' .. '9';  \n");
+		grammarBuilder.append("fragment UPPER    : 'A' .. 'Z';\n");
+		grammarBuilder.append("fragment LOWER    : 'a' .. 'z';\n");
+		grammarBuilder.append("fragment LETTER   : LOWER | UPPER;\n");
+		grammarBuilder.append("fragment WORD     : LETTER | '_' | '$' | '#' | '.';\n");
+		grammarBuilder.append("fragment ALPHANUM : WORD | DIGIT;  \n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("// Tokens\n");
+		grammarBuilder.append("ID              : LETTER ALPHANUM*;\n");
+		grammarBuilder.append("NUMBER          : DIGIT+ ('.' DIGIT+)? (('e'|'E')('+'|'-')? DIGIT+)?;\n");
+		grammarBuilder.append("DATE            : '\\'' DIGIT DIGIT DIGIT DIGIT '-' DIGIT DIGIT '-' DIGIT DIGIT (' ' DIGIT DIGIT ':' DIGIT DIGIT ':' DIGIT DIGIT ('.' DIGIT+)?)? '\\'';\n");
+		grammarBuilder.append("SQ_STRING       : '\\'' ('\\'\\'' | ~'\\'')* '\\'';\n");
+		grammarBuilder.append("DQ_STRING       : '\"' ('\\\\\"' | ~'\"')* '\"';\n");
+		grammarBuilder.append("WS              : [ \\t\\n\\r]+ -> skip ;\n");
+		grammarBuilder.append("COMMENTS        : ('/*' .*? '*/' | '//' ~'\\n'* '\\n' ) -> skip;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="Test(1, 3)";
+		String found = execParser("Expr.g4", grammar, "ExprParser", "ExprLexer", "ExprListener", "ExprVisitor", "prog", input, false);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+
+}
\ No newline at end of file
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/python3/TestLexerErrors.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/python3/TestLexerErrors.java
new file mode 100644
index 000000000..9aa05115f
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/python3/TestLexerErrors.java
@@ -0,0 +1,258 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.python3;
+
+import org.junit.Ignore;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+@SuppressWarnings("unused")
+public class TestLexerErrors extends BasePython3Test {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDFAToATNThatFailsBackToDFA() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(39);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : 'ab' ;\n");
+		grammarBuilder.append("B : 'abc' ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="ababx";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:1='ab',<1>,1:0]\n" +
+			"[@1,2:3='ab',<1>,1:2]\n" +
+			"[@2,5:4='<EOF>',<-1>,1:5]\n", found);
+
+		assertEquals("line 1:4 token recognition error at: 'x'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDFAToATNThatMatchesThenFailsInATN() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(52);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : 'ab' ;\n");
+		grammarBuilder.append("B : 'abc' ;\n");
+		grammarBuilder.append("C : 'abcd' ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="ababcx";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:1='ab',<1>,1:0]\n" +
+			"[@1,2:4='abc',<2>,1:2]\n" +
+			"[@2,6:5='<EOF>',<-1>,1:6]\n", found);
+
+		assertEquals("line 1:5 token recognition error at: 'x'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testEnforcedGreedyNestedBrances_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(77);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("ACTION : '{' (ACTION | ~[{}])* '}';\n");
+		grammarBuilder.append("WS : [ \\r\\n\\t]+ -> skip;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="{ { } }";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:6='{ { } }',<1>,1:0]\n" +
+			"[@1,7:6='<EOF>',<-1>,1:7]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testEnforcedGreedyNestedBrances_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(77);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("ACTION : '{' (ACTION | ~[{}])* '}';\n");
+		grammarBuilder.append("WS : [ \\r\\n\\t]+ -> skip;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="{ { }";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals("[@0,5:4='<EOF>',<-1>,1:5]\n", found);
+
+		assertEquals("line 1:0 token recognition error at: '{ { }'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testErrorInMiddle() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(28);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : 'abc' ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="abx";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals("[@0,3:2='<EOF>',<-1>,1:3]\n", found);
+
+		assertEquals("line 1:0 token recognition error at: 'abx'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testInvalidCharAtStart() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(30);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : 'a' 'b' ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="x";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals("[@0,1:0='<EOF>',<-1>,1:1]\n", found);
+
+		assertEquals("line 1:0 token recognition error at: 'x'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testInvalidCharAtStartAfterDFACache() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(30);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : 'a' 'b' ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="abx";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:1='ab',<1>,1:0]\n" +
+			"[@1,3:2='<EOF>',<-1>,1:3]\n", found);
+
+		assertEquals("line 1:2 token recognition error at: 'x'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testInvalidCharInToken() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(30);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : 'a' 'b' ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="ax";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals("[@0,2:1='<EOF>',<-1>,1:2]\n", found);
+
+		assertEquals("line 1:0 token recognition error at: 'ax'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testInvalidCharInTokenAfterDFACache() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(30);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : 'a' 'b' ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="abax";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:1='ab',<1>,1:0]\n" +
+			"[@1,4:3='<EOF>',<-1>,1:4]\n", found);
+
+		assertEquals("line 1:2 token recognition error at: 'ax'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLexerExecDFA() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(98);
+		grammarBuilder.append("grammar L;\n");
+		grammarBuilder.append("start : ID ':' expr;\n");
+		grammarBuilder.append("expr : primary expr? {} | expr '->' ID;\n");
+		grammarBuilder.append("primary : ID;\n");
+		grammarBuilder.append("ID : [a-z]+;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="x : x";
+		String found = execLexer("L.g4", grammar, "LLexer", input, false);
+		assertEquals(
+			"[@0,0:0='x',<3>,1:0]\n" +
+			"[@1,2:2=':',<1>,1:2]\n" +
+			"[@2,4:4='x',<3>,1:4]\n" +
+			"[@3,5:4='<EOF>',<-1>,1:5]\n", found);
+
+		assertEquals(
+			"line 1:1 token recognition error at: ' '\n" +
+			"line 1:3 token recognition error at: ' '\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testStringsEmbeddedInActions_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(109);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("ACTION2 : '[' (STRING | ~'\"')*? ']';\n");
+		grammarBuilder.append("STRING : '\"' ('\\\"' | .)*? '\"';\n");
+		grammarBuilder.append("WS : [ \\t\\r\\n]+ -> skip;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="[\"foo\"]";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:6='[\"foo\"]',<1>,1:0]\n" +
+			"[@1,7:6='<EOF>',<-1>,1:7]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testStringsEmbeddedInActions_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(109);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("ACTION2 : '[' (STRING | ~'\"')*? ']';\n");
+		grammarBuilder.append("STRING : '\"' ('\\\"' | .)*? '\"';\n");
+		grammarBuilder.append("WS : [ \\t\\r\\n]+ -> skip;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="[\"foo]";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals("[@0,6:5='<EOF>',<-1>,1:6]\n", found);
+
+		assertEquals("line 1:0 token recognition error at: '[\"foo]'\n", this.stderrDuringParse);
+
+	}
+
+
+}
\ No newline at end of file
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/python3/TestLexerExec.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/python3/TestLexerExec.java
new file mode 100644
index 000000000..1d87851ef
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/python3/TestLexerExec.java
@@ -0,0 +1,4996 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.python3;
+
+import org.junit.Ignore;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+@SuppressWarnings("unused")
+public class TestLexerExec extends BasePython3Test {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testActionPlacement() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(228);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("I : ({print(\"stuff fail: \" + self.text)} 'a'\n");
+		grammarBuilder.append("| {print(\"stuff0: \" + self.text)}\n");
+		grammarBuilder.append("		'a' {print(\"stuff1: \" + self.text)}\n");
+		grammarBuilder.append("		'b' {print(\"stuff2: \" + self.text)})\n");
+		grammarBuilder.append("		{print(self.text)} ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;\n");
+		grammarBuilder.append("J : .;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="ab";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"stuff0: \n" +
+			"stuff1: a\n" +
+			"stuff2: ab\n" +
+			"ab\n" +
+			"[@0,0:1='ab',<1>,1:0]\n" +
+			"[@1,2:1='<EOF>',<-1>,1:2]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(72);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("I : '0'..'9'+ {print(\"I\")} ;\n");
+		grammarBuilder.append("WS : [ \\n\\u000D] -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+		String input =
+			"34\n" +
+			" 34";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"I\n" +
+			"I\n" +
+			"[@0,0:1='34',<1>,1:0]\n" +
+			"[@1,4:5='34',<1>,2:1]\n" +
+			"[@2,6:5='<EOF>',<-1>,2:3]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetInSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(79);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("I : (~[ab \\n]|'a')  {print(\"I\")} ;\n");
+		grammarBuilder.append("WS : [ \\n\\u000D]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="a x";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"I\n" +
+			"I\n" +
+			"[@0,0:0='a',<1>,1:0]\n" +
+			"[@1,2:2='x',<1>,1:2]\n" +
+			"[@2,3:2='<EOF>',<-1>,1:3]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetNot() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(82);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("I : ~[ab \\n] ~[ \\ncd]* {print(\"I\")} ;\n");
+		grammarBuilder.append("WS : [ \\n\\u000D]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="xaf";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"I\n" +
+			"[@0,0:2='xaf',<1>,1:0]\n" +
+			"[@1,3:2='<EOF>',<-1>,1:3]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetPlus() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(73);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("I : '0'..'9'+ {print(\"I\")} ;\n");
+		grammarBuilder.append("WS : [ \\n\\u000D]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+		String input =
+			"34\n" +
+			" 34";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"I\n" +
+			"I\n" +
+			"[@0,0:1='34',<1>,1:0]\n" +
+			"[@1,4:5='34',<1>,2:1]\n" +
+			"[@2,6:5='<EOF>',<-1>,2:3]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetRange() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(115);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("I : [0-9]+ {print(\"I\")} ;\n");
+		grammarBuilder.append("ID : [a-zA-Z] [a-zA-Z0-9]* {print(\"ID\")} ;\n");
+		grammarBuilder.append("WS : [ \\n\\u0009\\r]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+		String input =
+			"34\n" +
+			" 34 a2 abc \n" +
+			"   ";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"I\n" +
+			"I\n" +
+			"ID\n" +
+			"ID\n" +
+			"[@0,0:1='34',<1>,1:0]\n" +
+			"[@1,4:5='34',<1>,2:1]\n" +
+			"[@2,7:8='a2',<2>,2:4]\n" +
+			"[@3,10:12='abc',<2>,2:7]\n" +
+			"[@4,18:17='<EOF>',<-1>,3:3]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetWithEscapedChar() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(81);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("DASHBRACK : [\\-\\]]+ {print(\"DASHBRACK\")} ;\n");
+		grammarBuilder.append("WS : [ \\u]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="- ] ";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"DASHBRACK\n" +
+			"DASHBRACK\n" +
+			"[@0,0:0='-',<1>,1:0]\n" +
+			"[@1,2:2=']',<1>,1:2]\n" +
+			"[@2,4:3='<EOF>',<-1>,1:4]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetWithMissingEndRange() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(69);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("I : [0-]+ {print(\"I\")} ;\n");
+		grammarBuilder.append("WS : [ \\n\\u000D]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="00\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"I\n" +
+			"[@0,0:1='00',<1>,1:0]\n" +
+			"[@1,3:2='<EOF>',<-1>,2:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetWithMissingEscapeChar() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(64);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("I : [0-9]+ {print(\"I\")} ;\n");
+		grammarBuilder.append("WS : [ \\u]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="34 ";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"I\n" +
+			"[@0,0:1='34',<1>,1:0]\n" +
+			"[@1,3:2='<EOF>',<-1>,1:3]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetWithQuote1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(67);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : [\"a-z]+ {print(\"A\")} ;\n");
+		grammarBuilder.append("WS : [ \\n\\t]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="b\"a";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"A\n" +
+			"[@0,0:2='b\"a',<1>,1:0]\n" +
+			"[@1,3:2='<EOF>',<-1>,1:3]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetWithQuote2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(68);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : [\"\\\\ab]+ {print(\"A\")} ;\n");
+		grammarBuilder.append("WS : [ \\n\\t]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="b\"\\a";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"A\n" +
+			"[@0,0:3='b\"\\a',<1>,1:0]\n" +
+			"[@1,4:3='<EOF>',<-1>,1:4]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetWithReversedRange() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(65);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : [z-a9]+ {print(\"A\")} ;\n");
+		grammarBuilder.append("WS : [ \\u]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="9";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"A\n" +
+			"[@0,0:0='9',<1>,1:0]\n" +
+			"[@1,1:0='<EOF>',<-1>,1:1]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testEOFByItself() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(38);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("DONE : EOF ;\n");
+		grammarBuilder.append("A : 'a';");
+		String grammar = grammarBuilder.toString();
+
+		String input ="";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:-1='<EOF>',<1>,1:0]\n" +
+			"[@1,0:-1='<EOF>',<-1>,1:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testEOFSuffixInFirstRule_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(48);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : 'a' EOF ;\n");
+		grammarBuilder.append("B : 'a';\n");
+		grammarBuilder.append("C : 'c';");
+		String grammar = grammarBuilder.toString();
+
+		String input ="";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals("[@0,0:-1='<EOF>',<-1>,1:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testEOFSuffixInFirstRule_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(48);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : 'a' EOF ;\n");
+		grammarBuilder.append("B : 'a';\n");
+		grammarBuilder.append("C : 'c';");
+		String grammar = grammarBuilder.toString();
+
+		String input ="a";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:0='a',<1>,1:0]\n" +
+			"[@1,1:0='<EOF>',<-1>,1:1]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testGreedyClosure() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(60);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("CMT : '//' .*? '\\n' CMT*;\n");
+		grammarBuilder.append("WS : (' '|'\\t')+;");
+		String grammar = grammarBuilder.toString();
+
+		String input =
+			"//blah\n" +
+			"//blah\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:13='//blah\\n//blah\\n',<1>,1:0]\n" +
+			"[@1,14:13='<EOF>',<-1>,3:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testGreedyConfigs() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(87);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("I : ('a' | 'ab') {print(self.text)} ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;\n");
+		grammarBuilder.append("J : .;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="ab";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"ab\n" +
+			"[@0,0:1='ab',<1>,1:0]\n" +
+			"[@1,2:1='<EOF>',<-1>,1:2]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testGreedyOptional() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(60);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("CMT : '//' .*? '\\n' CMT?;\n");
+		grammarBuilder.append("WS : (' '|'\\t')+;");
+		String grammar = grammarBuilder.toString();
+
+		String input =
+			"//blah\n" +
+			"//blah\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:13='//blah\\n//blah\\n',<1>,1:0]\n" +
+			"[@1,14:13='<EOF>',<-1>,3:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testGreedyPositiveClosure() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(58);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("CMT : ('//' .*? '\\n')+;\n");
+		grammarBuilder.append("WS : (' '|'\\t')+;");
+		String grammar = grammarBuilder.toString();
+
+		String input =
+			"//blah\n" +
+			"//blah\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:13='//blah\\n//blah\\n',<1>,1:0]\n" +
+			"[@1,14:13='<EOF>',<-1>,3:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testHexVsID() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(265);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("HexLiteral : '0' ('x'|'X') HexDigit+ ;\n");
+		grammarBuilder.append("DecimalLiteral : ('0' | '1'..'9' '0'..'9'*) ;\n");
+		grammarBuilder.append("FloatingPointLiteral : ('0x' | '0X') HexDigit* ('.' HexDigit*)? ;\n");
+		grammarBuilder.append("DOT : '.' ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("fragment HexDigit : ('0'..'9'|'a'..'f'|'A'..'F') ;\n");
+		grammarBuilder.append("WS : (' '|'\\n')+;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="x 0 1 a.b a.l";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:0='x',<5>,1:0]\n" +
+			"[@1,1:1=' ',<6>,1:1]\n" +
+			"[@2,2:2='0',<2>,1:2]\n" +
+			"[@3,3:3=' ',<6>,1:3]\n" +
+			"[@4,4:4='1',<2>,1:4]\n" +
+			"[@5,5:5=' ',<6>,1:5]\n" +
+			"[@6,6:6='a',<5>,1:6]\n" +
+			"[@7,7:7='.',<4>,1:7]\n" +
+			"[@8,8:8='b',<5>,1:8]\n" +
+			"[@9,9:9=' ',<6>,1:9]\n" +
+			"[@10,10:10='a',<5>,1:10]\n" +
+			"[@11,11:11='.',<4>,1:11]\n" +
+			"[@12,12:12='l',<5>,1:12]\n" +
+			"[@13,13:12='<EOF>',<-1>,1:13]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testKeywordID() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(82);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("KEND : 'end' ; // has priority\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n')+;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="end eend ending a";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:2='end',<1>,1:0]\n" +
+			"[@1,3:3=' ',<3>,1:3]\n" +
+			"[@2,4:7='eend',<2>,1:4]\n" +
+			"[@3,8:8=' ',<3>,1:8]\n" +
+			"[@4,9:14='ending',<2>,1:9]\n" +
+			"[@5,15:15=' ',<3>,1:15]\n" +
+			"[@6,16:16='a',<2>,1:16]\n" +
+			"[@7,17:16='<EOF>',<-1>,1:17]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLargeLexer() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(85821);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("WS : [ \\t\\r\\n]+ -> skip;\n");
+		grammarBuilder.append("KW0 : 'KW' '0';\n");
+		grammarBuilder.append("KW1 : 'KW' '1';\n");
+		grammarBuilder.append("KW2 : 'KW' '2';\n");
+		grammarBuilder.append("KW3 : 'KW' '3';\n");
+		grammarBuilder.append("KW4 : 'KW' '4';\n");
+		grammarBuilder.append("KW5 : 'KW' '5';\n");
+		grammarBuilder.append("KW6 : 'KW' '6';\n");
+		grammarBuilder.append("KW7 : 'KW' '7';\n");
+		grammarBuilder.append("KW8 : 'KW' '8';\n");
+		grammarBuilder.append("KW9 : 'KW' '9';\n");
+		grammarBuilder.append("KW10 : 'KW' '10';\n");
+		grammarBuilder.append("KW11 : 'KW' '11';\n");
+		grammarBuilder.append("KW12 : 'KW' '12';\n");
+		grammarBuilder.append("KW13 : 'KW' '13';\n");
+		grammarBuilder.append("KW14 : 'KW' '14';\n");
+		grammarBuilder.append("KW15 : 'KW' '15';\n");
+		grammarBuilder.append("KW16 : 'KW' '16';\n");
+		grammarBuilder.append("KW17 : 'KW' '17';\n");
+		grammarBuilder.append("KW18 : 'KW' '18';\n");
+		grammarBuilder.append("KW19 : 'KW' '19';\n");
+		grammarBuilder.append("KW20 : 'KW' '20';\n");
+		grammarBuilder.append("KW21 : 'KW' '21';\n");
+		grammarBuilder.append("KW22 : 'KW' '22';\n");
+		grammarBuilder.append("KW23 : 'KW' '23';\n");
+		grammarBuilder.append("KW24 : 'KW' '24';\n");
+		grammarBuilder.append("KW25 : 'KW' '25';\n");
+		grammarBuilder.append("KW26 : 'KW' '26';\n");
+		grammarBuilder.append("KW27 : 'KW' '27';\n");
+		grammarBuilder.append("KW28 : 'KW' '28';\n");
+		grammarBuilder.append("KW29 : 'KW' '29';\n");
+		grammarBuilder.append("KW30 : 'KW' '30';\n");
+		grammarBuilder.append("KW31 : 'KW' '31';\n");
+		grammarBuilder.append("KW32 : 'KW' '32';\n");
+		grammarBuilder.append("KW33 : 'KW' '33';\n");
+		grammarBuilder.append("KW34 : 'KW' '34';\n");
+		grammarBuilder.append("KW35 : 'KW' '35';\n");
+		grammarBuilder.append("KW36 : 'KW' '36';\n");
+		grammarBuilder.append("KW37 : 'KW' '37';\n");
+		grammarBuilder.append("KW38 : 'KW' '38';\n");
+		grammarBuilder.append("KW39 : 'KW' '39';\n");
+		grammarBuilder.append("KW40 : 'KW' '40';\n");
+		grammarBuilder.append("KW41 : 'KW' '41';\n");
+		grammarBuilder.append("KW42 : 'KW' '42';\n");
+		grammarBuilder.append("KW43 : 'KW' '43';\n");
+		grammarBuilder.append("KW44 : 'KW' '44';\n");
+		grammarBuilder.append("KW45 : 'KW' '45';\n");
+		grammarBuilder.append("KW46 : 'KW' '46';\n");
+		grammarBuilder.append("KW47 : 'KW' '47';\n");
+		grammarBuilder.append("KW48 : 'KW' '48';\n");
+		grammarBuilder.append("KW49 : 'KW' '49';\n");
+		grammarBuilder.append("KW50 : 'KW' '50';\n");
+		grammarBuilder.append("KW51 : 'KW' '51';\n");
+		grammarBuilder.append("KW52 : 'KW' '52';\n");
+		grammarBuilder.append("KW53 : 'KW' '53';\n");
+		grammarBuilder.append("KW54 : 'KW' '54';\n");
+		grammarBuilder.append("KW55 : 'KW' '55';\n");
+		grammarBuilder.append("KW56 : 'KW' '56';\n");
+		grammarBuilder.append("KW57 : 'KW' '57';\n");
+		grammarBuilder.append("KW58 : 'KW' '58';\n");
+		grammarBuilder.append("KW59 : 'KW' '59';\n");
+		grammarBuilder.append("KW60 : 'KW' '60';\n");
+		grammarBuilder.append("KW61 : 'KW' '61';\n");
+		grammarBuilder.append("KW62 : 'KW' '62';\n");
+		grammarBuilder.append("KW63 : 'KW' '63';\n");
+		grammarBuilder.append("KW64 : 'KW' '64';\n");
+		grammarBuilder.append("KW65 : 'KW' '65';\n");
+		grammarBuilder.append("KW66 : 'KW' '66';\n");
+		grammarBuilder.append("KW67 : 'KW' '67';\n");
+		grammarBuilder.append("KW68 : 'KW' '68';\n");
+		grammarBuilder.append("KW69 : 'KW' '69';\n");
+		grammarBuilder.append("KW70 : 'KW' '70';\n");
+		grammarBuilder.append("KW71 : 'KW' '71';\n");
+		grammarBuilder.append("KW72 : 'KW' '72';\n");
+		grammarBuilder.append("KW73 : 'KW' '73';\n");
+		grammarBuilder.append("KW74 : 'KW' '74';\n");
+		grammarBuilder.append("KW75 : 'KW' '75';\n");
+		grammarBuilder.append("KW76 : 'KW' '76';\n");
+		grammarBuilder.append("KW77 : 'KW' '77';\n");
+		grammarBuilder.append("KW78 : 'KW' '78';\n");
+		grammarBuilder.append("KW79 : 'KW' '79';\n");
+		grammarBuilder.append("KW80 : 'KW' '80';\n");
+		grammarBuilder.append("KW81 : 'KW' '81';\n");
+		grammarBuilder.append("KW82 : 'KW' '82';\n");
+		grammarBuilder.append("KW83 : 'KW' '83';\n");
+		grammarBuilder.append("KW84 : 'KW' '84';\n");
+		grammarBuilder.append("KW85 : 'KW' '85';\n");
+		grammarBuilder.append("KW86 : 'KW' '86';\n");
+		grammarBuilder.append("KW87 : 'KW' '87';\n");
+		grammarBuilder.append("KW88 : 'KW' '88';\n");
+		grammarBuilder.append("KW89 : 'KW' '89';\n");
+		grammarBuilder.append("KW90 : 'KW' '90';\n");
+		grammarBuilder.append("KW91 : 'KW' '91';\n");
+		grammarBuilder.append("KW92 : 'KW' '92';\n");
+		grammarBuilder.append("KW93 : 'KW' '93';\n");
+		grammarBuilder.append("KW94 : 'KW' '94';\n");
+		grammarBuilder.append("KW95 : 'KW' '95';\n");
+		grammarBuilder.append("KW96 : 'KW' '96';\n");
+		grammarBuilder.append("KW97 : 'KW' '97';\n");
+		grammarBuilder.append("KW98 : 'KW' '98';\n");
+		grammarBuilder.append("KW99 : 'KW' '99';\n");
+		grammarBuilder.append("KW100 : 'KW' '100';\n");
+		grammarBuilder.append("KW101 : 'KW' '101';\n");
+		grammarBuilder.append("KW102 : 'KW' '102';\n");
+		grammarBuilder.append("KW103 : 'KW' '103';\n");
+		grammarBuilder.append("KW104 : 'KW' '104';\n");
+		grammarBuilder.append("KW105 : 'KW' '105';\n");
+		grammarBuilder.append("KW106 : 'KW' '106';\n");
+		grammarBuilder.append("KW107 : 'KW' '107';\n");
+		grammarBuilder.append("KW108 : 'KW' '108';\n");
+		grammarBuilder.append("KW109 : 'KW' '109';\n");
+		grammarBuilder.append("KW110 : 'KW' '110';\n");
+		grammarBuilder.append("KW111 : 'KW' '111';\n");
+		grammarBuilder.append("KW112 : 'KW' '112';\n");
+		grammarBuilder.append("KW113 : 'KW' '113';\n");
+		grammarBuilder.append("KW114 : 'KW' '114';\n");
+		grammarBuilder.append("KW115 : 'KW' '115';\n");
+		grammarBuilder.append("KW116 : 'KW' '116';\n");
+		grammarBuilder.append("KW117 : 'KW' '117';\n");
+		grammarBuilder.append("KW118 : 'KW' '118';\n");
+		grammarBuilder.append("KW119 : 'KW' '119';\n");
+		grammarBuilder.append("KW120 : 'KW' '120';\n");
+		grammarBuilder.append("KW121 : 'KW' '121';\n");
+		grammarBuilder.append("KW122 : 'KW' '122';\n");
+		grammarBuilder.append("KW123 : 'KW' '123';\n");
+		grammarBuilder.append("KW124 : 'KW' '124';\n");
+		grammarBuilder.append("KW125 : 'KW' '125';\n");
+		grammarBuilder.append("KW126 : 'KW' '126';\n");
+		grammarBuilder.append("KW127 : 'KW' '127';\n");
+		grammarBuilder.append("KW128 : 'KW' '128';\n");
+		grammarBuilder.append("KW129 : 'KW' '129';\n");
+		grammarBuilder.append("KW130 : 'KW' '130';\n");
+		grammarBuilder.append("KW131 : 'KW' '131';\n");
+		grammarBuilder.append("KW132 : 'KW' '132';\n");
+		grammarBuilder.append("KW133 : 'KW' '133';\n");
+		grammarBuilder.append("KW134 : 'KW' '134';\n");
+		grammarBuilder.append("KW135 : 'KW' '135';\n");
+		grammarBuilder.append("KW136 : 'KW' '136';\n");
+		grammarBuilder.append("KW137 : 'KW' '137';\n");
+		grammarBuilder.append("KW138 : 'KW' '138';\n");
+		grammarBuilder.append("KW139 : 'KW' '139';\n");
+		grammarBuilder.append("KW140 : 'KW' '140';\n");
+		grammarBuilder.append("KW141 : 'KW' '141';\n");
+		grammarBuilder.append("KW142 : 'KW' '142';\n");
+		grammarBuilder.append("KW143 : 'KW' '143';\n");
+		grammarBuilder.append("KW144 : 'KW' '144';\n");
+		grammarBuilder.append("KW145 : 'KW' '145';\n");
+		grammarBuilder.append("KW146 : 'KW' '146';\n");
+		grammarBuilder.append("KW147 : 'KW' '147';\n");
+		grammarBuilder.append("KW148 : 'KW' '148';\n");
+		grammarBuilder.append("KW149 : 'KW' '149';\n");
+		grammarBuilder.append("KW150 : 'KW' '150';\n");
+		grammarBuilder.append("KW151 : 'KW' '151';\n");
+		grammarBuilder.append("KW152 : 'KW' '152';\n");
+		grammarBuilder.append("KW153 : 'KW' '153';\n");
+		grammarBuilder.append("KW154 : 'KW' '154';\n");
+		grammarBuilder.append("KW155 : 'KW' '155';\n");
+		grammarBuilder.append("KW156 : 'KW' '156';\n");
+		grammarBuilder.append("KW157 : 'KW' '157';\n");
+		grammarBuilder.append("KW158 : 'KW' '158';\n");
+		grammarBuilder.append("KW159 : 'KW' '159';\n");
+		grammarBuilder.append("KW160 : 'KW' '160';\n");
+		grammarBuilder.append("KW161 : 'KW' '161';\n");
+		grammarBuilder.append("KW162 : 'KW' '162';\n");
+		grammarBuilder.append("KW163 : 'KW' '163';\n");
+		grammarBuilder.append("KW164 : 'KW' '164';\n");
+		grammarBuilder.append("KW165 : 'KW' '165';\n");
+		grammarBuilder.append("KW166 : 'KW' '166';\n");
+		grammarBuilder.append("KW167 : 'KW' '167';\n");
+		grammarBuilder.append("KW168 : 'KW' '168';\n");
+		grammarBuilder.append("KW169 : 'KW' '169';\n");
+		grammarBuilder.append("KW170 : 'KW' '170';\n");
+		grammarBuilder.append("KW171 : 'KW' '171';\n");
+		grammarBuilder.append("KW172 : 'KW' '172';\n");
+		grammarBuilder.append("KW173 : 'KW' '173';\n");
+		grammarBuilder.append("KW174 : 'KW' '174';\n");
+		grammarBuilder.append("KW175 : 'KW' '175';\n");
+		grammarBuilder.append("KW176 : 'KW' '176';\n");
+		grammarBuilder.append("KW177 : 'KW' '177';\n");
+		grammarBuilder.append("KW178 : 'KW' '178';\n");
+		grammarBuilder.append("KW179 : 'KW' '179';\n");
+		grammarBuilder.append("KW180 : 'KW' '180';\n");
+		grammarBuilder.append("KW181 : 'KW' '181';\n");
+		grammarBuilder.append("KW182 : 'KW' '182';\n");
+		grammarBuilder.append("KW183 : 'KW' '183';\n");
+		grammarBuilder.append("KW184 : 'KW' '184';\n");
+		grammarBuilder.append("KW185 : 'KW' '185';\n");
+		grammarBuilder.append("KW186 : 'KW' '186';\n");
+		grammarBuilder.append("KW187 : 'KW' '187';\n");
+		grammarBuilder.append("KW188 : 'KW' '188';\n");
+		grammarBuilder.append("KW189 : 'KW' '189';\n");
+		grammarBuilder.append("KW190 : 'KW' '190';\n");
+		grammarBuilder.append("KW191 : 'KW' '191';\n");
+		grammarBuilder.append("KW192 : 'KW' '192';\n");
+		grammarBuilder.append("KW193 : 'KW' '193';\n");
+		grammarBuilder.append("KW194 : 'KW' '194';\n");
+		grammarBuilder.append("KW195 : 'KW' '195';\n");
+		grammarBuilder.append("KW196 : 'KW' '196';\n");
+		grammarBuilder.append("KW197 : 'KW' '197';\n");
+		grammarBuilder.append("KW198 : 'KW' '198';\n");
+		grammarBuilder.append("KW199 : 'KW' '199';\n");
+		grammarBuilder.append("KW200 : 'KW' '200';\n");
+		grammarBuilder.append("KW201 : 'KW' '201';\n");
+		grammarBuilder.append("KW202 : 'KW' '202';\n");
+		grammarBuilder.append("KW203 : 'KW' '203';\n");
+		grammarBuilder.append("KW204 : 'KW' '204';\n");
+		grammarBuilder.append("KW205 : 'KW' '205';\n");
+		grammarBuilder.append("KW206 : 'KW' '206';\n");
+		grammarBuilder.append("KW207 : 'KW' '207';\n");
+		grammarBuilder.append("KW208 : 'KW' '208';\n");
+		grammarBuilder.append("KW209 : 'KW' '209';\n");
+		grammarBuilder.append("KW210 : 'KW' '210';\n");
+		grammarBuilder.append("KW211 : 'KW' '211';\n");
+		grammarBuilder.append("KW212 : 'KW' '212';\n");
+		grammarBuilder.append("KW213 : 'KW' '213';\n");
+		grammarBuilder.append("KW214 : 'KW' '214';\n");
+		grammarBuilder.append("KW215 : 'KW' '215';\n");
+		grammarBuilder.append("KW216 : 'KW' '216';\n");
+		grammarBuilder.append("KW217 : 'KW' '217';\n");
+		grammarBuilder.append("KW218 : 'KW' '218';\n");
+		grammarBuilder.append("KW219 : 'KW' '219';\n");
+		grammarBuilder.append("KW220 : 'KW' '220';\n");
+		grammarBuilder.append("KW221 : 'KW' '221';\n");
+		grammarBuilder.append("KW222 : 'KW' '222';\n");
+		grammarBuilder.append("KW223 : 'KW' '223';\n");
+		grammarBuilder.append("KW224 : 'KW' '224';\n");
+		grammarBuilder.append("KW225 : 'KW' '225';\n");
+		grammarBuilder.append("KW226 : 'KW' '226';\n");
+		grammarBuilder.append("KW227 : 'KW' '227';\n");
+		grammarBuilder.append("KW228 : 'KW' '228';\n");
+		grammarBuilder.append("KW229 : 'KW' '229';\n");
+		grammarBuilder.append("KW230 : 'KW' '230';\n");
+		grammarBuilder.append("KW231 : 'KW' '231';\n");
+		grammarBuilder.append("KW232 : 'KW' '232';\n");
+		grammarBuilder.append("KW233 : 'KW' '233';\n");
+		grammarBuilder.append("KW234 : 'KW' '234';\n");
+		grammarBuilder.append("KW235 : 'KW' '235';\n");
+		grammarBuilder.append("KW236 : 'KW' '236';\n");
+		grammarBuilder.append("KW237 : 'KW' '237';\n");
+		grammarBuilder.append("KW238 : 'KW' '238';\n");
+		grammarBuilder.append("KW239 : 'KW' '239';\n");
+		grammarBuilder.append("KW240 : 'KW' '240';\n");
+		grammarBuilder.append("KW241 : 'KW' '241';\n");
+		grammarBuilder.append("KW242 : 'KW' '242';\n");
+		grammarBuilder.append("KW243 : 'KW' '243';\n");
+		grammarBuilder.append("KW244 : 'KW' '244';\n");
+		grammarBuilder.append("KW245 : 'KW' '245';\n");
+		grammarBuilder.append("KW246 : 'KW' '246';\n");
+		grammarBuilder.append("KW247 : 'KW' '247';\n");
+		grammarBuilder.append("KW248 : 'KW' '248';\n");
+		grammarBuilder.append("KW249 : 'KW' '249';\n");
+		grammarBuilder.append("KW250 : 'KW' '250';\n");
+		grammarBuilder.append("KW251 : 'KW' '251';\n");
+		grammarBuilder.append("KW252 : 'KW' '252';\n");
+		grammarBuilder.append("KW253 : 'KW' '253';\n");
+		grammarBuilder.append("KW254 : 'KW' '254';\n");
+		grammarBuilder.append("KW255 : 'KW' '255';\n");
+		grammarBuilder.append("KW256 : 'KW' '256';\n");
+		grammarBuilder.append("KW257 : 'KW' '257';\n");
+		grammarBuilder.append("KW258 : 'KW' '258';\n");
+		grammarBuilder.append("KW259 : 'KW' '259';\n");
+		grammarBuilder.append("KW260 : 'KW' '260';\n");
+		grammarBuilder.append("KW261 : 'KW' '261';\n");
+		grammarBuilder.append("KW262 : 'KW' '262';\n");
+		grammarBuilder.append("KW263 : 'KW' '263';\n");
+		grammarBuilder.append("KW264 : 'KW' '264';\n");
+		grammarBuilder.append("KW265 : 'KW' '265';\n");
+		grammarBuilder.append("KW266 : 'KW' '266';\n");
+		grammarBuilder.append("KW267 : 'KW' '267';\n");
+		grammarBuilder.append("KW268 : 'KW' '268';\n");
+		grammarBuilder.append("KW269 : 'KW' '269';\n");
+		grammarBuilder.append("KW270 : 'KW' '270';\n");
+		grammarBuilder.append("KW271 : 'KW' '271';\n");
+		grammarBuilder.append("KW272 : 'KW' '272';\n");
+		grammarBuilder.append("KW273 : 'KW' '273';\n");
+		grammarBuilder.append("KW274 : 'KW' '274';\n");
+		grammarBuilder.append("KW275 : 'KW' '275';\n");
+		grammarBuilder.append("KW276 : 'KW' '276';\n");
+		grammarBuilder.append("KW277 : 'KW' '277';\n");
+		grammarBuilder.append("KW278 : 'KW' '278';\n");
+		grammarBuilder.append("KW279 : 'KW' '279';\n");
+		grammarBuilder.append("KW280 : 'KW' '280';\n");
+		grammarBuilder.append("KW281 : 'KW' '281';\n");
+		grammarBuilder.append("KW282 : 'KW' '282';\n");
+		grammarBuilder.append("KW283 : 'KW' '283';\n");
+		grammarBuilder.append("KW284 : 'KW' '284';\n");
+		grammarBuilder.append("KW285 : 'KW' '285';\n");
+		grammarBuilder.append("KW286 : 'KW' '286';\n");
+		grammarBuilder.append("KW287 : 'KW' '287';\n");
+		grammarBuilder.append("KW288 : 'KW' '288';\n");
+		grammarBuilder.append("KW289 : 'KW' '289';\n");
+		grammarBuilder.append("KW290 : 'KW' '290';\n");
+		grammarBuilder.append("KW291 : 'KW' '291';\n");
+		grammarBuilder.append("KW292 : 'KW' '292';\n");
+		grammarBuilder.append("KW293 : 'KW' '293';\n");
+		grammarBuilder.append("KW294 : 'KW' '294';\n");
+		grammarBuilder.append("KW295 : 'KW' '295';\n");
+		grammarBuilder.append("KW296 : 'KW' '296';\n");
+		grammarBuilder.append("KW297 : 'KW' '297';\n");
+		grammarBuilder.append("KW298 : 'KW' '298';\n");
+		grammarBuilder.append("KW299 : 'KW' '299';\n");
+		grammarBuilder.append("KW300 : 'KW' '300';\n");
+		grammarBuilder.append("KW301 : 'KW' '301';\n");
+		grammarBuilder.append("KW302 : 'KW' '302';\n");
+		grammarBuilder.append("KW303 : 'KW' '303';\n");
+		grammarBuilder.append("KW304 : 'KW' '304';\n");
+		grammarBuilder.append("KW305 : 'KW' '305';\n");
+		grammarBuilder.append("KW306 : 'KW' '306';\n");
+		grammarBuilder.append("KW307 : 'KW' '307';\n");
+		grammarBuilder.append("KW308 : 'KW' '308';\n");
+		grammarBuilder.append("KW309 : 'KW' '309';\n");
+		grammarBuilder.append("KW310 : 'KW' '310';\n");
+		grammarBuilder.append("KW311 : 'KW' '311';\n");
+		grammarBuilder.append("KW312 : 'KW' '312';\n");
+		grammarBuilder.append("KW313 : 'KW' '313';\n");
+		grammarBuilder.append("KW314 : 'KW' '314';\n");
+		grammarBuilder.append("KW315 : 'KW' '315';\n");
+		grammarBuilder.append("KW316 : 'KW' '316';\n");
+		grammarBuilder.append("KW317 : 'KW' '317';\n");
+		grammarBuilder.append("KW318 : 'KW' '318';\n");
+		grammarBuilder.append("KW319 : 'KW' '319';\n");
+		grammarBuilder.append("KW320 : 'KW' '320';\n");
+		grammarBuilder.append("KW321 : 'KW' '321';\n");
+		grammarBuilder.append("KW322 : 'KW' '322';\n");
+		grammarBuilder.append("KW323 : 'KW' '323';\n");
+		grammarBuilder.append("KW324 : 'KW' '324';\n");
+		grammarBuilder.append("KW325 : 'KW' '325';\n");
+		grammarBuilder.append("KW326 : 'KW' '326';\n");
+		grammarBuilder.append("KW327 : 'KW' '327';\n");
+		grammarBuilder.append("KW328 : 'KW' '328';\n");
+		grammarBuilder.append("KW329 : 'KW' '329';\n");
+		grammarBuilder.append("KW330 : 'KW' '330';\n");
+		grammarBuilder.append("KW331 : 'KW' '331';\n");
+		grammarBuilder.append("KW332 : 'KW' '332';\n");
+		grammarBuilder.append("KW333 : 'KW' '333';\n");
+		grammarBuilder.append("KW334 : 'KW' '334';\n");
+		grammarBuilder.append("KW335 : 'KW' '335';\n");
+		grammarBuilder.append("KW336 : 'KW' '336';\n");
+		grammarBuilder.append("KW337 : 'KW' '337';\n");
+		grammarBuilder.append("KW338 : 'KW' '338';\n");
+		grammarBuilder.append("KW339 : 'KW' '339';\n");
+		grammarBuilder.append("KW340 : 'KW' '340';\n");
+		grammarBuilder.append("KW341 : 'KW' '341';\n");
+		grammarBuilder.append("KW342 : 'KW' '342';\n");
+		grammarBuilder.append("KW343 : 'KW' '343';\n");
+		grammarBuilder.append("KW344 : 'KW' '344';\n");
+		grammarBuilder.append("KW345 : 'KW' '345';\n");
+		grammarBuilder.append("KW346 : 'KW' '346';\n");
+		grammarBuilder.append("KW347 : 'KW' '347';\n");
+		grammarBuilder.append("KW348 : 'KW' '348';\n");
+		grammarBuilder.append("KW349 : 'KW' '349';\n");
+		grammarBuilder.append("KW350 : 'KW' '350';\n");
+		grammarBuilder.append("KW351 : 'KW' '351';\n");
+		grammarBuilder.append("KW352 : 'KW' '352';\n");
+		grammarBuilder.append("KW353 : 'KW' '353';\n");
+		grammarBuilder.append("KW354 : 'KW' '354';\n");
+		grammarBuilder.append("KW355 : 'KW' '355';\n");
+		grammarBuilder.append("KW356 : 'KW' '356';\n");
+		grammarBuilder.append("KW357 : 'KW' '357';\n");
+		grammarBuilder.append("KW358 : 'KW' '358';\n");
+		grammarBuilder.append("KW359 : 'KW' '359';\n");
+		grammarBuilder.append("KW360 : 'KW' '360';\n");
+		grammarBuilder.append("KW361 : 'KW' '361';\n");
+		grammarBuilder.append("KW362 : 'KW' '362';\n");
+		grammarBuilder.append("KW363 : 'KW' '363';\n");
+		grammarBuilder.append("KW364 : 'KW' '364';\n");
+		grammarBuilder.append("KW365 : 'KW' '365';\n");
+		grammarBuilder.append("KW366 : 'KW' '366';\n");
+		grammarBuilder.append("KW367 : 'KW' '367';\n");
+		grammarBuilder.append("KW368 : 'KW' '368';\n");
+		grammarBuilder.append("KW369 : 'KW' '369';\n");
+		grammarBuilder.append("KW370 : 'KW' '370';\n");
+		grammarBuilder.append("KW371 : 'KW' '371';\n");
+		grammarBuilder.append("KW372 : 'KW' '372';\n");
+		grammarBuilder.append("KW373 : 'KW' '373';\n");
+		grammarBuilder.append("KW374 : 'KW' '374';\n");
+		grammarBuilder.append("KW375 : 'KW' '375';\n");
+		grammarBuilder.append("KW376 : 'KW' '376';\n");
+		grammarBuilder.append("KW377 : 'KW' '377';\n");
+		grammarBuilder.append("KW378 : 'KW' '378';\n");
+		grammarBuilder.append("KW379 : 'KW' '379';\n");
+		grammarBuilder.append("KW380 : 'KW' '380';\n");
+		grammarBuilder.append("KW381 : 'KW' '381';\n");
+		grammarBuilder.append("KW382 : 'KW' '382';\n");
+		grammarBuilder.append("KW383 : 'KW' '383';\n");
+		grammarBuilder.append("KW384 : 'KW' '384';\n");
+		grammarBuilder.append("KW385 : 'KW' '385';\n");
+		grammarBuilder.append("KW386 : 'KW' '386';\n");
+		grammarBuilder.append("KW387 : 'KW' '387';\n");
+		grammarBuilder.append("KW388 : 'KW' '388';\n");
+		grammarBuilder.append("KW389 : 'KW' '389';\n");
+		grammarBuilder.append("KW390 : 'KW' '390';\n");
+		grammarBuilder.append("KW391 : 'KW' '391';\n");
+		grammarBuilder.append("KW392 : 'KW' '392';\n");
+		grammarBuilder.append("KW393 : 'KW' '393';\n");
+		grammarBuilder.append("KW394 : 'KW' '394';\n");
+		grammarBuilder.append("KW395 : 'KW' '395';\n");
+		grammarBuilder.append("KW396 : 'KW' '396';\n");
+		grammarBuilder.append("KW397 : 'KW' '397';\n");
+		grammarBuilder.append("KW398 : 'KW' '398';\n");
+		grammarBuilder.append("KW399 : 'KW' '399';\n");
+		grammarBuilder.append("KW400 : 'KW' '400';\n");
+		grammarBuilder.append("KW401 : 'KW' '401';\n");
+		grammarBuilder.append("KW402 : 'KW' '402';\n");
+		grammarBuilder.append("KW403 : 'KW' '403';\n");
+		grammarBuilder.append("KW404 : 'KW' '404';\n");
+		grammarBuilder.append("KW405 : 'KW' '405';\n");
+		grammarBuilder.append("KW406 : 'KW' '406';\n");
+		grammarBuilder.append("KW407 : 'KW' '407';\n");
+		grammarBuilder.append("KW408 : 'KW' '408';\n");
+		grammarBuilder.append("KW409 : 'KW' '409';\n");
+		grammarBuilder.append("KW410 : 'KW' '410';\n");
+		grammarBuilder.append("KW411 : 'KW' '411';\n");
+		grammarBuilder.append("KW412 : 'KW' '412';\n");
+		grammarBuilder.append("KW413 : 'KW' '413';\n");
+		grammarBuilder.append("KW414 : 'KW' '414';\n");
+		grammarBuilder.append("KW415 : 'KW' '415';\n");
+		grammarBuilder.append("KW416 : 'KW' '416';\n");
+		grammarBuilder.append("KW417 : 'KW' '417';\n");
+		grammarBuilder.append("KW418 : 'KW' '418';\n");
+		grammarBuilder.append("KW419 : 'KW' '419';\n");
+		grammarBuilder.append("KW420 : 'KW' '420';\n");
+		grammarBuilder.append("KW421 : 'KW' '421';\n");
+		grammarBuilder.append("KW422 : 'KW' '422';\n");
+		grammarBuilder.append("KW423 : 'KW' '423';\n");
+		grammarBuilder.append("KW424 : 'KW' '424';\n");
+		grammarBuilder.append("KW425 : 'KW' '425';\n");
+		grammarBuilder.append("KW426 : 'KW' '426';\n");
+		grammarBuilder.append("KW427 : 'KW' '427';\n");
+		grammarBuilder.append("KW428 : 'KW' '428';\n");
+		grammarBuilder.append("KW429 : 'KW' '429';\n");
+		grammarBuilder.append("KW430 : 'KW' '430';\n");
+		grammarBuilder.append("KW431 : 'KW' '431';\n");
+		grammarBuilder.append("KW432 : 'KW' '432';\n");
+		grammarBuilder.append("KW433 : 'KW' '433';\n");
+		grammarBuilder.append("KW434 : 'KW' '434';\n");
+		grammarBuilder.append("KW435 : 'KW' '435';\n");
+		grammarBuilder.append("KW436 : 'KW' '436';\n");
+		grammarBuilder.append("KW437 : 'KW' '437';\n");
+		grammarBuilder.append("KW438 : 'KW' '438';\n");
+		grammarBuilder.append("KW439 : 'KW' '439';\n");
+		grammarBuilder.append("KW440 : 'KW' '440';\n");
+		grammarBuilder.append("KW441 : 'KW' '441';\n");
+		grammarBuilder.append("KW442 : 'KW' '442';\n");
+		grammarBuilder.append("KW443 : 'KW' '443';\n");
+		grammarBuilder.append("KW444 : 'KW' '444';\n");
+		grammarBuilder.append("KW445 : 'KW' '445';\n");
+		grammarBuilder.append("KW446 : 'KW' '446';\n");
+		grammarBuilder.append("KW447 : 'KW' '447';\n");
+		grammarBuilder.append("KW448 : 'KW' '448';\n");
+		grammarBuilder.append("KW449 : 'KW' '449';\n");
+		grammarBuilder.append("KW450 : 'KW' '450';\n");
+		grammarBuilder.append("KW451 : 'KW' '451';\n");
+		grammarBuilder.append("KW452 : 'KW' '452';\n");
+		grammarBuilder.append("KW453 : 'KW' '453';\n");
+		grammarBuilder.append("KW454 : 'KW' '454';\n");
+		grammarBuilder.append("KW455 : 'KW' '455';\n");
+		grammarBuilder.append("KW456 : 'KW' '456';\n");
+		grammarBuilder.append("KW457 : 'KW' '457';\n");
+		grammarBuilder.append("KW458 : 'KW' '458';\n");
+		grammarBuilder.append("KW459 : 'KW' '459';\n");
+		grammarBuilder.append("KW460 : 'KW' '460';\n");
+		grammarBuilder.append("KW461 : 'KW' '461';\n");
+		grammarBuilder.append("KW462 : 'KW' '462';\n");
+		grammarBuilder.append("KW463 : 'KW' '463';\n");
+		grammarBuilder.append("KW464 : 'KW' '464';\n");
+		grammarBuilder.append("KW465 : 'KW' '465';\n");
+		grammarBuilder.append("KW466 : 'KW' '466';\n");
+		grammarBuilder.append("KW467 : 'KW' '467';\n");
+		grammarBuilder.append("KW468 : 'KW' '468';\n");
+		grammarBuilder.append("KW469 : 'KW' '469';\n");
+		grammarBuilder.append("KW470 : 'KW' '470';\n");
+		grammarBuilder.append("KW471 : 'KW' '471';\n");
+		grammarBuilder.append("KW472 : 'KW' '472';\n");
+		grammarBuilder.append("KW473 : 'KW' '473';\n");
+		grammarBuilder.append("KW474 : 'KW' '474';\n");
+		grammarBuilder.append("KW475 : 'KW' '475';\n");
+		grammarBuilder.append("KW476 : 'KW' '476';\n");
+		grammarBuilder.append("KW477 : 'KW' '477';\n");
+		grammarBuilder.append("KW478 : 'KW' '478';\n");
+		grammarBuilder.append("KW479 : 'KW' '479';\n");
+		grammarBuilder.append("KW480 : 'KW' '480';\n");
+		grammarBuilder.append("KW481 : 'KW' '481';\n");
+		grammarBuilder.append("KW482 : 'KW' '482';\n");
+		grammarBuilder.append("KW483 : 'KW' '483';\n");
+		grammarBuilder.append("KW484 : 'KW' '484';\n");
+		grammarBuilder.append("KW485 : 'KW' '485';\n");
+		grammarBuilder.append("KW486 : 'KW' '486';\n");
+		grammarBuilder.append("KW487 : 'KW' '487';\n");
+		grammarBuilder.append("KW488 : 'KW' '488';\n");
+		grammarBuilder.append("KW489 : 'KW' '489';\n");
+		grammarBuilder.append("KW490 : 'KW' '490';\n");
+		grammarBuilder.append("KW491 : 'KW' '491';\n");
+		grammarBuilder.append("KW492 : 'KW' '492';\n");
+		grammarBuilder.append("KW493 : 'KW' '493';\n");
+		grammarBuilder.append("KW494 : 'KW' '494';\n");
+		grammarBuilder.append("KW495 : 'KW' '495';\n");
+		grammarBuilder.append("KW496 : 'KW' '496';\n");
+		grammarBuilder.append("KW497 : 'KW' '497';\n");
+		grammarBuilder.append("KW498 : 'KW' '498';\n");
+		grammarBuilder.append("KW499 : 'KW' '499';\n");
+		grammarBuilder.append("KW500 : 'KW' '500';\n");
+		grammarBuilder.append("KW501 : 'KW' '501';\n");
+		grammarBuilder.append("KW502 : 'KW' '502';\n");
+		grammarBuilder.append("KW503 : 'KW' '503';\n");
+		grammarBuilder.append("KW504 : 'KW' '504';\n");
+		grammarBuilder.append("KW505 : 'KW' '505';\n");
+		grammarBuilder.append("KW506 : 'KW' '506';\n");
+		grammarBuilder.append("KW507 : 'KW' '507';\n");
+		grammarBuilder.append("KW508 : 'KW' '508';\n");
+		grammarBuilder.append("KW509 : 'KW' '509';\n");
+		grammarBuilder.append("KW510 : 'KW' '510';\n");
+		grammarBuilder.append("KW511 : 'KW' '511';\n");
+		grammarBuilder.append("KW512 : 'KW' '512';\n");
+		grammarBuilder.append("KW513 : 'KW' '513';\n");
+		grammarBuilder.append("KW514 : 'KW' '514';\n");
+		grammarBuilder.append("KW515 : 'KW' '515';\n");
+		grammarBuilder.append("KW516 : 'KW' '516';\n");
+		grammarBuilder.append("KW517 : 'KW' '517';\n");
+		grammarBuilder.append("KW518 : 'KW' '518';\n");
+		grammarBuilder.append("KW519 : 'KW' '519';\n");
+		grammarBuilder.append("KW520 : 'KW' '520';\n");
+		grammarBuilder.append("KW521 : 'KW' '521';\n");
+		grammarBuilder.append("KW522 : 'KW' '522';\n");
+		grammarBuilder.append("KW523 : 'KW' '523';\n");
+		grammarBuilder.append("KW524 : 'KW' '524';\n");
+		grammarBuilder.append("KW525 : 'KW' '525';\n");
+		grammarBuilder.append("KW526 : 'KW' '526';\n");
+		grammarBuilder.append("KW527 : 'KW' '527';\n");
+		grammarBuilder.append("KW528 : 'KW' '528';\n");
+		grammarBuilder.append("KW529 : 'KW' '529';\n");
+		grammarBuilder.append("KW530 : 'KW' '530';\n");
+		grammarBuilder.append("KW531 : 'KW' '531';\n");
+		grammarBuilder.append("KW532 : 'KW' '532';\n");
+		grammarBuilder.append("KW533 : 'KW' '533';\n");
+		grammarBuilder.append("KW534 : 'KW' '534';\n");
+		grammarBuilder.append("KW535 : 'KW' '535';\n");
+		grammarBuilder.append("KW536 : 'KW' '536';\n");
+		grammarBuilder.append("KW537 : 'KW' '537';\n");
+		grammarBuilder.append("KW538 : 'KW' '538';\n");
+		grammarBuilder.append("KW539 : 'KW' '539';\n");
+		grammarBuilder.append("KW540 : 'KW' '540';\n");
+		grammarBuilder.append("KW541 : 'KW' '541';\n");
+		grammarBuilder.append("KW542 : 'KW' '542';\n");
+		grammarBuilder.append("KW543 : 'KW' '543';\n");
+		grammarBuilder.append("KW544 : 'KW' '544';\n");
+		grammarBuilder.append("KW545 : 'KW' '545';\n");
+		grammarBuilder.append("KW546 : 'KW' '546';\n");
+		grammarBuilder.append("KW547 : 'KW' '547';\n");
+		grammarBuilder.append("KW548 : 'KW' '548';\n");
+		grammarBuilder.append("KW549 : 'KW' '549';\n");
+		grammarBuilder.append("KW550 : 'KW' '550';\n");
+		grammarBuilder.append("KW551 : 'KW' '551';\n");
+		grammarBuilder.append("KW552 : 'KW' '552';\n");
+		grammarBuilder.append("KW553 : 'KW' '553';\n");
+		grammarBuilder.append("KW554 : 'KW' '554';\n");
+		grammarBuilder.append("KW555 : 'KW' '555';\n");
+		grammarBuilder.append("KW556 : 'KW' '556';\n");
+		grammarBuilder.append("KW557 : 'KW' '557';\n");
+		grammarBuilder.append("KW558 : 'KW' '558';\n");
+		grammarBuilder.append("KW559 : 'KW' '559';\n");
+		grammarBuilder.append("KW560 : 'KW' '560';\n");
+		grammarBuilder.append("KW561 : 'KW' '561';\n");
+		grammarBuilder.append("KW562 : 'KW' '562';\n");
+		grammarBuilder.append("KW563 : 'KW' '563';\n");
+		grammarBuilder.append("KW564 : 'KW' '564';\n");
+		grammarBuilder.append("KW565 : 'KW' '565';\n");
+		grammarBuilder.append("KW566 : 'KW' '566';\n");
+		grammarBuilder.append("KW567 : 'KW' '567';\n");
+		grammarBuilder.append("KW568 : 'KW' '568';\n");
+		grammarBuilder.append("KW569 : 'KW' '569';\n");
+		grammarBuilder.append("KW570 : 'KW' '570';\n");
+		grammarBuilder.append("KW571 : 'KW' '571';\n");
+		grammarBuilder.append("KW572 : 'KW' '572';\n");
+		grammarBuilder.append("KW573 : 'KW' '573';\n");
+		grammarBuilder.append("KW574 : 'KW' '574';\n");
+		grammarBuilder.append("KW575 : 'KW' '575';\n");
+		grammarBuilder.append("KW576 : 'KW' '576';\n");
+		grammarBuilder.append("KW577 : 'KW' '577';\n");
+		grammarBuilder.append("KW578 : 'KW' '578';\n");
+		grammarBuilder.append("KW579 : 'KW' '579';\n");
+		grammarBuilder.append("KW580 : 'KW' '580';\n");
+		grammarBuilder.append("KW581 : 'KW' '581';\n");
+		grammarBuilder.append("KW582 : 'KW' '582';\n");
+		grammarBuilder.append("KW583 : 'KW' '583';\n");
+		grammarBuilder.append("KW584 : 'KW' '584';\n");
+		grammarBuilder.append("KW585 : 'KW' '585';\n");
+		grammarBuilder.append("KW586 : 'KW' '586';\n");
+		grammarBuilder.append("KW587 : 'KW' '587';\n");
+		grammarBuilder.append("KW588 : 'KW' '588';\n");
+		grammarBuilder.append("KW589 : 'KW' '589';\n");
+		grammarBuilder.append("KW590 : 'KW' '590';\n");
+		grammarBuilder.append("KW591 : 'KW' '591';\n");
+		grammarBuilder.append("KW592 : 'KW' '592';\n");
+		grammarBuilder.append("KW593 : 'KW' '593';\n");
+		grammarBuilder.append("KW594 : 'KW' '594';\n");
+		grammarBuilder.append("KW595 : 'KW' '595';\n");
+		grammarBuilder.append("KW596 : 'KW' '596';\n");
+		grammarBuilder.append("KW597 : 'KW' '597';\n");
+		grammarBuilder.append("KW598 : 'KW' '598';\n");
+		grammarBuilder.append("KW599 : 'KW' '599';\n");
+		grammarBuilder.append("KW600 : 'KW' '600';\n");
+		grammarBuilder.append("KW601 : 'KW' '601';\n");
+		grammarBuilder.append("KW602 : 'KW' '602';\n");
+		grammarBuilder.append("KW603 : 'KW' '603';\n");
+		grammarBuilder.append("KW604 : 'KW' '604';\n");
+		grammarBuilder.append("KW605 : 'KW' '605';\n");
+		grammarBuilder.append("KW606 : 'KW' '606';\n");
+		grammarBuilder.append("KW607 : 'KW' '607';\n");
+		grammarBuilder.append("KW608 : 'KW' '608';\n");
+		grammarBuilder.append("KW609 : 'KW' '609';\n");
+		grammarBuilder.append("KW610 : 'KW' '610';\n");
+		grammarBuilder.append("KW611 : 'KW' '611';\n");
+		grammarBuilder.append("KW612 : 'KW' '612';\n");
+		grammarBuilder.append("KW613 : 'KW' '613';\n");
+		grammarBuilder.append("KW614 : 'KW' '614';\n");
+		grammarBuilder.append("KW615 : 'KW' '615';\n");
+		grammarBuilder.append("KW616 : 'KW' '616';\n");
+		grammarBuilder.append("KW617 : 'KW' '617';\n");
+		grammarBuilder.append("KW618 : 'KW' '618';\n");
+		grammarBuilder.append("KW619 : 'KW' '619';\n");
+		grammarBuilder.append("KW620 : 'KW' '620';\n");
+		grammarBuilder.append("KW621 : 'KW' '621';\n");
+		grammarBuilder.append("KW622 : 'KW' '622';\n");
+		grammarBuilder.append("KW623 : 'KW' '623';\n");
+		grammarBuilder.append("KW624 : 'KW' '624';\n");
+		grammarBuilder.append("KW625 : 'KW' '625';\n");
+		grammarBuilder.append("KW626 : 'KW' '626';\n");
+		grammarBuilder.append("KW627 : 'KW' '627';\n");
+		grammarBuilder.append("KW628 : 'KW' '628';\n");
+		grammarBuilder.append("KW629 : 'KW' '629';\n");
+		grammarBuilder.append("KW630 : 'KW' '630';\n");
+		grammarBuilder.append("KW631 : 'KW' '631';\n");
+		grammarBuilder.append("KW632 : 'KW' '632';\n");
+		grammarBuilder.append("KW633 : 'KW' '633';\n");
+		grammarBuilder.append("KW634 : 'KW' '634';\n");
+		grammarBuilder.append("KW635 : 'KW' '635';\n");
+		grammarBuilder.append("KW636 : 'KW' '636';\n");
+		grammarBuilder.append("KW637 : 'KW' '637';\n");
+		grammarBuilder.append("KW638 : 'KW' '638';\n");
+		grammarBuilder.append("KW639 : 'KW' '639';\n");
+		grammarBuilder.append("KW640 : 'KW' '640';\n");
+		grammarBuilder.append("KW641 : 'KW' '641';\n");
+		grammarBuilder.append("KW642 : 'KW' '642';\n");
+		grammarBuilder.append("KW643 : 'KW' '643';\n");
+		grammarBuilder.append("KW644 : 'KW' '644';\n");
+		grammarBuilder.append("KW645 : 'KW' '645';\n");
+		grammarBuilder.append("KW646 : 'KW' '646';\n");
+		grammarBuilder.append("KW647 : 'KW' '647';\n");
+		grammarBuilder.append("KW648 : 'KW' '648';\n");
+		grammarBuilder.append("KW649 : 'KW' '649';\n");
+		grammarBuilder.append("KW650 : 'KW' '650';\n");
+		grammarBuilder.append("KW651 : 'KW' '651';\n");
+		grammarBuilder.append("KW652 : 'KW' '652';\n");
+		grammarBuilder.append("KW653 : 'KW' '653';\n");
+		grammarBuilder.append("KW654 : 'KW' '654';\n");
+		grammarBuilder.append("KW655 : 'KW' '655';\n");
+		grammarBuilder.append("KW656 : 'KW' '656';\n");
+		grammarBuilder.append("KW657 : 'KW' '657';\n");
+		grammarBuilder.append("KW658 : 'KW' '658';\n");
+		grammarBuilder.append("KW659 : 'KW' '659';\n");
+		grammarBuilder.append("KW660 : 'KW' '660';\n");
+		grammarBuilder.append("KW661 : 'KW' '661';\n");
+		grammarBuilder.append("KW662 : 'KW' '662';\n");
+		grammarBuilder.append("KW663 : 'KW' '663';\n");
+		grammarBuilder.append("KW664 : 'KW' '664';\n");
+		grammarBuilder.append("KW665 : 'KW' '665';\n");
+		grammarBuilder.append("KW666 : 'KW' '666';\n");
+		grammarBuilder.append("KW667 : 'KW' '667';\n");
+		grammarBuilder.append("KW668 : 'KW' '668';\n");
+		grammarBuilder.append("KW669 : 'KW' '669';\n");
+		grammarBuilder.append("KW670 : 'KW' '670';\n");
+		grammarBuilder.append("KW671 : 'KW' '671';\n");
+		grammarBuilder.append("KW672 : 'KW' '672';\n");
+		grammarBuilder.append("KW673 : 'KW' '673';\n");
+		grammarBuilder.append("KW674 : 'KW' '674';\n");
+		grammarBuilder.append("KW675 : 'KW' '675';\n");
+		grammarBuilder.append("KW676 : 'KW' '676';\n");
+		grammarBuilder.append("KW677 : 'KW' '677';\n");
+		grammarBuilder.append("KW678 : 'KW' '678';\n");
+		grammarBuilder.append("KW679 : 'KW' '679';\n");
+		grammarBuilder.append("KW680 : 'KW' '680';\n");
+		grammarBuilder.append("KW681 : 'KW' '681';\n");
+		grammarBuilder.append("KW682 : 'KW' '682';\n");
+		grammarBuilder.append("KW683 : 'KW' '683';\n");
+		grammarBuilder.append("KW684 : 'KW' '684';\n");
+		grammarBuilder.append("KW685 : 'KW' '685';\n");
+		grammarBuilder.append("KW686 : 'KW' '686';\n");
+		grammarBuilder.append("KW687 : 'KW' '687';\n");
+		grammarBuilder.append("KW688 : 'KW' '688';\n");
+		grammarBuilder.append("KW689 : 'KW' '689';\n");
+		grammarBuilder.append("KW690 : 'KW' '690';\n");
+		grammarBuilder.append("KW691 : 'KW' '691';\n");
+		grammarBuilder.append("KW692 : 'KW' '692';\n");
+		grammarBuilder.append("KW693 : 'KW' '693';\n");
+		grammarBuilder.append("KW694 : 'KW' '694';\n");
+		grammarBuilder.append("KW695 : 'KW' '695';\n");
+		grammarBuilder.append("KW696 : 'KW' '696';\n");
+		grammarBuilder.append("KW697 : 'KW' '697';\n");
+		grammarBuilder.append("KW698 : 'KW' '698';\n");
+		grammarBuilder.append("KW699 : 'KW' '699';\n");
+		grammarBuilder.append("KW700 : 'KW' '700';\n");
+		grammarBuilder.append("KW701 : 'KW' '701';\n");
+		grammarBuilder.append("KW702 : 'KW' '702';\n");
+		grammarBuilder.append("KW703 : 'KW' '703';\n");
+		grammarBuilder.append("KW704 : 'KW' '704';\n");
+		grammarBuilder.append("KW705 : 'KW' '705';\n");
+		grammarBuilder.append("KW706 : 'KW' '706';\n");
+		grammarBuilder.append("KW707 : 'KW' '707';\n");
+		grammarBuilder.append("KW708 : 'KW' '708';\n");
+		grammarBuilder.append("KW709 : 'KW' '709';\n");
+		grammarBuilder.append("KW710 : 'KW' '710';\n");
+		grammarBuilder.append("KW711 : 'KW' '711';\n");
+		grammarBuilder.append("KW712 : 'KW' '712';\n");
+		grammarBuilder.append("KW713 : 'KW' '713';\n");
+		grammarBuilder.append("KW714 : 'KW' '714';\n");
+		grammarBuilder.append("KW715 : 'KW' '715';\n");
+		grammarBuilder.append("KW716 : 'KW' '716';\n");
+		grammarBuilder.append("KW717 : 'KW' '717';\n");
+		grammarBuilder.append("KW718 : 'KW' '718';\n");
+		grammarBuilder.append("KW719 : 'KW' '719';\n");
+		grammarBuilder.append("KW720 : 'KW' '720';\n");
+		grammarBuilder.append("KW721 : 'KW' '721';\n");
+		grammarBuilder.append("KW722 : 'KW' '722';\n");
+		grammarBuilder.append("KW723 : 'KW' '723';\n");
+		grammarBuilder.append("KW724 : 'KW' '724';\n");
+		grammarBuilder.append("KW725 : 'KW' '725';\n");
+		grammarBuilder.append("KW726 : 'KW' '726';\n");
+		grammarBuilder.append("KW727 : 'KW' '727';\n");
+		grammarBuilder.append("KW728 : 'KW' '728';\n");
+		grammarBuilder.append("KW729 : 'KW' '729';\n");
+		grammarBuilder.append("KW730 : 'KW' '730';\n");
+		grammarBuilder.append("KW731 : 'KW' '731';\n");
+		grammarBuilder.append("KW732 : 'KW' '732';\n");
+		grammarBuilder.append("KW733 : 'KW' '733';\n");
+		grammarBuilder.append("KW734 : 'KW' '734';\n");
+		grammarBuilder.append("KW735 : 'KW' '735';\n");
+		grammarBuilder.append("KW736 : 'KW' '736';\n");
+		grammarBuilder.append("KW737 : 'KW' '737';\n");
+		grammarBuilder.append("KW738 : 'KW' '738';\n");
+		grammarBuilder.append("KW739 : 'KW' '739';\n");
+		grammarBuilder.append("KW740 : 'KW' '740';\n");
+		grammarBuilder.append("KW741 : 'KW' '741';\n");
+		grammarBuilder.append("KW742 : 'KW' '742';\n");
+		grammarBuilder.append("KW743 : 'KW' '743';\n");
+		grammarBuilder.append("KW744 : 'KW' '744';\n");
+		grammarBuilder.append("KW745 : 'KW' '745';\n");
+		grammarBuilder.append("KW746 : 'KW' '746';\n");
+		grammarBuilder.append("KW747 : 'KW' '747';\n");
+		grammarBuilder.append("KW748 : 'KW' '748';\n");
+		grammarBuilder.append("KW749 : 'KW' '749';\n");
+		grammarBuilder.append("KW750 : 'KW' '750';\n");
+		grammarBuilder.append("KW751 : 'KW' '751';\n");
+		grammarBuilder.append("KW752 : 'KW' '752';\n");
+		grammarBuilder.append("KW753 : 'KW' '753';\n");
+		grammarBuilder.append("KW754 : 'KW' '754';\n");
+		grammarBuilder.append("KW755 : 'KW' '755';\n");
+		grammarBuilder.append("KW756 : 'KW' '756';\n");
+		grammarBuilder.append("KW757 : 'KW' '757';\n");
+		grammarBuilder.append("KW758 : 'KW' '758';\n");
+		grammarBuilder.append("KW759 : 'KW' '759';\n");
+		grammarBuilder.append("KW760 : 'KW' '760';\n");
+		grammarBuilder.append("KW761 : 'KW' '761';\n");
+		grammarBuilder.append("KW762 : 'KW' '762';\n");
+		grammarBuilder.append("KW763 : 'KW' '763';\n");
+		grammarBuilder.append("KW764 : 'KW' '764';\n");
+		grammarBuilder.append("KW765 : 'KW' '765';\n");
+		grammarBuilder.append("KW766 : 'KW' '766';\n");
+		grammarBuilder.append("KW767 : 'KW' '767';\n");
+		grammarBuilder.append("KW768 : 'KW' '768';\n");
+		grammarBuilder.append("KW769 : 'KW' '769';\n");
+		grammarBuilder.append("KW770 : 'KW' '770';\n");
+		grammarBuilder.append("KW771 : 'KW' '771';\n");
+		grammarBuilder.append("KW772 : 'KW' '772';\n");
+		grammarBuilder.append("KW773 : 'KW' '773';\n");
+		grammarBuilder.append("KW774 : 'KW' '774';\n");
+		grammarBuilder.append("KW775 : 'KW' '775';\n");
+		grammarBuilder.append("KW776 : 'KW' '776';\n");
+		grammarBuilder.append("KW777 : 'KW' '777';\n");
+		grammarBuilder.append("KW778 : 'KW' '778';\n");
+		grammarBuilder.append("KW779 : 'KW' '779';\n");
+		grammarBuilder.append("KW780 : 'KW' '780';\n");
+		grammarBuilder.append("KW781 : 'KW' '781';\n");
+		grammarBuilder.append("KW782 : 'KW' '782';\n");
+		grammarBuilder.append("KW783 : 'KW' '783';\n");
+		grammarBuilder.append("KW784 : 'KW' '784';\n");
+		grammarBuilder.append("KW785 : 'KW' '785';\n");
+		grammarBuilder.append("KW786 : 'KW' '786';\n");
+		grammarBuilder.append("KW787 : 'KW' '787';\n");
+		grammarBuilder.append("KW788 : 'KW' '788';\n");
+		grammarBuilder.append("KW789 : 'KW' '789';\n");
+		grammarBuilder.append("KW790 : 'KW' '790';\n");
+		grammarBuilder.append("KW791 : 'KW' '791';\n");
+		grammarBuilder.append("KW792 : 'KW' '792';\n");
+		grammarBuilder.append("KW793 : 'KW' '793';\n");
+		grammarBuilder.append("KW794 : 'KW' '794';\n");
+		grammarBuilder.append("KW795 : 'KW' '795';\n");
+		grammarBuilder.append("KW796 : 'KW' '796';\n");
+		grammarBuilder.append("KW797 : 'KW' '797';\n");
+		grammarBuilder.append("KW798 : 'KW' '798';\n");
+		grammarBuilder.append("KW799 : 'KW' '799';\n");
+		grammarBuilder.append("KW800 : 'KW' '800';\n");
+		grammarBuilder.append("KW801 : 'KW' '801';\n");
+		grammarBuilder.append("KW802 : 'KW' '802';\n");
+		grammarBuilder.append("KW803 : 'KW' '803';\n");
+		grammarBuilder.append("KW804 : 'KW' '804';\n");
+		grammarBuilder.append("KW805 : 'KW' '805';\n");
+		grammarBuilder.append("KW806 : 'KW' '806';\n");
+		grammarBuilder.append("KW807 : 'KW' '807';\n");
+		grammarBuilder.append("KW808 : 'KW' '808';\n");
+		grammarBuilder.append("KW809 : 'KW' '809';\n");
+		grammarBuilder.append("KW810 : 'KW' '810';\n");
+		grammarBuilder.append("KW811 : 'KW' '811';\n");
+		grammarBuilder.append("KW812 : 'KW' '812';\n");
+		grammarBuilder.append("KW813 : 'KW' '813';\n");
+		grammarBuilder.append("KW814 : 'KW' '814';\n");
+		grammarBuilder.append("KW815 : 'KW' '815';\n");
+		grammarBuilder.append("KW816 : 'KW' '816';\n");
+		grammarBuilder.append("KW817 : 'KW' '817';\n");
+		grammarBuilder.append("KW818 : 'KW' '818';\n");
+		grammarBuilder.append("KW819 : 'KW' '819';\n");
+		grammarBuilder.append("KW820 : 'KW' '820';\n");
+		grammarBuilder.append("KW821 : 'KW' '821';\n");
+		grammarBuilder.append("KW822 : 'KW' '822';\n");
+		grammarBuilder.append("KW823 : 'KW' '823';\n");
+		grammarBuilder.append("KW824 : 'KW' '824';\n");
+		grammarBuilder.append("KW825 : 'KW' '825';\n");
+		grammarBuilder.append("KW826 : 'KW' '826';\n");
+		grammarBuilder.append("KW827 : 'KW' '827';\n");
+		grammarBuilder.append("KW828 : 'KW' '828';\n");
+		grammarBuilder.append("KW829 : 'KW' '829';\n");
+		grammarBuilder.append("KW830 : 'KW' '830';\n");
+		grammarBuilder.append("KW831 : 'KW' '831';\n");
+		grammarBuilder.append("KW832 : 'KW' '832';\n");
+		grammarBuilder.append("KW833 : 'KW' '833';\n");
+		grammarBuilder.append("KW834 : 'KW' '834';\n");
+		grammarBuilder.append("KW835 : 'KW' '835';\n");
+		grammarBuilder.append("KW836 : 'KW' '836';\n");
+		grammarBuilder.append("KW837 : 'KW' '837';\n");
+		grammarBuilder.append("KW838 : 'KW' '838';\n");
+		grammarBuilder.append("KW839 : 'KW' '839';\n");
+		grammarBuilder.append("KW840 : 'KW' '840';\n");
+		grammarBuilder.append("KW841 : 'KW' '841';\n");
+		grammarBuilder.append("KW842 : 'KW' '842';\n");
+		grammarBuilder.append("KW843 : 'KW' '843';\n");
+		grammarBuilder.append("KW844 : 'KW' '844';\n");
+		grammarBuilder.append("KW845 : 'KW' '845';\n");
+		grammarBuilder.append("KW846 : 'KW' '846';\n");
+		grammarBuilder.append("KW847 : 'KW' '847';\n");
+		grammarBuilder.append("KW848 : 'KW' '848';\n");
+		grammarBuilder.append("KW849 : 'KW' '849';\n");
+		grammarBuilder.append("KW850 : 'KW' '850';\n");
+		grammarBuilder.append("KW851 : 'KW' '851';\n");
+		grammarBuilder.append("KW852 : 'KW' '852';\n");
+		grammarBuilder.append("KW853 : 'KW' '853';\n");
+		grammarBuilder.append("KW854 : 'KW' '854';\n");
+		grammarBuilder.append("KW855 : 'KW' '855';\n");
+		grammarBuilder.append("KW856 : 'KW' '856';\n");
+		grammarBuilder.append("KW857 : 'KW' '857';\n");
+		grammarBuilder.append("KW858 : 'KW' '858';\n");
+		grammarBuilder.append("KW859 : 'KW' '859';\n");
+		grammarBuilder.append("KW860 : 'KW' '860';\n");
+		grammarBuilder.append("KW861 : 'KW' '861';\n");
+		grammarBuilder.append("KW862 : 'KW' '862';\n");
+		grammarBuilder.append("KW863 : 'KW' '863';\n");
+		grammarBuilder.append("KW864 : 'KW' '864';\n");
+		grammarBuilder.append("KW865 : 'KW' '865';\n");
+		grammarBuilder.append("KW866 : 'KW' '866';\n");
+		grammarBuilder.append("KW867 : 'KW' '867';\n");
+		grammarBuilder.append("KW868 : 'KW' '868';\n");
+		grammarBuilder.append("KW869 : 'KW' '869';\n");
+		grammarBuilder.append("KW870 : 'KW' '870';\n");
+		grammarBuilder.append("KW871 : 'KW' '871';\n");
+		grammarBuilder.append("KW872 : 'KW' '872';\n");
+		grammarBuilder.append("KW873 : 'KW' '873';\n");
+		grammarBuilder.append("KW874 : 'KW' '874';\n");
+		grammarBuilder.append("KW875 : 'KW' '875';\n");
+		grammarBuilder.append("KW876 : 'KW' '876';\n");
+		grammarBuilder.append("KW877 : 'KW' '877';\n");
+		grammarBuilder.append("KW878 : 'KW' '878';\n");
+		grammarBuilder.append("KW879 : 'KW' '879';\n");
+		grammarBuilder.append("KW880 : 'KW' '880';\n");
+		grammarBuilder.append("KW881 : 'KW' '881';\n");
+		grammarBuilder.append("KW882 : 'KW' '882';\n");
+		grammarBuilder.append("KW883 : 'KW' '883';\n");
+		grammarBuilder.append("KW884 : 'KW' '884';\n");
+		grammarBuilder.append("KW885 : 'KW' '885';\n");
+		grammarBuilder.append("KW886 : 'KW' '886';\n");
+		grammarBuilder.append("KW887 : 'KW' '887';\n");
+		grammarBuilder.append("KW888 : 'KW' '888';\n");
+		grammarBuilder.append("KW889 : 'KW' '889';\n");
+		grammarBuilder.append("KW890 : 'KW' '890';\n");
+		grammarBuilder.append("KW891 : 'KW' '891';\n");
+		grammarBuilder.append("KW892 : 'KW' '892';\n");
+		grammarBuilder.append("KW893 : 'KW' '893';\n");
+		grammarBuilder.append("KW894 : 'KW' '894';\n");
+		grammarBuilder.append("KW895 : 'KW' '895';\n");
+		grammarBuilder.append("KW896 : 'KW' '896';\n");
+		grammarBuilder.append("KW897 : 'KW' '897';\n");
+		grammarBuilder.append("KW898 : 'KW' '898';\n");
+		grammarBuilder.append("KW899 : 'KW' '899';\n");
+		grammarBuilder.append("KW900 : 'KW' '900';\n");
+		grammarBuilder.append("KW901 : 'KW' '901';\n");
+		grammarBuilder.append("KW902 : 'KW' '902';\n");
+		grammarBuilder.append("KW903 : 'KW' '903';\n");
+		grammarBuilder.append("KW904 : 'KW' '904';\n");
+		grammarBuilder.append("KW905 : 'KW' '905';\n");
+		grammarBuilder.append("KW906 : 'KW' '906';\n");
+		grammarBuilder.append("KW907 : 'KW' '907';\n");
+		grammarBuilder.append("KW908 : 'KW' '908';\n");
+		grammarBuilder.append("KW909 : 'KW' '909';\n");
+		grammarBuilder.append("KW910 : 'KW' '910';\n");
+		grammarBuilder.append("KW911 : 'KW' '911';\n");
+		grammarBuilder.append("KW912 : 'KW' '912';\n");
+		grammarBuilder.append("KW913 : 'KW' '913';\n");
+		grammarBuilder.append("KW914 : 'KW' '914';\n");
+		grammarBuilder.append("KW915 : 'KW' '915';\n");
+		grammarBuilder.append("KW916 : 'KW' '916';\n");
+		grammarBuilder.append("KW917 : 'KW' '917';\n");
+		grammarBuilder.append("KW918 : 'KW' '918';\n");
+		grammarBuilder.append("KW919 : 'KW' '919';\n");
+		grammarBuilder.append("KW920 : 'KW' '920';\n");
+		grammarBuilder.append("KW921 : 'KW' '921';\n");
+		grammarBuilder.append("KW922 : 'KW' '922';\n");
+		grammarBuilder.append("KW923 : 'KW' '923';\n");
+		grammarBuilder.append("KW924 : 'KW' '924';\n");
+		grammarBuilder.append("KW925 : 'KW' '925';\n");
+		grammarBuilder.append("KW926 : 'KW' '926';\n");
+		grammarBuilder.append("KW927 : 'KW' '927';\n");
+		grammarBuilder.append("KW928 : 'KW' '928';\n");
+		grammarBuilder.append("KW929 : 'KW' '929';\n");
+		grammarBuilder.append("KW930 : 'KW' '930';\n");
+		grammarBuilder.append("KW931 : 'KW' '931';\n");
+		grammarBuilder.append("KW932 : 'KW' '932';\n");
+		grammarBuilder.append("KW933 : 'KW' '933';\n");
+		grammarBuilder.append("KW934 : 'KW' '934';\n");
+		grammarBuilder.append("KW935 : 'KW' '935';\n");
+		grammarBuilder.append("KW936 : 'KW' '936';\n");
+		grammarBuilder.append("KW937 : 'KW' '937';\n");
+		grammarBuilder.append("KW938 : 'KW' '938';\n");
+		grammarBuilder.append("KW939 : 'KW' '939';\n");
+		grammarBuilder.append("KW940 : 'KW' '940';\n");
+		grammarBuilder.append("KW941 : 'KW' '941';\n");
+		grammarBuilder.append("KW942 : 'KW' '942';\n");
+		grammarBuilder.append("KW943 : 'KW' '943';\n");
+		grammarBuilder.append("KW944 : 'KW' '944';\n");
+		grammarBuilder.append("KW945 : 'KW' '945';\n");
+		grammarBuilder.append("KW946 : 'KW' '946';\n");
+		grammarBuilder.append("KW947 : 'KW' '947';\n");
+		grammarBuilder.append("KW948 : 'KW' '948';\n");
+		grammarBuilder.append("KW949 : 'KW' '949';\n");
+		grammarBuilder.append("KW950 : 'KW' '950';\n");
+		grammarBuilder.append("KW951 : 'KW' '951';\n");
+		grammarBuilder.append("KW952 : 'KW' '952';\n");
+		grammarBuilder.append("KW953 : 'KW' '953';\n");
+		grammarBuilder.append("KW954 : 'KW' '954';\n");
+		grammarBuilder.append("KW955 : 'KW' '955';\n");
+		grammarBuilder.append("KW956 : 'KW' '956';\n");
+		grammarBuilder.append("KW957 : 'KW' '957';\n");
+		grammarBuilder.append("KW958 : 'KW' '958';\n");
+		grammarBuilder.append("KW959 : 'KW' '959';\n");
+		grammarBuilder.append("KW960 : 'KW' '960';\n");
+		grammarBuilder.append("KW961 : 'KW' '961';\n");
+		grammarBuilder.append("KW962 : 'KW' '962';\n");
+		grammarBuilder.append("KW963 : 'KW' '963';\n");
+		grammarBuilder.append("KW964 : 'KW' '964';\n");
+		grammarBuilder.append("KW965 : 'KW' '965';\n");
+		grammarBuilder.append("KW966 : 'KW' '966';\n");
+		grammarBuilder.append("KW967 : 'KW' '967';\n");
+		grammarBuilder.append("KW968 : 'KW' '968';\n");
+		grammarBuilder.append("KW969 : 'KW' '969';\n");
+		grammarBuilder.append("KW970 : 'KW' '970';\n");
+		grammarBuilder.append("KW971 : 'KW' '971';\n");
+		grammarBuilder.append("KW972 : 'KW' '972';\n");
+		grammarBuilder.append("KW973 : 'KW' '973';\n");
+		grammarBuilder.append("KW974 : 'KW' '974';\n");
+		grammarBuilder.append("KW975 : 'KW' '975';\n");
+		grammarBuilder.append("KW976 : 'KW' '976';\n");
+		grammarBuilder.append("KW977 : 'KW' '977';\n");
+		grammarBuilder.append("KW978 : 'KW' '978';\n");
+		grammarBuilder.append("KW979 : 'KW' '979';\n");
+		grammarBuilder.append("KW980 : 'KW' '980';\n");
+		grammarBuilder.append("KW981 : 'KW' '981';\n");
+		grammarBuilder.append("KW982 : 'KW' '982';\n");
+		grammarBuilder.append("KW983 : 'KW' '983';\n");
+		grammarBuilder.append("KW984 : 'KW' '984';\n");
+		grammarBuilder.append("KW985 : 'KW' '985';\n");
+		grammarBuilder.append("KW986 : 'KW' '986';\n");
+		grammarBuilder.append("KW987 : 'KW' '987';\n");
+		grammarBuilder.append("KW988 : 'KW' '988';\n");
+		grammarBuilder.append("KW989 : 'KW' '989';\n");
+		grammarBuilder.append("KW990 : 'KW' '990';\n");
+		grammarBuilder.append("KW991 : 'KW' '991';\n");
+		grammarBuilder.append("KW992 : 'KW' '992';\n");
+		grammarBuilder.append("KW993 : 'KW' '993';\n");
+		grammarBuilder.append("KW994 : 'KW' '994';\n");
+		grammarBuilder.append("KW995 : 'KW' '995';\n");
+		grammarBuilder.append("KW996 : 'KW' '996';\n");
+		grammarBuilder.append("KW997 : 'KW' '997';\n");
+		grammarBuilder.append("KW998 : 'KW' '998';\n");
+		grammarBuilder.append("KW999 : 'KW' '999';\n");
+		grammarBuilder.append("KW1000 : 'KW' '1000';\n");
+		grammarBuilder.append("KW1001 : 'KW' '1001';\n");
+		grammarBuilder.append("KW1002 : 'KW' '1002';\n");
+		grammarBuilder.append("KW1003 : 'KW' '1003';\n");
+		grammarBuilder.append("KW1004 : 'KW' '1004';\n");
+		grammarBuilder.append("KW1005 : 'KW' '1005';\n");
+		grammarBuilder.append("KW1006 : 'KW' '1006';\n");
+		grammarBuilder.append("KW1007 : 'KW' '1007';\n");
+		grammarBuilder.append("KW1008 : 'KW' '1008';\n");
+		grammarBuilder.append("KW1009 : 'KW' '1009';\n");
+		grammarBuilder.append("KW1010 : 'KW' '1010';\n");
+		grammarBuilder.append("KW1011 : 'KW' '1011';\n");
+		grammarBuilder.append("KW1012 : 'KW' '1012';\n");
+		grammarBuilder.append("KW1013 : 'KW' '1013';\n");
+		grammarBuilder.append("KW1014 : 'KW' '1014';\n");
+		grammarBuilder.append("KW1015 : 'KW' '1015';\n");
+		grammarBuilder.append("KW1016 : 'KW' '1016';\n");
+		grammarBuilder.append("KW1017 : 'KW' '1017';\n");
+		grammarBuilder.append("KW1018 : 'KW' '1018';\n");
+		grammarBuilder.append("KW1019 : 'KW' '1019';\n");
+		grammarBuilder.append("KW1020 : 'KW' '1020';\n");
+		grammarBuilder.append("KW1021 : 'KW' '1021';\n");
+		grammarBuilder.append("KW1022 : 'KW' '1022';\n");
+		grammarBuilder.append("KW1023 : 'KW' '1023';\n");
+		grammarBuilder.append("KW1024 : 'KW' '1024';\n");
+		grammarBuilder.append("KW1025 : 'KW' '1025';\n");
+		grammarBuilder.append("KW1026 : 'KW' '1026';\n");
+		grammarBuilder.append("KW1027 : 'KW' '1027';\n");
+		grammarBuilder.append("KW1028 : 'KW' '1028';\n");
+		grammarBuilder.append("KW1029 : 'KW' '1029';\n");
+		grammarBuilder.append("KW1030 : 'KW' '1030';\n");
+		grammarBuilder.append("KW1031 : 'KW' '1031';\n");
+		grammarBuilder.append("KW1032 : 'KW' '1032';\n");
+		grammarBuilder.append("KW1033 : 'KW' '1033';\n");
+		grammarBuilder.append("KW1034 : 'KW' '1034';\n");
+		grammarBuilder.append("KW1035 : 'KW' '1035';\n");
+		grammarBuilder.append("KW1036 : 'KW' '1036';\n");
+		grammarBuilder.append("KW1037 : 'KW' '1037';\n");
+		grammarBuilder.append("KW1038 : 'KW' '1038';\n");
+		grammarBuilder.append("KW1039 : 'KW' '1039';\n");
+		grammarBuilder.append("KW1040 : 'KW' '1040';\n");
+		grammarBuilder.append("KW1041 : 'KW' '1041';\n");
+		grammarBuilder.append("KW1042 : 'KW' '1042';\n");
+		grammarBuilder.append("KW1043 : 'KW' '1043';\n");
+		grammarBuilder.append("KW1044 : 'KW' '1044';\n");
+		grammarBuilder.append("KW1045 : 'KW' '1045';\n");
+		grammarBuilder.append("KW1046 : 'KW' '1046';\n");
+		grammarBuilder.append("KW1047 : 'KW' '1047';\n");
+		grammarBuilder.append("KW1048 : 'KW' '1048';\n");
+		grammarBuilder.append("KW1049 : 'KW' '1049';\n");
+		grammarBuilder.append("KW1050 : 'KW' '1050';\n");
+		grammarBuilder.append("KW1051 : 'KW' '1051';\n");
+		grammarBuilder.append("KW1052 : 'KW' '1052';\n");
+		grammarBuilder.append("KW1053 : 'KW' '1053';\n");
+		grammarBuilder.append("KW1054 : 'KW' '1054';\n");
+		grammarBuilder.append("KW1055 : 'KW' '1055';\n");
+		grammarBuilder.append("KW1056 : 'KW' '1056';\n");
+		grammarBuilder.append("KW1057 : 'KW' '1057';\n");
+		grammarBuilder.append("KW1058 : 'KW' '1058';\n");
+		grammarBuilder.append("KW1059 : 'KW' '1059';\n");
+		grammarBuilder.append("KW1060 : 'KW' '1060';\n");
+		grammarBuilder.append("KW1061 : 'KW' '1061';\n");
+		grammarBuilder.append("KW1062 : 'KW' '1062';\n");
+		grammarBuilder.append("KW1063 : 'KW' '1063';\n");
+		grammarBuilder.append("KW1064 : 'KW' '1064';\n");
+		grammarBuilder.append("KW1065 : 'KW' '1065';\n");
+		grammarBuilder.append("KW1066 : 'KW' '1066';\n");
+		grammarBuilder.append("KW1067 : 'KW' '1067';\n");
+		grammarBuilder.append("KW1068 : 'KW' '1068';\n");
+		grammarBuilder.append("KW1069 : 'KW' '1069';\n");
+		grammarBuilder.append("KW1070 : 'KW' '1070';\n");
+		grammarBuilder.append("KW1071 : 'KW' '1071';\n");
+		grammarBuilder.append("KW1072 : 'KW' '1072';\n");
+		grammarBuilder.append("KW1073 : 'KW' '1073';\n");
+		grammarBuilder.append("KW1074 : 'KW' '1074';\n");
+		grammarBuilder.append("KW1075 : 'KW' '1075';\n");
+		grammarBuilder.append("KW1076 : 'KW' '1076';\n");
+		grammarBuilder.append("KW1077 : 'KW' '1077';\n");
+		grammarBuilder.append("KW1078 : 'KW' '1078';\n");
+		grammarBuilder.append("KW1079 : 'KW' '1079';\n");
+		grammarBuilder.append("KW1080 : 'KW' '1080';\n");
+		grammarBuilder.append("KW1081 : 'KW' '1081';\n");
+		grammarBuilder.append("KW1082 : 'KW' '1082';\n");
+		grammarBuilder.append("KW1083 : 'KW' '1083';\n");
+		grammarBuilder.append("KW1084 : 'KW' '1084';\n");
+		grammarBuilder.append("KW1085 : 'KW' '1085';\n");
+		grammarBuilder.append("KW1086 : 'KW' '1086';\n");
+		grammarBuilder.append("KW1087 : 'KW' '1087';\n");
+		grammarBuilder.append("KW1088 : 'KW' '1088';\n");
+		grammarBuilder.append("KW1089 : 'KW' '1089';\n");
+		grammarBuilder.append("KW1090 : 'KW' '1090';\n");
+		grammarBuilder.append("KW1091 : 'KW' '1091';\n");
+		grammarBuilder.append("KW1092 : 'KW' '1092';\n");
+		grammarBuilder.append("KW1093 : 'KW' '1093';\n");
+		grammarBuilder.append("KW1094 : 'KW' '1094';\n");
+		grammarBuilder.append("KW1095 : 'KW' '1095';\n");
+		grammarBuilder.append("KW1096 : 'KW' '1096';\n");
+		grammarBuilder.append("KW1097 : 'KW' '1097';\n");
+		grammarBuilder.append("KW1098 : 'KW' '1098';\n");
+		grammarBuilder.append("KW1099 : 'KW' '1099';\n");
+		grammarBuilder.append("KW1100 : 'KW' '1100';\n");
+		grammarBuilder.append("KW1101 : 'KW' '1101';\n");
+		grammarBuilder.append("KW1102 : 'KW' '1102';\n");
+		grammarBuilder.append("KW1103 : 'KW' '1103';\n");
+		grammarBuilder.append("KW1104 : 'KW' '1104';\n");
+		grammarBuilder.append("KW1105 : 'KW' '1105';\n");
+		grammarBuilder.append("KW1106 : 'KW' '1106';\n");
+		grammarBuilder.append("KW1107 : 'KW' '1107';\n");
+		grammarBuilder.append("KW1108 : 'KW' '1108';\n");
+		grammarBuilder.append("KW1109 : 'KW' '1109';\n");
+		grammarBuilder.append("KW1110 : 'KW' '1110';\n");
+		grammarBuilder.append("KW1111 : 'KW' '1111';\n");
+		grammarBuilder.append("KW1112 : 'KW' '1112';\n");
+		grammarBuilder.append("KW1113 : 'KW' '1113';\n");
+		grammarBuilder.append("KW1114 : 'KW' '1114';\n");
+		grammarBuilder.append("KW1115 : 'KW' '1115';\n");
+		grammarBuilder.append("KW1116 : 'KW' '1116';\n");
+		grammarBuilder.append("KW1117 : 'KW' '1117';\n");
+		grammarBuilder.append("KW1118 : 'KW' '1118';\n");
+		grammarBuilder.append("KW1119 : 'KW' '1119';\n");
+		grammarBuilder.append("KW1120 : 'KW' '1120';\n");
+		grammarBuilder.append("KW1121 : 'KW' '1121';\n");
+		grammarBuilder.append("KW1122 : 'KW' '1122';\n");
+		grammarBuilder.append("KW1123 : 'KW' '1123';\n");
+		grammarBuilder.append("KW1124 : 'KW' '1124';\n");
+		grammarBuilder.append("KW1125 : 'KW' '1125';\n");
+		grammarBuilder.append("KW1126 : 'KW' '1126';\n");
+		grammarBuilder.append("KW1127 : 'KW' '1127';\n");
+		grammarBuilder.append("KW1128 : 'KW' '1128';\n");
+		grammarBuilder.append("KW1129 : 'KW' '1129';\n");
+		grammarBuilder.append("KW1130 : 'KW' '1130';\n");
+		grammarBuilder.append("KW1131 : 'KW' '1131';\n");
+		grammarBuilder.append("KW1132 : 'KW' '1132';\n");
+		grammarBuilder.append("KW1133 : 'KW' '1133';\n");
+		grammarBuilder.append("KW1134 : 'KW' '1134';\n");
+		grammarBuilder.append("KW1135 : 'KW' '1135';\n");
+		grammarBuilder.append("KW1136 : 'KW' '1136';\n");
+		grammarBuilder.append("KW1137 : 'KW' '1137';\n");
+		grammarBuilder.append("KW1138 : 'KW' '1138';\n");
+		grammarBuilder.append("KW1139 : 'KW' '1139';\n");
+		grammarBuilder.append("KW1140 : 'KW' '1140';\n");
+		grammarBuilder.append("KW1141 : 'KW' '1141';\n");
+		grammarBuilder.append("KW1142 : 'KW' '1142';\n");
+		grammarBuilder.append("KW1143 : 'KW' '1143';\n");
+		grammarBuilder.append("KW1144 : 'KW' '1144';\n");
+		grammarBuilder.append("KW1145 : 'KW' '1145';\n");
+		grammarBuilder.append("KW1146 : 'KW' '1146';\n");
+		grammarBuilder.append("KW1147 : 'KW' '1147';\n");
+		grammarBuilder.append("KW1148 : 'KW' '1148';\n");
+		grammarBuilder.append("KW1149 : 'KW' '1149';\n");
+		grammarBuilder.append("KW1150 : 'KW' '1150';\n");
+		grammarBuilder.append("KW1151 : 'KW' '1151';\n");
+		grammarBuilder.append("KW1152 : 'KW' '1152';\n");
+		grammarBuilder.append("KW1153 : 'KW' '1153';\n");
+		grammarBuilder.append("KW1154 : 'KW' '1154';\n");
+		grammarBuilder.append("KW1155 : 'KW' '1155';\n");
+		grammarBuilder.append("KW1156 : 'KW' '1156';\n");
+		grammarBuilder.append("KW1157 : 'KW' '1157';\n");
+		grammarBuilder.append("KW1158 : 'KW' '1158';\n");
+		grammarBuilder.append("KW1159 : 'KW' '1159';\n");
+		grammarBuilder.append("KW1160 : 'KW' '1160';\n");
+		grammarBuilder.append("KW1161 : 'KW' '1161';\n");
+		grammarBuilder.append("KW1162 : 'KW' '1162';\n");
+		grammarBuilder.append("KW1163 : 'KW' '1163';\n");
+		grammarBuilder.append("KW1164 : 'KW' '1164';\n");
+		grammarBuilder.append("KW1165 : 'KW' '1165';\n");
+		grammarBuilder.append("KW1166 : 'KW' '1166';\n");
+		grammarBuilder.append("KW1167 : 'KW' '1167';\n");
+		grammarBuilder.append("KW1168 : 'KW' '1168';\n");
+		grammarBuilder.append("KW1169 : 'KW' '1169';\n");
+		grammarBuilder.append("KW1170 : 'KW' '1170';\n");
+		grammarBuilder.append("KW1171 : 'KW' '1171';\n");
+		grammarBuilder.append("KW1172 : 'KW' '1172';\n");
+		grammarBuilder.append("KW1173 : 'KW' '1173';\n");
+		grammarBuilder.append("KW1174 : 'KW' '1174';\n");
+		grammarBuilder.append("KW1175 : 'KW' '1175';\n");
+		grammarBuilder.append("KW1176 : 'KW' '1176';\n");
+		grammarBuilder.append("KW1177 : 'KW' '1177';\n");
+		grammarBuilder.append("KW1178 : 'KW' '1178';\n");
+		grammarBuilder.append("KW1179 : 'KW' '1179';\n");
+		grammarBuilder.append("KW1180 : 'KW' '1180';\n");
+		grammarBuilder.append("KW1181 : 'KW' '1181';\n");
+		grammarBuilder.append("KW1182 : 'KW' '1182';\n");
+		grammarBuilder.append("KW1183 : 'KW' '1183';\n");
+		grammarBuilder.append("KW1184 : 'KW' '1184';\n");
+		grammarBuilder.append("KW1185 : 'KW' '1185';\n");
+		grammarBuilder.append("KW1186 : 'KW' '1186';\n");
+		grammarBuilder.append("KW1187 : 'KW' '1187';\n");
+		grammarBuilder.append("KW1188 : 'KW' '1188';\n");
+		grammarBuilder.append("KW1189 : 'KW' '1189';\n");
+		grammarBuilder.append("KW1190 : 'KW' '1190';\n");
+		grammarBuilder.append("KW1191 : 'KW' '1191';\n");
+		grammarBuilder.append("KW1192 : 'KW' '1192';\n");
+		grammarBuilder.append("KW1193 : 'KW' '1193';\n");
+		grammarBuilder.append("KW1194 : 'KW' '1194';\n");
+		grammarBuilder.append("KW1195 : 'KW' '1195';\n");
+		grammarBuilder.append("KW1196 : 'KW' '1196';\n");
+		grammarBuilder.append("KW1197 : 'KW' '1197';\n");
+		grammarBuilder.append("KW1198 : 'KW' '1198';\n");
+		grammarBuilder.append("KW1199 : 'KW' '1199';\n");
+		grammarBuilder.append("KW1200 : 'KW' '1200';\n");
+		grammarBuilder.append("KW1201 : 'KW' '1201';\n");
+		grammarBuilder.append("KW1202 : 'KW' '1202';\n");
+		grammarBuilder.append("KW1203 : 'KW' '1203';\n");
+		grammarBuilder.append("KW1204 : 'KW' '1204';\n");
+		grammarBuilder.append("KW1205 : 'KW' '1205';\n");
+		grammarBuilder.append("KW1206 : 'KW' '1206';\n");
+		grammarBuilder.append("KW1207 : 'KW' '1207';\n");
+		grammarBuilder.append("KW1208 : 'KW' '1208';\n");
+		grammarBuilder.append("KW1209 : 'KW' '1209';\n");
+		grammarBuilder.append("KW1210 : 'KW' '1210';\n");
+		grammarBuilder.append("KW1211 : 'KW' '1211';\n");
+		grammarBuilder.append("KW1212 : 'KW' '1212';\n");
+		grammarBuilder.append("KW1213 : 'KW' '1213';\n");
+		grammarBuilder.append("KW1214 : 'KW' '1214';\n");
+		grammarBuilder.append("KW1215 : 'KW' '1215';\n");
+		grammarBuilder.append("KW1216 : 'KW' '1216';\n");
+		grammarBuilder.append("KW1217 : 'KW' '1217';\n");
+		grammarBuilder.append("KW1218 : 'KW' '1218';\n");
+		grammarBuilder.append("KW1219 : 'KW' '1219';\n");
+		grammarBuilder.append("KW1220 : 'KW' '1220';\n");
+		grammarBuilder.append("KW1221 : 'KW' '1221';\n");
+		grammarBuilder.append("KW1222 : 'KW' '1222';\n");
+		grammarBuilder.append("KW1223 : 'KW' '1223';\n");
+		grammarBuilder.append("KW1224 : 'KW' '1224';\n");
+		grammarBuilder.append("KW1225 : 'KW' '1225';\n");
+		grammarBuilder.append("KW1226 : 'KW' '1226';\n");
+		grammarBuilder.append("KW1227 : 'KW' '1227';\n");
+		grammarBuilder.append("KW1228 : 'KW' '1228';\n");
+		grammarBuilder.append("KW1229 : 'KW' '1229';\n");
+		grammarBuilder.append("KW1230 : 'KW' '1230';\n");
+		grammarBuilder.append("KW1231 : 'KW' '1231';\n");
+		grammarBuilder.append("KW1232 : 'KW' '1232';\n");
+		grammarBuilder.append("KW1233 : 'KW' '1233';\n");
+		grammarBuilder.append("KW1234 : 'KW' '1234';\n");
+		grammarBuilder.append("KW1235 : 'KW' '1235';\n");
+		grammarBuilder.append("KW1236 : 'KW' '1236';\n");
+		grammarBuilder.append("KW1237 : 'KW' '1237';\n");
+		grammarBuilder.append("KW1238 : 'KW' '1238';\n");
+		grammarBuilder.append("KW1239 : 'KW' '1239';\n");
+		grammarBuilder.append("KW1240 : 'KW' '1240';\n");
+		grammarBuilder.append("KW1241 : 'KW' '1241';\n");
+		grammarBuilder.append("KW1242 : 'KW' '1242';\n");
+		grammarBuilder.append("KW1243 : 'KW' '1243';\n");
+		grammarBuilder.append("KW1244 : 'KW' '1244';\n");
+		grammarBuilder.append("KW1245 : 'KW' '1245';\n");
+		grammarBuilder.append("KW1246 : 'KW' '1246';\n");
+		grammarBuilder.append("KW1247 : 'KW' '1247';\n");
+		grammarBuilder.append("KW1248 : 'KW' '1248';\n");
+		grammarBuilder.append("KW1249 : 'KW' '1249';\n");
+		grammarBuilder.append("KW1250 : 'KW' '1250';\n");
+		grammarBuilder.append("KW1251 : 'KW' '1251';\n");
+		grammarBuilder.append("KW1252 : 'KW' '1252';\n");
+		grammarBuilder.append("KW1253 : 'KW' '1253';\n");
+		grammarBuilder.append("KW1254 : 'KW' '1254';\n");
+		grammarBuilder.append("KW1255 : 'KW' '1255';\n");
+		grammarBuilder.append("KW1256 : 'KW' '1256';\n");
+		grammarBuilder.append("KW1257 : 'KW' '1257';\n");
+		grammarBuilder.append("KW1258 : 'KW' '1258';\n");
+		grammarBuilder.append("KW1259 : 'KW' '1259';\n");
+		grammarBuilder.append("KW1260 : 'KW' '1260';\n");
+		grammarBuilder.append("KW1261 : 'KW' '1261';\n");
+		grammarBuilder.append("KW1262 : 'KW' '1262';\n");
+		grammarBuilder.append("KW1263 : 'KW' '1263';\n");
+		grammarBuilder.append("KW1264 : 'KW' '1264';\n");
+		grammarBuilder.append("KW1265 : 'KW' '1265';\n");
+		grammarBuilder.append("KW1266 : 'KW' '1266';\n");
+		grammarBuilder.append("KW1267 : 'KW' '1267';\n");
+		grammarBuilder.append("KW1268 : 'KW' '1268';\n");
+		grammarBuilder.append("KW1269 : 'KW' '1269';\n");
+		grammarBuilder.append("KW1270 : 'KW' '1270';\n");
+		grammarBuilder.append("KW1271 : 'KW' '1271';\n");
+		grammarBuilder.append("KW1272 : 'KW' '1272';\n");
+		grammarBuilder.append("KW1273 : 'KW' '1273';\n");
+		grammarBuilder.append("KW1274 : 'KW' '1274';\n");
+		grammarBuilder.append("KW1275 : 'KW' '1275';\n");
+		grammarBuilder.append("KW1276 : 'KW' '1276';\n");
+		grammarBuilder.append("KW1277 : 'KW' '1277';\n");
+		grammarBuilder.append("KW1278 : 'KW' '1278';\n");
+		grammarBuilder.append("KW1279 : 'KW' '1279';\n");
+		grammarBuilder.append("KW1280 : 'KW' '1280';\n");
+		grammarBuilder.append("KW1281 : 'KW' '1281';\n");
+		grammarBuilder.append("KW1282 : 'KW' '1282';\n");
+		grammarBuilder.append("KW1283 : 'KW' '1283';\n");
+		grammarBuilder.append("KW1284 : 'KW' '1284';\n");
+		grammarBuilder.append("KW1285 : 'KW' '1285';\n");
+		grammarBuilder.append("KW1286 : 'KW' '1286';\n");
+		grammarBuilder.append("KW1287 : 'KW' '1287';\n");
+		grammarBuilder.append("KW1288 : 'KW' '1288';\n");
+		grammarBuilder.append("KW1289 : 'KW' '1289';\n");
+		grammarBuilder.append("KW1290 : 'KW' '1290';\n");
+		grammarBuilder.append("KW1291 : 'KW' '1291';\n");
+		grammarBuilder.append("KW1292 : 'KW' '1292';\n");
+		grammarBuilder.append("KW1293 : 'KW' '1293';\n");
+		grammarBuilder.append("KW1294 : 'KW' '1294';\n");
+		grammarBuilder.append("KW1295 : 'KW' '1295';\n");
+		grammarBuilder.append("KW1296 : 'KW' '1296';\n");
+		grammarBuilder.append("KW1297 : 'KW' '1297';\n");
+		grammarBuilder.append("KW1298 : 'KW' '1298';\n");
+		grammarBuilder.append("KW1299 : 'KW' '1299';\n");
+		grammarBuilder.append("KW1300 : 'KW' '1300';\n");
+		grammarBuilder.append("KW1301 : 'KW' '1301';\n");
+		grammarBuilder.append("KW1302 : 'KW' '1302';\n");
+		grammarBuilder.append("KW1303 : 'KW' '1303';\n");
+		grammarBuilder.append("KW1304 : 'KW' '1304';\n");
+		grammarBuilder.append("KW1305 : 'KW' '1305';\n");
+		grammarBuilder.append("KW1306 : 'KW' '1306';\n");
+		grammarBuilder.append("KW1307 : 'KW' '1307';\n");
+		grammarBuilder.append("KW1308 : 'KW' '1308';\n");
+		grammarBuilder.append("KW1309 : 'KW' '1309';\n");
+		grammarBuilder.append("KW1310 : 'KW' '1310';\n");
+		grammarBuilder.append("KW1311 : 'KW' '1311';\n");
+		grammarBuilder.append("KW1312 : 'KW' '1312';\n");
+		grammarBuilder.append("KW1313 : 'KW' '1313';\n");
+		grammarBuilder.append("KW1314 : 'KW' '1314';\n");
+		grammarBuilder.append("KW1315 : 'KW' '1315';\n");
+		grammarBuilder.append("KW1316 : 'KW' '1316';\n");
+		grammarBuilder.append("KW1317 : 'KW' '1317';\n");
+		grammarBuilder.append("KW1318 : 'KW' '1318';\n");
+		grammarBuilder.append("KW1319 : 'KW' '1319';\n");
+		grammarBuilder.append("KW1320 : 'KW' '1320';\n");
+		grammarBuilder.append("KW1321 : 'KW' '1321';\n");
+		grammarBuilder.append("KW1322 : 'KW' '1322';\n");
+		grammarBuilder.append("KW1323 : 'KW' '1323';\n");
+		grammarBuilder.append("KW1324 : 'KW' '1324';\n");
+		grammarBuilder.append("KW1325 : 'KW' '1325';\n");
+		grammarBuilder.append("KW1326 : 'KW' '1326';\n");
+		grammarBuilder.append("KW1327 : 'KW' '1327';\n");
+		grammarBuilder.append("KW1328 : 'KW' '1328';\n");
+		grammarBuilder.append("KW1329 : 'KW' '1329';\n");
+		grammarBuilder.append("KW1330 : 'KW' '1330';\n");
+		grammarBuilder.append("KW1331 : 'KW' '1331';\n");
+		grammarBuilder.append("KW1332 : 'KW' '1332';\n");
+		grammarBuilder.append("KW1333 : 'KW' '1333';\n");
+		grammarBuilder.append("KW1334 : 'KW' '1334';\n");
+		grammarBuilder.append("KW1335 : 'KW' '1335';\n");
+		grammarBuilder.append("KW1336 : 'KW' '1336';\n");
+		grammarBuilder.append("KW1337 : 'KW' '1337';\n");
+		grammarBuilder.append("KW1338 : 'KW' '1338';\n");
+		grammarBuilder.append("KW1339 : 'KW' '1339';\n");
+		grammarBuilder.append("KW1340 : 'KW' '1340';\n");
+		grammarBuilder.append("KW1341 : 'KW' '1341';\n");
+		grammarBuilder.append("KW1342 : 'KW' '1342';\n");
+		grammarBuilder.append("KW1343 : 'KW' '1343';\n");
+		grammarBuilder.append("KW1344 : 'KW' '1344';\n");
+		grammarBuilder.append("KW1345 : 'KW' '1345';\n");
+		grammarBuilder.append("KW1346 : 'KW' '1346';\n");
+		grammarBuilder.append("KW1347 : 'KW' '1347';\n");
+		grammarBuilder.append("KW1348 : 'KW' '1348';\n");
+		grammarBuilder.append("KW1349 : 'KW' '1349';\n");
+		grammarBuilder.append("KW1350 : 'KW' '1350';\n");
+		grammarBuilder.append("KW1351 : 'KW' '1351';\n");
+		grammarBuilder.append("KW1352 : 'KW' '1352';\n");
+		grammarBuilder.append("KW1353 : 'KW' '1353';\n");
+		grammarBuilder.append("KW1354 : 'KW' '1354';\n");
+		grammarBuilder.append("KW1355 : 'KW' '1355';\n");
+		grammarBuilder.append("KW1356 : 'KW' '1356';\n");
+		grammarBuilder.append("KW1357 : 'KW' '1357';\n");
+		grammarBuilder.append("KW1358 : 'KW' '1358';\n");
+		grammarBuilder.append("KW1359 : 'KW' '1359';\n");
+		grammarBuilder.append("KW1360 : 'KW' '1360';\n");
+		grammarBuilder.append("KW1361 : 'KW' '1361';\n");
+		grammarBuilder.append("KW1362 : 'KW' '1362';\n");
+		grammarBuilder.append("KW1363 : 'KW' '1363';\n");
+		grammarBuilder.append("KW1364 : 'KW' '1364';\n");
+		grammarBuilder.append("KW1365 : 'KW' '1365';\n");
+		grammarBuilder.append("KW1366 : 'KW' '1366';\n");
+		grammarBuilder.append("KW1367 : 'KW' '1367';\n");
+		grammarBuilder.append("KW1368 : 'KW' '1368';\n");
+		grammarBuilder.append("KW1369 : 'KW' '1369';\n");
+		grammarBuilder.append("KW1370 : 'KW' '1370';\n");
+		grammarBuilder.append("KW1371 : 'KW' '1371';\n");
+		grammarBuilder.append("KW1372 : 'KW' '1372';\n");
+		grammarBuilder.append("KW1373 : 'KW' '1373';\n");
+		grammarBuilder.append("KW1374 : 'KW' '1374';\n");
+		grammarBuilder.append("KW1375 : 'KW' '1375';\n");
+		grammarBuilder.append("KW1376 : 'KW' '1376';\n");
+		grammarBuilder.append("KW1377 : 'KW' '1377';\n");
+		grammarBuilder.append("KW1378 : 'KW' '1378';\n");
+		grammarBuilder.append("KW1379 : 'KW' '1379';\n");
+		grammarBuilder.append("KW1380 : 'KW' '1380';\n");
+		grammarBuilder.append("KW1381 : 'KW' '1381';\n");
+		grammarBuilder.append("KW1382 : 'KW' '1382';\n");
+		grammarBuilder.append("KW1383 : 'KW' '1383';\n");
+		grammarBuilder.append("KW1384 : 'KW' '1384';\n");
+		grammarBuilder.append("KW1385 : 'KW' '1385';\n");
+		grammarBuilder.append("KW1386 : 'KW' '1386';\n");
+		grammarBuilder.append("KW1387 : 'KW' '1387';\n");
+		grammarBuilder.append("KW1388 : 'KW' '1388';\n");
+		grammarBuilder.append("KW1389 : 'KW' '1389';\n");
+		grammarBuilder.append("KW1390 : 'KW' '1390';\n");
+		grammarBuilder.append("KW1391 : 'KW' '1391';\n");
+		grammarBuilder.append("KW1392 : 'KW' '1392';\n");
+		grammarBuilder.append("KW1393 : 'KW' '1393';\n");
+		grammarBuilder.append("KW1394 : 'KW' '1394';\n");
+		grammarBuilder.append("KW1395 : 'KW' '1395';\n");
+		grammarBuilder.append("KW1396 : 'KW' '1396';\n");
+		grammarBuilder.append("KW1397 : 'KW' '1397';\n");
+		grammarBuilder.append("KW1398 : 'KW' '1398';\n");
+		grammarBuilder.append("KW1399 : 'KW' '1399';\n");
+		grammarBuilder.append("KW1400 : 'KW' '1400';\n");
+		grammarBuilder.append("KW1401 : 'KW' '1401';\n");
+		grammarBuilder.append("KW1402 : 'KW' '1402';\n");
+		grammarBuilder.append("KW1403 : 'KW' '1403';\n");
+		grammarBuilder.append("KW1404 : 'KW' '1404';\n");
+		grammarBuilder.append("KW1405 : 'KW' '1405';\n");
+		grammarBuilder.append("KW1406 : 'KW' '1406';\n");
+		grammarBuilder.append("KW1407 : 'KW' '1407';\n");
+		grammarBuilder.append("KW1408 : 'KW' '1408';\n");
+		grammarBuilder.append("KW1409 : 'KW' '1409';\n");
+		grammarBuilder.append("KW1410 : 'KW' '1410';\n");
+		grammarBuilder.append("KW1411 : 'KW' '1411';\n");
+		grammarBuilder.append("KW1412 : 'KW' '1412';\n");
+		grammarBuilder.append("KW1413 : 'KW' '1413';\n");
+		grammarBuilder.append("KW1414 : 'KW' '1414';\n");
+		grammarBuilder.append("KW1415 : 'KW' '1415';\n");
+		grammarBuilder.append("KW1416 : 'KW' '1416';\n");
+		grammarBuilder.append("KW1417 : 'KW' '1417';\n");
+		grammarBuilder.append("KW1418 : 'KW' '1418';\n");
+		grammarBuilder.append("KW1419 : 'KW' '1419';\n");
+		grammarBuilder.append("KW1420 : 'KW' '1420';\n");
+		grammarBuilder.append("KW1421 : 'KW' '1421';\n");
+		grammarBuilder.append("KW1422 : 'KW' '1422';\n");
+		grammarBuilder.append("KW1423 : 'KW' '1423';\n");
+		grammarBuilder.append("KW1424 : 'KW' '1424';\n");
+		grammarBuilder.append("KW1425 : 'KW' '1425';\n");
+		grammarBuilder.append("KW1426 : 'KW' '1426';\n");
+		grammarBuilder.append("KW1427 : 'KW' '1427';\n");
+		grammarBuilder.append("KW1428 : 'KW' '1428';\n");
+		grammarBuilder.append("KW1429 : 'KW' '1429';\n");
+		grammarBuilder.append("KW1430 : 'KW' '1430';\n");
+		grammarBuilder.append("KW1431 : 'KW' '1431';\n");
+		grammarBuilder.append("KW1432 : 'KW' '1432';\n");
+		grammarBuilder.append("KW1433 : 'KW' '1433';\n");
+		grammarBuilder.append("KW1434 : 'KW' '1434';\n");
+		grammarBuilder.append("KW1435 : 'KW' '1435';\n");
+		grammarBuilder.append("KW1436 : 'KW' '1436';\n");
+		grammarBuilder.append("KW1437 : 'KW' '1437';\n");
+		grammarBuilder.append("KW1438 : 'KW' '1438';\n");
+		grammarBuilder.append("KW1439 : 'KW' '1439';\n");
+		grammarBuilder.append("KW1440 : 'KW' '1440';\n");
+		grammarBuilder.append("KW1441 : 'KW' '1441';\n");
+		grammarBuilder.append("KW1442 : 'KW' '1442';\n");
+		grammarBuilder.append("KW1443 : 'KW' '1443';\n");
+		grammarBuilder.append("KW1444 : 'KW' '1444';\n");
+		grammarBuilder.append("KW1445 : 'KW' '1445';\n");
+		grammarBuilder.append("KW1446 : 'KW' '1446';\n");
+		grammarBuilder.append("KW1447 : 'KW' '1447';\n");
+		grammarBuilder.append("KW1448 : 'KW' '1448';\n");
+		grammarBuilder.append("KW1449 : 'KW' '1449';\n");
+		grammarBuilder.append("KW1450 : 'KW' '1450';\n");
+		grammarBuilder.append("KW1451 : 'KW' '1451';\n");
+		grammarBuilder.append("KW1452 : 'KW' '1452';\n");
+		grammarBuilder.append("KW1453 : 'KW' '1453';\n");
+		grammarBuilder.append("KW1454 : 'KW' '1454';\n");
+		grammarBuilder.append("KW1455 : 'KW' '1455';\n");
+		grammarBuilder.append("KW1456 : 'KW' '1456';\n");
+		grammarBuilder.append("KW1457 : 'KW' '1457';\n");
+		grammarBuilder.append("KW1458 : 'KW' '1458';\n");
+		grammarBuilder.append("KW1459 : 'KW' '1459';\n");
+		grammarBuilder.append("KW1460 : 'KW' '1460';\n");
+		grammarBuilder.append("KW1461 : 'KW' '1461';\n");
+		grammarBuilder.append("KW1462 : 'KW' '1462';\n");
+		grammarBuilder.append("KW1463 : 'KW' '1463';\n");
+		grammarBuilder.append("KW1464 : 'KW' '1464';\n");
+		grammarBuilder.append("KW1465 : 'KW' '1465';\n");
+		grammarBuilder.append("KW1466 : 'KW' '1466';\n");
+		grammarBuilder.append("KW1467 : 'KW' '1467';\n");
+		grammarBuilder.append("KW1468 : 'KW' '1468';\n");
+		grammarBuilder.append("KW1469 : 'KW' '1469';\n");
+		grammarBuilder.append("KW1470 : 'KW' '1470';\n");
+		grammarBuilder.append("KW1471 : 'KW' '1471';\n");
+		grammarBuilder.append("KW1472 : 'KW' '1472';\n");
+		grammarBuilder.append("KW1473 : 'KW' '1473';\n");
+		grammarBuilder.append("KW1474 : 'KW' '1474';\n");
+		grammarBuilder.append("KW1475 : 'KW' '1475';\n");
+		grammarBuilder.append("KW1476 : 'KW' '1476';\n");
+		grammarBuilder.append("KW1477 : 'KW' '1477';\n");
+		grammarBuilder.append("KW1478 : 'KW' '1478';\n");
+		grammarBuilder.append("KW1479 : 'KW' '1479';\n");
+		grammarBuilder.append("KW1480 : 'KW' '1480';\n");
+		grammarBuilder.append("KW1481 : 'KW' '1481';\n");
+		grammarBuilder.append("KW1482 : 'KW' '1482';\n");
+		grammarBuilder.append("KW1483 : 'KW' '1483';\n");
+		grammarBuilder.append("KW1484 : 'KW' '1484';\n");
+		grammarBuilder.append("KW1485 : 'KW' '1485';\n");
+		grammarBuilder.append("KW1486 : 'KW' '1486';\n");
+		grammarBuilder.append("KW1487 : 'KW' '1487';\n");
+		grammarBuilder.append("KW1488 : 'KW' '1488';\n");
+		grammarBuilder.append("KW1489 : 'KW' '1489';\n");
+		grammarBuilder.append("KW1490 : 'KW' '1490';\n");
+		grammarBuilder.append("KW1491 : 'KW' '1491';\n");
+		grammarBuilder.append("KW1492 : 'KW' '1492';\n");
+		grammarBuilder.append("KW1493 : 'KW' '1493';\n");
+		grammarBuilder.append("KW1494 : 'KW' '1494';\n");
+		grammarBuilder.append("KW1495 : 'KW' '1495';\n");
+		grammarBuilder.append("KW1496 : 'KW' '1496';\n");
+		grammarBuilder.append("KW1497 : 'KW' '1497';\n");
+		grammarBuilder.append("KW1498 : 'KW' '1498';\n");
+		grammarBuilder.append("KW1499 : 'KW' '1499';\n");
+		grammarBuilder.append("KW1500 : 'KW' '1500';\n");
+		grammarBuilder.append("KW1501 : 'KW' '1501';\n");
+		grammarBuilder.append("KW1502 : 'KW' '1502';\n");
+		grammarBuilder.append("KW1503 : 'KW' '1503';\n");
+		grammarBuilder.append("KW1504 : 'KW' '1504';\n");
+		grammarBuilder.append("KW1505 : 'KW' '1505';\n");
+		grammarBuilder.append("KW1506 : 'KW' '1506';\n");
+		grammarBuilder.append("KW1507 : 'KW' '1507';\n");
+		grammarBuilder.append("KW1508 : 'KW' '1508';\n");
+		grammarBuilder.append("KW1509 : 'KW' '1509';\n");
+		grammarBuilder.append("KW1510 : 'KW' '1510';\n");
+		grammarBuilder.append("KW1511 : 'KW' '1511';\n");
+		grammarBuilder.append("KW1512 : 'KW' '1512';\n");
+		grammarBuilder.append("KW1513 : 'KW' '1513';\n");
+		grammarBuilder.append("KW1514 : 'KW' '1514';\n");
+		grammarBuilder.append("KW1515 : 'KW' '1515';\n");
+		grammarBuilder.append("KW1516 : 'KW' '1516';\n");
+		grammarBuilder.append("KW1517 : 'KW' '1517';\n");
+		grammarBuilder.append("KW1518 : 'KW' '1518';\n");
+		grammarBuilder.append("KW1519 : 'KW' '1519';\n");
+		grammarBuilder.append("KW1520 : 'KW' '1520';\n");
+		grammarBuilder.append("KW1521 : 'KW' '1521';\n");
+		grammarBuilder.append("KW1522 : 'KW' '1522';\n");
+		grammarBuilder.append("KW1523 : 'KW' '1523';\n");
+		grammarBuilder.append("KW1524 : 'KW' '1524';\n");
+		grammarBuilder.append("KW1525 : 'KW' '1525';\n");
+		grammarBuilder.append("KW1526 : 'KW' '1526';\n");
+		grammarBuilder.append("KW1527 : 'KW' '1527';\n");
+		grammarBuilder.append("KW1528 : 'KW' '1528';\n");
+		grammarBuilder.append("KW1529 : 'KW' '1529';\n");
+		grammarBuilder.append("KW1530 : 'KW' '1530';\n");
+		grammarBuilder.append("KW1531 : 'KW' '1531';\n");
+		grammarBuilder.append("KW1532 : 'KW' '1532';\n");
+		grammarBuilder.append("KW1533 : 'KW' '1533';\n");
+		grammarBuilder.append("KW1534 : 'KW' '1534';\n");
+		grammarBuilder.append("KW1535 : 'KW' '1535';\n");
+		grammarBuilder.append("KW1536 : 'KW' '1536';\n");
+		grammarBuilder.append("KW1537 : 'KW' '1537';\n");
+		grammarBuilder.append("KW1538 : 'KW' '1538';\n");
+		grammarBuilder.append("KW1539 : 'KW' '1539';\n");
+		grammarBuilder.append("KW1540 : 'KW' '1540';\n");
+		grammarBuilder.append("KW1541 : 'KW' '1541';\n");
+		grammarBuilder.append("KW1542 : 'KW' '1542';\n");
+		grammarBuilder.append("KW1543 : 'KW' '1543';\n");
+		grammarBuilder.append("KW1544 : 'KW' '1544';\n");
+		grammarBuilder.append("KW1545 : 'KW' '1545';\n");
+		grammarBuilder.append("KW1546 : 'KW' '1546';\n");
+		grammarBuilder.append("KW1547 : 'KW' '1547';\n");
+		grammarBuilder.append("KW1548 : 'KW' '1548';\n");
+		grammarBuilder.append("KW1549 : 'KW' '1549';\n");
+		grammarBuilder.append("KW1550 : 'KW' '1550';\n");
+		grammarBuilder.append("KW1551 : 'KW' '1551';\n");
+		grammarBuilder.append("KW1552 : 'KW' '1552';\n");
+		grammarBuilder.append("KW1553 : 'KW' '1553';\n");
+		grammarBuilder.append("KW1554 : 'KW' '1554';\n");
+		grammarBuilder.append("KW1555 : 'KW' '1555';\n");
+		grammarBuilder.append("KW1556 : 'KW' '1556';\n");
+		grammarBuilder.append("KW1557 : 'KW' '1557';\n");
+		grammarBuilder.append("KW1558 : 'KW' '1558';\n");
+		grammarBuilder.append("KW1559 : 'KW' '1559';\n");
+		grammarBuilder.append("KW1560 : 'KW' '1560';\n");
+		grammarBuilder.append("KW1561 : 'KW' '1561';\n");
+		grammarBuilder.append("KW1562 : 'KW' '1562';\n");
+		grammarBuilder.append("KW1563 : 'KW' '1563';\n");
+		grammarBuilder.append("KW1564 : 'KW' '1564';\n");
+		grammarBuilder.append("KW1565 : 'KW' '1565';\n");
+		grammarBuilder.append("KW1566 : 'KW' '1566';\n");
+		grammarBuilder.append("KW1567 : 'KW' '1567';\n");
+		grammarBuilder.append("KW1568 : 'KW' '1568';\n");
+		grammarBuilder.append("KW1569 : 'KW' '1569';\n");
+		grammarBuilder.append("KW1570 : 'KW' '1570';\n");
+		grammarBuilder.append("KW1571 : 'KW' '1571';\n");
+		grammarBuilder.append("KW1572 : 'KW' '1572';\n");
+		grammarBuilder.append("KW1573 : 'KW' '1573';\n");
+		grammarBuilder.append("KW1574 : 'KW' '1574';\n");
+		grammarBuilder.append("KW1575 : 'KW' '1575';\n");
+		grammarBuilder.append("KW1576 : 'KW' '1576';\n");
+		grammarBuilder.append("KW1577 : 'KW' '1577';\n");
+		grammarBuilder.append("KW1578 : 'KW' '1578';\n");
+		grammarBuilder.append("KW1579 : 'KW' '1579';\n");
+		grammarBuilder.append("KW1580 : 'KW' '1580';\n");
+		grammarBuilder.append("KW1581 : 'KW' '1581';\n");
+		grammarBuilder.append("KW1582 : 'KW' '1582';\n");
+		grammarBuilder.append("KW1583 : 'KW' '1583';\n");
+		grammarBuilder.append("KW1584 : 'KW' '1584';\n");
+		grammarBuilder.append("KW1585 : 'KW' '1585';\n");
+		grammarBuilder.append("KW1586 : 'KW' '1586';\n");
+		grammarBuilder.append("KW1587 : 'KW' '1587';\n");
+		grammarBuilder.append("KW1588 : 'KW' '1588';\n");
+		grammarBuilder.append("KW1589 : 'KW' '1589';\n");
+		grammarBuilder.append("KW1590 : 'KW' '1590';\n");
+		grammarBuilder.append("KW1591 : 'KW' '1591';\n");
+		grammarBuilder.append("KW1592 : 'KW' '1592';\n");
+		grammarBuilder.append("KW1593 : 'KW' '1593';\n");
+		grammarBuilder.append("KW1594 : 'KW' '1594';\n");
+		grammarBuilder.append("KW1595 : 'KW' '1595';\n");
+		grammarBuilder.append("KW1596 : 'KW' '1596';\n");
+		grammarBuilder.append("KW1597 : 'KW' '1597';\n");
+		grammarBuilder.append("KW1598 : 'KW' '1598';\n");
+		grammarBuilder.append("KW1599 : 'KW' '1599';\n");
+		grammarBuilder.append("KW1600 : 'KW' '1600';\n");
+		grammarBuilder.append("KW1601 : 'KW' '1601';\n");
+		grammarBuilder.append("KW1602 : 'KW' '1602';\n");
+		grammarBuilder.append("KW1603 : 'KW' '1603';\n");
+		grammarBuilder.append("KW1604 : 'KW' '1604';\n");
+		grammarBuilder.append("KW1605 : 'KW' '1605';\n");
+		grammarBuilder.append("KW1606 : 'KW' '1606';\n");
+		grammarBuilder.append("KW1607 : 'KW' '1607';\n");
+		grammarBuilder.append("KW1608 : 'KW' '1608';\n");
+		grammarBuilder.append("KW1609 : 'KW' '1609';\n");
+		grammarBuilder.append("KW1610 : 'KW' '1610';\n");
+		grammarBuilder.append("KW1611 : 'KW' '1611';\n");
+		grammarBuilder.append("KW1612 : 'KW' '1612';\n");
+		grammarBuilder.append("KW1613 : 'KW' '1613';\n");
+		grammarBuilder.append("KW1614 : 'KW' '1614';\n");
+		grammarBuilder.append("KW1615 : 'KW' '1615';\n");
+		grammarBuilder.append("KW1616 : 'KW' '1616';\n");
+		grammarBuilder.append("KW1617 : 'KW' '1617';\n");
+		grammarBuilder.append("KW1618 : 'KW' '1618';\n");
+		grammarBuilder.append("KW1619 : 'KW' '1619';\n");
+		grammarBuilder.append("KW1620 : 'KW' '1620';\n");
+		grammarBuilder.append("KW1621 : 'KW' '1621';\n");
+		grammarBuilder.append("KW1622 : 'KW' '1622';\n");
+		grammarBuilder.append("KW1623 : 'KW' '1623';\n");
+		grammarBuilder.append("KW1624 : 'KW' '1624';\n");
+		grammarBuilder.append("KW1625 : 'KW' '1625';\n");
+		grammarBuilder.append("KW1626 : 'KW' '1626';\n");
+		grammarBuilder.append("KW1627 : 'KW' '1627';\n");
+		grammarBuilder.append("KW1628 : 'KW' '1628';\n");
+		grammarBuilder.append("KW1629 : 'KW' '1629';\n");
+		grammarBuilder.append("KW1630 : 'KW' '1630';\n");
+		grammarBuilder.append("KW1631 : 'KW' '1631';\n");
+		grammarBuilder.append("KW1632 : 'KW' '1632';\n");
+		grammarBuilder.append("KW1633 : 'KW' '1633';\n");
+		grammarBuilder.append("KW1634 : 'KW' '1634';\n");
+		grammarBuilder.append("KW1635 : 'KW' '1635';\n");
+		grammarBuilder.append("KW1636 : 'KW' '1636';\n");
+		grammarBuilder.append("KW1637 : 'KW' '1637';\n");
+		grammarBuilder.append("KW1638 : 'KW' '1638';\n");
+		grammarBuilder.append("KW1639 : 'KW' '1639';\n");
+		grammarBuilder.append("KW1640 : 'KW' '1640';\n");
+		grammarBuilder.append("KW1641 : 'KW' '1641';\n");
+		grammarBuilder.append("KW1642 : 'KW' '1642';\n");
+		grammarBuilder.append("KW1643 : 'KW' '1643';\n");
+		grammarBuilder.append("KW1644 : 'KW' '1644';\n");
+		grammarBuilder.append("KW1645 : 'KW' '1645';\n");
+		grammarBuilder.append("KW1646 : 'KW' '1646';\n");
+		grammarBuilder.append("KW1647 : 'KW' '1647';\n");
+		grammarBuilder.append("KW1648 : 'KW' '1648';\n");
+		grammarBuilder.append("KW1649 : 'KW' '1649';\n");
+		grammarBuilder.append("KW1650 : 'KW' '1650';\n");
+		grammarBuilder.append("KW1651 : 'KW' '1651';\n");
+		grammarBuilder.append("KW1652 : 'KW' '1652';\n");
+		grammarBuilder.append("KW1653 : 'KW' '1653';\n");
+		grammarBuilder.append("KW1654 : 'KW' '1654';\n");
+		grammarBuilder.append("KW1655 : 'KW' '1655';\n");
+		grammarBuilder.append("KW1656 : 'KW' '1656';\n");
+		grammarBuilder.append("KW1657 : 'KW' '1657';\n");
+		grammarBuilder.append("KW1658 : 'KW' '1658';\n");
+		grammarBuilder.append("KW1659 : 'KW' '1659';\n");
+		grammarBuilder.append("KW1660 : 'KW' '1660';\n");
+		grammarBuilder.append("KW1661 : 'KW' '1661';\n");
+		grammarBuilder.append("KW1662 : 'KW' '1662';\n");
+		grammarBuilder.append("KW1663 : 'KW' '1663';\n");
+		grammarBuilder.append("KW1664 : 'KW' '1664';\n");
+		grammarBuilder.append("KW1665 : 'KW' '1665';\n");
+		grammarBuilder.append("KW1666 : 'KW' '1666';\n");
+		grammarBuilder.append("KW1667 : 'KW' '1667';\n");
+		grammarBuilder.append("KW1668 : 'KW' '1668';\n");
+		grammarBuilder.append("KW1669 : 'KW' '1669';\n");
+		grammarBuilder.append("KW1670 : 'KW' '1670';\n");
+		grammarBuilder.append("KW1671 : 'KW' '1671';\n");
+		grammarBuilder.append("KW1672 : 'KW' '1672';\n");
+		grammarBuilder.append("KW1673 : 'KW' '1673';\n");
+		grammarBuilder.append("KW1674 : 'KW' '1674';\n");
+		grammarBuilder.append("KW1675 : 'KW' '1675';\n");
+		grammarBuilder.append("KW1676 : 'KW' '1676';\n");
+		grammarBuilder.append("KW1677 : 'KW' '1677';\n");
+		grammarBuilder.append("KW1678 : 'KW' '1678';\n");
+		grammarBuilder.append("KW1679 : 'KW' '1679';\n");
+		grammarBuilder.append("KW1680 : 'KW' '1680';\n");
+		grammarBuilder.append("KW1681 : 'KW' '1681';\n");
+		grammarBuilder.append("KW1682 : 'KW' '1682';\n");
+		grammarBuilder.append("KW1683 : 'KW' '1683';\n");
+		grammarBuilder.append("KW1684 : 'KW' '1684';\n");
+		grammarBuilder.append("KW1685 : 'KW' '1685';\n");
+		grammarBuilder.append("KW1686 : 'KW' '1686';\n");
+		grammarBuilder.append("KW1687 : 'KW' '1687';\n");
+		grammarBuilder.append("KW1688 : 'KW' '1688';\n");
+		grammarBuilder.append("KW1689 : 'KW' '1689';\n");
+		grammarBuilder.append("KW1690 : 'KW' '1690';\n");
+		grammarBuilder.append("KW1691 : 'KW' '1691';\n");
+		grammarBuilder.append("KW1692 : 'KW' '1692';\n");
+		grammarBuilder.append("KW1693 : 'KW' '1693';\n");
+		grammarBuilder.append("KW1694 : 'KW' '1694';\n");
+		grammarBuilder.append("KW1695 : 'KW' '1695';\n");
+		grammarBuilder.append("KW1696 : 'KW' '1696';\n");
+		grammarBuilder.append("KW1697 : 'KW' '1697';\n");
+		grammarBuilder.append("KW1698 : 'KW' '1698';\n");
+		grammarBuilder.append("KW1699 : 'KW' '1699';\n");
+		grammarBuilder.append("KW1700 : 'KW' '1700';\n");
+		grammarBuilder.append("KW1701 : 'KW' '1701';\n");
+		grammarBuilder.append("KW1702 : 'KW' '1702';\n");
+		grammarBuilder.append("KW1703 : 'KW' '1703';\n");
+		grammarBuilder.append("KW1704 : 'KW' '1704';\n");
+		grammarBuilder.append("KW1705 : 'KW' '1705';\n");
+		grammarBuilder.append("KW1706 : 'KW' '1706';\n");
+		grammarBuilder.append("KW1707 : 'KW' '1707';\n");
+		grammarBuilder.append("KW1708 : 'KW' '1708';\n");
+		grammarBuilder.append("KW1709 : 'KW' '1709';\n");
+		grammarBuilder.append("KW1710 : 'KW' '1710';\n");
+		grammarBuilder.append("KW1711 : 'KW' '1711';\n");
+		grammarBuilder.append("KW1712 : 'KW' '1712';\n");
+		grammarBuilder.append("KW1713 : 'KW' '1713';\n");
+		grammarBuilder.append("KW1714 : 'KW' '1714';\n");
+		grammarBuilder.append("KW1715 : 'KW' '1715';\n");
+		grammarBuilder.append("KW1716 : 'KW' '1716';\n");
+		grammarBuilder.append("KW1717 : 'KW' '1717';\n");
+		grammarBuilder.append("KW1718 : 'KW' '1718';\n");
+		grammarBuilder.append("KW1719 : 'KW' '1719';\n");
+		grammarBuilder.append("KW1720 : 'KW' '1720';\n");
+		grammarBuilder.append("KW1721 : 'KW' '1721';\n");
+		grammarBuilder.append("KW1722 : 'KW' '1722';\n");
+		grammarBuilder.append("KW1723 : 'KW' '1723';\n");
+		grammarBuilder.append("KW1724 : 'KW' '1724';\n");
+		grammarBuilder.append("KW1725 : 'KW' '1725';\n");
+		grammarBuilder.append("KW1726 : 'KW' '1726';\n");
+		grammarBuilder.append("KW1727 : 'KW' '1727';\n");
+		grammarBuilder.append("KW1728 : 'KW' '1728';\n");
+		grammarBuilder.append("KW1729 : 'KW' '1729';\n");
+		grammarBuilder.append("KW1730 : 'KW' '1730';\n");
+		grammarBuilder.append("KW1731 : 'KW' '1731';\n");
+		grammarBuilder.append("KW1732 : 'KW' '1732';\n");
+		grammarBuilder.append("KW1733 : 'KW' '1733';\n");
+		grammarBuilder.append("KW1734 : 'KW' '1734';\n");
+		grammarBuilder.append("KW1735 : 'KW' '1735';\n");
+		grammarBuilder.append("KW1736 : 'KW' '1736';\n");
+		grammarBuilder.append("KW1737 : 'KW' '1737';\n");
+		grammarBuilder.append("KW1738 : 'KW' '1738';\n");
+		grammarBuilder.append("KW1739 : 'KW' '1739';\n");
+		grammarBuilder.append("KW1740 : 'KW' '1740';\n");
+		grammarBuilder.append("KW1741 : 'KW' '1741';\n");
+		grammarBuilder.append("KW1742 : 'KW' '1742';\n");
+		grammarBuilder.append("KW1743 : 'KW' '1743';\n");
+		grammarBuilder.append("KW1744 : 'KW' '1744';\n");
+		grammarBuilder.append("KW1745 : 'KW' '1745';\n");
+		grammarBuilder.append("KW1746 : 'KW' '1746';\n");
+		grammarBuilder.append("KW1747 : 'KW' '1747';\n");
+		grammarBuilder.append("KW1748 : 'KW' '1748';\n");
+		grammarBuilder.append("KW1749 : 'KW' '1749';\n");
+		grammarBuilder.append("KW1750 : 'KW' '1750';\n");
+		grammarBuilder.append("KW1751 : 'KW' '1751';\n");
+		grammarBuilder.append("KW1752 : 'KW' '1752';\n");
+		grammarBuilder.append("KW1753 : 'KW' '1753';\n");
+		grammarBuilder.append("KW1754 : 'KW' '1754';\n");
+		grammarBuilder.append("KW1755 : 'KW' '1755';\n");
+		grammarBuilder.append("KW1756 : 'KW' '1756';\n");
+		grammarBuilder.append("KW1757 : 'KW' '1757';\n");
+		grammarBuilder.append("KW1758 : 'KW' '1758';\n");
+		grammarBuilder.append("KW1759 : 'KW' '1759';\n");
+		grammarBuilder.append("KW1760 : 'KW' '1760';\n");
+		grammarBuilder.append("KW1761 : 'KW' '1761';\n");
+		grammarBuilder.append("KW1762 : 'KW' '1762';\n");
+		grammarBuilder.append("KW1763 : 'KW' '1763';\n");
+		grammarBuilder.append("KW1764 : 'KW' '1764';\n");
+		grammarBuilder.append("KW1765 : 'KW' '1765';\n");
+		grammarBuilder.append("KW1766 : 'KW' '1766';\n");
+		grammarBuilder.append("KW1767 : 'KW' '1767';\n");
+		grammarBuilder.append("KW1768 : 'KW' '1768';\n");
+		grammarBuilder.append("KW1769 : 'KW' '1769';\n");
+		grammarBuilder.append("KW1770 : 'KW' '1770';\n");
+		grammarBuilder.append("KW1771 : 'KW' '1771';\n");
+		grammarBuilder.append("KW1772 : 'KW' '1772';\n");
+		grammarBuilder.append("KW1773 : 'KW' '1773';\n");
+		grammarBuilder.append("KW1774 : 'KW' '1774';\n");
+		grammarBuilder.append("KW1775 : 'KW' '1775';\n");
+		grammarBuilder.append("KW1776 : 'KW' '1776';\n");
+		grammarBuilder.append("KW1777 : 'KW' '1777';\n");
+		grammarBuilder.append("KW1778 : 'KW' '1778';\n");
+		grammarBuilder.append("KW1779 : 'KW' '1779';\n");
+		grammarBuilder.append("KW1780 : 'KW' '1780';\n");
+		grammarBuilder.append("KW1781 : 'KW' '1781';\n");
+		grammarBuilder.append("KW1782 : 'KW' '1782';\n");
+		grammarBuilder.append("KW1783 : 'KW' '1783';\n");
+		grammarBuilder.append("KW1784 : 'KW' '1784';\n");
+		grammarBuilder.append("KW1785 : 'KW' '1785';\n");
+		grammarBuilder.append("KW1786 : 'KW' '1786';\n");
+		grammarBuilder.append("KW1787 : 'KW' '1787';\n");
+		grammarBuilder.append("KW1788 : 'KW' '1788';\n");
+		grammarBuilder.append("KW1789 : 'KW' '1789';\n");
+		grammarBuilder.append("KW1790 : 'KW' '1790';\n");
+		grammarBuilder.append("KW1791 : 'KW' '1791';\n");
+		grammarBuilder.append("KW1792 : 'KW' '1792';\n");
+		grammarBuilder.append("KW1793 : 'KW' '1793';\n");
+		grammarBuilder.append("KW1794 : 'KW' '1794';\n");
+		grammarBuilder.append("KW1795 : 'KW' '1795';\n");
+		grammarBuilder.append("KW1796 : 'KW' '1796';\n");
+		grammarBuilder.append("KW1797 : 'KW' '1797';\n");
+		grammarBuilder.append("KW1798 : 'KW' '1798';\n");
+		grammarBuilder.append("KW1799 : 'KW' '1799';\n");
+		grammarBuilder.append("KW1800 : 'KW' '1800';\n");
+		grammarBuilder.append("KW1801 : 'KW' '1801';\n");
+		grammarBuilder.append("KW1802 : 'KW' '1802';\n");
+		grammarBuilder.append("KW1803 : 'KW' '1803';\n");
+		grammarBuilder.append("KW1804 : 'KW' '1804';\n");
+		grammarBuilder.append("KW1805 : 'KW' '1805';\n");
+		grammarBuilder.append("KW1806 : 'KW' '1806';\n");
+		grammarBuilder.append("KW1807 : 'KW' '1807';\n");
+		grammarBuilder.append("KW1808 : 'KW' '1808';\n");
+		grammarBuilder.append("KW1809 : 'KW' '1809';\n");
+		grammarBuilder.append("KW1810 : 'KW' '1810';\n");
+		grammarBuilder.append("KW1811 : 'KW' '1811';\n");
+		grammarBuilder.append("KW1812 : 'KW' '1812';\n");
+		grammarBuilder.append("KW1813 : 'KW' '1813';\n");
+		grammarBuilder.append("KW1814 : 'KW' '1814';\n");
+		grammarBuilder.append("KW1815 : 'KW' '1815';\n");
+		grammarBuilder.append("KW1816 : 'KW' '1816';\n");
+		grammarBuilder.append("KW1817 : 'KW' '1817';\n");
+		grammarBuilder.append("KW1818 : 'KW' '1818';\n");
+		grammarBuilder.append("KW1819 : 'KW' '1819';\n");
+		grammarBuilder.append("KW1820 : 'KW' '1820';\n");
+		grammarBuilder.append("KW1821 : 'KW' '1821';\n");
+		grammarBuilder.append("KW1822 : 'KW' '1822';\n");
+		grammarBuilder.append("KW1823 : 'KW' '1823';\n");
+		grammarBuilder.append("KW1824 : 'KW' '1824';\n");
+		grammarBuilder.append("KW1825 : 'KW' '1825';\n");
+		grammarBuilder.append("KW1826 : 'KW' '1826';\n");
+		grammarBuilder.append("KW1827 : 'KW' '1827';\n");
+		grammarBuilder.append("KW1828 : 'KW' '1828';\n");
+		grammarBuilder.append("KW1829 : 'KW' '1829';\n");
+		grammarBuilder.append("KW1830 : 'KW' '1830';\n");
+		grammarBuilder.append("KW1831 : 'KW' '1831';\n");
+		grammarBuilder.append("KW1832 : 'KW' '1832';\n");
+		grammarBuilder.append("KW1833 : 'KW' '1833';\n");
+		grammarBuilder.append("KW1834 : 'KW' '1834';\n");
+		grammarBuilder.append("KW1835 : 'KW' '1835';\n");
+		grammarBuilder.append("KW1836 : 'KW' '1836';\n");
+		grammarBuilder.append("KW1837 : 'KW' '1837';\n");
+		grammarBuilder.append("KW1838 : 'KW' '1838';\n");
+		grammarBuilder.append("KW1839 : 'KW' '1839';\n");
+		grammarBuilder.append("KW1840 : 'KW' '1840';\n");
+		grammarBuilder.append("KW1841 : 'KW' '1841';\n");
+		grammarBuilder.append("KW1842 : 'KW' '1842';\n");
+		grammarBuilder.append("KW1843 : 'KW' '1843';\n");
+		grammarBuilder.append("KW1844 : 'KW' '1844';\n");
+		grammarBuilder.append("KW1845 : 'KW' '1845';\n");
+		grammarBuilder.append("KW1846 : 'KW' '1846';\n");
+		grammarBuilder.append("KW1847 : 'KW' '1847';\n");
+		grammarBuilder.append("KW1848 : 'KW' '1848';\n");
+		grammarBuilder.append("KW1849 : 'KW' '1849';\n");
+		grammarBuilder.append("KW1850 : 'KW' '1850';\n");
+		grammarBuilder.append("KW1851 : 'KW' '1851';\n");
+		grammarBuilder.append("KW1852 : 'KW' '1852';\n");
+		grammarBuilder.append("KW1853 : 'KW' '1853';\n");
+		grammarBuilder.append("KW1854 : 'KW' '1854';\n");
+		grammarBuilder.append("KW1855 : 'KW' '1855';\n");
+		grammarBuilder.append("KW1856 : 'KW' '1856';\n");
+		grammarBuilder.append("KW1857 : 'KW' '1857';\n");
+		grammarBuilder.append("KW1858 : 'KW' '1858';\n");
+		grammarBuilder.append("KW1859 : 'KW' '1859';\n");
+		grammarBuilder.append("KW1860 : 'KW' '1860';\n");
+		grammarBuilder.append("KW1861 : 'KW' '1861';\n");
+		grammarBuilder.append("KW1862 : 'KW' '1862';\n");
+		grammarBuilder.append("KW1863 : 'KW' '1863';\n");
+		grammarBuilder.append("KW1864 : 'KW' '1864';\n");
+		grammarBuilder.append("KW1865 : 'KW' '1865';\n");
+		grammarBuilder.append("KW1866 : 'KW' '1866';\n");
+		grammarBuilder.append("KW1867 : 'KW' '1867';\n");
+		grammarBuilder.append("KW1868 : 'KW' '1868';\n");
+		grammarBuilder.append("KW1869 : 'KW' '1869';\n");
+		grammarBuilder.append("KW1870 : 'KW' '1870';\n");
+		grammarBuilder.append("KW1871 : 'KW' '1871';\n");
+		grammarBuilder.append("KW1872 : 'KW' '1872';\n");
+		grammarBuilder.append("KW1873 : 'KW' '1873';\n");
+		grammarBuilder.append("KW1874 : 'KW' '1874';\n");
+		grammarBuilder.append("KW1875 : 'KW' '1875';\n");
+		grammarBuilder.append("KW1876 : 'KW' '1876';\n");
+		grammarBuilder.append("KW1877 : 'KW' '1877';\n");
+		grammarBuilder.append("KW1878 : 'KW' '1878';\n");
+		grammarBuilder.append("KW1879 : 'KW' '1879';\n");
+		grammarBuilder.append("KW1880 : 'KW' '1880';\n");
+		grammarBuilder.append("KW1881 : 'KW' '1881';\n");
+		grammarBuilder.append("KW1882 : 'KW' '1882';\n");
+		grammarBuilder.append("KW1883 : 'KW' '1883';\n");
+		grammarBuilder.append("KW1884 : 'KW' '1884';\n");
+		grammarBuilder.append("KW1885 : 'KW' '1885';\n");
+		grammarBuilder.append("KW1886 : 'KW' '1886';\n");
+		grammarBuilder.append("KW1887 : 'KW' '1887';\n");
+		grammarBuilder.append("KW1888 : 'KW' '1888';\n");
+		grammarBuilder.append("KW1889 : 'KW' '1889';\n");
+		grammarBuilder.append("KW1890 : 'KW' '1890';\n");
+		grammarBuilder.append("KW1891 : 'KW' '1891';\n");
+		grammarBuilder.append("KW1892 : 'KW' '1892';\n");
+		grammarBuilder.append("KW1893 : 'KW' '1893';\n");
+		grammarBuilder.append("KW1894 : 'KW' '1894';\n");
+		grammarBuilder.append("KW1895 : 'KW' '1895';\n");
+		grammarBuilder.append("KW1896 : 'KW' '1896';\n");
+		grammarBuilder.append("KW1897 : 'KW' '1897';\n");
+		grammarBuilder.append("KW1898 : 'KW' '1898';\n");
+		grammarBuilder.append("KW1899 : 'KW' '1899';\n");
+		grammarBuilder.append("KW1900 : 'KW' '1900';\n");
+		grammarBuilder.append("KW1901 : 'KW' '1901';\n");
+		grammarBuilder.append("KW1902 : 'KW' '1902';\n");
+		grammarBuilder.append("KW1903 : 'KW' '1903';\n");
+		grammarBuilder.append("KW1904 : 'KW' '1904';\n");
+		grammarBuilder.append("KW1905 : 'KW' '1905';\n");
+		grammarBuilder.append("KW1906 : 'KW' '1906';\n");
+		grammarBuilder.append("KW1907 : 'KW' '1907';\n");
+		grammarBuilder.append("KW1908 : 'KW' '1908';\n");
+		grammarBuilder.append("KW1909 : 'KW' '1909';\n");
+		grammarBuilder.append("KW1910 : 'KW' '1910';\n");
+		grammarBuilder.append("KW1911 : 'KW' '1911';\n");
+		grammarBuilder.append("KW1912 : 'KW' '1912';\n");
+		grammarBuilder.append("KW1913 : 'KW' '1913';\n");
+		grammarBuilder.append("KW1914 : 'KW' '1914';\n");
+		grammarBuilder.append("KW1915 : 'KW' '1915';\n");
+		grammarBuilder.append("KW1916 : 'KW' '1916';\n");
+		grammarBuilder.append("KW1917 : 'KW' '1917';\n");
+		grammarBuilder.append("KW1918 : 'KW' '1918';\n");
+		grammarBuilder.append("KW1919 : 'KW' '1919';\n");
+		grammarBuilder.append("KW1920 : 'KW' '1920';\n");
+		grammarBuilder.append("KW1921 : 'KW' '1921';\n");
+		grammarBuilder.append("KW1922 : 'KW' '1922';\n");
+		grammarBuilder.append("KW1923 : 'KW' '1923';\n");
+		grammarBuilder.append("KW1924 : 'KW' '1924';\n");
+		grammarBuilder.append("KW1925 : 'KW' '1925';\n");
+		grammarBuilder.append("KW1926 : 'KW' '1926';\n");
+		grammarBuilder.append("KW1927 : 'KW' '1927';\n");
+		grammarBuilder.append("KW1928 : 'KW' '1928';\n");
+		grammarBuilder.append("KW1929 : 'KW' '1929';\n");
+		grammarBuilder.append("KW1930 : 'KW' '1930';\n");
+		grammarBuilder.append("KW1931 : 'KW' '1931';\n");
+		grammarBuilder.append("KW1932 : 'KW' '1932';\n");
+		grammarBuilder.append("KW1933 : 'KW' '1933';\n");
+		grammarBuilder.append("KW1934 : 'KW' '1934';\n");
+		grammarBuilder.append("KW1935 : 'KW' '1935';\n");
+		grammarBuilder.append("KW1936 : 'KW' '1936';\n");
+		grammarBuilder.append("KW1937 : 'KW' '1937';\n");
+		grammarBuilder.append("KW1938 : 'KW' '1938';\n");
+		grammarBuilder.append("KW1939 : 'KW' '1939';\n");
+		grammarBuilder.append("KW1940 : 'KW' '1940';\n");
+		grammarBuilder.append("KW1941 : 'KW' '1941';\n");
+		grammarBuilder.append("KW1942 : 'KW' '1942';\n");
+		grammarBuilder.append("KW1943 : 'KW' '1943';\n");
+		grammarBuilder.append("KW1944 : 'KW' '1944';\n");
+		grammarBuilder.append("KW1945 : 'KW' '1945';\n");
+		grammarBuilder.append("KW1946 : 'KW' '1946';\n");
+		grammarBuilder.append("KW1947 : 'KW' '1947';\n");
+		grammarBuilder.append("KW1948 : 'KW' '1948';\n");
+		grammarBuilder.append("KW1949 : 'KW' '1949';\n");
+		grammarBuilder.append("KW1950 : 'KW' '1950';\n");
+		grammarBuilder.append("KW1951 : 'KW' '1951';\n");
+		grammarBuilder.append("KW1952 : 'KW' '1952';\n");
+		grammarBuilder.append("KW1953 : 'KW' '1953';\n");
+		grammarBuilder.append("KW1954 : 'KW' '1954';\n");
+		grammarBuilder.append("KW1955 : 'KW' '1955';\n");
+		grammarBuilder.append("KW1956 : 'KW' '1956';\n");
+		grammarBuilder.append("KW1957 : 'KW' '1957';\n");
+		grammarBuilder.append("KW1958 : 'KW' '1958';\n");
+		grammarBuilder.append("KW1959 : 'KW' '1959';\n");
+		grammarBuilder.append("KW1960 : 'KW' '1960';\n");
+		grammarBuilder.append("KW1961 : 'KW' '1961';\n");
+		grammarBuilder.append("KW1962 : 'KW' '1962';\n");
+		grammarBuilder.append("KW1963 : 'KW' '1963';\n");
+		grammarBuilder.append("KW1964 : 'KW' '1964';\n");
+		grammarBuilder.append("KW1965 : 'KW' '1965';\n");
+		grammarBuilder.append("KW1966 : 'KW' '1966';\n");
+		grammarBuilder.append("KW1967 : 'KW' '1967';\n");
+		grammarBuilder.append("KW1968 : 'KW' '1968';\n");
+		grammarBuilder.append("KW1969 : 'KW' '1969';\n");
+		grammarBuilder.append("KW1970 : 'KW' '1970';\n");
+		grammarBuilder.append("KW1971 : 'KW' '1971';\n");
+		grammarBuilder.append("KW1972 : 'KW' '1972';\n");
+		grammarBuilder.append("KW1973 : 'KW' '1973';\n");
+		grammarBuilder.append("KW1974 : 'KW' '1974';\n");
+		grammarBuilder.append("KW1975 : 'KW' '1975';\n");
+		grammarBuilder.append("KW1976 : 'KW' '1976';\n");
+		grammarBuilder.append("KW1977 : 'KW' '1977';\n");
+		grammarBuilder.append("KW1978 : 'KW' '1978';\n");
+		grammarBuilder.append("KW1979 : 'KW' '1979';\n");
+		grammarBuilder.append("KW1980 : 'KW' '1980';\n");
+		grammarBuilder.append("KW1981 : 'KW' '1981';\n");
+		grammarBuilder.append("KW1982 : 'KW' '1982';\n");
+		grammarBuilder.append("KW1983 : 'KW' '1983';\n");
+		grammarBuilder.append("KW1984 : 'KW' '1984';\n");
+		grammarBuilder.append("KW1985 : 'KW' '1985';\n");
+		grammarBuilder.append("KW1986 : 'KW' '1986';\n");
+		grammarBuilder.append("KW1987 : 'KW' '1987';\n");
+		grammarBuilder.append("KW1988 : 'KW' '1988';\n");
+		grammarBuilder.append("KW1989 : 'KW' '1989';\n");
+		grammarBuilder.append("KW1990 : 'KW' '1990';\n");
+		grammarBuilder.append("KW1991 : 'KW' '1991';\n");
+		grammarBuilder.append("KW1992 : 'KW' '1992';\n");
+		grammarBuilder.append("KW1993 : 'KW' '1993';\n");
+		grammarBuilder.append("KW1994 : 'KW' '1994';\n");
+		grammarBuilder.append("KW1995 : 'KW' '1995';\n");
+		grammarBuilder.append("KW1996 : 'KW' '1996';\n");
+		grammarBuilder.append("KW1997 : 'KW' '1997';\n");
+		grammarBuilder.append("KW1998 : 'KW' '1998';\n");
+		grammarBuilder.append("KW1999 : 'KW' '1999';\n");
+		grammarBuilder.append("KW2000 : 'KW' '2000';\n");
+		grammarBuilder.append("KW2001 : 'KW' '2001';\n");
+		grammarBuilder.append("KW2002 : 'KW' '2002';\n");
+		grammarBuilder.append("KW2003 : 'KW' '2003';\n");
+		grammarBuilder.append("KW2004 : 'KW' '2004';\n");
+		grammarBuilder.append("KW2005 : 'KW' '2005';\n");
+		grammarBuilder.append("KW2006 : 'KW' '2006';\n");
+		grammarBuilder.append("KW2007 : 'KW' '2007';\n");
+		grammarBuilder.append("KW2008 : 'KW' '2008';\n");
+		grammarBuilder.append("KW2009 : 'KW' '2009';\n");
+		grammarBuilder.append("KW2010 : 'KW' '2010';\n");
+		grammarBuilder.append("KW2011 : 'KW' '2011';\n");
+		grammarBuilder.append("KW2012 : 'KW' '2012';\n");
+		grammarBuilder.append("KW2013 : 'KW' '2013';\n");
+		grammarBuilder.append("KW2014 : 'KW' '2014';\n");
+		grammarBuilder.append("KW2015 : 'KW' '2015';\n");
+		grammarBuilder.append("KW2016 : 'KW' '2016';\n");
+		grammarBuilder.append("KW2017 : 'KW' '2017';\n");
+		grammarBuilder.append("KW2018 : 'KW' '2018';\n");
+		grammarBuilder.append("KW2019 : 'KW' '2019';\n");
+		grammarBuilder.append("KW2020 : 'KW' '2020';\n");
+		grammarBuilder.append("KW2021 : 'KW' '2021';\n");
+		grammarBuilder.append("KW2022 : 'KW' '2022';\n");
+		grammarBuilder.append("KW2023 : 'KW' '2023';\n");
+		grammarBuilder.append("KW2024 : 'KW' '2024';\n");
+		grammarBuilder.append("KW2025 : 'KW' '2025';\n");
+		grammarBuilder.append("KW2026 : 'KW' '2026';\n");
+		grammarBuilder.append("KW2027 : 'KW' '2027';\n");
+		grammarBuilder.append("KW2028 : 'KW' '2028';\n");
+		grammarBuilder.append("KW2029 : 'KW' '2029';\n");
+		grammarBuilder.append("KW2030 : 'KW' '2030';\n");
+		grammarBuilder.append("KW2031 : 'KW' '2031';\n");
+		grammarBuilder.append("KW2032 : 'KW' '2032';\n");
+		grammarBuilder.append("KW2033 : 'KW' '2033';\n");
+		grammarBuilder.append("KW2034 : 'KW' '2034';\n");
+		grammarBuilder.append("KW2035 : 'KW' '2035';\n");
+		grammarBuilder.append("KW2036 : 'KW' '2036';\n");
+		grammarBuilder.append("KW2037 : 'KW' '2037';\n");
+		grammarBuilder.append("KW2038 : 'KW' '2038';\n");
+		grammarBuilder.append("KW2039 : 'KW' '2039';\n");
+		grammarBuilder.append("KW2040 : 'KW' '2040';\n");
+		grammarBuilder.append("KW2041 : 'KW' '2041';\n");
+		grammarBuilder.append("KW2042 : 'KW' '2042';\n");
+		grammarBuilder.append("KW2043 : 'KW' '2043';\n");
+		grammarBuilder.append("KW2044 : 'KW' '2044';\n");
+		grammarBuilder.append("KW2045 : 'KW' '2045';\n");
+		grammarBuilder.append("KW2046 : 'KW' '2046';\n");
+		grammarBuilder.append("KW2047 : 'KW' '2047';\n");
+		grammarBuilder.append("KW2048 : 'KW' '2048';\n");
+		grammarBuilder.append("KW2049 : 'KW' '2049';\n");
+		grammarBuilder.append("KW2050 : 'KW' '2050';\n");
+		grammarBuilder.append("KW2051 : 'KW' '2051';\n");
+		grammarBuilder.append("KW2052 : 'KW' '2052';\n");
+		grammarBuilder.append("KW2053 : 'KW' '2053';\n");
+		grammarBuilder.append("KW2054 : 'KW' '2054';\n");
+		grammarBuilder.append("KW2055 : 'KW' '2055';\n");
+		grammarBuilder.append("KW2056 : 'KW' '2056';\n");
+		grammarBuilder.append("KW2057 : 'KW' '2057';\n");
+		grammarBuilder.append("KW2058 : 'KW' '2058';\n");
+		grammarBuilder.append("KW2059 : 'KW' '2059';\n");
+		grammarBuilder.append("KW2060 : 'KW' '2060';\n");
+		grammarBuilder.append("KW2061 : 'KW' '2061';\n");
+		grammarBuilder.append("KW2062 : 'KW' '2062';\n");
+		grammarBuilder.append("KW2063 : 'KW' '2063';\n");
+		grammarBuilder.append("KW2064 : 'KW' '2064';\n");
+		grammarBuilder.append("KW2065 : 'KW' '2065';\n");
+		grammarBuilder.append("KW2066 : 'KW' '2066';\n");
+		grammarBuilder.append("KW2067 : 'KW' '2067';\n");
+		grammarBuilder.append("KW2068 : 'KW' '2068';\n");
+		grammarBuilder.append("KW2069 : 'KW' '2069';\n");
+		grammarBuilder.append("KW2070 : 'KW' '2070';\n");
+		grammarBuilder.append("KW2071 : 'KW' '2071';\n");
+		grammarBuilder.append("KW2072 : 'KW' '2072';\n");
+		grammarBuilder.append("KW2073 : 'KW' '2073';\n");
+		grammarBuilder.append("KW2074 : 'KW' '2074';\n");
+		grammarBuilder.append("KW2075 : 'KW' '2075';\n");
+		grammarBuilder.append("KW2076 : 'KW' '2076';\n");
+		grammarBuilder.append("KW2077 : 'KW' '2077';\n");
+		grammarBuilder.append("KW2078 : 'KW' '2078';\n");
+		grammarBuilder.append("KW2079 : 'KW' '2079';\n");
+		grammarBuilder.append("KW2080 : 'KW' '2080';\n");
+		grammarBuilder.append("KW2081 : 'KW' '2081';\n");
+		grammarBuilder.append("KW2082 : 'KW' '2082';\n");
+		grammarBuilder.append("KW2083 : 'KW' '2083';\n");
+		grammarBuilder.append("KW2084 : 'KW' '2084';\n");
+		grammarBuilder.append("KW2085 : 'KW' '2085';\n");
+		grammarBuilder.append("KW2086 : 'KW' '2086';\n");
+		grammarBuilder.append("KW2087 : 'KW' '2087';\n");
+		grammarBuilder.append("KW2088 : 'KW' '2088';\n");
+		grammarBuilder.append("KW2089 : 'KW' '2089';\n");
+		grammarBuilder.append("KW2090 : 'KW' '2090';\n");
+		grammarBuilder.append("KW2091 : 'KW' '2091';\n");
+		grammarBuilder.append("KW2092 : 'KW' '2092';\n");
+		grammarBuilder.append("KW2093 : 'KW' '2093';\n");
+		grammarBuilder.append("KW2094 : 'KW' '2094';\n");
+		grammarBuilder.append("KW2095 : 'KW' '2095';\n");
+		grammarBuilder.append("KW2096 : 'KW' '2096';\n");
+		grammarBuilder.append("KW2097 : 'KW' '2097';\n");
+		grammarBuilder.append("KW2098 : 'KW' '2098';\n");
+		grammarBuilder.append("KW2099 : 'KW' '2099';\n");
+		grammarBuilder.append("KW2100 : 'KW' '2100';\n");
+		grammarBuilder.append("KW2101 : 'KW' '2101';\n");
+		grammarBuilder.append("KW2102 : 'KW' '2102';\n");
+		grammarBuilder.append("KW2103 : 'KW' '2103';\n");
+		grammarBuilder.append("KW2104 : 'KW' '2104';\n");
+		grammarBuilder.append("KW2105 : 'KW' '2105';\n");
+		grammarBuilder.append("KW2106 : 'KW' '2106';\n");
+		grammarBuilder.append("KW2107 : 'KW' '2107';\n");
+		grammarBuilder.append("KW2108 : 'KW' '2108';\n");
+		grammarBuilder.append("KW2109 : 'KW' '2109';\n");
+		grammarBuilder.append("KW2110 : 'KW' '2110';\n");
+		grammarBuilder.append("KW2111 : 'KW' '2111';\n");
+		grammarBuilder.append("KW2112 : 'KW' '2112';\n");
+		grammarBuilder.append("KW2113 : 'KW' '2113';\n");
+		grammarBuilder.append("KW2114 : 'KW' '2114';\n");
+		grammarBuilder.append("KW2115 : 'KW' '2115';\n");
+		grammarBuilder.append("KW2116 : 'KW' '2116';\n");
+		grammarBuilder.append("KW2117 : 'KW' '2117';\n");
+		grammarBuilder.append("KW2118 : 'KW' '2118';\n");
+		grammarBuilder.append("KW2119 : 'KW' '2119';\n");
+		grammarBuilder.append("KW2120 : 'KW' '2120';\n");
+		grammarBuilder.append("KW2121 : 'KW' '2121';\n");
+		grammarBuilder.append("KW2122 : 'KW' '2122';\n");
+		grammarBuilder.append("KW2123 : 'KW' '2123';\n");
+		grammarBuilder.append("KW2124 : 'KW' '2124';\n");
+		grammarBuilder.append("KW2125 : 'KW' '2125';\n");
+		grammarBuilder.append("KW2126 : 'KW' '2126';\n");
+		grammarBuilder.append("KW2127 : 'KW' '2127';\n");
+		grammarBuilder.append("KW2128 : 'KW' '2128';\n");
+		grammarBuilder.append("KW2129 : 'KW' '2129';\n");
+		grammarBuilder.append("KW2130 : 'KW' '2130';\n");
+		grammarBuilder.append("KW2131 : 'KW' '2131';\n");
+		grammarBuilder.append("KW2132 : 'KW' '2132';\n");
+		grammarBuilder.append("KW2133 : 'KW' '2133';\n");
+		grammarBuilder.append("KW2134 : 'KW' '2134';\n");
+		grammarBuilder.append("KW2135 : 'KW' '2135';\n");
+		grammarBuilder.append("KW2136 : 'KW' '2136';\n");
+		grammarBuilder.append("KW2137 : 'KW' '2137';\n");
+		grammarBuilder.append("KW2138 : 'KW' '2138';\n");
+		grammarBuilder.append("KW2139 : 'KW' '2139';\n");
+		grammarBuilder.append("KW2140 : 'KW' '2140';\n");
+		grammarBuilder.append("KW2141 : 'KW' '2141';\n");
+		grammarBuilder.append("KW2142 : 'KW' '2142';\n");
+		grammarBuilder.append("KW2143 : 'KW' '2143';\n");
+		grammarBuilder.append("KW2144 : 'KW' '2144';\n");
+		grammarBuilder.append("KW2145 : 'KW' '2145';\n");
+		grammarBuilder.append("KW2146 : 'KW' '2146';\n");
+		grammarBuilder.append("KW2147 : 'KW' '2147';\n");
+		grammarBuilder.append("KW2148 : 'KW' '2148';\n");
+		grammarBuilder.append("KW2149 : 'KW' '2149';\n");
+		grammarBuilder.append("KW2150 : 'KW' '2150';\n");
+		grammarBuilder.append("KW2151 : 'KW' '2151';\n");
+		grammarBuilder.append("KW2152 : 'KW' '2152';\n");
+		grammarBuilder.append("KW2153 : 'KW' '2153';\n");
+		grammarBuilder.append("KW2154 : 'KW' '2154';\n");
+		grammarBuilder.append("KW2155 : 'KW' '2155';\n");
+		grammarBuilder.append("KW2156 : 'KW' '2156';\n");
+		grammarBuilder.append("KW2157 : 'KW' '2157';\n");
+		grammarBuilder.append("KW2158 : 'KW' '2158';\n");
+		grammarBuilder.append("KW2159 : 'KW' '2159';\n");
+		grammarBuilder.append("KW2160 : 'KW' '2160';\n");
+		grammarBuilder.append("KW2161 : 'KW' '2161';\n");
+		grammarBuilder.append("KW2162 : 'KW' '2162';\n");
+		grammarBuilder.append("KW2163 : 'KW' '2163';\n");
+		grammarBuilder.append("KW2164 : 'KW' '2164';\n");
+		grammarBuilder.append("KW2165 : 'KW' '2165';\n");
+		grammarBuilder.append("KW2166 : 'KW' '2166';\n");
+		grammarBuilder.append("KW2167 : 'KW' '2167';\n");
+		grammarBuilder.append("KW2168 : 'KW' '2168';\n");
+		grammarBuilder.append("KW2169 : 'KW' '2169';\n");
+		grammarBuilder.append("KW2170 : 'KW' '2170';\n");
+		grammarBuilder.append("KW2171 : 'KW' '2171';\n");
+		grammarBuilder.append("KW2172 : 'KW' '2172';\n");
+		grammarBuilder.append("KW2173 : 'KW' '2173';\n");
+		grammarBuilder.append("KW2174 : 'KW' '2174';\n");
+		grammarBuilder.append("KW2175 : 'KW' '2175';\n");
+		grammarBuilder.append("KW2176 : 'KW' '2176';\n");
+		grammarBuilder.append("KW2177 : 'KW' '2177';\n");
+		grammarBuilder.append("KW2178 : 'KW' '2178';\n");
+		grammarBuilder.append("KW2179 : 'KW' '2179';\n");
+		grammarBuilder.append("KW2180 : 'KW' '2180';\n");
+		grammarBuilder.append("KW2181 : 'KW' '2181';\n");
+		grammarBuilder.append("KW2182 : 'KW' '2182';\n");
+		grammarBuilder.append("KW2183 : 'KW' '2183';\n");
+		grammarBuilder.append("KW2184 : 'KW' '2184';\n");
+		grammarBuilder.append("KW2185 : 'KW' '2185';\n");
+		grammarBuilder.append("KW2186 : 'KW' '2186';\n");
+		grammarBuilder.append("KW2187 : 'KW' '2187';\n");
+		grammarBuilder.append("KW2188 : 'KW' '2188';\n");
+		grammarBuilder.append("KW2189 : 'KW' '2189';\n");
+		grammarBuilder.append("KW2190 : 'KW' '2190';\n");
+		grammarBuilder.append("KW2191 : 'KW' '2191';\n");
+		grammarBuilder.append("KW2192 : 'KW' '2192';\n");
+		grammarBuilder.append("KW2193 : 'KW' '2193';\n");
+		grammarBuilder.append("KW2194 : 'KW' '2194';\n");
+		grammarBuilder.append("KW2195 : 'KW' '2195';\n");
+		grammarBuilder.append("KW2196 : 'KW' '2196';\n");
+		grammarBuilder.append("KW2197 : 'KW' '2197';\n");
+		grammarBuilder.append("KW2198 : 'KW' '2198';\n");
+		grammarBuilder.append("KW2199 : 'KW' '2199';\n");
+		grammarBuilder.append("KW2200 : 'KW' '2200';\n");
+		grammarBuilder.append("KW2201 : 'KW' '2201';\n");
+		grammarBuilder.append("KW2202 : 'KW' '2202';\n");
+		grammarBuilder.append("KW2203 : 'KW' '2203';\n");
+		grammarBuilder.append("KW2204 : 'KW' '2204';\n");
+		grammarBuilder.append("KW2205 : 'KW' '2205';\n");
+		grammarBuilder.append("KW2206 : 'KW' '2206';\n");
+		grammarBuilder.append("KW2207 : 'KW' '2207';\n");
+		grammarBuilder.append("KW2208 : 'KW' '2208';\n");
+		grammarBuilder.append("KW2209 : 'KW' '2209';\n");
+		grammarBuilder.append("KW2210 : 'KW' '2210';\n");
+		grammarBuilder.append("KW2211 : 'KW' '2211';\n");
+		grammarBuilder.append("KW2212 : 'KW' '2212';\n");
+		grammarBuilder.append("KW2213 : 'KW' '2213';\n");
+		grammarBuilder.append("KW2214 : 'KW' '2214';\n");
+		grammarBuilder.append("KW2215 : 'KW' '2215';\n");
+		grammarBuilder.append("KW2216 : 'KW' '2216';\n");
+		grammarBuilder.append("KW2217 : 'KW' '2217';\n");
+		grammarBuilder.append("KW2218 : 'KW' '2218';\n");
+		grammarBuilder.append("KW2219 : 'KW' '2219';\n");
+		grammarBuilder.append("KW2220 : 'KW' '2220';\n");
+		grammarBuilder.append("KW2221 : 'KW' '2221';\n");
+		grammarBuilder.append("KW2222 : 'KW' '2222';\n");
+		grammarBuilder.append("KW2223 : 'KW' '2223';\n");
+		grammarBuilder.append("KW2224 : 'KW' '2224';\n");
+		grammarBuilder.append("KW2225 : 'KW' '2225';\n");
+		grammarBuilder.append("KW2226 : 'KW' '2226';\n");
+		grammarBuilder.append("KW2227 : 'KW' '2227';\n");
+		grammarBuilder.append("KW2228 : 'KW' '2228';\n");
+		grammarBuilder.append("KW2229 : 'KW' '2229';\n");
+		grammarBuilder.append("KW2230 : 'KW' '2230';\n");
+		grammarBuilder.append("KW2231 : 'KW' '2231';\n");
+		grammarBuilder.append("KW2232 : 'KW' '2232';\n");
+		grammarBuilder.append("KW2233 : 'KW' '2233';\n");
+		grammarBuilder.append("KW2234 : 'KW' '2234';\n");
+		grammarBuilder.append("KW2235 : 'KW' '2235';\n");
+		grammarBuilder.append("KW2236 : 'KW' '2236';\n");
+		grammarBuilder.append("KW2237 : 'KW' '2237';\n");
+		grammarBuilder.append("KW2238 : 'KW' '2238';\n");
+		grammarBuilder.append("KW2239 : 'KW' '2239';\n");
+		grammarBuilder.append("KW2240 : 'KW' '2240';\n");
+		grammarBuilder.append("KW2241 : 'KW' '2241';\n");
+		grammarBuilder.append("KW2242 : 'KW' '2242';\n");
+		grammarBuilder.append("KW2243 : 'KW' '2243';\n");
+		grammarBuilder.append("KW2244 : 'KW' '2244';\n");
+		grammarBuilder.append("KW2245 : 'KW' '2245';\n");
+		grammarBuilder.append("KW2246 : 'KW' '2246';\n");
+		grammarBuilder.append("KW2247 : 'KW' '2247';\n");
+		grammarBuilder.append("KW2248 : 'KW' '2248';\n");
+		grammarBuilder.append("KW2249 : 'KW' '2249';\n");
+		grammarBuilder.append("KW2250 : 'KW' '2250';\n");
+		grammarBuilder.append("KW2251 : 'KW' '2251';\n");
+		grammarBuilder.append("KW2252 : 'KW' '2252';\n");
+		grammarBuilder.append("KW2253 : 'KW' '2253';\n");
+		grammarBuilder.append("KW2254 : 'KW' '2254';\n");
+		grammarBuilder.append("KW2255 : 'KW' '2255';\n");
+		grammarBuilder.append("KW2256 : 'KW' '2256';\n");
+		grammarBuilder.append("KW2257 : 'KW' '2257';\n");
+		grammarBuilder.append("KW2258 : 'KW' '2258';\n");
+		grammarBuilder.append("KW2259 : 'KW' '2259';\n");
+		grammarBuilder.append("KW2260 : 'KW' '2260';\n");
+		grammarBuilder.append("KW2261 : 'KW' '2261';\n");
+		grammarBuilder.append("KW2262 : 'KW' '2262';\n");
+		grammarBuilder.append("KW2263 : 'KW' '2263';\n");
+		grammarBuilder.append("KW2264 : 'KW' '2264';\n");
+		grammarBuilder.append("KW2265 : 'KW' '2265';\n");
+		grammarBuilder.append("KW2266 : 'KW' '2266';\n");
+		grammarBuilder.append("KW2267 : 'KW' '2267';\n");
+		grammarBuilder.append("KW2268 : 'KW' '2268';\n");
+		grammarBuilder.append("KW2269 : 'KW' '2269';\n");
+		grammarBuilder.append("KW2270 : 'KW' '2270';\n");
+		grammarBuilder.append("KW2271 : 'KW' '2271';\n");
+		grammarBuilder.append("KW2272 : 'KW' '2272';\n");
+		grammarBuilder.append("KW2273 : 'KW' '2273';\n");
+		grammarBuilder.append("KW2274 : 'KW' '2274';\n");
+		grammarBuilder.append("KW2275 : 'KW' '2275';\n");
+		grammarBuilder.append("KW2276 : 'KW' '2276';\n");
+		grammarBuilder.append("KW2277 : 'KW' '2277';\n");
+		grammarBuilder.append("KW2278 : 'KW' '2278';\n");
+		grammarBuilder.append("KW2279 : 'KW' '2279';\n");
+		grammarBuilder.append("KW2280 : 'KW' '2280';\n");
+		grammarBuilder.append("KW2281 : 'KW' '2281';\n");
+		grammarBuilder.append("KW2282 : 'KW' '2282';\n");
+		grammarBuilder.append("KW2283 : 'KW' '2283';\n");
+		grammarBuilder.append("KW2284 : 'KW' '2284';\n");
+		grammarBuilder.append("KW2285 : 'KW' '2285';\n");
+		grammarBuilder.append("KW2286 : 'KW' '2286';\n");
+		grammarBuilder.append("KW2287 : 'KW' '2287';\n");
+		grammarBuilder.append("KW2288 : 'KW' '2288';\n");
+		grammarBuilder.append("KW2289 : 'KW' '2289';\n");
+		grammarBuilder.append("KW2290 : 'KW' '2290';\n");
+		grammarBuilder.append("KW2291 : 'KW' '2291';\n");
+		grammarBuilder.append("KW2292 : 'KW' '2292';\n");
+		grammarBuilder.append("KW2293 : 'KW' '2293';\n");
+		grammarBuilder.append("KW2294 : 'KW' '2294';\n");
+		grammarBuilder.append("KW2295 : 'KW' '2295';\n");
+		grammarBuilder.append("KW2296 : 'KW' '2296';\n");
+		grammarBuilder.append("KW2297 : 'KW' '2297';\n");
+		grammarBuilder.append("KW2298 : 'KW' '2298';\n");
+		grammarBuilder.append("KW2299 : 'KW' '2299';\n");
+		grammarBuilder.append("KW2300 : 'KW' '2300';\n");
+		grammarBuilder.append("KW2301 : 'KW' '2301';\n");
+		grammarBuilder.append("KW2302 : 'KW' '2302';\n");
+		grammarBuilder.append("KW2303 : 'KW' '2303';\n");
+		grammarBuilder.append("KW2304 : 'KW' '2304';\n");
+		grammarBuilder.append("KW2305 : 'KW' '2305';\n");
+		grammarBuilder.append("KW2306 : 'KW' '2306';\n");
+		grammarBuilder.append("KW2307 : 'KW' '2307';\n");
+		grammarBuilder.append("KW2308 : 'KW' '2308';\n");
+		grammarBuilder.append("KW2309 : 'KW' '2309';\n");
+		grammarBuilder.append("KW2310 : 'KW' '2310';\n");
+		grammarBuilder.append("KW2311 : 'KW' '2311';\n");
+		grammarBuilder.append("KW2312 : 'KW' '2312';\n");
+		grammarBuilder.append("KW2313 : 'KW' '2313';\n");
+		grammarBuilder.append("KW2314 : 'KW' '2314';\n");
+		grammarBuilder.append("KW2315 : 'KW' '2315';\n");
+		grammarBuilder.append("KW2316 : 'KW' '2316';\n");
+		grammarBuilder.append("KW2317 : 'KW' '2317';\n");
+		grammarBuilder.append("KW2318 : 'KW' '2318';\n");
+		grammarBuilder.append("KW2319 : 'KW' '2319';\n");
+		grammarBuilder.append("KW2320 : 'KW' '2320';\n");
+		grammarBuilder.append("KW2321 : 'KW' '2321';\n");
+		grammarBuilder.append("KW2322 : 'KW' '2322';\n");
+		grammarBuilder.append("KW2323 : 'KW' '2323';\n");
+		grammarBuilder.append("KW2324 : 'KW' '2324';\n");
+		grammarBuilder.append("KW2325 : 'KW' '2325';\n");
+		grammarBuilder.append("KW2326 : 'KW' '2326';\n");
+		grammarBuilder.append("KW2327 : 'KW' '2327';\n");
+		grammarBuilder.append("KW2328 : 'KW' '2328';\n");
+		grammarBuilder.append("KW2329 : 'KW' '2329';\n");
+		grammarBuilder.append("KW2330 : 'KW' '2330';\n");
+		grammarBuilder.append("KW2331 : 'KW' '2331';\n");
+		grammarBuilder.append("KW2332 : 'KW' '2332';\n");
+		grammarBuilder.append("KW2333 : 'KW' '2333';\n");
+		grammarBuilder.append("KW2334 : 'KW' '2334';\n");
+		grammarBuilder.append("KW2335 : 'KW' '2335';\n");
+		grammarBuilder.append("KW2336 : 'KW' '2336';\n");
+		grammarBuilder.append("KW2337 : 'KW' '2337';\n");
+		grammarBuilder.append("KW2338 : 'KW' '2338';\n");
+		grammarBuilder.append("KW2339 : 'KW' '2339';\n");
+		grammarBuilder.append("KW2340 : 'KW' '2340';\n");
+		grammarBuilder.append("KW2341 : 'KW' '2341';\n");
+		grammarBuilder.append("KW2342 : 'KW' '2342';\n");
+		grammarBuilder.append("KW2343 : 'KW' '2343';\n");
+		grammarBuilder.append("KW2344 : 'KW' '2344';\n");
+		grammarBuilder.append("KW2345 : 'KW' '2345';\n");
+		grammarBuilder.append("KW2346 : 'KW' '2346';\n");
+		grammarBuilder.append("KW2347 : 'KW' '2347';\n");
+		grammarBuilder.append("KW2348 : 'KW' '2348';\n");
+		grammarBuilder.append("KW2349 : 'KW' '2349';\n");
+		grammarBuilder.append("KW2350 : 'KW' '2350';\n");
+		grammarBuilder.append("KW2351 : 'KW' '2351';\n");
+		grammarBuilder.append("KW2352 : 'KW' '2352';\n");
+		grammarBuilder.append("KW2353 : 'KW' '2353';\n");
+		grammarBuilder.append("KW2354 : 'KW' '2354';\n");
+		grammarBuilder.append("KW2355 : 'KW' '2355';\n");
+		grammarBuilder.append("KW2356 : 'KW' '2356';\n");
+		grammarBuilder.append("KW2357 : 'KW' '2357';\n");
+		grammarBuilder.append("KW2358 : 'KW' '2358';\n");
+		grammarBuilder.append("KW2359 : 'KW' '2359';\n");
+		grammarBuilder.append("KW2360 : 'KW' '2360';\n");
+		grammarBuilder.append("KW2361 : 'KW' '2361';\n");
+		grammarBuilder.append("KW2362 : 'KW' '2362';\n");
+		grammarBuilder.append("KW2363 : 'KW' '2363';\n");
+		grammarBuilder.append("KW2364 : 'KW' '2364';\n");
+		grammarBuilder.append("KW2365 : 'KW' '2365';\n");
+		grammarBuilder.append("KW2366 : 'KW' '2366';\n");
+		grammarBuilder.append("KW2367 : 'KW' '2367';\n");
+		grammarBuilder.append("KW2368 : 'KW' '2368';\n");
+		grammarBuilder.append("KW2369 : 'KW' '2369';\n");
+		grammarBuilder.append("KW2370 : 'KW' '2370';\n");
+		grammarBuilder.append("KW2371 : 'KW' '2371';\n");
+		grammarBuilder.append("KW2372 : 'KW' '2372';\n");
+		grammarBuilder.append("KW2373 : 'KW' '2373';\n");
+		grammarBuilder.append("KW2374 : 'KW' '2374';\n");
+		grammarBuilder.append("KW2375 : 'KW' '2375';\n");
+		grammarBuilder.append("KW2376 : 'KW' '2376';\n");
+		grammarBuilder.append("KW2377 : 'KW' '2377';\n");
+		grammarBuilder.append("KW2378 : 'KW' '2378';\n");
+		grammarBuilder.append("KW2379 : 'KW' '2379';\n");
+		grammarBuilder.append("KW2380 : 'KW' '2380';\n");
+		grammarBuilder.append("KW2381 : 'KW' '2381';\n");
+		grammarBuilder.append("KW2382 : 'KW' '2382';\n");
+		grammarBuilder.append("KW2383 : 'KW' '2383';\n");
+		grammarBuilder.append("KW2384 : 'KW' '2384';\n");
+		grammarBuilder.append("KW2385 : 'KW' '2385';\n");
+		grammarBuilder.append("KW2386 : 'KW' '2386';\n");
+		grammarBuilder.append("KW2387 : 'KW' '2387';\n");
+		grammarBuilder.append("KW2388 : 'KW' '2388';\n");
+		grammarBuilder.append("KW2389 : 'KW' '2389';\n");
+		grammarBuilder.append("KW2390 : 'KW' '2390';\n");
+		grammarBuilder.append("KW2391 : 'KW' '2391';\n");
+		grammarBuilder.append("KW2392 : 'KW' '2392';\n");
+		grammarBuilder.append("KW2393 : 'KW' '2393';\n");
+		grammarBuilder.append("KW2394 : 'KW' '2394';\n");
+		grammarBuilder.append("KW2395 : 'KW' '2395';\n");
+		grammarBuilder.append("KW2396 : 'KW' '2396';\n");
+		grammarBuilder.append("KW2397 : 'KW' '2397';\n");
+		grammarBuilder.append("KW2398 : 'KW' '2398';\n");
+		grammarBuilder.append("KW2399 : 'KW' '2399';\n");
+		grammarBuilder.append("KW2400 : 'KW' '2400';\n");
+		grammarBuilder.append("KW2401 : 'KW' '2401';\n");
+		grammarBuilder.append("KW2402 : 'KW' '2402';\n");
+		grammarBuilder.append("KW2403 : 'KW' '2403';\n");
+		grammarBuilder.append("KW2404 : 'KW' '2404';\n");
+		grammarBuilder.append("KW2405 : 'KW' '2405';\n");
+		grammarBuilder.append("KW2406 : 'KW' '2406';\n");
+		grammarBuilder.append("KW2407 : 'KW' '2407';\n");
+		grammarBuilder.append("KW2408 : 'KW' '2408';\n");
+		grammarBuilder.append("KW2409 : 'KW' '2409';\n");
+		grammarBuilder.append("KW2410 : 'KW' '2410';\n");
+		grammarBuilder.append("KW2411 : 'KW' '2411';\n");
+		grammarBuilder.append("KW2412 : 'KW' '2412';\n");
+		grammarBuilder.append("KW2413 : 'KW' '2413';\n");
+		grammarBuilder.append("KW2414 : 'KW' '2414';\n");
+		grammarBuilder.append("KW2415 : 'KW' '2415';\n");
+		grammarBuilder.append("KW2416 : 'KW' '2416';\n");
+		grammarBuilder.append("KW2417 : 'KW' '2417';\n");
+		grammarBuilder.append("KW2418 : 'KW' '2418';\n");
+		grammarBuilder.append("KW2419 : 'KW' '2419';\n");
+		grammarBuilder.append("KW2420 : 'KW' '2420';\n");
+		grammarBuilder.append("KW2421 : 'KW' '2421';\n");
+		grammarBuilder.append("KW2422 : 'KW' '2422';\n");
+		grammarBuilder.append("KW2423 : 'KW' '2423';\n");
+		grammarBuilder.append("KW2424 : 'KW' '2424';\n");
+		grammarBuilder.append("KW2425 : 'KW' '2425';\n");
+		grammarBuilder.append("KW2426 : 'KW' '2426';\n");
+		grammarBuilder.append("KW2427 : 'KW' '2427';\n");
+		grammarBuilder.append("KW2428 : 'KW' '2428';\n");
+		grammarBuilder.append("KW2429 : 'KW' '2429';\n");
+		grammarBuilder.append("KW2430 : 'KW' '2430';\n");
+		grammarBuilder.append("KW2431 : 'KW' '2431';\n");
+		grammarBuilder.append("KW2432 : 'KW' '2432';\n");
+		grammarBuilder.append("KW2433 : 'KW' '2433';\n");
+		grammarBuilder.append("KW2434 : 'KW' '2434';\n");
+		grammarBuilder.append("KW2435 : 'KW' '2435';\n");
+		grammarBuilder.append("KW2436 : 'KW' '2436';\n");
+		grammarBuilder.append("KW2437 : 'KW' '2437';\n");
+		grammarBuilder.append("KW2438 : 'KW' '2438';\n");
+		grammarBuilder.append("KW2439 : 'KW' '2439';\n");
+		grammarBuilder.append("KW2440 : 'KW' '2440';\n");
+		grammarBuilder.append("KW2441 : 'KW' '2441';\n");
+		grammarBuilder.append("KW2442 : 'KW' '2442';\n");
+		grammarBuilder.append("KW2443 : 'KW' '2443';\n");
+		grammarBuilder.append("KW2444 : 'KW' '2444';\n");
+		grammarBuilder.append("KW2445 : 'KW' '2445';\n");
+		grammarBuilder.append("KW2446 : 'KW' '2446';\n");
+		grammarBuilder.append("KW2447 : 'KW' '2447';\n");
+		grammarBuilder.append("KW2448 : 'KW' '2448';\n");
+		grammarBuilder.append("KW2449 : 'KW' '2449';\n");
+		grammarBuilder.append("KW2450 : 'KW' '2450';\n");
+		grammarBuilder.append("KW2451 : 'KW' '2451';\n");
+		grammarBuilder.append("KW2452 : 'KW' '2452';\n");
+		grammarBuilder.append("KW2453 : 'KW' '2453';\n");
+		grammarBuilder.append("KW2454 : 'KW' '2454';\n");
+		grammarBuilder.append("KW2455 : 'KW' '2455';\n");
+		grammarBuilder.append("KW2456 : 'KW' '2456';\n");
+		grammarBuilder.append("KW2457 : 'KW' '2457';\n");
+		grammarBuilder.append("KW2458 : 'KW' '2458';\n");
+		grammarBuilder.append("KW2459 : 'KW' '2459';\n");
+		grammarBuilder.append("KW2460 : 'KW' '2460';\n");
+		grammarBuilder.append("KW2461 : 'KW' '2461';\n");
+		grammarBuilder.append("KW2462 : 'KW' '2462';\n");
+		grammarBuilder.append("KW2463 : 'KW' '2463';\n");
+		grammarBuilder.append("KW2464 : 'KW' '2464';\n");
+		grammarBuilder.append("KW2465 : 'KW' '2465';\n");
+		grammarBuilder.append("KW2466 : 'KW' '2466';\n");
+		grammarBuilder.append("KW2467 : 'KW' '2467';\n");
+		grammarBuilder.append("KW2468 : 'KW' '2468';\n");
+		grammarBuilder.append("KW2469 : 'KW' '2469';\n");
+		grammarBuilder.append("KW2470 : 'KW' '2470';\n");
+		grammarBuilder.append("KW2471 : 'KW' '2471';\n");
+		grammarBuilder.append("KW2472 : 'KW' '2472';\n");
+		grammarBuilder.append("KW2473 : 'KW' '2473';\n");
+		grammarBuilder.append("KW2474 : 'KW' '2474';\n");
+		grammarBuilder.append("KW2475 : 'KW' '2475';\n");
+		grammarBuilder.append("KW2476 : 'KW' '2476';\n");
+		grammarBuilder.append("KW2477 : 'KW' '2477';\n");
+		grammarBuilder.append("KW2478 : 'KW' '2478';\n");
+		grammarBuilder.append("KW2479 : 'KW' '2479';\n");
+		grammarBuilder.append("KW2480 : 'KW' '2480';\n");
+		grammarBuilder.append("KW2481 : 'KW' '2481';\n");
+		grammarBuilder.append("KW2482 : 'KW' '2482';\n");
+		grammarBuilder.append("KW2483 : 'KW' '2483';\n");
+		grammarBuilder.append("KW2484 : 'KW' '2484';\n");
+		grammarBuilder.append("KW2485 : 'KW' '2485';\n");
+		grammarBuilder.append("KW2486 : 'KW' '2486';\n");
+		grammarBuilder.append("KW2487 : 'KW' '2487';\n");
+		grammarBuilder.append("KW2488 : 'KW' '2488';\n");
+		grammarBuilder.append("KW2489 : 'KW' '2489';\n");
+		grammarBuilder.append("KW2490 : 'KW' '2490';\n");
+		grammarBuilder.append("KW2491 : 'KW' '2491';\n");
+		grammarBuilder.append("KW2492 : 'KW' '2492';\n");
+		grammarBuilder.append("KW2493 : 'KW' '2493';\n");
+		grammarBuilder.append("KW2494 : 'KW' '2494';\n");
+		grammarBuilder.append("KW2495 : 'KW' '2495';\n");
+		grammarBuilder.append("KW2496 : 'KW' '2496';\n");
+		grammarBuilder.append("KW2497 : 'KW' '2497';\n");
+		grammarBuilder.append("KW2498 : 'KW' '2498';\n");
+		grammarBuilder.append("KW2499 : 'KW' '2499';\n");
+		grammarBuilder.append("KW2500 : 'KW' '2500';\n");
+		grammarBuilder.append("KW2501 : 'KW' '2501';\n");
+		grammarBuilder.append("KW2502 : 'KW' '2502';\n");
+		grammarBuilder.append("KW2503 : 'KW' '2503';\n");
+		grammarBuilder.append("KW2504 : 'KW' '2504';\n");
+		grammarBuilder.append("KW2505 : 'KW' '2505';\n");
+		grammarBuilder.append("KW2506 : 'KW' '2506';\n");
+		grammarBuilder.append("KW2507 : 'KW' '2507';\n");
+		grammarBuilder.append("KW2508 : 'KW' '2508';\n");
+		grammarBuilder.append("KW2509 : 'KW' '2509';\n");
+		grammarBuilder.append("KW2510 : 'KW' '2510';\n");
+		grammarBuilder.append("KW2511 : 'KW' '2511';\n");
+		grammarBuilder.append("KW2512 : 'KW' '2512';\n");
+		grammarBuilder.append("KW2513 : 'KW' '2513';\n");
+		grammarBuilder.append("KW2514 : 'KW' '2514';\n");
+		grammarBuilder.append("KW2515 : 'KW' '2515';\n");
+		grammarBuilder.append("KW2516 : 'KW' '2516';\n");
+		grammarBuilder.append("KW2517 : 'KW' '2517';\n");
+		grammarBuilder.append("KW2518 : 'KW' '2518';\n");
+		grammarBuilder.append("KW2519 : 'KW' '2519';\n");
+		grammarBuilder.append("KW2520 : 'KW' '2520';\n");
+		grammarBuilder.append("KW2521 : 'KW' '2521';\n");
+		grammarBuilder.append("KW2522 : 'KW' '2522';\n");
+		grammarBuilder.append("KW2523 : 'KW' '2523';\n");
+		grammarBuilder.append("KW2524 : 'KW' '2524';\n");
+		grammarBuilder.append("KW2525 : 'KW' '2525';\n");
+		grammarBuilder.append("KW2526 : 'KW' '2526';\n");
+		grammarBuilder.append("KW2527 : 'KW' '2527';\n");
+		grammarBuilder.append("KW2528 : 'KW' '2528';\n");
+		grammarBuilder.append("KW2529 : 'KW' '2529';\n");
+		grammarBuilder.append("KW2530 : 'KW' '2530';\n");
+		grammarBuilder.append("KW2531 : 'KW' '2531';\n");
+		grammarBuilder.append("KW2532 : 'KW' '2532';\n");
+		grammarBuilder.append("KW2533 : 'KW' '2533';\n");
+		grammarBuilder.append("KW2534 : 'KW' '2534';\n");
+		grammarBuilder.append("KW2535 : 'KW' '2535';\n");
+		grammarBuilder.append("KW2536 : 'KW' '2536';\n");
+		grammarBuilder.append("KW2537 : 'KW' '2537';\n");
+		grammarBuilder.append("KW2538 : 'KW' '2538';\n");
+		grammarBuilder.append("KW2539 : 'KW' '2539';\n");
+		grammarBuilder.append("KW2540 : 'KW' '2540';\n");
+		grammarBuilder.append("KW2541 : 'KW' '2541';\n");
+		grammarBuilder.append("KW2542 : 'KW' '2542';\n");
+		grammarBuilder.append("KW2543 : 'KW' '2543';\n");
+		grammarBuilder.append("KW2544 : 'KW' '2544';\n");
+		grammarBuilder.append("KW2545 : 'KW' '2545';\n");
+		grammarBuilder.append("KW2546 : 'KW' '2546';\n");
+		grammarBuilder.append("KW2547 : 'KW' '2547';\n");
+		grammarBuilder.append("KW2548 : 'KW' '2548';\n");
+		grammarBuilder.append("KW2549 : 'KW' '2549';\n");
+		grammarBuilder.append("KW2550 : 'KW' '2550';\n");
+		grammarBuilder.append("KW2551 : 'KW' '2551';\n");
+		grammarBuilder.append("KW2552 : 'KW' '2552';\n");
+		grammarBuilder.append("KW2553 : 'KW' '2553';\n");
+		grammarBuilder.append("KW2554 : 'KW' '2554';\n");
+		grammarBuilder.append("KW2555 : 'KW' '2555';\n");
+		grammarBuilder.append("KW2556 : 'KW' '2556';\n");
+		grammarBuilder.append("KW2557 : 'KW' '2557';\n");
+		grammarBuilder.append("KW2558 : 'KW' '2558';\n");
+		grammarBuilder.append("KW2559 : 'KW' '2559';\n");
+		grammarBuilder.append("KW2560 : 'KW' '2560';\n");
+		grammarBuilder.append("KW2561 : 'KW' '2561';\n");
+		grammarBuilder.append("KW2562 : 'KW' '2562';\n");
+		grammarBuilder.append("KW2563 : 'KW' '2563';\n");
+		grammarBuilder.append("KW2564 : 'KW' '2564';\n");
+		grammarBuilder.append("KW2565 : 'KW' '2565';\n");
+		grammarBuilder.append("KW2566 : 'KW' '2566';\n");
+		grammarBuilder.append("KW2567 : 'KW' '2567';\n");
+		grammarBuilder.append("KW2568 : 'KW' '2568';\n");
+		grammarBuilder.append("KW2569 : 'KW' '2569';\n");
+		grammarBuilder.append("KW2570 : 'KW' '2570';\n");
+		grammarBuilder.append("KW2571 : 'KW' '2571';\n");
+		grammarBuilder.append("KW2572 : 'KW' '2572';\n");
+		grammarBuilder.append("KW2573 : 'KW' '2573';\n");
+		grammarBuilder.append("KW2574 : 'KW' '2574';\n");
+		grammarBuilder.append("KW2575 : 'KW' '2575';\n");
+		grammarBuilder.append("KW2576 : 'KW' '2576';\n");
+		grammarBuilder.append("KW2577 : 'KW' '2577';\n");
+		grammarBuilder.append("KW2578 : 'KW' '2578';\n");
+		grammarBuilder.append("KW2579 : 'KW' '2579';\n");
+		grammarBuilder.append("KW2580 : 'KW' '2580';\n");
+		grammarBuilder.append("KW2581 : 'KW' '2581';\n");
+		grammarBuilder.append("KW2582 : 'KW' '2582';\n");
+		grammarBuilder.append("KW2583 : 'KW' '2583';\n");
+		grammarBuilder.append("KW2584 : 'KW' '2584';\n");
+		grammarBuilder.append("KW2585 : 'KW' '2585';\n");
+		grammarBuilder.append("KW2586 : 'KW' '2586';\n");
+		grammarBuilder.append("KW2587 : 'KW' '2587';\n");
+		grammarBuilder.append("KW2588 : 'KW' '2588';\n");
+		grammarBuilder.append("KW2589 : 'KW' '2589';\n");
+		grammarBuilder.append("KW2590 : 'KW' '2590';\n");
+		grammarBuilder.append("KW2591 : 'KW' '2591';\n");
+		grammarBuilder.append("KW2592 : 'KW' '2592';\n");
+		grammarBuilder.append("KW2593 : 'KW' '2593';\n");
+		grammarBuilder.append("KW2594 : 'KW' '2594';\n");
+		grammarBuilder.append("KW2595 : 'KW' '2595';\n");
+		grammarBuilder.append("KW2596 : 'KW' '2596';\n");
+		grammarBuilder.append("KW2597 : 'KW' '2597';\n");
+		grammarBuilder.append("KW2598 : 'KW' '2598';\n");
+		grammarBuilder.append("KW2599 : 'KW' '2599';\n");
+		grammarBuilder.append("KW2600 : 'KW' '2600';\n");
+		grammarBuilder.append("KW2601 : 'KW' '2601';\n");
+		grammarBuilder.append("KW2602 : 'KW' '2602';\n");
+		grammarBuilder.append("KW2603 : 'KW' '2603';\n");
+		grammarBuilder.append("KW2604 : 'KW' '2604';\n");
+		grammarBuilder.append("KW2605 : 'KW' '2605';\n");
+		grammarBuilder.append("KW2606 : 'KW' '2606';\n");
+		grammarBuilder.append("KW2607 : 'KW' '2607';\n");
+		grammarBuilder.append("KW2608 : 'KW' '2608';\n");
+		grammarBuilder.append("KW2609 : 'KW' '2609';\n");
+		grammarBuilder.append("KW2610 : 'KW' '2610';\n");
+		grammarBuilder.append("KW2611 : 'KW' '2611';\n");
+		grammarBuilder.append("KW2612 : 'KW' '2612';\n");
+		grammarBuilder.append("KW2613 : 'KW' '2613';\n");
+		grammarBuilder.append("KW2614 : 'KW' '2614';\n");
+		grammarBuilder.append("KW2615 : 'KW' '2615';\n");
+		grammarBuilder.append("KW2616 : 'KW' '2616';\n");
+		grammarBuilder.append("KW2617 : 'KW' '2617';\n");
+		grammarBuilder.append("KW2618 : 'KW' '2618';\n");
+		grammarBuilder.append("KW2619 : 'KW' '2619';\n");
+		grammarBuilder.append("KW2620 : 'KW' '2620';\n");
+		grammarBuilder.append("KW2621 : 'KW' '2621';\n");
+		grammarBuilder.append("KW2622 : 'KW' '2622';\n");
+		grammarBuilder.append("KW2623 : 'KW' '2623';\n");
+		grammarBuilder.append("KW2624 : 'KW' '2624';\n");
+		grammarBuilder.append("KW2625 : 'KW' '2625';\n");
+		grammarBuilder.append("KW2626 : 'KW' '2626';\n");
+		grammarBuilder.append("KW2627 : 'KW' '2627';\n");
+		grammarBuilder.append("KW2628 : 'KW' '2628';\n");
+		grammarBuilder.append("KW2629 : 'KW' '2629';\n");
+		grammarBuilder.append("KW2630 : 'KW' '2630';\n");
+		grammarBuilder.append("KW2631 : 'KW' '2631';\n");
+		grammarBuilder.append("KW2632 : 'KW' '2632';\n");
+		grammarBuilder.append("KW2633 : 'KW' '2633';\n");
+		grammarBuilder.append("KW2634 : 'KW' '2634';\n");
+		grammarBuilder.append("KW2635 : 'KW' '2635';\n");
+		grammarBuilder.append("KW2636 : 'KW' '2636';\n");
+		grammarBuilder.append("KW2637 : 'KW' '2637';\n");
+		grammarBuilder.append("KW2638 : 'KW' '2638';\n");
+		grammarBuilder.append("KW2639 : 'KW' '2639';\n");
+		grammarBuilder.append("KW2640 : 'KW' '2640';\n");
+		grammarBuilder.append("KW2641 : 'KW' '2641';\n");
+		grammarBuilder.append("KW2642 : 'KW' '2642';\n");
+		grammarBuilder.append("KW2643 : 'KW' '2643';\n");
+		grammarBuilder.append("KW2644 : 'KW' '2644';\n");
+		grammarBuilder.append("KW2645 : 'KW' '2645';\n");
+		grammarBuilder.append("KW2646 : 'KW' '2646';\n");
+		grammarBuilder.append("KW2647 : 'KW' '2647';\n");
+		grammarBuilder.append("KW2648 : 'KW' '2648';\n");
+		grammarBuilder.append("KW2649 : 'KW' '2649';\n");
+		grammarBuilder.append("KW2650 : 'KW' '2650';\n");
+		grammarBuilder.append("KW2651 : 'KW' '2651';\n");
+		grammarBuilder.append("KW2652 : 'KW' '2652';\n");
+		grammarBuilder.append("KW2653 : 'KW' '2653';\n");
+		grammarBuilder.append("KW2654 : 'KW' '2654';\n");
+		grammarBuilder.append("KW2655 : 'KW' '2655';\n");
+		grammarBuilder.append("KW2656 : 'KW' '2656';\n");
+		grammarBuilder.append("KW2657 : 'KW' '2657';\n");
+		grammarBuilder.append("KW2658 : 'KW' '2658';\n");
+		grammarBuilder.append("KW2659 : 'KW' '2659';\n");
+		grammarBuilder.append("KW2660 : 'KW' '2660';\n");
+		grammarBuilder.append("KW2661 : 'KW' '2661';\n");
+		grammarBuilder.append("KW2662 : 'KW' '2662';\n");
+		grammarBuilder.append("KW2663 : 'KW' '2663';\n");
+		grammarBuilder.append("KW2664 : 'KW' '2664';\n");
+		grammarBuilder.append("KW2665 : 'KW' '2665';\n");
+		grammarBuilder.append("KW2666 : 'KW' '2666';\n");
+		grammarBuilder.append("KW2667 : 'KW' '2667';\n");
+		grammarBuilder.append("KW2668 : 'KW' '2668';\n");
+		grammarBuilder.append("KW2669 : 'KW' '2669';\n");
+		grammarBuilder.append("KW2670 : 'KW' '2670';\n");
+		grammarBuilder.append("KW2671 : 'KW' '2671';\n");
+		grammarBuilder.append("KW2672 : 'KW' '2672';\n");
+		grammarBuilder.append("KW2673 : 'KW' '2673';\n");
+		grammarBuilder.append("KW2674 : 'KW' '2674';\n");
+		grammarBuilder.append("KW2675 : 'KW' '2675';\n");
+		grammarBuilder.append("KW2676 : 'KW' '2676';\n");
+		grammarBuilder.append("KW2677 : 'KW' '2677';\n");
+		grammarBuilder.append("KW2678 : 'KW' '2678';\n");
+		grammarBuilder.append("KW2679 : 'KW' '2679';\n");
+		grammarBuilder.append("KW2680 : 'KW' '2680';\n");
+		grammarBuilder.append("KW2681 : 'KW' '2681';\n");
+		grammarBuilder.append("KW2682 : 'KW' '2682';\n");
+		grammarBuilder.append("KW2683 : 'KW' '2683';\n");
+		grammarBuilder.append("KW2684 : 'KW' '2684';\n");
+		grammarBuilder.append("KW2685 : 'KW' '2685';\n");
+		grammarBuilder.append("KW2686 : 'KW' '2686';\n");
+		grammarBuilder.append("KW2687 : 'KW' '2687';\n");
+		grammarBuilder.append("KW2688 : 'KW' '2688';\n");
+		grammarBuilder.append("KW2689 : 'KW' '2689';\n");
+		grammarBuilder.append("KW2690 : 'KW' '2690';\n");
+		grammarBuilder.append("KW2691 : 'KW' '2691';\n");
+		grammarBuilder.append("KW2692 : 'KW' '2692';\n");
+		grammarBuilder.append("KW2693 : 'KW' '2693';\n");
+		grammarBuilder.append("KW2694 : 'KW' '2694';\n");
+		grammarBuilder.append("KW2695 : 'KW' '2695';\n");
+		grammarBuilder.append("KW2696 : 'KW' '2696';\n");
+		grammarBuilder.append("KW2697 : 'KW' '2697';\n");
+		grammarBuilder.append("KW2698 : 'KW' '2698';\n");
+		grammarBuilder.append("KW2699 : 'KW' '2699';\n");
+		grammarBuilder.append("KW2700 : 'KW' '2700';\n");
+		grammarBuilder.append("KW2701 : 'KW' '2701';\n");
+		grammarBuilder.append("KW2702 : 'KW' '2702';\n");
+		grammarBuilder.append("KW2703 : 'KW' '2703';\n");
+		grammarBuilder.append("KW2704 : 'KW' '2704';\n");
+		grammarBuilder.append("KW2705 : 'KW' '2705';\n");
+		grammarBuilder.append("KW2706 : 'KW' '2706';\n");
+		grammarBuilder.append("KW2707 : 'KW' '2707';\n");
+		grammarBuilder.append("KW2708 : 'KW' '2708';\n");
+		grammarBuilder.append("KW2709 : 'KW' '2709';\n");
+		grammarBuilder.append("KW2710 : 'KW' '2710';\n");
+		grammarBuilder.append("KW2711 : 'KW' '2711';\n");
+		grammarBuilder.append("KW2712 : 'KW' '2712';\n");
+		grammarBuilder.append("KW2713 : 'KW' '2713';\n");
+		grammarBuilder.append("KW2714 : 'KW' '2714';\n");
+		grammarBuilder.append("KW2715 : 'KW' '2715';\n");
+		grammarBuilder.append("KW2716 : 'KW' '2716';\n");
+		grammarBuilder.append("KW2717 : 'KW' '2717';\n");
+		grammarBuilder.append("KW2718 : 'KW' '2718';\n");
+		grammarBuilder.append("KW2719 : 'KW' '2719';\n");
+		grammarBuilder.append("KW2720 : 'KW' '2720';\n");
+		grammarBuilder.append("KW2721 : 'KW' '2721';\n");
+		grammarBuilder.append("KW2722 : 'KW' '2722';\n");
+		grammarBuilder.append("KW2723 : 'KW' '2723';\n");
+		grammarBuilder.append("KW2724 : 'KW' '2724';\n");
+		grammarBuilder.append("KW2725 : 'KW' '2725';\n");
+		grammarBuilder.append("KW2726 : 'KW' '2726';\n");
+		grammarBuilder.append("KW2727 : 'KW' '2727';\n");
+		grammarBuilder.append("KW2728 : 'KW' '2728';\n");
+		grammarBuilder.append("KW2729 : 'KW' '2729';\n");
+		grammarBuilder.append("KW2730 : 'KW' '2730';\n");
+		grammarBuilder.append("KW2731 : 'KW' '2731';\n");
+		grammarBuilder.append("KW2732 : 'KW' '2732';\n");
+		grammarBuilder.append("KW2733 : 'KW' '2733';\n");
+		grammarBuilder.append("KW2734 : 'KW' '2734';\n");
+		grammarBuilder.append("KW2735 : 'KW' '2735';\n");
+		grammarBuilder.append("KW2736 : 'KW' '2736';\n");
+		grammarBuilder.append("KW2737 : 'KW' '2737';\n");
+		grammarBuilder.append("KW2738 : 'KW' '2738';\n");
+		grammarBuilder.append("KW2739 : 'KW' '2739';\n");
+		grammarBuilder.append("KW2740 : 'KW' '2740';\n");
+		grammarBuilder.append("KW2741 : 'KW' '2741';\n");
+		grammarBuilder.append("KW2742 : 'KW' '2742';\n");
+		grammarBuilder.append("KW2743 : 'KW' '2743';\n");
+		grammarBuilder.append("KW2744 : 'KW' '2744';\n");
+		grammarBuilder.append("KW2745 : 'KW' '2745';\n");
+		grammarBuilder.append("KW2746 : 'KW' '2746';\n");
+		grammarBuilder.append("KW2747 : 'KW' '2747';\n");
+		grammarBuilder.append("KW2748 : 'KW' '2748';\n");
+		grammarBuilder.append("KW2749 : 'KW' '2749';\n");
+		grammarBuilder.append("KW2750 : 'KW' '2750';\n");
+		grammarBuilder.append("KW2751 : 'KW' '2751';\n");
+		grammarBuilder.append("KW2752 : 'KW' '2752';\n");
+		grammarBuilder.append("KW2753 : 'KW' '2753';\n");
+		grammarBuilder.append("KW2754 : 'KW' '2754';\n");
+		grammarBuilder.append("KW2755 : 'KW' '2755';\n");
+		grammarBuilder.append("KW2756 : 'KW' '2756';\n");
+		grammarBuilder.append("KW2757 : 'KW' '2757';\n");
+		grammarBuilder.append("KW2758 : 'KW' '2758';\n");
+		grammarBuilder.append("KW2759 : 'KW' '2759';\n");
+		grammarBuilder.append("KW2760 : 'KW' '2760';\n");
+		grammarBuilder.append("KW2761 : 'KW' '2761';\n");
+		grammarBuilder.append("KW2762 : 'KW' '2762';\n");
+		grammarBuilder.append("KW2763 : 'KW' '2763';\n");
+		grammarBuilder.append("KW2764 : 'KW' '2764';\n");
+		grammarBuilder.append("KW2765 : 'KW' '2765';\n");
+		grammarBuilder.append("KW2766 : 'KW' '2766';\n");
+		grammarBuilder.append("KW2767 : 'KW' '2767';\n");
+		grammarBuilder.append("KW2768 : 'KW' '2768';\n");
+		grammarBuilder.append("KW2769 : 'KW' '2769';\n");
+		grammarBuilder.append("KW2770 : 'KW' '2770';\n");
+		grammarBuilder.append("KW2771 : 'KW' '2771';\n");
+		grammarBuilder.append("KW2772 : 'KW' '2772';\n");
+		grammarBuilder.append("KW2773 : 'KW' '2773';\n");
+		grammarBuilder.append("KW2774 : 'KW' '2774';\n");
+		grammarBuilder.append("KW2775 : 'KW' '2775';\n");
+		grammarBuilder.append("KW2776 : 'KW' '2776';\n");
+		grammarBuilder.append("KW2777 : 'KW' '2777';\n");
+		grammarBuilder.append("KW2778 : 'KW' '2778';\n");
+		grammarBuilder.append("KW2779 : 'KW' '2779';\n");
+		grammarBuilder.append("KW2780 : 'KW' '2780';\n");
+		grammarBuilder.append("KW2781 : 'KW' '2781';\n");
+		grammarBuilder.append("KW2782 : 'KW' '2782';\n");
+		grammarBuilder.append("KW2783 : 'KW' '2783';\n");
+		grammarBuilder.append("KW2784 : 'KW' '2784';\n");
+		grammarBuilder.append("KW2785 : 'KW' '2785';\n");
+		grammarBuilder.append("KW2786 : 'KW' '2786';\n");
+		grammarBuilder.append("KW2787 : 'KW' '2787';\n");
+		grammarBuilder.append("KW2788 : 'KW' '2788';\n");
+		grammarBuilder.append("KW2789 : 'KW' '2789';\n");
+		grammarBuilder.append("KW2790 : 'KW' '2790';\n");
+		grammarBuilder.append("KW2791 : 'KW' '2791';\n");
+		grammarBuilder.append("KW2792 : 'KW' '2792';\n");
+		grammarBuilder.append("KW2793 : 'KW' '2793';\n");
+		grammarBuilder.append("KW2794 : 'KW' '2794';\n");
+		grammarBuilder.append("KW2795 : 'KW' '2795';\n");
+		grammarBuilder.append("KW2796 : 'KW' '2796';\n");
+		grammarBuilder.append("KW2797 : 'KW' '2797';\n");
+		grammarBuilder.append("KW2798 : 'KW' '2798';\n");
+		grammarBuilder.append("KW2799 : 'KW' '2799';\n");
+		grammarBuilder.append("KW2800 : 'KW' '2800';\n");
+		grammarBuilder.append("KW2801 : 'KW' '2801';\n");
+		grammarBuilder.append("KW2802 : 'KW' '2802';\n");
+		grammarBuilder.append("KW2803 : 'KW' '2803';\n");
+		grammarBuilder.append("KW2804 : 'KW' '2804';\n");
+		grammarBuilder.append("KW2805 : 'KW' '2805';\n");
+		grammarBuilder.append("KW2806 : 'KW' '2806';\n");
+		grammarBuilder.append("KW2807 : 'KW' '2807';\n");
+		grammarBuilder.append("KW2808 : 'KW' '2808';\n");
+		grammarBuilder.append("KW2809 : 'KW' '2809';\n");
+		grammarBuilder.append("KW2810 : 'KW' '2810';\n");
+		grammarBuilder.append("KW2811 : 'KW' '2811';\n");
+		grammarBuilder.append("KW2812 : 'KW' '2812';\n");
+		grammarBuilder.append("KW2813 : 'KW' '2813';\n");
+		grammarBuilder.append("KW2814 : 'KW' '2814';\n");
+		grammarBuilder.append("KW2815 : 'KW' '2815';\n");
+		grammarBuilder.append("KW2816 : 'KW' '2816';\n");
+		grammarBuilder.append("KW2817 : 'KW' '2817';\n");
+		grammarBuilder.append("KW2818 : 'KW' '2818';\n");
+		grammarBuilder.append("KW2819 : 'KW' '2819';\n");
+		grammarBuilder.append("KW2820 : 'KW' '2820';\n");
+		grammarBuilder.append("KW2821 : 'KW' '2821';\n");
+		grammarBuilder.append("KW2822 : 'KW' '2822';\n");
+		grammarBuilder.append("KW2823 : 'KW' '2823';\n");
+		grammarBuilder.append("KW2824 : 'KW' '2824';\n");
+		grammarBuilder.append("KW2825 : 'KW' '2825';\n");
+		grammarBuilder.append("KW2826 : 'KW' '2826';\n");
+		grammarBuilder.append("KW2827 : 'KW' '2827';\n");
+		grammarBuilder.append("KW2828 : 'KW' '2828';\n");
+		grammarBuilder.append("KW2829 : 'KW' '2829';\n");
+		grammarBuilder.append("KW2830 : 'KW' '2830';\n");
+		grammarBuilder.append("KW2831 : 'KW' '2831';\n");
+		grammarBuilder.append("KW2832 : 'KW' '2832';\n");
+		grammarBuilder.append("KW2833 : 'KW' '2833';\n");
+		grammarBuilder.append("KW2834 : 'KW' '2834';\n");
+		grammarBuilder.append("KW2835 : 'KW' '2835';\n");
+		grammarBuilder.append("KW2836 : 'KW' '2836';\n");
+		grammarBuilder.append("KW2837 : 'KW' '2837';\n");
+		grammarBuilder.append("KW2838 : 'KW' '2838';\n");
+		grammarBuilder.append("KW2839 : 'KW' '2839';\n");
+		grammarBuilder.append("KW2840 : 'KW' '2840';\n");
+		grammarBuilder.append("KW2841 : 'KW' '2841';\n");
+		grammarBuilder.append("KW2842 : 'KW' '2842';\n");
+		grammarBuilder.append("KW2843 : 'KW' '2843';\n");
+		grammarBuilder.append("KW2844 : 'KW' '2844';\n");
+		grammarBuilder.append("KW2845 : 'KW' '2845';\n");
+		grammarBuilder.append("KW2846 : 'KW' '2846';\n");
+		grammarBuilder.append("KW2847 : 'KW' '2847';\n");
+		grammarBuilder.append("KW2848 : 'KW' '2848';\n");
+		grammarBuilder.append("KW2849 : 'KW' '2849';\n");
+		grammarBuilder.append("KW2850 : 'KW' '2850';\n");
+		grammarBuilder.append("KW2851 : 'KW' '2851';\n");
+		grammarBuilder.append("KW2852 : 'KW' '2852';\n");
+		grammarBuilder.append("KW2853 : 'KW' '2853';\n");
+		grammarBuilder.append("KW2854 : 'KW' '2854';\n");
+		grammarBuilder.append("KW2855 : 'KW' '2855';\n");
+		grammarBuilder.append("KW2856 : 'KW' '2856';\n");
+		grammarBuilder.append("KW2857 : 'KW' '2857';\n");
+		grammarBuilder.append("KW2858 : 'KW' '2858';\n");
+		grammarBuilder.append("KW2859 : 'KW' '2859';\n");
+		grammarBuilder.append("KW2860 : 'KW' '2860';\n");
+		grammarBuilder.append("KW2861 : 'KW' '2861';\n");
+		grammarBuilder.append("KW2862 : 'KW' '2862';\n");
+		grammarBuilder.append("KW2863 : 'KW' '2863';\n");
+		grammarBuilder.append("KW2864 : 'KW' '2864';\n");
+		grammarBuilder.append("KW2865 : 'KW' '2865';\n");
+		grammarBuilder.append("KW2866 : 'KW' '2866';\n");
+		grammarBuilder.append("KW2867 : 'KW' '2867';\n");
+		grammarBuilder.append("KW2868 : 'KW' '2868';\n");
+		grammarBuilder.append("KW2869 : 'KW' '2869';\n");
+		grammarBuilder.append("KW2870 : 'KW' '2870';\n");
+		grammarBuilder.append("KW2871 : 'KW' '2871';\n");
+		grammarBuilder.append("KW2872 : 'KW' '2872';\n");
+		grammarBuilder.append("KW2873 : 'KW' '2873';\n");
+		grammarBuilder.append("KW2874 : 'KW' '2874';\n");
+		grammarBuilder.append("KW2875 : 'KW' '2875';\n");
+		grammarBuilder.append("KW2876 : 'KW' '2876';\n");
+		grammarBuilder.append("KW2877 : 'KW' '2877';\n");
+		grammarBuilder.append("KW2878 : 'KW' '2878';\n");
+		grammarBuilder.append("KW2879 : 'KW' '2879';\n");
+		grammarBuilder.append("KW2880 : 'KW' '2880';\n");
+		grammarBuilder.append("KW2881 : 'KW' '2881';\n");
+		grammarBuilder.append("KW2882 : 'KW' '2882';\n");
+		grammarBuilder.append("KW2883 : 'KW' '2883';\n");
+		grammarBuilder.append("KW2884 : 'KW' '2884';\n");
+		grammarBuilder.append("KW2885 : 'KW' '2885';\n");
+		grammarBuilder.append("KW2886 : 'KW' '2886';\n");
+		grammarBuilder.append("KW2887 : 'KW' '2887';\n");
+		grammarBuilder.append("KW2888 : 'KW' '2888';\n");
+		grammarBuilder.append("KW2889 : 'KW' '2889';\n");
+		grammarBuilder.append("KW2890 : 'KW' '2890';\n");
+		grammarBuilder.append("KW2891 : 'KW' '2891';\n");
+		grammarBuilder.append("KW2892 : 'KW' '2892';\n");
+		grammarBuilder.append("KW2893 : 'KW' '2893';\n");
+		grammarBuilder.append("KW2894 : 'KW' '2894';\n");
+		grammarBuilder.append("KW2895 : 'KW' '2895';\n");
+		grammarBuilder.append("KW2896 : 'KW' '2896';\n");
+		grammarBuilder.append("KW2897 : 'KW' '2897';\n");
+		grammarBuilder.append("KW2898 : 'KW' '2898';\n");
+		grammarBuilder.append("KW2899 : 'KW' '2899';\n");
+		grammarBuilder.append("KW2900 : 'KW' '2900';\n");
+		grammarBuilder.append("KW2901 : 'KW' '2901';\n");
+		grammarBuilder.append("KW2902 : 'KW' '2902';\n");
+		grammarBuilder.append("KW2903 : 'KW' '2903';\n");
+		grammarBuilder.append("KW2904 : 'KW' '2904';\n");
+		grammarBuilder.append("KW2905 : 'KW' '2905';\n");
+		grammarBuilder.append("KW2906 : 'KW' '2906';\n");
+		grammarBuilder.append("KW2907 : 'KW' '2907';\n");
+		grammarBuilder.append("KW2908 : 'KW' '2908';\n");
+		grammarBuilder.append("KW2909 : 'KW' '2909';\n");
+		grammarBuilder.append("KW2910 : 'KW' '2910';\n");
+		grammarBuilder.append("KW2911 : 'KW' '2911';\n");
+		grammarBuilder.append("KW2912 : 'KW' '2912';\n");
+		grammarBuilder.append("KW2913 : 'KW' '2913';\n");
+		grammarBuilder.append("KW2914 : 'KW' '2914';\n");
+		grammarBuilder.append("KW2915 : 'KW' '2915';\n");
+		grammarBuilder.append("KW2916 : 'KW' '2916';\n");
+		grammarBuilder.append("KW2917 : 'KW' '2917';\n");
+		grammarBuilder.append("KW2918 : 'KW' '2918';\n");
+		grammarBuilder.append("KW2919 : 'KW' '2919';\n");
+		grammarBuilder.append("KW2920 : 'KW' '2920';\n");
+		grammarBuilder.append("KW2921 : 'KW' '2921';\n");
+		grammarBuilder.append("KW2922 : 'KW' '2922';\n");
+		grammarBuilder.append("KW2923 : 'KW' '2923';\n");
+		grammarBuilder.append("KW2924 : 'KW' '2924';\n");
+		grammarBuilder.append("KW2925 : 'KW' '2925';\n");
+		grammarBuilder.append("KW2926 : 'KW' '2926';\n");
+		grammarBuilder.append("KW2927 : 'KW' '2927';\n");
+		grammarBuilder.append("KW2928 : 'KW' '2928';\n");
+		grammarBuilder.append("KW2929 : 'KW' '2929';\n");
+		grammarBuilder.append("KW2930 : 'KW' '2930';\n");
+		grammarBuilder.append("KW2931 : 'KW' '2931';\n");
+		grammarBuilder.append("KW2932 : 'KW' '2932';\n");
+		grammarBuilder.append("KW2933 : 'KW' '2933';\n");
+		grammarBuilder.append("KW2934 : 'KW' '2934';\n");
+		grammarBuilder.append("KW2935 : 'KW' '2935';\n");
+		grammarBuilder.append("KW2936 : 'KW' '2936';\n");
+		grammarBuilder.append("KW2937 : 'KW' '2937';\n");
+		grammarBuilder.append("KW2938 : 'KW' '2938';\n");
+		grammarBuilder.append("KW2939 : 'KW' '2939';\n");
+		grammarBuilder.append("KW2940 : 'KW' '2940';\n");
+		grammarBuilder.append("KW2941 : 'KW' '2941';\n");
+		grammarBuilder.append("KW2942 : 'KW' '2942';\n");
+		grammarBuilder.append("KW2943 : 'KW' '2943';\n");
+		grammarBuilder.append("KW2944 : 'KW' '2944';\n");
+		grammarBuilder.append("KW2945 : 'KW' '2945';\n");
+		grammarBuilder.append("KW2946 : 'KW' '2946';\n");
+		grammarBuilder.append("KW2947 : 'KW' '2947';\n");
+		grammarBuilder.append("KW2948 : 'KW' '2948';\n");
+		grammarBuilder.append("KW2949 : 'KW' '2949';\n");
+		grammarBuilder.append("KW2950 : 'KW' '2950';\n");
+		grammarBuilder.append("KW2951 : 'KW' '2951';\n");
+		grammarBuilder.append("KW2952 : 'KW' '2952';\n");
+		grammarBuilder.append("KW2953 : 'KW' '2953';\n");
+		grammarBuilder.append("KW2954 : 'KW' '2954';\n");
+		grammarBuilder.append("KW2955 : 'KW' '2955';\n");
+		grammarBuilder.append("KW2956 : 'KW' '2956';\n");
+		grammarBuilder.append("KW2957 : 'KW' '2957';\n");
+		grammarBuilder.append("KW2958 : 'KW' '2958';\n");
+		grammarBuilder.append("KW2959 : 'KW' '2959';\n");
+		grammarBuilder.append("KW2960 : 'KW' '2960';\n");
+		grammarBuilder.append("KW2961 : 'KW' '2961';\n");
+		grammarBuilder.append("KW2962 : 'KW' '2962';\n");
+		grammarBuilder.append("KW2963 : 'KW' '2963';\n");
+		grammarBuilder.append("KW2964 : 'KW' '2964';\n");
+		grammarBuilder.append("KW2965 : 'KW' '2965';\n");
+		grammarBuilder.append("KW2966 : 'KW' '2966';\n");
+		grammarBuilder.append("KW2967 : 'KW' '2967';\n");
+		grammarBuilder.append("KW2968 : 'KW' '2968';\n");
+		grammarBuilder.append("KW2969 : 'KW' '2969';\n");
+		grammarBuilder.append("KW2970 : 'KW' '2970';\n");
+		grammarBuilder.append("KW2971 : 'KW' '2971';\n");
+		grammarBuilder.append("KW2972 : 'KW' '2972';\n");
+		grammarBuilder.append("KW2973 : 'KW' '2973';\n");
+		grammarBuilder.append("KW2974 : 'KW' '2974';\n");
+		grammarBuilder.append("KW2975 : 'KW' '2975';\n");
+		grammarBuilder.append("KW2976 : 'KW' '2976';\n");
+		grammarBuilder.append("KW2977 : 'KW' '2977';\n");
+		grammarBuilder.append("KW2978 : 'KW' '2978';\n");
+		grammarBuilder.append("KW2979 : 'KW' '2979';\n");
+		grammarBuilder.append("KW2980 : 'KW' '2980';\n");
+		grammarBuilder.append("KW2981 : 'KW' '2981';\n");
+		grammarBuilder.append("KW2982 : 'KW' '2982';\n");
+		grammarBuilder.append("KW2983 : 'KW' '2983';\n");
+		grammarBuilder.append("KW2984 : 'KW' '2984';\n");
+		grammarBuilder.append("KW2985 : 'KW' '2985';\n");
+		grammarBuilder.append("KW2986 : 'KW' '2986';\n");
+		grammarBuilder.append("KW2987 : 'KW' '2987';\n");
+		grammarBuilder.append("KW2988 : 'KW' '2988';\n");
+		grammarBuilder.append("KW2989 : 'KW' '2989';\n");
+		grammarBuilder.append("KW2990 : 'KW' '2990';\n");
+		grammarBuilder.append("KW2991 : 'KW' '2991';\n");
+		grammarBuilder.append("KW2992 : 'KW' '2992';\n");
+		grammarBuilder.append("KW2993 : 'KW' '2993';\n");
+		grammarBuilder.append("KW2994 : 'KW' '2994';\n");
+		grammarBuilder.append("KW2995 : 'KW' '2995';\n");
+		grammarBuilder.append("KW2996 : 'KW' '2996';\n");
+		grammarBuilder.append("KW2997 : 'KW' '2997';\n");
+		grammarBuilder.append("KW2998 : 'KW' '2998';\n");
+		grammarBuilder.append("KW2999 : 'KW' '2999';\n");
+		grammarBuilder.append("KW3000 : 'KW' '3000';\n");
+		grammarBuilder.append("KW3001 : 'KW' '3001';\n");
+		grammarBuilder.append("KW3002 : 'KW' '3002';\n");
+		grammarBuilder.append("KW3003 : 'KW' '3003';\n");
+		grammarBuilder.append("KW3004 : 'KW' '3004';\n");
+		grammarBuilder.append("KW3005 : 'KW' '3005';\n");
+		grammarBuilder.append("KW3006 : 'KW' '3006';\n");
+		grammarBuilder.append("KW3007 : 'KW' '3007';\n");
+		grammarBuilder.append("KW3008 : 'KW' '3008';\n");
+		grammarBuilder.append("KW3009 : 'KW' '3009';\n");
+		grammarBuilder.append("KW3010 : 'KW' '3010';\n");
+		grammarBuilder.append("KW3011 : 'KW' '3011';\n");
+		grammarBuilder.append("KW3012 : 'KW' '3012';\n");
+		grammarBuilder.append("KW3013 : 'KW' '3013';\n");
+		grammarBuilder.append("KW3014 : 'KW' '3014';\n");
+		grammarBuilder.append("KW3015 : 'KW' '3015';\n");
+		grammarBuilder.append("KW3016 : 'KW' '3016';\n");
+		grammarBuilder.append("KW3017 : 'KW' '3017';\n");
+		grammarBuilder.append("KW3018 : 'KW' '3018';\n");
+		grammarBuilder.append("KW3019 : 'KW' '3019';\n");
+		grammarBuilder.append("KW3020 : 'KW' '3020';\n");
+		grammarBuilder.append("KW3021 : 'KW' '3021';\n");
+		grammarBuilder.append("KW3022 : 'KW' '3022';\n");
+		grammarBuilder.append("KW3023 : 'KW' '3023';\n");
+		grammarBuilder.append("KW3024 : 'KW' '3024';\n");
+		grammarBuilder.append("KW3025 : 'KW' '3025';\n");
+		grammarBuilder.append("KW3026 : 'KW' '3026';\n");
+		grammarBuilder.append("KW3027 : 'KW' '3027';\n");
+		grammarBuilder.append("KW3028 : 'KW' '3028';\n");
+		grammarBuilder.append("KW3029 : 'KW' '3029';\n");
+		grammarBuilder.append("KW3030 : 'KW' '3030';\n");
+		grammarBuilder.append("KW3031 : 'KW' '3031';\n");
+		grammarBuilder.append("KW3032 : 'KW' '3032';\n");
+		grammarBuilder.append("KW3033 : 'KW' '3033';\n");
+		grammarBuilder.append("KW3034 : 'KW' '3034';\n");
+		grammarBuilder.append("KW3035 : 'KW' '3035';\n");
+		grammarBuilder.append("KW3036 : 'KW' '3036';\n");
+		grammarBuilder.append("KW3037 : 'KW' '3037';\n");
+		grammarBuilder.append("KW3038 : 'KW' '3038';\n");
+		grammarBuilder.append("KW3039 : 'KW' '3039';\n");
+		grammarBuilder.append("KW3040 : 'KW' '3040';\n");
+		grammarBuilder.append("KW3041 : 'KW' '3041';\n");
+		grammarBuilder.append("KW3042 : 'KW' '3042';\n");
+		grammarBuilder.append("KW3043 : 'KW' '3043';\n");
+		grammarBuilder.append("KW3044 : 'KW' '3044';\n");
+		grammarBuilder.append("KW3045 : 'KW' '3045';\n");
+		grammarBuilder.append("KW3046 : 'KW' '3046';\n");
+		grammarBuilder.append("KW3047 : 'KW' '3047';\n");
+		grammarBuilder.append("KW3048 : 'KW' '3048';\n");
+		grammarBuilder.append("KW3049 : 'KW' '3049';\n");
+		grammarBuilder.append("KW3050 : 'KW' '3050';\n");
+		grammarBuilder.append("KW3051 : 'KW' '3051';\n");
+		grammarBuilder.append("KW3052 : 'KW' '3052';\n");
+		grammarBuilder.append("KW3053 : 'KW' '3053';\n");
+		grammarBuilder.append("KW3054 : 'KW' '3054';\n");
+		grammarBuilder.append("KW3055 : 'KW' '3055';\n");
+		grammarBuilder.append("KW3056 : 'KW' '3056';\n");
+		grammarBuilder.append("KW3057 : 'KW' '3057';\n");
+		grammarBuilder.append("KW3058 : 'KW' '3058';\n");
+		grammarBuilder.append("KW3059 : 'KW' '3059';\n");
+		grammarBuilder.append("KW3060 : 'KW' '3060';\n");
+		grammarBuilder.append("KW3061 : 'KW' '3061';\n");
+		grammarBuilder.append("KW3062 : 'KW' '3062';\n");
+		grammarBuilder.append("KW3063 : 'KW' '3063';\n");
+		grammarBuilder.append("KW3064 : 'KW' '3064';\n");
+		grammarBuilder.append("KW3065 : 'KW' '3065';\n");
+		grammarBuilder.append("KW3066 : 'KW' '3066';\n");
+		grammarBuilder.append("KW3067 : 'KW' '3067';\n");
+		grammarBuilder.append("KW3068 : 'KW' '3068';\n");
+		grammarBuilder.append("KW3069 : 'KW' '3069';\n");
+		grammarBuilder.append("KW3070 : 'KW' '3070';\n");
+		grammarBuilder.append("KW3071 : 'KW' '3071';\n");
+		grammarBuilder.append("KW3072 : 'KW' '3072';\n");
+		grammarBuilder.append("KW3073 : 'KW' '3073';\n");
+		grammarBuilder.append("KW3074 : 'KW' '3074';\n");
+		grammarBuilder.append("KW3075 : 'KW' '3075';\n");
+		grammarBuilder.append("KW3076 : 'KW' '3076';\n");
+		grammarBuilder.append("KW3077 : 'KW' '3077';\n");
+		grammarBuilder.append("KW3078 : 'KW' '3078';\n");
+		grammarBuilder.append("KW3079 : 'KW' '3079';\n");
+		grammarBuilder.append("KW3080 : 'KW' '3080';\n");
+		grammarBuilder.append("KW3081 : 'KW' '3081';\n");
+		grammarBuilder.append("KW3082 : 'KW' '3082';\n");
+		grammarBuilder.append("KW3083 : 'KW' '3083';\n");
+		grammarBuilder.append("KW3084 : 'KW' '3084';\n");
+		grammarBuilder.append("KW3085 : 'KW' '3085';\n");
+		grammarBuilder.append("KW3086 : 'KW' '3086';\n");
+		grammarBuilder.append("KW3087 : 'KW' '3087';\n");
+		grammarBuilder.append("KW3088 : 'KW' '3088';\n");
+		grammarBuilder.append("KW3089 : 'KW' '3089';\n");
+		grammarBuilder.append("KW3090 : 'KW' '3090';\n");
+		grammarBuilder.append("KW3091 : 'KW' '3091';\n");
+		grammarBuilder.append("KW3092 : 'KW' '3092';\n");
+		grammarBuilder.append("KW3093 : 'KW' '3093';\n");
+		grammarBuilder.append("KW3094 : 'KW' '3094';\n");
+		grammarBuilder.append("KW3095 : 'KW' '3095';\n");
+		grammarBuilder.append("KW3096 : 'KW' '3096';\n");
+		grammarBuilder.append("KW3097 : 'KW' '3097';\n");
+		grammarBuilder.append("KW3098 : 'KW' '3098';\n");
+		grammarBuilder.append("KW3099 : 'KW' '3099';\n");
+		grammarBuilder.append("KW3100 : 'KW' '3100';\n");
+		grammarBuilder.append("KW3101 : 'KW' '3101';\n");
+		grammarBuilder.append("KW3102 : 'KW' '3102';\n");
+		grammarBuilder.append("KW3103 : 'KW' '3103';\n");
+		grammarBuilder.append("KW3104 : 'KW' '3104';\n");
+		grammarBuilder.append("KW3105 : 'KW' '3105';\n");
+		grammarBuilder.append("KW3106 : 'KW' '3106';\n");
+		grammarBuilder.append("KW3107 : 'KW' '3107';\n");
+		grammarBuilder.append("KW3108 : 'KW' '3108';\n");
+		grammarBuilder.append("KW3109 : 'KW' '3109';\n");
+		grammarBuilder.append("KW3110 : 'KW' '3110';\n");
+		grammarBuilder.append("KW3111 : 'KW' '3111';\n");
+		grammarBuilder.append("KW3112 : 'KW' '3112';\n");
+		grammarBuilder.append("KW3113 : 'KW' '3113';\n");
+		grammarBuilder.append("KW3114 : 'KW' '3114';\n");
+		grammarBuilder.append("KW3115 : 'KW' '3115';\n");
+		grammarBuilder.append("KW3116 : 'KW' '3116';\n");
+		grammarBuilder.append("KW3117 : 'KW' '3117';\n");
+		grammarBuilder.append("KW3118 : 'KW' '3118';\n");
+		grammarBuilder.append("KW3119 : 'KW' '3119';\n");
+		grammarBuilder.append("KW3120 : 'KW' '3120';\n");
+		grammarBuilder.append("KW3121 : 'KW' '3121';\n");
+		grammarBuilder.append("KW3122 : 'KW' '3122';\n");
+		grammarBuilder.append("KW3123 : 'KW' '3123';\n");
+		grammarBuilder.append("KW3124 : 'KW' '3124';\n");
+		grammarBuilder.append("KW3125 : 'KW' '3125';\n");
+		grammarBuilder.append("KW3126 : 'KW' '3126';\n");
+		grammarBuilder.append("KW3127 : 'KW' '3127';\n");
+		grammarBuilder.append("KW3128 : 'KW' '3128';\n");
+		grammarBuilder.append("KW3129 : 'KW' '3129';\n");
+		grammarBuilder.append("KW3130 : 'KW' '3130';\n");
+		grammarBuilder.append("KW3131 : 'KW' '3131';\n");
+		grammarBuilder.append("KW3132 : 'KW' '3132';\n");
+		grammarBuilder.append("KW3133 : 'KW' '3133';\n");
+		grammarBuilder.append("KW3134 : 'KW' '3134';\n");
+		grammarBuilder.append("KW3135 : 'KW' '3135';\n");
+		grammarBuilder.append("KW3136 : 'KW' '3136';\n");
+		grammarBuilder.append("KW3137 : 'KW' '3137';\n");
+		grammarBuilder.append("KW3138 : 'KW' '3138';\n");
+		grammarBuilder.append("KW3139 : 'KW' '3139';\n");
+		grammarBuilder.append("KW3140 : 'KW' '3140';\n");
+		grammarBuilder.append("KW3141 : 'KW' '3141';\n");
+		grammarBuilder.append("KW3142 : 'KW' '3142';\n");
+		grammarBuilder.append("KW3143 : 'KW' '3143';\n");
+		grammarBuilder.append("KW3144 : 'KW' '3144';\n");
+		grammarBuilder.append("KW3145 : 'KW' '3145';\n");
+		grammarBuilder.append("KW3146 : 'KW' '3146';\n");
+		grammarBuilder.append("KW3147 : 'KW' '3147';\n");
+		grammarBuilder.append("KW3148 : 'KW' '3148';\n");
+		grammarBuilder.append("KW3149 : 'KW' '3149';\n");
+		grammarBuilder.append("KW3150 : 'KW' '3150';\n");
+		grammarBuilder.append("KW3151 : 'KW' '3151';\n");
+		grammarBuilder.append("KW3152 : 'KW' '3152';\n");
+		grammarBuilder.append("KW3153 : 'KW' '3153';\n");
+		grammarBuilder.append("KW3154 : 'KW' '3154';\n");
+		grammarBuilder.append("KW3155 : 'KW' '3155';\n");
+		grammarBuilder.append("KW3156 : 'KW' '3156';\n");
+		grammarBuilder.append("KW3157 : 'KW' '3157';\n");
+		grammarBuilder.append("KW3158 : 'KW' '3158';\n");
+		grammarBuilder.append("KW3159 : 'KW' '3159';\n");
+		grammarBuilder.append("KW3160 : 'KW' '3160';\n");
+		grammarBuilder.append("KW3161 : 'KW' '3161';\n");
+		grammarBuilder.append("KW3162 : 'KW' '3162';\n");
+		grammarBuilder.append("KW3163 : 'KW' '3163';\n");
+		grammarBuilder.append("KW3164 : 'KW' '3164';\n");
+		grammarBuilder.append("KW3165 : 'KW' '3165';\n");
+		grammarBuilder.append("KW3166 : 'KW' '3166';\n");
+		grammarBuilder.append("KW3167 : 'KW' '3167';\n");
+		grammarBuilder.append("KW3168 : 'KW' '3168';\n");
+		grammarBuilder.append("KW3169 : 'KW' '3169';\n");
+		grammarBuilder.append("KW3170 : 'KW' '3170';\n");
+		grammarBuilder.append("KW3171 : 'KW' '3171';\n");
+		grammarBuilder.append("KW3172 : 'KW' '3172';\n");
+		grammarBuilder.append("KW3173 : 'KW' '3173';\n");
+		grammarBuilder.append("KW3174 : 'KW' '3174';\n");
+		grammarBuilder.append("KW3175 : 'KW' '3175';\n");
+		grammarBuilder.append("KW3176 : 'KW' '3176';\n");
+		grammarBuilder.append("KW3177 : 'KW' '3177';\n");
+		grammarBuilder.append("KW3178 : 'KW' '3178';\n");
+		grammarBuilder.append("KW3179 : 'KW' '3179';\n");
+		grammarBuilder.append("KW3180 : 'KW' '3180';\n");
+		grammarBuilder.append("KW3181 : 'KW' '3181';\n");
+		grammarBuilder.append("KW3182 : 'KW' '3182';\n");
+		grammarBuilder.append("KW3183 : 'KW' '3183';\n");
+		grammarBuilder.append("KW3184 : 'KW' '3184';\n");
+		grammarBuilder.append("KW3185 : 'KW' '3185';\n");
+		grammarBuilder.append("KW3186 : 'KW' '3186';\n");
+		grammarBuilder.append("KW3187 : 'KW' '3187';\n");
+		grammarBuilder.append("KW3188 : 'KW' '3188';\n");
+		grammarBuilder.append("KW3189 : 'KW' '3189';\n");
+		grammarBuilder.append("KW3190 : 'KW' '3190';\n");
+		grammarBuilder.append("KW3191 : 'KW' '3191';\n");
+		grammarBuilder.append("KW3192 : 'KW' '3192';\n");
+		grammarBuilder.append("KW3193 : 'KW' '3193';\n");
+		grammarBuilder.append("KW3194 : 'KW' '3194';\n");
+		grammarBuilder.append("KW3195 : 'KW' '3195';\n");
+		grammarBuilder.append("KW3196 : 'KW' '3196';\n");
+		grammarBuilder.append("KW3197 : 'KW' '3197';\n");
+		grammarBuilder.append("KW3198 : 'KW' '3198';\n");
+		grammarBuilder.append("KW3199 : 'KW' '3199';\n");
+		grammarBuilder.append("KW3200 : 'KW' '3200';\n");
+		grammarBuilder.append("KW3201 : 'KW' '3201';\n");
+		grammarBuilder.append("KW3202 : 'KW' '3202';\n");
+		grammarBuilder.append("KW3203 : 'KW' '3203';\n");
+		grammarBuilder.append("KW3204 : 'KW' '3204';\n");
+		grammarBuilder.append("KW3205 : 'KW' '3205';\n");
+		grammarBuilder.append("KW3206 : 'KW' '3206';\n");
+		grammarBuilder.append("KW3207 : 'KW' '3207';\n");
+		grammarBuilder.append("KW3208 : 'KW' '3208';\n");
+		grammarBuilder.append("KW3209 : 'KW' '3209';\n");
+		grammarBuilder.append("KW3210 : 'KW' '3210';\n");
+		grammarBuilder.append("KW3211 : 'KW' '3211';\n");
+		grammarBuilder.append("KW3212 : 'KW' '3212';\n");
+		grammarBuilder.append("KW3213 : 'KW' '3213';\n");
+		grammarBuilder.append("KW3214 : 'KW' '3214';\n");
+		grammarBuilder.append("KW3215 : 'KW' '3215';\n");
+		grammarBuilder.append("KW3216 : 'KW' '3216';\n");
+		grammarBuilder.append("KW3217 : 'KW' '3217';\n");
+		grammarBuilder.append("KW3218 : 'KW' '3218';\n");
+		grammarBuilder.append("KW3219 : 'KW' '3219';\n");
+		grammarBuilder.append("KW3220 : 'KW' '3220';\n");
+		grammarBuilder.append("KW3221 : 'KW' '3221';\n");
+		grammarBuilder.append("KW3222 : 'KW' '3222';\n");
+		grammarBuilder.append("KW3223 : 'KW' '3223';\n");
+		grammarBuilder.append("KW3224 : 'KW' '3224';\n");
+		grammarBuilder.append("KW3225 : 'KW' '3225';\n");
+		grammarBuilder.append("KW3226 : 'KW' '3226';\n");
+		grammarBuilder.append("KW3227 : 'KW' '3227';\n");
+		grammarBuilder.append("KW3228 : 'KW' '3228';\n");
+		grammarBuilder.append("KW3229 : 'KW' '3229';\n");
+		grammarBuilder.append("KW3230 : 'KW' '3230';\n");
+		grammarBuilder.append("KW3231 : 'KW' '3231';\n");
+		grammarBuilder.append("KW3232 : 'KW' '3232';\n");
+		grammarBuilder.append("KW3233 : 'KW' '3233';\n");
+		grammarBuilder.append("KW3234 : 'KW' '3234';\n");
+		grammarBuilder.append("KW3235 : 'KW' '3235';\n");
+		grammarBuilder.append("KW3236 : 'KW' '3236';\n");
+		grammarBuilder.append("KW3237 : 'KW' '3237';\n");
+		grammarBuilder.append("KW3238 : 'KW' '3238';\n");
+		grammarBuilder.append("KW3239 : 'KW' '3239';\n");
+		grammarBuilder.append("KW3240 : 'KW' '3240';\n");
+		grammarBuilder.append("KW3241 : 'KW' '3241';\n");
+		grammarBuilder.append("KW3242 : 'KW' '3242';\n");
+		grammarBuilder.append("KW3243 : 'KW' '3243';\n");
+		grammarBuilder.append("KW3244 : 'KW' '3244';\n");
+		grammarBuilder.append("KW3245 : 'KW' '3245';\n");
+		grammarBuilder.append("KW3246 : 'KW' '3246';\n");
+		grammarBuilder.append("KW3247 : 'KW' '3247';\n");
+		grammarBuilder.append("KW3248 : 'KW' '3248';\n");
+		grammarBuilder.append("KW3249 : 'KW' '3249';\n");
+		grammarBuilder.append("KW3250 : 'KW' '3250';\n");
+		grammarBuilder.append("KW3251 : 'KW' '3251';\n");
+		grammarBuilder.append("KW3252 : 'KW' '3252';\n");
+		grammarBuilder.append("KW3253 : 'KW' '3253';\n");
+		grammarBuilder.append("KW3254 : 'KW' '3254';\n");
+		grammarBuilder.append("KW3255 : 'KW' '3255';\n");
+		grammarBuilder.append("KW3256 : 'KW' '3256';\n");
+		grammarBuilder.append("KW3257 : 'KW' '3257';\n");
+		grammarBuilder.append("KW3258 : 'KW' '3258';\n");
+		grammarBuilder.append("KW3259 : 'KW' '3259';\n");
+		grammarBuilder.append("KW3260 : 'KW' '3260';\n");
+		grammarBuilder.append("KW3261 : 'KW' '3261';\n");
+		grammarBuilder.append("KW3262 : 'KW' '3262';\n");
+		grammarBuilder.append("KW3263 : 'KW' '3263';\n");
+		grammarBuilder.append("KW3264 : 'KW' '3264';\n");
+		grammarBuilder.append("KW3265 : 'KW' '3265';\n");
+		grammarBuilder.append("KW3266 : 'KW' '3266';\n");
+		grammarBuilder.append("KW3267 : 'KW' '3267';\n");
+		grammarBuilder.append("KW3268 : 'KW' '3268';\n");
+		grammarBuilder.append("KW3269 : 'KW' '3269';\n");
+		grammarBuilder.append("KW3270 : 'KW' '3270';\n");
+		grammarBuilder.append("KW3271 : 'KW' '3271';\n");
+		grammarBuilder.append("KW3272 : 'KW' '3272';\n");
+		grammarBuilder.append("KW3273 : 'KW' '3273';\n");
+		grammarBuilder.append("KW3274 : 'KW' '3274';\n");
+		grammarBuilder.append("KW3275 : 'KW' '3275';\n");
+		grammarBuilder.append("KW3276 : 'KW' '3276';\n");
+		grammarBuilder.append("KW3277 : 'KW' '3277';\n");
+		grammarBuilder.append("KW3278 : 'KW' '3278';\n");
+		grammarBuilder.append("KW3279 : 'KW' '3279';\n");
+		grammarBuilder.append("KW3280 : 'KW' '3280';\n");
+		grammarBuilder.append("KW3281 : 'KW' '3281';\n");
+		grammarBuilder.append("KW3282 : 'KW' '3282';\n");
+		grammarBuilder.append("KW3283 : 'KW' '3283';\n");
+		grammarBuilder.append("KW3284 : 'KW' '3284';\n");
+		grammarBuilder.append("KW3285 : 'KW' '3285';\n");
+		grammarBuilder.append("KW3286 : 'KW' '3286';\n");
+		grammarBuilder.append("KW3287 : 'KW' '3287';\n");
+		grammarBuilder.append("KW3288 : 'KW' '3288';\n");
+		grammarBuilder.append("KW3289 : 'KW' '3289';\n");
+		grammarBuilder.append("KW3290 : 'KW' '3290';\n");
+		grammarBuilder.append("KW3291 : 'KW' '3291';\n");
+		grammarBuilder.append("KW3292 : 'KW' '3292';\n");
+		grammarBuilder.append("KW3293 : 'KW' '3293';\n");
+		grammarBuilder.append("KW3294 : 'KW' '3294';\n");
+		grammarBuilder.append("KW3295 : 'KW' '3295';\n");
+		grammarBuilder.append("KW3296 : 'KW' '3296';\n");
+		grammarBuilder.append("KW3297 : 'KW' '3297';\n");
+		grammarBuilder.append("KW3298 : 'KW' '3298';\n");
+		grammarBuilder.append("KW3299 : 'KW' '3299';\n");
+		grammarBuilder.append("KW3300 : 'KW' '3300';\n");
+		grammarBuilder.append("KW3301 : 'KW' '3301';\n");
+		grammarBuilder.append("KW3302 : 'KW' '3302';\n");
+		grammarBuilder.append("KW3303 : 'KW' '3303';\n");
+		grammarBuilder.append("KW3304 : 'KW' '3304';\n");
+		grammarBuilder.append("KW3305 : 'KW' '3305';\n");
+		grammarBuilder.append("KW3306 : 'KW' '3306';\n");
+		grammarBuilder.append("KW3307 : 'KW' '3307';\n");
+		grammarBuilder.append("KW3308 : 'KW' '3308';\n");
+		grammarBuilder.append("KW3309 : 'KW' '3309';\n");
+		grammarBuilder.append("KW3310 : 'KW' '3310';\n");
+		grammarBuilder.append("KW3311 : 'KW' '3311';\n");
+		grammarBuilder.append("KW3312 : 'KW' '3312';\n");
+		grammarBuilder.append("KW3313 : 'KW' '3313';\n");
+		grammarBuilder.append("KW3314 : 'KW' '3314';\n");
+		grammarBuilder.append("KW3315 : 'KW' '3315';\n");
+		grammarBuilder.append("KW3316 : 'KW' '3316';\n");
+		grammarBuilder.append("KW3317 : 'KW' '3317';\n");
+		grammarBuilder.append("KW3318 : 'KW' '3318';\n");
+		grammarBuilder.append("KW3319 : 'KW' '3319';\n");
+		grammarBuilder.append("KW3320 : 'KW' '3320';\n");
+		grammarBuilder.append("KW3321 : 'KW' '3321';\n");
+		grammarBuilder.append("KW3322 : 'KW' '3322';\n");
+		grammarBuilder.append("KW3323 : 'KW' '3323';\n");
+		grammarBuilder.append("KW3324 : 'KW' '3324';\n");
+		grammarBuilder.append("KW3325 : 'KW' '3325';\n");
+		grammarBuilder.append("KW3326 : 'KW' '3326';\n");
+		grammarBuilder.append("KW3327 : 'KW' '3327';\n");
+		grammarBuilder.append("KW3328 : 'KW' '3328';\n");
+		grammarBuilder.append("KW3329 : 'KW' '3329';\n");
+		grammarBuilder.append("KW3330 : 'KW' '3330';\n");
+		grammarBuilder.append("KW3331 : 'KW' '3331';\n");
+		grammarBuilder.append("KW3332 : 'KW' '3332';\n");
+		grammarBuilder.append("KW3333 : 'KW' '3333';\n");
+		grammarBuilder.append("KW3334 : 'KW' '3334';\n");
+		grammarBuilder.append("KW3335 : 'KW' '3335';\n");
+		grammarBuilder.append("KW3336 : 'KW' '3336';\n");
+		grammarBuilder.append("KW3337 : 'KW' '3337';\n");
+		grammarBuilder.append("KW3338 : 'KW' '3338';\n");
+		grammarBuilder.append("KW3339 : 'KW' '3339';\n");
+		grammarBuilder.append("KW3340 : 'KW' '3340';\n");
+		grammarBuilder.append("KW3341 : 'KW' '3341';\n");
+		grammarBuilder.append("KW3342 : 'KW' '3342';\n");
+		grammarBuilder.append("KW3343 : 'KW' '3343';\n");
+		grammarBuilder.append("KW3344 : 'KW' '3344';\n");
+		grammarBuilder.append("KW3345 : 'KW' '3345';\n");
+		grammarBuilder.append("KW3346 : 'KW' '3346';\n");
+		grammarBuilder.append("KW3347 : 'KW' '3347';\n");
+		grammarBuilder.append("KW3348 : 'KW' '3348';\n");
+		grammarBuilder.append("KW3349 : 'KW' '3349';\n");
+		grammarBuilder.append("KW3350 : 'KW' '3350';\n");
+		grammarBuilder.append("KW3351 : 'KW' '3351';\n");
+		grammarBuilder.append("KW3352 : 'KW' '3352';\n");
+		grammarBuilder.append("KW3353 : 'KW' '3353';\n");
+		grammarBuilder.append("KW3354 : 'KW' '3354';\n");
+		grammarBuilder.append("KW3355 : 'KW' '3355';\n");
+		grammarBuilder.append("KW3356 : 'KW' '3356';\n");
+		grammarBuilder.append("KW3357 : 'KW' '3357';\n");
+		grammarBuilder.append("KW3358 : 'KW' '3358';\n");
+		grammarBuilder.append("KW3359 : 'KW' '3359';\n");
+		grammarBuilder.append("KW3360 : 'KW' '3360';\n");
+		grammarBuilder.append("KW3361 : 'KW' '3361';\n");
+		grammarBuilder.append("KW3362 : 'KW' '3362';\n");
+		grammarBuilder.append("KW3363 : 'KW' '3363';\n");
+		grammarBuilder.append("KW3364 : 'KW' '3364';\n");
+		grammarBuilder.append("KW3365 : 'KW' '3365';\n");
+		grammarBuilder.append("KW3366 : 'KW' '3366';\n");
+		grammarBuilder.append("KW3367 : 'KW' '3367';\n");
+		grammarBuilder.append("KW3368 : 'KW' '3368';\n");
+		grammarBuilder.append("KW3369 : 'KW' '3369';\n");
+		grammarBuilder.append("KW3370 : 'KW' '3370';\n");
+		grammarBuilder.append("KW3371 : 'KW' '3371';\n");
+		grammarBuilder.append("KW3372 : 'KW' '3372';\n");
+		grammarBuilder.append("KW3373 : 'KW' '3373';\n");
+		grammarBuilder.append("KW3374 : 'KW' '3374';\n");
+		grammarBuilder.append("KW3375 : 'KW' '3375';\n");
+		grammarBuilder.append("KW3376 : 'KW' '3376';\n");
+		grammarBuilder.append("KW3377 : 'KW' '3377';\n");
+		grammarBuilder.append("KW3378 : 'KW' '3378';\n");
+		grammarBuilder.append("KW3379 : 'KW' '3379';\n");
+		grammarBuilder.append("KW3380 : 'KW' '3380';\n");
+		grammarBuilder.append("KW3381 : 'KW' '3381';\n");
+		grammarBuilder.append("KW3382 : 'KW' '3382';\n");
+		grammarBuilder.append("KW3383 : 'KW' '3383';\n");
+		grammarBuilder.append("KW3384 : 'KW' '3384';\n");
+		grammarBuilder.append("KW3385 : 'KW' '3385';\n");
+		grammarBuilder.append("KW3386 : 'KW' '3386';\n");
+		grammarBuilder.append("KW3387 : 'KW' '3387';\n");
+		grammarBuilder.append("KW3388 : 'KW' '3388';\n");
+		grammarBuilder.append("KW3389 : 'KW' '3389';\n");
+		grammarBuilder.append("KW3390 : 'KW' '3390';\n");
+		grammarBuilder.append("KW3391 : 'KW' '3391';\n");
+		grammarBuilder.append("KW3392 : 'KW' '3392';\n");
+		grammarBuilder.append("KW3393 : 'KW' '3393';\n");
+		grammarBuilder.append("KW3394 : 'KW' '3394';\n");
+		grammarBuilder.append("KW3395 : 'KW' '3395';\n");
+		grammarBuilder.append("KW3396 : 'KW' '3396';\n");
+		grammarBuilder.append("KW3397 : 'KW' '3397';\n");
+		grammarBuilder.append("KW3398 : 'KW' '3398';\n");
+		grammarBuilder.append("KW3399 : 'KW' '3399';\n");
+		grammarBuilder.append("KW3400 : 'KW' '3400';\n");
+		grammarBuilder.append("KW3401 : 'KW' '3401';\n");
+		grammarBuilder.append("KW3402 : 'KW' '3402';\n");
+		grammarBuilder.append("KW3403 : 'KW' '3403';\n");
+		grammarBuilder.append("KW3404 : 'KW' '3404';\n");
+		grammarBuilder.append("KW3405 : 'KW' '3405';\n");
+		grammarBuilder.append("KW3406 : 'KW' '3406';\n");
+		grammarBuilder.append("KW3407 : 'KW' '3407';\n");
+		grammarBuilder.append("KW3408 : 'KW' '3408';\n");
+		grammarBuilder.append("KW3409 : 'KW' '3409';\n");
+		grammarBuilder.append("KW3410 : 'KW' '3410';\n");
+		grammarBuilder.append("KW3411 : 'KW' '3411';\n");
+		grammarBuilder.append("KW3412 : 'KW' '3412';\n");
+		grammarBuilder.append("KW3413 : 'KW' '3413';\n");
+		grammarBuilder.append("KW3414 : 'KW' '3414';\n");
+		grammarBuilder.append("KW3415 : 'KW' '3415';\n");
+		grammarBuilder.append("KW3416 : 'KW' '3416';\n");
+		grammarBuilder.append("KW3417 : 'KW' '3417';\n");
+		grammarBuilder.append("KW3418 : 'KW' '3418';\n");
+		grammarBuilder.append("KW3419 : 'KW' '3419';\n");
+		grammarBuilder.append("KW3420 : 'KW' '3420';\n");
+		grammarBuilder.append("KW3421 : 'KW' '3421';\n");
+		grammarBuilder.append("KW3422 : 'KW' '3422';\n");
+		grammarBuilder.append("KW3423 : 'KW' '3423';\n");
+		grammarBuilder.append("KW3424 : 'KW' '3424';\n");
+		grammarBuilder.append("KW3425 : 'KW' '3425';\n");
+		grammarBuilder.append("KW3426 : 'KW' '3426';\n");
+		grammarBuilder.append("KW3427 : 'KW' '3427';\n");
+		grammarBuilder.append("KW3428 : 'KW' '3428';\n");
+		grammarBuilder.append("KW3429 : 'KW' '3429';\n");
+		grammarBuilder.append("KW3430 : 'KW' '3430';\n");
+		grammarBuilder.append("KW3431 : 'KW' '3431';\n");
+		grammarBuilder.append("KW3432 : 'KW' '3432';\n");
+		grammarBuilder.append("KW3433 : 'KW' '3433';\n");
+		grammarBuilder.append("KW3434 : 'KW' '3434';\n");
+		grammarBuilder.append("KW3435 : 'KW' '3435';\n");
+		grammarBuilder.append("KW3436 : 'KW' '3436';\n");
+		grammarBuilder.append("KW3437 : 'KW' '3437';\n");
+		grammarBuilder.append("KW3438 : 'KW' '3438';\n");
+		grammarBuilder.append("KW3439 : 'KW' '3439';\n");
+		grammarBuilder.append("KW3440 : 'KW' '3440';\n");
+		grammarBuilder.append("KW3441 : 'KW' '3441';\n");
+		grammarBuilder.append("KW3442 : 'KW' '3442';\n");
+		grammarBuilder.append("KW3443 : 'KW' '3443';\n");
+		grammarBuilder.append("KW3444 : 'KW' '3444';\n");
+		grammarBuilder.append("KW3445 : 'KW' '3445';\n");
+		grammarBuilder.append("KW3446 : 'KW' '3446';\n");
+		grammarBuilder.append("KW3447 : 'KW' '3447';\n");
+		grammarBuilder.append("KW3448 : 'KW' '3448';\n");
+		grammarBuilder.append("KW3449 : 'KW' '3449';\n");
+		grammarBuilder.append("KW3450 : 'KW' '3450';\n");
+		grammarBuilder.append("KW3451 : 'KW' '3451';\n");
+		grammarBuilder.append("KW3452 : 'KW' '3452';\n");
+		grammarBuilder.append("KW3453 : 'KW' '3453';\n");
+		grammarBuilder.append("KW3454 : 'KW' '3454';\n");
+		grammarBuilder.append("KW3455 : 'KW' '3455';\n");
+		grammarBuilder.append("KW3456 : 'KW' '3456';\n");
+		grammarBuilder.append("KW3457 : 'KW' '3457';\n");
+		grammarBuilder.append("KW3458 : 'KW' '3458';\n");
+		grammarBuilder.append("KW3459 : 'KW' '3459';\n");
+		grammarBuilder.append("KW3460 : 'KW' '3460';\n");
+		grammarBuilder.append("KW3461 : 'KW' '3461';\n");
+		grammarBuilder.append("KW3462 : 'KW' '3462';\n");
+		grammarBuilder.append("KW3463 : 'KW' '3463';\n");
+		grammarBuilder.append("KW3464 : 'KW' '3464';\n");
+		grammarBuilder.append("KW3465 : 'KW' '3465';\n");
+		grammarBuilder.append("KW3466 : 'KW' '3466';\n");
+		grammarBuilder.append("KW3467 : 'KW' '3467';\n");
+		grammarBuilder.append("KW3468 : 'KW' '3468';\n");
+		grammarBuilder.append("KW3469 : 'KW' '3469';\n");
+		grammarBuilder.append("KW3470 : 'KW' '3470';\n");
+		grammarBuilder.append("KW3471 : 'KW' '3471';\n");
+		grammarBuilder.append("KW3472 : 'KW' '3472';\n");
+		grammarBuilder.append("KW3473 : 'KW' '3473';\n");
+		grammarBuilder.append("KW3474 : 'KW' '3474';\n");
+		grammarBuilder.append("KW3475 : 'KW' '3475';\n");
+		grammarBuilder.append("KW3476 : 'KW' '3476';\n");
+		grammarBuilder.append("KW3477 : 'KW' '3477';\n");
+		grammarBuilder.append("KW3478 : 'KW' '3478';\n");
+		grammarBuilder.append("KW3479 : 'KW' '3479';\n");
+		grammarBuilder.append("KW3480 : 'KW' '3480';\n");
+		grammarBuilder.append("KW3481 : 'KW' '3481';\n");
+		grammarBuilder.append("KW3482 : 'KW' '3482';\n");
+		grammarBuilder.append("KW3483 : 'KW' '3483';\n");
+		grammarBuilder.append("KW3484 : 'KW' '3484';\n");
+		grammarBuilder.append("KW3485 : 'KW' '3485';\n");
+		grammarBuilder.append("KW3486 : 'KW' '3486';\n");
+		grammarBuilder.append("KW3487 : 'KW' '3487';\n");
+		grammarBuilder.append("KW3488 : 'KW' '3488';\n");
+		grammarBuilder.append("KW3489 : 'KW' '3489';\n");
+		grammarBuilder.append("KW3490 : 'KW' '3490';\n");
+		grammarBuilder.append("KW3491 : 'KW' '3491';\n");
+		grammarBuilder.append("KW3492 : 'KW' '3492';\n");
+		grammarBuilder.append("KW3493 : 'KW' '3493';\n");
+		grammarBuilder.append("KW3494 : 'KW' '3494';\n");
+		grammarBuilder.append("KW3495 : 'KW' '3495';\n");
+		grammarBuilder.append("KW3496 : 'KW' '3496';\n");
+		grammarBuilder.append("KW3497 : 'KW' '3497';\n");
+		grammarBuilder.append("KW3498 : 'KW' '3498';\n");
+		grammarBuilder.append("KW3499 : 'KW' '3499';\n");
+		grammarBuilder.append("KW3500 : 'KW' '3500';\n");
+		grammarBuilder.append("KW3501 : 'KW' '3501';\n");
+		grammarBuilder.append("KW3502 : 'KW' '3502';\n");
+		grammarBuilder.append("KW3503 : 'KW' '3503';\n");
+		grammarBuilder.append("KW3504 : 'KW' '3504';\n");
+		grammarBuilder.append("KW3505 : 'KW' '3505';\n");
+		grammarBuilder.append("KW3506 : 'KW' '3506';\n");
+		grammarBuilder.append("KW3507 : 'KW' '3507';\n");
+		grammarBuilder.append("KW3508 : 'KW' '3508';\n");
+		grammarBuilder.append("KW3509 : 'KW' '3509';\n");
+		grammarBuilder.append("KW3510 : 'KW' '3510';\n");
+		grammarBuilder.append("KW3511 : 'KW' '3511';\n");
+		grammarBuilder.append("KW3512 : 'KW' '3512';\n");
+		grammarBuilder.append("KW3513 : 'KW' '3513';\n");
+		grammarBuilder.append("KW3514 : 'KW' '3514';\n");
+		grammarBuilder.append("KW3515 : 'KW' '3515';\n");
+		grammarBuilder.append("KW3516 : 'KW' '3516';\n");
+		grammarBuilder.append("KW3517 : 'KW' '3517';\n");
+		grammarBuilder.append("KW3518 : 'KW' '3518';\n");
+		grammarBuilder.append("KW3519 : 'KW' '3519';\n");
+		grammarBuilder.append("KW3520 : 'KW' '3520';\n");
+		grammarBuilder.append("KW3521 : 'KW' '3521';\n");
+		grammarBuilder.append("KW3522 : 'KW' '3522';\n");
+		grammarBuilder.append("KW3523 : 'KW' '3523';\n");
+		grammarBuilder.append("KW3524 : 'KW' '3524';\n");
+		grammarBuilder.append("KW3525 : 'KW' '3525';\n");
+		grammarBuilder.append("KW3526 : 'KW' '3526';\n");
+		grammarBuilder.append("KW3527 : 'KW' '3527';\n");
+		grammarBuilder.append("KW3528 : 'KW' '3528';\n");
+		grammarBuilder.append("KW3529 : 'KW' '3529';\n");
+		grammarBuilder.append("KW3530 : 'KW' '3530';\n");
+		grammarBuilder.append("KW3531 : 'KW' '3531';\n");
+		grammarBuilder.append("KW3532 : 'KW' '3532';\n");
+		grammarBuilder.append("KW3533 : 'KW' '3533';\n");
+		grammarBuilder.append("KW3534 : 'KW' '3534';\n");
+		grammarBuilder.append("KW3535 : 'KW' '3535';\n");
+		grammarBuilder.append("KW3536 : 'KW' '3536';\n");
+		grammarBuilder.append("KW3537 : 'KW' '3537';\n");
+		grammarBuilder.append("KW3538 : 'KW' '3538';\n");
+		grammarBuilder.append("KW3539 : 'KW' '3539';\n");
+		grammarBuilder.append("KW3540 : 'KW' '3540';\n");
+		grammarBuilder.append("KW3541 : 'KW' '3541';\n");
+		grammarBuilder.append("KW3542 : 'KW' '3542';\n");
+		grammarBuilder.append("KW3543 : 'KW' '3543';\n");
+		grammarBuilder.append("KW3544 : 'KW' '3544';\n");
+		grammarBuilder.append("KW3545 : 'KW' '3545';\n");
+		grammarBuilder.append("KW3546 : 'KW' '3546';\n");
+		grammarBuilder.append("KW3547 : 'KW' '3547';\n");
+		grammarBuilder.append("KW3548 : 'KW' '3548';\n");
+		grammarBuilder.append("KW3549 : 'KW' '3549';\n");
+		grammarBuilder.append("KW3550 : 'KW' '3550';\n");
+		grammarBuilder.append("KW3551 : 'KW' '3551';\n");
+		grammarBuilder.append("KW3552 : 'KW' '3552';\n");
+		grammarBuilder.append("KW3553 : 'KW' '3553';\n");
+		grammarBuilder.append("KW3554 : 'KW' '3554';\n");
+		grammarBuilder.append("KW3555 : 'KW' '3555';\n");
+		grammarBuilder.append("KW3556 : 'KW' '3556';\n");
+		grammarBuilder.append("KW3557 : 'KW' '3557';\n");
+		grammarBuilder.append("KW3558 : 'KW' '3558';\n");
+		grammarBuilder.append("KW3559 : 'KW' '3559';\n");
+		grammarBuilder.append("KW3560 : 'KW' '3560';\n");
+		grammarBuilder.append("KW3561 : 'KW' '3561';\n");
+		grammarBuilder.append("KW3562 : 'KW' '3562';\n");
+		grammarBuilder.append("KW3563 : 'KW' '3563';\n");
+		grammarBuilder.append("KW3564 : 'KW' '3564';\n");
+		grammarBuilder.append("KW3565 : 'KW' '3565';\n");
+		grammarBuilder.append("KW3566 : 'KW' '3566';\n");
+		grammarBuilder.append("KW3567 : 'KW' '3567';\n");
+		grammarBuilder.append("KW3568 : 'KW' '3568';\n");
+		grammarBuilder.append("KW3569 : 'KW' '3569';\n");
+		grammarBuilder.append("KW3570 : 'KW' '3570';\n");
+		grammarBuilder.append("KW3571 : 'KW' '3571';\n");
+		grammarBuilder.append("KW3572 : 'KW' '3572';\n");
+		grammarBuilder.append("KW3573 : 'KW' '3573';\n");
+		grammarBuilder.append("KW3574 : 'KW' '3574';\n");
+		grammarBuilder.append("KW3575 : 'KW' '3575';\n");
+		grammarBuilder.append("KW3576 : 'KW' '3576';\n");
+		grammarBuilder.append("KW3577 : 'KW' '3577';\n");
+		grammarBuilder.append("KW3578 : 'KW' '3578';\n");
+		grammarBuilder.append("KW3579 : 'KW' '3579';\n");
+		grammarBuilder.append("KW3580 : 'KW' '3580';\n");
+		grammarBuilder.append("KW3581 : 'KW' '3581';\n");
+		grammarBuilder.append("KW3582 : 'KW' '3582';\n");
+		grammarBuilder.append("KW3583 : 'KW' '3583';\n");
+		grammarBuilder.append("KW3584 : 'KW' '3584';\n");
+		grammarBuilder.append("KW3585 : 'KW' '3585';\n");
+		grammarBuilder.append("KW3586 : 'KW' '3586';\n");
+		grammarBuilder.append("KW3587 : 'KW' '3587';\n");
+		grammarBuilder.append("KW3588 : 'KW' '3588';\n");
+		grammarBuilder.append("KW3589 : 'KW' '3589';\n");
+		grammarBuilder.append("KW3590 : 'KW' '3590';\n");
+		grammarBuilder.append("KW3591 : 'KW' '3591';\n");
+		grammarBuilder.append("KW3592 : 'KW' '3592';\n");
+		grammarBuilder.append("KW3593 : 'KW' '3593';\n");
+		grammarBuilder.append("KW3594 : 'KW' '3594';\n");
+		grammarBuilder.append("KW3595 : 'KW' '3595';\n");
+		grammarBuilder.append("KW3596 : 'KW' '3596';\n");
+		grammarBuilder.append("KW3597 : 'KW' '3597';\n");
+		grammarBuilder.append("KW3598 : 'KW' '3598';\n");
+		grammarBuilder.append("KW3599 : 'KW' '3599';\n");
+		grammarBuilder.append("KW3600 : 'KW' '3600';\n");
+		grammarBuilder.append("KW3601 : 'KW' '3601';\n");
+		grammarBuilder.append("KW3602 : 'KW' '3602';\n");
+		grammarBuilder.append("KW3603 : 'KW' '3603';\n");
+		grammarBuilder.append("KW3604 : 'KW' '3604';\n");
+		grammarBuilder.append("KW3605 : 'KW' '3605';\n");
+		grammarBuilder.append("KW3606 : 'KW' '3606';\n");
+		grammarBuilder.append("KW3607 : 'KW' '3607';\n");
+		grammarBuilder.append("KW3608 : 'KW' '3608';\n");
+		grammarBuilder.append("KW3609 : 'KW' '3609';\n");
+		grammarBuilder.append("KW3610 : 'KW' '3610';\n");
+		grammarBuilder.append("KW3611 : 'KW' '3611';\n");
+		grammarBuilder.append("KW3612 : 'KW' '3612';\n");
+		grammarBuilder.append("KW3613 : 'KW' '3613';\n");
+		grammarBuilder.append("KW3614 : 'KW' '3614';\n");
+		grammarBuilder.append("KW3615 : 'KW' '3615';\n");
+		grammarBuilder.append("KW3616 : 'KW' '3616';\n");
+		grammarBuilder.append("KW3617 : 'KW' '3617';\n");
+		grammarBuilder.append("KW3618 : 'KW' '3618';\n");
+		grammarBuilder.append("KW3619 : 'KW' '3619';\n");
+		grammarBuilder.append("KW3620 : 'KW' '3620';\n");
+		grammarBuilder.append("KW3621 : 'KW' '3621';\n");
+		grammarBuilder.append("KW3622 : 'KW' '3622';\n");
+		grammarBuilder.append("KW3623 : 'KW' '3623';\n");
+		grammarBuilder.append("KW3624 : 'KW' '3624';\n");
+		grammarBuilder.append("KW3625 : 'KW' '3625';\n");
+		grammarBuilder.append("KW3626 : 'KW' '3626';\n");
+		grammarBuilder.append("KW3627 : 'KW' '3627';\n");
+		grammarBuilder.append("KW3628 : 'KW' '3628';\n");
+		grammarBuilder.append("KW3629 : 'KW' '3629';\n");
+		grammarBuilder.append("KW3630 : 'KW' '3630';\n");
+		grammarBuilder.append("KW3631 : 'KW' '3631';\n");
+		grammarBuilder.append("KW3632 : 'KW' '3632';\n");
+		grammarBuilder.append("KW3633 : 'KW' '3633';\n");
+		grammarBuilder.append("KW3634 : 'KW' '3634';\n");
+		grammarBuilder.append("KW3635 : 'KW' '3635';\n");
+		grammarBuilder.append("KW3636 : 'KW' '3636';\n");
+		grammarBuilder.append("KW3637 : 'KW' '3637';\n");
+		grammarBuilder.append("KW3638 : 'KW' '3638';\n");
+		grammarBuilder.append("KW3639 : 'KW' '3639';\n");
+		grammarBuilder.append("KW3640 : 'KW' '3640';\n");
+		grammarBuilder.append("KW3641 : 'KW' '3641';\n");
+		grammarBuilder.append("KW3642 : 'KW' '3642';\n");
+		grammarBuilder.append("KW3643 : 'KW' '3643';\n");
+		grammarBuilder.append("KW3644 : 'KW' '3644';\n");
+		grammarBuilder.append("KW3645 : 'KW' '3645';\n");
+		grammarBuilder.append("KW3646 : 'KW' '3646';\n");
+		grammarBuilder.append("KW3647 : 'KW' '3647';\n");
+		grammarBuilder.append("KW3648 : 'KW' '3648';\n");
+		grammarBuilder.append("KW3649 : 'KW' '3649';\n");
+		grammarBuilder.append("KW3650 : 'KW' '3650';\n");
+		grammarBuilder.append("KW3651 : 'KW' '3651';\n");
+		grammarBuilder.append("KW3652 : 'KW' '3652';\n");
+		grammarBuilder.append("KW3653 : 'KW' '3653';\n");
+		grammarBuilder.append("KW3654 : 'KW' '3654';\n");
+		grammarBuilder.append("KW3655 : 'KW' '3655';\n");
+		grammarBuilder.append("KW3656 : 'KW' '3656';\n");
+		grammarBuilder.append("KW3657 : 'KW' '3657';\n");
+		grammarBuilder.append("KW3658 : 'KW' '3658';\n");
+		grammarBuilder.append("KW3659 : 'KW' '3659';\n");
+		grammarBuilder.append("KW3660 : 'KW' '3660';\n");
+		grammarBuilder.append("KW3661 : 'KW' '3661';\n");
+		grammarBuilder.append("KW3662 : 'KW' '3662';\n");
+		grammarBuilder.append("KW3663 : 'KW' '3663';\n");
+		grammarBuilder.append("KW3664 : 'KW' '3664';\n");
+		grammarBuilder.append("KW3665 : 'KW' '3665';\n");
+		grammarBuilder.append("KW3666 : 'KW' '3666';\n");
+		grammarBuilder.append("KW3667 : 'KW' '3667';\n");
+		grammarBuilder.append("KW3668 : 'KW' '3668';\n");
+		grammarBuilder.append("KW3669 : 'KW' '3669';\n");
+		grammarBuilder.append("KW3670 : 'KW' '3670';\n");
+		grammarBuilder.append("KW3671 : 'KW' '3671';\n");
+		grammarBuilder.append("KW3672 : 'KW' '3672';\n");
+		grammarBuilder.append("KW3673 : 'KW' '3673';\n");
+		grammarBuilder.append("KW3674 : 'KW' '3674';\n");
+		grammarBuilder.append("KW3675 : 'KW' '3675';\n");
+		grammarBuilder.append("KW3676 : 'KW' '3676';\n");
+		grammarBuilder.append("KW3677 : 'KW' '3677';\n");
+		grammarBuilder.append("KW3678 : 'KW' '3678';\n");
+		grammarBuilder.append("KW3679 : 'KW' '3679';\n");
+		grammarBuilder.append("KW3680 : 'KW' '3680';\n");
+		grammarBuilder.append("KW3681 : 'KW' '3681';\n");
+		grammarBuilder.append("KW3682 : 'KW' '3682';\n");
+		grammarBuilder.append("KW3683 : 'KW' '3683';\n");
+		grammarBuilder.append("KW3684 : 'KW' '3684';\n");
+		grammarBuilder.append("KW3685 : 'KW' '3685';\n");
+		grammarBuilder.append("KW3686 : 'KW' '3686';\n");
+		grammarBuilder.append("KW3687 : 'KW' '3687';\n");
+		grammarBuilder.append("KW3688 : 'KW' '3688';\n");
+		grammarBuilder.append("KW3689 : 'KW' '3689';\n");
+		grammarBuilder.append("KW3690 : 'KW' '3690';\n");
+		grammarBuilder.append("KW3691 : 'KW' '3691';\n");
+		grammarBuilder.append("KW3692 : 'KW' '3692';\n");
+		grammarBuilder.append("KW3693 : 'KW' '3693';\n");
+		grammarBuilder.append("KW3694 : 'KW' '3694';\n");
+		grammarBuilder.append("KW3695 : 'KW' '3695';\n");
+		grammarBuilder.append("KW3696 : 'KW' '3696';\n");
+		grammarBuilder.append("KW3697 : 'KW' '3697';\n");
+		grammarBuilder.append("KW3698 : 'KW' '3698';\n");
+		grammarBuilder.append("KW3699 : 'KW' '3699';\n");
+		grammarBuilder.append("KW3700 : 'KW' '3700';\n");
+		grammarBuilder.append("KW3701 : 'KW' '3701';\n");
+		grammarBuilder.append("KW3702 : 'KW' '3702';\n");
+		grammarBuilder.append("KW3703 : 'KW' '3703';\n");
+		grammarBuilder.append("KW3704 : 'KW' '3704';\n");
+		grammarBuilder.append("KW3705 : 'KW' '3705';\n");
+		grammarBuilder.append("KW3706 : 'KW' '3706';\n");
+		grammarBuilder.append("KW3707 : 'KW' '3707';\n");
+		grammarBuilder.append("KW3708 : 'KW' '3708';\n");
+		grammarBuilder.append("KW3709 : 'KW' '3709';\n");
+		grammarBuilder.append("KW3710 : 'KW' '3710';\n");
+		grammarBuilder.append("KW3711 : 'KW' '3711';\n");
+		grammarBuilder.append("KW3712 : 'KW' '3712';\n");
+		grammarBuilder.append("KW3713 : 'KW' '3713';\n");
+		grammarBuilder.append("KW3714 : 'KW' '3714';\n");
+		grammarBuilder.append("KW3715 : 'KW' '3715';\n");
+		grammarBuilder.append("KW3716 : 'KW' '3716';\n");
+		grammarBuilder.append("KW3717 : 'KW' '3717';\n");
+		grammarBuilder.append("KW3718 : 'KW' '3718';\n");
+		grammarBuilder.append("KW3719 : 'KW' '3719';\n");
+		grammarBuilder.append("KW3720 : 'KW' '3720';\n");
+		grammarBuilder.append("KW3721 : 'KW' '3721';\n");
+		grammarBuilder.append("KW3722 : 'KW' '3722';\n");
+		grammarBuilder.append("KW3723 : 'KW' '3723';\n");
+		grammarBuilder.append("KW3724 : 'KW' '3724';\n");
+		grammarBuilder.append("KW3725 : 'KW' '3725';\n");
+		grammarBuilder.append("KW3726 : 'KW' '3726';\n");
+		grammarBuilder.append("KW3727 : 'KW' '3727';\n");
+		grammarBuilder.append("KW3728 : 'KW' '3728';\n");
+		grammarBuilder.append("KW3729 : 'KW' '3729';\n");
+		grammarBuilder.append("KW3730 : 'KW' '3730';\n");
+		grammarBuilder.append("KW3731 : 'KW' '3731';\n");
+		grammarBuilder.append("KW3732 : 'KW' '3732';\n");
+		grammarBuilder.append("KW3733 : 'KW' '3733';\n");
+		grammarBuilder.append("KW3734 : 'KW' '3734';\n");
+		grammarBuilder.append("KW3735 : 'KW' '3735';\n");
+		grammarBuilder.append("KW3736 : 'KW' '3736';\n");
+		grammarBuilder.append("KW3737 : 'KW' '3737';\n");
+		grammarBuilder.append("KW3738 : 'KW' '3738';\n");
+		grammarBuilder.append("KW3739 : 'KW' '3739';\n");
+		grammarBuilder.append("KW3740 : 'KW' '3740';\n");
+		grammarBuilder.append("KW3741 : 'KW' '3741';\n");
+		grammarBuilder.append("KW3742 : 'KW' '3742';\n");
+		grammarBuilder.append("KW3743 : 'KW' '3743';\n");
+		grammarBuilder.append("KW3744 : 'KW' '3744';\n");
+		grammarBuilder.append("KW3745 : 'KW' '3745';\n");
+		grammarBuilder.append("KW3746 : 'KW' '3746';\n");
+		grammarBuilder.append("KW3747 : 'KW' '3747';\n");
+		grammarBuilder.append("KW3748 : 'KW' '3748';\n");
+		grammarBuilder.append("KW3749 : 'KW' '3749';\n");
+		grammarBuilder.append("KW3750 : 'KW' '3750';\n");
+		grammarBuilder.append("KW3751 : 'KW' '3751';\n");
+		grammarBuilder.append("KW3752 : 'KW' '3752';\n");
+		grammarBuilder.append("KW3753 : 'KW' '3753';\n");
+		grammarBuilder.append("KW3754 : 'KW' '3754';\n");
+		grammarBuilder.append("KW3755 : 'KW' '3755';\n");
+		grammarBuilder.append("KW3756 : 'KW' '3756';\n");
+		grammarBuilder.append("KW3757 : 'KW' '3757';\n");
+		grammarBuilder.append("KW3758 : 'KW' '3758';\n");
+		grammarBuilder.append("KW3759 : 'KW' '3759';\n");
+		grammarBuilder.append("KW3760 : 'KW' '3760';\n");
+		grammarBuilder.append("KW3761 : 'KW' '3761';\n");
+		grammarBuilder.append("KW3762 : 'KW' '3762';\n");
+		grammarBuilder.append("KW3763 : 'KW' '3763';\n");
+		grammarBuilder.append("KW3764 : 'KW' '3764';\n");
+		grammarBuilder.append("KW3765 : 'KW' '3765';\n");
+		grammarBuilder.append("KW3766 : 'KW' '3766';\n");
+		grammarBuilder.append("KW3767 : 'KW' '3767';\n");
+		grammarBuilder.append("KW3768 : 'KW' '3768';\n");
+		grammarBuilder.append("KW3769 : 'KW' '3769';\n");
+		grammarBuilder.append("KW3770 : 'KW' '3770';\n");
+		grammarBuilder.append("KW3771 : 'KW' '3771';\n");
+		grammarBuilder.append("KW3772 : 'KW' '3772';\n");
+		grammarBuilder.append("KW3773 : 'KW' '3773';\n");
+		grammarBuilder.append("KW3774 : 'KW' '3774';\n");
+		grammarBuilder.append("KW3775 : 'KW' '3775';\n");
+		grammarBuilder.append("KW3776 : 'KW' '3776';\n");
+		grammarBuilder.append("KW3777 : 'KW' '3777';\n");
+		grammarBuilder.append("KW3778 : 'KW' '3778';\n");
+		grammarBuilder.append("KW3779 : 'KW' '3779';\n");
+		grammarBuilder.append("KW3780 : 'KW' '3780';\n");
+		grammarBuilder.append("KW3781 : 'KW' '3781';\n");
+		grammarBuilder.append("KW3782 : 'KW' '3782';\n");
+		grammarBuilder.append("KW3783 : 'KW' '3783';\n");
+		grammarBuilder.append("KW3784 : 'KW' '3784';\n");
+		grammarBuilder.append("KW3785 : 'KW' '3785';\n");
+		grammarBuilder.append("KW3786 : 'KW' '3786';\n");
+		grammarBuilder.append("KW3787 : 'KW' '3787';\n");
+		grammarBuilder.append("KW3788 : 'KW' '3788';\n");
+		grammarBuilder.append("KW3789 : 'KW' '3789';\n");
+		grammarBuilder.append("KW3790 : 'KW' '3790';\n");
+		grammarBuilder.append("KW3791 : 'KW' '3791';\n");
+		grammarBuilder.append("KW3792 : 'KW' '3792';\n");
+		grammarBuilder.append("KW3793 : 'KW' '3793';\n");
+		grammarBuilder.append("KW3794 : 'KW' '3794';\n");
+		grammarBuilder.append("KW3795 : 'KW' '3795';\n");
+		grammarBuilder.append("KW3796 : 'KW' '3796';\n");
+		grammarBuilder.append("KW3797 : 'KW' '3797';\n");
+		grammarBuilder.append("KW3798 : 'KW' '3798';\n");
+		grammarBuilder.append("KW3799 : 'KW' '3799';\n");
+		grammarBuilder.append("KW3800 : 'KW' '3800';\n");
+		grammarBuilder.append("KW3801 : 'KW' '3801';\n");
+		grammarBuilder.append("KW3802 : 'KW' '3802';\n");
+		grammarBuilder.append("KW3803 : 'KW' '3803';\n");
+		grammarBuilder.append("KW3804 : 'KW' '3804';\n");
+		grammarBuilder.append("KW3805 : 'KW' '3805';\n");
+		grammarBuilder.append("KW3806 : 'KW' '3806';\n");
+		grammarBuilder.append("KW3807 : 'KW' '3807';\n");
+		grammarBuilder.append("KW3808 : 'KW' '3808';\n");
+		grammarBuilder.append("KW3809 : 'KW' '3809';\n");
+		grammarBuilder.append("KW3810 : 'KW' '3810';\n");
+		grammarBuilder.append("KW3811 : 'KW' '3811';\n");
+		grammarBuilder.append("KW3812 : 'KW' '3812';\n");
+		grammarBuilder.append("KW3813 : 'KW' '3813';\n");
+		grammarBuilder.append("KW3814 : 'KW' '3814';\n");
+		grammarBuilder.append("KW3815 : 'KW' '3815';\n");
+		grammarBuilder.append("KW3816 : 'KW' '3816';\n");
+		grammarBuilder.append("KW3817 : 'KW' '3817';\n");
+		grammarBuilder.append("KW3818 : 'KW' '3818';\n");
+		grammarBuilder.append("KW3819 : 'KW' '3819';\n");
+		grammarBuilder.append("KW3820 : 'KW' '3820';\n");
+		grammarBuilder.append("KW3821 : 'KW' '3821';\n");
+		grammarBuilder.append("KW3822 : 'KW' '3822';\n");
+		grammarBuilder.append("KW3823 : 'KW' '3823';\n");
+		grammarBuilder.append("KW3824 : 'KW' '3824';\n");
+		grammarBuilder.append("KW3825 : 'KW' '3825';\n");
+		grammarBuilder.append("KW3826 : 'KW' '3826';\n");
+		grammarBuilder.append("KW3827 : 'KW' '3827';\n");
+		grammarBuilder.append("KW3828 : 'KW' '3828';\n");
+		grammarBuilder.append("KW3829 : 'KW' '3829';\n");
+		grammarBuilder.append("KW3830 : 'KW' '3830';\n");
+		grammarBuilder.append("KW3831 : 'KW' '3831';\n");
+		grammarBuilder.append("KW3832 : 'KW' '3832';\n");
+		grammarBuilder.append("KW3833 : 'KW' '3833';\n");
+		grammarBuilder.append("KW3834 : 'KW' '3834';\n");
+		grammarBuilder.append("KW3835 : 'KW' '3835';\n");
+		grammarBuilder.append("KW3836 : 'KW' '3836';\n");
+		grammarBuilder.append("KW3837 : 'KW' '3837';\n");
+		grammarBuilder.append("KW3838 : 'KW' '3838';\n");
+		grammarBuilder.append("KW3839 : 'KW' '3839';\n");
+		grammarBuilder.append("KW3840 : 'KW' '3840';\n");
+		grammarBuilder.append("KW3841 : 'KW' '3841';\n");
+		grammarBuilder.append("KW3842 : 'KW' '3842';\n");
+		grammarBuilder.append("KW3843 : 'KW' '3843';\n");
+		grammarBuilder.append("KW3844 : 'KW' '3844';\n");
+		grammarBuilder.append("KW3845 : 'KW' '3845';\n");
+		grammarBuilder.append("KW3846 : 'KW' '3846';\n");
+		grammarBuilder.append("KW3847 : 'KW' '3847';\n");
+		grammarBuilder.append("KW3848 : 'KW' '3848';\n");
+		grammarBuilder.append("KW3849 : 'KW' '3849';\n");
+		grammarBuilder.append("KW3850 : 'KW' '3850';\n");
+		grammarBuilder.append("KW3851 : 'KW' '3851';\n");
+		grammarBuilder.append("KW3852 : 'KW' '3852';\n");
+		grammarBuilder.append("KW3853 : 'KW' '3853';\n");
+		grammarBuilder.append("KW3854 : 'KW' '3854';\n");
+		grammarBuilder.append("KW3855 : 'KW' '3855';\n");
+		grammarBuilder.append("KW3856 : 'KW' '3856';\n");
+		grammarBuilder.append("KW3857 : 'KW' '3857';\n");
+		grammarBuilder.append("KW3858 : 'KW' '3858';\n");
+		grammarBuilder.append("KW3859 : 'KW' '3859';\n");
+		grammarBuilder.append("KW3860 : 'KW' '3860';\n");
+		grammarBuilder.append("KW3861 : 'KW' '3861';\n");
+		grammarBuilder.append("KW3862 : 'KW' '3862';\n");
+		grammarBuilder.append("KW3863 : 'KW' '3863';\n");
+		grammarBuilder.append("KW3864 : 'KW' '3864';\n");
+		grammarBuilder.append("KW3865 : 'KW' '3865';\n");
+		grammarBuilder.append("KW3866 : 'KW' '3866';\n");
+		grammarBuilder.append("KW3867 : 'KW' '3867';\n");
+		grammarBuilder.append("KW3868 : 'KW' '3868';\n");
+		grammarBuilder.append("KW3869 : 'KW' '3869';\n");
+		grammarBuilder.append("KW3870 : 'KW' '3870';\n");
+		grammarBuilder.append("KW3871 : 'KW' '3871';\n");
+		grammarBuilder.append("KW3872 : 'KW' '3872';\n");
+		grammarBuilder.append("KW3873 : 'KW' '3873';\n");
+		grammarBuilder.append("KW3874 : 'KW' '3874';\n");
+		grammarBuilder.append("KW3875 : 'KW' '3875';\n");
+		grammarBuilder.append("KW3876 : 'KW' '3876';\n");
+		grammarBuilder.append("KW3877 : 'KW' '3877';\n");
+		grammarBuilder.append("KW3878 : 'KW' '3878';\n");
+		grammarBuilder.append("KW3879 : 'KW' '3879';\n");
+		grammarBuilder.append("KW3880 : 'KW' '3880';\n");
+		grammarBuilder.append("KW3881 : 'KW' '3881';\n");
+		grammarBuilder.append("KW3882 : 'KW' '3882';\n");
+		grammarBuilder.append("KW3883 : 'KW' '3883';\n");
+		grammarBuilder.append("KW3884 : 'KW' '3884';\n");
+		grammarBuilder.append("KW3885 : 'KW' '3885';\n");
+		grammarBuilder.append("KW3886 : 'KW' '3886';\n");
+		grammarBuilder.append("KW3887 : 'KW' '3887';\n");
+		grammarBuilder.append("KW3888 : 'KW' '3888';\n");
+		grammarBuilder.append("KW3889 : 'KW' '3889';\n");
+		grammarBuilder.append("KW3890 : 'KW' '3890';\n");
+		grammarBuilder.append("KW3891 : 'KW' '3891';\n");
+		grammarBuilder.append("KW3892 : 'KW' '3892';\n");
+		grammarBuilder.append("KW3893 : 'KW' '3893';\n");
+		grammarBuilder.append("KW3894 : 'KW' '3894';\n");
+		grammarBuilder.append("KW3895 : 'KW' '3895';\n");
+		grammarBuilder.append("KW3896 : 'KW' '3896';\n");
+		grammarBuilder.append("KW3897 : 'KW' '3897';\n");
+		grammarBuilder.append("KW3898 : 'KW' '3898';\n");
+		grammarBuilder.append("KW3899 : 'KW' '3899';\n");
+		grammarBuilder.append("KW3900 : 'KW' '3900';\n");
+		grammarBuilder.append("KW3901 : 'KW' '3901';\n");
+		grammarBuilder.append("KW3902 : 'KW' '3902';\n");
+		grammarBuilder.append("KW3903 : 'KW' '3903';\n");
+		grammarBuilder.append("KW3904 : 'KW' '3904';\n");
+		grammarBuilder.append("KW3905 : 'KW' '3905';\n");
+		grammarBuilder.append("KW3906 : 'KW' '3906';\n");
+		grammarBuilder.append("KW3907 : 'KW' '3907';\n");
+		grammarBuilder.append("KW3908 : 'KW' '3908';\n");
+		grammarBuilder.append("KW3909 : 'KW' '3909';\n");
+		grammarBuilder.append("KW3910 : 'KW' '3910';\n");
+		grammarBuilder.append("KW3911 : 'KW' '3911';\n");
+		grammarBuilder.append("KW3912 : 'KW' '3912';\n");
+		grammarBuilder.append("KW3913 : 'KW' '3913';\n");
+		grammarBuilder.append("KW3914 : 'KW' '3914';\n");
+		grammarBuilder.append("KW3915 : 'KW' '3915';\n");
+		grammarBuilder.append("KW3916 : 'KW' '3916';\n");
+		grammarBuilder.append("KW3917 : 'KW' '3917';\n");
+		grammarBuilder.append("KW3918 : 'KW' '3918';\n");
+		grammarBuilder.append("KW3919 : 'KW' '3919';\n");
+		grammarBuilder.append("KW3920 : 'KW' '3920';\n");
+		grammarBuilder.append("KW3921 : 'KW' '3921';\n");
+		grammarBuilder.append("KW3922 : 'KW' '3922';\n");
+		grammarBuilder.append("KW3923 : 'KW' '3923';\n");
+		grammarBuilder.append("KW3924 : 'KW' '3924';\n");
+		grammarBuilder.append("KW3925 : 'KW' '3925';\n");
+		grammarBuilder.append("KW3926 : 'KW' '3926';\n");
+		grammarBuilder.append("KW3927 : 'KW' '3927';\n");
+		grammarBuilder.append("KW3928 : 'KW' '3928';\n");
+		grammarBuilder.append("KW3929 : 'KW' '3929';\n");
+		grammarBuilder.append("KW3930 : 'KW' '3930';\n");
+		grammarBuilder.append("KW3931 : 'KW' '3931';\n");
+		grammarBuilder.append("KW3932 : 'KW' '3932';\n");
+		grammarBuilder.append("KW3933 : 'KW' '3933';\n");
+		grammarBuilder.append("KW3934 : 'KW' '3934';\n");
+		grammarBuilder.append("KW3935 : 'KW' '3935';\n");
+		grammarBuilder.append("KW3936 : 'KW' '3936';\n");
+		grammarBuilder.append("KW3937 : 'KW' '3937';\n");
+		grammarBuilder.append("KW3938 : 'KW' '3938';\n");
+		grammarBuilder.append("KW3939 : 'KW' '3939';\n");
+		grammarBuilder.append("KW3940 : 'KW' '3940';\n");
+		grammarBuilder.append("KW3941 : 'KW' '3941';\n");
+		grammarBuilder.append("KW3942 : 'KW' '3942';\n");
+		grammarBuilder.append("KW3943 : 'KW' '3943';\n");
+		grammarBuilder.append("KW3944 : 'KW' '3944';\n");
+		grammarBuilder.append("KW3945 : 'KW' '3945';\n");
+		grammarBuilder.append("KW3946 : 'KW' '3946';\n");
+		grammarBuilder.append("KW3947 : 'KW' '3947';\n");
+		grammarBuilder.append("KW3948 : 'KW' '3948';\n");
+		grammarBuilder.append("KW3949 : 'KW' '3949';\n");
+		grammarBuilder.append("KW3950 : 'KW' '3950';\n");
+		grammarBuilder.append("KW3951 : 'KW' '3951';\n");
+		grammarBuilder.append("KW3952 : 'KW' '3952';\n");
+		grammarBuilder.append("KW3953 : 'KW' '3953';\n");
+		grammarBuilder.append("KW3954 : 'KW' '3954';\n");
+		grammarBuilder.append("KW3955 : 'KW' '3955';\n");
+		grammarBuilder.append("KW3956 : 'KW' '3956';\n");
+		grammarBuilder.append("KW3957 : 'KW' '3957';\n");
+		grammarBuilder.append("KW3958 : 'KW' '3958';\n");
+		grammarBuilder.append("KW3959 : 'KW' '3959';\n");
+		grammarBuilder.append("KW3960 : 'KW' '3960';\n");
+		grammarBuilder.append("KW3961 : 'KW' '3961';\n");
+		grammarBuilder.append("KW3962 : 'KW' '3962';\n");
+		grammarBuilder.append("KW3963 : 'KW' '3963';\n");
+		grammarBuilder.append("KW3964 : 'KW' '3964';\n");
+		grammarBuilder.append("KW3965 : 'KW' '3965';\n");
+		grammarBuilder.append("KW3966 : 'KW' '3966';\n");
+		grammarBuilder.append("KW3967 : 'KW' '3967';\n");
+		grammarBuilder.append("KW3968 : 'KW' '3968';\n");
+		grammarBuilder.append("KW3969 : 'KW' '3969';\n");
+		grammarBuilder.append("KW3970 : 'KW' '3970';\n");
+		grammarBuilder.append("KW3971 : 'KW' '3971';\n");
+		grammarBuilder.append("KW3972 : 'KW' '3972';\n");
+		grammarBuilder.append("KW3973 : 'KW' '3973';\n");
+		grammarBuilder.append("KW3974 : 'KW' '3974';\n");
+		grammarBuilder.append("KW3975 : 'KW' '3975';\n");
+		grammarBuilder.append("KW3976 : 'KW' '3976';\n");
+		grammarBuilder.append("KW3977 : 'KW' '3977';\n");
+		grammarBuilder.append("KW3978 : 'KW' '3978';\n");
+		grammarBuilder.append("KW3979 : 'KW' '3979';\n");
+		grammarBuilder.append("KW3980 : 'KW' '3980';\n");
+		grammarBuilder.append("KW3981 : 'KW' '3981';\n");
+		grammarBuilder.append("KW3982 : 'KW' '3982';\n");
+		grammarBuilder.append("KW3983 : 'KW' '3983';\n");
+		grammarBuilder.append("KW3984 : 'KW' '3984';\n");
+		grammarBuilder.append("KW3985 : 'KW' '3985';\n");
+		grammarBuilder.append("KW3986 : 'KW' '3986';\n");
+		grammarBuilder.append("KW3987 : 'KW' '3987';\n");
+		grammarBuilder.append("KW3988 : 'KW' '3988';\n");
+		grammarBuilder.append("KW3989 : 'KW' '3989';\n");
+		grammarBuilder.append("KW3990 : 'KW' '3990';\n");
+		grammarBuilder.append("KW3991 : 'KW' '3991';\n");
+		grammarBuilder.append("KW3992 : 'KW' '3992';\n");
+		grammarBuilder.append("KW3993 : 'KW' '3993';\n");
+		grammarBuilder.append("KW3994 : 'KW' '3994';\n");
+		grammarBuilder.append("KW3995 : 'KW' '3995';\n");
+		grammarBuilder.append("KW3996 : 'KW' '3996';\n");
+		grammarBuilder.append("KW3997 : 'KW' '3997';\n");
+		grammarBuilder.append("KW3998 : 'KW' '3998';\n");
+		grammarBuilder.append("KW3999 : 'KW' '3999';");
+		String grammar = grammarBuilder.toString();
+
+		String input ="KW400";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:4='KW400',<402>,1:0]\n" +
+			"[@1,5:4='<EOF>',<-1>,1:5]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNonGreedyClosure() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(61);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("CMT : '//' .*? '\\n' CMT*?;\n");
+		grammarBuilder.append("WS : (' '|'\\t')+;");
+		String grammar = grammarBuilder.toString();
+
+		String input =
+			"//blah\n" +
+			"//blah\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:6='//blah\\n',<1>,1:0]\n" +
+			"[@1,7:13='//blah\\n',<1>,2:0]\n" +
+			"[@2,14:13='<EOF>',<-1>,3:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNonGreedyConfigs() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(110);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("I : .*? ('a' | 'ab') {print(self.text)} ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;\n");
+		grammarBuilder.append("J : . {print(self.text)};");
+		String grammar = grammarBuilder.toString();
+
+		String input ="ab";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"a\n" +
+			"b\n" +
+			"[@0,0:0='a',<1>,1:0]\n" +
+			"[@1,1:1='b',<3>,1:1]\n" +
+			"[@2,2:1='<EOF>',<-1>,1:2]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNonGreedyOptional() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(61);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("CMT : '//' .*? '\\n' CMT??;\n");
+		grammarBuilder.append("WS : (' '|'\\t')+;");
+		String grammar = grammarBuilder.toString();
+
+		String input =
+			"//blah\n" +
+			"//blah\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:6='//blah\\n',<1>,1:0]\n" +
+			"[@1,7:13='//blah\\n',<1>,2:0]\n" +
+			"[@2,14:13='<EOF>',<-1>,3:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNonGreedyPositiveClosure() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(59);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("CMT : ('//' .*? '\\n')+?;\n");
+		grammarBuilder.append("WS : (' '|'\\t')+;");
+		String grammar = grammarBuilder.toString();
+
+		String input =
+			"//blah\n" +
+			"//blah\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:6='//blah\\n',<1>,1:0]\n" +
+			"[@1,7:13='//blah\\n',<1>,2:0]\n" +
+			"[@2,14:13='<EOF>',<-1>,3:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNonGreedyTermination1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(47);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("STRING : '\"' ('\"\"' | .)*? '\"';");
+		String grammar = grammarBuilder.toString();
+
+		String input ="\"hi\"\"mom\"";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:3='\"hi\"',<1>,1:0]\n" +
+			"[@1,4:8='\"mom\"',<1>,1:4]\n" +
+			"[@2,9:8='<EOF>',<-1>,1:9]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNonGreedyTermination2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(47);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("STRING : '\"' ('\"\"' | .)+? '\"';");
+		String grammar = grammarBuilder.toString();
+
+		String input ="\"\"\"mom\"";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:6='\"\"\"mom\"',<1>,1:0]\n" +
+			"[@1,7:6='<EOF>',<-1>,1:7]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testParentheses() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(166);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("START_BLOCK: '-.-.-';\n");
+		grammarBuilder.append("ID : (LETTER SEPARATOR) (LETTER SEPARATOR)+;\n");
+		grammarBuilder.append("fragment LETTER: L_A|L_K;\n");
+		grammarBuilder.append("fragment L_A: '.-';\n");
+		grammarBuilder.append("fragment L_K: '-.-';\n");
+		grammarBuilder.append("SEPARATOR: '!';");
+		String grammar = grammarBuilder.toString();
+
+		String input ="-.-.-!";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:4='-.-.-',<1>,1:0]\n" +
+			"[@1,5:5='!',<3>,1:5]\n" +
+			"[@2,6:5='<EOF>',<-1>,1:6]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPositionAdjustingLexer() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(1839);
+		grammarBuilder.append("lexer grammar PositionAdjustingLexer;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("@members {\n");
+		grammarBuilder.append("def resetAcceptPosition(self, index, line, column):\n");
+		grammarBuilder.append("	self._input.seek(index)\n");
+		grammarBuilder.append("	self.line = line\n");
+		grammarBuilder.append("	self.column = column\n");
+		grammarBuilder.append("	self._interp.consume(self._input)\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("def nextToken(self):\n");
+		grammarBuilder.append("	if self._interp.__dict__.get(\"resetAcceptPosition\", None) is None:\n");
+		grammarBuilder.append("		self._interp.__dict__[\"resetAcceptPosition\"] = self.resetAcceptPosition\n");
+		grammarBuilder.append("	return super(type(self),self).nextToken()\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("def emit(self):\n");
+		grammarBuilder.append("	if self._type==PositionAdjustingLexer.TOKENS:\n");
+		grammarBuilder.append("		self.handleAcceptPositionForKeyword(\"tokens\")\n");
+		grammarBuilder.append("	elif self._type==PositionAdjustingLexer.LABEL:\n");
+		grammarBuilder.append("		self.handleAcceptPositionForIdentifier()\n");
+		grammarBuilder.append("	return super(type(self),self).emit()\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("def handleAcceptPositionForIdentifier(self):\n");
+		grammarBuilder.append("	tokenText = self.text\n");
+		grammarBuilder.append("	identifierLength = 0\n");
+		grammarBuilder.append("	while identifierLength < len(tokenText) and self.isIdentifierChar(tokenText[identifierLength]):\n");
+		grammarBuilder.append("		identifierLength += 1\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("	if self._input.index > self._tokenStartCharIndex + identifierLength:\n");
+		grammarBuilder.append("		offset = identifierLength - 1\n");
+		grammarBuilder.append("		self._interp.resetAcceptPosition(self._tokenStartCharIndex + offset,\n");
+		grammarBuilder.append("				self._tokenStartLine, self._tokenStartColumn + offset)\n");
+		grammarBuilder.append("		return True\n");
+		grammarBuilder.append("	else:\n");
+		grammarBuilder.append("		return False\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("def handleAcceptPositionForKeyword(self, keyword):\n");
+		grammarBuilder.append("	if self._input.index > self._tokenStartCharIndex + len(keyword):\n");
+		grammarBuilder.append("		offset = len(keyword) - 1\n");
+		grammarBuilder.append("		self._interp.resetAcceptPosition(self._tokenStartCharIndex + offset,\n");
+		grammarBuilder.append("			self._tokenStartLine, self._tokenStartColumn + offset)\n");
+		grammarBuilder.append("		return True\n");
+		grammarBuilder.append("	else:\n");
+		grammarBuilder.append("		return False\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("@staticmethod\n");
+		grammarBuilder.append("def isIdentifierChar(c):\n");
+		grammarBuilder.append("	return c.isalnum() or c == '_'\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("ASSIGN : '=' ;\n");
+		grammarBuilder.append("PLUS_ASSIGN : '+=' ;\n");
+		grammarBuilder.append("LCURLY:	'{';\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("// 'tokens' followed by '{'\n");
+		grammarBuilder.append("TOKENS : 'tokens' IGNORED '{';\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("// IDENTIFIER followed by '+=' or '='\n");
+		grammarBuilder.append("LABEL\n");
+		grammarBuilder.append("	:	IDENTIFIER IGNORED '+'? '='\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("IDENTIFIER\n");
+		grammarBuilder.append("	:	[a-zA-Z_] [a-zA-Z0-9_]*\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("fragment\n");
+		grammarBuilder.append("IGNORED\n");
+		grammarBuilder.append("	:	[ \\t\\r\\n]*\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("NEWLINE\n");
+		grammarBuilder.append("	:	[\\r\\n]+ -> skip\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("WS\n");
+		grammarBuilder.append("	:	[ \\t]+ -> skip\n");
+		grammarBuilder.append("	;");
+		String grammar = grammarBuilder.toString();
+
+		String input =
+			"tokens\n" +
+			"tokens {\n" +
+			"notLabel\n" +
+			"label1 =\n" +
+			"label2 +=\n" +
+			"notLabel\n";
+		String found = execLexer("PositionAdjustingLexer.g4", grammar, "PositionAdjustingLexer", input, false);
+		assertEquals(
+			"[@0,0:5='tokens',<6>,1:0]\n" +
+			"[@1,7:12='tokens',<4>,2:0]\n" +
+			"[@2,14:14='{',<3>,2:7]\n" +
+			"[@3,16:23='notLabel',<6>,3:0]\n" +
+			"[@4,25:30='label1',<5>,4:0]\n" +
+			"[@5,32:32='=',<1>,4:7]\n" +
+			"[@6,34:39='label2',<5>,5:0]\n" +
+			"[@7,41:42='+=',<2>,5:7]\n" +
+			"[@8,44:51='notLabel',<6>,6:0]\n" +
+			"[@9,53:52='<EOF>',<-1>,7:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testQuoteTranslation() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(57);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("QUOTE : '\"' ; // make sure this compiles");
+		String grammar = grammarBuilder.toString();
+
+		String input ="\"";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:0='\"',<1>,1:0]\n" +
+			"[@1,1:0='<EOF>',<-1>,1:1]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testRecursiveLexerRuleRefWithWildcardPlus_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(64);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("CMT : '/*' (CMT | .)+? '*/' ;\n");
+		grammarBuilder.append("WS : (' '|'\\n')+;");
+		String grammar = grammarBuilder.toString();
+
+		String input =
+			"/* ick */\n" +
+			"/* /* */\n" +
+			"/* /*nested*/ */\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:8='/* ick */',<1>,1:0]\n" +
+			"[@1,9:9='\\n',<2>,1:9]\n" +
+			"[@2,10:34='/* /* */\\n/* /*nested*/ */',<1>,2:0]\n" +
+			"[@3,35:35='\\n',<2>,3:16]\n" +
+			"[@4,36:35='<EOF>',<-1>,4:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testRecursiveLexerRuleRefWithWildcardPlus_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(64);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("CMT : '/*' (CMT | .)+? '*/' ;\n");
+		grammarBuilder.append("WS : (' '|'\\n')+;");
+		String grammar = grammarBuilder.toString();
+
+		String input =
+			"/* ick */x\n" +
+			"/* /* */x\n" +
+			"/* /*nested*/ */x\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:8='/* ick */',<1>,1:0]\n" +
+			"[@1,10:10='\\n',<2>,1:10]\n" +
+			"[@2,11:36='/* /* */x\\n/* /*nested*/ */',<1>,2:0]\n" +
+			"[@3,38:38='\\n',<2>,3:17]\n" +
+			"[@4,39:38='<EOF>',<-1>,4:0]\n", found);
+
+		assertEquals(
+			"line 1:9 token recognition error at: 'x'\n" +
+			"line 3:16 token recognition error at: 'x'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testRecursiveLexerRuleRefWithWildcardStar_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(64);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("CMT : '/*' (CMT | .)*? '*/' ;\n");
+		grammarBuilder.append("WS : (' '|'\\n')+;");
+		String grammar = grammarBuilder.toString();
+
+		String input =
+			"/* ick */\n" +
+			"/* /* */\n" +
+			"/* /*nested*/ */\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:8='/* ick */',<1>,1:0]\n" +
+			"[@1,9:9='\\n',<2>,1:9]\n" +
+			"[@2,10:34='/* /* */\\n/* /*nested*/ */',<1>,2:0]\n" +
+			"[@3,35:35='\\n',<2>,3:16]\n" +
+			"[@4,36:35='<EOF>',<-1>,4:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testRecursiveLexerRuleRefWithWildcardStar_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(64);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("CMT : '/*' (CMT | .)*? '*/' ;\n");
+		grammarBuilder.append("WS : (' '|'\\n')+;");
+		String grammar = grammarBuilder.toString();
+
+		String input =
+			"/* ick */x\n" +
+			"/* /* */x\n" +
+			"/* /*nested*/ */x\n";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:8='/* ick */',<1>,1:0]\n" +
+			"[@1,10:10='\\n',<2>,1:10]\n" +
+			"[@2,11:36='/* /* */x\\n/* /*nested*/ */',<1>,2:0]\n" +
+			"[@3,38:38='\\n',<2>,3:17]\n" +
+			"[@4,39:38='<EOF>',<-1>,4:0]\n", found);
+
+		assertEquals(
+			"line 1:9 token recognition error at: 'x'\n" +
+			"line 3:16 token recognition error at: 'x'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testRefToRuleDoesNotSetTokenNorEmitAnother() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(70);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("A : '-' I ;\n");
+		grammarBuilder.append("I : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="34 -21 3";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:1='34',<2>,1:0]\n" +
+			"[@1,3:5='-21',<1>,1:3]\n" +
+			"[@2,7:7='3',<2>,1:7]\n" +
+			"[@3,8:7='<EOF>',<-1>,1:8]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSlashes() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(95);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("Backslash : '\\\\';\n");
+		grammarBuilder.append("Slash : '/';\n");
+		grammarBuilder.append("Vee : '\\\\/';\n");
+		grammarBuilder.append("Wedge : '/\\\\';\n");
+		grammarBuilder.append("WS : [ \\t] -> skip;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="\\ / \\/ /\\";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:0='\\',<1>,1:0]\n" +
+			"[@1,2:2='/',<2>,1:2]\n" +
+			"[@2,4:5='\\/',<3>,1:4]\n" +
+			"[@3,7:8='/\\',<4>,1:7]\n" +
+			"[@4,9:8='<EOF>',<-1>,1:9]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testZeroLengthToken() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(215);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("BeginString\n");
+		grammarBuilder.append("	:	'\\'' -> more, pushMode(StringMode)\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("mode StringMode;\n");
+		grammarBuilder.append("	StringMode_X : 'x' -> more;\n");
+		grammarBuilder.append("	StringMode_Done : -> more, mode(EndStringMode);\n");
+		grammarBuilder.append("mode EndStringMode;	\n");
+		grammarBuilder.append("	EndString : '\\'' -> popMode;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="'xxx'";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"[@0,0:4=''xxx'',<1>,1:0]\n" +
+			"[@1,5:4='<EOF>',<-1>,1:5]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+
+}
\ No newline at end of file
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/python3/TestListeners.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/python3/TestListeners.java
new file mode 100644
index 000000000..710d0a017
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/python3/TestListeners.java
@@ -0,0 +1,405 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.python3;
+
+import org.junit.Ignore;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+@SuppressWarnings("unused")
+public class TestListeners extends BasePython3Test {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testBasic() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(588);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@parser::header {\n");
+		grammarBuilder.append("class MockListener:\n");
+		grammarBuilder.append("    pass\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("@parser::members {\n");
+		grammarBuilder.append("class LeafListener(MockListener):\n");
+		grammarBuilder.append("    def visitTerminal(self, node):\n");
+		grammarBuilder.append("        print(node.symbol.text)\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("print($ctx.r.toStringTree(recog=self))\n");
+		grammarBuilder.append("if __name__ is not None and \".\" in __name__:\n");
+		grammarBuilder.append("    from .TListener import TListener\n");
+		grammarBuilder.append("else:\n");
+		grammarBuilder.append("    from TListener import TListener\n");
+		grammarBuilder.append("TParser.LeafListener.__bases__ = (TListener,)\n");
+		grammarBuilder.append("walker = ParseTreeWalker()\n");
+		grammarBuilder.append("walker.walk(TParser.LeafListener(), $ctx.r)\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : INT INT\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("MULT: '*' ;\n");
+		grammarBuilder.append("ADD : '+' ;\n");
+		grammarBuilder.append("INT : [0-9]+ ;\n");
+		grammarBuilder.append("ID  : [a-z]+ ;\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="1 2";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals(
+			"(a 1 2)\n" +
+			"1\n" +
+			"2\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLR() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(749);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@parser::header {\n");
+		grammarBuilder.append("class MockListener:\n");
+		grammarBuilder.append("    pass\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("@parser::members {\n");
+		grammarBuilder.append("class LeafListener(MockListener):\n");
+		grammarBuilder.append("    def exitE(self, ctx):\n");
+		grammarBuilder.append("        if ctx.getChildCount()==3:\n");
+		grammarBuilder.append("            print(ctx.e(0).start.text + ' ' + ctx.e(1).start.text + ' ' + ctx.e()[0].start.text)\n");
+		grammarBuilder.append("        else:\n");
+		grammarBuilder.append("            print(ctx.INT().symbol.text)\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("print($ctx.r.toStringTree(recog=self))\n");
+		grammarBuilder.append("if __name__ is not None and \".\" in __name__:\n");
+		grammarBuilder.append("    from .TListener import TListener\n");
+		grammarBuilder.append("else:\n");
+		grammarBuilder.append("    from TListener import TListener\n");
+		grammarBuilder.append("TParser.LeafListener.__bases__ = (TListener,)\n");
+		grammarBuilder.append("walker = ParseTreeWalker()\n");
+		grammarBuilder.append("walker.walk(TParser.LeafListener(), $ctx.r)\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("	: r=e ;\n");
+		grammarBuilder.append("e : e op='*' e\n");
+		grammarBuilder.append("	| e op='+' e\n");
+		grammarBuilder.append("	| INT\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("MULT: '*' ;\n");
+		grammarBuilder.append("ADD : '+' ;\n");
+		grammarBuilder.append("INT : [0-9]+ ;\n");
+		grammarBuilder.append("ID  : [a-z]+ ;\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="1+2*3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals(
+			"(e (e 1) + (e (e 2) * (e 3)))\n" +
+			"1\n" +
+			"2\n" +
+			"3\n" +
+			"2 3 2\n" +
+			"1 2 1\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLRWithLabels() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(729);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@parser::header {\n");
+		grammarBuilder.append("class MockListener:\n");
+		grammarBuilder.append("    pass\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("@parser::members {\n");
+		grammarBuilder.append("class LeafListener(MockListener):\n");
+		grammarBuilder.append("    def exitCall(self, ctx):\n");
+		grammarBuilder.append("        print(ctx.e().start.text + ' ' + str(ctx.eList()))\n");
+		grammarBuilder.append("    def exitInt(self, ctx):\n");
+		grammarBuilder.append("        print(ctx.INT().symbol.text)\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("print($ctx.r.toStringTree(recog=self))\n");
+		grammarBuilder.append("if __name__ is not None and \".\" in __name__:\n");
+		grammarBuilder.append("    from .TListener import TListener\n");
+		grammarBuilder.append("else:\n");
+		grammarBuilder.append("    from TListener import TListener\n");
+		grammarBuilder.append("TParser.LeafListener.__bases__ = (TListener,)\n");
+		grammarBuilder.append("walker = ParseTreeWalker()\n");
+		grammarBuilder.append("walker.walk(TParser.LeafListener(), $ctx.r)\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=e ;\n");
+		grammarBuilder.append("e : e '(' eList ')' # Call\n");
+		grammarBuilder.append("  | INT             # Int\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("eList : e (',' e)* ;\n");
+		grammarBuilder.append("MULT: '*' ;\n");
+		grammarBuilder.append("ADD : '+' ;\n");
+		grammarBuilder.append("INT : [0-9]+ ;\n");
+		grammarBuilder.append("ID  : [a-z]+ ;\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="1(2,3)";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals(
+			"(e (e 1) ( (eList (e 2) , (e 3)) ))\n" +
+			"1\n" +
+			"2\n" +
+			"3\n" +
+			"1 [13 6]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testRuleGetters_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(774);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@parser::header {\n");
+		grammarBuilder.append("class MockListener:\n");
+		grammarBuilder.append("    pass\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("@parser::members {\n");
+		grammarBuilder.append("class LeafListener(MockListener):\n");
+		grammarBuilder.append("    def exitA(self, ctx):\n");
+		grammarBuilder.append("        if ctx.getChildCount()==2:\n");
+		grammarBuilder.append("            print(ctx.b(0).start.text + ' ' + ctx.b(1).start.text + ' ' + ctx.b()[0].start.text)\n");
+		grammarBuilder.append("        else:\n");
+		grammarBuilder.append("            print(ctx.b(0).start.text)\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("print($ctx.r.toStringTree(recog=self))\n");
+		grammarBuilder.append("if __name__ is not None and \".\" in __name__:\n");
+		grammarBuilder.append("    from .TListener import TListener\n");
+		grammarBuilder.append("else:\n");
+		grammarBuilder.append("    from TListener import TListener\n");
+		grammarBuilder.append("TParser.LeafListener.__bases__ = (TListener,)\n");
+		grammarBuilder.append("walker = ParseTreeWalker()\n");
+		grammarBuilder.append("walker.walk(TParser.LeafListener(), $ctx.r)\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : b b		// forces list\n");
+		grammarBuilder.append("  | b		// a list still\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("b : ID | INT;\n");
+		grammarBuilder.append("MULT: '*' ;\n");
+		grammarBuilder.append("ADD : '+' ;\n");
+		grammarBuilder.append("INT : [0-9]+ ;\n");
+		grammarBuilder.append("ID  : [a-z]+ ;\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="1 2";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals(
+			"(a (b 1) (b 2))\n" +
+			"1 2 1\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testRuleGetters_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(774);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@parser::header {\n");
+		grammarBuilder.append("class MockListener:\n");
+		grammarBuilder.append("    pass\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("@parser::members {\n");
+		grammarBuilder.append("class LeafListener(MockListener):\n");
+		grammarBuilder.append("    def exitA(self, ctx):\n");
+		grammarBuilder.append("        if ctx.getChildCount()==2:\n");
+		grammarBuilder.append("            print(ctx.b(0).start.text + ' ' + ctx.b(1).start.text + ' ' + ctx.b()[0].start.text)\n");
+		grammarBuilder.append("        else:\n");
+		grammarBuilder.append("            print(ctx.b(0).start.text)\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("print($ctx.r.toStringTree(recog=self))\n");
+		grammarBuilder.append("if __name__ is not None and \".\" in __name__:\n");
+		grammarBuilder.append("    from .TListener import TListener\n");
+		grammarBuilder.append("else:\n");
+		grammarBuilder.append("    from TListener import TListener\n");
+		grammarBuilder.append("TParser.LeafListener.__bases__ = (TListener,)\n");
+		grammarBuilder.append("walker = ParseTreeWalker()\n");
+		grammarBuilder.append("walker.walk(TParser.LeafListener(), $ctx.r)\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : b b		// forces list\n");
+		grammarBuilder.append("  | b		// a list still\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("b : ID | INT;\n");
+		grammarBuilder.append("MULT: '*' ;\n");
+		grammarBuilder.append("ADD : '+' ;\n");
+		grammarBuilder.append("INT : [0-9]+ ;\n");
+		grammarBuilder.append("ID  : [a-z]+ ;\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="abc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals(
+			"(a (b abc))\n" +
+			"abc\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTokenGetters_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(737);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@parser::header {\n");
+		grammarBuilder.append("class MockListener:\n");
+		grammarBuilder.append("    pass\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("@parser::members {\n");
+		grammarBuilder.append("class LeafListener(MockListener):\n");
+		grammarBuilder.append("    def exitA(self, ctx):\n");
+		grammarBuilder.append("        if ctx.getChildCount()==2:\n");
+		grammarBuilder.append("            print(ctx.INT(0).symbol.text + ' ' + ctx.INT(1).symbol.text + ' ' + str_list(ctx.INT()))\n");
+		grammarBuilder.append("        else:\n");
+		grammarBuilder.append("            print(str(ctx.ID().symbol))\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("print($ctx.r.toStringTree(recog=self))\n");
+		grammarBuilder.append("if __name__ is not None and \".\" in __name__:\n");
+		grammarBuilder.append("    from .TListener import TListener\n");
+		grammarBuilder.append("else:\n");
+		grammarBuilder.append("    from TListener import TListener\n");
+		grammarBuilder.append("TParser.LeafListener.__bases__ = (TListener,)\n");
+		grammarBuilder.append("walker = ParseTreeWalker()\n");
+		grammarBuilder.append("walker.walk(TParser.LeafListener(), $ctx.r)\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : INT INT\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("MULT: '*' ;\n");
+		grammarBuilder.append("ADD : '+' ;\n");
+		grammarBuilder.append("INT : [0-9]+ ;\n");
+		grammarBuilder.append("ID  : [a-z]+ ;\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="1 2";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals(
+			"(a 1 2)\n" +
+			"1 2 [1, 2]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTokenGetters_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(737);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@parser::header {\n");
+		grammarBuilder.append("class MockListener:\n");
+		grammarBuilder.append("    pass\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("@parser::members {\n");
+		grammarBuilder.append("class LeafListener(MockListener):\n");
+		grammarBuilder.append("    def exitA(self, ctx):\n");
+		grammarBuilder.append("        if ctx.getChildCount()==2:\n");
+		grammarBuilder.append("            print(ctx.INT(0).symbol.text + ' ' + ctx.INT(1).symbol.text + ' ' + str_list(ctx.INT()))\n");
+		grammarBuilder.append("        else:\n");
+		grammarBuilder.append("            print(str(ctx.ID().symbol))\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("print($ctx.r.toStringTree(recog=self))\n");
+		grammarBuilder.append("if __name__ is not None and \".\" in __name__:\n");
+		grammarBuilder.append("    from .TListener import TListener\n");
+		grammarBuilder.append("else:\n");
+		grammarBuilder.append("    from TListener import TListener\n");
+		grammarBuilder.append("TParser.LeafListener.__bases__ = (TListener,)\n");
+		grammarBuilder.append("walker = ParseTreeWalker()\n");
+		grammarBuilder.append("walker.walk(TParser.LeafListener(), $ctx.r)\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : INT INT\n");
+		grammarBuilder.append("  | ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("MULT: '*' ;\n");
+		grammarBuilder.append("ADD : '+' ;\n");
+		grammarBuilder.append("INT : [0-9]+ ;\n");
+		grammarBuilder.append("ID  : [a-z]+ ;\n");
+		grammarBuilder.append("WS : [ \\t\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="abc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals(
+			"(a abc)\n" +
+			"[@0,0:2='abc',<4>,1:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+
+}
\ No newline at end of file
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/python3/TestParseTrees.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/python3/TestParseTrees.java
new file mode 100644
index 000000000..5d1b0da2d
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/python3/TestParseTrees.java
@@ -0,0 +1,301 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.python3;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
+@SuppressWarnings("unused")
+public class TestParseTrees extends BasePython3Test {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void test2AltLoop() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(136);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {\n");
+		grammarBuilder.append("self._buildParseTrees = True\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("print($r.ctx.toStringTree(recog=self))\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : ('x' | 'y')* 'z'\n");
+		grammarBuilder.append("  ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="xyyxyxz";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(a x y y x y x z)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void test2Alts() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(129);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {\n");
+		grammarBuilder.append("self._buildParseTrees = True\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("print($r.ctx.toStringTree(recog=self))\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : 'x' | 'y'\n");
+		grammarBuilder.append("  ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="y";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(a y)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAltNum() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(584);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("options { contextSuperClass=MyRuleNode; }\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("@parser::members {\n");
+		grammarBuilder.append("class MyRuleNode(ParserRuleContext):\n");
+		grammarBuilder.append("    def __init__(self, parent:ParserRuleContext = None, invokingStateNumber:int = None ):\n");
+		grammarBuilder.append("        super(TParser.MyRuleNode, self).__init__(parent, invokingStateNumber)\n");
+		grammarBuilder.append("        self.altNum = 0;\n");
+		grammarBuilder.append("    def getAltNumber(self):\n");
+		grammarBuilder.append("        return self.altNum\n");
+		grammarBuilder.append("    def setAltNumber(self, altNum):\n");
+		grammarBuilder.append("        self.altNum = altNum\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {\n");
+		grammarBuilder.append("self._buildParseTrees = True\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("print($r.ctx.toStringTree(recog=self))\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("a : 'f'\n");
+		grammarBuilder.append("  | 'g'\n");
+		grammarBuilder.append("  | 'x' b 'z'\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("b : 'e' {} | 'y'\n");
+		grammarBuilder.append("  ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="xyz";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(a:3 x (b:2 y) z)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExtraToken() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(142);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {\n");
+		grammarBuilder.append("self._buildParseTrees = True\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("print($r.ctx.toStringTree(recog=self))\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : 'x' 'y'\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("Z : 'z' \n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append(" ");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="xzy";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(a x z y)\n", found);
+
+		assertEquals("line 1:1 extraneous input 'z' expecting 'y'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNoViableAlt() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(144);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {\n");
+		grammarBuilder.append("self._buildParseTrees = True\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("print($r.ctx.toStringTree(recog=self))\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : 'x' | 'y'\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("Z : 'z' \n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append(" ");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="z";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(a z)\n", found);
+
+		assertEquals("line 1:0 mismatched input 'z' expecting {'x', 'y'}\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testRuleRef() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(138);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {\n");
+		grammarBuilder.append("self._buildParseTrees = True\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("print($r.ctx.toStringTree(recog=self))\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : b 'x'\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("b : 'y' \n");
+		grammarBuilder.append("  ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="yx";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(a (b y) x)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSync() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(145);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {\n");
+		grammarBuilder.append("self._buildParseTrees = True\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("print($r.ctx.toStringTree(recog=self))\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : 'x' 'y'* '!'\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("Z : 'z' \n");
+		grammarBuilder.append("  ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="xzyy!";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(a x z y y !)\n", found);
+
+		assertEquals("line 1:1 extraneous input 'z' expecting {'y', '!'}\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testToken2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(127);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {\n");
+		grammarBuilder.append("self._buildParseTrees = True\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("print($r.ctx.toStringTree(recog=self))\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : 'x' 'y'\n");
+		grammarBuilder.append("  ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="xy";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("(a x y)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTokenAndRuleContextString() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(173);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s\n");
+		grammarBuilder.append("@init {\n");
+		grammarBuilder.append("self._buildParseTrees = True\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("print($r.ctx.toStringTree(recog=self))\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  : r=a ;\n");
+		grammarBuilder.append("a : 'x' { \n");
+		grammarBuilder.append("print(str_list(self.getRuleInvocationStack()))\n");
+		grammarBuilder.append("} ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals(
+			"[a, s]\n" +
+			"(a x)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+
+}
\ No newline at end of file
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/python3/TestParserErrors.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/python3/TestParserErrors.java
new file mode 100644
index 000000000..be494441b
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/python3/TestParserErrors.java
@@ -0,0 +1,718 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.python3;
+
+import org.junit.Ignore;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+@SuppressWarnings("unused")
+public class TestParserErrors extends BasePython3Test {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testConjuringUpToken() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(61);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' x='b' {print(\"conjured=\" + str($x))} 'c' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="ac";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("conjured=[@-1,-1:-1='<missing 'b'>',<2>,1:1]\n", found);
+
+		assertEquals("line 1:1 missing 'b' at 'c'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testConjuringUpTokenFromSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(67);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' x=('b'|'c') {print(\"conjured=\" + str($x))} 'd' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="ad";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("conjured=[@-1,-1:-1='<missing 'b'>',<2>,1:1]\n", found);
+
+		assertEquals("line 1:1 missing {'b', 'c'} at 'd'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testContextListGetters() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(160);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@parser::members{\n");
+		grammarBuilder.append("def foo():\n");
+		grammarBuilder.append("    s = SContext()\n");
+		grammarBuilder.append("    a = s.a()\n");
+		grammarBuilder.append("    b = s.b()\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("s : (a | b)+;\n");
+		grammarBuilder.append("a : 'a' {print('a',end='')};\n");
+		grammarBuilder.append("b : 'b' {print('b',end='')};");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="abab";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, true);
+
+		assertEquals("abab\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDuplicatedLeftRecursiveCall_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(63);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : expr EOF;\n");
+		grammarBuilder.append("expr : 'x'\n");
+		grammarBuilder.append("     | expr expr\n");
+		grammarBuilder.append("     ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "start", input, true);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDuplicatedLeftRecursiveCall_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(63);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : expr EOF;\n");
+		grammarBuilder.append("expr : 'x'\n");
+		grammarBuilder.append("     | expr expr\n");
+		grammarBuilder.append("     ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="xx";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "start", input, true);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDuplicatedLeftRecursiveCall_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(63);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : expr EOF;\n");
+		grammarBuilder.append("expr : 'x'\n");
+		grammarBuilder.append("     | expr expr\n");
+		grammarBuilder.append("     ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="xxx";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "start", input, true);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDuplicatedLeftRecursiveCall_4() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(63);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : expr EOF;\n");
+		grammarBuilder.append("expr : 'x'\n");
+		grammarBuilder.append("     | expr expr\n");
+		grammarBuilder.append("     ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="xxxx";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "start", input, true);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testInvalidATNStateRemoval() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(102);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : ID ':' expr;\n");
+		grammarBuilder.append("expr : primary expr? {pass} | expr '->' ID;\n");
+		grammarBuilder.append("primary : ID;\n");
+		grammarBuilder.append("ID : [a-z]+;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x:x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "start", input, false);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testInvalidEmptyInput() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(36);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : ID+;\n");
+		grammarBuilder.append("ID : [a-z]+;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "start", input, true);
+
+		assertEquals("", found);
+
+		assertEquals("line 1:0 missing ID at '<EOF>'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLL1ErrorInfo() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(314);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : animal (AND acClass)? service EOF;\n");
+		grammarBuilder.append("animal : (DOG | CAT );\n");
+		grammarBuilder.append("service : (HARDWARE | SOFTWARE) ;\n");
+		grammarBuilder.append("AND : 'and';\n");
+		grammarBuilder.append("DOG : 'dog';\n");
+		grammarBuilder.append("CAT : 'cat';\n");
+		grammarBuilder.append("HARDWARE: 'hardware';\n");
+		grammarBuilder.append("SOFTWARE: 'software';\n");
+		grammarBuilder.append("WS : ' ' -> skip ;\n");
+		grammarBuilder.append("acClass\n");
+		grammarBuilder.append("@init\n");
+		grammarBuilder.append("{print(self.getExpectedTokens().toString(self.literalNames, self.symbolicNames))}\n");
+		grammarBuilder.append("  : ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="dog and software";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "start", input, false);
+
+		assertEquals("{'hardware', 'software'}\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLL2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(46);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' 'b'\n");
+		grammarBuilder.append("  | 'a' 'c'\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("q : 'e' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="ae";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("", found);
+
+		assertEquals("line 1:1 no viable alternative at input 'ae'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLL3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(55);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' 'b'* 'c'\n");
+		grammarBuilder.append("  | 'a' 'b' 'd'\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("q : 'e' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="abe";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("", found);
+
+		assertEquals("line 1:2 no viable alternative at input 'abe'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLLStar() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(48);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a'+ 'b'\n");
+		grammarBuilder.append("  | 'a'+ 'c'\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("q : 'e' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="aaae";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("", found);
+
+		assertEquals("line 1:3 no viable alternative at input 'aaae'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultiTokenDeletionBeforeLoop() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(28);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' 'b'* 'c';");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="aacabc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("", found);
+
+		assertEquals("line 1:1 extraneous input 'a' expecting {'b', 'c'}\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultiTokenDeletionBeforeLoop2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(40);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' ('b'|'z'{pass})* 'c';");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="aacabc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("", found);
+
+		assertEquals("line 1:1 extraneous input 'a' expecting {'b', 'z', 'c'}\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultiTokenDeletionDuringLoop() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(29);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' 'b'* 'c' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="abaaababc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("", found);
+
+		assertEquals(
+			"line 1:2 extraneous input 'a' expecting {'b', 'c'}\n" +
+			"line 1:6 extraneous input 'a' expecting {'b', 'c'}\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultiTokenDeletionDuringLoop2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(41);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' ('b'|'z'{pass})* 'c' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="abaaababc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("", found);
+
+		assertEquals(
+			"line 1:2 extraneous input 'a' expecting {'b', 'z', 'c'}\n" +
+			"line 1:6 extraneous input 'a' expecting {'b', 'z', 'c'}\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNoViableAltAvoidance() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(83);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : e '!' ;\n");
+		grammarBuilder.append("e : 'a' 'b'\n");
+		grammarBuilder.append("  | 'a'\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("DOT : '.' ;\n");
+		grammarBuilder.append("WS : [ \\t\\r\\n]+ -> skip;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a.";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("", found);
+
+		assertEquals("line 1:1 mismatched input '.' expecting '!'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleSetInsertion() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(34);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' ('b'|'c') 'd' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="ad";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("", found);
+
+		assertEquals("line 1:1 missing {'b', 'c'} at 'd'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleSetInsertionConsumption() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(80);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("myset: ('b'|'c') ;\n");
+		grammarBuilder.append("a: 'a' myset 'd' {print(\"\" + str($myset.stop))} ; ");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="ad";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("[@0,0:0='a',<3>,1:0]\n", found);
+
+		assertEquals("line 1:1 missing {'b', 'c'} at 'd'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleTokenDeletion() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(24);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' 'b' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="aab";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("", found);
+
+		assertEquals("line 1:1 extraneous input 'a' expecting 'b'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleTokenDeletionBeforeAlt() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(38);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : ('b' | 'c')\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("q : 'a'\n");
+		grammarBuilder.append(";");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="ac";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("", found);
+
+		assertEquals("line 1:0 extraneous input 'a' expecting {'b', 'c'}\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleTokenDeletionBeforeLoop() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(25);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' 'b'* ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="aabc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("", found);
+
+		assertEquals(
+			"line 1:1 extraneous input 'a' expecting {<EOF>, 'b'}\n" +
+			"line 1:3 token recognition error at: 'c'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleTokenDeletionBeforeLoop2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(36);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' ('b'|'z'{pass})*;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="aabc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("", found);
+
+		assertEquals(
+			"line 1:1 extraneous input 'a' expecting {<EOF>, 'b', 'z'}\n" +
+			"line 1:3 token recognition error at: 'c'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleTokenDeletionBeforePredict() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(48);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a'+ 'b'\n");
+		grammarBuilder.append("  | 'a'+ 'c'\n");
+		grammarBuilder.append(";\n");
+		grammarBuilder.append("q : 'e' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="caaab";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("", found);
+
+		assertEquals("line 1:0 extraneous input 'c' expecting 'a'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleTokenDeletionConsumption() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(80);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("myset: ('b'|'c') ;\n");
+		grammarBuilder.append("a: 'a' myset 'd' {print(\"\" + str($myset.stop))} ; ");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="aabd";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("[@2,2:2='b',<1>,1:2]\n", found);
+
+		assertEquals("line 1:1 extraneous input 'a' expecting {'b', 'c'}\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleTokenDeletionDuringLoop() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(29);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' 'b'* 'c' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="ababbc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("", found);
+
+		assertEquals("line 1:2 extraneous input 'a' expecting {'b', 'c'}\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleTokenDeletionDuringLoop2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(41);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' ('b'|'z'{pass})* 'c' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="ababbc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("", found);
+
+		assertEquals("line 1:2 extraneous input 'a' expecting {'b', 'z', 'c'}\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleTokenDeletionExpectingSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(30);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' ('b'|'c') ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="aab";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("", found);
+
+		assertEquals("line 1:1 extraneous input 'a' expecting {'b', 'c'}\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSingleTokenInsertion() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(28);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' 'b' 'c' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="ac";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("", found);
+
+		assertEquals("line 1:1 missing 'b' at 'c'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTokenMismatch() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(24);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : 'a' 'b' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="aa";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("", found);
+
+		assertEquals("line 1:1 mismatched input 'a' expecting 'b'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testTokenMismatch2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(165);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("stat:   ( '(' expr? ')' )? EOF ;\n");
+		grammarBuilder.append("expr:   ID '=' STR ;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("ERR :   '~FORCE_ERROR~' ;\n");
+		grammarBuilder.append("ID  :   [a-zA-Z]+ ;\n");
+		grammarBuilder.append("STR :   '\"' ~[\"]* '\"' ;\n");
+		grammarBuilder.append("WS  :   [ \\t\\r\\n]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="( ~FORCE_ERROR~ ";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "stat", input, false);
+
+		assertEquals("", found);
+
+		assertEquals("line 1:2 mismatched input '~FORCE_ERROR~' expecting ')'\n", this.stderrDuringParse);
+
+	}
+
+
+}
\ No newline at end of file
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/python3/TestParserExec.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/python3/TestParserExec.java
new file mode 100644
index 000000000..5242e41fe
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/python3/TestParserExec.java
@@ -0,0 +1,790 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.python3;
+
+import org.junit.Ignore;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+@SuppressWarnings("unused")
+public class TestParserExec extends BasePython3Test {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAPlus() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(77);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : ID+ {\n");
+		grammarBuilder.append("print($text)\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a b c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("abc\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAStar_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(77);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : ID* {\n");
+		grammarBuilder.append("print($text)\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAStar_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(77);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : ID* {\n");
+		grammarBuilder.append("print($text)\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a b c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("abc\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAorAPlus() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(82);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (ID|ID)+ {\n");
+		grammarBuilder.append("print($text)\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a b c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("abc\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAorAStar_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(82);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (ID|ID)* {\n");
+		grammarBuilder.append("print($text)\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAorAStar_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(82);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (ID|ID)* {\n");
+		grammarBuilder.append("print($text)\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a b c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("abc\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAorB() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(122);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : ID {\n");
+		grammarBuilder.append("print(\"alt 1\")\n");
+		grammarBuilder.append("} | INT {\n");
+		grammarBuilder.append("print(\"alt 2\")\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="34";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("alt 2\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAorBPlus() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(105);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (ID|INT{\n");
+		grammarBuilder.append("})+ {\n");
+		grammarBuilder.append("print($text)\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a 34 c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("a34c\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAorBStar_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(105);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (ID|INT{\n");
+		grammarBuilder.append("})* {\n");
+		grammarBuilder.append("print($text)\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAorBStar_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(105);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (ID|INT{\n");
+		grammarBuilder.append("})* {\n");
+		grammarBuilder.append("print($text)\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a 34 c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("a34c\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testBasic() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(98);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : ID INT {\n");
+		grammarBuilder.append("print($text)\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="abc 34";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("abc34\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testEOFInClosure() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(53);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("prog : stat EOF;\n");
+		grammarBuilder.append("stat : 'x' ('y' | EOF)*?;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "prog", input, false);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testIfIfElseGreedyBinding1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(186);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : statement+ ;\n");
+		grammarBuilder.append("statement : 'x' | ifStatement;\n");
+		grammarBuilder.append("ifStatement : 'if' 'y' statement ('else' statement)? {\n");
+		grammarBuilder.append("print($text)\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> channel(HIDDEN);");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="if y if y x else x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "start", input, false);
+
+		assertEquals(
+			"if y x else x\n" +
+			"if y if y x else x\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testIfIfElseGreedyBinding2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(186);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : statement+ ;\n");
+		grammarBuilder.append("statement : 'x' | ifStatement;\n");
+		grammarBuilder.append("ifStatement : 'if' 'y' statement ('else' statement|) {\n");
+		grammarBuilder.append("print($text)\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> channel(HIDDEN);");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="if y if y x else x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "start", input, false);
+
+		assertEquals(
+			"if y x else x\n" +
+			"if y if y x else x\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testIfIfElseNonGreedyBinding1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(187);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : statement+ ;\n");
+		grammarBuilder.append("statement : 'x' | ifStatement;\n");
+		grammarBuilder.append("ifStatement : 'if' 'y' statement ('else' statement)?? {\n");
+		grammarBuilder.append("print($text)\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> channel(HIDDEN);");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="if y if y x else x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "start", input, false);
+
+		assertEquals(
+			"if y x\n" +
+			"if y if y x else x\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testIfIfElseNonGreedyBinding2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(186);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : statement+ ;\n");
+		grammarBuilder.append("statement : 'x' | ifStatement;\n");
+		grammarBuilder.append("ifStatement : 'if' 'y' statement (|'else' statement) {\n");
+		grammarBuilder.append("print($text)\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> channel(HIDDEN);");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="if y if y x else x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "start", input, false);
+
+		assertEquals(
+			"if y x\n" +
+			"if y if y x else x\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLL1OptionalBlock_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(103);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (ID|{}INT)? {\n");
+		grammarBuilder.append("print($text)\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLL1OptionalBlock_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(103);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (ID|{}INT)? {\n");
+		grammarBuilder.append("print($text)\n");
+		grammarBuilder.append("};\n");
+		grammarBuilder.append("ID : 'a'..'z'+;\n");
+		grammarBuilder.append("INT : '0'..'9'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("a\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLabelAliasingAcrossLabeledAlternatives() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(157);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : a* EOF;\n");
+		grammarBuilder.append("a\n");
+		grammarBuilder.append("  : label=subrule {print($label.text)} #One\n");
+		grammarBuilder.append("  | label='y' {print($label.text)} #Two\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("subrule : 'x';\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="xy";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "start", input, false);
+
+		assertEquals(
+			"x\n" +
+			"y\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLabels() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(118);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : b1=b b2+=b* b3+=';' ;\n");
+		grammarBuilder.append("b : id_=ID val+=INT*;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="abc 34;";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testListLabelForClosureContext() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(456);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("ifStatement\n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("assert isinstance(v, (list, tuple))\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("    : 'if' expression\n");
+		grammarBuilder.append("      ( ( 'then'\n");
+		grammarBuilder.append("          executableStatement*\n");
+		grammarBuilder.append("          elseIfStatement*  // <--- problem is here; should yield a list not node\n");
+		grammarBuilder.append("          elseStatement?\n");
+		grammarBuilder.append("          'end' 'if'\n");
+		grammarBuilder.append("        ) | executableStatement )\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("elseIfStatement\n");
+		grammarBuilder.append("    : 'else' 'if' expression 'then' executableStatement*\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("expression : 'a' ;\n");
+		grammarBuilder.append("executableStatement : 'a' ;\n");
+		grammarBuilder.append("elseStatement : 'a' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "expression", input, false);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testListLabelsOnSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(140);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : b b* ';' ;\n");
+		grammarBuilder.append("b : ID val+=(INT | FLOAT)*;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("FLOAT : [0-9]+ '.' [0-9]+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="abc 34;";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testMultipleEOFHandling() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(42);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("prog : ('x' | 'x' 'y') EOF EOF;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "prog", input, false);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testOptional_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(90);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("stat : ifstat | 'x';\n");
+		grammarBuilder.append("ifstat : 'if' stat ('else' stat)?;\n");
+		grammarBuilder.append("WS : [ \\n\\t]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "stat", input, false);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testOptional_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(90);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("stat : ifstat | 'x';\n");
+		grammarBuilder.append("ifstat : 'if' stat ('else' stat)?;\n");
+		grammarBuilder.append("WS : [ \\n\\t]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="if x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "stat", input, false);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testOptional_3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(90);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("stat : ifstat | 'x';\n");
+		grammarBuilder.append("ifstat : 'if' stat ('else' stat)?;\n");
+		grammarBuilder.append("WS : [ \\n\\t]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="if x else x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "stat", input, false);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testOptional_4() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(90);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("stat : ifstat | 'x';\n");
+		grammarBuilder.append("ifstat : 'if' stat ('else' stat)?;\n");
+		grammarBuilder.append("WS : [ \\n\\t]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="if if x else x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "stat", input, false);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testParserProperty() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(153);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@members {\n");
+		grammarBuilder.append("def Property(self):\n");
+		grammarBuilder.append("    return True\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("a : {$parser.Property()}? ID {print(\"valid\")}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="abc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("valid\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPredicatedIfIfElse() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(175);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : stmt EOF ;\n");
+		grammarBuilder.append("stmt : ifStmt | ID;\n");
+		grammarBuilder.append("ifStmt : 'if' ID stmt ('else' stmt | { self._input.LA(1)!=TParser.ELSE }?);\n");
+		grammarBuilder.append("ELSE : 'else';\n");
+		grammarBuilder.append("ID : [a-zA-Z]+;\n");
+		grammarBuilder.append("WS : [ \\n\\t]+ -> skip;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="if x if x a else b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, true);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPredictionIssue334() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(244);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("file_ @init{\n");
+		grammarBuilder.append("self._errHandler = BailErrorStrategy()\n");
+		grammarBuilder.append("} \n");
+		grammarBuilder.append("@after {\n");
+		grammarBuilder.append("print($ctx.toStringTree(recog=self))\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("  :   item (SEMICOLON item)* SEMICOLON? EOF ;\n");
+		grammarBuilder.append("item : A B?;\n");
+		grammarBuilder.append("SEMICOLON: ';';\n");
+		grammarBuilder.append("A : 'a'|'A';\n");
+		grammarBuilder.append("B : 'b'|'B';\n");
+		grammarBuilder.append("WS      : [ \\r\\t\\n]+ -> skip;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "file_", input, false);
+
+		assertEquals("(file_ (item a) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReferenceToATN_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(106);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (ID|ATN)* ATN? {print($text)} ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("ATN : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testReferenceToATN_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(106);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (ID|ATN)* ATN? {print($text)} ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("ATN : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a 34 c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("a34c\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+
+}
\ No newline at end of file
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/python3/TestPerformance.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/python3/TestPerformance.java
new file mode 100644
index 000000000..adce8dcad
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/python3/TestPerformance.java
@@ -0,0 +1,217 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.python3;
+
+import org.junit.Ignore;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+@SuppressWarnings("unused")
+public class TestPerformance extends BasePython3Test {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExpressionGrammar_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(164);
+		grammarBuilder.append("grammar Expr;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("program: expr EOF;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("expr\n");
+		grammarBuilder.append("	: ID\n");
+		grammarBuilder.append("	| 'not' expr\n");
+		grammarBuilder.append("	| expr 'and' expr\n");
+		grammarBuilder.append("	| expr 'or' expr\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("ID: [a-zA-Z_][a-zA-Z_0-9]*;\n");
+		grammarBuilder.append("WS: [ \\t\\n\\r\\f]+ -> skip;\n");
+		grammarBuilder.append("ERROR: .;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input =
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12";
+		String found = execParser("Expr.g4", grammar, "ExprParser", "ExprLexer", "ExprListener", "ExprVisitor", "program", input, false);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testExpressionGrammar_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(164);
+		grammarBuilder.append("grammar Expr;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("program: expr EOF;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("expr\n");
+		grammarBuilder.append("	: ID\n");
+		grammarBuilder.append("	| 'not' expr\n");
+		grammarBuilder.append("	| expr 'and' expr\n");
+		grammarBuilder.append("	| expr 'or' expr\n");
+		grammarBuilder.append("	;\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("ID: [a-zA-Z_][a-zA-Z_0-9]*;\n");
+		grammarBuilder.append("WS: [ \\t\\n\\r\\f]+ -> skip;\n");
+		grammarBuilder.append("ERROR: .;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input =
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"    X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and     X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and     X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and     X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and     X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and     X6 and not X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and     X7 and not X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and     X8 and not X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and     X9 and not X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and     X10 and not X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and     X11 and not X12 or\n" +
+			"not X1 and not X2 and not X3 and not X4 and not X5 and not X6 and not X7 and not X8 and not X9 and not X10 and not X11 and     X12";
+		String found = execParser("Expr.g4", grammar, "ExprParser", "ExprLexer", "ExprListener", "ExprVisitor", "program", input, false);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+
+}
\ No newline at end of file
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/python3/TestSemPredEvalLexer.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/python3/TestSemPredEvalLexer.java
new file mode 100644
index 000000000..96fe43d28
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/python3/TestSemPredEvalLexer.java
@@ -0,0 +1,217 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.python3;
+
+import org.junit.Ignore;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+@SuppressWarnings("unused")
+public class TestSemPredEvalLexer extends BasePython3Test {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDisableRule() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(131);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("E1 : 'enum' { False }? ;\n");
+		grammarBuilder.append("E2 : 'enum' { True }? ;  // winner not E1 or ID\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="enum abc";
+		String found = execLexer("L.g4", grammar, "L", input, true);
+		assertEquals(
+			"[@0,0:3='enum',<2>,1:0]\n" +
+			"[@1,5:7='abc',<3>,1:5]\n" +
+			"[@2,8:7='<EOF>',<-1>,1:8]\n" +
+			"s0-' '->:s5=>4\n" +
+			"s0-'a'->:s6=>3\n" +
+			"s0-'e'->:s1=>3\n" +
+			":s1=>3-'n'->:s2=>3\n" +
+			":s2=>3-'u'->:s3=>3\n" +
+			":s6=>3-'b'->:s6=>3\n" +
+			":s6=>3-'c'->:s6=>3\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testEnumNotID() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(96);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("ENUM : [a-z]+  { self.text==\"enum\" }? ;\n");
+		grammarBuilder.append("ID : [a-z]+  ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="enum abc enum";
+		String found = execLexer("L.g4", grammar, "L", input, true);
+		assertEquals(
+			"[@0,0:3='enum',<1>,1:0]\n" +
+			"[@1,5:7='abc',<2>,1:5]\n" +
+			"[@2,9:12='enum',<1>,1:9]\n" +
+			"[@3,13:12='<EOF>',<-1>,1:13]\n" +
+			"s0-' '->:s3=>3\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testIDnotEnum() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(84);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("ENUM : [a-z]+  { False }? ;\n");
+		grammarBuilder.append("ID : [a-z]+  ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="enum abc enum";
+		String found = execLexer("L.g4", grammar, "L", input, true);
+		assertEquals(
+			"[@0,0:3='enum',<2>,1:0]\n" +
+			"[@1,5:7='abc',<2>,1:5]\n" +
+			"[@2,9:12='enum',<2>,1:9]\n" +
+			"[@3,13:12='<EOF>',<-1>,1:13]\n" +
+			"s0-' '->:s2=>3\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testIDvsEnum() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(85);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("ENUM : 'enum' { False }? ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="enum abc enum";
+		String found = execLexer("L.g4", grammar, "L", input, true);
+		assertEquals(
+			"[@0,0:3='enum',<2>,1:0]\n" +
+			"[@1,5:7='abc',<2>,1:5]\n" +
+			"[@2,9:12='enum',<2>,1:9]\n" +
+			"[@3,13:12='<EOF>',<-1>,1:13]\n" +
+			"s0-' '->:s5=>3\n" +
+			"s0-'a'->:s4=>2\n" +
+			"s0-'e'->:s1=>2\n" +
+			":s1=>2-'n'->:s2=>2\n" +
+			":s2=>2-'u'->:s3=>2\n" +
+			":s4=>2-'b'->:s4=>2\n" +
+			":s4=>2-'c'->:s4=>2\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testIndent() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(135);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("ID : [a-z]+  ;\n");
+		grammarBuilder.append("INDENT : [ \\t]+ { self._tokenStartColumn==0 }?\n");
+		grammarBuilder.append("         { print(\"INDENT\") }  ;\n");
+		grammarBuilder.append("NL : '\\n';\n");
+		grammarBuilder.append("WS : [ \\t]+ ;");
+		String grammar = grammarBuilder.toString();
+
+		String input =
+			"abc\n" +
+			"  def  \n";
+		String found = execLexer("L.g4", grammar, "L", input, true);
+		assertEquals(
+			"INDENT\n" +
+			"[@0,0:2='abc',<1>,1:0]\n" +
+			"[@1,3:3='\\n',<3>,1:3]\n" +
+			"[@2,4:5='  ',<2>,2:0]\n" +
+			"[@3,6:8='def',<1>,2:2]\n" +
+			"[@4,9:10='  ',<4>,2:5]\n" +
+			"[@5,11:11='\\n',<3>,2:7]\n" +
+			"[@6,12:11='<EOF>',<-1>,3:0]\n" +
+			"s0-'\n" +
+			"'->:s2=>3\n" +
+			"s0-'a'->:s1=>1\n" +
+			"s0-'d'->:s1=>1\n" +
+			":s1=>1-'b'->:s1=>1\n" +
+			":s1=>1-'c'->:s1=>1\n" +
+			":s1=>1-'e'->:s1=>1\n" +
+			":s1=>1-'f'->:s1=>1\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLexerInputPositionSensitivePredicates() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(206);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("WORD1 : ID1+ { print(self.text) } ;\n");
+		grammarBuilder.append("WORD2 : ID2+ { print(self.text) } ;\n");
+		grammarBuilder.append("fragment ID1 : { self.column < 2 }? [a-zA-Z];\n");
+		grammarBuilder.append("fragment ID2 : { self.column >= 2 }? [a-zA-Z];\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip;");
+		String grammar = grammarBuilder.toString();
+
+		String input =
+			"a cde\n" +
+			"abcde\n";
+		String found = execLexer("L.g4", grammar, "L", input, true);
+		assertEquals(
+			"a\n" +
+			"cde\n" +
+			"ab\n" +
+			"cde\n" +
+			"[@0,0:0='a',<1>,1:0]\n" +
+			"[@1,2:4='cde',<2>,1:2]\n" +
+			"[@2,6:7='ab',<1>,2:0]\n" +
+			"[@3,8:10='cde',<2>,2:2]\n" +
+			"[@4,12:11='<EOF>',<-1>,3:0]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPredicatedKeywords() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(142);
+		grammarBuilder.append("lexer grammar L;\n");
+		grammarBuilder.append("ENUM : [a-z]+ { self.text==\"enum\" }? { print(\"enum!\") } ;\n");
+		grammarBuilder.append("ID   : [a-z]+ { print(\"ID \" + self.text) } ;\n");
+		grammarBuilder.append("WS   : [ \\n] -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+		String input ="enum enu a";
+		String found = execLexer("L.g4", grammar, "L", input, false);
+		assertEquals(
+			"enum!\n" +
+			"ID enu\n" +
+			"ID a\n" +
+			"[@0,0:3='enum',<1>,1:0]\n" +
+			"[@1,5:7='enu',<2>,1:5]\n" +
+			"[@2,9:9='a',<2>,1:9]\n" +
+			"[@3,10:9='<EOF>',<-1>,1:10]\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+
+}
\ No newline at end of file
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/python3/TestSemPredEvalParser.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/python3/TestSemPredEvalParser.java
new file mode 100644
index 000000000..0db605df7
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/python3/TestSemPredEvalParser.java
@@ -0,0 +1,761 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.python3;
+
+import org.junit.Ignore;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+@SuppressWarnings("unused")
+public class TestSemPredEvalParser extends BasePython3Test {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void test2UnpredicatedAlts() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(276);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : {self._interp.predictionMode =  PredictionMode.LL_EXACT_AMBIG_DETECTION} a ';' a; // do 2x: once in ATN, next in DFA\n");
+		grammarBuilder.append("a : ID {print(\"alt 1\")}\n");
+		grammarBuilder.append("  | ID {print(\"alt 2\")}\n");
+		grammarBuilder.append("  | {False}? ID {print(\"alt 3\")}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x; y";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, true);
+
+		assertEquals(
+			"alt 1\n" +
+			"alt 1\n", found);
+
+		assertEquals(
+			"line 1:0 reportAttemptingFullContext d=0 (a), input='x'\n" +
+			"line 1:0 reportAmbiguity d=0 (a): ambigAlts={1, 2}, input='x'\n" +
+			"line 1:3 reportAttemptingFullContext d=0 (a), input='y'\n" +
+			"line 1:3 reportAmbiguity d=0 (a): ambigAlts={1, 2}, input='y'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void test2UnpredicatedAltsAndOneOrthogonalAlt() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(321);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : {self._interp.predictionMode =  PredictionMode.LL_EXACT_AMBIG_DETECTION} a ';' a ';' a;\n");
+		grammarBuilder.append("a : INT {print(\"alt 1\")}\n");
+		grammarBuilder.append("  | ID {print(\"alt 2\")} // must pick this one for ID since pred is false\n");
+		grammarBuilder.append("  | ID {print(\"alt 3\")}\n");
+		grammarBuilder.append("  | {False}? ID {print(\"alt 4\")}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="34; x; y";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, true);
+
+		assertEquals(
+			"alt 1\n" +
+			"alt 2\n" +
+			"alt 2\n", found);
+
+		assertEquals(
+			"line 1:4 reportAttemptingFullContext d=0 (a), input='x'\n" +
+			"line 1:4 reportAmbiguity d=0 (a): ambigAlts={2, 3}, input='x'\n" +
+			"line 1:7 reportAttemptingFullContext d=0 (a), input='y'\n" +
+			"line 1:7 reportAmbiguity d=0 (a): ambigAlts={2, 3}, input='y'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testActionHidesPreds() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(204);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@members {i = 0}\n");
+		grammarBuilder.append("s : a+ ;\n");
+		grammarBuilder.append("a : {self.i = 1} ID {self.i == 1}? {print(\"alt 1\")}\n");
+		grammarBuilder.append("  | {self.i = 2} ID {self.i == 2}? {print(\"alt 2\")}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x x y";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals(
+			"alt 1\n" +
+			"alt 1\n" +
+			"alt 1\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testActionsHidePredsInGlobalFOLLOW() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(269);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@members {\n");
+		grammarBuilder.append("def pred(self, v):\n");
+		grammarBuilder.append("	print('eval=' + str(v).lower())\n");
+		grammarBuilder.append("	return v\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("s : e {} {self.pred(True)}? {print(\"parse\")} '!' ;\n");
+		grammarBuilder.append("t : e {} {self.pred(False)}? ID ;\n");
+		grammarBuilder.append("e : ID | ; // non-LL(1) so we use ATN\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a!";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals(
+			"eval=true\n" +
+			"parse\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testAtomWithClosureInTranslatedLRRule() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(94);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("start : e[0] EOF;\n");
+		grammarBuilder.append("e[int _p]\n");
+		grammarBuilder.append("    :   ( 'a' | 'b'+ ) ( {3 >= $_p}? '+' e[4] )*\n");
+		grammarBuilder.append("    ;\n");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a+b+a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "start", input, false);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDepedentPredsInGlobalFOLLOW() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(292);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@members {\n");
+		grammarBuilder.append("def pred(self, v):\n");
+		grammarBuilder.append("	print('eval=' + str(v).lower())\n");
+		grammarBuilder.append("	return v\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("s : a[99] ;\n");
+		grammarBuilder.append("a[int i] : e {self.pred($i==99)}? {print(\"parse\")} '!' ;\n");
+		grammarBuilder.append("b[int i] : e {self.pred($i==99)}? ID ;\n");
+		grammarBuilder.append("e : ID | ; // non-LL(1) so we use ATN\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a!";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals(
+			"eval=true\n" +
+			"parse\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDependentPredNotInOuterCtxShouldBeIgnored() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(256);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : b[2] ';' |  b[2] '.' ; // decision in s drills down to ctx-dependent pred in a;\n");
+		grammarBuilder.append("b[int i] : a[i] ;\n");
+		grammarBuilder.append("a[int i]\n");
+		grammarBuilder.append("  : {$i==1}? ID {print(\"alt 1\")}\n");
+		grammarBuilder.append("    | {$i==2}? ID {print(\"alt 2\")}\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;\n");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a;";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("alt 2\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testDisabledAlternative() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(121);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("cppCompilationUnit : content+ EOF;\n");
+		grammarBuilder.append("content: anything | {False}? .;\n");
+		grammarBuilder.append("anything: ANY_CHAR;\n");
+		grammarBuilder.append("ANY_CHAR: [_a-zA-Z0-9];");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="hello";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "cppCompilationUnit", input, false);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testIndependentPredNotPassedOuterCtxToAvoidCastException() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(169);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : b ';' |  b '.' ;\n");
+		grammarBuilder.append("b : a ;\n");
+		grammarBuilder.append("a\n");
+		grammarBuilder.append("  : {False}? ID {print(\"alt 1\")}\n");
+		grammarBuilder.append("  | {True}? ID {print(\"alt 2\")}\n");
+		grammarBuilder.append(" ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a;";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("alt 2\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNoTruePredsThrowsNoViableAlt() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(157);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : a a;\n");
+		grammarBuilder.append("a : {False}? ID INT {print(\"alt 1\")}\n");
+		grammarBuilder.append("  | {False}? ID INT {print(\"alt 2\")}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="y 3 x 4";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("", found);
+
+		assertEquals("line 1:0 no viable alternative at input 'y'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testOrder() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(283);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : a {} a; // do 2x: once in ATN, next in DFA;\n");
+		grammarBuilder.append("// action blocks lookahead from falling off of 'a'\n");
+		grammarBuilder.append("// and looking into 2nd 'a' ref. !ctx dependent pred\n");
+		grammarBuilder.append("a : ID {print(\"alt 1\")}\n");
+		grammarBuilder.append("  | {True}?  ID {print(\"alt 2\")}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x y";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals(
+			"alt 1\n" +
+			"alt 1\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPredFromAltTestedInLoopBack_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(203);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("file_\n");
+		grammarBuilder.append("@after {print($ctx.toStringTree(recog=self))}\n");
+		grammarBuilder.append("  : para para EOF ;\n");
+		grammarBuilder.append("para: paraContent NL NL ;\n");
+		grammarBuilder.append("paraContent : ('s'|'x'|{self._input.LA(2)!=TParser.NL}? NL)+ ;\n");
+		grammarBuilder.append("NL : '\\n' ;\n");
+		grammarBuilder.append("s : 's' ;\n");
+		grammarBuilder.append("X : 'x' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input =
+			"s\n" +
+			"\n" +
+			"\n" +
+			"x\n";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "file_", input, true);
+
+		assertEquals("(file_ (para (paraContent s) \\n \\n) (para (paraContent \\n x \\n)) <EOF>)\n", found);
+
+		assertEquals(
+			"line 5:0 mismatched input '<EOF>' expecting '\n" +
+			"'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPredFromAltTestedInLoopBack_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(203);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("file_\n");
+		grammarBuilder.append("@after {print($ctx.toStringTree(recog=self))}\n");
+		grammarBuilder.append("  : para para EOF ;\n");
+		grammarBuilder.append("para: paraContent NL NL ;\n");
+		grammarBuilder.append("paraContent : ('s'|'x'|{self._input.LA(2)!=TParser.NL}? NL)+ ;\n");
+		grammarBuilder.append("NL : '\\n' ;\n");
+		grammarBuilder.append("s : 's' ;\n");
+		grammarBuilder.append("X : 'x' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input =
+			"s\n" +
+			"\n" +
+			"\n" +
+			"x\n" +
+			"\n";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "file_", input, true);
+
+		assertEquals("(file_ (para (paraContent s) \\n \\n) (para (paraContent \\n x) \\n \\n) <EOF>)\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPredTestedEvenWhenUnAmbig_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(184);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@members {enumKeyword = True}\n");
+		grammarBuilder.append("primary\n");
+		grammarBuilder.append("    :   ID {print(\"ID \"+$ID.text)}\n");
+		grammarBuilder.append("    |   {not self.enumKeyword}? 'enum' {print(\"enum\")}\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : [a-z]+ ;\n");
+		grammarBuilder.append("WS : [ \\t\\n\\r]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="abc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "primary", input, false);
+
+		assertEquals("ID abc\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPredTestedEvenWhenUnAmbig_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(184);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@members {enumKeyword = True}\n");
+		grammarBuilder.append("primary\n");
+		grammarBuilder.append("    :   ID {print(\"ID \"+$ID.text)}\n");
+		grammarBuilder.append("    |   {not self.enumKeyword}? 'enum' {print(\"enum\")}\n");
+		grammarBuilder.append("    ;\n");
+		grammarBuilder.append("ID : [a-z]+ ;\n");
+		grammarBuilder.append("WS : [ \\t\\n\\r]+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="enum";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "primary", input, false);
+
+		assertEquals("", found);
+
+		assertEquals("line 1:0 no viable alternative at input 'enum'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPredicateDependentOnArg() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(181);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@members {i = 0}\n");
+		grammarBuilder.append("s : a[2] a[1];\n");
+		grammarBuilder.append("a[int i]\n");
+		grammarBuilder.append("  : {$i==1}? ID {print(\"alt 1\")}\n");
+		grammarBuilder.append("  | {$i==2}? ID {print(\"alt 2\")}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals(
+			"alt 2\n" +
+			"alt 1\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPredicateDependentOnArg2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(149);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@members {i = 0}\n");
+		grammarBuilder.append("s : a[2] a[1];\n");
+		grammarBuilder.append("a[int i]\n");
+		grammarBuilder.append("  : {$i==1}? ID \n");
+		grammarBuilder.append("  | {$i==2}? ID \n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPredsInGlobalFOLLOW() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(263);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@members {\n");
+		grammarBuilder.append("def pred(self, v):\n");
+		grammarBuilder.append("	print('eval=' + str(v).lower())\n");
+		grammarBuilder.append("	return v\n");
+		grammarBuilder.append("\n");
+		grammarBuilder.append("}\n");
+		grammarBuilder.append("s : e {self.pred(True)}? {print(\"parse\")} '!' ;\n");
+		grammarBuilder.append("t : e {self.pred(False)}? ID ;\n");
+		grammarBuilder.append("e : ID | ; // non-LL(1) so we use ATN\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a!";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals(
+			"eval=true\n" +
+			"parse\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testRewindBeforePredEval() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(201);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : a a;\n");
+		grammarBuilder.append("a : {self._input.LT(1).text==\"x\"}? ID INT {print(\"alt 1\")}\n");
+		grammarBuilder.append("  | {self._input.LT(1).text==\"y\"}? ID INT {print(\"alt 2\")}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="y 3 x 4";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals(
+			"alt 2\n" +
+			"alt 1\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSimple() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(235);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : a a a; // do 3x: once in ATN, next in DFA then INT in ATN\n");
+		grammarBuilder.append("a : {False}? ID {print(\"alt 1\")}\n");
+		grammarBuilder.append("  | {True}?  ID {print(\"alt 2\")}\n");
+		grammarBuilder.append("  | INT         {print(\"alt 3\")}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x y 3";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals(
+			"alt 2\n" +
+			"alt 2\n" +
+			"alt 3\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSimpleValidate() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(150);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : a ;\n");
+		grammarBuilder.append("a : {False}? ID  {print(\"alt 1\")}\n");
+		grammarBuilder.append("  | {True}?  INT {print(\"alt 2\")}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("", found);
+
+		assertEquals("line 1:0 no viable alternative at input 'x'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSimpleValidate2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(153);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : a a a;\n");
+		grammarBuilder.append("a : {False}? ID  {print(\"alt 1\")}\n");
+		grammarBuilder.append("  | {True}?  INT {print(\"alt 2\")}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="3 4 x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals(
+			"alt 2\n" +
+			"alt 2\n", found);
+
+		assertEquals("line 1:4 no viable alternative at input 'x'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testToLeft() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(150);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("	s : a+ ;\n");
+		grammarBuilder.append("a : {False}? ID {print(\"alt 1\")}\n");
+		grammarBuilder.append("  | {True}?  ID {print(\"alt 2\")}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x x y";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals(
+			"alt 2\n" +
+			"alt 2\n" +
+			"alt 2\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testToLeftWithVaryingPredicate() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(228);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("@members {i = 0}\n");
+		grammarBuilder.append("s : ({self.i += 1\n");
+		grammarBuilder.append("print(\"i=\" + str(self.i))} a)+ ;\n");
+		grammarBuilder.append("a : {self.i % 2 == 0}? ID {print(\"alt 1\")}\n");
+		grammarBuilder.append("  | {self.i % 2 != 0}? ID {print(\"alt 2\")}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x x y";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals(
+			"i=1\n" +
+			"alt 2\n" +
+			"i=2\n" +
+			"alt 1\n" +
+			"i=3\n" +
+			"alt 2\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testUnpredicatedPathsInAlt() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(169);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : a {print(\"alt 1\")}\n");
+		grammarBuilder.append("  | b {print(\"alt 2\")}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("a : {False}? ID INT\n");
+		grammarBuilder.append("  | ID INT\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("b : ID ID\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x 4";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("alt 1\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testValidateInDFA() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(318);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("s : a ';' a;\n");
+		grammarBuilder.append("// ';' helps us to resynchronize without consuming\n");
+		grammarBuilder.append("// 2nd 'a' reference. We our testing that the DFA also\n");
+		grammarBuilder.append("// throws an exception if the validating predicate fails\n");
+		grammarBuilder.append("a : {False}? ID  {print(\"alt 1\")}\n");
+		grammarBuilder.append("  | {True}?  INT {print(\"alt 2\")}\n");
+		grammarBuilder.append("  ;\n");
+		grammarBuilder.append("ID : 'a'..'z'+ ;\n");
+		grammarBuilder.append("INT : '0'..'9'+;\n");
+		grammarBuilder.append("WS : (' '|'\\n') -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x ; y";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "s", input, false);
+
+		assertEquals("", found);
+
+		assertEquals(
+			"line 1:0 no viable alternative at input 'x'\n" +
+			"line 1:4 no viable alternative at input 'y'\n", this.stderrDuringParse);
+
+	}
+
+
+}
\ No newline at end of file
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/python3/TestSets.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/python3/TestSets.java
new file mode 100644
index 000000000..96f550caf
--- /dev/null
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/python3/TestSets.java
@@ -0,0 +1,476 @@
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.python3;
+
+import org.junit.Ignore;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+@SuppressWarnings("unused")
+public class TestSets extends BasePython3Test {
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testCharSetLiteral() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(78);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : (A {print($A.text)})+ ;\n");
+		grammarBuilder.append("A : [AaBb] ;\n");
+		grammarBuilder.append("WS : (' '|'\\n')+ -> skip ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="A a B b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals(
+			"A\n" +
+			"a\n" +
+			"B\n" +
+			"b\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testComplementSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(51);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("parse : ~NEW_LINE;\n");
+		grammarBuilder.append("NEW_LINE: '\\r'? '\\n';");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="a";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "parse", input, false);
+
+		assertEquals("", found);
+
+		assertEquals(
+			"line 1:0 token recognition error at: 'a'\n" +
+			"line 1:1 missing {} at '<EOF>'\n", this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLexerOptionalSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(70);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {print(self._input.getText())} ;\n");
+		grammarBuilder.append("A : ('a'|'b')? 'c' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="ac";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("ac\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLexerPlusSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(70);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {print(self._input.getText())} ;\n");
+		grammarBuilder.append("A : ('a'|'b')+ 'c' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="abaac";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("abaac\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testLexerStarSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(70);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {print(self._input.getText())} ;\n");
+		grammarBuilder.append("A : ('a'|'b')* 'c' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="abaac";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("abaac\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNotChar() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(46);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {print($A.text)} ;\n");
+		grammarBuilder.append("A : ~'b' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("x\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNotCharSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(52);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {print($A.text)} ;\n");
+		grammarBuilder.append("A : ~('b'|'c') ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("x\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNotCharSetWithLabel() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(54);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {print($A.text)} ;\n");
+		grammarBuilder.append("A : h=~('b'|'c') ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("x\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testNotCharSetWithRuleRef3() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(118);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {print($A.text)} ;\n");
+		grammarBuilder.append("A : ('a'|B) ;  // this doesn't collapse to set but works\n");
+		grammarBuilder.append("fragment\n");
+		grammarBuilder.append("B : ~('a'|'c') ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("x\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testOptionalLexerSingleElement() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(64);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {print(self._input.getText())} ;\n");
+		grammarBuilder.append("A : 'b'? 'c' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="bc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("bc\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testOptionalSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(62);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : ('a'|'b')? 'c' {print(self._input.getText())} ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="ac";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("ac\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testOptionalSingleElement() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(64);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A? 'c' {print(self._input.getText())} ;\n");
+		grammarBuilder.append("A : 'b' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="bc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("bc\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testParserNotSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(50);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : t=~('x'|'y') 'z' {print($t.text)} ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="zz";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("z\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testParserNotToken() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(56);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : ~'x' 'z' {print(self._input.getText())} ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="zz";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("zz\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testParserNotTokenWithLabel() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(44);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : t=~'x' 'z' {print($t.text)} ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="zz";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("z\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testParserSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(45);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : t=('x'|'y') {print($t.text)} ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="x";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("x\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPlusLexerSingleElement() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(64);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {print(self._input.getText())} ;\n");
+		grammarBuilder.append("A : 'b'+ 'c' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="bbbbc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("bbbbc\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testPlusSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(62);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : ('a'|'b')+ 'c' {print(self._input.getText())} ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="abaac";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("abaac\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testRuleAsSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(69);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a @after {print(self._input.getText())} : 'a' | 'b' |'c' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="b";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("b\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testSeqDoesNotBecomeSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(106);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : C {print(self._input.getText())} ;\n");
+		grammarBuilder.append("fragment A : '1' | '2';\n");
+		grammarBuilder.append("fragment B : '3' '4';\n");
+		grammarBuilder.append("C : A | B;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="34";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("34\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testStarLexerSingleElement_1() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(64);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {print(self._input.getText())} ;\n");
+		grammarBuilder.append("A : 'b'* 'c' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="bbbbc";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("bbbbc\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testStarLexerSingleElement_2() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(64);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : A {print(self._input.getText())} ;\n");
+		grammarBuilder.append("A : 'b'* 'c' ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="c";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("c\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+	/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+	@Test
+	public void testStarSet() throws Exception {
+		mkdir(tmpdir);
+
+		StringBuilder grammarBuilder = new StringBuilder(62);
+		grammarBuilder.append("grammar T;\n");
+		grammarBuilder.append("a : ('a'|'b')* 'c' {print(self._input.getText())} ;");
+		String grammar = grammarBuilder.toString();
+
+
+		String input ="abaac";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "TListener", "TVisitor", "a", input, false);
+
+		assertEquals("abaac\n", found);
+		assertNull(this.stderrDuringParse);
+
+	}
+
+
+}
\ No newline at end of file
diff --git a/runtime/CSharp/LICENSE.txt b/runtime/CSharp/LICENSE.txt
new file mode 100644
index 000000000..dff211c19
--- /dev/null
+++ b/runtime/CSharp/LICENSE.txt
@@ -0,0 +1,26 @@
+[The "BSD license"]
+Copyright (c) 2015 Terence Parr, Sam Harwell, Eric Vergnaud
+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.
diff --git a/runtime/CSharp/README.md b/runtime/CSharp/README.md
new file mode 100644
index 000000000..f4decd5a3
--- /dev/null
+++ b/runtime/CSharp/README.md
@@ -0,0 +1,69 @@
+# C# target for ANTLR 4
+
+### Note to existing users
+
+Versions of ANTLR 4.4.x and before managed the C# target as a [separate tool provided by Sam Harwell](https://github.com/tunnelvisionlabs/antlr4cs/releases/tag/v4.3.0). As of 4.5, we our releasing a (mono-compatible) C# target derived from Sam's with the main tool. ANTLR 4.5 is now able to generate C#, Java, Python 2, Python 3 and JavaScript. Sam continues to work on his version of the ANTLR tool and so a C# target is also available through that.
+
+This makes it possible to use ANTLR 4 in any C# development environment, including of course Microsoft Visual Studio, but also Xamarin Studio, which runs on MacOS X.
+Given Microsoft's recent commitment to *cross-platform developer experiences*, we believe this is a great opportunity for C# developers.
+
+## Getting Started
+
+### Step 1: Install Java
+
+The C# target for ANTLR 4 requires Java for *generating* C# code (but the applications compiled from this C# code will not require Java to be installed).
+You can install *any* of the following versions of Java to use this target.
+
+If you already have one of the following installed, you should check to make sure the installation is up-to-date.
+
+* Java 7 runtime environment (x86 or x64)
+* Java 7 development kit (x86 or x64, provided that the JRE option is also installed during the development kit installation)
+* Java 6 runtime environment (x86 or x64)
+* Java 6 development kit (x86 or x64, provided that the JRE option is also installed during the development kit installation)
+
+### Step 2: Download the tool and runtime, and install the runtime
+
+You need to download the following from the ANTLR web site:
+
+1. The ANTLR tool. This is a Java archive (*.jar) used to generate the C# code from an ANTLR grammar.
+2. The ANTLR runtime assembly. This is a regular .Net assembly (*.dll).
+
+You then need to install the runtime assembly in the GAC. 
+This is required to easily reference the runtime from your project. 
+Go the the directory where you downloaded the runtime, and type the following command: 
+`gacutil -i Antlr4.Runtime.dll`
+
+### Step 3: Add a reference to the ANTLR runtime in your project
+
+We trust that you know how to do this :-).
+
+### Step 4: Add or create a grammar file (*.g4) in your project
+
+To avoid confusing your IDE, we suggest setting the build action to None for this file.
+See the docs and the book to learn about writing lexer and parser grammars.
+
+### Step 5: Generate the C# code
+
+This can be done either from the cmd line, or by adding a custom pre-build command.
+At minimal, the cmd line should look as follows: ``java -jar antlr4-4.5.jar -Dlanguage=CSharp grammar.g4``
+This will generate the files, which you can then integrate in your project.
+This is just a quick start. The tool has many useful options to control generation, please refer to its documentation. 
+ 
+### Step 6: You're done!
+
+Of course, the generated code is not going to meet your requirement by magic.
+There are 3 ways to use the generated code:
+ - by generating a parse tree, and traversing it using a listener. This is the most common method.
+ - by generating a parse tree, and traversing it using a visitor. This requires the -visitor option, and is a bit more work.
+ - by providing code within your grammar, which gets executed when your input files are parsed. 
+While the latter works, it is no longer the recommended approach, because it is not portable, and harder to maintain. More importantly, it breaks the parsing when your code breaks.
+
+See the web site for examples of using the generated code.
+ 
+To learn more about ANTLR 4, read the book.
+ 
+### Visual Studio integration
+
+If you require tighter Visual Studio integration, you can use the tools from Tunnel Vision Labs. 
+(please note however that they use a different tool and runtime)
+
diff --git a/runtime/CSharp/runtime/Antlr4.snk b/runtime/CSharp/runtime/Antlr4.snk
new file mode 100644
index 000000000..d8ba34b74
Binary files /dev/null and b/runtime/CSharp/runtime/Antlr4.snk differ
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Antlr4.Runtime.mono.csproj b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Antlr4.Runtime.mono.csproj
new file mode 100644
index 000000000..f2fa39284
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Antlr4.Runtime.mono.csproj
@@ -0,0 +1,237 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{E1A46D9D-66CB-46E8-93B0-7FC87299ABEF}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>Antlr4.Runtime</RootNamespace>
+    <AssemblyName>Antlr4.Runtime</AssemblyName>
+    <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <BaseIntermediateOutputPath>obj\net20\</BaseIntermediateOutputPath>
+    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\</SolutionDir>
+    <RestorePackages>true</RestorePackages>
+    <SignAssembly>true</SignAssembly>
+    <AssemblyOriginatorKeyFile>..\..\Antlr4.snk</AssemblyOriginatorKeyFile>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\net35\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE;NET35PLUS</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <NoWarn>1591</NoWarn>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <Optimize>true</Optimize>
+    <OutputPath>bin\net35\Release\</OutputPath>
+    <DefineConstants>TRACE;NET35PLUS</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <NoWarn>1591</NoWarn>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="AntlrFileStream.cs" />
+    <Compile Include="AntlrInputStream.cs" />
+    <Compile Include="Atn\AbstractPredicateTransition.cs" />
+    <Compile Include="Atn\ActionTransition.cs" />
+    <Compile Include="Atn\AmbiguityInfo.cs" />
+    <Compile Include="Atn\ArrayPredictionContext.cs" />
+    <Compile Include="Atn\ATN.cs" />
+    <Compile Include="Atn\ATNConfig.cs" />
+    <Compile Include="Atn\ATNConfigSet.cs" />
+    <Compile Include="Atn\ATNDeserializationOptions.cs" />
+    <Compile Include="Atn\ATNDeserializer.cs" />
+    <Compile Include="Atn\ConflictInfo.cs" />
+    <Compile Include="Dfa\AcceptStateInfo.cs" />
+    <Compile Include="IVocabulary.cs" />
+    <Compile Include="Vocabulary.cs" />
+    <Compile Include="Atn\ATNSimulator.cs" />
+    <Compile Include="Atn\ATNState.cs" />
+    <Compile Include="Atn\ATNType.cs" />
+    <Compile Include="Atn\AtomTransition.cs" />
+    <Compile Include="Atn\BasicBlockStartState.cs" />
+    <Compile Include="Atn\BasicState.cs" />
+    <Compile Include="Atn\BlockEndState.cs" />
+    <Compile Include="Atn\BlockStartState.cs" />
+    <Compile Include="Atn\ContextSensitivityInfo.cs" />
+    <Compile Include="Atn\DecisionEventInfo.cs" />
+    <Compile Include="Atn\DecisionInfo.cs" />
+    <Compile Include="Atn\DecisionState.cs" />
+    <Compile Include="Atn\EmptyPredictionContext.cs" />
+    <Compile Include="Atn\EpsilonTransition.cs" />
+    <Compile Include="Atn\ErrorInfo.cs" />
+    <Compile Include="Atn\ILexerAction.cs" />
+    <Compile Include="Atn\LexerActionExecutor.cs" />
+    <Compile Include="Atn\LexerActionType.cs" />
+    <Compile Include="Atn\LexerATNSimulator.cs" />
+    <Compile Include="Atn\LexerChannelAction.cs" />
+    <Compile Include="Atn\LexerCustomAction.cs" />
+    <Compile Include="Atn\LexerIndexedCustomAction.cs" />
+    <Compile Include="Atn\LexerModeAction.cs" />
+    <Compile Include="Atn\LexerMoreAction.cs" />
+    <Compile Include="Atn\LexerPopModeAction.cs" />
+    <Compile Include="Atn\LexerPushModeAction.cs" />
+    <Compile Include="Atn\LexerSkipAction.cs" />
+    <Compile Include="Atn\LexerTypeAction.cs" />
+    <Compile Include="Atn\LL1Analyzer.cs" />
+    <Compile Include="Atn\LookaheadEventInfo.cs" />
+    <Compile Include="Atn\LoopEndState.cs" />
+    <Compile Include="Atn\NotSetTransition.cs" />
+    <Compile Include="Atn\OrderedATNConfigSet.cs" />
+    <Compile Include="Atn\ParseInfo.cs" />
+    <Compile Include="Atn\ParserATNSimulator.cs" />
+    <Compile Include="Atn\PlusBlockStartState.cs" />
+    <Compile Include="Atn\PlusLoopbackState.cs" />
+    <Compile Include="Atn\PrecedencePredicateTransition.cs" />
+    <Compile Include="Atn\PredicateEvalInfo.cs" />
+    <Compile Include="Atn\PredicateTransition.cs" />
+    <Compile Include="Atn\PredictionContext.cs" />
+    <Compile Include="Atn\PredictionContextCache.cs" />
+    <Compile Include="Atn\PredictionMode.cs" />
+    <Compile Include="Atn\ProfilingATNSimulator.cs" />
+    <Compile Include="Atn\RangeTransition.cs" />
+    <Compile Include="Atn\RuleStartState.cs" />
+    <Compile Include="Atn\RuleStopState.cs" />
+    <Compile Include="Atn\RuleTransition.cs" />
+    <Compile Include="Atn\SemanticContext.cs" />
+    <Compile Include="Atn\SetTransition.cs" />
+    <Compile Include="Atn\SimulatorState.cs" />
+    <Compile Include="Atn\SingletonPredictionContext.cs" />
+    <Compile Include="Atn\StarBlockStartState.cs" />
+    <Compile Include="Atn\StarLoopbackState.cs" />
+    <Compile Include="Atn\StarLoopEntryState.cs" />
+    <Compile Include="Atn\StateType.cs" />
+    <Compile Include="Atn\TokensStartState.cs" />
+    <Compile Include="Atn\Transition.cs" />
+    <Compile Include="Atn\TransitionType.cs" />
+    <Compile Include="Atn\WildcardTransition.cs" />
+    <Compile Include="BailErrorStrategy.cs" />
+    <Compile Include="BaseErrorListener.cs" />
+    <Compile Include="BufferedTokenStream.cs" />
+    <Compile Include="CommonToken.cs" />
+    <Compile Include="CommonTokenFactory.cs" />
+    <Compile Include="CommonTokenStream.cs" />
+    <Compile Include="ConsoleErrorListener.cs" />
+    <Compile Include="DefaultErrorStrategy.cs" />
+    <Compile Include="Dependents.cs" />
+    <Compile Include="Dfa\DFA.cs" />
+    <Compile Include="Dfa\DFASerializer.cs" />
+    <Compile Include="Dfa\DFAState.cs" />
+    <Compile Include="Dfa\LexerDFASerializer.cs" />
+    <Compile Include="DiagnosticErrorListener.cs" />
+    <Compile Include="FailedPredicateException.cs" />
+    <Compile Include="IAntlrErrorStrategy.cs" />
+    <Compile Include="ICharStream.cs" />
+    <Compile Include="IIntStream.cs" />
+    <Compile Include="InputMismatchException.cs" />
+    <Compile Include="InterpreterRuleContext.cs" />
+    <Compile Include="IParserErrorListener.cs" />
+    <Compile Include="IRecognizer.cs" />
+    <Compile Include="IToken.cs" />
+    <Compile Include="ITokenFactory.cs" />
+    <Compile Include="ITokenSource.cs" />
+    <Compile Include="ITokenStream.cs" />
+    <Compile Include="IWritableToken.cs" />
+    <Compile Include="Lexer.cs" />
+    <Compile Include="LexerInterpreter.cs" />
+    <Compile Include="LexerNoViableAltException.cs" />
+    <Compile Include="ListTokenSource.cs" />
+    <Compile Include="Misc\Args.cs" />
+    <Compile Include="Misc\MurmurHash.cs" />
+    <Compile Include="Misc\NullableAttribute.cs" />
+    <Compile Include="Misc\IIntSet.cs" />
+    <Compile Include="Misc\Interval.cs" />
+    <Compile Include="Misc\IntervalSet.cs" />
+    <Compile Include="Misc\NotNullAttribute.cs" />
+    <Compile Include="Misc\ParseCanceledException.cs" />
+    <Compile Include="Misc\RuleDependencyChecker.cs" />
+    <Compile Include="Misc\Utils.cs" />
+    <Compile Include="NoViableAltException.cs" />
+    <Compile Include="Parser.cs" />
+    <Compile Include="ParserInterpreter.cs" />
+    <Compile Include="ParserRuleContext.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="ProxyParserErrorListener.cs" />
+    <Compile Include="RecognitionException.cs" />
+    <Compile Include="RuleContext.cs" />
+    <Compile Include="RuleDependencyAttribute.cs" />
+    <Compile Include="RuleVersionAttribute.cs" />
+    <Compile Include="Sharpen\Arrays.cs" />
+    <Compile Include="Sharpen\BitSet.cs" />
+    <Compile Include="Sharpen\Collections.cs" />
+    <Compile Include="Sharpen\Compat\Funcs.cs" />
+    <Compile Include="Sharpen\Compat\IStructuralComparable.cs" />
+    <Compile Include="Sharpen\Compat\IStructuralEquatable.cs" />
+    <Compile Include="Sharpen\Compat\Tuple.cs" />
+    <Compile Include="Sharpen\Compat\Tuples.cs" />
+    <Compile Include="Sharpen\DictionaryExtensions.cs" />
+    <Compile Include="Sharpen\ListExtensions.cs" />
+    <Compile Include="Sharpen\Runtime.cs" />
+    <Compile Include="TokenStreamRewriter.cs" />
+    <Compile Include="TokenTypes.cs" />
+    <Compile Include="Tree\ErrorNodeImpl.cs" />
+    <Compile Include="Tree\IErrorNode.cs" />
+    <Compile Include="Tree\IParseTree.cs" />
+    <Compile Include="Tree\IParseTreeListener.cs" />
+    <Compile Include="Tree\IRuleNode.cs" />
+    <Compile Include="Tree\ISyntaxTree.cs" />
+    <Compile Include="Tree\ITerminalNode.cs" />
+    <Compile Include="Tree\ITree.cs" />
+    <Compile Include="Tree\ParseTreeWalker.cs" />
+    <Compile Include="Tree\Pattern\Chunk.cs" />
+    <Compile Include="Tree\Pattern\ParseTreeMatch.cs" />
+    <Compile Include="Tree\Pattern\ParseTreePattern.cs" />
+    <Compile Include="Tree\Pattern\ParseTreePatternMatcher.cs" />
+    <Compile Include="Tree\Pattern\RuleTagToken.cs" />
+    <Compile Include="Tree\Pattern\TagChunk.cs" />
+    <Compile Include="Tree\Pattern\TextChunk.cs" />
+    <Compile Include="Tree\Pattern\TokenTagToken.cs" />
+    <Compile Include="Tree\TerminalNodeImpl.cs" />
+    <Compile Include="Tree\Trees.cs" />
+    <Compile Include="Tree\Xpath\XPath.cs" />
+    <Compile Include="Tree\Xpath\XPathElement.cs" />
+    <Compile Include="Tree\Xpath\XPathLexerErrorListener.cs" />
+    <Compile Include="Tree\Xpath\XPathRuleAnywhereElement.cs" />
+    <Compile Include="Tree\Xpath\XPathRuleElement.cs" />
+    <Compile Include="Tree\Xpath\XPathTokenAnywhereElement.cs" />
+    <Compile Include="Tree\Xpath\XPathTokenElement.cs" />
+    <Compile Include="Tree\Xpath\XPathWildcardAnywhereElement.cs" />
+    <Compile Include="Tree\Xpath\XPathWildcardElement.cs" />
+    <Compile Include="UnbufferedCharStream.cs" />
+    <Compile Include="UnbufferedTokenStream.cs" />
+    <Compile Include="Tree\Xpath\XPathLexer.cs" />
+    <None Include="Tree\Xpath\XPathLexer.g4">
+      <Generator>MSBuild:Compile</Generator>
+      <CustomToolNamespace>Antlr4.Runtime.Tree.Xpath</CustomToolNamespace>
+    </None>
+    <Compile Include="Recognizer.cs" />
+    <Compile Include="Sharpen\Compat\CollectionDebuggerView.cs" />
+    <Compile Include="Sharpen\Compat\ConcurrentDictionary.cs" />
+    <Compile Include="Sharpen\Compat\SplitOrderedList.cs" />
+    <Compile Include="Sharpen\AtomicReference.cs" />
+    <Compile Include="Sharpen\SequenceEqualityComparer.cs" />
+    <Compile Include="IAntlrErrorListener.cs" />
+    <Compile Include="ProxyErrorListener.cs" />
+    <Compile Include="Tree\AbstractParseTreeVisitor.cs" />
+    <Compile Include="Tree\IParseTreeVisitor.cs" />
+    <Compile Include="Tree\ParseTreeProperty.cs" />
+    <Compile Include="Misc\MultiMap.cs" />
+    <Compile Include="Dfa\AbstractEdgeMap.cs" />
+    <Compile Include="Dfa\ArrayEdgeMap.cs" />
+    <Compile Include="Dfa\EmptyEdgeMap.cs" />
+    <Compile Include="Dfa\IEdgeMap.cs" />
+    <Compile Include="Dfa\SingletonEdgeMap.cs" />
+    <Compile Include="Dfa\SparseEdgeMap.cs" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+</Project>
\ No newline at end of file
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Antlr4.Runtime.vs2013.csproj b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Antlr4.Runtime.vs2013.csproj
new file mode 100644
index 000000000..8a501e5a0
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Antlr4.Runtime.vs2013.csproj
@@ -0,0 +1,235 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{E1A46D9D-66CB-46E8-93B0-7FC87299ABEF}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>Antlr4.Runtime</RootNamespace>
+    <AssemblyName>Antlr4.Runtime</AssemblyName>
+    <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <BaseIntermediateOutputPath>obj\net35\</BaseIntermediateOutputPath>
+    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\</SolutionDir>
+    <RestorePackages>true</RestorePackages>
+    <TargetFrameworkProfile />
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\net35\Debug\</OutputPath>
+    <DocumentationFile>$(OutputPath)$(AssemblyName).xml</DocumentationFile>
+    <DefineConstants>DEBUG;TRACE;NET35PLUS</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <NoWarn>1591</NoWarn>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\net35\Release\</OutputPath>
+    <DocumentationFile>$(OutputPath)$(AssemblyName).xml</DocumentationFile>
+    <DefineConstants>TRACE;NET35PLUS</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <NoWarn>1591</NoWarn>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="AntlrFileStream.cs" />
+    <Compile Include="AntlrInputStream.cs" />
+    <Compile Include="Atn\AbstractPredicateTransition.cs" />
+    <Compile Include="Atn\ActionTransition.cs" />
+    <Compile Include="Atn\AmbiguityInfo.cs" />
+    <Compile Include="Atn\ArrayPredictionContext.cs" />
+    <Compile Include="Atn\ATN.cs" />
+    <Compile Include="Atn\ATNConfig.cs" />
+    <Compile Include="Atn\ATNConfigSet.cs" />
+    <Compile Include="Atn\ATNDeserializationOptions.cs" />
+    <Compile Include="Atn\ATNDeserializer.cs" />
+    <Compile Include="Atn\ConflictInfo.cs" />
+    <Compile Include="Dfa\AbstractEdgeMap.cs" />
+    <Compile Include="Dfa\AcceptStateInfo.cs" />
+    <Compile Include="Dfa\ArrayEdgeMap.cs" />
+    <Compile Include="Dfa\EmptyEdgeMap.cs" />
+    <Compile Include="Dfa\IEdgeMap.cs" />
+    <Compile Include="Dfa\SingletonEdgeMap.cs" />
+    <Compile Include="Dfa\SparseEdgeMap.cs" />
+    <Compile Include="IAntlrErrorListener.cs" />
+    <Compile Include="IVocabulary.cs" />
+    <Compile Include="Misc\MultiMap.cs" />
+    <Compile Include="ProxyErrorListener.cs" />
+    <Compile Include="Recognizer.cs" />
+    <Compile Include="Sharpen\AtomicReference.cs" />
+    <Compile Include="Sharpen\Compat\CollectionDebuggerView.cs" />
+    <Compile Include="Sharpen\Compat\ConcurrentDictionary.cs" />
+    <Compile Include="Sharpen\Compat\SplitOrderedList.cs" />
+    <Compile Include="Sharpen\SequenceEqualityComparer.cs" />
+    <Compile Include="Tree\AbstractParseTreeVisitor.cs" />
+    <Compile Include="Tree\IParseTreeVisitor.cs" />
+    <Compile Include="Tree\ParseTreeProperty.cs" />
+    <Compile Include="Tree\Xpath\XPathLexer.cs" />
+    <Compile Include="Vocabulary.cs" />
+    <Compile Include="Atn\ATNSimulator.cs" />
+    <Compile Include="Atn\ATNState.cs" />
+    <Compile Include="Atn\ATNType.cs" />
+    <Compile Include="Atn\AtomTransition.cs" />
+    <Compile Include="Atn\BasicBlockStartState.cs" />
+    <Compile Include="Atn\BasicState.cs" />
+    <Compile Include="Atn\BlockEndState.cs" />
+    <Compile Include="Atn\BlockStartState.cs" />
+    <Compile Include="Atn\ContextSensitivityInfo.cs" />
+    <Compile Include="Atn\DecisionEventInfo.cs" />
+    <Compile Include="Atn\DecisionInfo.cs" />
+    <Compile Include="Atn\DecisionState.cs" />
+    <Compile Include="Atn\EmptyPredictionContext.cs" />
+    <Compile Include="Atn\EpsilonTransition.cs" />
+    <Compile Include="Atn\ErrorInfo.cs" />
+    <Compile Include="Atn\ILexerAction.cs" />
+    <Compile Include="Atn\LexerActionExecutor.cs" />
+    <Compile Include="Atn\LexerActionType.cs" />
+    <Compile Include="Atn\LexerATNSimulator.cs" />
+    <Compile Include="Atn\LexerChannelAction.cs" />
+    <Compile Include="Atn\LexerCustomAction.cs" />
+    <Compile Include="Atn\LexerIndexedCustomAction.cs" />
+    <Compile Include="Atn\LexerModeAction.cs" />
+    <Compile Include="Atn\LexerMoreAction.cs" />
+    <Compile Include="Atn\LexerPopModeAction.cs" />
+    <Compile Include="Atn\LexerPushModeAction.cs" />
+    <Compile Include="Atn\LexerSkipAction.cs" />
+    <Compile Include="Atn\LexerTypeAction.cs" />
+    <Compile Include="Atn\LL1Analyzer.cs" />
+    <Compile Include="Atn\LookaheadEventInfo.cs" />
+    <Compile Include="Atn\LoopEndState.cs" />
+    <Compile Include="Atn\NotSetTransition.cs" />
+    <Compile Include="Atn\OrderedATNConfigSet.cs" />
+    <Compile Include="Atn\ParseInfo.cs" />
+    <Compile Include="Atn\ParserATNSimulator.cs" />
+    <Compile Include="Atn\PlusBlockStartState.cs" />
+    <Compile Include="Atn\PlusLoopbackState.cs" />
+    <Compile Include="Atn\PrecedencePredicateTransition.cs" />
+    <Compile Include="Atn\PredicateEvalInfo.cs" />
+    <Compile Include="Atn\PredicateTransition.cs" />
+    <Compile Include="Atn\PredictionContext.cs" />
+    <Compile Include="Atn\PredictionContextCache.cs" />
+    <Compile Include="Atn\PredictionMode.cs" />
+    <Compile Include="Atn\ProfilingATNSimulator.cs" />
+    <Compile Include="Atn\RangeTransition.cs" />
+    <Compile Include="Atn\RuleStartState.cs" />
+    <Compile Include="Atn\RuleStopState.cs" />
+    <Compile Include="Atn\RuleTransition.cs" />
+    <Compile Include="Atn\SemanticContext.cs" />
+    <Compile Include="Atn\SetTransition.cs" />
+    <Compile Include="Atn\SimulatorState.cs" />
+    <Compile Include="Atn\SingletonPredictionContext.cs" />
+    <Compile Include="Atn\StarBlockStartState.cs" />
+    <Compile Include="Atn\StarLoopbackState.cs" />
+    <Compile Include="Atn\StarLoopEntryState.cs" />
+    <Compile Include="Atn\StateType.cs" />
+    <Compile Include="Atn\TokensStartState.cs" />
+    <Compile Include="Atn\Transition.cs" />
+    <Compile Include="Atn\TransitionType.cs" />
+    <Compile Include="Atn\WildcardTransition.cs" />
+    <Compile Include="BailErrorStrategy.cs" />
+    <Compile Include="BaseErrorListener.cs" />
+    <Compile Include="BufferedTokenStream.cs" />
+    <Compile Include="CommonToken.cs" />
+    <Compile Include="CommonTokenFactory.cs" />
+    <Compile Include="CommonTokenStream.cs" />
+    <Compile Include="ConsoleErrorListener.cs" />
+    <Compile Include="DefaultErrorStrategy.cs" />
+    <Compile Include="Dependents.cs" />
+    <Compile Include="Dfa\DFA.cs" />
+    <Compile Include="Dfa\DFASerializer.cs" />
+    <Compile Include="Dfa\DFAState.cs" />
+    <Compile Include="Dfa\LexerDFASerializer.cs" />
+    <Compile Include="DiagnosticErrorListener.cs" />
+    <Compile Include="FailedPredicateException.cs" />
+    <Compile Include="IAntlrErrorStrategy.cs" />
+    <Compile Include="ICharStream.cs" />
+    <Compile Include="IIntStream.cs" />
+    <Compile Include="InputMismatchException.cs" />
+    <Compile Include="InterpreterRuleContext.cs" />
+    <Compile Include="IParserErrorListener.cs" />
+    <Compile Include="IRecognizer.cs" />
+    <Compile Include="IToken.cs" />
+    <Compile Include="ITokenFactory.cs" />
+    <Compile Include="ITokenSource.cs" />
+    <Compile Include="ITokenStream.cs" />
+    <Compile Include="IWritableToken.cs" />
+    <Compile Include="Lexer.cs" />
+    <Compile Include="LexerInterpreter.cs" />
+    <Compile Include="LexerNoViableAltException.cs" />
+    <Compile Include="ListTokenSource.cs" />
+    <Compile Include="Misc\Args.cs" />
+    <Compile Include="Misc\MurmurHash.cs" />
+    <Compile Include="Misc\NullableAttribute.cs" />
+    <Compile Include="Misc\IIntSet.cs" />
+    <Compile Include="Misc\Interval.cs" />
+    <Compile Include="Misc\IntervalSet.cs" />
+    <Compile Include="Misc\NotNullAttribute.cs" />
+    <Compile Include="Misc\ParseCanceledException.cs" />
+    <Compile Include="Misc\RuleDependencyChecker.cs" />
+    <Compile Include="Misc\Utils.cs" />
+    <Compile Include="NoViableAltException.cs" />
+    <Compile Include="Parser.cs" />
+    <Compile Include="ParserInterpreter.cs" />
+    <Compile Include="ParserRuleContext.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="ProxyParserErrorListener.cs" />
+    <Compile Include="RecognitionException.cs" />
+    <Compile Include="RuleContext.cs" />
+    <Compile Include="RuleDependencyAttribute.cs" />
+    <Compile Include="RuleVersionAttribute.cs" />
+    <Compile Include="Sharpen\Arrays.cs" />
+    <Compile Include="Sharpen\BitSet.cs" />
+    <Compile Include="Sharpen\Collections.cs" />
+    <Compile Include="Sharpen\Compat\Funcs.cs" />
+    <Compile Include="Sharpen\Compat\IStructuralComparable.cs" />
+    <Compile Include="Sharpen\Compat\IStructuralEquatable.cs" />
+    <Compile Include="Sharpen\Compat\Tuple.cs" />
+    <Compile Include="Sharpen\Compat\Tuples.cs" />
+    <Compile Include="Sharpen\DictionaryExtensions.cs" />
+    <Compile Include="Sharpen\ListExtensions.cs" />
+    <Compile Include="Sharpen\Runtime.cs" />
+    <Compile Include="TokenStreamRewriter.cs" />
+    <Compile Include="TokenTypes.cs" />
+    <Compile Include="Tree\ErrorNodeImpl.cs" />
+    <Compile Include="Tree\IErrorNode.cs" />
+    <Compile Include="Tree\IParseTree.cs" />
+    <Compile Include="Tree\IParseTreeListener.cs" />
+    <Compile Include="Tree\IRuleNode.cs" />
+    <Compile Include="Tree\ISyntaxTree.cs" />
+    <Compile Include="Tree\ITerminalNode.cs" />
+    <Compile Include="Tree\ITree.cs" />
+    <Compile Include="Tree\ParseTreeWalker.cs" />
+    <Compile Include="Tree\Pattern\Chunk.cs" />
+    <Compile Include="Tree\Pattern\ParseTreeMatch.cs" />
+    <Compile Include="Tree\Pattern\ParseTreePattern.cs" />
+    <Compile Include="Tree\Pattern\ParseTreePatternMatcher.cs" />
+    <Compile Include="Tree\Pattern\RuleTagToken.cs" />
+    <Compile Include="Tree\Pattern\TagChunk.cs" />
+    <Compile Include="Tree\Pattern\TextChunk.cs" />
+    <Compile Include="Tree\Pattern\TokenTagToken.cs" />
+    <Compile Include="Tree\TerminalNodeImpl.cs" />
+    <Compile Include="Tree\Trees.cs" />
+    <Compile Include="Tree\Xpath\XPath.cs" />
+    <Compile Include="Tree\Xpath\XPathElement.cs" />
+    <Compile Include="Tree\Xpath\XPathLexerErrorListener.cs" />
+    <Compile Include="Tree\Xpath\XPathRuleAnywhereElement.cs" />
+    <Compile Include="Tree\Xpath\XPathRuleElement.cs" />
+    <Compile Include="Tree\Xpath\XPathTokenAnywhereElement.cs" />
+    <Compile Include="Tree\Xpath\XPathTokenElement.cs" />
+    <Compile Include="Tree\Xpath\XPathWildcardAnywhereElement.cs" />
+    <Compile Include="Tree\Xpath\XPathWildcardElement.cs" />
+    <Compile Include="UnbufferedCharStream.cs" />
+    <Compile Include="UnbufferedTokenStream.cs" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+</Project>
\ No newline at end of file
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/AntlrFileStream.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/AntlrFileStream.cs
new file mode 100644
index 000000000..115ceb8c3
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/AntlrFileStream.cs
@@ -0,0 +1,119 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+
+#if !PORTABLE
+
+using Antlr4.Runtime.Sharpen;
+using Encoding = System.Text.Encoding;
+using File = System.IO.File;
+
+namespace Antlr4.Runtime
+{
+#if COMPACT
+    using StreamReader = System.IO.StreamReader;
+#endif
+
+    /// <summary>
+    /// This is an
+    /// <see cref="AntlrInputStream"/>
+    /// that is loaded from a file all at once
+    /// when you construct the object.
+    /// </summary>
+    public class AntlrFileStream : AntlrInputStream
+    {
+        protected internal string fileName;
+
+        /// <exception cref="System.IO.IOException"/>
+        public AntlrFileStream(string fileName)
+            : this(fileName, null)
+        {
+        }
+
+        /// <exception cref="System.IO.IOException"/>
+        public AntlrFileStream(string fileName, Encoding encoding)
+        {
+            this.fileName = fileName;
+            Load(fileName, encoding);
+        }
+
+        /// <exception cref="System.IO.IOException"/>
+        public virtual void Load(string fileName, Encoding encoding)
+        {
+            if (fileName == null)
+            {
+                return;
+            }
+
+            string text;
+#if !COMPACT
+            if (encoding != null)
+                text = File.ReadAllText(fileName, encoding);
+            else
+                text = File.ReadAllText(fileName);
+#else
+            if (encoding != null)
+                text = ReadAllText(fileName, encoding);
+            else
+                text = ReadAllText(fileName);
+#endif
+
+            data = text.ToCharArray();
+            n = data.Length;
+        }
+
+        public override string SourceName
+        {
+            get
+            {
+                return fileName;
+            }
+        }
+
+#if COMPACT
+        private static string ReadAllText(string path)
+        {
+            using (var reader = new StreamReader(path))
+            {
+                return reader.ReadToEnd();
+            }
+        }
+
+        private static string ReadAllText(string path, Encoding encoding)
+        {
+            using (var reader = new StreamReader(path, encoding ?? Encoding.Default))
+            {
+                return reader.ReadToEnd();
+            }
+        }
+#endif
+    }
+}
+
+#endif
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/AntlrInputStream.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/AntlrInputStream.cs
new file mode 100644
index 000000000..90e37f926
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/AntlrInputStream.cs
@@ -0,0 +1,294 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System;
+using System.IO;
+using Antlr4.Runtime;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime
+{
+    /// <summary>
+    /// Vacuum all input from a
+    /// <see cref="System.IO.TextReader"/>
+    /// /
+    /// <see cref="System.IO.Stream"/>
+    /// and then treat it
+    /// like a
+    /// <c>char[]</c>
+    /// buffer. Can also pass in a
+    /// <see cref="string"/>
+    /// or
+    /// <c>char[]</c>
+    /// to use.
+    /// <p>If you need encoding, pass in stream/reader with correct encoding.</p>
+    /// </summary>
+    public class AntlrInputStream : ICharStream
+    {
+        public const int ReadBufferSize = 1024;
+
+        public const int InitialBufferSize = 1024;
+
+        /// <summary>The data being scanned</summary>
+        protected internal char[] data;
+
+        /// <summary>How many characters are actually in the buffer</summary>
+        protected internal int n;
+
+        /// <summary>0..n-1 index into string of next char</summary>
+        protected internal int p = 0;
+
+        /// <summary>What is name or source of this char stream?</summary>
+        public string name;
+
+        public AntlrInputStream()
+        {
+        }
+
+        /// <summary>Copy data in string to a local char array</summary>
+        public AntlrInputStream(string input)
+        {
+            this.data = input.ToCharArray();
+            this.n = input.Length;
+        }
+
+        /// <summary>This is the preferred constructor for strings as no data is copied</summary>
+        public AntlrInputStream(char[] data, int numberOfActualCharsInArray)
+        {
+            this.data = data;
+            this.n = numberOfActualCharsInArray;
+        }
+
+        /// <exception cref="System.IO.IOException"/>
+        public AntlrInputStream(TextReader r)
+            : this(r, InitialBufferSize, ReadBufferSize)
+        {
+        }
+
+        /// <exception cref="System.IO.IOException"/>
+        public AntlrInputStream(TextReader r, int initialSize)
+            : this(r, initialSize, ReadBufferSize)
+        {
+        }
+
+        /// <exception cref="System.IO.IOException"/>
+        public AntlrInputStream(TextReader r, int initialSize, int readChunkSize)
+        {
+            Load(r, initialSize, readChunkSize);
+        }
+
+        /// <exception cref="System.IO.IOException"/>
+        public AntlrInputStream(Stream input)
+            : this(new StreamReader(input), InitialBufferSize)
+        {
+        }
+
+        /// <exception cref="System.IO.IOException"/>
+        public AntlrInputStream(Stream input, int initialSize)
+            : this(new StreamReader(input), initialSize)
+        {
+        }
+
+        /// <exception cref="System.IO.IOException"/>
+        public AntlrInputStream(Stream input, int initialSize, int readChunkSize)
+            : this(new StreamReader(input), initialSize, readChunkSize)
+        {
+        }
+
+        /// <exception cref="System.IO.IOException"/>
+        public virtual void Load(TextReader r, int size, int readChunkSize)
+        {
+            if (r == null)
+            {
+                return;
+            }
+
+            data = r.ReadToEnd().ToCharArray();
+            n = data.Length;
+        }
+
+        /// <summary>
+        /// Reset the stream so that it's in the same state it was
+        /// when the object was created *except* the data array is not
+        /// touched.
+        /// </summary>
+        /// <remarks>
+        /// Reset the stream so that it's in the same state it was
+        /// when the object was created *except* the data array is not
+        /// touched.
+        /// </remarks>
+        public virtual void Reset()
+        {
+            p = 0;
+        }
+
+        public virtual void Consume()
+        {
+            if (p >= n)
+            {
+                System.Diagnostics.Debug.Assert(La(1) == IntStreamConstants.Eof);
+                throw new InvalidOperationException("cannot consume EOF");
+            }
+            //System.out.println("prev p="+p+", c="+(char)data[p]);
+            if (p < n)
+            {
+                p++;
+            }
+        }
+
+        //System.out.println("p moves to "+p+" (c='"+(char)data[p]+"')");
+        public virtual int La(int i)
+        {
+            if (i == 0)
+            {
+                return 0;
+            }
+            // undefined
+            if (i < 0)
+            {
+                i++;
+                // e.g., translate LA(-1) to use offset i=0; then data[p+0-1]
+                if ((p + i - 1) < 0)
+                {
+                    return IntStreamConstants.Eof;
+                }
+            }
+            // invalid; no char before first char
+            if ((p + i - 1) >= n)
+            {
+                //System.out.println("char LA("+i+")=EOF; p="+p);
+                return IntStreamConstants.Eof;
+            }
+            //System.out.println("char LA("+i+")="+(char)data[p+i-1]+"; p="+p);
+            //System.out.println("LA("+i+"); p="+p+" n="+n+" data.length="+data.length);
+            return data[p + i - 1];
+        }
+
+        public virtual int Lt(int i)
+        {
+            return La(i);
+        }
+
+        /// <summary>
+        /// Return the current input symbol index 0..n where n indicates the
+        /// last symbol has been read.
+        /// </summary>
+        /// <remarks>
+        /// Return the current input symbol index 0..n where n indicates the
+        /// last symbol has been read.  The index is the index of char to
+        /// be returned from LA(1).
+        /// </remarks>
+        public virtual int Index
+        {
+            get
+            {
+                return p;
+            }
+        }
+
+        public virtual int Size
+        {
+            get
+            {
+                return n;
+            }
+        }
+
+        /// <summary>mark/release do nothing; we have entire buffer</summary>
+        public virtual int Mark()
+        {
+            return -1;
+        }
+
+        public virtual void Release(int marker)
+        {
+        }
+
+        /// <summary>
+        /// consume() ahead until p==index; can't just set p=index as we must
+        /// update line and charPositionInLine.
+        /// </summary>
+        /// <remarks>
+        /// consume() ahead until p==index; can't just set p=index as we must
+        /// update line and charPositionInLine. If we seek backwards, just set p
+        /// </remarks>
+        public virtual void Seek(int index)
+        {
+            if (index <= p)
+            {
+                p = index;
+                // just jump; don't update stream state (line, ...)
+                return;
+            }
+            // seek forward, consume until p hits index or n (whichever comes first)
+            index = Math.Min(index, n);
+            while (p < index)
+            {
+                Consume();
+            }
+        }
+
+        public virtual string GetText(Interval interval)
+        {
+            int start = interval.a;
+            int stop = interval.b;
+            if (stop >= n)
+            {
+                stop = n - 1;
+            }
+            int count = stop - start + 1;
+            if (start >= n)
+            {
+                return string.Empty;
+            }
+            //		System.err.println("data: "+Arrays.toString(data)+", n="+n+
+            //						   ", start="+start+
+            //						   ", stop="+stop);
+            return new string(data, start, count);
+        }
+
+        public virtual string SourceName
+        {
+            get
+            {
+                if (string.IsNullOrEmpty(name))
+                {
+                    return IntStreamConstants.UnknownSourceName;
+                }
+                return name;
+            }
+        }
+
+        public override string ToString()
+        {
+            return new string(data);
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/ATN.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/ATN.cs
new file mode 100644
index 000000000..e13be048f
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/ATN.cs
@@ -0,0 +1,311 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using Antlr4.Runtime;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Dfa;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    public class ATN
+    {
+        public const int InvalidAltNumber = 0;
+
+        [NotNull]
+        public readonly IList<ATNState> states = new List<ATNState>();
+
+        /// <summary>
+        /// Each subrule/rule is a decision point and we must track them so we
+        /// can go back later and build DFA predictors for them.
+        /// </summary>
+        /// <remarks>
+        /// Each subrule/rule is a decision point and we must track them so we
+        /// can go back later and build DFA predictors for them.  This includes
+        /// all the rules, subrules, optional blocks, ()+, ()* etc...
+        /// </remarks>
+        [NotNull]
+        public readonly IList<DecisionState> decisionToState = new List<DecisionState>();
+
+        /// <summary>Maps from rule index to starting state number.</summary>
+        /// <remarks>Maps from rule index to starting state number.</remarks>
+        public RuleStartState[] ruleToStartState;
+
+        /// <summary>Maps from rule index to stop state number.</summary>
+        /// <remarks>Maps from rule index to stop state number.</remarks>
+        public RuleStopState[] ruleToStopState;
+
+        [NotNull]
+        public readonly IDictionary<string, TokensStartState> modeNameToStartState = new Dictionary<string, TokensStartState>();
+
+        /// <summary>The type of the ATN.</summary>
+        /// <remarks>The type of the ATN.</remarks>
+        public readonly ATNType grammarType;
+
+        /// <summary>The maximum value for any symbol recognized by a transition in the ATN.</summary>
+        /// <remarks>The maximum value for any symbol recognized by a transition in the ATN.</remarks>
+        public readonly int maxTokenType;
+
+        /// <summary>For lexer ATNs, this maps the rule index to the resulting token type.</summary>
+        /// <remarks>
+        /// For lexer ATNs, this maps the rule index to the resulting token type.
+        /// For parser ATNs, this maps the rule index to the generated bypass token
+        /// type if the
+        /// <see cref="ATNDeserializationOptions.GenerateRuleBypassTransitions()"/>
+        /// deserialization option was specified; otherwise, this is
+        /// <see langword="null"/>
+        /// .
+        /// </remarks>
+        public int[] ruleToTokenType;
+
+        /// <summary>
+        /// For lexer ATNs, this is an array of
+        /// <see cref="ILexerAction"/>
+        /// objects which may
+        /// be referenced by action transitions in the ATN.
+        /// </summary>
+        public ILexerAction[] lexerActions;
+
+        [NotNull]
+        public readonly IList<TokensStartState> modeToStartState = new List<TokensStartState>();
+
+        private readonly ConcurrentDictionary<PredictionContext, PredictionContext> contextCache = new ConcurrentDictionary<PredictionContext, PredictionContext>();
+
+        [NotNull]
+		public DFA[] decisionToDFA = new DFA[0];
+
+        [NotNull]
+		public DFA[] modeToDFA = new DFA[0];
+
+        protected internal readonly ConcurrentDictionary<int, int> LL1Table = new ConcurrentDictionary<int, int>();
+
+        /// <summary>Used for runtime deserialization of ATNs from strings</summary>
+        public ATN(ATNType grammarType, int maxTokenType)
+        {
+            this.grammarType = grammarType;
+            this.maxTokenType = maxTokenType;
+        }
+
+        public void ClearDFA()
+        {
+            decisionToDFA = new DFA[decisionToState.Count];
+            for (int i = 0; i < decisionToDFA.Length; i++)
+            {
+                decisionToDFA[i] = new DFA(decisionToState[i], i);
+            }
+            modeToDFA = new DFA[modeToStartState.Count];
+            for (int i_1 = 0; i_1 < modeToDFA.Length; i_1++)
+            {
+                modeToDFA[i_1] = new DFA(modeToStartState[i_1]);
+            }
+            contextCache.Clear();
+            LL1Table.Clear();
+        }
+
+        public virtual int ContextCacheSize
+        {
+            get
+            {
+                return contextCache.Count;
+            }
+        }
+
+        public virtual PredictionContext GetCachedContext(PredictionContext context)
+        {
+            return PredictionContext.GetCachedContext(context, contextCache, new PredictionContext.IdentityHashMap());
+        }
+
+        /// <summary>
+        /// Compute the set of valid tokens that can occur starting in state
+        /// <paramref name="s"/>
+        /// .
+        /// If
+        /// <paramref name="ctx"/>
+        /// is
+        /// <see cref="PredictionContext.EmptyLocal"/>
+        /// , the set of tokens will not include what can follow
+        /// the rule surrounding
+        /// <paramref name="s"/>
+        /// . In other words, the set will be
+        /// restricted to tokens reachable staying within
+        /// <paramref name="s"/>
+        /// 's rule.
+        /// </summary>
+        [return: NotNull]
+        public virtual IntervalSet NextTokens(ATNState s, PredictionContext ctx)
+        {
+            Args.NotNull("ctx", ctx);
+            LL1Analyzer anal = new LL1Analyzer(this);
+            IntervalSet next = anal.Look(s, ctx);
+            return next;
+        }
+
+        /// <summary>
+        /// Compute the set of valid tokens that can occur starting in
+        /// <paramref name="s"/>
+        /// and
+        /// staying in same rule.
+        /// <see cref="TokenConstants.Epsilon"/>
+        /// is in set if we reach end of
+        /// rule.
+        /// </summary>
+        [return: NotNull]
+        public virtual IntervalSet NextTokens(ATNState s)
+        {
+            if (s.nextTokenWithinRule != null)
+            {
+                return s.nextTokenWithinRule;
+            }
+            s.nextTokenWithinRule = NextTokens(s, PredictionContext.EmptyLocal);
+            s.nextTokenWithinRule.SetReadonly(true);
+            return s.nextTokenWithinRule;
+        }
+
+        public virtual void AddState(ATNState state)
+        {
+            if (state != null)
+            {
+                state.atn = this;
+                state.stateNumber = states.Count;
+            }
+            states.Add(state);
+        }
+
+        public virtual void RemoveState(ATNState state)
+        {
+            states[state.stateNumber] = null;
+        }
+
+        // just free mem, don't shift states in list
+        public virtual void DefineMode(string name, TokensStartState s)
+        {
+            modeNameToStartState[name] = s;
+            modeToStartState.Add(s);
+            modeToDFA = Arrays.CopyOf(modeToDFA, modeToStartState.Count);
+            modeToDFA[modeToDFA.Length - 1] = new DFA(s);
+            DefineDecisionState(s);
+        }
+
+        public virtual int DefineDecisionState(DecisionState s)
+        {
+            decisionToState.Add(s);
+            s.decision = decisionToState.Count - 1;
+            decisionToDFA = Arrays.CopyOf(decisionToDFA, decisionToState.Count);
+            decisionToDFA[decisionToDFA.Length - 1] = new DFA(s, s.decision);
+            return s.decision;
+        }
+
+        public virtual DecisionState GetDecisionState(int decision)
+        {
+            if (decisionToState.Count != 0)
+            {
+                return decisionToState[decision];
+            }
+            return null;
+        }
+
+        public virtual int NumberOfDecisions
+        {
+            get
+            {
+                return decisionToState.Count;
+            }
+        }
+
+        /// <summary>
+        /// Computes the set of input symbols which could follow ATN state number
+        /// <paramref name="stateNumber"/>
+        /// in the specified full
+        /// <paramref name="context"/>
+        /// . This method
+        /// considers the complete parser context, but does not evaluate semantic
+        /// predicates (i.e. all predicates encountered during the calculation are
+        /// assumed true). If a path in the ATN exists from the starting state to the
+        /// <see cref="RuleStopState"/>
+        /// of the outermost context without matching any
+        /// symbols,
+        /// <see cref="TokenConstants.Eof"/>
+        /// is added to the returned set.
+        /// <p>If
+        /// <paramref name="context"/>
+        /// is
+        /// <see langword="null"/>
+        /// , it is treated as
+        /// <see cref="ParserRuleContext.EmptyContext"/>
+        /// .</p>
+        /// </summary>
+        /// <param name="stateNumber">the ATN state number</param>
+        /// <param name="context">the full parse context</param>
+        /// <returns>
+        /// The set of potentially valid input symbols which could follow the
+        /// specified state in the specified context.
+        /// </returns>
+        /// <exception cref="System.ArgumentException">
+        /// if the ATN does not contain a state with
+        /// number
+        /// <paramref name="stateNumber"/>
+        /// </exception>
+        [return: NotNull]
+        public virtual IntervalSet GetExpectedTokens(int stateNumber, RuleContext context)
+        {
+            if (stateNumber < 0 || stateNumber >= states.Count)
+            {
+                throw new ArgumentException("Invalid state number.");
+            }
+            RuleContext ctx = context;
+            ATNState s = states[stateNumber];
+            IntervalSet following = NextTokens(s);
+            if (!following.Contains(TokenConstants.Epsilon))
+            {
+                return following;
+            }
+            IntervalSet expected = new IntervalSet();
+            expected.AddAll(following);
+            expected.Remove(TokenConstants.Epsilon);
+            while (ctx != null && ctx.invokingState >= 0 && following.Contains(TokenConstants.Epsilon))
+            {
+                ATNState invokingState = states[ctx.invokingState];
+                RuleTransition rt = (RuleTransition)invokingState.Transition(0);
+                following = NextTokens(rt.followState);
+                expected.AddAll(following);
+                expected.Remove(TokenConstants.Epsilon);
+                ctx = ctx.Parent;
+            }
+            if (following.Contains(TokenConstants.Epsilon))
+            {
+                expected.Add(TokenConstants.Eof);
+            }
+            return expected;
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/ATNConfig.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/ATNConfig.cs
new file mode 100644
index 000000000..6372d47a6
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/ATNConfig.cs
@@ -0,0 +1,617 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Antlr4.Runtime;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    /// <summary>A tuple: (ATN state, predicted alt, syntactic, semantic context).</summary>
+    /// <remarks>
+    /// A tuple: (ATN state, predicted alt, syntactic, semantic context).
+    /// The syntactic context is a graph-structured stack node whose
+    /// path(s) to the root is the rule invocation(s)
+    /// chain used to arrive at the state.  The semantic context is
+    /// the tree of semantic predicates encountered before reaching
+    /// an ATN state.
+    /// </remarks>
+    public class ATNConfig
+    {
+        /// <summary>
+        /// This field stores the bit mask for implementing the
+        /// <see cref="PrecedenceFilterSuppressed()"/>
+        /// property as a bit within the
+        /// existing
+        /// <see cref="altAndOuterContextDepth"/>
+        /// field.
+        /// </summary>
+        private const int SuppressPrecedenceFilter = unchecked((int)(0x80000000));
+
+        /// <summary>The ATN state associated with this configuration</summary>
+        [NotNull]
+        private readonly ATNState state;
+
+        /// <summary>This is a bit-field currently containing the following values.</summary>
+        /// <remarks>
+        /// This is a bit-field currently containing the following values.
+        /// <ul>
+        /// <li>0x00FFFFFF: Alternative</li>
+        /// <li>0x7F000000: Outer context depth</li>
+        /// <li>0x80000000: Suppress precedence filter</li>
+        /// </ul>
+        /// </remarks>
+        private int altAndOuterContextDepth;
+
+        /// <summary>
+        /// The stack of invoking states leading to the rule/states associated
+        /// with this config.
+        /// </summary>
+        /// <remarks>
+        /// The stack of invoking states leading to the rule/states associated
+        /// with this config.  We track only those contexts pushed during
+        /// execution of the ATN simulator.
+        /// </remarks>
+        [NotNull]
+        private PredictionContext context;
+
+        protected internal ATNConfig(ATNState state, int alt, PredictionContext context)
+        {
+            System.Diagnostics.Debug.Assert((alt & unchecked((int)(0xFFFFFF))) == alt);
+            this.state = state;
+            this.altAndOuterContextDepth = alt;
+            this.context = context;
+        }
+
+        protected internal ATNConfig(Antlr4.Runtime.Atn.ATNConfig c, ATNState state, PredictionContext context)
+        {
+            this.state = state;
+            this.altAndOuterContextDepth = c.altAndOuterContextDepth;
+            this.context = context;
+        }
+
+        public static Antlr4.Runtime.Atn.ATNConfig Create(ATNState state, int alt, PredictionContext context)
+        {
+            return Create(state, alt, context, Antlr4.Runtime.Atn.SemanticContext.None, null);
+        }
+
+        public static Antlr4.Runtime.Atn.ATNConfig Create(ATNState state, int alt, PredictionContext context, Antlr4.Runtime.Atn.SemanticContext semanticContext)
+        {
+            return Create(state, alt, context, semanticContext, null);
+        }
+
+        public static Antlr4.Runtime.Atn.ATNConfig Create(ATNState state, int alt, PredictionContext context, Antlr4.Runtime.Atn.SemanticContext semanticContext, LexerActionExecutor lexerActionExecutor)
+        {
+            if (semanticContext != Antlr4.Runtime.Atn.SemanticContext.None)
+            {
+                if (lexerActionExecutor != null)
+                {
+                    return new ATNConfig.ActionSemanticContextATNConfig(lexerActionExecutor, semanticContext, state, alt, context, false);
+                }
+                else
+                {
+                    return new ATNConfig.SemanticContextATNConfig(semanticContext, state, alt, context);
+                }
+            }
+            else
+            {
+                if (lexerActionExecutor != null)
+                {
+                    return new ATNConfig.ActionATNConfig(lexerActionExecutor, state, alt, context, false);
+                }
+                else
+                {
+                    return new Antlr4.Runtime.Atn.ATNConfig(state, alt, context);
+                }
+            }
+        }
+
+        /// <summary>Gets the ATN state associated with this configuration.</summary>
+        /// <remarks>Gets the ATN state associated with this configuration.</remarks>
+        public ATNState State
+        {
+            get
+            {
+                return state;
+            }
+        }
+
+        /// <summary>What alt (or lexer rule) is predicted by this configuration.</summary>
+        /// <remarks>What alt (or lexer rule) is predicted by this configuration.</remarks>
+        public int Alt
+        {
+            get
+            {
+                return altAndOuterContextDepth & unchecked((int)(0x00FFFFFF));
+            }
+        }
+
+        public virtual PredictionContext Context
+        {
+            get
+            {
+                return context;
+            }
+            set
+            {
+                PredictionContext context = value;
+                this.context = context;
+            }
+        }
+
+        public bool ReachesIntoOuterContext
+        {
+            get
+            {
+                return OuterContextDepth != 0;
+            }
+        }
+
+        /// <summary>
+        /// We cannot execute predicates dependent upon local context unless
+        /// we know for sure we are in the correct context.
+        /// </summary>
+        /// <remarks>
+        /// We cannot execute predicates dependent upon local context unless
+        /// we know for sure we are in the correct context. Because there is
+        /// no way to do this efficiently, we simply cannot evaluate
+        /// dependent predicates unless we are in the rule that initially
+        /// invokes the ATN simulator.
+        /// <p>
+        /// closure() tracks the depth of how far we dip into the outer context:
+        /// depth &gt; 0.  Note that it may not be totally accurate depth since I
+        /// don't ever decrement. TODO: make it a boolean then</p>
+        /// </remarks>
+        public virtual int OuterContextDepth
+        {
+            get
+            {
+                return ((int)(((uint)altAndOuterContextDepth) >> 24)) & unchecked((int)(0x7F));
+            }
+            set
+            {
+                int outerContextDepth = value;
+                System.Diagnostics.Debug.Assert(outerContextDepth >= 0);
+                // saturate at 0x7F - everything but zero/positive is only used for debug information anyway
+                outerContextDepth = Math.Min(outerContextDepth, unchecked((int)(0x7F)));
+                this.altAndOuterContextDepth = (outerContextDepth << 24) | (altAndOuterContextDepth & ~unchecked((int)(0x7F000000)));
+            }
+        }
+
+        public virtual LexerActionExecutor ActionExecutor
+        {
+            get
+            {
+                return null;
+            }
+        }
+
+        public virtual Antlr4.Runtime.Atn.SemanticContext SemanticContext
+        {
+            get
+            {
+                return Antlr4.Runtime.Atn.SemanticContext.None;
+            }
+        }
+
+        public virtual bool PassedThroughNonGreedyDecision
+        {
+            get
+            {
+                return false;
+            }
+        }
+
+        public Antlr4.Runtime.Atn.ATNConfig Clone()
+        {
+            return Transform(this.State, false);
+        }
+
+        public Antlr4.Runtime.Atn.ATNConfig Transform(ATNState state, bool checkNonGreedy)
+        {
+            return Transform(state, this.context, this.SemanticContext, checkNonGreedy, this.ActionExecutor);
+        }
+
+        public Antlr4.Runtime.Atn.ATNConfig Transform(ATNState state, Antlr4.Runtime.Atn.SemanticContext semanticContext, bool checkNonGreedy)
+        {
+            return Transform(state, this.context, semanticContext, checkNonGreedy, this.ActionExecutor);
+        }
+
+        public Antlr4.Runtime.Atn.ATNConfig Transform(ATNState state, PredictionContext context, bool checkNonGreedy)
+        {
+            return Transform(state, context, this.SemanticContext, checkNonGreedy, this.ActionExecutor);
+        }
+
+        public Antlr4.Runtime.Atn.ATNConfig Transform(ATNState state, LexerActionExecutor lexerActionExecutor, bool checkNonGreedy)
+        {
+            return Transform(state, context, this.SemanticContext, checkNonGreedy, lexerActionExecutor);
+        }
+
+        private Antlr4.Runtime.Atn.ATNConfig Transform(ATNState state, PredictionContext context, Antlr4.Runtime.Atn.SemanticContext semanticContext, bool checkNonGreedy, LexerActionExecutor lexerActionExecutor)
+        {
+            bool passedThroughNonGreedy = checkNonGreedy && CheckNonGreedyDecision(this, state);
+            if (semanticContext != Antlr4.Runtime.Atn.SemanticContext.None)
+            {
+                if (lexerActionExecutor != null || passedThroughNonGreedy)
+                {
+                    return new ATNConfig.ActionSemanticContextATNConfig(lexerActionExecutor, semanticContext, this, state, context, passedThroughNonGreedy);
+                }
+                else
+                {
+                    return new ATNConfig.SemanticContextATNConfig(semanticContext, this, state, context);
+                }
+            }
+            else
+            {
+                if (lexerActionExecutor != null || passedThroughNonGreedy)
+                {
+                    return new ATNConfig.ActionATNConfig(lexerActionExecutor, this, state, context, passedThroughNonGreedy);
+                }
+                else
+                {
+                    return new Antlr4.Runtime.Atn.ATNConfig(this, state, context);
+                }
+            }
+        }
+
+        private static bool CheckNonGreedyDecision(Antlr4.Runtime.Atn.ATNConfig source, ATNState target)
+        {
+            return source.PassedThroughNonGreedyDecision || target is DecisionState && ((DecisionState)target).nonGreedy;
+        }
+
+        public virtual Antlr4.Runtime.Atn.ATNConfig AppendContext(int context, PredictionContextCache contextCache)
+        {
+            PredictionContext appendedContext = Context.AppendContext(context, contextCache);
+            Antlr4.Runtime.Atn.ATNConfig result = Transform(State, appendedContext, false);
+            return result;
+        }
+
+        public virtual Antlr4.Runtime.Atn.ATNConfig AppendContext(PredictionContext context, PredictionContextCache contextCache)
+        {
+            PredictionContext appendedContext = Context.AppendContext(context, contextCache);
+            Antlr4.Runtime.Atn.ATNConfig result = Transform(State, appendedContext, false);
+            return result;
+        }
+
+        public virtual bool Contains(Antlr4.Runtime.Atn.ATNConfig subconfig)
+        {
+            if (this.state.stateNumber != subconfig.State.stateNumber || this.Alt != subconfig.Alt || !this.SemanticContext.Equals(subconfig.SemanticContext))
+            {
+                return false;
+            }
+            Stack<PredictionContext> leftWorkList = new Stack<PredictionContext>();
+            Stack<PredictionContext> rightWorkList = new Stack<PredictionContext>();
+            leftWorkList.Push(Context);
+            rightWorkList.Push(subconfig.Context);
+            while (leftWorkList.Count > 0)
+            {
+                PredictionContext left = leftWorkList.Pop();
+                PredictionContext right = rightWorkList.Pop();
+                if (left == right)
+                {
+                    return true;
+                }
+                if (left.Size < right.Size)
+                {
+                    return false;
+                }
+                if (right.IsEmpty)
+                {
+                    return left.HasEmpty;
+                }
+                else
+                {
+                    for (int i = 0; i < right.Size; i++)
+                    {
+                        int index = left.FindReturnState(right.GetReturnState(i));
+                        if (index < 0)
+                        {
+                            // assumes invokingStates has no duplicate entries
+                            return false;
+                        }
+                        leftWorkList.Push(left.GetParent(index));
+                        rightWorkList.Push(right.GetParent(i));
+                    }
+                }
+            }
+            return false;
+        }
+
+        public bool PrecedenceFilterSuppressed
+        {
+            get
+            {
+                return (altAndOuterContextDepth & SuppressPrecedenceFilter) != 0;
+            }
+            set
+            {
+                if (value)
+                {
+                    this.altAndOuterContextDepth |= SuppressPrecedenceFilter;
+                }
+                else
+                {
+                    this.altAndOuterContextDepth &= ~SuppressPrecedenceFilter;
+                }
+            }
+        }
+
+        /// <summary>
+        /// An ATN configuration is equal to another if both have
+        /// the same state, they predict the same alternative, and
+        /// syntactic/semantic contexts are the same.
+        /// </summary>
+        /// <remarks>
+        /// An ATN configuration is equal to another if both have
+        /// the same state, they predict the same alternative, and
+        /// syntactic/semantic contexts are the same.
+        /// </remarks>
+        public override bool Equals(object o)
+        {
+            if (!(o is Antlr4.Runtime.Atn.ATNConfig))
+            {
+                return false;
+            }
+            return this.Equals((Antlr4.Runtime.Atn.ATNConfig)o);
+        }
+
+        public virtual bool Equals(Antlr4.Runtime.Atn.ATNConfig other)
+        {
+            if (this == other)
+            {
+                return true;
+            }
+            else
+            {
+                if (other == null)
+                {
+                    return false;
+                }
+            }
+            return this.State.stateNumber == other.State.stateNumber && this.Alt == other.Alt && this.ReachesIntoOuterContext == other.ReachesIntoOuterContext && this.Context.Equals(other.Context) && this.SemanticContext.Equals(other.SemanticContext) && this.PrecedenceFilterSuppressed == other.PrecedenceFilterSuppressed && this.PassedThroughNonGreedyDecision == other.PassedThroughNonGreedyDecision && EqualityComparer<LexerActionExecutor>.Default.Equals(this.ActionExecutor, other.ActionExecutor);
+        }
+
+        public override int GetHashCode()
+        {
+            int hashCode = MurmurHash.Initialize(7);
+            hashCode = MurmurHash.Update(hashCode, State.stateNumber);
+            hashCode = MurmurHash.Update(hashCode, Alt);
+            hashCode = MurmurHash.Update(hashCode, ReachesIntoOuterContext ? 1 : 0);
+            hashCode = MurmurHash.Update(hashCode, Context);
+            hashCode = MurmurHash.Update(hashCode, SemanticContext);
+            hashCode = MurmurHash.Update(hashCode, PassedThroughNonGreedyDecision ? 1 : 0);
+            hashCode = MurmurHash.Update(hashCode, ActionExecutor);
+            hashCode = MurmurHash.Finish(hashCode, 7);
+            return hashCode;
+        }
+
+        public virtual string ToDotString()
+        {
+#if COMPACT
+            throw new NotImplementedException("The current platform does not provide RuntimeHelpers.GetHashCode(object).");
+#else
+            StringBuilder builder = new StringBuilder();
+            builder.Append("digraph G {\n");
+            builder.Append("rankdir=LR;\n");
+            HashSet<PredictionContext> visited = new HashSet<PredictionContext>();
+            Stack<PredictionContext> workList = new Stack<PredictionContext>();
+            workList.Push(Context);
+            visited.Add(Context);
+            while (workList.Count > 0)
+            {
+                PredictionContext current = workList.Pop();
+                for (int i = 0; i < current.Size; i++)
+                {
+                    builder.Append("  s").Append(System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(current));
+                    builder.Append("->");
+                    builder.Append("s").Append(System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(current.GetParent(i)));
+                    builder.Append("[label=\"").Append(current.GetReturnState(i)).Append("\"];\n");
+                    if (visited.Add(current.GetParent(i)))
+                    {
+                        workList.Push(current.GetParent(i));
+                    }
+                }
+            }
+            builder.Append("}\n");
+            return builder.ToString();
+#endif
+        }
+
+        public override string ToString()
+        {
+            return ToString(null, true, false);
+        }
+
+        public virtual string ToString(IRecognizer recog, bool showAlt)
+        {
+            return ToString(recog, showAlt, true);
+        }
+
+        public virtual string ToString(IRecognizer recog, bool showAlt, bool showContext)
+        {
+            StringBuilder buf = new StringBuilder();
+            //		if ( state.ruleIndex>=0 ) {
+            //			if ( recog!=null ) buf.append(recog.getRuleNames()[state.ruleIndex]+":");
+            //			else buf.append(state.ruleIndex+":");
+            //		}
+            string[] contexts;
+            if (showContext)
+            {
+                contexts = Context.ToStrings(recog, this.State.stateNumber);
+            }
+            else
+            {
+                contexts = new string[] { "?" };
+            }
+            bool first = true;
+            foreach (string contextDesc in contexts)
+            {
+                if (first)
+                {
+                    first = false;
+                }
+                else
+                {
+                    buf.Append(", ");
+                }
+                buf.Append('(');
+                buf.Append(State);
+                if (showAlt)
+                {
+                    buf.Append(",");
+                    buf.Append(Alt);
+                }
+                if (Context != null)
+                {
+                    buf.Append(",");
+                    buf.Append(contextDesc);
+                }
+                if (SemanticContext != null && SemanticContext != Antlr4.Runtime.Atn.SemanticContext.None)
+                {
+                    buf.Append(",");
+                    buf.Append(SemanticContext);
+                }
+                if (ReachesIntoOuterContext)
+                {
+                    buf.Append(",up=").Append(OuterContextDepth);
+                }
+                buf.Append(')');
+            }
+            return buf.ToString();
+        }
+
+        private class SemanticContextATNConfig : ATNConfig
+        {
+            [NotNull]
+            private readonly Antlr4.Runtime.Atn.SemanticContext semanticContext;
+
+            public SemanticContextATNConfig(Antlr4.Runtime.Atn.SemanticContext semanticContext, ATNState state, int alt, PredictionContext context)
+                : base(state, alt, context)
+            {
+                this.semanticContext = semanticContext;
+            }
+
+            public SemanticContextATNConfig(Antlr4.Runtime.Atn.SemanticContext semanticContext, ATNConfig c, ATNState state, PredictionContext context)
+                : base(c, state, context)
+            {
+                this.semanticContext = semanticContext;
+            }
+
+            public override Antlr4.Runtime.Atn.SemanticContext SemanticContext
+            {
+                get
+                {
+                    return semanticContext;
+                }
+            }
+        }
+
+        private class ActionATNConfig : ATNConfig
+        {
+            private readonly LexerActionExecutor lexerActionExecutor;
+
+            private readonly bool passedThroughNonGreedyDecision;
+
+            public ActionATNConfig(LexerActionExecutor lexerActionExecutor, ATNState state, int alt, PredictionContext context, bool passedThroughNonGreedyDecision)
+                : base(state, alt, context)
+            {
+                this.lexerActionExecutor = lexerActionExecutor;
+                this.passedThroughNonGreedyDecision = passedThroughNonGreedyDecision;
+            }
+
+            protected internal ActionATNConfig(LexerActionExecutor lexerActionExecutor, ATNConfig c, ATNState state, PredictionContext context, bool passedThroughNonGreedyDecision)
+                : base(c, state, context)
+            {
+                if (c.SemanticContext != SemanticContext.None)
+                {
+                    throw new NotSupportedException();
+                }
+                this.lexerActionExecutor = lexerActionExecutor;
+                this.passedThroughNonGreedyDecision = passedThroughNonGreedyDecision;
+            }
+
+            public override LexerActionExecutor ActionExecutor
+            {
+                get
+                {
+                    return lexerActionExecutor;
+                }
+            }
+
+            public override bool PassedThroughNonGreedyDecision
+            {
+                get
+                {
+                    return passedThroughNonGreedyDecision;
+                }
+            }
+        }
+
+        private class ActionSemanticContextATNConfig : ATNConfig.SemanticContextATNConfig
+        {
+            private readonly LexerActionExecutor lexerActionExecutor;
+
+            private readonly bool passedThroughNonGreedyDecision;
+
+            public ActionSemanticContextATNConfig(LexerActionExecutor lexerActionExecutor, SemanticContext semanticContext, ATNState state, int alt, PredictionContext context, bool passedThroughNonGreedyDecision)
+                : base(semanticContext, state, alt, context)
+            {
+                this.lexerActionExecutor = lexerActionExecutor;
+                this.passedThroughNonGreedyDecision = passedThroughNonGreedyDecision;
+            }
+
+            public ActionSemanticContextATNConfig(LexerActionExecutor lexerActionExecutor, SemanticContext semanticContext, ATNConfig c, ATNState state, PredictionContext context, bool passedThroughNonGreedyDecision)
+                : base(semanticContext, c, state, context)
+            {
+                this.lexerActionExecutor = lexerActionExecutor;
+                this.passedThroughNonGreedyDecision = passedThroughNonGreedyDecision;
+            }
+
+            public override LexerActionExecutor ActionExecutor
+            {
+                get
+                {
+                    return lexerActionExecutor;
+                }
+            }
+
+            public override bool PassedThroughNonGreedyDecision
+            {
+                get
+                {
+                    return passedThroughNonGreedyDecision;
+                }
+            }
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/ATNConfigSet.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/ATNConfigSet.cs
new file mode 100644
index 000000000..9d3699390
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/ATNConfigSet.cs
@@ -0,0 +1,681 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+using IEnumerable = System.Collections.IEnumerable;
+using IEnumerator = System.Collections.IEnumerator;
+
+namespace Antlr4.Runtime.Atn
+{
+    /// <author>Sam Harwell</author>
+    public class ATNConfigSet : IEnumerable<ATNConfig>
+    {
+        /// <summary>
+        /// This maps (state, alt) -&gt; merged
+        /// <see cref="ATNConfig"/>
+        /// . The key does not account for
+        /// the
+        /// <see cref="ATNConfig.SemanticContext()"/>
+        /// of the value, which is only a problem if a single
+        /// <c>ATNConfigSet</c>
+        /// contains two configs with the same state and alternative
+        /// but different semantic contexts. When this case arises, the first config
+        /// added to this map stays, and the remaining configs are placed in
+        /// <see cref="unmerged"/>
+        /// .
+        /// <p/>
+        /// This map is only used for optimizing the process of adding configs to the set,
+        /// and is
+        /// <see langword="null"/>
+        /// for read-only sets stored in the DFA.
+        /// </summary>
+        private readonly Dictionary<long, ATNConfig> mergedConfigs;
+
+        /// <summary>
+        /// This is an "overflow" list holding configs which cannot be merged with one
+        /// of the configs in
+        /// <see cref="mergedConfigs"/>
+        /// but have a colliding key. This
+        /// occurs when two configs in the set have the same state and alternative but
+        /// different semantic contexts.
+        /// <p/>
+        /// This list is only used for optimizing the process of adding configs to the set,
+        /// and is
+        /// <see langword="null"/>
+        /// for read-only sets stored in the DFA.
+        /// </summary>
+        private readonly List<ATNConfig> unmerged;
+
+        /// <summary>This is a list of all configs in this set.</summary>
+        /// <remarks>This is a list of all configs in this set.</remarks>
+        private readonly List<ATNConfig> configs;
+
+        private int uniqueAlt;
+
+        private ConflictInfo conflictInfo;
+
+        private bool hasSemanticContext;
+
+        private bool dipsIntoOuterContext;
+
+        /// <summary>
+        /// When
+        /// <see langword="true"/>
+        /// , this config set represents configurations where the entire
+        /// outer context has been consumed by the ATN interpreter. This prevents the
+        /// <see cref="ParserATNSimulator.Closure(ATNConfigSet, ATNConfigSet, bool, bool, PredictionContextCache, bool)"/>
+        /// from pursuing the global FOLLOW when a
+        /// rule stop state is reached with an empty prediction context.
+        /// <p/>
+        /// Note:
+        /// <c>outermostConfigSet</c>
+        /// and
+        /// <see cref="dipsIntoOuterContext"/>
+        /// should never
+        /// be true at the same time.
+        /// </summary>
+        private bool outermostConfigSet;
+
+        private int cachedHashCode = -1;
+
+        public ATNConfigSet()
+        {
+            // Used in parser and lexer. In lexer, it indicates we hit a pred
+            // while computing a closure operation.  Don't make a DFA state from this.
+            this.mergedConfigs = new Dictionary<long, ATNConfig>();
+            this.unmerged = new List<ATNConfig>();
+            this.configs = new List<ATNConfig>();
+            this.uniqueAlt = ATN.InvalidAltNumber;
+        }
+
+        protected internal ATNConfigSet(Antlr4.Runtime.Atn.ATNConfigSet set, bool @readonly)
+        {
+            if (@readonly)
+            {
+                this.mergedConfigs = null;
+                this.unmerged = null;
+            }
+            else
+            {
+                if (!set.IsReadOnly)
+                {
+                    this.mergedConfigs = new Dictionary<long, ATNConfig>(set.mergedConfigs);
+                    this.unmerged = new List<ATNConfig>(set.unmerged);
+                }
+                else
+                {
+                    this.mergedConfigs = new Dictionary<long, ATNConfig>(set.configs.Count);
+                    this.unmerged = new List<ATNConfig>();
+                }
+            }
+            this.configs = new List<ATNConfig>(set.configs);
+            this.dipsIntoOuterContext = set.dipsIntoOuterContext;
+            this.hasSemanticContext = set.hasSemanticContext;
+            this.outermostConfigSet = set.outermostConfigSet;
+            if (@readonly || !set.IsReadOnly)
+            {
+                this.uniqueAlt = set.uniqueAlt;
+                this.conflictInfo = set.conflictInfo;
+            }
+        }
+
+        /// <summary>
+        /// Get the set of all alternatives represented by configurations in this
+        /// set.
+        /// </summary>
+        /// <remarks>
+        /// Get the set of all alternatives represented by configurations in this
+        /// set.
+        /// </remarks>
+        [NotNull]
+        public virtual BitSet RepresentedAlternatives
+        {
+            get
+            {
+                // if (!readonly && set.isReadOnly()) -> addAll is called from clone()
+                if (conflictInfo != null)
+                {
+                    return (BitSet)conflictInfo.ConflictedAlts.Clone();
+                }
+                BitSet alts = new BitSet();
+                foreach (ATNConfig config in this)
+                {
+                    alts.Set(config.Alt);
+                }
+                return alts;
+            }
+        }
+
+        public bool IsReadOnly
+        {
+            get
+            {
+                return mergedConfigs == null;
+            }
+        }
+
+        public virtual bool IsOutermostConfigSet
+        {
+            get
+            {
+                return outermostConfigSet;
+            }
+            set
+            {
+                bool outermostConfigSet = value;
+                if (this.outermostConfigSet && !outermostConfigSet)
+                {
+                    throw new InvalidOperationException();
+                }
+                System.Diagnostics.Debug.Assert(!outermostConfigSet || !dipsIntoOuterContext);
+                this.outermostConfigSet = outermostConfigSet;
+            }
+        }
+
+        public virtual HashSet<ATNState> States
+        {
+            get
+            {
+                HashSet<ATNState> states = new HashSet<ATNState>();
+                foreach (ATNConfig c in this.configs)
+                {
+                    states.Add(c.State);
+                }
+                return states;
+            }
+        }
+
+        public virtual void OptimizeConfigs(ATNSimulator interpreter)
+        {
+            if (configs.Count == 0)
+            {
+                return;
+            }
+            for (int i = 0; i < configs.Count; i++)
+            {
+                ATNConfig config = configs[i];
+                config.Context = interpreter.atn.GetCachedContext(config.Context);
+            }
+        }
+
+        public virtual Antlr4.Runtime.Atn.ATNConfigSet Clone(bool @readonly)
+        {
+            Antlr4.Runtime.Atn.ATNConfigSet copy = new Antlr4.Runtime.Atn.ATNConfigSet(this, @readonly);
+            if (!@readonly && this.IsReadOnly)
+            {
+                copy.AddAll(configs);
+            }
+            return copy;
+        }
+
+        public virtual int Count
+        {
+            get
+            {
+                return configs.Count;
+            }
+        }
+
+        public virtual bool IsEmpty()
+        {
+            return configs.Count == 0;
+        }
+
+        public virtual bool Contains(object o)
+        {
+            if (!(o is ATNConfig))
+            {
+                return false;
+            }
+            ATNConfig config = (ATNConfig)o;
+            long configKey = GetKey(config);
+            ATNConfig mergedConfig;
+            if (mergedConfigs.TryGetValue(configKey, out mergedConfig) && CanMerge(config, configKey, mergedConfig))
+            {
+                return mergedConfig.Contains(config);
+            }
+            foreach (ATNConfig c in unmerged)
+            {
+                if (c.Contains(config))
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        public virtual IEnumerator<ATNConfig> GetEnumerator()
+        {
+            return configs.GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+        public virtual object[] ToArray()
+        {
+            return configs.ToArray();
+        }
+
+        public virtual bool Add(ATNConfig e)
+        {
+            return Add(e, null);
+        }
+
+        public virtual bool Add(ATNConfig e, PredictionContextCache contextCache)
+        {
+            EnsureWritable();
+            System.Diagnostics.Debug.Assert(!outermostConfigSet || !e.ReachesIntoOuterContext);
+            if (contextCache == null)
+            {
+                contextCache = PredictionContextCache.Uncached;
+            }
+            bool addKey;
+            long key = GetKey(e);
+            ATNConfig mergedConfig;
+            addKey = !mergedConfigs.TryGetValue(key, out mergedConfig);
+            if (mergedConfig != null && CanMerge(e, key, mergedConfig))
+            {
+                mergedConfig.OuterContextDepth = Math.Max(mergedConfig.OuterContextDepth, e.OuterContextDepth);
+                if (e.PrecedenceFilterSuppressed)
+                {
+                    mergedConfig.PrecedenceFilterSuppressed = true;
+                }
+                PredictionContext joined = PredictionContext.Join(mergedConfig.Context, e.Context, contextCache);
+                UpdatePropertiesForMergedConfig(e);
+                if (mergedConfig.Context == joined)
+                {
+                    return false;
+                }
+                mergedConfig.Context = joined;
+                return true;
+            }
+            for (int i = 0; i < unmerged.Count; i++)
+            {
+                ATNConfig unmergedConfig = unmerged[i];
+                if (CanMerge(e, key, unmergedConfig))
+                {
+                    unmergedConfig.OuterContextDepth = Math.Max(unmergedConfig.OuterContextDepth, e.OuterContextDepth);
+                    if (e.PrecedenceFilterSuppressed)
+                    {
+                        unmergedConfig.PrecedenceFilterSuppressed = true;
+                    }
+                    PredictionContext joined = PredictionContext.Join(unmergedConfig.Context, e.Context, contextCache);
+                    UpdatePropertiesForMergedConfig(e);
+                    if (unmergedConfig.Context == joined)
+                    {
+                        return false;
+                    }
+                    unmergedConfig.Context = joined;
+                    if (addKey)
+                    {
+                        mergedConfigs[key] = unmergedConfig;
+                        unmerged.RemoveAt(i);
+                    }
+                    return true;
+                }
+            }
+            configs.Add(e);
+            if (addKey)
+            {
+                mergedConfigs[key] = e;
+            }
+            else
+            {
+                unmerged.Add(e);
+            }
+            UpdatePropertiesForAddedConfig(e);
+            return true;
+        }
+
+        private void UpdatePropertiesForMergedConfig(ATNConfig config)
+        {
+            // merged configs can't change the alt or semantic context
+            dipsIntoOuterContext |= config.ReachesIntoOuterContext;
+            System.Diagnostics.Debug.Assert(!outermostConfigSet || !dipsIntoOuterContext);
+        }
+
+        private void UpdatePropertiesForAddedConfig(ATNConfig config)
+        {
+            if (configs.Count == 1)
+            {
+                uniqueAlt = config.Alt;
+            }
+            else
+            {
+                if (uniqueAlt != config.Alt)
+                {
+                    uniqueAlt = ATN.InvalidAltNumber;
+                }
+            }
+            hasSemanticContext |= !SemanticContext.None.Equals(config.SemanticContext);
+            dipsIntoOuterContext |= config.ReachesIntoOuterContext;
+            System.Diagnostics.Debug.Assert(!outermostConfigSet || !dipsIntoOuterContext);
+        }
+
+        protected internal virtual bool CanMerge(ATNConfig left, long leftKey, ATNConfig right)
+        {
+            if (left.State.stateNumber != right.State.stateNumber)
+            {
+                return false;
+            }
+            if (leftKey != GetKey(right))
+            {
+                return false;
+            }
+            return left.SemanticContext.Equals(right.SemanticContext);
+        }
+
+        protected internal virtual long GetKey(ATNConfig e)
+        {
+            long key = e.State.stateNumber;
+            key = (key << 12) | (e.Alt & 0xFFFL);
+            return key;
+        }
+
+        public virtual bool Remove(object o)
+        {
+            EnsureWritable();
+            throw new NotSupportedException("Not supported yet.");
+        }
+
+        public virtual bool ContainsAll(IEnumerable<ATNConfig> c)
+        {
+            foreach (ATNConfig o in c)
+            {
+                if (!Contains(o))
+                {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        public virtual bool AddAll(IEnumerable<ATNConfig> c)
+        {
+            return AddAll(c, null);
+        }
+
+        public virtual bool AddAll(IEnumerable<ATNConfig> c, PredictionContextCache contextCache)
+        {
+            EnsureWritable();
+            bool changed = false;
+            foreach (ATNConfig group in c)
+            {
+                changed |= Add(group, contextCache);
+            }
+            return changed;
+        }
+
+        public virtual bool RetainAll<_T0>(ICollection<_T0> c)
+        {
+            EnsureWritable();
+            throw new NotSupportedException("Not supported yet.");
+        }
+
+        public virtual bool RemoveAll<_T0>(ICollection<_T0> c)
+        {
+            EnsureWritable();
+            throw new NotSupportedException("Not supported yet.");
+        }
+
+        public virtual void Clear()
+        {
+            EnsureWritable();
+            mergedConfigs.Clear();
+            unmerged.Clear();
+            configs.Clear();
+            dipsIntoOuterContext = false;
+            hasSemanticContext = false;
+            uniqueAlt = ATN.InvalidAltNumber;
+            conflictInfo = null;
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (this == obj)
+            {
+                return true;
+            }
+            if (!(obj is Antlr4.Runtime.Atn.ATNConfigSet))
+            {
+                return false;
+            }
+            Antlr4.Runtime.Atn.ATNConfigSet other = (Antlr4.Runtime.Atn.ATNConfigSet)obj;
+            return this.outermostConfigSet == other.outermostConfigSet && Utils.Equals(conflictInfo, other.conflictInfo) && configs.SequenceEqual(other.configs);
+        }
+
+        public override int GetHashCode()
+        {
+            if (IsReadOnly && cachedHashCode != -1)
+            {
+                return cachedHashCode;
+            }
+            int hashCode = 1;
+            hashCode = 5 * hashCode ^ (outermostConfigSet ? 1 : 0);
+            hashCode = 5 * hashCode ^ SequenceEqualityComparer<ATNConfig>.Default.GetHashCode(configs);
+            if (IsReadOnly)
+            {
+                cachedHashCode = hashCode;
+            }
+            return hashCode;
+        }
+
+        public override string ToString()
+        {
+            return ToString(false);
+        }
+
+        public virtual string ToString(bool showContext)
+        {
+            StringBuilder buf = new StringBuilder();
+            List<ATNConfig> sortedConfigs = new List<ATNConfig>(configs);
+            sortedConfigs.Sort(new _IComparer_475());
+            buf.Append("[");
+            for (int i = 0; i < sortedConfigs.Count; i++)
+            {
+                if (i > 0)
+                {
+                    buf.Append(", ");
+                }
+                buf.Append(sortedConfigs[i].ToString(null, true, showContext));
+            }
+            buf.Append("]");
+            if (hasSemanticContext)
+            {
+                buf.Append(",hasSemanticContext=").Append(hasSemanticContext);
+            }
+            if (uniqueAlt != ATN.InvalidAltNumber)
+            {
+                buf.Append(",uniqueAlt=").Append(uniqueAlt);
+            }
+            if (conflictInfo != null)
+            {
+                buf.Append(",conflictingAlts=").Append(conflictInfo.ConflictedAlts);
+                if (!conflictInfo.IsExact)
+                {
+                    buf.Append("*");
+                }
+            }
+            if (dipsIntoOuterContext)
+            {
+                buf.Append(",dipsIntoOuterContext");
+            }
+            return buf.ToString();
+        }
+
+        private sealed class _IComparer_475 : IComparer<ATNConfig>
+        {
+            public _IComparer_475()
+            {
+            }
+
+            public int Compare(ATNConfig o1, ATNConfig o2)
+            {
+                if (o1.Alt != o2.Alt)
+                {
+                    return o1.Alt - o2.Alt;
+                }
+                else
+                {
+                    if (o1.State.stateNumber != o2.State.stateNumber)
+                    {
+                        return o1.State.stateNumber - o2.State.stateNumber;
+                    }
+                    else
+                    {
+                        return string.CompareOrdinal(o1.SemanticContext.ToString(), o2.SemanticContext.ToString());
+                    }
+                }
+            }
+        }
+
+        public virtual int UniqueAlt
+        {
+            get
+            {
+                return uniqueAlt;
+            }
+        }
+
+        public virtual bool HasSemanticContext
+        {
+            get
+            {
+                return hasSemanticContext;
+            }
+        }
+
+        public virtual void ClearExplicitSemanticContext()
+        {
+            EnsureWritable();
+            hasSemanticContext = false;
+        }
+
+        public virtual void MarkExplicitSemanticContext()
+        {
+            EnsureWritable();
+            hasSemanticContext = true;
+        }
+
+        public virtual ConflictInfo ConflictInformation
+        {
+            get
+            {
+                return conflictInfo;
+            }
+            set
+            {
+                ConflictInfo conflictInfo = value;
+                EnsureWritable();
+                this.conflictInfo = conflictInfo;
+            }
+        }
+
+        public virtual BitSet ConflictingAlts
+        {
+            get
+            {
+                if (conflictInfo == null)
+                {
+                    return null;
+                }
+                return conflictInfo.ConflictedAlts;
+            }
+        }
+
+        public virtual bool IsExactConflict
+        {
+            get
+            {
+                if (conflictInfo == null)
+                {
+                    return false;
+                }
+                return conflictInfo.IsExact;
+            }
+        }
+
+        public virtual bool DipsIntoOuterContext
+        {
+            get
+            {
+                return dipsIntoOuterContext;
+            }
+        }
+
+        public virtual ATNConfig this[int index]
+        {
+            get
+            {
+                return configs[index];
+            }
+        }
+
+        public virtual void Remove(int index)
+        {
+            EnsureWritable();
+            ATNConfig config = configs[index];
+            configs.Remove(config);
+            long key = GetKey(config);
+            ATNConfig existing;
+            if (mergedConfigs.TryGetValue(key, out existing) && existing == config)
+            {
+                mergedConfigs.Remove(key);
+            }
+            else
+            {
+                for (int i = 0; i < unmerged.Count; i++)
+                {
+                    if (unmerged[i] == config)
+                    {
+                        unmerged.RemoveAt(i);
+                        return;
+                    }
+                }
+            }
+        }
+
+        protected internal void EnsureWritable()
+        {
+            if (IsReadOnly)
+            {
+                throw new InvalidOperationException("This ATNConfigSet is read only.");
+            }
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/ATNDeserializationOptions.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/ATNDeserializationOptions.cs
new file mode 100644
index 000000000..c104dac7e
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/ATNDeserializationOptions.cs
@@ -0,0 +1,141 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    /// <author>Sam Harwell</author>
+    public class ATNDeserializationOptions
+    {
+        private static readonly Antlr4.Runtime.Atn.ATNDeserializationOptions defaultOptions;
+
+        static ATNDeserializationOptions()
+        {
+            defaultOptions = new Antlr4.Runtime.Atn.ATNDeserializationOptions();
+            defaultOptions.MakeReadOnly();
+        }
+
+        private bool readOnly;
+
+        private bool verifyATN;
+
+        private bool generateRuleBypassTransitions;
+
+        private bool optimize;
+
+        public ATNDeserializationOptions()
+        {
+            this.verifyATN = true;
+            this.generateRuleBypassTransitions = false;
+            this.optimize = true;
+        }
+
+        public ATNDeserializationOptions(Antlr4.Runtime.Atn.ATNDeserializationOptions options)
+        {
+            this.verifyATN = options.verifyATN;
+            this.generateRuleBypassTransitions = options.generateRuleBypassTransitions;
+            this.optimize = options.optimize;
+        }
+
+        [NotNull]
+        public static Antlr4.Runtime.Atn.ATNDeserializationOptions Default
+        {
+            get
+            {
+                return defaultOptions;
+            }
+        }
+
+        public bool IsReadOnly
+        {
+            get
+            {
+                return readOnly;
+            }
+        }
+
+        public void MakeReadOnly()
+        {
+            readOnly = true;
+        }
+
+        public bool VerifyAtn
+        {
+            get
+            {
+                return verifyATN;
+            }
+            set
+            {
+                bool verifyATN = value;
+                ThrowIfReadOnly();
+                this.verifyATN = verifyATN;
+            }
+        }
+
+        public bool GenerateRuleBypassTransitions
+        {
+            get
+            {
+                return generateRuleBypassTransitions;
+            }
+            set
+            {
+                bool generateRuleBypassTransitions = value;
+                ThrowIfReadOnly();
+                this.generateRuleBypassTransitions = generateRuleBypassTransitions;
+            }
+        }
+
+        public bool Optimize
+        {
+            get
+            {
+                return optimize;
+            }
+            set
+            {
+                bool optimize = value;
+                ThrowIfReadOnly();
+                this.optimize = optimize;
+            }
+        }
+
+        protected internal virtual void ThrowIfReadOnly()
+        {
+            if (IsReadOnly)
+            {
+                throw new InvalidOperationException("The object is read only.");
+            }
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/ATNDeserializer.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/ATNDeserializer.cs
new file mode 100644
index 000000000..c98988fa8
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/ATNDeserializer.cs
@@ -0,0 +1,1329 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Dfa;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    /// <author>Sam Harwell</author>
+    public class ATNDeserializer
+    {
+        public static readonly int SerializedVersion = 3;
+
+        /// <summary>This is the earliest supported serialized UUID.</summary>
+        /// <remarks>This is the earliest supported serialized UUID.</remarks>
+        private static readonly Guid BaseSerializedUuid;
+
+        /// <summary>
+        /// This list contains all of the currently supported UUIDs, ordered by when
+        /// the feature first appeared in this branch.
+        /// </summary>
+        /// <remarks>
+        /// This list contains all of the currently supported UUIDs, ordered by when
+        /// the feature first appeared in this branch.
+        /// </remarks>
+        private static readonly IList<Guid> SupportedUuids;
+
+        /// <summary>This is the current serialized UUID.</summary>
+        /// <remarks>This is the current serialized UUID.</remarks>
+        public static readonly Guid SerializedUuid;
+
+        static ATNDeserializer()
+        {
+			BaseSerializedUuid = new Guid("AADB8D7E-AEEF-4415-AD2B-8204D6CF042E");
+            SupportedUuids = new List<Guid>();
+            SupportedUuids.Add(BaseSerializedUuid);
+			SerializedUuid = BaseSerializedUuid;
+        }
+
+        [NotNull]
+        private readonly ATNDeserializationOptions deserializationOptions;
+
+        public ATNDeserializer()
+            : this(ATNDeserializationOptions.Default)
+        {
+        }
+
+        public ATNDeserializer(ATNDeserializationOptions deserializationOptions)
+        {
+            if (deserializationOptions == null)
+            {
+                deserializationOptions = ATNDeserializationOptions.Default;
+            }
+            this.deserializationOptions = deserializationOptions;
+        }
+
+        /// <summary>
+        /// Determines if a particular serialized representation of an ATN supports
+        /// a particular feature, identified by the
+        /// <see cref="Guid"/>
+        /// used for serializing
+        /// the ATN at the time the feature was first introduced.
+        /// </summary>
+        /// <param name="feature">
+        /// The
+        /// <see cref="Guid"/>
+        /// marking the first time the feature was
+        /// supported in the serialized ATN.
+        /// </param>
+        /// <param name="actualUuid">
+        /// The
+        /// <see cref="Guid"/>
+        /// of the actual serialized ATN which is
+        /// currently being deserialized.
+        /// </param>
+        /// <returns>
+        /// 
+        /// <see langword="true"/>
+        /// if the
+        /// <paramref name="actualUuid"/>
+        /// value represents a
+        /// serialized ATN at or after the feature identified by
+        /// <paramref name="feature"/>
+        /// was
+        /// introduced; otherwise,
+        /// <see langword="false"/>
+        /// .
+        /// </returns>
+        protected internal virtual bool IsFeatureSupported(Guid feature, Guid actualUuid)
+        {
+            int featureIndex = SupportedUuids.IndexOf(feature);
+            if (featureIndex < 0)
+            {
+                return false;
+            }
+            return SupportedUuids.IndexOf(actualUuid) >= featureIndex;
+        }
+
+		char[] data;
+		int p;
+
+        public virtual ATN Deserialize(char[] data)
+        {
+			Reset (data);
+			CheckVersion ();
+			CheckUUID ();
+			ATN atn = ReadATN ();
+			ReadStates (atn);
+			ReadRules (atn);
+			ReadModes (atn);
+			IList<IntervalSet> sets = ReadSets (atn);
+			ReadEdges (atn, sets);
+			ReadDecisions (atn);
+			ReadLexerActions (atn);
+            MarkPrecedenceDecisions(atn);
+			if (deserializationOptions.VerifyAtn) {
+				VerifyATN (atn);
+			}
+			if (deserializationOptions.GenerateRuleBypassTransitions && atn.grammarType == ATNType.Parser) {
+				GenerateRuleBypassTransitions (atn);
+			}
+            if (deserializationOptions.Optimize)
+            {
+				OptimizeATN (atn);
+            }
+            IdentifyTailCalls(atn);
+            return atn;
+        }
+
+		protected internal virtual void OptimizeATN(ATN atn)
+		{
+			while (true)
+			{
+				int optimizationCount = 0;
+				optimizationCount += InlineSetRules(atn);
+				optimizationCount += CombineChainedEpsilons(atn);
+				bool preserveOrder = atn.grammarType == ATNType.Lexer;
+				optimizationCount += OptimizeSets(atn, preserveOrder);
+				if (optimizationCount == 0)
+				{
+					break;
+				}
+			}
+			if (deserializationOptions.VerifyAtn)
+			{
+				// reverify after modification
+				VerifyATN(atn);
+			}
+		}
+
+		protected internal virtual void GenerateRuleBypassTransitions(ATN atn)
+		{
+			atn.ruleToTokenType = new int[atn.ruleToStartState.Length];
+			for (int i_10 = 0; i_10 < atn.ruleToStartState.Length; i_10++)
+			{
+				atn.ruleToTokenType[i_10] = atn.maxTokenType + i_10 + 1;
+			}
+			for (int i_13 = 0; i_13 < atn.ruleToStartState.Length; i_13++)
+			{
+				BasicBlockStartState bypassStart = new BasicBlockStartState();
+				bypassStart.ruleIndex = i_13;
+				atn.AddState(bypassStart);
+				BlockEndState bypassStop = new BlockEndState();
+				bypassStop.ruleIndex = i_13;
+				atn.AddState(bypassStop);
+				bypassStart.endState = bypassStop;
+				atn.DefineDecisionState(bypassStart);
+				bypassStop.startState = bypassStart;
+				ATNState endState;
+				Transition excludeTransition = null;
+				if (atn.ruleToStartState[i_13].isPrecedenceRule)
+				{
+					// wrap from the beginning of the rule to the StarLoopEntryState
+					endState = null;
+					foreach (ATNState state_3 in atn.states)
+					{
+						if (state_3.ruleIndex != i_13)
+						{
+							continue;
+						}
+						if (!(state_3 is StarLoopEntryState))
+						{
+							continue;
+						}
+						ATNState maybeLoopEndState = state_3.Transition(state_3.NumberOfTransitions - 1).target;
+						if (!(maybeLoopEndState is LoopEndState))
+						{
+							continue;
+						}
+						if (maybeLoopEndState.epsilonOnlyTransitions && maybeLoopEndState.Transition(0).target is RuleStopState)
+						{
+							endState = state_3;
+							break;
+						}
+					}
+					if (endState == null)
+					{
+						throw new NotSupportedException("Couldn't identify final state of the precedence rule prefix section.");
+					}
+					excludeTransition = ((StarLoopEntryState)endState).loopBackState.Transition(0);
+				}
+				else
+				{
+					endState = atn.ruleToStopState[i_13];
+				}
+				// all non-excluded transitions that currently target end state need to target blockEnd instead
+				foreach (ATNState state_4 in atn.states)
+				{
+					foreach (Transition transition in state_4.transitions)
+					{
+						if (transition == excludeTransition)
+						{
+							continue;
+						}
+						if (transition.target == endState)
+						{
+							transition.target = bypassStop;
+						}
+					}
+				}
+				// all transitions leaving the rule start state need to leave blockStart instead
+				while (atn.ruleToStartState[i_13].NumberOfTransitions > 0)
+				{
+					Transition transition = atn.ruleToStartState[i_13].Transition(atn.ruleToStartState[i_13].NumberOfTransitions - 1);
+					atn.ruleToStartState[i_13].RemoveTransition(atn.ruleToStartState[i_13].NumberOfTransitions - 1);
+					bypassStart.AddTransition(transition);
+				}
+				// link the new states
+				atn.ruleToStartState[i_13].AddTransition(new EpsilonTransition(bypassStart));
+				bypassStop.AddTransition(new EpsilonTransition(endState));
+				ATNState matchState = new BasicState();
+				atn.AddState(matchState);
+				matchState.AddTransition(new AtomTransition(bypassStop, atn.ruleToTokenType[i_13]));
+				bypassStart.AddTransition(new EpsilonTransition(matchState));
+			}
+			if (deserializationOptions.VerifyAtn)
+			{
+				// reverify after modification
+				VerifyATN(atn);
+			}
+		}		
+
+		protected internal virtual void ReadLexerActions(ATN atn)
+		{
+			//
+			// LEXER ACTIONS
+			//
+			if (atn.grammarType == ATNType.Lexer)
+			{
+				atn.lexerActions = new ILexerAction[ReadInt()];
+				for (int i_10 = 0; i_10 < atn.lexerActions.Length; i_10++)
+				{
+					LexerActionType actionType = (LexerActionType)ReadInt();
+					int data1 = ReadInt();
+					if (data1 == unchecked((int)(0xFFFF)))
+					{
+						data1 = -1;
+					}
+					int data2 = ReadInt();
+					if (data2 == unchecked((int)(0xFFFF)))
+					{
+						data2 = -1;
+					}
+					ILexerAction lexerAction = LexerActionFactory(actionType, data1, data2);
+					atn.lexerActions[i_10] = lexerAction;
+				}
+			}		
+		}
+
+		protected internal virtual void ReadDecisions(ATN atn)
+		{
+			//
+			// DECISIONS
+			//
+			int ndecisions = ReadInt();
+			for (int i_11 = 0; i_11 < ndecisions; i_11++)
+			{
+				int s = ReadInt();
+				DecisionState decState = (DecisionState)atn.states[s];
+				atn.decisionToState.Add(decState);
+				decState.decision = i_11;
+			}
+			atn.decisionToDFA = new DFA[ndecisions];
+			for (int i_12 = 0; i_12 < ndecisions; i_12++)
+			{
+				atn.decisionToDFA[i_12] = new DFA(atn.decisionToState[i_12], i_12);
+			}
+		}
+
+		protected internal virtual void ReadEdges(ATN atn, IList<IntervalSet> sets)
+		{
+			//
+			// EDGES
+			//
+			int nedges = ReadInt();
+			for (int i_9 = 0; i_9 < nedges; i_9++)
+			{
+				int src = ReadInt();
+				int trg = ReadInt();
+				TransitionType ttype = (TransitionType)ReadInt();
+				int arg1 = ReadInt();
+				int arg2 = ReadInt();
+				int arg3 = ReadInt();
+				Transition trans = EdgeFactory(atn, ttype, src, trg, arg1, arg2, arg3, sets);
+				ATNState srcState = atn.states[src];
+				srcState.AddTransition(trans);
+			}
+			// edges for rule stop states can be derived, so they aren't serialized
+			foreach (ATNState state_1 in atn.states)
+			{
+				for (int i_10 = 0; i_10 < state_1.NumberOfTransitions; i_10++)
+				{
+					Transition t = state_1.Transition(i_10);
+					if (!(t is RuleTransition))
+					{
+						continue;
+					}
+					RuleTransition ruleTransition = (RuleTransition)t;
+					int outermostPrecedenceReturn = -1;
+					if (atn.ruleToStartState[ruleTransition.target.ruleIndex].isPrecedenceRule)
+					{
+						if (ruleTransition.precedence == 0)
+						{
+							outermostPrecedenceReturn = ruleTransition.target.ruleIndex;
+						}
+					}
+					EpsilonTransition returnTransition = new EpsilonTransition(ruleTransition.followState, outermostPrecedenceReturn);
+					atn.ruleToStopState[ruleTransition.target.ruleIndex].AddTransition(returnTransition);
+				}
+			}
+			foreach (ATNState state_2 in atn.states)
+			{
+				if (state_2 is BlockStartState)
+				{
+					// we need to know the end state to set its start state
+					if (((BlockStartState)state_2).endState == null)
+					{
+						throw new InvalidOperationException();
+					}
+					// block end states can only be associated to a single block start state
+					if (((BlockStartState)state_2).endState.startState != null)
+					{
+						throw new InvalidOperationException();
+					}
+					((BlockStartState)state_2).endState.startState = (BlockStartState)state_2;
+				}
+				else if (state_2 is PlusLoopbackState)
+				{
+					PlusLoopbackState loopbackState = (PlusLoopbackState)state_2;
+					for (int i_10 = 0; i_10 < loopbackState.NumberOfTransitions; i_10++)
+					{
+						ATNState target = loopbackState.Transition(i_10).target;
+						if (target is PlusBlockStartState)
+						{
+							((PlusBlockStartState)target).loopBackState = loopbackState;
+						}
+					}
+				}
+				else if (state_2 is StarLoopbackState)
+				{
+					StarLoopbackState loopbackState = (StarLoopbackState)state_2;
+					for (int i_10 = 0; i_10 < loopbackState.NumberOfTransitions; i_10++)
+					{
+						ATNState target = loopbackState.Transition(i_10).target;
+						if (target is StarLoopEntryState)
+						{
+							((StarLoopEntryState)target).loopBackState = loopbackState;
+						}
+					}
+				}
+			}
+		}
+
+		protected internal virtual IList<IntervalSet> ReadSets(ATN atn)
+		{
+			//
+			// SETS
+			//
+			IList<IntervalSet> sets = new List<IntervalSet>();
+			int nsets = ReadInt();
+			for (int i_8 = 0; i_8 < nsets; i_8++)
+			{
+				IntervalSet set = new IntervalSet();
+				sets.Add(set);
+				int nintervals = ReadInt();
+				bool containsEof = ReadInt() != 0;
+				if (containsEof)
+				{
+					set.Add(-1);
+				}
+				for (int j = 0; j < nintervals; j++)
+				{
+					set.Add(ReadInt(), ReadInt());
+				}
+			}
+			return sets;
+		}
+
+		protected internal virtual void ReadModes(ATN atn)
+		{
+			//
+			// MODES
+			//
+			int nmodes = ReadInt();
+			for (int i_6 = 0; i_6 < nmodes; i_6++)
+			{
+				int _i = ReadInt();
+				atn.modeToStartState.Add((TokensStartState)atn.states[_i]);
+			}
+			// not in Java code
+			atn.modeToDFA = new DFA[nmodes];
+			for (int i_7 = 0; i_7 < nmodes; i_7++)
+			{
+				atn.modeToDFA[i_7] = new DFA(atn.modeToStartState[i_7]);
+			}
+		}
+
+		protected internal virtual void ReadRules(ATN atn)
+		{
+			//
+			// RULES
+			//
+			int nrules = ReadInt();
+			if (atn.grammarType == ATNType.Lexer)
+			{
+				atn.ruleToTokenType = new int[nrules];
+			}
+			atn.ruleToStartState = new RuleStartState[nrules];
+			for (int i_5 = 0; i_5 < nrules; i_5++)
+			{
+				int s = ReadInt();
+				RuleStartState startState = (RuleStartState)atn.states[s];
+				atn.ruleToStartState[i_5] = startState;
+				if (atn.grammarType == ATNType.Lexer) {
+					int tokenType = ReadInt ();
+					if (tokenType == unchecked((int)(0xFFFF))) {
+						tokenType = TokenConstants.Eof;
+					}
+					atn.ruleToTokenType [i_5] = tokenType;
+				}
+			}
+			atn.ruleToStopState = new RuleStopState[nrules];
+			foreach (ATNState state in atn.states)
+			{
+				if (!(state is RuleStopState))
+				{
+					continue;
+				}
+				RuleStopState stopState = (RuleStopState)state;
+				atn.ruleToStopState[state.ruleIndex] = stopState;
+				atn.ruleToStartState[state.ruleIndex].stopState = stopState;
+			}
+		}
+
+		protected internal virtual void ReadStates(ATN atn)
+		{
+			//
+			// STATES
+			//
+			IList<Tuple<LoopEndState, int>> loopBackStateNumbers = new List<Tuple<LoopEndState, int>>();
+			IList<Tuple<BlockStartState, int>> endStateNumbers = new List<Tuple<BlockStartState, int>>();
+			int nstates = ReadInt();
+			for (int i_1 = 0; i_1 < nstates; i_1++)
+			{
+				StateType stype = (StateType)ReadInt();
+				// ignore bad type of states
+				if (stype == StateType.InvalidType)
+				{
+					atn.AddState(null);
+					continue;
+				}
+				int ruleIndex = ReadInt();
+				if (ruleIndex == char.MaxValue)
+				{
+					ruleIndex = -1;
+				}
+				ATNState s = StateFactory(stype, ruleIndex);
+				if (stype == StateType.LoopEnd)
+				{
+					// special case
+					int loopBackStateNumber = ReadInt();
+					loopBackStateNumbers.Add(Tuple.Create((LoopEndState)s, loopBackStateNumber));
+				}
+				else
+				{
+					if (s is BlockStartState)
+					{
+						int endStateNumber = ReadInt();
+						endStateNumbers.Add(Tuple.Create((BlockStartState)s, endStateNumber));
+					}
+				}
+				atn.AddState(s);
+			}
+			// delay the assignment of loop back and end states until we know all the state instances have been initialized
+			foreach (Tuple<LoopEndState, int> pair in loopBackStateNumbers)
+			{
+				pair.Item1.loopBackState = atn.states[pair.Item2];
+			}
+			foreach (Tuple<BlockStartState, int> pair_1 in endStateNumbers)
+			{
+				pair_1.Item1.endState = (BlockEndState)atn.states[pair_1.Item2];
+			}
+			int numNonGreedyStates = ReadInt();
+			for (int i_2 = 0; i_2 < numNonGreedyStates; i_2++)
+			{
+				int stateNumber = ReadInt();
+				((DecisionState)atn.states[stateNumber]).nonGreedy = true;
+			}
+			int numPrecedenceStates = ReadInt();
+			for (int i_4 = 0; i_4 < numPrecedenceStates; i_4++)
+			{
+				int stateNumber = ReadInt();
+				((RuleStartState)atn.states[stateNumber]).isPrecedenceRule = true;
+			}
+		}
+
+		protected internal virtual ATN ReadATN()
+		{
+			ATNType grammarType = (ATNType)ReadInt();
+			int maxTokenType = ReadInt();
+			return new ATN(grammarType, maxTokenType);
+		}
+
+		protected internal virtual void CheckUUID()
+		{
+			Guid uuid = ReadUUID();
+			if (!SupportedUuids.Contains(uuid))
+			{
+				string reason = string.Format(CultureInfo.CurrentCulture, "Could not deserialize ATN with UUID {0} (expected {1} or a legacy UUID).", uuid, SerializedUuid);
+				throw new NotSupportedException(reason);
+			}
+		}
+
+		protected internal virtual void CheckVersion()
+		{
+			int version = ReadInt();
+			if (version != SerializedVersion)
+			{
+				string reason = string.Format(CultureInfo.CurrentCulture, "Could not deserialize ATN with version {0} (expected {1}).", version, SerializedVersion);
+				throw new NotSupportedException(reason);
+			}
+		}
+
+		protected internal virtual void Reset(char[] data)
+		{
+			this.data = new char[data.Length];
+			// don't adjust the first value since that's the version number
+			this.data[0] = data[0];
+			for (int i = 1; i < data.Length; i++)
+			{
+				this.data[i] = (char)(data[i] - 2);
+			}
+			this.p = 0;
+		}
+
+        /// <summary>
+        /// Analyze the
+        /// <see cref="StarLoopEntryState"/>
+        /// states in the specified ATN to set
+        /// the
+        /// <see cref="StarLoopEntryState.precedenceRuleDecision"/>
+        /// field to the
+        /// correct value.
+        /// </summary>
+        /// <param name="atn">The ATN.</param>
+        protected internal virtual void MarkPrecedenceDecisions(ATN atn)
+        {
+            foreach (ATNState state in atn.states)
+            {
+                if (!(state is StarLoopEntryState))
+                {
+                    continue;
+                }
+                if (atn.ruleToStartState[state.ruleIndex].isPrecedenceRule)
+                {
+                    ATNState maybeLoopEndState = state.Transition(state.NumberOfTransitions - 1).target;
+                    if (maybeLoopEndState is LoopEndState)
+                    {
+                        if (maybeLoopEndState.epsilonOnlyTransitions && maybeLoopEndState.Transition(0).target is RuleStopState)
+                        {
+                            ((StarLoopEntryState)state).precedenceRuleDecision = true;
+                        }
+                    }
+                }
+            }
+        }
+
+        protected internal virtual void VerifyATN(ATN atn)
+        {
+            // verify assumptions
+            foreach (ATNState state in atn.states)
+            {
+                if (state == null)
+                {
+                    continue;
+                }
+                CheckCondition(state.OnlyHasEpsilonTransitions || state.NumberOfTransitions <= 1);
+                if (state is PlusBlockStartState)
+                {
+                    CheckCondition(((PlusBlockStartState)state).loopBackState != null);
+                }
+                if (state is StarLoopEntryState)
+                {
+                    StarLoopEntryState starLoopEntryState = (StarLoopEntryState)state;
+                    CheckCondition(starLoopEntryState.loopBackState != null);
+                    CheckCondition(starLoopEntryState.NumberOfTransitions == 2);
+                    if (starLoopEntryState.Transition(0).target is StarBlockStartState)
+                    {
+                        CheckCondition(starLoopEntryState.Transition(1).target is LoopEndState);
+                        CheckCondition(!starLoopEntryState.nonGreedy);
+                    }
+                    else
+                    {
+                        if (starLoopEntryState.Transition(0).target is LoopEndState)
+                        {
+                            CheckCondition(starLoopEntryState.Transition(1).target is StarBlockStartState);
+                            CheckCondition(starLoopEntryState.nonGreedy);
+                        }
+                        else
+                        {
+                            throw new InvalidOperationException();
+                        }
+                    }
+                }
+                if (state is StarLoopbackState)
+                {
+                    CheckCondition(state.NumberOfTransitions == 1);
+                    CheckCondition(state.Transition(0).target is StarLoopEntryState);
+                }
+                if (state is LoopEndState)
+                {
+                    CheckCondition(((LoopEndState)state).loopBackState != null);
+                }
+                if (state is RuleStartState)
+                {
+                    CheckCondition(((RuleStartState)state).stopState != null);
+                }
+                if (state is BlockStartState)
+                {
+                    CheckCondition(((BlockStartState)state).endState != null);
+                }
+                if (state is BlockEndState)
+                {
+                    CheckCondition(((BlockEndState)state).startState != null);
+                }
+                if (state is DecisionState)
+                {
+                    DecisionState decisionState = (DecisionState)state;
+                    CheckCondition(decisionState.NumberOfTransitions <= 1 || decisionState.decision >= 0);
+                }
+                else
+                {
+                    CheckCondition(state.NumberOfTransitions <= 1 || state is RuleStopState);
+                }
+            }
+        }
+
+        protected internal virtual void CheckCondition(bool condition)
+        {
+            CheckCondition(condition, null);
+        }
+
+        protected internal virtual void CheckCondition(bool condition, string message)
+        {
+            if (!condition)
+            {
+                throw new InvalidOperationException(message);
+            }
+        }
+
+        private static int InlineSetRules(ATN atn)
+        {
+            int inlinedCalls = 0;
+            Transition[] ruleToInlineTransition = new Transition[atn.ruleToStartState.Length];
+            for (int i = 0; i < atn.ruleToStartState.Length; i++)
+            {
+                RuleStartState startState = atn.ruleToStartState[i];
+                ATNState middleState = startState;
+                while (middleState.OnlyHasEpsilonTransitions && middleState.NumberOfOptimizedTransitions == 1 && middleState.GetOptimizedTransition(0).TransitionType == TransitionType.Epsilon)
+                {
+                    middleState = middleState.GetOptimizedTransition(0).target;
+                }
+                if (middleState.NumberOfOptimizedTransitions != 1)
+                {
+                    continue;
+                }
+                Transition matchTransition = middleState.GetOptimizedTransition(0);
+                ATNState matchTarget = matchTransition.target;
+                if (matchTransition.IsEpsilon || !matchTarget.OnlyHasEpsilonTransitions || matchTarget.NumberOfOptimizedTransitions != 1 || !(matchTarget.GetOptimizedTransition(0).target is RuleStopState))
+                {
+                    continue;
+                }
+                switch (matchTransition.TransitionType)
+                {
+                    case TransitionType.Atom:
+                    case TransitionType.Range:
+                    case TransitionType.Set:
+                    {
+                        ruleToInlineTransition[i] = matchTransition;
+                        break;
+                    }
+
+                    case TransitionType.NotSet:
+                    case TransitionType.Wildcard:
+                    {
+                        // not implemented yet
+                        continue;
+                    }
+
+                    default:
+                    {
+                        continue;
+                    }
+                }
+            }
+            for (int stateNumber = 0; stateNumber < atn.states.Count; stateNumber++)
+            {
+                ATNState state = atn.states[stateNumber];
+                if (state.ruleIndex < 0)
+                {
+                    continue;
+                }
+                IList<Transition> optimizedTransitions = null;
+                for (int i_1 = 0; i_1 < state.NumberOfOptimizedTransitions; i_1++)
+                {
+                    Transition transition = state.GetOptimizedTransition(i_1);
+                    if (!(transition is RuleTransition))
+                    {
+                        if (optimizedTransitions != null)
+                        {
+                            optimizedTransitions.Add(transition);
+                        }
+                        continue;
+                    }
+                    RuleTransition ruleTransition = (RuleTransition)transition;
+                    Transition effective = ruleToInlineTransition[ruleTransition.target.ruleIndex];
+                    if (effective == null)
+                    {
+                        if (optimizedTransitions != null)
+                        {
+                            optimizedTransitions.Add(transition);
+                        }
+                        continue;
+                    }
+                    if (optimizedTransitions == null)
+                    {
+                        optimizedTransitions = new List<Transition>();
+                        for (int j = 0; j < i_1; j++)
+                        {
+                            optimizedTransitions.Add(state.GetOptimizedTransition(i_1));
+                        }
+                    }
+                    inlinedCalls++;
+                    ATNState target = ruleTransition.followState;
+                    ATNState intermediateState = new BasicState();
+                    intermediateState.SetRuleIndex(target.ruleIndex);
+                    atn.AddState(intermediateState);
+                    optimizedTransitions.Add(new EpsilonTransition(intermediateState));
+                    switch (effective.TransitionType)
+                    {
+                        case TransitionType.Atom:
+                        {
+							intermediateState.AddTransition(new AtomTransition(target, ((AtomTransition)effective).token));
+                            break;
+                        }
+
+                        case TransitionType.Range:
+                        {
+                            intermediateState.AddTransition(new RangeTransition(target, ((RangeTransition)effective).from, ((RangeTransition)effective).to));
+                            break;
+                        }
+
+                        case TransitionType.Set:
+                        {
+                            intermediateState.AddTransition(new SetTransition(target, effective.Label));
+                            break;
+                        }
+
+                        default:
+                        {
+                            throw new NotSupportedException();
+                        }
+                    }
+                }
+                if (optimizedTransitions != null)
+                {
+                    if (state.IsOptimized)
+                    {
+                        while (state.NumberOfOptimizedTransitions > 0)
+                        {
+                            state.RemoveOptimizedTransition(state.NumberOfOptimizedTransitions - 1);
+                        }
+                    }
+                    foreach (Transition transition in optimizedTransitions)
+                    {
+                        state.AddOptimizedTransition(transition);
+                    }
+                }
+            }
+            return inlinedCalls;
+        }
+
+        private static int CombineChainedEpsilons(ATN atn)
+        {
+            int removedEdges = 0;
+            foreach (ATNState state in atn.states)
+            {
+                if (!state.OnlyHasEpsilonTransitions || state is RuleStopState)
+                {
+                    continue;
+                }
+                IList<Transition> optimizedTransitions = null;
+                for (int i = 0; i < state.NumberOfOptimizedTransitions; i++)
+                {
+                    Transition transition = state.GetOptimizedTransition(i);
+                    ATNState intermediate = transition.target;
+                    if (transition.TransitionType != TransitionType.Epsilon || ((EpsilonTransition)transition).OutermostPrecedenceReturn != -1 || intermediate.StateType != StateType.Basic || !intermediate.OnlyHasEpsilonTransitions)
+                    {
+                        if (optimizedTransitions != null)
+                        {
+                            optimizedTransitions.Add(transition);
+                        }
+                        goto nextTransition_continue;
+                    }
+                    for (int j = 0; j < intermediate.NumberOfOptimizedTransitions; j++)
+                    {
+                        if (intermediate.GetOptimizedTransition(j).TransitionType != TransitionType.Epsilon || ((EpsilonTransition)intermediate.GetOptimizedTransition(j)).OutermostPrecedenceReturn != -1)
+                        {
+                            if (optimizedTransitions != null)
+                            {
+                                optimizedTransitions.Add(transition);
+                            }
+                            goto nextTransition_continue;
+                        }
+                    }
+                    removedEdges++;
+                    if (optimizedTransitions == null)
+                    {
+                        optimizedTransitions = new List<Transition>();
+                        for (int j_1 = 0; j_1 < i; j_1++)
+                        {
+                            optimizedTransitions.Add(state.GetOptimizedTransition(j_1));
+                        }
+                    }
+                    for (int j_2 = 0; j_2 < intermediate.NumberOfOptimizedTransitions; j_2++)
+                    {
+                        ATNState target = intermediate.GetOptimizedTransition(j_2).target;
+                        optimizedTransitions.Add(new EpsilonTransition(target));
+                    }
+nextTransition_continue: ;
+                }
+
+                if (optimizedTransitions != null)
+                {
+                    if (state.IsOptimized)
+                    {
+                        while (state.NumberOfOptimizedTransitions > 0)
+                        {
+                            state.RemoveOptimizedTransition(state.NumberOfOptimizedTransitions - 1);
+                        }
+                    }
+                    foreach (Transition transition in optimizedTransitions)
+                    {
+                        state.AddOptimizedTransition(transition);
+                    }
+                }
+            }
+
+            return removedEdges;
+        }
+
+        private static int OptimizeSets(ATN atn, bool preserveOrder)
+        {
+            if (preserveOrder)
+            {
+                // this optimization currently doesn't preserve edge order.
+                return 0;
+            }
+            int removedPaths = 0;
+            IList<DecisionState> decisions = atn.decisionToState;
+            foreach (DecisionState decision in decisions)
+            {
+                IntervalSet setTransitions = new IntervalSet();
+                for (int i = 0; i < decision.NumberOfOptimizedTransitions; i++)
+                {
+                    Transition epsTransition = decision.GetOptimizedTransition(i);
+                    if (!(epsTransition is EpsilonTransition))
+                    {
+                        continue;
+                    }
+                    if (epsTransition.target.NumberOfOptimizedTransitions != 1)
+                    {
+                        continue;
+                    }
+                    Transition transition = epsTransition.target.GetOptimizedTransition(0);
+                    if (!(transition.target is BlockEndState))
+                    {
+                        continue;
+                    }
+                    if (transition is NotSetTransition)
+                    {
+                        // TODO: not yet implemented
+                        continue;
+                    }
+                    if (transition is AtomTransition || transition is RangeTransition || transition is SetTransition)
+                    {
+                        setTransitions.Add(i);
+                    }
+                }
+                if (setTransitions.Count <= 1)
+                {
+                    continue;
+                }
+                IList<Transition> optimizedTransitions = new List<Transition>();
+                for (int i_1 = 0; i_1 < decision.NumberOfOptimizedTransitions; i_1++)
+                {
+                    if (!setTransitions.Contains(i_1))
+                    {
+                        optimizedTransitions.Add(decision.GetOptimizedTransition(i_1));
+                    }
+                }
+                ATNState blockEndState = decision.GetOptimizedTransition(setTransitions.MinElement).target.GetOptimizedTransition(0).target;
+                IntervalSet matchSet = new IntervalSet();
+                for (int i_2 = 0; i_2 < setTransitions.GetIntervals().Count; i_2++)
+                {
+                    Interval interval = setTransitions.GetIntervals()[i_2];
+                    for (int j = interval.a; j <= interval.b; j++)
+                    {
+                        Transition matchTransition = decision.GetOptimizedTransition(j).target.GetOptimizedTransition(0);
+                        if (matchTransition is NotSetTransition)
+                        {
+                            throw new NotSupportedException("Not yet implemented.");
+                        }
+                        else
+                        {
+                            matchSet.AddAll(matchTransition.Label);
+                        }
+                    }
+                }
+                Transition newTransition;
+                if (matchSet.GetIntervals().Count == 1)
+                {
+                    if (matchSet.Count == 1)
+                    {
+                        newTransition = new AtomTransition(blockEndState, matchSet.MinElement);
+                    }
+                    else
+                    {
+                        Interval matchInterval = matchSet.GetIntervals()[0];
+                        newTransition = new RangeTransition(blockEndState, matchInterval.a, matchInterval.b);
+                    }
+                }
+                else
+                {
+                    newTransition = new SetTransition(blockEndState, matchSet);
+                }
+                ATNState setOptimizedState = new BasicState();
+                setOptimizedState.SetRuleIndex(decision.ruleIndex);
+                atn.AddState(setOptimizedState);
+                setOptimizedState.AddTransition(newTransition);
+                optimizedTransitions.Add(new EpsilonTransition(setOptimizedState));
+                removedPaths += decision.NumberOfOptimizedTransitions - optimizedTransitions.Count;
+                if (decision.IsOptimized)
+                {
+                    while (decision.NumberOfOptimizedTransitions > 0)
+                    {
+                        decision.RemoveOptimizedTransition(decision.NumberOfOptimizedTransitions - 1);
+                    }
+                }
+                foreach (Transition transition_1 in optimizedTransitions)
+                {
+                    decision.AddOptimizedTransition(transition_1);
+                }
+            }
+            return removedPaths;
+        }
+
+        private static void IdentifyTailCalls(ATN atn)
+        {
+            foreach (ATNState state in atn.states)
+            {
+                foreach (Transition transition in state.transitions)
+                {
+                    if (!(transition is RuleTransition))
+                    {
+                        continue;
+                    }
+                    RuleTransition ruleTransition = (RuleTransition)transition;
+                    ruleTransition.tailCall = TestTailCall(atn, ruleTransition, false);
+                    ruleTransition.optimizedTailCall = TestTailCall(atn, ruleTransition, true);
+                }
+                if (!state.IsOptimized)
+                {
+                    continue;
+                }
+                foreach (Transition transition_1 in state.optimizedTransitions)
+                {
+                    if (!(transition_1 is RuleTransition))
+                    {
+                        continue;
+                    }
+                    RuleTransition ruleTransition = (RuleTransition)transition_1;
+                    ruleTransition.tailCall = TestTailCall(atn, ruleTransition, false);
+                    ruleTransition.optimizedTailCall = TestTailCall(atn, ruleTransition, true);
+                }
+            }
+        }
+
+        private static bool TestTailCall(ATN atn, RuleTransition transition, bool optimizedPath)
+        {
+            if (!optimizedPath && transition.tailCall)
+            {
+                return true;
+            }
+            if (optimizedPath && transition.optimizedTailCall)
+            {
+                return true;
+            }
+            BitSet reachable = new BitSet(atn.states.Count);
+            Stack<ATNState> worklist = new Stack<ATNState>();
+            worklist.Push(transition.followState);
+            while (worklist.Count > 0)
+            {
+                ATNState state = worklist.Pop();
+                if (reachable.Get(state.stateNumber))
+                {
+                    continue;
+                }
+                if (state is RuleStopState)
+                {
+                    continue;
+                }
+                if (!state.OnlyHasEpsilonTransitions)
+                {
+                    return false;
+                }
+                IList<Transition> transitions = optimizedPath ? state.optimizedTransitions : state.transitions;
+                foreach (Transition t in transitions)
+                {
+                    if (t.TransitionType != TransitionType.Epsilon)
+                    {
+                        return false;
+                    }
+                    worklist.Push(t.target);
+                }
+            }
+            return true;
+        }
+
+
+        protected internal int ReadInt()
+        {
+			return data[p++];
+        }
+
+        protected internal int ReadInt32()
+        {
+			return (int)data[p++] | ((int)data[p++] << 16);
+        }
+
+        protected internal long ReadLong()
+        {
+            long lowOrder = ReadInt32() & unchecked((long)(0x00000000FFFFFFFFL));
+            return lowOrder | ((long)ReadInt32() << 32);
+        }
+
+        protected internal Guid ReadUUID()
+        {
+			byte[] d = BitConverter.GetBytes (ReadLong ());
+			Array.Reverse(d);
+			short c = (short)ReadInt();
+			short b = (short)ReadInt();
+			int a = ReadInt32();
+            return new Guid(a, b, c, d);
+        }
+
+        [return: NotNull]
+        protected internal virtual Transition EdgeFactory(ATN atn, TransitionType type, int src, int trg, int arg1, int arg2, int arg3, IList<IntervalSet> sets)
+        {
+            ATNState target = atn.states[trg];
+            switch (type)
+            {
+                case TransitionType.Epsilon:
+                {
+                    return new EpsilonTransition(target);
+                }
+
+                case TransitionType.Range:
+                {
+                    if (arg3 != 0)
+                    {
+                        return new RangeTransition(target, TokenConstants.Eof, arg2);
+                    }
+                    else
+                    {
+                        return new RangeTransition(target, arg1, arg2);
+                    }
+                }
+
+                case TransitionType.Rule:
+                {
+                    RuleTransition rt = new RuleTransition((RuleStartState)atn.states[arg1], arg2, arg3, target);
+                    return rt;
+                }
+
+                case TransitionType.Predicate:
+                {
+                    PredicateTransition pt = new PredicateTransition(target, arg1, arg2, arg3 != 0);
+                    return pt;
+                }
+
+                case TransitionType.Precedence:
+                {
+                    return new PrecedencePredicateTransition(target, arg1);
+                }
+
+                case TransitionType.Atom:
+                {
+                    if (arg3 != 0)
+                    {
+                        return new AtomTransition(target, TokenConstants.Eof);
+                    }
+                    else
+                    {
+                        return new AtomTransition(target, arg1);
+                    }
+                }
+
+                case TransitionType.Action:
+                {
+                    ActionTransition a = new ActionTransition(target, arg1, arg2, arg3 != 0);
+                    return a;
+                }
+
+                case TransitionType.Set:
+                {
+                    return new SetTransition(target, sets[arg1]);
+                }
+
+                case TransitionType.NotSet:
+                {
+                    return new NotSetTransition(target, sets[arg1]);
+                }
+
+                case TransitionType.Wildcard:
+                {
+                    return new WildcardTransition(target);
+                }
+            }
+            throw new ArgumentException("The specified transition type is not valid.");
+        }
+
+        protected internal virtual ATNState StateFactory(StateType type, int ruleIndex)
+        {
+            ATNState s;
+            switch (type)
+            {
+                case StateType.InvalidType:
+                {
+                    return null;
+                }
+
+                case StateType.Basic:
+                {
+                    s = new BasicState();
+                    break;
+                }
+
+                case StateType.RuleStart:
+                {
+                    s = new RuleStartState();
+                    break;
+                }
+
+                case StateType.BlockStart:
+                {
+                    s = new BasicBlockStartState();
+                    break;
+                }
+
+                case StateType.PlusBlockStart:
+                {
+                    s = new PlusBlockStartState();
+                    break;
+                }
+
+                case StateType.StarBlockStart:
+                {
+                    s = new StarBlockStartState();
+                    break;
+                }
+
+                case StateType.TokenStart:
+                {
+                    s = new TokensStartState();
+                    break;
+                }
+
+                case StateType.RuleStop:
+                {
+                    s = new RuleStopState();
+                    break;
+                }
+
+                case StateType.BlockEnd:
+                {
+                    s = new BlockEndState();
+                    break;
+                }
+
+                case StateType.StarLoopBack:
+                {
+                    s = new StarLoopbackState();
+                    break;
+                }
+
+                case StateType.StarLoopEntry:
+                {
+                    s = new StarLoopEntryState();
+                    break;
+                }
+
+                case StateType.PlusLoopBack:
+                {
+                    s = new PlusLoopbackState();
+                    break;
+                }
+
+                case StateType.LoopEnd:
+                {
+                    s = new LoopEndState();
+                    break;
+                }
+
+                default:
+                {
+                    string message = string.Format(CultureInfo.CurrentCulture, "The specified state type {0} is not valid.", type);
+                    throw new ArgumentException(message);
+                }
+            }
+            s.ruleIndex = ruleIndex;
+            return s;
+        }
+
+        protected internal virtual ILexerAction LexerActionFactory(LexerActionType type, int data1, int data2)
+        {
+            switch (type)
+            {
+                case LexerActionType.Channel:
+                {
+                    return new LexerChannelAction(data1);
+                }
+
+                case LexerActionType.Custom:
+                {
+                    return new LexerCustomAction(data1, data2);
+                }
+
+                case LexerActionType.Mode:
+                {
+                    return new LexerModeAction(data1);
+                }
+
+                case LexerActionType.More:
+                {
+                    return LexerMoreAction.Instance;
+                }
+
+                case LexerActionType.PopMode:
+                {
+                    return LexerPopModeAction.Instance;
+                }
+
+                case LexerActionType.PushMode:
+                {
+                    return new LexerPushModeAction(data1);
+                }
+
+                case LexerActionType.Skip:
+                {
+                    return LexerSkipAction.Instance;
+                }
+
+                case LexerActionType.Type:
+                {
+                    return new LexerTypeAction(data1);
+                }
+
+                default:
+                {
+                    string message = string.Format(CultureInfo.CurrentCulture, "The specified lexer action type {0} is not valid.", type);
+                    throw new ArgumentException(message);
+                }
+            }
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/ATNSimulator.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/ATNSimulator.cs
new file mode 100644
index 000000000..ae8bfc31b
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/ATNSimulator.cs
@@ -0,0 +1,109 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System;
+using System.Collections.Generic;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Dfa;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    public abstract class ATNSimulator
+    {
+        [Obsolete(@"Use ATNDeserializer.SerializedVersion instead.")]
+        public static readonly int SerializedVersion = ATNDeserializer.SerializedVersion;
+
+        /// <summary>This is the current serialized UUID.</summary>
+        /// <remarks>This is the current serialized UUID.</remarks>
+        [Obsolete(@"Use ATNDeserializer.CheckCondition(bool) instead.")]
+        public static readonly Guid SerializedUuid = ATNDeserializer.SerializedUuid;
+
+        public const char RuleVariantDelimiter = '$';
+
+        public const string RuleLfVariantMarker = "$lf$";
+
+        public const string RuleNolfVariantMarker = "$nolf$";
+
+        /// <summary>Must distinguish between missing edge and edge we know leads nowhere</summary>
+        [NotNull]
+        public static readonly DFAState Error =
+            new DFAState(new EmptyEdgeMap<DFAState>(0, -1), new EmptyEdgeMap<DFAState>(0, -1), new ATNConfigSet())
+            {
+                stateNumber = int.MaxValue
+            };
+
+        [NotNull]
+        public readonly ATN atn;
+
+        public ATNSimulator(ATN atn)
+        {
+            this.atn = atn;
+        }
+
+        public abstract void Reset();
+
+        /// <summary>Clear the DFA cache used by the current instance.</summary>
+        /// <remarks>
+        /// Clear the DFA cache used by the current instance. Since the DFA cache may
+        /// be shared by multiple ATN simulators, this method may affect the
+        /// performance (but not accuracy) of other parsers which are being used
+        /// concurrently.
+        /// </remarks>
+        /// <exception cref="System.NotSupportedException">
+        /// if the current instance does not
+        /// support clearing the DFA.
+        /// </exception>
+        /// <since>4.3</since>
+        public virtual void ClearDFA()
+        {
+            atn.ClearDFA();
+        }
+
+        [Obsolete(@"Use ATNDeserializer.Deserialize(char[]) instead.")]
+        public static ATN Deserialize(char[] data)
+        {
+            return new ATNDeserializer().Deserialize(data);
+        }
+
+        [return: NotNull]
+        [Obsolete(@"Use ATNDeserializer.EdgeFactory(ATN, TransitionType, int, int, int, int, int, System.Collections.Generic.IList{E}) instead.")]
+        public static Transition EdgeFactory(ATN atn, TransitionType type, int src, int trg, int arg1, int arg2, int arg3, IList<IntervalSet> sets)
+        {
+            return new ATNDeserializer().EdgeFactory(atn, type, src, trg, arg1, arg2, arg3, sets);
+        }
+
+        [Obsolete(@"Use ATNDeserializer.StateFactory(StateType, int) instead.")]
+        public static ATNState StateFactory(StateType type, int ruleIndex)
+        {
+            return new ATNDeserializer().StateFactory(type, ruleIndex);
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/ATNState.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/ATNState.cs
new file mode 100644
index 000000000..fdb11f5e9
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/ATNState.cs
@@ -0,0 +1,294 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Globalization;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    /// <summary>
+    /// The following images show the relation of states and
+    /// <see cref="transitions"/>
+    /// for various grammar constructs.
+    /// <ul>
+    /// <li>Solid edges marked with an &#0949; indicate a required
+    /// <see cref="EpsilonTransition"/>
+    /// .</li>
+    /// <li>Dashed edges indicate locations where any transition derived from
+    /// <see cref="Transition"/>
+    /// might appear.</li>
+    /// <li>Dashed nodes are place holders for either a sequence of linked
+    /// <see cref="BasicState"/>
+    /// states or the inclusion of a block representing a nested
+    /// construct in one of the forms below.</li>
+    /// <li>Nodes showing multiple outgoing alternatives with a
+    /// <c>...</c>
+    /// support
+    /// any number of alternatives (one or more). Nodes without the
+    /// <c>...</c>
+    /// only
+    /// support the exact number of alternatives shown in the diagram.</li>
+    /// </ul>
+    /// <h2>Basic Blocks</h2>
+    /// <h3>Rule</h3>
+    /// <embed src="images/Rule.svg" type="image/svg+xml"/>
+    /// <h3>Block of 1 or more alternatives</h3>
+    /// <embed src="images/Block.svg" type="image/svg+xml"/>
+    /// <h2>Greedy Loops</h2>
+    /// <h3>Greedy Closure:
+    /// <c>(...)*</c>
+    /// </h3>
+    /// <embed src="images/ClosureGreedy.svg" type="image/svg+xml"/>
+    /// <h3>Greedy Positive Closure:
+    /// <c>(...)+</c>
+    /// </h3>
+    /// <embed src="images/PositiveClosureGreedy.svg" type="image/svg+xml"/>
+    /// <h3>Greedy Optional:
+    /// <c>(...)?</c>
+    /// </h3>
+    /// <embed src="images/OptionalGreedy.svg" type="image/svg+xml"/>
+    /// <h2>Non-Greedy Loops</h2>
+    /// <h3>Non-Greedy Closure:
+    /// <c>(...)*?</c>
+    /// </h3>
+    /// <embed src="images/ClosureNonGreedy.svg" type="image/svg+xml"/>
+    /// <h3>Non-Greedy Positive Closure:
+    /// <c>(...)+?</c>
+    /// </h3>
+    /// <embed src="images/PositiveClosureNonGreedy.svg" type="image/svg+xml"/>
+    /// <h3>Non-Greedy Optional:
+    /// <c>(...)??</c>
+    /// </h3>
+    /// <embed src="images/OptionalNonGreedy.svg" type="image/svg+xml"/>
+    /// </summary>
+    public abstract class ATNState
+    {
+        public const int InitialNumTransitions = 4;
+
+        public static readonly ReadOnlyCollection<string> serializationNames = new ReadOnlyCollection<string>(Arrays.AsList("INVALID", "BASIC", "RULE_START", "BLOCK_START", "PLUS_BLOCK_START", "STAR_BLOCK_START", "TOKEN_START", "RULE_STOP", "BLOCK_END", "STAR_LOOP_BACK", "STAR_LOOP_ENTRY", "PLUS_LOOP_BACK", "LOOP_END"));
+
+        public const int InvalidStateNumber = -1;
+
+        /// <summary>Which ATN are we in?</summary>
+        public ATN atn = null;
+
+        public int stateNumber = InvalidStateNumber;
+
+        public int ruleIndex;
+
+        public bool epsilonOnlyTransitions = false;
+
+        /// <summary>Track the transitions emanating from this ATN state.</summary>
+        /// <remarks>Track the transitions emanating from this ATN state.</remarks>
+        protected internal readonly List<Antlr4.Runtime.Atn.Transition> transitions = new List<Antlr4.Runtime.Atn.Transition>(InitialNumTransitions);
+
+        protected internal List<Antlr4.Runtime.Atn.Transition> optimizedTransitions;
+
+        /// <summary>Used to cache lookahead during parsing, not used during construction</summary>
+        public IntervalSet nextTokenWithinRule;
+
+        /// <summary>
+        /// For all states except
+        /// <see cref="RuleStopState"/>
+        /// , this returns the state
+        /// number. Returns -1 for stop states.
+        /// </summary>
+        /// <returns>
+        /// -1 for
+        /// <see cref="RuleStopState"/>
+        /// , otherwise the state number
+        /// </returns>
+        public virtual int NonStopStateNumber
+        {
+            get
+            {
+                return stateNumber;
+            }
+        }
+
+        public override int GetHashCode()
+        {
+            return stateNumber;
+        }
+
+        public override bool Equals(object o)
+        {
+            // are these states same object?
+            if (o is ATNState)
+            {
+                return stateNumber == ((ATNState)o).stateNumber;
+            }
+            return false;
+        }
+
+        public virtual bool IsNonGreedyExitState
+        {
+            get
+            {
+                return false;
+            }
+        }
+
+        public override string ToString()
+        {
+            return stateNumber.ToString();
+        }
+
+        public virtual Transition[] TransitionsArray
+        {
+            get
+            {
+                return transitions.ToArray();
+            }
+        }
+
+        public virtual int NumberOfTransitions
+        {
+            get
+            {
+                return transitions.Count;
+            }
+        }
+
+        public virtual void AddTransition(Antlr4.Runtime.Atn.Transition e)
+        {
+            AddTransition(transitions.Count, e);
+        }
+
+        public virtual void AddTransition(int index, Antlr4.Runtime.Atn.Transition e)
+        {
+            if (transitions.Count == 0)
+            {
+                epsilonOnlyTransitions = e.IsEpsilon;
+            }
+            else
+            {
+                if (epsilonOnlyTransitions != e.IsEpsilon)
+                {
+#if !PORTABLE
+                    System.Console.Error.WriteLine("ATN state {0} has both epsilon and non-epsilon transitions.", stateNumber);
+#endif
+                    epsilonOnlyTransitions = false;
+                }
+            }
+            transitions.Insert(index, e);
+        }
+
+        public virtual Antlr4.Runtime.Atn.Transition Transition(int i)
+        {
+            return transitions[i];
+        }
+
+        public virtual void SetTransition(int i, Antlr4.Runtime.Atn.Transition e)
+        {
+            transitions[i] = e;
+        }
+
+        public virtual void RemoveTransition(int index)
+        {
+            transitions.RemoveAt(index);
+        }
+
+        public abstract Antlr4.Runtime.Atn.StateType StateType
+        {
+            get;
+        }
+
+        public bool OnlyHasEpsilonTransitions
+        {
+            get
+            {
+                return epsilonOnlyTransitions;
+            }
+        }
+
+        public virtual void SetRuleIndex(int ruleIndex)
+        {
+            this.ruleIndex = ruleIndex;
+        }
+
+        public virtual bool IsOptimized
+        {
+            get
+            {
+                return optimizedTransitions != transitions;
+            }
+        }
+
+        public virtual int NumberOfOptimizedTransitions
+        {
+            get
+            {
+                return optimizedTransitions.Count;
+            }
+        }
+
+        public virtual Antlr4.Runtime.Atn.Transition GetOptimizedTransition(int i)
+        {
+            return optimizedTransitions[i];
+        }
+
+        public virtual void AddOptimizedTransition(Antlr4.Runtime.Atn.Transition e)
+        {
+            if (!IsOptimized)
+            {
+                optimizedTransitions = new List<Antlr4.Runtime.Atn.Transition>();
+            }
+            optimizedTransitions.Add(e);
+        }
+
+        public virtual void SetOptimizedTransition(int i, Antlr4.Runtime.Atn.Transition e)
+        {
+            if (!IsOptimized)
+            {
+                throw new InvalidOperationException();
+            }
+            optimizedTransitions[i] = e;
+        }
+
+        public virtual void RemoveOptimizedTransition(int i)
+        {
+            if (!IsOptimized)
+            {
+                throw new InvalidOperationException();
+            }
+            optimizedTransitions.RemoveAt(i);
+        }
+
+        public ATNState()
+        {
+            optimizedTransitions = transitions;
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/ATNType.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/ATNType.cs
new file mode 100644
index 000000000..994323379
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/ATNType.cs
@@ -0,0 +1,43 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    /// <summary>Represents the type of recognizer an ATN applies to.</summary>
+    /// <remarks>Represents the type of recognizer an ATN applies to.</remarks>
+    /// <author>Sam Harwell</author>
+    public enum ATNType
+    {
+        Lexer,
+        Parser
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/AbstractPredicateTransition.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/AbstractPredicateTransition.cs
new file mode 100644
index 000000000..4f7dcb63e
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/AbstractPredicateTransition.cs
@@ -0,0 +1,43 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    /// <author>Sam Harwell</author>
+    public abstract class AbstractPredicateTransition : Transition
+    {
+        public AbstractPredicateTransition(ATNState target)
+            : base(target)
+        {
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/ActionTransition.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/ActionTransition.cs
new file mode 100644
index 000000000..0f642f8b0
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/ActionTransition.cs
@@ -0,0 +1,84 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    public sealed class ActionTransition : Transition
+    {
+        public readonly int ruleIndex;
+
+        public readonly int actionIndex;
+
+        public readonly bool isCtxDependent;
+
+        public ActionTransition(ATNState target, int ruleIndex)
+            : this(target, ruleIndex, -1, false)
+        {
+        }
+
+        public ActionTransition(ATNState target, int ruleIndex, int actionIndex, bool isCtxDependent)
+            : base(target)
+        {
+            // e.g., $i ref in action
+            this.ruleIndex = ruleIndex;
+            this.actionIndex = actionIndex;
+            this.isCtxDependent = isCtxDependent;
+        }
+
+        public override Antlr4.Runtime.Atn.TransitionType TransitionType
+        {
+            get
+            {
+                return Antlr4.Runtime.Atn.TransitionType.Action;
+            }
+        }
+
+        public override bool IsEpsilon
+        {
+            get
+            {
+                return true;
+            }
+        }
+
+        // we are to be ignored by analysis 'cept for predicates
+        public override bool Matches(int symbol, int minVocabSymbol, int maxVocabSymbol)
+        {
+            return false;
+        }
+
+        public override string ToString()
+        {
+            return "action_" + ruleIndex + ":" + actionIndex;
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/AmbiguityInfo.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/AmbiguityInfo.cs
new file mode 100644
index 000000000..8941d54fe
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/AmbiguityInfo.cs
@@ -0,0 +1,91 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    /// <summary>This class represents profiling event information for an ambiguity.</summary>
+    /// <remarks>
+    /// This class represents profiling event information for an ambiguity.
+    /// Ambiguities are decisions where a particular input resulted in an SLL
+    /// conflict, followed by LL prediction also reaching a conflict state
+    /// (indicating a true ambiguity in the grammar).
+    /// <p>
+    /// This event may be reported during SLL prediction in cases where the
+    /// conflicting SLL configuration set provides sufficient information to
+    /// determine that the SLL conflict is truly an ambiguity. For example, if none
+    /// of the ATN configurations in the conflicting SLL configuration set have
+    /// traversed a global follow transition (i.e.
+    /// <see cref="ATNConfig.ReachesIntoOuterContext()"/>
+    /// is
+    /// <see langword="false"/>
+    /// for all
+    /// configurations), then the result of SLL prediction for that input is known to
+    /// be equivalent to the result of LL prediction for that input.</p>
+    /// <p>
+    /// In some cases, the minimum represented alternative in the conflicting LL
+    /// configuration set is not equal to the minimum represented alternative in the
+    /// conflicting SLL configuration set. Grammars and inputs which result in this
+    /// scenario are unable to use
+    /// <see cref="PredictionMode.Sll"/>
+    /// , which in turn means
+    /// they cannot use the two-stage parsing strategy to improve parsing performance
+    /// for that input.</p>
+    /// </remarks>
+    /// <seealso cref="ParserATNSimulator.ReportAmbiguity(Antlr4.Runtime.Dfa.DFA, Antlr4.Runtime.Dfa.DFAState, int, int, bool, Antlr4.Runtime.Sharpen.BitSet, ATNConfigSet)"/>
+    /// <seealso cref="Antlr4.Runtime.IParserErrorListener.ReportAmbiguity(Antlr4.Runtime.Parser, Antlr4.Runtime.Dfa.DFA, int, int, bool, Antlr4.Runtime.Sharpen.BitSet, ATNConfigSet)"/>
+    /// <since>4.3</since>
+    public class AmbiguityInfo : DecisionEventInfo
+    {
+        /// <summary>
+        /// Constructs a new instance of the
+        /// <see cref="AmbiguityInfo"/>
+        /// class with the
+        /// specified detailed ambiguity information.
+        /// </summary>
+        /// <param name="decision">The decision number</param>
+        /// <param name="state">
+        /// The final simulator state identifying the ambiguous
+        /// alternatives for the current input
+        /// </param>
+        /// <param name="input">The input token stream</param>
+        /// <param name="startIndex">The start index for the current prediction</param>
+        /// <param name="stopIndex">
+        /// The index at which the ambiguity was identified during
+        /// prediction
+        /// </param>
+        public AmbiguityInfo(int decision, SimulatorState state, ITokenStream input, int startIndex, int stopIndex)
+            : base(decision, state, input, startIndex, stopIndex, state.useContext)
+        {
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/ArrayPredictionContext.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/ArrayPredictionContext.cs
new file mode 100644
index 000000000..2fba97a2c
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/ArrayPredictionContext.cs
@@ -0,0 +1,272 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System;
+using System.Collections.Generic;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+#pragma warning disable 0659 // 'class' overrides Object.Equals(object o) but does not override Object.GetHashCode()
+    public class ArrayPredictionContext : PredictionContext
+    {
+        [NotNull]
+        public readonly PredictionContext[] parents;
+
+        [NotNull]
+        public readonly int[] returnStates;
+
+        internal ArrayPredictionContext(PredictionContext[] parents, int[] returnStates)
+            : base(CalculateHashCode(parents, returnStates))
+        {
+            System.Diagnostics.Debug.Assert(parents.Length == returnStates.Length);
+            System.Diagnostics.Debug.Assert(returnStates.Length > 1 || returnStates[0] != EmptyFullStateKey, "Should be using PredictionContext.EMPTY instead.");
+            this.parents = parents;
+            this.returnStates = returnStates;
+        }
+
+        internal ArrayPredictionContext(PredictionContext[] parents, int[] returnStates, int hashCode)
+            : base(hashCode)
+        {
+            System.Diagnostics.Debug.Assert(parents.Length == returnStates.Length);
+            System.Diagnostics.Debug.Assert(returnStates.Length > 1 || returnStates[0] != EmptyFullStateKey, "Should be using PredictionContext.EMPTY instead.");
+            this.parents = parents;
+            this.returnStates = returnStates;
+        }
+
+        public override PredictionContext GetParent(int index)
+        {
+            return parents[index];
+        }
+
+        public override int GetReturnState(int index)
+        {
+            return returnStates[index];
+        }
+
+        public override int FindReturnState(int returnState)
+        {
+            return System.Array.BinarySearch(returnStates, returnState);
+        }
+
+        public override int Size
+        {
+            get
+            {
+                return returnStates.Length;
+            }
+        }
+
+        public override bool IsEmpty
+        {
+            get
+            {
+                return false;
+            }
+        }
+
+        public override bool HasEmpty
+        {
+            get
+            {
+                return returnStates[returnStates.Length - 1] == EmptyFullStateKey;
+            }
+        }
+
+        protected internal override PredictionContext AddEmptyContext()
+        {
+            if (HasEmpty)
+            {
+                return this;
+            }
+            PredictionContext[] parents2 = Arrays.CopyOf(parents, parents.Length + 1);
+            int[] returnStates2 = Arrays.CopyOf(returnStates, returnStates.Length + 1);
+            parents2[parents2.Length - 1] = PredictionContext.EmptyFull;
+            returnStates2[returnStates2.Length - 1] = PredictionContext.EmptyFullStateKey;
+            return new Antlr4.Runtime.Atn.ArrayPredictionContext(parents2, returnStates2);
+        }
+
+        protected internal override PredictionContext RemoveEmptyContext()
+        {
+            if (!HasEmpty)
+            {
+                return this;
+            }
+            if (returnStates.Length == 2)
+            {
+                return new SingletonPredictionContext(parents[0], returnStates[0]);
+            }
+            else
+            {
+                PredictionContext[] parents2 = Arrays.CopyOf(parents, parents.Length - 1);
+                int[] returnStates2 = Arrays.CopyOf(returnStates, returnStates.Length - 1);
+                return new Antlr4.Runtime.Atn.ArrayPredictionContext(parents2, returnStates2);
+            }
+        }
+
+        public override PredictionContext AppendContext(PredictionContext suffix, PredictionContextCache contextCache)
+        {
+            return AppendContext(this, suffix, new PredictionContext.IdentityHashMap());
+        }
+
+        private static PredictionContext AppendContext(PredictionContext context, PredictionContext suffix, PredictionContext.IdentityHashMap visited)
+        {
+            if (suffix.IsEmpty)
+            {
+                if (IsEmptyLocal(suffix))
+                {
+                    if (context.HasEmpty)
+                    {
+                        return EmptyLocal;
+                    }
+                    throw new NotSupportedException("what to do here?");
+                }
+                return context;
+            }
+            if (suffix.Size != 1)
+            {
+                throw new NotSupportedException("Appending a tree suffix is not yet supported.");
+            }
+            PredictionContext result;
+            if (!visited.TryGetValue(context, out result))
+            {
+                if (context.IsEmpty)
+                {
+                    result = suffix;
+                }
+                else
+                {
+                    int parentCount = context.Size;
+                    if (context.HasEmpty)
+                    {
+                        parentCount--;
+                    }
+                    PredictionContext[] updatedParents = new PredictionContext[parentCount];
+                    int[] updatedReturnStates = new int[parentCount];
+                    for (int i = 0; i < parentCount; i++)
+                    {
+                        updatedReturnStates[i] = context.GetReturnState(i);
+                    }
+                    for (int i_1 = 0; i_1 < parentCount; i_1++)
+                    {
+                        updatedParents[i_1] = AppendContext(context.GetParent(i_1), suffix, visited);
+                    }
+                    if (updatedParents.Length == 1)
+                    {
+                        result = new SingletonPredictionContext(updatedParents[0], updatedReturnStates[0]);
+                    }
+                    else
+                    {
+                        System.Diagnostics.Debug.Assert(updatedParents.Length > 1);
+                        result = new Antlr4.Runtime.Atn.ArrayPredictionContext(updatedParents, updatedReturnStates);
+                    }
+                    if (context.HasEmpty)
+                    {
+                        result = PredictionContext.Join(result, suffix);
+                    }
+                }
+                visited[context] = result;
+            }
+            return result;
+        }
+
+        public override bool Equals(object o)
+        {
+            if (this == o)
+            {
+                return true;
+            }
+            else
+            {
+                if (!(o is Antlr4.Runtime.Atn.ArrayPredictionContext))
+                {
+                    return false;
+                }
+            }
+            if (this.GetHashCode() != o.GetHashCode())
+            {
+                return false;
+            }
+            // can't be same if hash is different
+            Antlr4.Runtime.Atn.ArrayPredictionContext other = (Antlr4.Runtime.Atn.ArrayPredictionContext)o;
+            return Equals(other, new HashSet<PredictionContextCache.IdentityCommutativePredictionContextOperands>());
+        }
+
+        private bool Equals(Antlr4.Runtime.Atn.ArrayPredictionContext other, HashSet<PredictionContextCache.IdentityCommutativePredictionContextOperands> visited)
+        {
+            Stack<PredictionContext> selfWorkList = new Stack<PredictionContext>();
+            Stack<PredictionContext> otherWorkList = new Stack<PredictionContext>();
+            selfWorkList.Push(this);
+            otherWorkList.Push(other);
+            while (selfWorkList.Count > 0)
+            {
+                PredictionContextCache.IdentityCommutativePredictionContextOperands operands = new PredictionContextCache.IdentityCommutativePredictionContextOperands(selfWorkList.Pop(), otherWorkList.Pop());
+                if (!visited.Add(operands))
+                {
+                    continue;
+                }
+                int selfSize = operands.X.Size;
+                if (selfSize == 0)
+                {
+                    if (!operands.X.Equals(operands.Y))
+                    {
+                        return false;
+                    }
+                    continue;
+                }
+                int otherSize = operands.Y.Size;
+                if (selfSize != otherSize)
+                {
+                    return false;
+                }
+                for (int i = 0; i < selfSize; i++)
+                {
+                    if (operands.X.GetReturnState(i) != operands.Y.GetReturnState(i))
+                    {
+                        return false;
+                    }
+                    PredictionContext selfParent = operands.X.GetParent(i);
+                    PredictionContext otherParent = operands.Y.GetParent(i);
+                    if (selfParent.GetHashCode() != otherParent.GetHashCode())
+                    {
+                        return false;
+                    }
+                    if (selfParent != otherParent)
+                    {
+                        selfWorkList.Push(selfParent);
+                        otherWorkList.Push(otherParent);
+                    }
+                }
+            }
+            return true;
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/AtomTransition.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/AtomTransition.cs
new file mode 100644
index 000000000..ffb0358be
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/AtomTransition.cs
@@ -0,0 +1,76 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    /// <summary>TODO: make all transitions sets? no, should remove set edges</summary>
+    public sealed class AtomTransition : Transition
+    {
+        /// <summary>The token type or character value; or, signifies special label.</summary>
+        /// <remarks>The token type or character value; or, signifies special label.</remarks>
+        public readonly int token;
+
+		public AtomTransition(ATNState target, int token)
+            : base(target)
+        {
+			this.token = token;
+        }
+
+        public override Antlr4.Runtime.Atn.TransitionType TransitionType
+        {
+            get
+            {
+                return Antlr4.Runtime.Atn.TransitionType.Atom;
+            }
+        }
+
+        public override IntervalSet Label
+        {
+            get
+            {
+				return IntervalSet.Of(token);
+            }
+        }
+
+        public override bool Matches(int symbol, int minVocabSymbol, int maxVocabSymbol)
+        {
+			return token == symbol;
+        }
+
+        [return: NotNull]
+        public override string ToString()
+        {
+			return token.ToString();
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/BasicBlockStartState.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/BasicBlockStartState.cs
new file mode 100644
index 000000000..cee1e5814
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/BasicBlockStartState.cs
@@ -0,0 +1,46 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    /// <author>Sam Harwell</author>
+    public sealed class BasicBlockStartState : BlockStartState
+    {
+        public override Antlr4.Runtime.Atn.StateType StateType
+        {
+            get
+            {
+                return Antlr4.Runtime.Atn.StateType.BlockStart;
+            }
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/BasicState.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/BasicState.cs
new file mode 100644
index 000000000..2aa1ab335
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/BasicState.cs
@@ -0,0 +1,46 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    /// <author>Sam Harwell</author>
+    public sealed class BasicState : ATNState
+    {
+        public override Antlr4.Runtime.Atn.StateType StateType
+        {
+            get
+            {
+                return Antlr4.Runtime.Atn.StateType.Basic;
+            }
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/BlockEndState.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/BlockEndState.cs
new file mode 100644
index 000000000..ffa3a4c4b
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/BlockEndState.cs
@@ -0,0 +1,52 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    /// <summary>
+    /// Terminal node of a simple
+    /// <c>(a|b|c)</c>
+    /// block.
+    /// </summary>
+    public sealed class BlockEndState : ATNState
+    {
+        public BlockStartState startState;
+
+        public override Antlr4.Runtime.Atn.StateType StateType
+        {
+            get
+            {
+                return Antlr4.Runtime.Atn.StateType.BlockEnd;
+            }
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/BlockStartState.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/BlockStartState.cs
new file mode 100644
index 000000000..dc7e2c53d
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/BlockStartState.cs
@@ -0,0 +1,44 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    /// <summary>
+    /// The start of a regular
+    /// <c>(...)</c>
+    /// block.
+    /// </summary>
+    public abstract class BlockStartState : DecisionState
+    {
+        public BlockEndState endState;
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/ConflictInfo.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/ConflictInfo.cs
new file mode 100644
index 000000000..049b001a9
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/ConflictInfo.cs
@@ -0,0 +1,106 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    /// <summary>This class stores information about a configuration conflict.</summary>
+    /// <remarks>This class stores information about a configuration conflict.</remarks>
+    /// <author>Sam Harwell</author>
+    public class ConflictInfo
+    {
+        private readonly BitSet conflictedAlts;
+
+        private readonly bool exact;
+
+        public ConflictInfo(BitSet conflictedAlts, bool exact)
+        {
+            this.conflictedAlts = conflictedAlts;
+            this.exact = exact;
+        }
+
+        /// <summary>Gets the set of conflicting alternatives for the configuration set.</summary>
+        /// <remarks>Gets the set of conflicting alternatives for the configuration set.</remarks>
+        public BitSet ConflictedAlts
+        {
+            get
+            {
+                return conflictedAlts;
+            }
+        }
+
+        /// <summary>Gets whether or not the configuration conflict is an exact conflict.</summary>
+        /// <remarks>
+        /// Gets whether or not the configuration conflict is an exact conflict.
+        /// An exact conflict occurs when the prediction algorithm determines that
+        /// the represented alternatives for a particular configuration set cannot be
+        /// further reduced by consuming additional input. After reaching an exact
+        /// conflict during an SLL prediction, only switch to full-context prediction
+        /// could reduce the set of viable alternatives. In LL prediction, an exact
+        /// conflict indicates a true ambiguity in the input.
+        /// <p>
+        /// For the
+        /// <see cref="PredictionMode.LlExactAmbigDetection"/>
+        /// prediction mode,
+        /// accept states are conflicting but not exact are treated as non-accept
+        /// states.</p>
+        /// </remarks>
+        public bool IsExact
+        {
+            get
+            {
+                return exact;
+            }
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (obj == this)
+            {
+                return true;
+            }
+            else
+            {
+                if (!(obj is Antlr4.Runtime.Atn.ConflictInfo))
+                {
+                    return false;
+                }
+            }
+            Antlr4.Runtime.Atn.ConflictInfo other = (Antlr4.Runtime.Atn.ConflictInfo)obj;
+            return IsExact == other.IsExact && Utils.Equals(ConflictedAlts, other.ConflictedAlts);
+        }
+
+        public override int GetHashCode()
+        {
+            return ConflictedAlts.GetHashCode();
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/ContextSensitivityInfo.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/ContextSensitivityInfo.cs
new file mode 100644
index 000000000..e28c7d9e2
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/ContextSensitivityInfo.cs
@@ -0,0 +1,78 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    /// <summary>This class represents profiling event information for a context sensitivity.</summary>
+    /// <remarks>
+    /// This class represents profiling event information for a context sensitivity.
+    /// Context sensitivities are decisions where a particular input resulted in an
+    /// SLL conflict, but LL prediction produced a single unique alternative.
+    /// <p>
+    /// In some cases, the unique alternative identified by LL prediction is not
+    /// equal to the minimum represented alternative in the conflicting SLL
+    /// configuration set. Grammars and inputs which result in this scenario are
+    /// unable to use
+    /// <see cref="PredictionMode.Sll"/>
+    /// , which in turn means they cannot use
+    /// the two-stage parsing strategy to improve parsing performance for that
+    /// input.</p>
+    /// </remarks>
+    /// <seealso cref="ParserATNSimulator.ReportContextSensitivity(Antlr4.Runtime.Dfa.DFA, int, SimulatorState, int, int)"/>
+    /// <seealso cref="Antlr4.Runtime.IParserErrorListener.ReportContextSensitivity(Antlr4.Runtime.Parser, Antlr4.Runtime.Dfa.DFA, int, int, int, SimulatorState)"/>
+    /// <since>4.3</since>
+    public class ContextSensitivityInfo : DecisionEventInfo
+    {
+        /// <summary>
+        /// Constructs a new instance of the
+        /// <see cref="ContextSensitivityInfo"/>
+        /// class
+        /// with the specified detailed context sensitivity information.
+        /// </summary>
+        /// <param name="decision">The decision number</param>
+        /// <param name="state">
+        /// The final simulator state containing the unique
+        /// alternative identified by full-context prediction
+        /// </param>
+        /// <param name="input">The input token stream</param>
+        /// <param name="startIndex">The start index for the current prediction</param>
+        /// <param name="stopIndex">
+        /// The index at which the context sensitivity was
+        /// identified during full-context prediction
+        /// </param>
+        public ContextSensitivityInfo(int decision, SimulatorState state, ITokenStream input, int startIndex, int stopIndex)
+            : base(decision, state, input, startIndex, stopIndex, true)
+        {
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/DecisionEventInfo.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/DecisionEventInfo.cs
new file mode 100644
index 000000000..1037cc30b
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/DecisionEventInfo.cs
@@ -0,0 +1,101 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    /// <summary>
+    /// This is the base class for gathering detailed information about prediction
+    /// events which occur during parsing.
+    /// </summary>
+    /// <remarks>
+    /// This is the base class for gathering detailed information about prediction
+    /// events which occur during parsing.
+    /// </remarks>
+    /// <since>4.3</since>
+    public class DecisionEventInfo
+    {
+        /// <summary>The invoked decision number which this event is related to.</summary>
+        /// <remarks>The invoked decision number which this event is related to.</remarks>
+        /// <seealso cref="ATN.decisionToState"/>
+        public readonly int decision;
+
+        /// <summary>
+        /// The simulator state containing additional information relevant to the
+        /// prediction state when the current event occurred, or
+        /// <see langword="null"/>
+        /// if no
+        /// additional information is relevant or available.
+        /// </summary>
+        [Nullable]
+        public readonly SimulatorState state;
+
+        /// <summary>The input token stream which is being parsed.</summary>
+        /// <remarks>The input token stream which is being parsed.</remarks>
+        [NotNull]
+        public readonly ITokenStream input;
+
+        /// <summary>
+        /// The token index in the input stream at which the current prediction was
+        /// originally invoked.
+        /// </summary>
+        /// <remarks>
+        /// The token index in the input stream at which the current prediction was
+        /// originally invoked.
+        /// </remarks>
+        public readonly int startIndex;
+
+        /// <summary>The token index in the input stream at which the current event occurred.</summary>
+        /// <remarks>The token index in the input stream at which the current event occurred.</remarks>
+        public readonly int stopIndex;
+
+        /// <summary>
+        /// <see langword="true"/>
+        /// if the current event occurred during LL prediction;
+        /// otherwise,
+        /// <see langword="false"/>
+        /// if the input occurred during SLL prediction.
+        /// </summary>
+        public readonly bool fullCtx;
+
+        public DecisionEventInfo(int decision, SimulatorState state, ITokenStream input, int startIndex, int stopIndex, bool fullCtx)
+        {
+            this.decision = decision;
+            this.fullCtx = fullCtx;
+            this.stopIndex = stopIndex;
+            this.input = input;
+            this.startIndex = startIndex;
+            this.state = state;
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/DecisionInfo.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/DecisionInfo.cs
new file mode 100644
index 000000000..9cd92543a
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/DecisionInfo.cs
@@ -0,0 +1,305 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System.Collections.Generic;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Dfa;
+using Antlr4.Runtime.Sharpen;
+
+
+namespace Antlr4.Runtime.Atn
+{
+    /// <summary>This class contains profiling gathered for a particular decision.</summary>
+    /// <remarks>
+    /// This class contains profiling gathered for a particular decision.
+    /// <p>
+    /// Parsing performance in ANTLR 4 is heavily influenced by both static factors
+    /// (e.g. the form of the rules in the grammar) and dynamic factors (e.g. the
+    /// choice of input and the state of the DFA cache at the time profiling
+    /// operations are started). For best results, gather and use aggregate
+    /// statistics from a large sample of inputs representing the inputs expected in
+    /// production before using the results to make changes in the grammar.</p>
+    /// </remarks>
+    /// <since>4.3</since>
+    public class DecisionInfo
+    {
+        /// <summary>
+        /// The decision number, which is an index into
+        /// <see cref="ATN.decisionToState"/>
+        /// .
+        /// </summary>
+        public readonly int decision;
+
+        /// <summary>
+        /// The total number of times
+        /// <see cref="ParserATNSimulator.AdaptivePredict(ITokenStream, int, ParserRuleContext)"/>
+        /// was
+        /// invoked for this decision.
+        /// </summary>
+        public long invocations;
+
+        /// <summary>The sum of the lookahead required for SLL prediction for this decision.</summary>
+        /// <remarks>
+        /// The sum of the lookahead required for SLL prediction for this decision.
+        /// Note that SLL prediction is used before LL prediction for performance
+        /// reasons even when
+        /// <see cref="PredictionMode.Ll"/>
+        /// or
+        /// <see cref="PredictionMode.LlExactAmbigDetection"/>
+        /// is used.
+        /// </remarks>
+        public long SLL_TotalLook;
+
+        /// <summary>
+        /// Gets the minimum lookahead required for any single SLL prediction to
+        /// complete for this decision, by reaching a unique prediction, reaching an
+        /// SLL conflict state, or encountering a syntax error.
+        /// </summary>
+        /// <remarks>
+        /// Gets the minimum lookahead required for any single SLL prediction to
+        /// complete for this decision, by reaching a unique prediction, reaching an
+        /// SLL conflict state, or encountering a syntax error.
+        /// </remarks>
+        public long SLL_MinLook;
+
+        /// <summary>
+        /// Gets the maximum lookahead required for any single SLL prediction to
+        /// complete for this decision, by reaching a unique prediction, reaching an
+        /// SLL conflict state, or encountering a syntax error.
+        /// </summary>
+        /// <remarks>
+        /// Gets the maximum lookahead required for any single SLL prediction to
+        /// complete for this decision, by reaching a unique prediction, reaching an
+        /// SLL conflict state, or encountering a syntax error.
+        /// </remarks>
+        public long SLL_MaxLook;
+
+        /// <summary>
+        /// Gets the
+        /// <see cref="LookaheadEventInfo"/>
+        /// associated with the event where the
+        /// <see cref="SLL_MaxLook"/>
+        /// value was set.
+        /// </summary>
+        public LookaheadEventInfo SLL_MaxLookEvent;
+
+        /// <summary>The sum of the lookahead required for LL prediction for this decision.</summary>
+        /// <remarks>
+        /// The sum of the lookahead required for LL prediction for this decision.
+        /// Note that LL prediction is only used when SLL prediction reaches a
+        /// conflict state.
+        /// </remarks>
+        public long LL_TotalLook;
+
+        /// <summary>
+        /// Gets the minimum lookahead required for any single LL prediction to
+        /// complete for this decision.
+        /// </summary>
+        /// <remarks>
+        /// Gets the minimum lookahead required for any single LL prediction to
+        /// complete for this decision. An LL prediction completes when the algorithm
+        /// reaches a unique prediction, a conflict state (for
+        /// <see cref="PredictionMode.Ll"/>
+        /// , an ambiguity state (for
+        /// <see cref="PredictionMode.LlExactAmbigDetection"/>
+        /// , or a syntax error.
+        /// </remarks>
+        public long LL_MinLook;
+
+        /// <summary>
+        /// Gets the maximum lookahead required for any single LL prediction to
+        /// complete for this decision.
+        /// </summary>
+        /// <remarks>
+        /// Gets the maximum lookahead required for any single LL prediction to
+        /// complete for this decision. An LL prediction completes when the algorithm
+        /// reaches a unique prediction, a conflict state (for
+        /// <see cref="PredictionMode.Ll"/>
+        /// , an ambiguity state (for
+        /// <see cref="PredictionMode.LlExactAmbigDetection"/>
+        /// , or a syntax error.
+        /// </remarks>
+        public long LL_MaxLook;
+
+        /// <summary>
+        /// Gets the
+        /// <see cref="LookaheadEventInfo"/>
+        /// associated with the event where the
+        /// <see cref="LL_MaxLook"/>
+        /// value was set.
+        /// </summary>
+        public LookaheadEventInfo LL_MaxLookEvent;
+
+        /// <summary>
+        /// A collection of
+        /// <see cref="ContextSensitivityInfo"/>
+        /// instances describing the
+        /// context sensitivities encountered during LL prediction for this decision.
+        /// </summary>
+        /// <seealso cref="ContextSensitivityInfo"/>
+        public readonly IList<ContextSensitivityInfo> contextSensitivities = new List<ContextSensitivityInfo>();
+
+        /// <summary>
+        /// A collection of
+        /// <see cref="ErrorInfo"/>
+        /// instances describing the parse errors
+        /// identified during calls to
+        /// <see cref="ParserATNSimulator.AdaptivePredict(ITokenStream, int, ParserRuleContext)"/>
+        /// for
+        /// this decision.
+        /// </summary>
+        /// <seealso cref="ErrorInfo"/>
+        public readonly IList<ErrorInfo> errors = new List<ErrorInfo>();
+
+        /// <summary>
+        /// A collection of
+        /// <see cref="AmbiguityInfo"/>
+        /// instances describing the
+        /// ambiguities encountered during LL prediction for this decision.
+        /// </summary>
+        /// <seealso cref="AmbiguityInfo"/>
+        public readonly IList<AmbiguityInfo> ambiguities = new List<AmbiguityInfo>();
+
+        /// <summary>
+        /// A collection of
+        /// <see cref="PredicateEvalInfo"/>
+        /// instances describing the
+        /// results of evaluating individual predicates during prediction for this
+        /// decision.
+        /// </summary>
+        /// <seealso cref="PredicateEvalInfo"/>
+        public readonly IList<PredicateEvalInfo> predicateEvals = new List<PredicateEvalInfo>();
+
+        /// <summary>
+        /// The total number of ATN transitions required during SLL prediction for
+        /// this decision.
+        /// </summary>
+        /// <remarks>
+        /// The total number of ATN transitions required during SLL prediction for
+        /// this decision. An ATN transition is determined by the number of times the
+        /// DFA does not contain an edge that is required for prediction, resulting
+        /// in on-the-fly computation of that edge.
+        /// <p>
+        /// If DFA caching of SLL transitions is employed by the implementation, ATN
+        /// computation may cache the computed edge for efficient lookup during
+        /// future parsing of this decision. Otherwise, the SLL parsing algorithm
+        /// will use ATN transitions exclusively.</p>
+        /// </remarks>
+        /// <seealso cref="SLL_ATNTransitions"/>
+        /// <seealso cref="ParserATNSimulator.ComputeTargetState"/>
+        /// <seealso cref="LexerATNSimulator.ComputeTargetState"/>
+        public long SLL_ATNTransitions;
+
+        /// <summary>
+        /// The total number of DFA transitions required during SLL prediction for
+        /// this decision.
+        /// </summary>
+        /// <remarks>
+        /// The total number of DFA transitions required during SLL prediction for
+        /// this decision.
+        /// <p>If the ATN simulator implementation does not use DFA caching for SLL
+        /// transitions, this value will be 0.</p>
+        /// </remarks>
+        /// <seealso cref="ParserATNSimulator.GetExistingTargetState"/>
+        /// <seealso cref="LexerATNSimulator.GetExistingTargetState"/>
+        public long SLL_DFATransitions;
+
+        /// <summary>
+        /// Gets the total number of times SLL prediction completed in a conflict
+        /// state, resulting in fallback to LL prediction.
+        /// </summary>
+        /// <remarks>
+        /// Gets the total number of times SLL prediction completed in a conflict
+        /// state, resulting in fallback to LL prediction.
+        /// <p>Note that this value is not related to whether or not
+        /// <see cref="PredictionMode.Sll"/>
+        /// may be used successfully with a particular
+        /// grammar. If the ambiguity resolution algorithm applied to the SLL
+        /// conflicts for this decision produce the same result as LL prediction for
+        /// this decision,
+        /// <see cref="PredictionMode.Sll"/>
+        /// would produce the same overall
+        /// parsing result as
+        /// <see cref="PredictionMode.Ll"/>
+        /// .</p>
+        /// </remarks>
+        public long LL_Fallback;
+
+        /// <summary>
+        /// The total number of ATN transitions required during LL prediction for
+        /// this decision.
+        /// </summary>
+        /// <remarks>
+        /// The total number of ATN transitions required during LL prediction for
+        /// this decision. An ATN transition is determined by the number of times the
+        /// DFA does not contain an edge that is required for prediction, resulting
+        /// in on-the-fly computation of that edge.
+        /// <p>
+        /// If DFA caching of LL transitions is employed by the implementation, ATN
+        /// computation may cache the computed edge for efficient lookup during
+        /// future parsing of this decision. Otherwise, the LL parsing algorithm will
+        /// use ATN transitions exclusively.</p>
+        /// </remarks>
+        /// <seealso cref="LL_DFATransitions"/>
+        /// <seealso cref="ParserATNSimulator.ComputeTargetState"/>
+        /// <seealso cref="LexerATNSimulator.ComputeTargetState"/>
+        public long LL_ATNTransitions;
+
+        /// <summary>
+        /// The total number of DFA transitions required during LL prediction for
+        /// this decision.
+        /// </summary>
+        /// <remarks>
+        /// The total number of DFA transitions required during LL prediction for
+        /// this decision.
+        /// <p>If the ATN simulator implementation does not use DFA caching for LL
+        /// transitions, this value will be 0.</p>
+        /// </remarks>
+        /// <seealso cref="ParserATNSimulator.GetExistingTargetState"/>
+        /// <seealso cref="LexerATNSimulator.GetExistingTargetState"/>
+        public long LL_DFATransitions;
+
+        /// <summary>
+        /// Constructs a new instance of the
+        /// <see cref="DecisionInfo"/>
+        /// class to contain
+        /// statistics for a particular decision.
+        /// </summary>
+        /// <param name="decision">The decision number</param>
+        public DecisionInfo(int decision)
+        {
+            this.decision = decision;
+        }
+
+        public override string ToString()
+        {
+            return "{" + "decision=" + decision + ", contextSensitivities=" + contextSensitivities.Count + ", errors=" + errors.Count + ", ambiguities=" + ambiguities.Count + ", SLL_lookahead=" + SLL_TotalLook + ", SLL_ATNTransitions=" + SLL_ATNTransitions + ", SLL_DFATransitions=" + SLL_DFATransitions + ", LL_Fallback=" + LL_Fallback + ", LL_lookahead=" + LL_TotalLook + ", LL_ATNTransitions=" + LL_ATNTransitions + '}';
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/DecisionState.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/DecisionState.cs
new file mode 100644
index 000000000..e1e31ebda
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/DecisionState.cs
@@ -0,0 +1,41 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    public abstract class DecisionState : ATNState
+    {
+        public int decision = -1;
+
+        public bool nonGreedy;
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/EmptyPredictionContext.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/EmptyPredictionContext.cs
new file mode 100644
index 000000000..11d7141eb
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/EmptyPredictionContext.cs
@@ -0,0 +1,134 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System;
+using Antlr4.Runtime;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+#pragma warning disable 0659 // 'class' overrides Object.Equals(object o) but does not override Object.GetHashCode()
+    public sealed class EmptyPredictionContext : PredictionContext
+    {
+        public static readonly Antlr4.Runtime.Atn.EmptyPredictionContext LocalContext = new Antlr4.Runtime.Atn.EmptyPredictionContext(false);
+
+        public static readonly Antlr4.Runtime.Atn.EmptyPredictionContext FullContext = new Antlr4.Runtime.Atn.EmptyPredictionContext(true);
+
+        private readonly bool fullContext;
+
+        private EmptyPredictionContext(bool fullContext)
+            : base(CalculateEmptyHashCode())
+        {
+            this.fullContext = fullContext;
+        }
+
+        public bool IsFullContext
+        {
+            get
+            {
+                return fullContext;
+            }
+        }
+
+        protected internal override PredictionContext AddEmptyContext()
+        {
+            return this;
+        }
+
+        protected internal override PredictionContext RemoveEmptyContext()
+        {
+            throw new NotSupportedException("Cannot remove the empty context from itself.");
+        }
+
+        public override PredictionContext GetParent(int index)
+        {
+            throw new ArgumentOutOfRangeException();
+        }
+
+        public override int GetReturnState(int index)
+        {
+            throw new ArgumentOutOfRangeException();
+        }
+
+        public override int FindReturnState(int returnState)
+        {
+            return -1;
+        }
+
+        public override int Size
+        {
+            get
+            {
+                return 0;
+            }
+        }
+
+        public override PredictionContext AppendContext(int returnContext, PredictionContextCache contextCache)
+        {
+            return contextCache.GetChild(this, returnContext);
+        }
+
+        public override PredictionContext AppendContext(PredictionContext suffix, PredictionContextCache contextCache)
+        {
+            return suffix;
+        }
+
+        public override bool IsEmpty
+        {
+            get
+            {
+                return true;
+            }
+        }
+
+        public override bool HasEmpty
+        {
+            get
+            {
+                return true;
+            }
+        }
+
+        public override bool Equals(object o)
+        {
+            return this == o;
+        }
+
+        public override string[] ToStrings(IRecognizer recognizer, int currentState)
+        {
+            return new string[] { "[]" };
+        }
+
+        public override string[] ToStrings(IRecognizer recognizer, PredictionContext stop, int currentState)
+        {
+            return new string[] { "[]" };
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/EpsilonTransition.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/EpsilonTransition.cs
new file mode 100644
index 000000000..c386838de
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/EpsilonTransition.cs
@@ -0,0 +1,93 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    public sealed class EpsilonTransition : Transition
+    {
+        private readonly int outermostPrecedenceReturn;
+
+        public EpsilonTransition(ATNState target)
+            : this(target, -1)
+        {
+        }
+
+        public EpsilonTransition(ATNState target, int outermostPrecedenceReturn)
+            : base(target)
+        {
+            this.outermostPrecedenceReturn = outermostPrecedenceReturn;
+        }
+
+        /// <returns>
+        /// the rule index of a precedence rule for which this transition is
+        /// returning from, where the precedence value is 0; otherwise, -1.
+        /// </returns>
+        /// <seealso cref="ATNConfig.PrecedenceFilterSuppressed()"/>
+        /// <seealso cref="ParserATNSimulator.ApplyPrecedenceFilter(ATNConfigSet, Antlr4.Runtime.ParserRuleContext, PredictionContextCache)"/>
+        /// <since>4.4.1</since>
+        public int OutermostPrecedenceReturn
+        {
+            get
+            {
+                return outermostPrecedenceReturn;
+            }
+        }
+
+        public override Antlr4.Runtime.Atn.TransitionType TransitionType
+        {
+            get
+            {
+                return Antlr4.Runtime.Atn.TransitionType.Epsilon;
+            }
+        }
+
+        public override bool IsEpsilon
+        {
+            get
+            {
+                return true;
+            }
+        }
+
+        public override bool Matches(int symbol, int minVocabSymbol, int maxVocabSymbol)
+        {
+            return false;
+        }
+
+        [return: NotNull]
+        public override string ToString()
+        {
+            return "epsilon";
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/ErrorInfo.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/ErrorInfo.cs
new file mode 100644
index 000000000..12c7ccf19
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/ErrorInfo.cs
@@ -0,0 +1,72 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    /// <summary>
+    /// This class represents profiling event information for a syntax error
+    /// identified during prediction.
+    /// </summary>
+    /// <remarks>
+    /// This class represents profiling event information for a syntax error
+    /// identified during prediction. Syntax errors occur when the prediction
+    /// algorithm is unable to identify an alternative which would lead to a
+    /// successful parse.
+    /// </remarks>
+    /// <seealso cref="Parser.NotifyErrorListeners(IToken, string, RecognitionException)"/>
+    /// <seealso cref="IAntlrErrorListener{TSymbol}.SyntaxError"/>
+    /// <since>4.3</since>
+    public class ErrorInfo : DecisionEventInfo
+    {
+        /// <summary>
+        /// Constructs a new instance of the
+        /// <see cref="ErrorInfo"/>
+        /// class with the
+        /// specified detailed syntax error information.
+        /// </summary>
+        /// <param name="decision">The decision number</param>
+        /// <param name="state">
+        /// The final simulator state reached during prediction
+        /// prior to reaching the
+        /// <see cref="ATNSimulator.Error"/>
+        /// state
+        /// </param>
+        /// <param name="input">The input token stream</param>
+        /// <param name="startIndex">The start index for the current prediction</param>
+        /// <param name="stopIndex">The index at which the syntax error was identified</param>
+        public ErrorInfo(int decision, SimulatorState state, ITokenStream input, int startIndex, int stopIndex)
+            : base(decision, state, input, startIndex, stopIndex, state.useContext)
+        {
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/ILexerAction.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/ILexerAction.cs
new file mode 100644
index 000000000..56b3e8e30
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/ILexerAction.cs
@@ -0,0 +1,103 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    /// <summary>
+    /// Represents a single action which can be executed following the successful
+    /// match of a lexer rule.
+    /// </summary>
+    /// <remarks>
+    /// Represents a single action which can be executed following the successful
+    /// match of a lexer rule. Lexer actions are used for both embedded action syntax
+    /// and ANTLR 4's new lexer command syntax.
+    /// </remarks>
+    /// <author>Sam Harwell</author>
+    /// <since>4.2</since>
+    public interface ILexerAction
+    {
+        /// <summary>Gets the serialization type of the lexer action.</summary>
+        /// <remarks>Gets the serialization type of the lexer action.</remarks>
+        /// <returns>The serialization type of the lexer action.</returns>
+        [NotNull]
+        LexerActionType ActionType
+        {
+            get;
+        }
+
+        /// <summary>Gets whether the lexer action is position-dependent.</summary>
+        /// <remarks>
+        /// Gets whether the lexer action is position-dependent. Position-dependent
+        /// actions may have different semantics depending on the
+        /// <see cref="Antlr4.Runtime.ICharStream"/>
+        /// index at the time the action is executed.
+        /// <p>Many lexer commands, including
+        /// <c>type</c>
+        /// ,
+        /// <c>skip</c>
+        /// , and
+        /// <c>more</c>
+        /// , do not check the input index during their execution.
+        /// Actions like this are position-independent, and may be stored more
+        /// efficiently as part of the
+        /// <see cref="ATNConfig.ActionExecutor()"/>
+        /// .</p>
+        /// </remarks>
+        /// <returns>
+        /// 
+        /// <see langword="true"/>
+        /// if the lexer action semantics can be affected by the
+        /// position of the input
+        /// <see cref="Antlr4.Runtime.ICharStream"/>
+        /// at the time it is executed;
+        /// otherwise,
+        /// <see langword="false"/>
+        /// .
+        /// </returns>
+        bool IsPositionDependent
+        {
+            get;
+        }
+
+        /// <summary>
+        /// Execute the lexer action in the context of the specified
+        /// <see cref="Antlr4.Runtime.Lexer"/>
+        /// .
+        /// <p>For position-dependent actions, the input stream must already be
+        /// positioned correctly prior to calling this method.</p>
+        /// </summary>
+        /// <param name="lexer">The lexer instance.</param>
+        void Execute(Lexer lexer);
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/LL1Analyzer.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/LL1Analyzer.cs
new file mode 100644
index 000000000..ed90cb8e4
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/LL1Analyzer.cs
@@ -0,0 +1,408 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System.Collections.Generic;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    public class LL1Analyzer
+    {
+        /// <summary>
+        /// Special value added to the lookahead sets to indicate that we hit
+        /// a predicate during analysis if
+        /// <c>seeThruPreds==false</c>
+        /// .
+        /// </summary>
+        public const int HitPred = TokenConstants.InvalidType;
+
+        [NotNull]
+        public readonly ATN atn;
+
+        public LL1Analyzer(ATN atn)
+        {
+            this.atn = atn;
+        }
+
+        /// <summary>
+        /// Calculates the SLL(1) expected lookahead set for each outgoing transition
+        /// of an
+        /// <see cref="ATNState"/>
+        /// . The returned array has one element for each
+        /// outgoing transition in
+        /// <paramref name="s"/>
+        /// . If the closure from transition
+        /// <em>i</em> leads to a semantic predicate before matching a symbol, the
+        /// element at index <em>i</em> of the result will be
+        /// <see langword="null"/>
+        /// .
+        /// </summary>
+        /// <param name="s">the ATN state</param>
+        /// <returns>
+        /// the expected symbols for each outgoing transition of
+        /// <paramref name="s"/>
+        /// .
+        /// </returns>
+        [return: Nullable]
+        public virtual IntervalSet[] GetDecisionLookahead(ATNState s)
+        {
+            //		System.out.println("LOOK("+s.stateNumber+")");
+            if (s == null)
+            {
+                return null;
+            }
+            IntervalSet[] look = new IntervalSet[s.NumberOfTransitions];
+            for (int alt = 0; alt < s.NumberOfTransitions; alt++)
+            {
+                look[alt] = new IntervalSet();
+                HashSet<ATNConfig> lookBusy = new HashSet<ATNConfig>();
+                bool seeThruPreds = false;
+                // fail to get lookahead upon pred
+                Look(s.Transition(alt).target, null, PredictionContext.EmptyLocal, look[alt], lookBusy, new BitSet(), seeThruPreds, false);
+                // Wipe out lookahead for this alternative if we found nothing
+                // or we had a predicate when we !seeThruPreds
+                if (look[alt].Count == 0 || look[alt].Contains(HitPred))
+                {
+                    look[alt] = null;
+                }
+            }
+            return look;
+        }
+
+        /// <summary>
+        /// Compute set of tokens that can follow
+        /// <paramref name="s"/>
+        /// in the ATN in the
+        /// specified
+        /// <paramref name="ctx"/>
+        /// .
+        /// <p>If
+        /// <paramref name="ctx"/>
+        /// is
+        /// <see langword="null"/>
+        /// and the end of the rule containing
+        /// <paramref name="s"/>
+        /// is reached,
+        /// <see cref="TokenConstants.Epsilon"/>
+        /// is added to the result set.
+        /// If
+        /// <paramref name="ctx"/>
+        /// is not
+        /// <see langword="null"/>
+        /// and the end of the outermost rule is
+        /// reached,
+        /// <see cref="TokenConstants.Eof"/>
+        /// is added to the result set.</p>
+        /// </summary>
+        /// <param name="s">the ATN state</param>
+        /// <param name="ctx">
+        /// the complete parser context, or
+        /// <see langword="null"/>
+        /// if the context
+        /// should be ignored
+        /// </param>
+        /// <returns>
+        /// The set of tokens that can follow
+        /// <paramref name="s"/>
+        /// in the ATN in the
+        /// specified
+        /// <paramref name="ctx"/>
+        /// .
+        /// </returns>
+        [return: NotNull]
+        public virtual IntervalSet Look(ATNState s, PredictionContext ctx)
+        {
+            return Look(s, s.atn.ruleToStopState[s.ruleIndex], ctx);
+        }
+
+        /// <summary>
+        /// Compute set of tokens that can follow
+        /// <paramref name="s"/>
+        /// in the ATN in the
+        /// specified
+        /// <paramref name="ctx"/>
+        /// .
+        /// <p>If
+        /// <paramref name="ctx"/>
+        /// is
+        /// <see langword="null"/>
+        /// and the end of the rule containing
+        /// <paramref name="s"/>
+        /// is reached,
+        /// <see cref="TokenConstants.Epsilon"/>
+        /// is added to the result set.
+        /// If
+        /// <paramref name="ctx"/>
+        /// is not
+        /// <c>PredictionContext#EMPTY_LOCAL</c>
+        /// and the end of the outermost rule is
+        /// reached,
+        /// <see cref="TokenConstants.Eof"/>
+        /// is added to the result set.</p>
+        /// </summary>
+        /// <param name="s">the ATN state</param>
+        /// <param name="stopState">
+        /// the ATN state to stop at. This can be a
+        /// <see cref="BlockEndState"/>
+        /// to detect epsilon paths through a closure.
+        /// </param>
+        /// <param name="ctx">
+        /// the complete parser context, or
+        /// <see langword="null"/>
+        /// if the context
+        /// should be ignored
+        /// </param>
+        /// <returns>
+        /// The set of tokens that can follow
+        /// <paramref name="s"/>
+        /// in the ATN in the
+        /// specified
+        /// <paramref name="ctx"/>
+        /// .
+        /// </returns>
+        [return: NotNull]
+        public virtual IntervalSet Look(ATNState s, ATNState stopState, PredictionContext ctx)
+        {
+            IntervalSet r = new IntervalSet();
+            bool seeThruPreds = true;
+            // ignore preds; get all lookahead
+            bool addEOF = true;
+            Look(s, stopState, ctx, r, new HashSet<ATNConfig>(), new BitSet(), seeThruPreds, addEOF);
+            return r;
+        }
+
+        /// <summary>
+        /// Compute set of tokens that can follow
+        /// <paramref name="s"/>
+        /// in the ATN in the
+        /// specified
+        /// <paramref name="ctx"/>
+        /// .
+        /// <p/>
+        /// If
+        /// <paramref name="ctx"/>
+        /// is
+        /// <see cref="PredictionContext.EmptyLocal"/>
+        /// and
+        /// <paramref name="stopState"/>
+        /// or the end of the rule containing
+        /// <paramref name="s"/>
+        /// is reached,
+        /// <see cref="TokenConstants.Epsilon"/>
+        /// is added to the result set. If
+        /// <paramref name="ctx"/>
+        /// is not
+        /// <see cref="PredictionContext.EmptyLocal"/>
+        /// and
+        /// <paramref name="addEOF"/>
+        /// is
+        /// <see langword="true"/>
+        /// and
+        /// <paramref name="stopState"/>
+        /// or the end of the outermost rule is reached,
+        /// <see cref="TokenConstants.Eof"/>
+        /// is added to the result set.
+        /// </summary>
+        /// <param name="s">the ATN state.</param>
+        /// <param name="stopState">
+        /// the ATN state to stop at. This can be a
+        /// <see cref="BlockEndState"/>
+        /// to detect epsilon paths through a closure.
+        /// </param>
+        /// <param name="ctx">
+        /// The outer context, or
+        /// <see cref="PredictionContext.EmptyLocal"/>
+        /// if
+        /// the outer context should not be used.
+        /// </param>
+        /// <param name="look">The result lookahead set.</param>
+        /// <param name="lookBusy">
+        /// A set used for preventing epsilon closures in the ATN
+        /// from causing a stack overflow. Outside code should pass
+        /// <c>new HashSet&lt;ATNConfig&gt;</c>
+        /// for this argument.
+        /// </param>
+        /// <param name="calledRuleStack">
+        /// A set used for preventing left recursion in the
+        /// ATN from causing a stack overflow. Outside code should pass
+        /// <c>new BitSet()</c>
+        /// for this argument.
+        /// </param>
+        /// <param name="seeThruPreds">
+        /// 
+        /// <see langword="true"/>
+        /// to true semantic predicates as
+        /// implicitly
+        /// <see langword="true"/>
+        /// and "see through them", otherwise
+        /// <see langword="false"/>
+        /// to treat semantic predicates as opaque and add
+        /// <see cref="HitPred"/>
+        /// to the
+        /// result if one is encountered.
+        /// </param>
+        /// <param name="addEOF">
+        /// Add
+        /// <see cref="TokenConstants.Eof"/>
+        /// to the result if the end of the
+        /// outermost context is reached. This parameter has no effect if
+        /// <paramref name="ctx"/>
+        /// is
+        /// <see cref="PredictionContext.EmptyLocal"/>
+        /// .
+        /// </param>
+        protected internal virtual void Look(ATNState s, ATNState stopState, PredictionContext ctx, IntervalSet look, HashSet<ATNConfig> lookBusy, BitSet calledRuleStack, bool seeThruPreds, bool addEOF)
+        {
+            //		System.out.println("_LOOK("+s.stateNumber+", ctx="+ctx);
+            ATNConfig c = ATNConfig.Create(s, 0, ctx);
+            if (!lookBusy.Add(c))
+            {
+                return;
+            }
+            if (s == stopState)
+            {
+                if (PredictionContext.IsEmptyLocal(ctx))
+                {
+                    look.Add(TokenConstants.Epsilon);
+                    return;
+                }
+                else
+                {
+                    if (ctx.IsEmpty)
+                    {
+                        if (addEOF)
+                        {
+                            look.Add(TokenConstants.Eof);
+                        }
+                        return;
+                    }
+                }
+            }
+            if (s is RuleStopState)
+            {
+                if (ctx.IsEmpty && !PredictionContext.IsEmptyLocal(ctx))
+                {
+                    if (addEOF)
+                    {
+                        look.Add(TokenConstants.Eof);
+                    }
+                    return;
+                }
+                bool removed = calledRuleStack.Get(s.ruleIndex);
+                try
+                {
+                    calledRuleStack.Clear(s.ruleIndex);
+                    for (int i = 0; i < ctx.Size; i++)
+                    {
+                        if (ctx.GetReturnState(i) == PredictionContext.EmptyFullStateKey)
+                        {
+                            continue;
+                        }
+                        ATNState returnState = atn.states[ctx.GetReturnState(i)];
+                        //					System.out.println("popping back to "+retState);
+                        Look(returnState, stopState, ctx.GetParent(i), look, lookBusy, calledRuleStack, seeThruPreds, addEOF);
+                    }
+                }
+                finally
+                {
+                    if (removed)
+                    {
+                        calledRuleStack.Set(s.ruleIndex);
+                    }
+                }
+            }
+            int n = s.NumberOfTransitions;
+            for (int i_1 = 0; i_1 < n; i_1++)
+            {
+                Transition t = s.Transition(i_1);
+                if (t is RuleTransition)
+                {
+                    RuleTransition ruleTransition = (RuleTransition)t;
+                    if (calledRuleStack.Get(ruleTransition.ruleIndex))
+                    {
+                        continue;
+                    }
+                    PredictionContext newContext = ctx.GetChild(ruleTransition.followState.stateNumber);
+                    try
+                    {
+                        calledRuleStack.Set(ruleTransition.ruleIndex);
+                        Look(t.target, stopState, newContext, look, lookBusy, calledRuleStack, seeThruPreds, addEOF);
+                    }
+                    finally
+                    {
+                        calledRuleStack.Clear(ruleTransition.ruleIndex);
+                    }
+                }
+                else
+                {
+                    if (t is AbstractPredicateTransition)
+                    {
+                        if (seeThruPreds)
+                        {
+                            Look(t.target, stopState, ctx, look, lookBusy, calledRuleStack, seeThruPreds, addEOF);
+                        }
+                        else
+                        {
+                            look.Add(HitPred);
+                        }
+                    }
+                    else
+                    {
+                        if (t.IsEpsilon)
+                        {
+                            Look(t.target, stopState, ctx, look, lookBusy, calledRuleStack, seeThruPreds, addEOF);
+                        }
+                        else
+                        {
+                            if (t.GetType() == typeof(WildcardTransition))
+                            {
+                                look.AddAll(IntervalSet.Of(TokenConstants.MinUserTokenType, atn.maxTokenType));
+                            }
+                            else
+                            {
+                                //				System.out.println("adding "+ t);
+                                IntervalSet set = t.Label;
+                                if (set != null)
+                                {
+                                    if (t is NotSetTransition)
+                                    {
+                                        set = set.Complement(IntervalSet.Of(TokenConstants.MinUserTokenType, atn.maxTokenType));
+                                    }
+                                    look.AddAll(set);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/LexerATNSimulator.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/LexerATNSimulator.cs
new file mode 100644
index 000000000..82404d10f
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/LexerATNSimulator.cs
@@ -0,0 +1,823 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System;
+using Antlr4.Runtime;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Dfa;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    /// <summary>"dup" of ParserInterpreter</summary>
+    public class LexerATNSimulator : ATNSimulator
+    {
+#if !PORTABLE
+        public const bool debug = false;
+
+        public const bool dfa_debug = false;
+#endif
+
+        public const int MinDfaEdge = 0;
+
+        public const int MaxDfaEdge = 127;
+
+        public bool optimize_tail_calls = true;
+
+        /// <summary>
+        /// When we hit an accept state in either the DFA or the ATN, we
+        /// have to notify the character stream to start buffering characters
+        /// via
+        /// <see cref="Antlr4.Runtime.IIntStream.Mark()"/>
+        /// and record the current state. The current sim state
+        /// includes the current index into the input, the current line,
+        /// and current character position in that line. Note that the Lexer is
+        /// tracking the starting line and characterization of the token. These
+        /// variables track the "state" of the simulator when it hits an accept state.
+        /// <p>We track these variables separately for the DFA and ATN simulation
+        /// because the DFA simulation often has to fail over to the ATN
+        /// simulation. If the ATN simulation fails, we need the DFA to fall
+        /// back to its previously accepted state, if any. If the ATN succeeds,
+        /// then the ATN does the accept and the DFA simulator that invoked it
+        /// can simply return the predicted token type.</p>
+        /// </summary>
+        protected internal class SimState
+        {
+            protected internal int index = -1;
+
+            protected internal int line = 0;
+
+            protected internal int charPos = -1;
+
+            protected internal DFAState dfaState;
+
+            // forces unicode to stay in ATN
+            protected internal virtual void Reset()
+            {
+                index = -1;
+                line = 0;
+                charPos = -1;
+                dfaState = null;
+            }
+        }
+
+        [Nullable]
+        protected internal readonly Lexer recog;
+
+        /// <summary>The current token's starting index into the character stream.</summary>
+        /// <remarks>
+        /// The current token's starting index into the character stream.
+        /// Shared across DFA to ATN simulation in case the ATN fails and the
+        /// DFA did not have a previous accept state. In this case, we use the
+        /// ATN-generated exception object.
+        /// </remarks>
+        protected internal int startIndex = -1;
+
+        /// <summary>line number 1..n within the input</summary>
+        private int _line = 1;
+
+        /// <summary>The index of the character relative to the beginning of the line 0..n-1</summary>
+        protected internal int charPositionInLine = 0;
+
+        protected internal int mode = Lexer.DefaultMode;
+
+        /// <summary>Used during DFA/ATN exec to record the most recent accept configuration info</summary>
+        [NotNull]
+        protected internal readonly LexerATNSimulator.SimState prevAccept = new LexerATNSimulator.SimState();
+
+        public static int match_calls = 0;
+
+        public LexerATNSimulator(ATN atn)
+            : this(null, atn)
+        {
+        }
+
+        public LexerATNSimulator(Lexer recog, ATN atn)
+            : base(atn)
+        {
+            this.recog = recog;
+        }
+
+        public virtual void CopyState(LexerATNSimulator simulator)
+        {
+            this.charPositionInLine = simulator.charPositionInLine;
+            this._line = simulator._line;
+            this.mode = simulator.mode;
+            this.startIndex = simulator.startIndex;
+        }
+
+        public virtual int Match(ICharStream input, int mode)
+        {
+            match_calls++;
+            this.mode = mode;
+            int mark = input.Mark();
+            try
+            {
+                this.startIndex = input.Index;
+                this.prevAccept.Reset();
+                DFAState s0 = atn.modeToDFA[mode].s0.Get();
+                if (s0 == null)
+                {
+                    return MatchATN(input);
+                }
+                else
+                {
+                    return ExecATN(input, s0);
+                }
+            }
+            finally
+            {
+                input.Release(mark);
+            }
+        }
+
+        public override void Reset()
+        {
+            prevAccept.Reset();
+            startIndex = -1;
+            _line = 1;
+            charPositionInLine = 0;
+            mode = Lexer.DefaultMode;
+        }
+
+        protected internal virtual int MatchATN(ICharStream input)
+        {
+            ATNState startState = atn.modeToStartState[mode];
+            ATNConfigSet s0_closure = ComputeStartState(input, startState);
+            bool suppressEdge = s0_closure.HasSemanticContext;
+            if (suppressEdge)
+            {
+                s0_closure.ClearExplicitSemanticContext();
+            }
+            DFAState next = AddDFAState(s0_closure);
+            if (!suppressEdge)
+            {
+                if (!atn.modeToDFA[mode].s0.CompareAndSet(null, next))
+                {
+                    next = atn.modeToDFA[mode].s0.Get();
+                }
+            }
+            int predict = ExecATN(input, next);
+            return predict;
+        }
+
+        protected internal virtual int ExecATN(ICharStream input, DFAState ds0)
+        {
+            //System.out.println("enter exec index "+input.index()+" from "+ds0.configs);
+            if (ds0.IsAcceptState)
+            {
+                // allow zero-length tokens
+                CaptureSimState(prevAccept, input, ds0);
+            }
+            int t = input.La(1);
+            DFAState s = ds0;
+            // s is current/from DFA state
+            while (true)
+            {
+                // while more work
+                // As we move src->trg, src->trg, we keep track of the previous trg to
+                // avoid looking up the DFA state again, which is expensive.
+                // If the previous target was already part of the DFA, we might
+                // be able to avoid doing a reach operation upon t. If s!=null,
+                // it means that semantic predicates didn't prevent us from
+                // creating a DFA state. Once we know s!=null, we check to see if
+                // the DFA state has an edge already for t. If so, we can just reuse
+                // it's configuration set; there's no point in re-computing it.
+                // This is kind of like doing DFA simulation within the ATN
+                // simulation because DFA simulation is really just a way to avoid
+                // computing reach/closure sets. Technically, once we know that
+                // we have a previously added DFA state, we could jump over to
+                // the DFA simulator. But, that would mean popping back and forth
+                // a lot and making things more complicated algorithmically.
+                // This optimization makes a lot of sense for loops within DFA.
+                // A character will take us back to an existing DFA state
+                // that already has lots of edges out of it. e.g., .* in comments.
+                DFAState target = GetExistingTargetState(s, t);
+                if (target == null)
+                {
+                    target = ComputeTargetState(input, s, t);
+                }
+                if (target == Error)
+                {
+                    break;
+                }
+				// If this is a consumable input element, make sure to consume before
+				// capturing the accept state so the input index, line, and char
+				// position accurately reflect the state of the interpreter at the
+				// end of the token.
+				if (t != IntStreamConstants.Eof) {
+					Consume(input);
+				}
+
+				if (target.IsAcceptState)
+                {
+                    CaptureSimState(prevAccept, input, target);
+                    if (t == IntStreamConstants.Eof)
+                    {
+                        break;
+                    }
+                }
+                t = input.La(1);
+                s = target;
+            }
+            // flip; current DFA target becomes new src/from state
+            return FailOrAccept(prevAccept, input, s.configs, t);
+        }
+
+        /// <summary>Get an existing target state for an edge in the DFA.</summary>
+        /// <remarks>
+        /// Get an existing target state for an edge in the DFA. If the target state
+        /// for the edge has not yet been computed or is otherwise not available,
+        /// this method returns
+        /// <see langword="null"/>
+        /// .
+        /// </remarks>
+        /// <param name="s">The current DFA state</param>
+        /// <param name="t">The next input symbol</param>
+        /// <returns>
+        /// The existing target DFA state for the given input symbol
+        /// <paramref name="t"/>
+        /// , or
+        /// <see langword="null"/>
+        /// if the target state for this edge is not
+        /// already cached
+        /// </returns>
+        [return: Nullable]
+        protected internal virtual DFAState GetExistingTargetState(DFAState s, int t)
+        {
+            DFAState target = s.GetTarget(t);
+#if !PORTABLE
+			#pragma warning disable 162, 429
+            if (debug && target != null)
+            {
+                System.Console.Out.WriteLine("reuse state " + s.stateNumber + " edge to " + target.stateNumber);
+            }
+			#pragma warning restore 162, 429
+#endif
+            return target;
+        }
+
+        /// <summary>
+        /// Compute a target state for an edge in the DFA, and attempt to add the
+        /// computed state and corresponding edge to the DFA.
+        /// </summary>
+        /// <remarks>
+        /// Compute a target state for an edge in the DFA, and attempt to add the
+        /// computed state and corresponding edge to the DFA.
+        /// </remarks>
+        /// <param name="input">The input stream</param>
+        /// <param name="s">The current DFA state</param>
+        /// <param name="t">The next input symbol</param>
+        /// <returns>
+        /// The computed target DFA state for the given input symbol
+        /// <paramref name="t"/>
+        /// . If
+        /// <paramref name="t"/>
+        /// does not lead to a valid DFA state, this method
+        /// returns
+        /// <see cref="ATNSimulator.Error"/>
+        /// .
+        /// </returns>
+        [return: NotNull]
+        protected internal virtual DFAState ComputeTargetState(ICharStream input, DFAState s, int t)
+        {
+            ATNConfigSet reach = new OrderedATNConfigSet();
+            // if we don't find an existing DFA state
+            // Fill reach starting from closure, following t transitions
+            GetReachableConfigSet(input, s.configs, reach, t);
+            if (reach.IsEmpty())
+            {
+                // we got nowhere on t from s
+                if (!reach.HasSemanticContext)
+                {
+                    // we got nowhere on t, don't throw out this knowledge; it'd
+                    // cause a failover from DFA later.
+                    AddDFAEdge(s, t, Error);
+                }
+                // stop when we can't match any more char
+                return Error;
+            }
+            // Add an edge from s to target DFA found/created for reach
+            return AddDFAEdge(s, t, reach);
+        }
+
+        protected internal virtual int FailOrAccept(LexerATNSimulator.SimState prevAccept, ICharStream input, ATNConfigSet reach, int t)
+        {
+            if (prevAccept.dfaState != null)
+            {
+                LexerActionExecutor lexerActionExecutor = prevAccept.dfaState.LexerActionExecutor;
+                Accept(input, lexerActionExecutor, startIndex, prevAccept.index, prevAccept.line, prevAccept.charPos);
+                return prevAccept.dfaState.Prediction;
+            }
+            else
+            {
+                // if no accept and EOF is first char, return EOF
+                if (t == IntStreamConstants.Eof && input.Index == startIndex)
+                {
+                    return TokenConstants.Eof;
+                }
+                throw new LexerNoViableAltException(recog, input, startIndex, reach);
+            }
+        }
+
+        /// <summary>
+        /// Given a starting configuration set, figure out all ATN configurations
+        /// we can reach upon input
+        /// <paramref name="t"/>
+        /// . Parameter
+        /// <paramref name="reach"/>
+        /// is a return
+        /// parameter.
+        /// </summary>
+        protected internal virtual void GetReachableConfigSet(ICharStream input, ATNConfigSet closure, ATNConfigSet reach, int t)
+        {
+            // this is used to skip processing for configs which have a lower priority
+            // than a config that already reached an accept state for the same rule
+            int skipAlt = ATN.InvalidAltNumber;
+            foreach (ATNConfig c in closure)
+            {
+                bool currentAltReachedAcceptState = c.Alt == skipAlt;
+                if (currentAltReachedAcceptState && c.PassedThroughNonGreedyDecision)
+                {
+                    continue;
+                }
+                int n = c.State.NumberOfOptimizedTransitions;
+                for (int ti = 0; ti < n; ti++)
+                {
+                    // for each optimized transition
+                    Transition trans = c.State.GetOptimizedTransition(ti);
+                    ATNState target = GetReachableTarget(trans, t);
+                    if (target != null)
+                    {
+                        LexerActionExecutor lexerActionExecutor = c.ActionExecutor;
+                        if (lexerActionExecutor != null)
+                        {
+                            lexerActionExecutor = lexerActionExecutor.FixOffsetBeforeMatch(input.Index - startIndex);
+                        }
+                        bool treatEofAsEpsilon = t == IntStreamConstants.Eof;
+                        if (Closure(input, c.Transform(target, lexerActionExecutor, true), reach, currentAltReachedAcceptState, true, treatEofAsEpsilon))
+                        {
+                            // any remaining configs for this alt have a lower priority than
+                            // the one that just reached an accept state.
+                            skipAlt = c.Alt;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+
+        protected internal virtual void Accept(ICharStream input, LexerActionExecutor lexerActionExecutor, int startIndex, int index, int line, int charPos)
+        {
+            // seek to after last char in token
+            input.Seek(index);
+            this._line = line;
+            this.charPositionInLine = charPos;
+            if (lexerActionExecutor != null && recog != null)
+            {
+                lexerActionExecutor.Execute(recog, input, startIndex);
+            }
+        }
+
+        [return: Nullable]
+        protected internal virtual ATNState GetReachableTarget(Transition trans, int t)
+        {
+            if (trans.Matches(t, char.MinValue, char.MaxValue))
+            {
+                return trans.target;
+            }
+            return null;
+        }
+
+        [return: NotNull]
+        protected internal virtual ATNConfigSet ComputeStartState(ICharStream input, ATNState p)
+        {
+            PredictionContext initialContext = PredictionContext.EmptyFull;
+            ATNConfigSet configs = new OrderedATNConfigSet();
+            for (int i = 0; i < p.NumberOfTransitions; i++)
+            {
+                ATNState target = p.Transition(i).target;
+                ATNConfig c = ATNConfig.Create(target, i + 1, initialContext);
+                Closure(input, c, configs, false, false, false);
+            }
+            return configs;
+        }
+
+        /// <summary>
+        /// Since the alternatives within any lexer decision are ordered by
+        /// preference, this method stops pursuing the closure as soon as an accept
+        /// state is reached.
+        /// </summary>
+        /// <remarks>
+        /// Since the alternatives within any lexer decision are ordered by
+        /// preference, this method stops pursuing the closure as soon as an accept
+        /// state is reached. After the first accept state is reached by depth-first
+        /// search from
+        /// <paramref name="config"/>
+        /// , all other (potentially reachable) states for
+        /// this rule would have a lower priority.
+        /// </remarks>
+        /// <returns>
+        /// 
+        /// <see langword="true"/>
+        /// if an accept state is reached, otherwise
+        /// <see langword="false"/>
+        /// .
+        /// </returns>
+        protected internal virtual bool Closure(ICharStream input, ATNConfig config, ATNConfigSet configs, bool currentAltReachedAcceptState, bool speculative, bool treatEofAsEpsilon)
+        {
+            if (config.State is RuleStopState)
+            {
+                PredictionContext context = config.Context;
+                if (context.IsEmpty)
+                {
+                    configs.Add(config);
+                    return true;
+                }
+                else
+                {
+                    if (context.HasEmpty)
+                    {
+                        configs.Add(config.Transform(config.State, PredictionContext.EmptyFull, true));
+                        currentAltReachedAcceptState = true;
+                    }
+                }
+                for (int i = 0; i < context.Size; i++)
+                {
+                    int returnStateNumber = context.GetReturnState(i);
+                    if (returnStateNumber == PredictionContext.EmptyFullStateKey)
+                    {
+                        continue;
+                    }
+                    PredictionContext newContext = context.GetParent(i);
+                    // "pop" return state
+                    ATNState returnState = atn.states[returnStateNumber];
+                    ATNConfig c = config.Transform(returnState, newContext, false);
+                    currentAltReachedAcceptState = Closure(input, c, configs, currentAltReachedAcceptState, speculative, treatEofAsEpsilon);
+                }
+                return currentAltReachedAcceptState;
+            }
+            // optimization
+            if (!config.State.OnlyHasEpsilonTransitions)
+            {
+                if (!currentAltReachedAcceptState || !config.PassedThroughNonGreedyDecision)
+                {
+                    configs.Add(config);
+                }
+            }
+            ATNState p = config.State;
+            for (int i_1 = 0; i_1 < p.NumberOfOptimizedTransitions; i_1++)
+            {
+                Transition t = p.GetOptimizedTransition(i_1);
+                ATNConfig c = GetEpsilonTarget(input, config, t, configs, speculative, treatEofAsEpsilon);
+                if (c != null)
+                {
+                    currentAltReachedAcceptState = Closure(input, c, configs, currentAltReachedAcceptState, speculative, treatEofAsEpsilon);
+                }
+            }
+            return currentAltReachedAcceptState;
+        }
+
+        // side-effect: can alter configs.hasSemanticContext
+        [return: Nullable]
+        protected internal virtual ATNConfig GetEpsilonTarget(ICharStream input, ATNConfig config, Transition t, ATNConfigSet configs, bool speculative, bool treatEofAsEpsilon)
+        {
+            ATNConfig c;
+            switch (t.TransitionType)
+            {
+                case TransitionType.Rule:
+                {
+                    RuleTransition ruleTransition = (RuleTransition)t;
+                    if (optimize_tail_calls && ruleTransition.optimizedTailCall && !config.Context.HasEmpty)
+                    {
+                        c = config.Transform(t.target, true);
+                    }
+                    else
+                    {
+                        PredictionContext newContext = config.Context.GetChild(ruleTransition.followState.stateNumber);
+                        c = config.Transform(t.target, newContext, true);
+                    }
+                    break;
+                }
+
+                case TransitionType.Precedence:
+                {
+                    throw new NotSupportedException("Precedence predicates are not supported in lexers.");
+                }
+
+                case TransitionType.Predicate:
+                {
+                    PredicateTransition pt = (PredicateTransition)t;
+                    configs.MarkExplicitSemanticContext();
+                    if (EvaluatePredicate(input, pt.ruleIndex, pt.predIndex, speculative))
+                    {
+                        c = config.Transform(t.target, true);
+                    }
+                    else
+                    {
+                        c = null;
+                    }
+                    break;
+                }
+
+                case TransitionType.Action:
+                {
+                    if (config.Context.HasEmpty)
+                    {
+                        // execute actions anywhere in the start rule for a token.
+                        //
+                        // TODO: if the entry rule is invoked recursively, some
+                        // actions may be executed during the recursive call. The
+                        // problem can appear when hasEmpty() is true but
+                        // isEmpty() is false. In this case, the config needs to be
+                        // split into two contexts - one with just the empty path
+                        // and another with everything but the empty path.
+                        // Unfortunately, the current algorithm does not allow
+                        // getEpsilonTarget to return two configurations, so
+                        // additional modifications are needed before we can support
+                        // the split operation.
+                        LexerActionExecutor lexerActionExecutor = LexerActionExecutor.Append(config.ActionExecutor, atn.lexerActions[((ActionTransition)t).actionIndex]);
+                        c = config.Transform(t.target, lexerActionExecutor, true);
+                        break;
+                    }
+                    else
+                    {
+                        // ignore actions in referenced rules
+                        c = config.Transform(t.target, true);
+                        break;
+                    }
+                }
+
+                case TransitionType.Epsilon:
+                {
+                    c = config.Transform(t.target, true);
+                    break;
+                }
+
+                case TransitionType.Atom:
+                case TransitionType.Range:
+                case TransitionType.Set:
+                {
+                    if (treatEofAsEpsilon)
+                    {
+                        if (t.Matches(IntStreamConstants.Eof, char.MinValue, char.MaxValue))
+                        {
+                            c = config.Transform(t.target, false);
+                            break;
+                        }
+                    }
+                    c = null;
+                    break;
+                }
+
+                default:
+                {
+                    c = null;
+                    break;
+                }
+            }
+            return c;
+        }
+
+        /// <summary>Evaluate a predicate specified in the lexer.</summary>
+        /// <remarks>
+        /// Evaluate a predicate specified in the lexer.
+        /// <p>If
+        /// <paramref name="speculative"/>
+        /// is
+        /// <see langword="true"/>
+        /// , this method was called before
+        /// <see cref="Consume(Antlr4.Runtime.ICharStream)"/>
+        /// for the matched character. This method should call
+        /// <see cref="Consume(Antlr4.Runtime.ICharStream)"/>
+        /// before evaluating the predicate to ensure position
+        /// sensitive values, including
+        /// <see cref="Antlr4.Runtime.Lexer.Text()"/>
+        /// ,
+        /// <see cref="Antlr4.Runtime.Lexer.Line()"/>
+        /// ,
+        /// and
+        /// <see cref="Antlr4.Runtime.Lexer.Column()"/>
+        /// , properly reflect the current
+        /// lexer state. This method should restore
+        /// <paramref name="input"/>
+        /// and the simulator
+        /// to the original state before returning (i.e. undo the actions made by the
+        /// call to
+        /// <see cref="Consume(Antlr4.Runtime.ICharStream)"/>
+        /// .</p>
+        /// </remarks>
+        /// <param name="input">The input stream.</param>
+        /// <param name="ruleIndex">The rule containing the predicate.</param>
+        /// <param name="predIndex">The index of the predicate within the rule.</param>
+        /// <param name="speculative">
+        /// 
+        /// <see langword="true"/>
+        /// if the current index in
+        /// <paramref name="input"/>
+        /// is
+        /// one character before the predicate's location.
+        /// </param>
+        /// <returns>
+        /// 
+        /// <see langword="true"/>
+        /// if the specified predicate evaluates to
+        /// <see langword="true"/>
+        /// .
+        /// </returns>
+        protected internal virtual bool EvaluatePredicate(ICharStream input, int ruleIndex, int predIndex, bool speculative)
+        {
+            // assume true if no recognizer was provided
+            if (recog == null)
+            {
+                return true;
+            }
+            if (!speculative)
+            {
+                return recog.Sempred(null, ruleIndex, predIndex);
+            }
+            int savedCharPositionInLine = charPositionInLine;
+            int savedLine = _line;
+            int index = input.Index;
+            int marker = input.Mark();
+            try
+            {
+                Consume(input);
+                return recog.Sempred(null, ruleIndex, predIndex);
+            }
+            finally
+            {
+                charPositionInLine = savedCharPositionInLine;
+                _line = savedLine;
+                input.Seek(index);
+                input.Release(marker);
+            }
+        }
+
+        protected internal virtual void CaptureSimState(LexerATNSimulator.SimState settings, ICharStream input, DFAState dfaState)
+        {
+            settings.index = input.Index;
+            settings.line = _line;
+            settings.charPos = charPositionInLine;
+            settings.dfaState = dfaState;
+        }
+
+        [return: NotNull]
+        protected internal virtual DFAState AddDFAEdge(DFAState from, int t, ATNConfigSet q)
+        {
+            bool suppressEdge = q.HasSemanticContext;
+            if (suppressEdge)
+            {
+                q.ClearExplicitSemanticContext();
+            }
+            DFAState to = AddDFAState(q);
+            if (suppressEdge)
+            {
+                return to;
+            }
+            AddDFAEdge(from, t, to);
+            return to;
+        }
+
+        protected internal virtual void AddDFAEdge(DFAState p, int t, DFAState q)
+        {
+            if (p != null)
+            {
+                p.SetTarget(t, q);
+            }
+        }
+
+        /// <summary>
+        /// Add a new DFA state if there isn't one with this set of
+        /// configurations already.
+        /// </summary>
+        /// <remarks>
+        /// Add a new DFA state if there isn't one with this set of
+        /// configurations already. This method also detects the first
+        /// configuration containing an ATN rule stop state. Later, when
+        /// traversing the DFA, we will know which rule to accept.
+        /// </remarks>
+        [return: NotNull]
+        protected internal virtual DFAState AddDFAState(ATNConfigSet configs)
+        {
+            System.Diagnostics.Debug.Assert(!configs.HasSemanticContext);
+            DFAState proposed = new DFAState(atn.modeToDFA[mode], configs);
+            DFAState existing;
+            if (atn.modeToDFA[mode].states.TryGetValue(proposed, out existing))
+            {
+                return existing;
+            }
+            configs.OptimizeConfigs(this);
+            DFAState newState = new DFAState(atn.modeToDFA[mode], configs.Clone(true));
+            ATNConfig firstConfigWithRuleStopState = null;
+            foreach (ATNConfig c in configs)
+            {
+                if (c.State is RuleStopState)
+                {
+                    firstConfigWithRuleStopState = c;
+                    break;
+                }
+            }
+            if (firstConfigWithRuleStopState != null)
+            {
+                int prediction = atn.ruleToTokenType[firstConfigWithRuleStopState.State.ruleIndex];
+                LexerActionExecutor lexerActionExecutor = firstConfigWithRuleStopState.ActionExecutor;
+                newState.AcceptStateInfo = new AcceptStateInfo(prediction, lexerActionExecutor);
+            }
+            return atn.modeToDFA[mode].AddState(newState);
+        }
+
+        [return: NotNull]
+        public DFA GetDFA(int mode)
+        {
+            return atn.modeToDFA[mode];
+        }
+
+        /// <summary>Get the text matched so far for the current token.</summary>
+        /// <remarks>Get the text matched so far for the current token.</remarks>
+        [return: NotNull]
+        public virtual string GetText(ICharStream input)
+        {
+            // index is first lookahead char, don't include.
+            return input.GetText(Interval.Of(startIndex, input.Index - 1));
+        }
+
+        public virtual int Line
+        {
+            get
+            {
+                return _line;
+            }
+            set
+            {
+                this._line = value;
+            }
+        }
+
+        public virtual int Column
+        {
+            get
+            {
+                return charPositionInLine;
+            }
+            set
+            {
+                int charPositionInLine = value;
+                this.charPositionInLine = charPositionInLine;
+            }
+        }
+
+        public virtual void Consume(ICharStream input)
+        {
+            int curChar = input.La(1);
+            if (curChar == '\n')
+            {
+                _line++;
+                charPositionInLine = 0;
+            }
+            else
+            {
+                charPositionInLine++;
+            }
+            input.Consume();
+        }
+
+        [return: NotNull]
+        public virtual string GetTokenName(int t)
+        {
+            if (t == -1)
+            {
+                return "EOF";
+            }
+            //if ( atn.g!=null ) return atn.g.getTokenDisplayName(t);
+            return "'" + (char)t + "'";
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/LexerActionExecutor.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/LexerActionExecutor.cs
new file mode 100644
index 000000000..b413607d3
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/LexerActionExecutor.cs
@@ -0,0 +1,297 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    /// <summary>
+    /// Represents an executor for a sequence of lexer actions which traversed during
+    /// the matching operation of a lexer rule (token).
+    /// </summary>
+    /// <remarks>
+    /// Represents an executor for a sequence of lexer actions which traversed during
+    /// the matching operation of a lexer rule (token).
+    /// <p>The executor tracks position information for position-dependent lexer actions
+    /// efficiently, ensuring that actions appearing only at the end of the rule do
+    /// not cause bloating of the
+    /// <see cref="Antlr4.Runtime.Dfa.DFA"/>
+    /// created for the lexer.</p>
+    /// </remarks>
+    /// <author>Sam Harwell</author>
+    /// <since>4.2</since>
+    public class LexerActionExecutor
+    {
+        [NotNull]
+        private readonly ILexerAction[] lexerActions;
+
+        /// <summary>
+        /// Caches the result of
+        /// <see cref="hashCode"/>
+        /// since the hash code is an element
+        /// of the performance-critical
+        /// <see cref="ATNConfig.GetHashCode()"/>
+        /// operation.
+        /// </summary>
+        private readonly int hashCode;
+
+        /// <summary>
+        /// Constructs an executor for a sequence of
+        /// <see cref="ILexerAction"/>
+        /// actions.
+        /// </summary>
+        /// <param name="lexerActions">The lexer actions to execute.</param>
+        public LexerActionExecutor(ILexerAction[] lexerActions)
+        {
+            this.lexerActions = lexerActions;
+            int hash = MurmurHash.Initialize();
+            foreach (ILexerAction lexerAction in lexerActions)
+            {
+                hash = MurmurHash.Update(hash, lexerAction);
+            }
+            this.hashCode = MurmurHash.Finish(hash, lexerActions.Length);
+        }
+
+        /// <summary>
+        /// Creates a
+        /// <see cref="LexerActionExecutor"/>
+        /// which executes the actions for
+        /// the input
+        /// <paramref name="lexerActionExecutor"/>
+        /// followed by a specified
+        /// <paramref name="lexerAction"/>
+        /// .
+        /// </summary>
+        /// <param name="lexerActionExecutor">
+        /// The executor for actions already traversed by
+        /// the lexer while matching a token within a particular
+        /// <see cref="ATNConfig"/>
+        /// . If this is
+        /// <see langword="null"/>
+        /// , the method behaves as though
+        /// it were an empty executor.
+        /// </param>
+        /// <param name="lexerAction">
+        /// The lexer action to execute after the actions
+        /// specified in
+        /// <paramref name="lexerActionExecutor"/>
+        /// .
+        /// </param>
+        /// <returns>
+        /// A
+        /// <see cref="LexerActionExecutor"/>
+        /// for executing the combine actions
+        /// of
+        /// <paramref name="lexerActionExecutor"/>
+        /// and
+        /// <paramref name="lexerAction"/>
+        /// .
+        /// </returns>
+        [return: NotNull]
+        public static Antlr4.Runtime.Atn.LexerActionExecutor Append(Antlr4.Runtime.Atn.LexerActionExecutor lexerActionExecutor, ILexerAction lexerAction)
+        {
+            if (lexerActionExecutor == null)
+            {
+                return new Antlr4.Runtime.Atn.LexerActionExecutor(new ILexerAction[] { lexerAction });
+            }
+            ILexerAction[] lexerActions = Arrays.CopyOf(lexerActionExecutor.lexerActions, lexerActionExecutor.lexerActions.Length + 1);
+            lexerActions[lexerActions.Length - 1] = lexerAction;
+            return new Antlr4.Runtime.Atn.LexerActionExecutor(lexerActions);
+        }
+
+        /// <summary>
+        /// Creates a
+        /// <see cref="LexerActionExecutor"/>
+        /// which encodes the current offset
+        /// for position-dependent lexer actions.
+        /// <p>Normally, when the executor encounters lexer actions where
+        /// <see cref="ILexerAction.IsPositionDependent()"/>
+        /// returns
+        /// <see langword="true"/>
+        /// , it calls
+        /// <see cref="Antlr4.Runtime.IIntStream.Seek(int)"/>
+        /// on the input
+        /// <see cref="Antlr4.Runtime.ICharStream"/>
+        /// to set the input
+        /// position to the <em>end</em> of the current token. This behavior provides
+        /// for efficient DFA representation of lexer actions which appear at the end
+        /// of a lexer rule, even when the lexer rule matches a variable number of
+        /// characters.</p>
+        /// <p>Prior to traversing a match transition in the ATN, the current offset
+        /// from the token start index is assigned to all position-dependent lexer
+        /// actions which have not already been assigned a fixed offset. By storing
+        /// the offsets relative to the token start index, the DFA representation of
+        /// lexer actions which appear in the middle of tokens remains efficient due
+        /// to sharing among tokens of the same length, regardless of their absolute
+        /// position in the input stream.</p>
+        /// <p>If the current executor already has offsets assigned to all
+        /// position-dependent lexer actions, the method returns
+        /// <c>this</c>
+        /// .</p>
+        /// </summary>
+        /// <param name="offset">
+        /// The current offset to assign to all position-dependent
+        /// lexer actions which do not already have offsets assigned.
+        /// </param>
+        /// <returns>
+        /// A
+        /// <see cref="LexerActionExecutor"/>
+        /// which stores input stream offsets
+        /// for all position-dependent lexer actions.
+        /// </returns>
+        public virtual Antlr4.Runtime.Atn.LexerActionExecutor FixOffsetBeforeMatch(int offset)
+        {
+            ILexerAction[] updatedLexerActions = null;
+            for (int i = 0; i < lexerActions.Length; i++)
+            {
+                if (lexerActions[i].IsPositionDependent && !(lexerActions[i] is LexerIndexedCustomAction))
+                {
+                    if (updatedLexerActions == null)
+                    {
+                        updatedLexerActions = (ILexerAction[])lexerActions.Clone();
+                    }
+                    updatedLexerActions[i] = new LexerIndexedCustomAction(offset, lexerActions[i]);
+                }
+            }
+            if (updatedLexerActions == null)
+            {
+                return this;
+            }
+            return new Antlr4.Runtime.Atn.LexerActionExecutor(updatedLexerActions);
+        }
+
+        /// <summary>Gets the lexer actions to be executed by this executor.</summary>
+        /// <remarks>Gets the lexer actions to be executed by this executor.</remarks>
+        /// <returns>The lexer actions to be executed by this executor.</returns>
+        [NotNull]
+        public virtual ILexerAction[] LexerActions
+        {
+            get
+            {
+                return lexerActions;
+            }
+        }
+
+        /// <summary>
+        /// Execute the actions encapsulated by this executor within the context of a
+        /// particular
+        /// <see cref="Antlr4.Runtime.Lexer"/>
+        /// .
+        /// <p>This method calls
+        /// <see cref="Antlr4.Runtime.IIntStream.Seek(int)"/>
+        /// to set the position of the
+        /// <paramref name="input"/>
+        /// 
+        /// <see cref="Antlr4.Runtime.ICharStream"/>
+        /// prior to calling
+        /// <see cref="ILexerAction.Execute(Antlr4.Runtime.Lexer)"/>
+        /// on a position-dependent action. Before the
+        /// method returns, the input position will be restored to the same position
+        /// it was in when the method was invoked.</p>
+        /// </summary>
+        /// <param name="lexer">The lexer instance.</param>
+        /// <param name="input">
+        /// The input stream which is the source for the current token.
+        /// When this method is called, the current
+        /// <see cref="Antlr4.Runtime.IIntStream.Index()"/>
+        /// for
+        /// <paramref name="input"/>
+        /// should be the start of the following token, i.e. 1
+        /// character past the end of the current token.
+        /// </param>
+        /// <param name="startIndex">
+        /// The token start index. This value may be passed to
+        /// <see cref="Antlr4.Runtime.IIntStream.Seek(int)"/>
+        /// to set the
+        /// <paramref name="input"/>
+        /// position to the beginning
+        /// of the token.
+        /// </param>
+        public virtual void Execute(Lexer lexer, ICharStream input, int startIndex)
+        {
+            bool requiresSeek = false;
+            int stopIndex = input.Index;
+            try
+            {
+                foreach (ILexerAction lexerAction in lexerActions)
+                {
+                    ILexerAction action = lexerAction;
+                    if (action is LexerIndexedCustomAction)
+                    {
+                        int offset = ((LexerIndexedCustomAction)action).Offset;
+                        input.Seek(startIndex + offset);
+                        action = ((LexerIndexedCustomAction)action).Action;
+                        requiresSeek = (startIndex + offset) != stopIndex;
+                    }
+                    else
+                    {
+                        if (action.IsPositionDependent)
+                        {
+                            input.Seek(stopIndex);
+                            requiresSeek = false;
+                        }
+                    }
+                    action.Execute(lexer);
+                }
+            }
+            finally
+            {
+                if (requiresSeek)
+                {
+                    input.Seek(stopIndex);
+                }
+            }
+        }
+
+        public override int GetHashCode()
+        {
+            return this.hashCode;
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (obj == this)
+            {
+                return true;
+            }
+            else
+            {
+                if (!(obj is Antlr4.Runtime.Atn.LexerActionExecutor))
+                {
+                    return false;
+                }
+            }
+            Antlr4.Runtime.Atn.LexerActionExecutor other = (Antlr4.Runtime.Atn.LexerActionExecutor)obj;
+            return hashCode == other.hashCode && Arrays.Equals(lexerActions, other.lexerActions);
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/LexerActionType.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/LexerActionType.cs
new file mode 100644
index 000000000..8326dd915
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/LexerActionType.cs
@@ -0,0 +1,48 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    /// <author>Sam Harwell</author>
+    /// <since>4.2</since>
+    public enum LexerActionType
+    {
+        Channel,
+        Custom,
+        Mode,
+        More,
+        PopMode,
+        PushMode,
+        Skip,
+        Type
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/LexerChannelAction.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/LexerChannelAction.cs
new file mode 100644
index 000000000..5b72651b9
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/LexerChannelAction.cs
@@ -0,0 +1,154 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    /// <summary>
+    /// Implements the
+    /// <c>channel</c>
+    /// lexer action by calling
+    /// <see cref="Lexer.Channel"/>
+    /// with the assigned channel.
+    /// </summary>
+    /// <author>Sam Harwell</author>
+    /// <since>4.2</since>
+    public sealed class LexerChannelAction : ILexerAction
+    {
+        private readonly int channel;
+
+        /// <summary>
+        /// Constructs a new
+        /// <paramref name="channel"/>
+        /// action with the specified channel value.
+        /// </summary>
+        /// <param name="channel">
+        /// The channel value to pass to
+        /// <see cref="Lexer.Channel"/>
+        /// .
+        /// </param>
+        public LexerChannelAction(int channel)
+        {
+            this.channel = channel;
+        }
+
+        /// <summary>
+        /// Gets the channel to use for the
+        /// <see cref="Antlr4.Runtime.IToken"/>
+        /// created by the lexer.
+        /// </summary>
+        /// <returns>
+        /// The channel to use for the
+        /// <see cref="Antlr4.Runtime.IToken"/>
+        /// created by the lexer.
+        /// </returns>
+        public int Channel
+        {
+            get
+            {
+                return channel;
+            }
+        }
+
+        /// <summary><inheritDoc/></summary>
+        /// <returns>
+        /// This method returns
+        /// <see cref="LexerActionType.Channel"/>
+        /// .
+        /// </returns>
+        public LexerActionType ActionType
+        {
+            get
+            {
+                return LexerActionType.Channel;
+            }
+        }
+
+        /// <summary><inheritDoc/></summary>
+        /// <returns>
+        /// This method returns
+        /// <see langword="false"/>
+        /// .
+        /// </returns>
+        public bool IsPositionDependent
+        {
+            get
+            {
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// <inheritDoc/>
+        /// <p>This action is implemented by calling
+        /// <see cref="Lexer.Channel"/>
+        /// with the
+        /// value provided by
+        /// <see cref="Channel()"/>
+        /// .</p>
+        /// </summary>
+        public void Execute(Lexer lexer)
+        {
+            lexer.Channel = channel;
+        }
+
+        public override int GetHashCode()
+        {
+            int hash = MurmurHash.Initialize();
+            hash = MurmurHash.Update(hash, (int)(ActionType));
+            hash = MurmurHash.Update(hash, channel);
+            return MurmurHash.Finish(hash, 2);
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (obj == this)
+            {
+                return true;
+            }
+            else
+            {
+                if (!(obj is Antlr4.Runtime.Atn.LexerChannelAction))
+                {
+                    return false;
+                }
+            }
+            return channel == ((Antlr4.Runtime.Atn.LexerChannelAction)obj).channel;
+        }
+
+        public override string ToString()
+        {
+            return string.Format("channel({0})", channel);
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/LexerCustomAction.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/LexerCustomAction.cs
new file mode 100644
index 000000000..fdacf2e23
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/LexerCustomAction.cs
@@ -0,0 +1,186 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    /// <summary>
+    /// Executes a custom lexer action by calling
+    /// <see cref="Antlr4.Runtime.Recognizer{Symbol, ATNInterpreter}.Action(Antlr4.Runtime.RuleContext, int, int)"/>
+    /// with the
+    /// rule and action indexes assigned to the custom action. The implementation of
+    /// a custom action is added to the generated code for the lexer in an override
+    /// of
+    /// <see cref="Antlr4.Runtime.Recognizer{Symbol, ATNInterpreter}.Action(Antlr4.Runtime.RuleContext, int, int)"/>
+    /// when the grammar is compiled.
+    /// <p>This class may represent embedded actions created with the <code>{...}</code>
+    /// syntax in ANTLR 4, as well as actions created for lexer commands where the
+    /// command argument could not be evaluated when the grammar was compiled.</p>
+    /// </summary>
+    /// <author>Sam Harwell</author>
+    /// <since>4.2</since>
+    public sealed class LexerCustomAction : ILexerAction
+    {
+        private readonly int ruleIndex;
+
+        private readonly int actionIndex;
+
+        /// <summary>
+        /// Constructs a custom lexer action with the specified rule and action
+        /// indexes.
+        /// </summary>
+        /// <remarks>
+        /// Constructs a custom lexer action with the specified rule and action
+        /// indexes.
+        /// </remarks>
+        /// <param name="ruleIndex">
+        /// The rule index to use for calls to
+        /// <see cref="Antlr4.Runtime.Recognizer{Symbol, ATNInterpreter}.Action(Antlr4.Runtime.RuleContext, int, int)"/>
+        /// .
+        /// </param>
+        /// <param name="actionIndex">
+        /// The action index to use for calls to
+        /// <see cref="Antlr4.Runtime.Recognizer{Symbol, ATNInterpreter}.Action(Antlr4.Runtime.RuleContext, int, int)"/>
+        /// .
+        /// </param>
+        public LexerCustomAction(int ruleIndex, int actionIndex)
+        {
+            this.ruleIndex = ruleIndex;
+            this.actionIndex = actionIndex;
+        }
+
+        /// <summary>
+        /// Gets the rule index to use for calls to
+        /// <see cref="Antlr4.Runtime.Recognizer{Symbol, ATNInterpreter}.Action(Antlr4.Runtime.RuleContext, int, int)"/>
+        /// .
+        /// </summary>
+        /// <returns>The rule index for the custom action.</returns>
+        public int RuleIndex
+        {
+            get
+            {
+                return ruleIndex;
+            }
+        }
+
+        /// <summary>
+        /// Gets the action index to use for calls to
+        /// <see cref="Antlr4.Runtime.Recognizer{Symbol, ATNInterpreter}.Action(Antlr4.Runtime.RuleContext, int, int)"/>
+        /// .
+        /// </summary>
+        /// <returns>The action index for the custom action.</returns>
+        public int ActionIndex
+        {
+            get
+            {
+                return actionIndex;
+            }
+        }
+
+        /// <summary><inheritDoc/></summary>
+        /// <returns>
+        /// This method returns
+        /// <see cref="LexerActionType.Custom"/>
+        /// .
+        /// </returns>
+        public LexerActionType ActionType
+        {
+            get
+            {
+                return LexerActionType.Custom;
+            }
+        }
+
+        /// <summary>Gets whether the lexer action is position-dependent.</summary>
+        /// <remarks>
+        /// Gets whether the lexer action is position-dependent. Position-dependent
+        /// actions may have different semantics depending on the
+        /// <see cref="Antlr4.Runtime.ICharStream"/>
+        /// index at the time the action is executed.
+        /// <p>Custom actions are position-dependent since they may represent a
+        /// user-defined embedded action which makes calls to methods like
+        /// <see cref="Antlr4.Runtime.Lexer.Text()"/>
+        /// .</p>
+        /// </remarks>
+        /// <returns>
+        /// This method returns
+        /// <see langword="true"/>
+        /// .
+        /// </returns>
+        public bool IsPositionDependent
+        {
+            get
+            {
+                return true;
+            }
+        }
+
+        /// <summary>
+        /// <inheritDoc/>
+        /// <p>Custom actions are implemented by calling
+        /// <see cref="Antlr4.Runtime.Recognizer{Symbol, ATNInterpreter}.Action(Antlr4.Runtime.RuleContext, int, int)"/>
+        /// with the
+        /// appropriate rule and action indexes.</p>
+        /// </summary>
+        public void Execute(Lexer lexer)
+        {
+            lexer.Action(null, ruleIndex, actionIndex);
+        }
+
+        public override int GetHashCode()
+        {
+            int hash = MurmurHash.Initialize();
+            hash = MurmurHash.Update(hash, (int)(ActionType));
+            hash = MurmurHash.Update(hash, ruleIndex);
+            hash = MurmurHash.Update(hash, actionIndex);
+            return MurmurHash.Finish(hash, 3);
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (obj == this)
+            {
+                return true;
+            }
+            else
+            {
+                if (!(obj is Antlr4.Runtime.Atn.LexerCustomAction))
+                {
+                    return false;
+                }
+            }
+            Antlr4.Runtime.Atn.LexerCustomAction other = (Antlr4.Runtime.Atn.LexerCustomAction)obj;
+            return ruleIndex == other.ruleIndex && actionIndex == other.actionIndex;
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/LexerIndexedCustomAction.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/LexerIndexedCustomAction.cs
new file mode 100644
index 000000000..f19da4d68
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/LexerIndexedCustomAction.cs
@@ -0,0 +1,201 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    /// <summary>
+    /// This implementation of
+    /// <see cref="ILexerAction"/>
+    /// is used for tracking input offsets
+    /// for position-dependent actions within a
+    /// <see cref="LexerActionExecutor"/>
+    /// .
+    /// <p>This action is not serialized as part of the ATN, and is only required for
+    /// position-dependent lexer actions which appear at a location other than the
+    /// end of a rule. For more information about DFA optimizations employed for
+    /// lexer actions, see
+    /// <see cref="LexerActionExecutor.Append(LexerActionExecutor, ILexerAction)"/>
+    /// and
+    /// <see cref="LexerActionExecutor.FixOffsetBeforeMatch(int)"/>
+    /// .</p>
+    /// </summary>
+    /// <author>Sam Harwell</author>
+    /// <since>4.2</since>
+    public sealed class LexerIndexedCustomAction : ILexerAction
+    {
+        private readonly int offset;
+
+        private readonly ILexerAction action;
+
+        /// <summary>
+        /// Constructs a new indexed custom action by associating a character offset
+        /// with a
+        /// <see cref="ILexerAction"/>
+        /// .
+        /// <p>Note: This class is only required for lexer actions for which
+        /// <see cref="ILexerAction.IsPositionDependent()"/>
+        /// returns
+        /// <see langword="true"/>
+        /// .</p>
+        /// </summary>
+        /// <param name="offset">
+        /// The offset into the input
+        /// <see cref="Antlr4.Runtime.ICharStream"/>
+        /// , relative to
+        /// the token start index, at which the specified lexer action should be
+        /// executed.
+        /// </param>
+        /// <param name="action">
+        /// The lexer action to execute at a particular offset in the
+        /// input
+        /// <see cref="Antlr4.Runtime.ICharStream"/>
+        /// .
+        /// </param>
+        public LexerIndexedCustomAction(int offset, ILexerAction action)
+        {
+            this.offset = offset;
+            this.action = action;
+        }
+
+        /// <summary>
+        /// Gets the location in the input
+        /// <see cref="Antlr4.Runtime.ICharStream"/>
+        /// at which the lexer
+        /// action should be executed. The value is interpreted as an offset relative
+        /// to the token start index.
+        /// </summary>
+        /// <returns>
+        /// The location in the input
+        /// <see cref="Antlr4.Runtime.ICharStream"/>
+        /// at which the lexer
+        /// action should be executed.
+        /// </returns>
+        public int Offset
+        {
+            get
+            {
+                return offset;
+            }
+        }
+
+        /// <summary>Gets the lexer action to execute.</summary>
+        /// <remarks>Gets the lexer action to execute.</remarks>
+        /// <returns>
+        /// A
+        /// <see cref="ILexerAction"/>
+        /// object which executes the lexer action.
+        /// </returns>
+        [NotNull]
+        public ILexerAction Action
+        {
+            get
+            {
+                return action;
+            }
+        }
+
+        /// <summary><inheritDoc/></summary>
+        /// <returns>
+        /// This method returns the result of calling
+        /// <see cref="ActionType()"/>
+        /// on the
+        /// <see cref="ILexerAction"/>
+        /// returned by
+        /// <see cref="Action()"/>
+        /// .
+        /// </returns>
+        public LexerActionType ActionType
+        {
+            get
+            {
+                return action.ActionType;
+            }
+        }
+
+        /// <summary><inheritDoc/></summary>
+        /// <returns>
+        /// This method returns
+        /// <see langword="true"/>
+        /// .
+        /// </returns>
+        public bool IsPositionDependent
+        {
+            get
+            {
+                return true;
+            }
+        }
+
+        /// <summary>
+        /// <inheritDoc/>
+        /// <p>This method calls
+        /// <see cref="Execute(Antlr4.Runtime.Lexer)"/>
+        /// on the result of
+        /// <see cref="Action()"/>
+        /// using the provided
+        /// <paramref name="lexer"/>
+        /// .</p>
+        /// </summary>
+        public void Execute(Lexer lexer)
+        {
+            // assume the input stream position was properly set by the calling code
+            action.Execute(lexer);
+        }
+
+        public override int GetHashCode()
+        {
+            int hash = MurmurHash.Initialize();
+            hash = MurmurHash.Update(hash, offset);
+            hash = MurmurHash.Update(hash, action);
+            return MurmurHash.Finish(hash, 2);
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (obj == this)
+            {
+                return true;
+            }
+            else
+            {
+                if (!(obj is Antlr4.Runtime.Atn.LexerIndexedCustomAction))
+                {
+                    return false;
+                }
+            }
+            Antlr4.Runtime.Atn.LexerIndexedCustomAction other = (Antlr4.Runtime.Atn.LexerIndexedCustomAction)obj;
+            return offset == other.offset && action.Equals(other.action);
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/LexerModeAction.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/LexerModeAction.cs
new file mode 100644
index 000000000..91d7ae3e1
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/LexerModeAction.cs
@@ -0,0 +1,152 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    /// <summary>
+    /// Implements the
+    /// <c>mode</c>
+    /// lexer action by calling
+    /// <see cref="Antlr4.Runtime.Lexer.Mode(int)"/>
+    /// with
+    /// the assigned mode.
+    /// </summary>
+    /// <author>Sam Harwell</author>
+    /// <since>4.2</since>
+    public sealed class LexerModeAction : ILexerAction
+    {
+        private readonly int mode;
+
+        /// <summary>
+        /// Constructs a new
+        /// <paramref name="mode"/>
+        /// action with the specified mode value.
+        /// </summary>
+        /// <param name="mode">
+        /// The mode value to pass to
+        /// <see cref="Antlr4.Runtime.Lexer.Mode(int)"/>
+        /// .
+        /// </param>
+        public LexerModeAction(int mode)
+        {
+            this.mode = mode;
+        }
+
+        /// <summary>Get the lexer mode this action should transition the lexer to.</summary>
+        /// <remarks>Get the lexer mode this action should transition the lexer to.</remarks>
+        /// <returns>
+        /// The lexer mode for this
+        /// <c>mode</c>
+        /// command.
+        /// </returns>
+        public int Mode
+        {
+            get
+            {
+                return mode;
+            }
+        }
+
+        /// <summary><inheritDoc/></summary>
+        /// <returns>
+        /// This method returns
+        /// <see cref="LexerActionType.Mode"/>
+        /// .
+        /// </returns>
+        public LexerActionType ActionType
+        {
+            get
+            {
+                return LexerActionType.Mode;
+            }
+        }
+
+        /// <summary><inheritDoc/></summary>
+        /// <returns>
+        /// This method returns
+        /// <see langword="false"/>
+        /// .
+        /// </returns>
+        public bool IsPositionDependent
+        {
+            get
+            {
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// <inheritDoc/>
+        /// <p>This action is implemented by calling
+        /// <see cref="Antlr4.Runtime.Lexer.Mode(int)"/>
+        /// with the
+        /// value provided by
+        /// <see cref="Mode()"/>
+        /// .</p>
+        /// </summary>
+        public void Execute(Lexer lexer)
+        {
+            lexer.Mode(mode);
+        }
+
+        public override int GetHashCode()
+        {
+            int hash = MurmurHash.Initialize();
+            hash = MurmurHash.Update(hash, (int)(ActionType));
+            hash = MurmurHash.Update(hash, mode);
+            return MurmurHash.Finish(hash, 2);
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (obj == this)
+            {
+                return true;
+            }
+            else
+            {
+                if (!(obj is Antlr4.Runtime.Atn.LexerModeAction))
+                {
+                    return false;
+                }
+            }
+            return mode == ((Antlr4.Runtime.Atn.LexerModeAction)obj).mode;
+        }
+
+        public override string ToString()
+        {
+            return string.Format("mode({0})", mode);
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/LexerMoreAction.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/LexerMoreAction.cs
new file mode 100644
index 000000000..e993f234a
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/LexerMoreAction.cs
@@ -0,0 +1,123 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    /// <summary>
+    /// Implements the
+    /// <c>more</c>
+    /// lexer action by calling
+    /// <see cref="Antlr4.Runtime.Lexer.More()"/>
+    /// .
+    /// <p>The
+    /// <c>more</c>
+    /// command does not have any parameters, so this action is
+    /// implemented as a singleton instance exposed by
+    /// <see cref="Instance"/>
+    /// .</p>
+    /// </summary>
+    /// <author>Sam Harwell</author>
+    /// <since>4.2</since>
+    public sealed class LexerMoreAction : ILexerAction
+    {
+        /// <summary>Provides a singleton instance of this parameterless lexer action.</summary>
+        /// <remarks>Provides a singleton instance of this parameterless lexer action.</remarks>
+        public static readonly Antlr4.Runtime.Atn.LexerMoreAction Instance = new Antlr4.Runtime.Atn.LexerMoreAction();
+
+        /// <summary>
+        /// Constructs the singleton instance of the lexer
+        /// <c>more</c>
+        /// command.
+        /// </summary>
+        private LexerMoreAction()
+        {
+        }
+
+        /// <summary><inheritDoc/></summary>
+        /// <returns>
+        /// This method returns
+        /// <see cref="LexerActionType.More"/>
+        /// .
+        /// </returns>
+        public LexerActionType ActionType
+        {
+            get
+            {
+                return LexerActionType.More;
+            }
+        }
+
+        /// <summary><inheritDoc/></summary>
+        /// <returns>
+        /// This method returns
+        /// <see langword="false"/>
+        /// .
+        /// </returns>
+        public bool IsPositionDependent
+        {
+            get
+            {
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// <inheritDoc/>
+        /// <p>This action is implemented by calling
+        /// <see cref="Antlr4.Runtime.Lexer.More()"/>
+        /// .</p>
+        /// </summary>
+        public void Execute(Lexer lexer)
+        {
+            lexer.More();
+        }
+
+        public override int GetHashCode()
+        {
+            int hash = MurmurHash.Initialize();
+            hash = MurmurHash.Update(hash, (int)(ActionType));
+            return MurmurHash.Finish(hash, 1);
+        }
+
+        public override bool Equals(object obj)
+        {
+            return obj == this;
+        }
+
+        public override string ToString()
+        {
+            return "more";
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/LexerPopModeAction.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/LexerPopModeAction.cs
new file mode 100644
index 000000000..585701e80
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/LexerPopModeAction.cs
@@ -0,0 +1,123 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    /// <summary>
+    /// Implements the
+    /// <c>popMode</c>
+    /// lexer action by calling
+    /// <see cref="Antlr4.Runtime.Lexer.PopMode()"/>
+    /// .
+    /// <p>The
+    /// <c>popMode</c>
+    /// command does not have any parameters, so this action is
+    /// implemented as a singleton instance exposed by
+    /// <see cref="Instance"/>
+    /// .</p>
+    /// </summary>
+    /// <author>Sam Harwell</author>
+    /// <since>4.2</since>
+    public sealed class LexerPopModeAction : ILexerAction
+    {
+        /// <summary>Provides a singleton instance of this parameterless lexer action.</summary>
+        /// <remarks>Provides a singleton instance of this parameterless lexer action.</remarks>
+        public static readonly Antlr4.Runtime.Atn.LexerPopModeAction Instance = new Antlr4.Runtime.Atn.LexerPopModeAction();
+
+        /// <summary>
+        /// Constructs the singleton instance of the lexer
+        /// <c>popMode</c>
+        /// command.
+        /// </summary>
+        private LexerPopModeAction()
+        {
+        }
+
+        /// <summary><inheritDoc/></summary>
+        /// <returns>
+        /// This method returns
+        /// <see cref="LexerActionType.PopMode"/>
+        /// .
+        /// </returns>
+        public LexerActionType ActionType
+        {
+            get
+            {
+                return LexerActionType.PopMode;
+            }
+        }
+
+        /// <summary><inheritDoc/></summary>
+        /// <returns>
+        /// This method returns
+        /// <see langword="false"/>
+        /// .
+        /// </returns>
+        public bool IsPositionDependent
+        {
+            get
+            {
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// <inheritDoc/>
+        /// <p>This action is implemented by calling
+        /// <see cref="Antlr4.Runtime.Lexer.PopMode()"/>
+        /// .</p>
+        /// </summary>
+        public void Execute(Lexer lexer)
+        {
+            lexer.PopMode();
+        }
+
+        public override int GetHashCode()
+        {
+            int hash = MurmurHash.Initialize();
+            hash = MurmurHash.Update(hash, (int)(ActionType));
+            return MurmurHash.Finish(hash, 1);
+        }
+
+        public override bool Equals(object obj)
+        {
+            return obj == this;
+        }
+
+        public override string ToString()
+        {
+            return "popMode";
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/LexerPushModeAction.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/LexerPushModeAction.cs
new file mode 100644
index 000000000..901ec06d8
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/LexerPushModeAction.cs
@@ -0,0 +1,151 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    /// <summary>
+    /// Implements the
+    /// <c>pushMode</c>
+    /// lexer action by calling
+    /// <see cref="Antlr4.Runtime.Lexer.PushMode(int)"/>
+    /// with the assigned mode.
+    /// </summary>
+    /// <author>Sam Harwell</author>
+    /// <since>4.2</since>
+    public sealed class LexerPushModeAction : ILexerAction
+    {
+        private readonly int mode;
+
+        /// <summary>
+        /// Constructs a new
+        /// <c>pushMode</c>
+        /// action with the specified mode value.
+        /// </summary>
+        /// <param name="mode">
+        /// The mode value to pass to
+        /// <see cref="Antlr4.Runtime.Lexer.PushMode(int)"/>
+        /// .
+        /// </param>
+        public LexerPushModeAction(int mode)
+        {
+            this.mode = mode;
+        }
+
+        /// <summary>Get the lexer mode this action should transition the lexer to.</summary>
+        /// <remarks>Get the lexer mode this action should transition the lexer to.</remarks>
+        /// <returns>
+        /// The lexer mode for this
+        /// <c>pushMode</c>
+        /// command.
+        /// </returns>
+        public int Mode
+        {
+            get
+            {
+                return mode;
+            }
+        }
+
+        /// <summary><inheritDoc/></summary>
+        /// <returns>
+        /// This method returns
+        /// <see cref="LexerActionType.PushMode"/>
+        /// .
+        /// </returns>
+        public LexerActionType ActionType
+        {
+            get
+            {
+                return LexerActionType.PushMode;
+            }
+        }
+
+        /// <summary><inheritDoc/></summary>
+        /// <returns>
+        /// This method returns
+        /// <see langword="false"/>
+        /// .
+        /// </returns>
+        public bool IsPositionDependent
+        {
+            get
+            {
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// <inheritDoc/>
+        /// <p>This action is implemented by calling
+        /// <see cref="Antlr4.Runtime.Lexer.PushMode(int)"/>
+        /// with the
+        /// value provided by
+        /// <see cref="Mode()"/>
+        /// .</p>
+        /// </summary>
+        public void Execute(Lexer lexer)
+        {
+            lexer.PushMode(mode);
+        }
+
+        public override int GetHashCode()
+        {
+            int hash = MurmurHash.Initialize();
+            hash = MurmurHash.Update(hash, (int)(ActionType));
+            hash = MurmurHash.Update(hash, mode);
+            return MurmurHash.Finish(hash, 2);
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (obj == this)
+            {
+                return true;
+            }
+            else
+            {
+                if (!(obj is Antlr4.Runtime.Atn.LexerPushModeAction))
+                {
+                    return false;
+                }
+            }
+            return mode == ((Antlr4.Runtime.Atn.LexerPushModeAction)obj).mode;
+        }
+
+        public override string ToString()
+        {
+            return string.Format("pushMode({0})", mode);
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/LexerSkipAction.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/LexerSkipAction.cs
new file mode 100644
index 000000000..d4bdb295b
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/LexerSkipAction.cs
@@ -0,0 +1,123 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    /// <summary>
+    /// Implements the
+    /// <c>skip</c>
+    /// lexer action by calling
+    /// <see cref="Antlr4.Runtime.Lexer.Skip()"/>
+    /// .
+    /// <p>The
+    /// <c>skip</c>
+    /// command does not have any parameters, so this action is
+    /// implemented as a singleton instance exposed by
+    /// <see cref="Instance"/>
+    /// .</p>
+    /// </summary>
+    /// <author>Sam Harwell</author>
+    /// <since>4.2</since>
+    public sealed class LexerSkipAction : ILexerAction
+    {
+        /// <summary>Provides a singleton instance of this parameterless lexer action.</summary>
+        /// <remarks>Provides a singleton instance of this parameterless lexer action.</remarks>
+        public static readonly Antlr4.Runtime.Atn.LexerSkipAction Instance = new Antlr4.Runtime.Atn.LexerSkipAction();
+
+        /// <summary>
+        /// Constructs the singleton instance of the lexer
+        /// <c>skip</c>
+        /// command.
+        /// </summary>
+        private LexerSkipAction()
+        {
+        }
+
+        /// <summary><inheritDoc/></summary>
+        /// <returns>
+        /// This method returns
+        /// <see cref="LexerActionType.Skip"/>
+        /// .
+        /// </returns>
+        public LexerActionType ActionType
+        {
+            get
+            {
+                return LexerActionType.Skip;
+            }
+        }
+
+        /// <summary><inheritDoc/></summary>
+        /// <returns>
+        /// This method returns
+        /// <see langword="false"/>
+        /// .
+        /// </returns>
+        public bool IsPositionDependent
+        {
+            get
+            {
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// <inheritDoc/>
+        /// <p>This action is implemented by calling
+        /// <see cref="Antlr4.Runtime.Lexer.Skip()"/>
+        /// .</p>
+        /// </summary>
+        public void Execute(Lexer lexer)
+        {
+            lexer.Skip();
+        }
+
+        public override int GetHashCode()
+        {
+            int hash = MurmurHash.Initialize();
+            hash = MurmurHash.Update(hash, (int)(ActionType));
+            return MurmurHash.Finish(hash, 1);
+        }
+
+        public override bool Equals(object obj)
+        {
+            return obj == this;
+        }
+
+        public override string ToString()
+        {
+            return "skip";
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/LexerTypeAction.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/LexerTypeAction.cs
new file mode 100644
index 000000000..fd227cd52
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/LexerTypeAction.cs
@@ -0,0 +1,147 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    /// <summary>
+    /// Implements the
+    /// <c>type</c>
+    /// lexer action by calling
+    /// <see cref="Lexer.Type"/>
+    /// with the assigned type.
+    /// </summary>
+    /// <author>Sam Harwell</author>
+    /// <since>4.2</since>
+    public class LexerTypeAction : ILexerAction
+    {
+        private readonly int type;
+
+        /// <summary>
+        /// Constructs a new
+        /// <paramref name="type"/>
+        /// action with the specified token type value.
+        /// </summary>
+        /// <param name="type">
+        /// The type to assign to the token using
+        /// <see cref="Lexer.Type"/>
+        /// .
+        /// </param>
+        public LexerTypeAction(int type)
+        {
+            this.type = type;
+        }
+
+        /// <summary>Gets the type to assign to a token created by the lexer.</summary>
+        /// <remarks>Gets the type to assign to a token created by the lexer.</remarks>
+        /// <returns>The type to assign to a token created by the lexer.</returns>
+        public virtual int Type
+        {
+            get
+            {
+                return type;
+            }
+        }
+
+        /// <summary><inheritDoc/></summary>
+        /// <returns>
+        /// This method returns
+        /// <see cref="LexerActionType.Type"/>
+        /// .
+        /// </returns>
+        public virtual LexerActionType ActionType
+        {
+            get
+            {
+                return LexerActionType.Type;
+            }
+        }
+
+        /// <summary><inheritDoc/></summary>
+        /// <returns>
+        /// This method returns
+        /// <see langword="false"/>
+        /// .
+        /// </returns>
+        public virtual bool IsPositionDependent
+        {
+            get
+            {
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// <inheritDoc/>
+        /// <p>This action is implemented by calling
+        /// <see cref="Lexer.Type"/>
+        /// with the
+        /// value provided by
+        /// <see cref="Type()"/>
+        /// .</p>
+        /// </summary>
+        public virtual void Execute(Lexer lexer)
+        {
+            lexer.Type = type;
+        }
+
+        public override int GetHashCode()
+        {
+            int hash = MurmurHash.Initialize();
+            hash = MurmurHash.Update(hash, (int)(ActionType));
+            hash = MurmurHash.Update(hash, type);
+            return MurmurHash.Finish(hash, 2);
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (obj == this)
+            {
+                return true;
+            }
+            else
+            {
+                if (!(obj is Antlr4.Runtime.Atn.LexerTypeAction))
+                {
+                    return false;
+                }
+            }
+            return type == ((Antlr4.Runtime.Atn.LexerTypeAction)obj).type;
+        }
+
+        public override string ToString()
+        {
+            return string.Format("type({0})", type);
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/LookaheadEventInfo.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/LookaheadEventInfo.cs
new file mode 100644
index 000000000..2422f5105
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/LookaheadEventInfo.cs
@@ -0,0 +1,78 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    /// <summary>
+    /// This class represents profiling event information for tracking the lookahead
+    /// depth required in order to make a prediction.
+    /// </summary>
+    /// <remarks>
+    /// This class represents profiling event information for tracking the lookahead
+    /// depth required in order to make a prediction.
+    /// </remarks>
+    /// <since>4.3</since>
+    public class LookaheadEventInfo : DecisionEventInfo
+    {
+        /// <summary>
+        /// Constructs a new instance of the
+        /// <see cref="LookaheadEventInfo"/>
+        /// class with
+        /// the specified detailed lookahead information.
+        /// </summary>
+        /// <param name="decision">The decision number</param>
+        /// <param name="state">
+        /// The final simulator state containing the necessary
+        /// information to determine the result of a prediction, or
+        /// <see langword="null"/>
+        /// if
+        /// the final state is not available
+        /// </param>
+        /// <param name="input">The input token stream</param>
+        /// <param name="startIndex">The start index for the current prediction</param>
+        /// <param name="stopIndex">The index at which the prediction was finally made</param>
+        /// <param name="fullCtx">
+        /// 
+        /// <see langword="true"/>
+        /// if the current lookahead is part of an LL
+        /// prediction; otherwise,
+        /// <see langword="false"/>
+        /// if the current lookahead is part of
+        /// an SLL prediction
+        /// </param>
+        public LookaheadEventInfo(int decision, SimulatorState state, ITokenStream input, int startIndex, int stopIndex, bool fullCtx)
+            : base(decision, state, input, startIndex, stopIndex, fullCtx)
+        {
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/LoopEndState.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/LoopEndState.cs
new file mode 100644
index 000000000..cc63b1c3b
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/LoopEndState.cs
@@ -0,0 +1,49 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    /// <summary>Mark the end of a * or + loop.</summary>
+    /// <remarks>Mark the end of a * or + loop.</remarks>
+    public sealed class LoopEndState : ATNState
+    {
+        public ATNState loopBackState;
+
+        public override Antlr4.Runtime.Atn.StateType StateType
+        {
+            get
+            {
+                return Antlr4.Runtime.Atn.StateType.LoopEnd;
+            }
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/NotSetTransition.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/NotSetTransition.cs
new file mode 100644
index 000000000..f3b4a0662
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/NotSetTransition.cs
@@ -0,0 +1,61 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    public sealed class NotSetTransition : SetTransition
+    {
+        public NotSetTransition(ATNState target, IntervalSet set)
+            : base(target, set)
+        {
+        }
+
+        public override Antlr4.Runtime.Atn.TransitionType TransitionType
+        {
+            get
+            {
+                return Antlr4.Runtime.Atn.TransitionType.NotSet;
+            }
+        }
+
+        public override bool Matches(int symbol, int minVocabSymbol, int maxVocabSymbol)
+        {
+            return symbol >= minVocabSymbol && symbol <= maxVocabSymbol && !base.Matches(symbol, minVocabSymbol, maxVocabSymbol);
+        }
+
+        public override string ToString()
+        {
+            return '~' + base.ToString();
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/OrderedATNConfigSet.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/OrderedATNConfigSet.cs
new file mode 100644
index 000000000..5e92a04d6
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/OrderedATNConfigSet.cs
@@ -0,0 +1,67 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    /// <author>Sam Harwell</author>
+    public class OrderedATNConfigSet : ATNConfigSet
+    {
+        public OrderedATNConfigSet()
+        {
+        }
+
+        public OrderedATNConfigSet(ATNConfigSet set, bool @readonly)
+            : base(set, @readonly)
+        {
+        }
+
+        public override ATNConfigSet Clone(bool @readonly)
+        {
+            Antlr4.Runtime.Atn.OrderedATNConfigSet copy = new Antlr4.Runtime.Atn.OrderedATNConfigSet(this, @readonly);
+            if (!@readonly && this.IsReadOnly)
+            {
+                copy.AddAll(this);
+            }
+            return copy;
+        }
+
+        protected internal override long GetKey(ATNConfig e)
+        {
+            return e.GetHashCode();
+        }
+
+        protected internal override bool CanMerge(ATNConfig left, long leftKey, ATNConfig right)
+        {
+            return left.Equals(right);
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/ParseInfo.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/ParseInfo.cs
new file mode 100644
index 000000000..17f9a5c42
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/ParseInfo.cs
@@ -0,0 +1,246 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System.Collections.Generic;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Dfa;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    /// <summary>
+    /// This class provides access to specific and aggregate statistics gathered
+    /// during profiling of a parser.
+    /// </summary>
+    /// <remarks>
+    /// This class provides access to specific and aggregate statistics gathered
+    /// during profiling of a parser.
+    /// </remarks>
+    /// <since>4.3</since>
+    public class ParseInfo
+    {
+        protected internal readonly ProfilingATNSimulator atnSimulator;
+
+        public ParseInfo(ProfilingATNSimulator atnSimulator)
+        {
+            this.atnSimulator = atnSimulator;
+        }
+
+        /// <summary>
+        /// Gets an array of
+        /// <see cref="DecisionInfo"/>
+        /// instances containing the profiling
+        /// information gathered for each decision in the ATN.
+        /// </summary>
+        /// <returns>
+        /// An array of
+        /// <see cref="DecisionInfo"/>
+        /// instances, indexed by decision
+        /// number.
+        /// </returns>
+        [NotNull]
+        public virtual Antlr4.Runtime.Atn.DecisionInfo[] DecisionInfo
+        {
+            get
+            {
+                return atnSimulator.DecisionInfo;
+            }
+        }
+
+        /// <summary>
+        /// Gets the decision numbers for decisions that required one or more
+        /// full-context predictions during parsing.
+        /// </summary>
+        /// <remarks>
+        /// Gets the decision numbers for decisions that required one or more
+        /// full-context predictions during parsing. These are decisions for which
+        /// <see cref="Antlr4.Runtime.Atn.DecisionInfo.LL_Fallback"/>
+        /// is non-zero.
+        /// </remarks>
+        /// <returns>
+        /// A list of decision numbers which required one or more
+        /// full-context predictions during parsing.
+        /// </returns>
+        [return: NotNull]
+        public virtual IList<int> GetLLDecisions()
+        {
+            Antlr4.Runtime.Atn.DecisionInfo[] decisions = atnSimulator.DecisionInfo;
+            IList<int> Ll = new List<int>();
+            for (int i = 0; i < decisions.Length; i++)
+            {
+                long fallBack = decisions[i].LL_Fallback;
+                if (fallBack > 0)
+                {
+                    Ll.Add(i);
+                }
+            }
+            return Ll;
+        }
+
+        /// <summary>
+        /// Gets the total number of SLL lookahead operations across all decisions
+        /// made during parsing.
+        /// </summary>
+        /// <remarks>
+        /// Gets the total number of SLL lookahead operations across all decisions
+        /// made during parsing. This value is the sum of
+        /// <see cref="Antlr4.Runtime.Atn.DecisionInfo.SLL_TotalLook"/>
+        /// for all decisions.
+        /// </remarks>
+        public virtual long GetTotalSLLLookaheadOps()
+        {
+            Antlr4.Runtime.Atn.DecisionInfo[] decisions = atnSimulator.DecisionInfo;
+            long k = 0;
+            for (int i = 0; i < decisions.Length; i++)
+            {
+                k += decisions[i].SLL_TotalLook;
+            }
+            return k;
+        }
+
+        /// <summary>
+        /// Gets the total number of LL lookahead operations across all decisions
+        /// made during parsing.
+        /// </summary>
+        /// <remarks>
+        /// Gets the total number of LL lookahead operations across all decisions
+        /// made during parsing. This value is the sum of
+        /// <see cref="Antlr4.Runtime.Atn.DecisionInfo.LL_TotalLook"/>
+        /// for all decisions.
+        /// </remarks>
+        public virtual long GetTotalLLLookaheadOps()
+        {
+            Antlr4.Runtime.Atn.DecisionInfo[] decisions = atnSimulator.DecisionInfo;
+            long k = 0;
+            for (int i = 0; i < decisions.Length; i++)
+            {
+                k += decisions[i].LL_TotalLook;
+            }
+            return k;
+        }
+
+        /// <summary>
+        /// Gets the total number of ATN lookahead operations for SLL prediction
+        /// across all decisions made during parsing.
+        /// </summary>
+        /// <remarks>
+        /// Gets the total number of ATN lookahead operations for SLL prediction
+        /// across all decisions made during parsing.
+        /// </remarks>
+        public virtual long GetTotalSLLATNLookaheadOps()
+        {
+            Antlr4.Runtime.Atn.DecisionInfo[] decisions = atnSimulator.DecisionInfo;
+            long k = 0;
+            for (int i = 0; i < decisions.Length; i++)
+            {
+                k += decisions[i].SLL_ATNTransitions;
+            }
+            return k;
+        }
+
+        /// <summary>
+        /// Gets the total number of ATN lookahead operations for LL prediction
+        /// across all decisions made during parsing.
+        /// </summary>
+        /// <remarks>
+        /// Gets the total number of ATN lookahead operations for LL prediction
+        /// across all decisions made during parsing.
+        /// </remarks>
+        public virtual long GetTotalLLATNLookaheadOps()
+        {
+            Antlr4.Runtime.Atn.DecisionInfo[] decisions = atnSimulator.DecisionInfo;
+            long k = 0;
+            for (int i = 0; i < decisions.Length; i++)
+            {
+                k += decisions[i].LL_ATNTransitions;
+            }
+            return k;
+        }
+
+        /// <summary>
+        /// Gets the total number of ATN lookahead operations for SLL and LL
+        /// prediction across all decisions made during parsing.
+        /// </summary>
+        /// <remarks>
+        /// Gets the total number of ATN lookahead operations for SLL and LL
+        /// prediction across all decisions made during parsing.
+        /// <p>
+        /// This value is the sum of
+        /// <see cref="GetTotalSLLATNLookaheadOps()"/>
+        /// and
+        /// <see cref="GetTotalLLATNLookaheadOps()"/>
+        /// .</p>
+        /// </remarks>
+        public virtual long GetTotalATNLookaheadOps()
+        {
+            Antlr4.Runtime.Atn.DecisionInfo[] decisions = atnSimulator.DecisionInfo;
+            long k = 0;
+            for (int i = 0; i < decisions.Length; i++)
+            {
+                k += decisions[i].SLL_ATNTransitions;
+                k += decisions[i].LL_ATNTransitions;
+            }
+            return k;
+        }
+
+        /// <summary>
+        /// Gets the total number of DFA states stored in the DFA cache for all
+        /// decisions in the ATN.
+        /// </summary>
+        /// <remarks>
+        /// Gets the total number of DFA states stored in the DFA cache for all
+        /// decisions in the ATN.
+        /// </remarks>
+        public virtual int GetDFASize()
+        {
+            int n = 0;
+            DFA[] decisionToDFA = atnSimulator.atn.decisionToDFA;
+            for (int i = 0; i < decisionToDFA.Length; i++)
+            {
+                n += GetDFASize(i);
+            }
+            return n;
+        }
+
+        /// <summary>
+        /// Gets the total number of DFA states stored in the DFA cache for a
+        /// particular decision.
+        /// </summary>
+        /// <remarks>
+        /// Gets the total number of DFA states stored in the DFA cache for a
+        /// particular decision.
+        /// </remarks>
+        public virtual int GetDFASize(int decision)
+        {
+            DFA decisionToDFA = atnSimulator.atn.decisionToDFA[decision];
+            return decisionToDFA.states.Count;
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/ParserATNSimulator.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/ParserATNSimulator.cs
new file mode 100644
index 000000000..1a587cbc0
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/ParserATNSimulator.cs
@@ -0,0 +1,2620 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System;
+using System.Collections.Generic;
+using Antlr4.Runtime;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Dfa;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    /// <summary>The embodiment of the adaptive LL(*), ALL(*), parsing strategy.</summary>
+    /// <remarks>
+    /// The embodiment of the adaptive LL(*), ALL(*), parsing strategy.
+    /// <p>
+    /// The basic complexity of the adaptive strategy makes it harder to understand.
+    /// We begin with ATN simulation to build paths in a DFA. Subsequent prediction
+    /// requests go through the DFA first. If they reach a state without an edge for
+    /// the current symbol, the algorithm fails over to the ATN simulation to
+    /// complete the DFA path for the current input (until it finds a conflict state
+    /// or uniquely predicting state).</p>
+    /// <p>
+    /// All of that is done without using the outer context because we want to create
+    /// a DFA that is not dependent upon the rule invocation stack when we do a
+    /// prediction. One DFA works in all contexts. We avoid using context not
+    /// necessarily because it's slower, although it can be, but because of the DFA
+    /// caching problem. The closure routine only considers the rule invocation stack
+    /// created during prediction beginning in the decision rule. For example, if
+    /// prediction occurs without invoking another rule's ATN, there are no context
+    /// stacks in the configurations. When lack of context leads to a conflict, we
+    /// don't know if it's an ambiguity or a weakness in the strong LL(*) parsing
+    /// strategy (versus full LL(*)).</p>
+    /// <p>
+    /// When SLL yields a configuration set with conflict, we rewind the input and
+    /// retry the ATN simulation, this time using full outer context without adding
+    /// to the DFA. Configuration context stacks will be the full invocation stacks
+    /// from the start rule. If we get a conflict using full context, then we can
+    /// definitively say we have a true ambiguity for that input sequence. If we
+    /// don't get a conflict, it implies that the decision is sensitive to the outer
+    /// context. (It is not context-sensitive in the sense of context-sensitive
+    /// grammars.)</p>
+    /// <p>
+    /// The next time we reach this DFA state with an SLL conflict, through DFA
+    /// simulation, we will again retry the ATN simulation using full context mode.
+    /// This is slow because we can't save the results and have to "interpret" the
+    /// ATN each time we get that input.</p>
+    /// <p>
+    /// <strong>CACHING FULL CONTEXT PREDICTIONS</strong></p>
+    /// <p>
+    /// We could cache results from full context to predicted alternative easily and
+    /// that saves a lot of time but doesn't work in presence of predicates. The set
+    /// of visible predicates from the ATN start state changes depending on the
+    /// context, because closure can fall off the end of a rule. I tried to cache
+    /// tuples (stack context, semantic context, predicted alt) but it was slower
+    /// than interpreting and much more complicated. Also required a huge amount of
+    /// memory. The goal is not to create the world's fastest parser anyway. I'd like
+    /// to keep this algorithm simple. By launching multiple threads, we can improve
+    /// the speed of parsing across a large number of files.</p>
+    /// <p>
+    /// There is no strict ordering between the amount of input used by SLL vs LL,
+    /// which makes it really hard to build a cache for full context. Let's say that
+    /// we have input A B C that leads to an SLL conflict with full context X. That
+    /// implies that using X we might only use A B but we could also use A B C D to
+    /// resolve conflict. Input A B C D could predict alternative 1 in one position
+    /// in the input and A B C E could predict alternative 2 in another position in
+    /// input. The conflicting SLL configurations could still be non-unique in the
+    /// full context prediction, which would lead us to requiring more input than the
+    /// original A B C.	To make a	prediction cache work, we have to track	the exact
+    /// input	used during the previous prediction. That amounts to a cache that maps
+    /// X to a specific DFA for that context.</p>
+    /// <p>
+    /// Something should be done for left-recursive expression predictions. They are
+    /// likely LL(1) + pred eval. Easier to do the whole SLL unless error and retry
+    /// with full LL thing Sam does.</p>
+    /// <p>
+    /// <strong>AVOIDING FULL CONTEXT PREDICTION</strong></p>
+    /// <p>
+    /// We avoid doing full context retry when the outer context is empty, we did not
+    /// dip into the outer context by falling off the end of the decision state rule,
+    /// or when we force SLL mode.</p>
+    /// <p>
+    /// As an example of the not dip into outer context case, consider as super
+    /// constructor calls versus function calls. One grammar might look like
+    /// this:</p>
+    /// <pre>
+    /// ctorBody
+    /// : '{' superCall? stat* '}'
+    /// ;
+    /// </pre>
+    /// <p>
+    /// Or, you might see something like</p>
+    /// <pre>
+    /// stat
+    /// : superCall ';'
+    /// | expression ';'
+    /// | ...
+    /// ;
+    /// </pre>
+    /// <p>
+    /// In both cases I believe that no closure operations will dip into the outer
+    /// context. In the first case ctorBody in the worst case will stop at the '}'.
+    /// In the 2nd case it should stop at the ';'. Both cases should stay within the
+    /// entry rule and not dip into the outer context.</p>
+    /// <p>
+    /// <strong>PREDICATES</strong></p>
+    /// <p>
+    /// Predicates are always evaluated if present in either SLL or LL both. SLL and
+    /// LL simulation deals with predicates differently. SLL collects predicates as
+    /// it performs closure operations like ANTLR v3 did. It delays predicate
+    /// evaluation until it reaches and accept state. This allows us to cache the SLL
+    /// ATN simulation whereas, if we had evaluated predicates on-the-fly during
+    /// closure, the DFA state configuration sets would be different and we couldn't
+    /// build up a suitable DFA.</p>
+    /// <p>
+    /// When building a DFA accept state during ATN simulation, we evaluate any
+    /// predicates and return the sole semantically valid alternative. If there is
+    /// more than 1 alternative, we report an ambiguity. If there are 0 alternatives,
+    /// we throw an exception. Alternatives without predicates act like they have
+    /// true predicates. The simple way to think about it is to strip away all
+    /// alternatives with false predicates and choose the minimum alternative that
+    /// remains.</p>
+    /// <p>
+    /// When we start in the DFA and reach an accept state that's predicated, we test
+    /// those and return the minimum semantically viable alternative. If no
+    /// alternatives are viable, we throw an exception.</p>
+    /// <p>
+    /// During full LL ATN simulation, closure always evaluates predicates and
+    /// on-the-fly. This is crucial to reducing the configuration set size during
+    /// closure. It hits a landmine when parsing with the Java grammar, for example,
+    /// without this on-the-fly evaluation.</p>
+    /// <p>
+    /// <strong>SHARING DFA</strong></p>
+    /// <p>
+    /// All instances of the same parser share the same decision DFAs through a
+    /// static field. Each instance gets its own ATN simulator but they share the
+    /// same
+    /// <see cref="ATN.decisionToDFA"/>
+    /// field. They also share a
+    /// <see cref="PredictionContextCache"/>
+    /// object that makes sure that all
+    /// <see cref="PredictionContext"/>
+    /// objects are shared among the DFA states. This makes
+    /// a big size difference.</p>
+    /// <p>
+    /// <strong>THREAD SAFETY</strong></p>
+    /// <p>
+    /// The
+    /// <see cref="ParserATNSimulator"/>
+    /// locks on the
+    /// <see cref="ATN.decisionToDFA"/>
+    /// field when
+    /// it adds a new DFA object to that array.
+    /// <see cref="AddDFAEdge(Antlr4.Runtime.Dfa.DFAState, int, Antlr4.Runtime.Dfa.DFAState)"/>
+    /// locks on the DFA for the current decision when setting the
+    /// <see cref="DFAState.edges"/>
+    /// field.
+    /// <see cref="AddDFAState(Antlr4.Runtime.Dfa.DFA, ATNConfigSet, PredictionContextCache)"/>
+    /// locks on
+    /// the DFA for the current decision when looking up a DFA state to see if it
+    /// already exists. We must make sure that all requests to add DFA states that
+    /// are equivalent result in the same shared DFA object. This is because lots of
+    /// threads will be trying to update the DFA at once. The
+    /// <see cref="AddDFAState(Antlr4.Runtime.Dfa.DFA, ATNConfigSet, PredictionContextCache)"/>
+    /// method also locks inside the DFA lock
+    /// but this time on the shared context cache when it rebuilds the
+    /// configurations'
+    /// <see cref="PredictionContext"/>
+    /// objects using cached
+    /// subgraphs/nodes. No other locking occurs, even during DFA simulation. This is
+    /// safe as long as we can guarantee that all threads referencing
+    /// <c>s.edge[t]</c>
+    /// get the same physical target
+    /// <see cref="Antlr4.Runtime.Dfa.DFAState"/>
+    /// , or
+    /// <see langword="null"/>
+    /// . Once into the DFA, the DFA simulation does not reference the
+    /// <see cref="Antlr4.Runtime.Dfa.DFA.states"/>
+    /// map. It follows the
+    /// <see cref="DFAState.edges"/>
+    /// field to new
+    /// targets. The DFA simulator will either find
+    /// <see cref="DFAState.edges"/>
+    /// to be
+    /// <see langword="null"/>
+    /// , to be non-
+    /// <see langword="null"/>
+    /// and
+    /// <c>dfa.edges[t]</c>
+    /// null, or
+    /// <c>dfa.edges[t]</c>
+    /// to be non-null. The
+    /// <see cref="AddDFAEdge(Antlr4.Runtime.Dfa.DFAState, int, Antlr4.Runtime.Dfa.DFAState)"/>
+    /// method could be racing to set the field
+    /// but in either case the DFA simulator works; if
+    /// <see langword="null"/>
+    /// , and requests ATN
+    /// simulation. It could also race trying to get
+    /// <c>dfa.edges[t]</c>
+    /// , but either
+    /// way it will work because it's not doing a test and set operation.</p>
+    /// <p>
+    /// <strong>Starting with SLL then failing to combined SLL/LL (Two-Stage
+    /// Parsing)</strong></p>
+    /// <p>
+    /// Sam pointed out that if SLL does not give a syntax error, then there is no
+    /// point in doing full LL, which is slower. We only have to try LL if we get a
+    /// syntax error. For maximum speed, Sam starts the parser set to pure SLL
+    /// mode with the
+    /// <see cref="Antlr4.Runtime.BailErrorStrategy"/>
+    /// :</p>
+    /// <pre>
+    /// parser.
+    /// <see cref="Antlr4.Runtime.Recognizer{Symbol, ATNInterpreter}.Interpreter()">getInterpreter()</see>
+    /// .
+    /// <see cref="PredictionMode"/>
+    /// <c>(</c>
+    /// <see cref="Atn.PredictionMode.Sll"/>
+    /// <c>)</c>
+    /// ;
+    /// parser.
+    /// (new
+    /// <see cref="Antlr4.Runtime.BailErrorStrategy"/>
+    /// ());
+    /// </pre>
+    /// <p>
+    /// If it does not get a syntax error, then we're done. If it does get a syntax
+    /// error, we need to retry with the combined SLL/LL strategy.</p>
+    /// <p>
+    /// The reason this works is as follows. If there are no SLL conflicts, then the
+    /// grammar is SLL (at least for that input set). If there is an SLL conflict,
+    /// the full LL analysis must yield a set of viable alternatives which is a
+    /// subset of the alternatives reported by SLL. If the LL set is a singleton,
+    /// then the grammar is LL but not SLL. If the LL set is the same size as the SLL
+    /// set, the decision is SLL. If the LL set has size &gt; 1, then that decision
+    /// is truly ambiguous on the current input. If the LL set is smaller, then the
+    /// SLL conflict resolution might choose an alternative that the full LL would
+    /// rule out as a possibility based upon better context information. If that's
+    /// the case, then the SLL parse will definitely get an error because the full LL
+    /// analysis says it's not viable. If SLL conflict resolution chooses an
+    /// alternative within the LL set, them both SLL and LL would choose the same
+    /// alternative because they both choose the minimum of multiple conflicting
+    /// alternatives.</p>
+    /// <p>
+    /// Let's say we have a set of SLL conflicting alternatives
+    /// <c/>
+    /// 
+    /// 1, 2, 3}} and
+    /// a smaller LL set called <em>s</em>. If <em>s</em> is
+    /// <c/>
+    /// 
+    /// 2, 3}}, then SLL
+    /// parsing will get an error because SLL will pursue alternative 1. If
+    /// <em>s</em> is
+    /// <c/>
+    /// 
+    /// 1, 2}} or
+    /// <c/>
+    /// 
+    /// 1, 3}} then both SLL and LL will
+    /// choose the same alternative because alternative one is the minimum of either
+    /// set. If <em>s</em> is
+    /// <c/>
+    /// 
+    /// 2}} or
+    /// <c/>
+    /// 
+    /// 3}} then SLL will get a syntax
+    /// error. If <em>s</em> is
+    /// <c/>
+    /// 
+    /// 1}} then SLL will succeed.</p>
+    /// <p>
+    /// Of course, if the input is invalid, then we will get an error for sure in
+    /// both SLL and LL parsing. Erroneous input will therefore require 2 passes over
+    /// the input.</p>
+    /// </remarks>
+    public class ParserATNSimulator : ATNSimulator
+    {
+#pragma warning disable 0162 // Unreachable code detected
+#if !PORTABLE
+        public const bool debug = false;
+
+        public const bool dfa_debug = false;
+
+        public const bool retry_debug = false;
+#endif
+
+        [NotNull]
+        private Antlr4.Runtime.Atn.PredictionMode predictionMode = Antlr4.Runtime.Atn.PredictionMode.Ll;
+
+        public bool force_global_context = false;
+
+        public bool always_try_local_context = true;
+
+        /// <summary>Determines whether the DFA is used for full-context predictions.</summary>
+        /// <remarks>
+        /// Determines whether the DFA is used for full-context predictions. When
+        /// <see langword="true"/>
+        /// , the DFA stores transition information for both full-context
+        /// and SLL parsing; otherwise, the DFA only stores SLL transition
+        /// information.
+        /// <p>
+        /// For some grammars, enabling the full-context DFA can result in a
+        /// substantial performance improvement. However, this improvement typically
+        /// comes at the expense of memory used for storing the cached DFA states,
+        /// configuration sets, and prediction contexts.</p>
+        /// <p>
+        /// The default value is
+        /// <see langword="false"/>
+        /// .</p>
+        /// </remarks>
+        public bool enable_global_context_dfa = false;
+
+        public bool optimize_unique_closure = true;
+
+        public bool optimize_ll1 = true;
+
+        [System.ObsoleteAttribute(@"This flag is not currently used by the ATN simulator.")]
+        public bool optimize_hidden_conflicted_configs = false;
+
+        public bool optimize_tail_calls = true;
+
+        public bool tail_call_preserves_sll = true;
+
+        public bool treat_sllk1_conflict_as_ambiguity = false;
+
+        [Nullable]
+        private readonly Antlr4.Runtime.Parser _parser;
+
+        /// <summary>
+        /// When
+        /// <see langword="true"/>
+        /// , ambiguous alternatives are reported when they are
+        /// encountered within
+        /// <see cref="ExecATN(Antlr4.Runtime.Dfa.DFA, Antlr4.Runtime.ITokenStream, int, SimulatorState)"/>
+        /// . When
+        /// <see langword="false"/>
+        /// , these messages
+        /// are suppressed. The default is
+        /// <see langword="false"/>
+        /// .
+        /// <p/>
+        /// When messages about ambiguous alternatives are not required, setting this
+        /// to
+        /// <see langword="false"/>
+        /// enables additional internal optimizations which may lose
+        /// this information.
+        /// </summary>
+		public bool reportAmbiguities = false;
+
+        /// <summary>
+        /// By default we do full context-sensitive LL(*) parsing not
+        /// Strong LL(*) parsing.
+        /// </summary>
+        /// <remarks>
+        /// By default we do full context-sensitive LL(*) parsing not
+        /// Strong LL(*) parsing. If we fail with Strong LL(*) we
+        /// try full LL(*). That means we rewind and use context information
+        /// when closure operations fall off the end of the rule that
+        /// holds the decision were evaluating.
+        /// </remarks>
+        protected internal bool userWantsCtxSensitive = true;
+
+        private DFA dfa;
+
+        /// <summary>Testing only!</summary>
+        public ParserATNSimulator(ATN atn)
+            : this(null, atn)
+        {
+        }
+
+        public ParserATNSimulator(Antlr4.Runtime.Parser parser, ATN atn)
+            : base(atn)
+        {
+            this._parser = parser;
+        }
+
+        public Antlr4.Runtime.Atn.PredictionMode PredictionMode
+        {
+            get
+            {
+                return predictionMode;
+            }
+            set
+            {
+                Antlr4.Runtime.Atn.PredictionMode predictionMode = value;
+                this.predictionMode = predictionMode;
+            }
+        }
+
+        public override void Reset()
+        {
+        }
+
+        public virtual int AdaptivePredict(ITokenStream input, int decision, ParserRuleContext outerContext)
+        {
+            return AdaptivePredict(input, decision, outerContext, false);
+        }
+
+        public virtual int AdaptivePredict(ITokenStream input, int decision, ParserRuleContext outerContext, bool useContext)
+        {
+            DFA dfa = atn.decisionToDFA[decision];
+            System.Diagnostics.Debug.Assert(dfa != null);
+            if (optimize_ll1 && !dfa.IsPrecedenceDfa && !dfa.IsEmpty)
+            {
+                int ll_1 = input.La(1);
+                if (ll_1 >= 0 && ll_1 <= short.MaxValue)
+                {
+                    int key = (decision << 16) + ll_1;
+                    int alt;
+                    if (atn.LL1Table.TryGetValue(key, out alt))
+                    {
+                        return alt;
+                    }
+                }
+            }
+            this.dfa = dfa;
+            if (force_global_context)
+            {
+                useContext = true;
+            }
+            else
+            {
+                if (!always_try_local_context)
+                {
+                    useContext |= dfa.IsContextSensitive;
+                }
+            }
+            userWantsCtxSensitive = useContext || (predictionMode != Antlr4.Runtime.Atn.PredictionMode.Sll && outerContext != null);
+            if (outerContext == null)
+            {
+                outerContext = ParserRuleContext.EmptyContext;
+            }
+            SimulatorState state = null;
+            if (!dfa.IsEmpty)
+            {
+                state = GetStartState(dfa, input, outerContext, useContext);
+            }
+            if (state == null)
+            {
+                if (outerContext == null)
+                {
+                    outerContext = ParserRuleContext.EmptyContext;
+                }
+                state = ComputeStartState(dfa, outerContext, useContext);
+            }
+            int m = input.Mark();
+            int index = input.Index;
+            try
+            {
+                int alt = ExecDFA(dfa, input, index, state);
+                return alt;
+            }
+            finally
+            {
+                this.dfa = null;
+                input.Seek(index);
+                input.Release(m);
+            }
+        }
+
+        protected internal virtual SimulatorState GetStartState(DFA dfa, ITokenStream input, ParserRuleContext outerContext, bool useContext)
+        {
+            if (!useContext)
+            {
+                if (dfa.IsPrecedenceDfa)
+                {
+                    // the start state for a precedence DFA depends on the current
+                    // parser precedence, and is provided by a DFA method.
+                    DFAState state = dfa.GetPrecedenceStartState(_parser.Precedence, false);
+                    if (state == null)
+                    {
+                        return null;
+                    }
+                    return new SimulatorState(outerContext, state, false, outerContext);
+                }
+                else
+                {
+                    if (dfa.s0.Get() == null)
+                    {
+                        return null;
+                    }
+                    return new SimulatorState(outerContext, dfa.s0.Get(), false, outerContext);
+                }
+            }
+            if (!enable_global_context_dfa)
+            {
+                return null;
+            }
+            ParserRuleContext remainingContext = outerContext;
+            System.Diagnostics.Debug.Assert(outerContext != null);
+            DFAState s0;
+            if (dfa.IsPrecedenceDfa)
+            {
+                s0 = dfa.GetPrecedenceStartState(_parser.Precedence, true);
+            }
+            else
+            {
+                s0 = dfa.s0full.Get();
+            }
+            while (remainingContext != null && s0 != null && s0.IsContextSensitive)
+            {
+                remainingContext = SkipTailCalls(remainingContext);
+                s0 = s0.GetContextTarget(GetReturnState(remainingContext));
+                if (remainingContext.IsEmpty)
+                {
+                    System.Diagnostics.Debug.Assert(s0 == null || !s0.IsContextSensitive);
+                }
+                else
+                {
+                    remainingContext = ((ParserRuleContext)remainingContext.Parent);
+                }
+            }
+            if (s0 == null)
+            {
+                return null;
+            }
+            return new SimulatorState(outerContext, s0, useContext, remainingContext);
+        }
+
+        protected internal virtual int ExecDFA(DFA dfa, ITokenStream input, int startIndex, SimulatorState state)
+        {
+            ParserRuleContext outerContext = state.outerContext;
+            DFAState s = state.s0;
+            int t = input.La(1);
+            ParserRuleContext remainingOuterContext = state.remainingOuterContext;
+            while (true)
+            {
+                if (state.useContext)
+                {
+                    while (s.IsContextSymbol(t))
+                    {
+                        DFAState next = null;
+                        if (remainingOuterContext != null)
+                        {
+                            remainingOuterContext = SkipTailCalls(remainingOuterContext);
+                            next = s.GetContextTarget(GetReturnState(remainingOuterContext));
+                        }
+                        if (next == null)
+                        {
+                            // fail over to ATN
+                            SimulatorState initialState = new SimulatorState(state.outerContext, s, state.useContext, remainingOuterContext);
+                            return ExecATN(dfa, input, startIndex, initialState);
+                        }
+                        System.Diagnostics.Debug.Assert(remainingOuterContext != null);
+                        remainingOuterContext = ((ParserRuleContext)remainingOuterContext.Parent);
+                        s = next;
+                    }
+                }
+                if (IsAcceptState(s, state.useContext))
+                {
+                    if (s.predicates != null)
+                    {
+                    }
+                    // keep going unless we're at EOF or state only has one alt number
+                    // mentioned in configs; check if something else could match
+                    // TODO: don't we always stop? only lexer would keep going
+                    // TODO: v3 dfa don't do this.
+                    break;
+                }
+                // t is not updated if one of these states is reached
+                System.Diagnostics.Debug.Assert(!IsAcceptState(s, state.useContext));
+                // if no edge, pop over to ATN interpreter, update DFA and return
+                DFAState target = GetExistingTargetState(s, t);
+                if (target == null)
+                {
+#if !PORTABLE
+					#pragma warning disable 162, 429
+					if (dfa_debug && t >= 0)
+                    {
+                        System.Console.Out.WriteLine("no edge for " + _parser.Vocabulary.GetDisplayName(t));
+                    }
+					#pragma warning restore 162, 429
+#endif
+                    int alt;
+                    SimulatorState initialState = new SimulatorState(outerContext, s, state.useContext, remainingOuterContext);
+                    alt = ExecATN(dfa, input, startIndex, initialState);
+                    //dump(dfa);
+                    // action already executed
+                    return alt;
+                }
+                else
+                {
+                    // we've updated DFA, exec'd action, and have our deepest answer
+                    if (target == Error)
+                    {
+                        SimulatorState errorState = new SimulatorState(outerContext, s, state.useContext, remainingOuterContext);
+                        return HandleNoViableAlt(input, startIndex, errorState);
+                    }
+                }
+                s = target;
+                if (!IsAcceptState(s, state.useContext) && t != IntStreamConstants.Eof)
+                {
+                    input.Consume();
+                    t = input.La(1);
+                }
+            }
+            //		if ( acceptState==null ) {
+            //			if ( debug ) System.out.println("!!! no viable alt in dfa");
+            //			return -1;
+            //		}
+            if (!state.useContext && s.configs.ConflictInformation != null)
+            {
+                if (dfa.atnStartState is DecisionState)
+                {
+                    if (!userWantsCtxSensitive || (!s.configs.DipsIntoOuterContext && s.configs.IsExactConflict) || (treat_sllk1_conflict_as_ambiguity && input.Index == startIndex))
+                    {
+                    }
+                    else
+                    {
+                        // we don't report the ambiguity again
+                        //if ( !acceptState.configset.hasSemanticContext() ) {
+                        //	reportAmbiguity(dfa, acceptState, startIndex, input.index(), acceptState.configset.getConflictingAlts(), acceptState.configset);
+                        //}
+                        System.Diagnostics.Debug.Assert(!state.useContext);
+                        // Before attempting full context prediction, check to see if there are
+                        // disambiguating or validating predicates to evaluate which allow an
+                        // immediate decision
+                        BitSet conflictingAlts = null;
+                        DFAState.PredPrediction[] predicates = s.predicates;
+                        if (predicates != null)
+                        {
+                            int conflictIndex = input.Index;
+                            if (conflictIndex != startIndex)
+                            {
+                                input.Seek(startIndex);
+                            }
+                            conflictingAlts = EvalSemanticContext(predicates, outerContext, true);
+                            if (conflictingAlts.Cardinality() == 1)
+                            {
+                                return conflictingAlts.NextSetBit(0);
+                            }
+                            if (conflictIndex != startIndex)
+                            {
+                                // restore the index so reporting the fallback to full
+                                // context occurs with the index at the correct spot
+                                input.Seek(conflictIndex);
+                            }
+                        }
+                        if (reportAmbiguities)
+                        {
+                            SimulatorState conflictState = new SimulatorState(outerContext, s, state.useContext, remainingOuterContext);
+                            ReportAttemptingFullContext(dfa, conflictingAlts, conflictState, startIndex, input.Index);
+                        }
+                        input.Seek(startIndex);
+                        return AdaptivePredict(input, dfa.decision, outerContext, true);
+                    }
+                }
+            }
+            // Before jumping to prediction, check to see if there are
+            // disambiguating or validating predicates to evaluate
+            DFAState.PredPrediction[] predicates_1 = s.predicates;
+            if (predicates_1 != null)
+            {
+                int stopIndex = input.Index;
+                if (startIndex != stopIndex)
+                {
+                    input.Seek(startIndex);
+                }
+                BitSet alts = EvalSemanticContext(predicates_1, outerContext, reportAmbiguities && predictionMode == Antlr4.Runtime.Atn.PredictionMode.LlExactAmbigDetection);
+                switch (alts.Cardinality())
+                {
+                    case 0:
+                    {
+                        throw NoViableAlt(input, outerContext, s.configs, startIndex);
+                    }
+
+                    case 1:
+                    {
+                        return alts.NextSetBit(0);
+                    }
+
+                    default:
+                    {
+                        // report ambiguity after predicate evaluation to make sure the correct
+                        // set of ambig alts is reported.
+                        if (startIndex != stopIndex)
+                        {
+                            input.Seek(stopIndex);
+                        }
+                        ReportAmbiguity(dfa, s, startIndex, stopIndex, s.configs.IsExactConflict, alts, s.configs);
+                        return alts.NextSetBit(0);
+                    }
+                }
+            }
+            return s.Prediction;
+        }
+
+        /// <summary>
+        /// Determines if a particular DFA state should be treated as an accept state
+        /// for the current prediction mode.
+        /// </summary>
+        /// <remarks>
+        /// Determines if a particular DFA state should be treated as an accept state
+        /// for the current prediction mode. In addition to the
+        /// <paramref name="useContext"/>
+        /// parameter, the
+        /// <see cref="PredictionMode()"/>
+        /// method provides the
+        /// prediction mode controlling the prediction algorithm as a whole.
+        /// <p>
+        /// The default implementation simply returns the value of
+        /// <see cref="Antlr4.Runtime.Dfa.DFAState.IsAcceptState()"/>
+        /// except for conflict states when
+        /// <paramref name="useContext"/>
+        /// is
+        /// <see langword="true"/>
+        /// and
+        /// <see cref="PredictionMode()"/>
+        /// is
+        /// <see cref="Antlr4.Runtime.Atn.PredictionMode.LlExactAmbigDetection"/>
+        /// . In that case, only
+        /// conflict states where
+        /// <see cref="ATNConfigSet.IsExactConflict()"/>
+        /// is
+        /// <see langword="true"/>
+        /// are considered accept states.
+        /// </p>
+        /// </remarks>
+        /// <param name="state">The DFA state to check.</param>
+        /// <param name="useContext">
+        /// 
+        /// <see langword="true"/>
+        /// if the prediction algorithm is currently
+        /// considering the full parser context; otherwise,
+        /// <see langword="false"/>
+        /// if the
+        /// algorithm is currently performing a local context prediction.
+        /// </param>
+        /// <returns>
+        /// 
+        /// <see langword="true"/>
+        /// if the specified
+        /// <paramref name="state"/>
+        /// is an accept state;
+        /// otherwise,
+        /// <see langword="false"/>
+        /// .
+        /// </returns>
+        protected internal virtual bool IsAcceptState(DFAState state, bool useContext)
+        {
+            if (!state.IsAcceptState)
+            {
+                return false;
+            }
+            if (state.configs.ConflictingAlts == null)
+            {
+                // unambiguous
+                return true;
+            }
+            // More picky when we need exact conflicts
+            if (useContext && predictionMode == Antlr4.Runtime.Atn.PredictionMode.LlExactAmbigDetection)
+            {
+                return state.configs.IsExactConflict;
+            }
+            return true;
+        }
+
+        /// <summary>
+        /// Performs ATN simulation to compute a predicted alternative based
+        /// upon the remaining input, but also updates the DFA cache to avoid
+        /// having to traverse the ATN again for the same input sequence.
+        /// </summary>
+        /// <remarks>
+        /// Performs ATN simulation to compute a predicted alternative based
+        /// upon the remaining input, but also updates the DFA cache to avoid
+        /// having to traverse the ATN again for the same input sequence.
+        /// There are some key conditions we're looking for after computing a new
+        /// set of ATN configs (proposed DFA state):
+        /// if the set is empty, there is no viable alternative for current symbol
+        /// does the state uniquely predict an alternative?
+        /// does the state have a conflict that would prevent us from
+        /// putting it on the work list?
+        /// if in non-greedy decision is there a config at a rule stop state?
+        /// We also have some key operations to do:
+        /// add an edge from previous DFA state to potentially new DFA state, D,
+        /// upon current symbol but only if adding to work list, which means in all
+        /// cases except no viable alternative (and possibly non-greedy decisions?)
+        /// collecting predicates and adding semantic context to DFA accept states
+        /// adding rule context to context-sensitive DFA accept states
+        /// consuming an input symbol
+        /// reporting a conflict
+        /// reporting an ambiguity
+        /// reporting a context sensitivity
+        /// reporting insufficient predicates
+        /// We should isolate those operations, which are side-effecting, to the
+        /// main work loop. We can isolate lots of code into other functions, but
+        /// they should be side effect free. They can return package that
+        /// indicates whether we should report something, whether we need to add a
+        /// DFA edge, whether we need to augment accept state with semantic
+        /// context or rule invocation context. Actually, it seems like we always
+        /// add predicates if they exist, so that can simply be done in the main
+        /// loop for any accept state creation or modification request.
+        /// cover these cases:
+        /// dead end
+        /// single alt
+        /// single alt + preds
+        /// conflict
+        /// conflict + preds
+        /// TODO: greedy + those
+        /// </remarks>
+        protected internal virtual int ExecATN(DFA dfa, ITokenStream input, int startIndex, SimulatorState initialState)
+        {
+            ParserRuleContext outerContext = initialState.outerContext;
+			bool useContext = initialState.useContext;
+            int t = input.La(1);
+            SimulatorState previous = initialState;
+            PredictionContextCache contextCache = new PredictionContextCache();
+            while (true)
+            {
+                // while more work
+                SimulatorState nextState = ComputeReachSet(dfa, previous, t, contextCache);
+                if (nextState == null)
+                {
+                    AddDFAEdge(previous.s0, input.La(1), Error);
+                    return HandleNoViableAlt(input, startIndex, previous);
+                }
+                DFAState D = nextState.s0;
+                // predicted alt => accept state
+                System.Diagnostics.Debug.Assert(D.IsAcceptState || D.Prediction == ATN.InvalidAltNumber);
+                // conflicted => accept state
+                System.Diagnostics.Debug.Assert(D.IsAcceptState || D.configs.ConflictInformation == null);
+                if (IsAcceptState(D, useContext))
+                {
+                    BitSet conflictingAlts = D.configs.ConflictingAlts;
+                    int predictedAlt = conflictingAlts == null ? D.Prediction : ATN.InvalidAltNumber;
+                    if (predictedAlt != ATN.InvalidAltNumber)
+                    {
+                        if (optimize_ll1 && input.Index == startIndex && !dfa.IsPrecedenceDfa && nextState.outerContext == nextState.remainingOuterContext && dfa.decision >= 0 && !D.configs.HasSemanticContext)
+                        {
+                            if (t >= 0 && t <= short.MaxValue)
+                            {
+                                int key = (dfa.decision << 16) + t;
+                                atn.LL1Table[key] = predictedAlt;
+                            }
+                        }
+                        if (useContext && always_try_local_context)
+                        {
+                            ReportContextSensitivity(dfa, predictedAlt, nextState, startIndex, input.Index);
+                        }
+                    }
+                    predictedAlt = D.Prediction;
+                    //				int k = input.index() - startIndex + 1; // how much input we used
+                    //				System.out.println("used k="+k);
+                    bool attemptFullContext = conflictingAlts != null && userWantsCtxSensitive;
+                    if (attemptFullContext)
+                    {
+                        // Only exact conflicts are known to be ambiguous when local
+                        // prediction does not step out of the decision rule.
+                        attemptFullContext = !useContext && (D.configs.DipsIntoOuterContext || !D.configs.IsExactConflict) && (!treat_sllk1_conflict_as_ambiguity || input.Index != startIndex);
+                    }
+                    if (D.configs.HasSemanticContext)
+                    {
+                        DFAState.PredPrediction[] predPredictions = D.predicates;
+                        if (predPredictions != null)
+                        {
+                            int conflictIndex = input.Index;
+                            if (conflictIndex != startIndex)
+                            {
+                                input.Seek(startIndex);
+                            }
+                            // use complete evaluation here if we'll want to retry with full context if still ambiguous
+                            conflictingAlts = EvalSemanticContext(predPredictions, outerContext, attemptFullContext || reportAmbiguities);
+                            switch (conflictingAlts.Cardinality())
+                            {
+                                case 0:
+                                {
+                                    throw NoViableAlt(input, outerContext, D.configs, startIndex);
+                                }
+
+                                case 1:
+                                {
+                                    return conflictingAlts.NextSetBit(0);
+                                }
+
+                                default:
+                                {
+                                    break;
+                                }
+                            }
+                            if (conflictIndex != startIndex)
+                            {
+                                // restore the index so reporting the fallback to full
+                                // context occurs with the index at the correct spot
+                                input.Seek(conflictIndex);
+                            }
+                        }
+                    }
+                    if (!attemptFullContext)
+                    {
+                        if (conflictingAlts != null)
+                        {
+                            if (reportAmbiguities && conflictingAlts.Cardinality() > 1)
+                            {
+                                ReportAmbiguity(dfa, D, startIndex, input.Index, D.configs.IsExactConflict, conflictingAlts, D.configs);
+                            }
+                            predictedAlt = conflictingAlts.NextSetBit(0);
+                        }
+                        return predictedAlt;
+                    }
+                    else
+                    {
+                        System.Diagnostics.Debug.Assert(!useContext);
+                        System.Diagnostics.Debug.Assert(IsAcceptState(D, false));
+                        SimulatorState fullContextState = ComputeStartState(dfa, outerContext, true);
+                        if (reportAmbiguities)
+                        {
+                            ReportAttemptingFullContext(dfa, conflictingAlts, nextState, startIndex, input.Index);
+                        }
+                        input.Seek(startIndex);
+                        return ExecATN(dfa, input, startIndex, fullContextState);
+                    }
+                }
+                previous = nextState;
+                if (t != IntStreamConstants.Eof)
+                {
+                    input.Consume();
+                    t = input.La(1);
+                }
+            }
+        }
+
+        /// <summary>
+        /// This method is used to improve the localization of error messages by
+        /// choosing an alternative rather than throwing a
+        /// <see cref="Antlr4.Runtime.NoViableAltException"/>
+        /// in particular prediction scenarios where the
+        /// <see cref="ATNSimulator.Error"/>
+        /// state was reached during ATN simulation.
+        /// <p>
+        /// The default implementation of this method uses the following
+        /// algorithm to identify an ATN configuration which successfully parsed the
+        /// decision entry rule. Choosing such an alternative ensures that the
+        /// <see cref="Antlr4.Runtime.ParserRuleContext"/>
+        /// returned by the calling rule will be complete
+        /// and valid, and the syntax error will be reported later at a more
+        /// localized location.</p>
+        /// <ul>
+        /// <li>If no configuration in
+        /// <c>configs</c>
+        /// reached the end of the
+        /// decision rule, return
+        /// <see cref="ATN.InvalidAltNumber"/>
+        /// .</li>
+        /// <li>If all configurations in
+        /// <c>configs</c>
+        /// which reached the end of the
+        /// decision rule predict the same alternative, return that alternative.</li>
+        /// <li>If the configurations in
+        /// <c>configs</c>
+        /// which reached the end of the
+        /// decision rule predict multiple alternatives (call this <em>S</em>),
+        /// choose an alternative in the following order.
+        /// <ol>
+        /// <li>Filter the configurations in
+        /// <c>configs</c>
+        /// to only those
+        /// configurations which remain viable after evaluating semantic predicates.
+        /// If the set of these filtered configurations which also reached the end of
+        /// the decision rule is not empty, return the minimum alternative
+        /// represented in this set.</li>
+        /// <li>Otherwise, choose the minimum alternative in <em>S</em>.</li>
+        /// </ol>
+        /// </li>
+        /// </ul>
+        /// <p>
+        /// In some scenarios, the algorithm described above could predict an
+        /// alternative which will result in a
+        /// <see cref="Antlr4.Runtime.FailedPredicateException"/>
+        /// in
+        /// parser. Specifically, this could occur if the <em>only</em> configuration
+        /// capable of successfully parsing to the end of the decision rule is
+        /// blocked by a semantic predicate. By choosing this alternative within
+        /// <see cref="AdaptivePredict(Antlr4.Runtime.ITokenStream, int, Antlr4.Runtime.ParserRuleContext)"/>
+        /// instead of throwing a
+        /// <see cref="Antlr4.Runtime.NoViableAltException"/>
+        /// , the resulting
+        /// <see cref="Antlr4.Runtime.FailedPredicateException"/>
+        /// in the parser will identify the specific
+        /// predicate which is preventing the parser from successfully parsing the
+        /// decision rule, which helps developers identify and correct logic errors
+        /// in semantic predicates.
+        /// </p>
+        /// </summary>
+        /// <param name="input">
+        /// The input
+        /// <see cref="Antlr4.Runtime.ITokenStream"/>
+        /// </param>
+        /// <param name="startIndex">
+        /// The start index for the current prediction, which is
+        /// the input index where any semantic context in
+        /// <c>configs</c>
+        /// should be
+        /// evaluated
+        /// </param>
+        /// <param name="previous">
+        /// The ATN simulation state immediately before the
+        /// <see cref="ATNSimulator.Error"/>
+        /// state was reached
+        /// </param>
+        /// <returns>
+        /// The value to return from
+        /// <see cref="AdaptivePredict(Antlr4.Runtime.ITokenStream, int, Antlr4.Runtime.ParserRuleContext)"/>
+        /// , or
+        /// <see cref="ATN.InvalidAltNumber"/>
+        /// if a suitable alternative was not
+        /// identified and
+        /// <see cref="AdaptivePredict(Antlr4.Runtime.ITokenStream, int, Antlr4.Runtime.ParserRuleContext)"/>
+        /// should report an error instead.
+        /// </returns>
+        protected internal virtual int HandleNoViableAlt(ITokenStream input, int startIndex, SimulatorState previous)
+        {
+            if (previous.s0 != null)
+            {
+                BitSet alts = new BitSet();
+                int maxAlt = 0;
+                foreach (ATNConfig config in previous.s0.configs)
+                {
+                    if (config.ReachesIntoOuterContext || config.State is RuleStopState)
+                    {
+                        alts.Set(config.Alt);
+                        maxAlt = Math.Max(maxAlt, config.Alt);
+                    }
+                }
+                switch (alts.Cardinality())
+                {
+                    case 0:
+                    {
+                        break;
+                    }
+
+                    case 1:
+                    {
+                        return alts.NextSetBit(0);
+                    }
+
+                    default:
+                    {
+                        if (!previous.s0.configs.HasSemanticContext)
+                        {
+                            // configs doesn't contain any predicates, so the predicate
+                            // filtering code below would be pointless
+                            return alts.NextSetBit(0);
+                        }
+                        ATNConfigSet filteredConfigs = new ATNConfigSet();
+                        foreach (ATNConfig config_1 in previous.s0.configs)
+                        {
+                            if (config_1.ReachesIntoOuterContext || config_1.State is RuleStopState)
+                            {
+                                filteredConfigs.Add(config_1);
+                            }
+                        }
+                        SemanticContext[] altToPred = GetPredsForAmbigAlts(alts, filteredConfigs, maxAlt);
+                        if (altToPred != null)
+                        {
+                            DFAState.PredPrediction[] predicates = GetPredicatePredictions(alts, altToPred);
+                            if (predicates != null)
+                            {
+                                int stopIndex = input.Index;
+                                try
+                                {
+                                    input.Seek(startIndex);
+                                    BitSet filteredAlts = EvalSemanticContext(predicates, previous.outerContext, false);
+                                    if (!filteredAlts.IsEmpty())
+                                    {
+                                        return filteredAlts.NextSetBit(0);
+                                    }
+                                }
+                                finally
+                                {
+                                    input.Seek(stopIndex);
+                                }
+                            }
+                        }
+                        return alts.NextSetBit(0);
+                    }
+                }
+            }
+            throw NoViableAlt(input, previous.outerContext, previous.s0.configs, startIndex);
+        }
+
+        protected internal virtual SimulatorState ComputeReachSet(DFA dfa, SimulatorState previous, int t, PredictionContextCache contextCache)
+        {
+            bool useContext = previous.useContext;
+            ParserRuleContext remainingGlobalContext = previous.remainingOuterContext;
+            DFAState s = previous.s0;
+            if (useContext)
+            {
+                while (s.IsContextSymbol(t))
+                {
+                    DFAState next = null;
+                    if (remainingGlobalContext != null)
+                    {
+                        remainingGlobalContext = SkipTailCalls(remainingGlobalContext);
+                        next = s.GetContextTarget(GetReturnState(remainingGlobalContext));
+                    }
+                    if (next == null)
+                    {
+                        break;
+                    }
+                    System.Diagnostics.Debug.Assert(remainingGlobalContext != null);
+                    remainingGlobalContext = ((ParserRuleContext)remainingGlobalContext.Parent);
+                    s = next;
+                }
+            }
+            System.Diagnostics.Debug.Assert(!IsAcceptState(s, useContext));
+            if (IsAcceptState(s, useContext))
+            {
+                return new SimulatorState(previous.outerContext, s, useContext, remainingGlobalContext);
+            }
+            DFAState s0 = s;
+            DFAState target = GetExistingTargetState(s0, t);
+            if (target == null)
+            {
+                Tuple<DFAState, ParserRuleContext> result = ComputeTargetState(dfa, s0, remainingGlobalContext, t, useContext, contextCache);
+                target = result.Item1;
+                remainingGlobalContext = result.Item2;
+            }
+            if (target == Error)
+            {
+                return null;
+            }
+            System.Diagnostics.Debug.Assert(!useContext || !target.configs.DipsIntoOuterContext);
+            return new SimulatorState(previous.outerContext, target, useContext, remainingGlobalContext);
+        }
+
+        /// <summary>Get an existing target state for an edge in the DFA.</summary>
+        /// <remarks>
+        /// Get an existing target state for an edge in the DFA. If the target state
+        /// for the edge has not yet been computed or is otherwise not available,
+        /// this method returns
+        /// <see langword="null"/>
+        /// .
+        /// </remarks>
+        /// <param name="s">The current DFA state</param>
+        /// <param name="t">The next input symbol</param>
+        /// <returns>
+        /// The existing target DFA state for the given input symbol
+        /// <paramref name="t"/>
+        /// , or
+        /// <see langword="null"/>
+        /// if the target state for this edge is not
+        /// already cached
+        /// </returns>
+        [return: Nullable]
+        protected internal virtual DFAState GetExistingTargetState(DFAState s, int t)
+        {
+            return s.GetTarget(t);
+        }
+
+        /// <summary>
+        /// Compute a target state for an edge in the DFA, and attempt to add the
+        /// computed state and corresponding edge to the DFA.
+        /// </summary>
+        /// <remarks>
+        /// Compute a target state for an edge in the DFA, and attempt to add the
+        /// computed state and corresponding edge to the DFA.
+        /// </remarks>
+        /// <param name="dfa"/>
+        /// <param name="s">The current DFA state</param>
+        /// <param name="remainingGlobalContext"/>
+        /// <param name="t">The next input symbol</param>
+        /// <param name="useContext"/>
+        /// <param name="contextCache"/>
+        /// <returns>
+        /// The computed target DFA state for the given input symbol
+        /// <paramref name="t"/>
+        /// . If
+        /// <paramref name="t"/>
+        /// does not lead to a valid DFA state, this method
+        /// returns
+        /// <see cref="ATNSimulator.Error"/>
+        /// .
+        /// </returns>
+        [return: NotNull]
+        protected internal virtual Tuple<DFAState, ParserRuleContext> ComputeTargetState(DFA dfa, DFAState s, ParserRuleContext remainingGlobalContext, int t, bool useContext, PredictionContextCache contextCache)
+        {
+            IList<ATNConfig> closureConfigs = new List<ATNConfig>(s.configs);
+            List<int> contextElements = null;
+            ATNConfigSet reach = new ATNConfigSet();
+            bool stepIntoGlobal;
+            do
+            {
+                bool hasMoreContext = !useContext || remainingGlobalContext != null;
+                if (!hasMoreContext)
+                {
+                    reach.IsOutermostConfigSet = true;
+                }
+                ATNConfigSet reachIntermediate = new ATNConfigSet();
+                IList<ATNConfig> skippedStopStates = null;
+                foreach (ATNConfig c in closureConfigs)
+                {
+                    if (c.State is RuleStopState)
+                    {
+                        System.Diagnostics.Debug.Assert(c.Context.IsEmpty);
+                        if (useContext && !c.ReachesIntoOuterContext || t == IntStreamConstants.Eof)
+                        {
+                            if (skippedStopStates == null)
+                            {
+                                skippedStopStates = new List<ATNConfig>();
+                            }
+                            skippedStopStates.Add(c);
+                        }
+                        continue;
+                    }
+                    int n = c.State.NumberOfOptimizedTransitions;
+                    for (int ti = 0; ti < n; ti++)
+                    {
+                        // for each optimized transition
+                        Transition trans = c.State.GetOptimizedTransition(ti);
+                        ATNState target = GetReachableTarget(c, trans, t);
+                        if (target != null)
+                        {
+                            reachIntermediate.Add(c.Transform(target, false), contextCache);
+                        }
+                    }
+                }
+                if (optimize_unique_closure && skippedStopStates == null && t != TokenConstants.Eof && reachIntermediate.UniqueAlt != ATN.InvalidAltNumber)
+                {
+                    reachIntermediate.IsOutermostConfigSet = reach.IsOutermostConfigSet;
+                    reach = reachIntermediate;
+                    break;
+                }
+                bool collectPredicates = false;
+                bool treatEofAsEpsilon = t == TokenConstants.Eof;
+                Closure(reachIntermediate, reach, collectPredicates, hasMoreContext, contextCache, treatEofAsEpsilon);
+                stepIntoGlobal = reach.DipsIntoOuterContext;
+                if (t == IntStreamConstants.Eof)
+                {
+                    reach = RemoveAllConfigsNotInRuleStopState(reach, contextCache);
+                }
+                if (skippedStopStates != null && (!useContext || !Antlr4.Runtime.Atn.PredictionMode.HasConfigInRuleStopState(reach)))
+                {
+                    System.Diagnostics.Debug.Assert(skippedStopStates.Count > 0);
+                    foreach (ATNConfig c_1 in skippedStopStates)
+                    {
+                        reach.Add(c_1, contextCache);
+                    }
+                }
+                if (useContext && stepIntoGlobal)
+                {
+                    reach.Clear();
+                    remainingGlobalContext = SkipTailCalls(remainingGlobalContext);
+                    int nextContextElement = GetReturnState(remainingGlobalContext);
+                    if (contextElements == null)
+                    {
+                        contextElements = new List<int>();
+                    }
+                    if (remainingGlobalContext.IsEmpty)
+                    {
+                        remainingGlobalContext = null;
+                    }
+                    else
+                    {
+                        remainingGlobalContext = ((ParserRuleContext)remainingGlobalContext.Parent);
+                    }
+                    contextElements.Add(nextContextElement);
+                    if (nextContextElement != PredictionContext.EmptyFullStateKey)
+                    {
+                        for (int i = 0; i < closureConfigs.Count; i++)
+                        {
+                            closureConfigs[i] = closureConfigs[i].AppendContext(nextContextElement, contextCache);
+                        }
+                    }
+                }
+            }
+            while (useContext && stepIntoGlobal);
+            if (reach.IsEmpty())
+            {
+                AddDFAEdge(s, t, Error);
+                return Tuple.Create(Error, remainingGlobalContext);
+            }
+            DFAState result = AddDFAEdge(dfa, s, t, contextElements, reach, contextCache);
+            return Tuple.Create(result, remainingGlobalContext);
+        }
+
+        /// <summary>
+        /// Return a configuration set containing only the configurations from
+        /// <paramref name="configs"/>
+        /// which are in a
+        /// <see cref="RuleStopState"/>
+        /// . If all
+        /// configurations in
+        /// <paramref name="configs"/>
+        /// are already in a rule stop state, this
+        /// method simply returns
+        /// <paramref name="configs"/>
+        /// .
+        /// </summary>
+        /// <param name="configs">the configuration set to update</param>
+        /// <param name="contextCache">
+        /// the
+        /// <see cref="PredictionContext"/>
+        /// cache
+        /// </param>
+        /// <returns>
+        /// 
+        /// <paramref name="configs"/>
+        /// if all configurations in
+        /// <paramref name="configs"/>
+        /// are in a
+        /// rule stop state, otherwise return a new configuration set containing only
+        /// the configurations from
+        /// <paramref name="configs"/>
+        /// which are in a rule stop state
+        /// </returns>
+        [return: NotNull]
+        protected internal virtual ATNConfigSet RemoveAllConfigsNotInRuleStopState(ATNConfigSet configs, PredictionContextCache contextCache)
+        {
+            if (Antlr4.Runtime.Atn.PredictionMode.AllConfigsInRuleStopStates(configs))
+            {
+                return configs;
+            }
+            ATNConfigSet result = new ATNConfigSet();
+            foreach (ATNConfig config in configs)
+            {
+                if (!(config.State is RuleStopState))
+                {
+                    continue;
+                }
+                result.Add(config, contextCache);
+            }
+            return result;
+        }
+
+        [return: NotNull]
+        protected internal virtual SimulatorState ComputeStartState(DFA dfa, ParserRuleContext globalContext, bool useContext)
+        {
+            DFAState s0 = dfa.IsPrecedenceDfa ? dfa.GetPrecedenceStartState(_parser.Precedence, useContext) : useContext ? dfa.s0full.Get() : dfa.s0.Get();
+            if (s0 != null)
+            {
+                if (!useContext)
+                {
+                    return new SimulatorState(globalContext, s0, useContext, globalContext);
+                }
+                s0.SetContextSensitive(atn);
+            }
+            ATNState p = dfa.atnStartState;
+            int previousContext = 0;
+            ParserRuleContext remainingGlobalContext = globalContext;
+            PredictionContext initialContext = useContext ? PredictionContext.EmptyFull : PredictionContext.EmptyLocal;
+            // always at least the implicit call to start rule
+            PredictionContextCache contextCache = new PredictionContextCache();
+            if (useContext)
+            {
+                if (!enable_global_context_dfa)
+                {
+                    while (remainingGlobalContext != null)
+                    {
+                        if (remainingGlobalContext.IsEmpty)
+                        {
+                            previousContext = PredictionContext.EmptyFullStateKey;
+                            remainingGlobalContext = null;
+                        }
+                        else
+                        {
+                            previousContext = GetReturnState(remainingGlobalContext);
+                            initialContext = initialContext.AppendContext(previousContext, contextCache);
+                            remainingGlobalContext = ((ParserRuleContext)remainingGlobalContext.Parent);
+                        }
+                    }
+                }
+                while (s0 != null && s0.IsContextSensitive && remainingGlobalContext != null)
+                {
+                    DFAState next;
+                    remainingGlobalContext = SkipTailCalls(remainingGlobalContext);
+                    if (remainingGlobalContext.IsEmpty)
+                    {
+                        next = s0.GetContextTarget(PredictionContext.EmptyFullStateKey);
+                        previousContext = PredictionContext.EmptyFullStateKey;
+                        remainingGlobalContext = null;
+                    }
+                    else
+                    {
+                        previousContext = GetReturnState(remainingGlobalContext);
+                        next = s0.GetContextTarget(previousContext);
+                        initialContext = initialContext.AppendContext(previousContext, contextCache);
+                        remainingGlobalContext = ((ParserRuleContext)remainingGlobalContext.Parent);
+                    }
+                    if (next == null)
+                    {
+                        break;
+                    }
+                    s0 = next;
+                }
+            }
+            if (s0 != null && !s0.IsContextSensitive)
+            {
+                return new SimulatorState(globalContext, s0, useContext, remainingGlobalContext);
+            }
+            ATNConfigSet configs = new ATNConfigSet();
+            while (true)
+            {
+                ATNConfigSet reachIntermediate = new ATNConfigSet();
+                int n = p.NumberOfTransitions;
+                for (int ti = 0; ti < n; ti++)
+                {
+                    // for each transition
+                    ATNState target = p.Transition(ti).target;
+                    reachIntermediate.Add(ATNConfig.Create(target, ti + 1, initialContext));
+                }
+                bool hasMoreContext = remainingGlobalContext != null;
+                if (!hasMoreContext)
+                {
+                    configs.IsOutermostConfigSet = true;
+                }
+                if (!useContext || enable_global_context_dfa)
+                {
+                    if (!dfa.IsPrecedenceDfa && dfa.atnStartState is StarLoopEntryState)
+                    {
+                        if (((StarLoopEntryState)dfa.atnStartState).precedenceRuleDecision)
+                        {
+                            dfa.IsPrecedenceDfa = true;
+                        }
+                    }
+                }
+                bool collectPredicates = true;
+                Closure(reachIntermediate, configs, collectPredicates, hasMoreContext, contextCache, false);
+                bool stepIntoGlobal = configs.DipsIntoOuterContext;
+                DFAState next;
+                if (useContext && !enable_global_context_dfa)
+                {
+                    s0 = AddDFAState(dfa, configs, contextCache);
+                    break;
+                }
+                else
+                {
+                    if (s0 == null)
+                    {
+                        if (!dfa.IsPrecedenceDfa)
+                        {
+                            AtomicReference<DFAState> reference = useContext ? dfa.s0full : dfa.s0;
+                            next = AddDFAState(dfa, configs, contextCache);
+                            if (!reference.CompareAndSet(null, next))
+                            {
+                                next = reference.Get();
+                            }
+                        }
+                        else
+                        {
+                            configs = ApplyPrecedenceFilter(configs, globalContext, contextCache);
+                            next = AddDFAState(dfa, configs, contextCache);
+                            dfa.SetPrecedenceStartState(_parser.Precedence, useContext, next);
+                        }
+                    }
+                    else
+                    {
+                        if (dfa.IsPrecedenceDfa)
+                        {
+                            configs = ApplyPrecedenceFilter(configs, globalContext, contextCache);
+                        }
+                        next = AddDFAState(dfa, configs, contextCache);
+                        s0.SetContextTarget(previousContext, next);
+                    }
+                }
+                s0 = next;
+                if (!useContext || !stepIntoGlobal)
+                {
+                    break;
+                }
+                // TODO: make sure it distinguishes empty stack states
+                next.SetContextSensitive(atn);
+                configs.Clear();
+                remainingGlobalContext = SkipTailCalls(remainingGlobalContext);
+                int nextContextElement = GetReturnState(remainingGlobalContext);
+                if (remainingGlobalContext.IsEmpty)
+                {
+                    remainingGlobalContext = null;
+                }
+                else
+                {
+                    remainingGlobalContext = ((ParserRuleContext)remainingGlobalContext.Parent);
+                }
+                if (nextContextElement != PredictionContext.EmptyFullStateKey)
+                {
+                    initialContext = initialContext.AppendContext(nextContextElement, contextCache);
+                }
+                previousContext = nextContextElement;
+            }
+            return new SimulatorState(globalContext, s0, useContext, remainingGlobalContext);
+        }
+
+        /// <summary>
+        /// This method transforms the start state computed by
+        /// <see cref="ComputeStartState(Antlr4.Runtime.Dfa.DFA, Antlr4.Runtime.ParserRuleContext, bool)"/>
+        /// to the special start state used by a
+        /// precedence DFA for a particular precedence value. The transformation
+        /// process applies the following changes to the start state's configuration
+        /// set.
+        /// <ol>
+        /// <li>Evaluate the precedence predicates for each configuration using
+        /// <see cref="SemanticContext.EvalPrecedence{Symbol, ATNInterpreter}(Antlr4.Runtime.Recognizer{Symbol, ATNInterpreter}, Antlr4.Runtime.RuleContext)"/>
+        /// .</li>
+        /// <li>When
+        /// <see cref="ATNConfig.PrecedenceFilterSuppressed()"/>
+        /// is
+        /// <see langword="false"/>
+        /// ,
+        /// remove all configurations which predict an alternative greater than 1,
+        /// for which another configuration that predicts alternative 1 is in the
+        /// same ATN state with the same prediction context. This transformation is
+        /// valid for the following reasons:
+        /// <ul>
+        /// <li>The closure block cannot contain any epsilon transitions which bypass
+        /// the body of the closure, so all states reachable via alternative 1 are
+        /// part of the precedence alternatives of the transformed left-recursive
+        /// rule.</li>
+        /// <li>The "primary" portion of a left recursive rule cannot contain an
+        /// epsilon transition, so the only way an alternative other than 1 can exist
+        /// in a state that is also reachable via alternative 1 is by nesting calls
+        /// to the left-recursive rule, with the outer calls not being at the
+        /// preferred precedence level. The
+        /// <see cref="ATNConfig.PrecedenceFilterSuppressed()"/>
+        /// property marks ATN
+        /// configurations which do not meet this condition, and therefore are not
+        /// eligible for elimination during the filtering process.</li>
+        /// </ul>
+        /// </li>
+        /// </ol>
+        /// <p>
+        /// The prediction context must be considered by this filter to address
+        /// situations like the following.
+        /// </p>
+        /// <code>
+        /// <pre>
+        /// grammar TA;
+        /// prog: statement* EOF;
+        /// statement: letterA | statement letterA 'b' ;
+        /// letterA: 'a';
+        /// </pre>
+        /// </code>
+        /// <p>
+        /// If the above grammar, the ATN state immediately before the token
+        /// reference
+        /// <c>'a'</c>
+        /// in
+        /// <c>letterA</c>
+        /// is reachable from the left edge
+        /// of both the primary and closure blocks of the left-recursive rule
+        /// <c>statement</c>
+        /// . The prediction context associated with each of these
+        /// configurations distinguishes between them, and prevents the alternative
+        /// which stepped out to
+        /// <c>prog</c>
+        /// (and then back in to
+        /// <c>statement</c>
+        /// from being eliminated by the filter.
+        /// </p>
+        /// </summary>
+        /// <param name="configs">
+        /// The configuration set computed by
+        /// <see cref="ComputeStartState(Antlr4.Runtime.Dfa.DFA, Antlr4.Runtime.ParserRuleContext, bool)"/>
+        /// as the start state for the DFA.
+        /// </param>
+		/// <param name="globalContext">
+		/// </param>
+		/// <param name="contextCache">
+		/// </param>
+        /// <returns>
+        /// The transformed configuration set representing the start state
+        /// for a precedence DFA at a particular precedence level (determined by
+        /// calling
+        /// <see cref="Antlr4.Runtime.Parser.Precedence()"/>
+        /// ).
+        /// </returns>
+        [return: NotNull]
+        protected internal virtual ATNConfigSet ApplyPrecedenceFilter(ATNConfigSet configs, ParserRuleContext globalContext, PredictionContextCache contextCache)
+        {
+            Dictionary<int, PredictionContext> statesFromAlt1 = new Dictionary<int, PredictionContext>();
+            ATNConfigSet configSet = new ATNConfigSet();
+            foreach (ATNConfig config in configs)
+            {
+                // handle alt 1 first
+                if (config.Alt != 1)
+                {
+                    continue;
+                }
+                SemanticContext updatedContext = config.SemanticContext.EvalPrecedence(_parser, globalContext);
+                if (updatedContext == null)
+                {
+                    // the configuration was eliminated
+                    continue;
+                }
+                statesFromAlt1[config.State.stateNumber] = config.Context;
+                if (updatedContext != config.SemanticContext)
+                {
+                    configSet.Add(config.Transform(config.State, updatedContext, false), contextCache);
+                }
+                else
+                {
+                    configSet.Add(config, contextCache);
+                }
+            }
+            foreach (ATNConfig config_1 in configs)
+            {
+                if (config_1.Alt == 1)
+                {
+                    // already handled
+                    continue;
+                }
+				if (!config_1.PrecedenceFilterSuppressed)
+				{
+	                PredictionContext context;
+	                if (statesFromAlt1.TryGetValue(config_1.State.stateNumber, out context) && context.Equals(config_1.Context))
+	                {
+	                    // eliminated
+	                    continue;
+	                }
+				}
+                configSet.Add(config_1, contextCache);
+            }
+            return configSet;
+        }
+
+        [return: Nullable]
+        protected internal virtual ATNState GetReachableTarget(ATNConfig source, Transition trans, int ttype)
+        {
+            if (trans.Matches(ttype, 0, atn.maxTokenType))
+            {
+                return trans.target;
+            }
+            return null;
+        }
+
+        /// <summary>collect and set D's semantic context</summary>
+        protected internal virtual DFAState.PredPrediction[] PredicateDFAState(DFAState D, ATNConfigSet configs, int nalts)
+        {
+            BitSet conflictingAlts = GetConflictingAltsFromConfigSet(configs);
+            SemanticContext[] altToPred = GetPredsForAmbigAlts(conflictingAlts, configs, nalts);
+            // altToPred[uniqueAlt] is now our validating predicate (if any)
+            DFAState.PredPrediction[] predPredictions = null;
+            if (altToPred != null)
+            {
+                // we have a validating predicate; test it
+                // Update DFA so reach becomes accept state with predicate
+                predPredictions = GetPredicatePredictions(conflictingAlts, altToPred);
+                D.predicates = predPredictions;
+            }
+            return predPredictions;
+        }
+
+        protected internal virtual SemanticContext[] GetPredsForAmbigAlts(BitSet ambigAlts, ATNConfigSet configs, int nalts)
+        {
+            // REACH=[1|1|[]|0:0, 1|2|[]|0:1]
+            SemanticContext[] altToPred = new SemanticContext[nalts + 1];
+            int n = altToPred.Length;
+            foreach (ATNConfig c in configs)
+            {
+                if (ambigAlts.Get(c.Alt))
+                {
+                    altToPred[c.Alt] = SemanticContext.OrOp(altToPred[c.Alt], c.SemanticContext);
+                }
+            }
+            int nPredAlts = 0;
+            for (int i = 0; i < n; i++)
+            {
+                if (altToPred[i] == null)
+                {
+                    altToPred[i] = SemanticContext.None;
+                }
+                else
+                {
+                    if (altToPred[i] != SemanticContext.None)
+                    {
+                        nPredAlts++;
+                    }
+                }
+            }
+            // nonambig alts are null in altToPred
+            if (nPredAlts == 0)
+            {
+                altToPred = null;
+            }
+            return altToPred;
+        }
+
+        protected internal virtual DFAState.PredPrediction[] GetPredicatePredictions(BitSet ambigAlts, SemanticContext[] altToPred)
+        {
+            List<DFAState.PredPrediction> pairs = new List<DFAState.PredPrediction>();
+            bool containsPredicate = false;
+            for (int i = 1; i < altToPred.Length; i++)
+            {
+                SemanticContext pred = altToPred[i];
+                // unpredicated is indicated by SemanticContext.NONE
+                System.Diagnostics.Debug.Assert(pred != null);
+                // find first unpredicated but ambig alternative, if any.
+                // Only ambiguous alternatives will have SemanticContext.NONE.
+                // Any unambig alts or ambig naked alts after first ambig naked are ignored
+                // (null, i) means alt i is the default prediction
+                // if no (null, i), then no default prediction.
+                if (ambigAlts != null && ambigAlts.Get(i) && pred == SemanticContext.None)
+                {
+                    pairs.Add(new DFAState.PredPrediction(pred, i));
+                }
+                else
+                {
+                    if (pred != SemanticContext.None)
+                    {
+                        containsPredicate = true;
+                        pairs.Add(new DFAState.PredPrediction(pred, i));
+                    }
+                }
+            }
+            if (!containsPredicate)
+            {
+                return null;
+            }
+            //		System.out.println(Arrays.toString(altToPred)+"->"+pairs);
+            return pairs.ToArray();
+        }
+
+        /// <summary>
+        /// Look through a list of predicate/alt pairs, returning alts for the
+        /// pairs that win.
+        /// </summary>
+        /// <remarks>
+        /// Look through a list of predicate/alt pairs, returning alts for the
+        /// pairs that win. A
+        /// <see langword="null"/>
+        /// predicate indicates an alt containing an
+        /// unpredicated config which behaves as "always true."
+        /// </remarks>
+        protected internal virtual BitSet EvalSemanticContext(DFAState.PredPrediction[] predPredictions, ParserRuleContext outerContext, bool complete)
+        {
+            BitSet predictions = new BitSet();
+            foreach (DFAState.PredPrediction pair in predPredictions)
+            {
+                if (pair.pred == SemanticContext.None)
+                {
+                    predictions.Set(pair.alt);
+                    if (!complete)
+                    {
+                        break;
+                    }
+                    continue;
+                }
+                bool evaluatedResult = EvalSemanticContext(pair.pred, outerContext, pair.alt);
+#if !PORTABLE
+				#pragma warning disable 162, 429
+				if (debug || dfa_debug)
+                {
+                    System.Console.Out.WriteLine("eval pred " + pair + "=" + evaluatedResult);
+                }
+				#pragma warning restore 162, 429
+#endif
+                if (evaluatedResult)
+                {
+#if !PORTABLE
+					#pragma warning disable 162, 429
+					if (debug || dfa_debug)
+                    {
+                        System.Console.Out.WriteLine("PREDICT " + pair.alt);
+                    }
+					#pragma warning restore 162, 429
+#endif
+                    predictions.Set(pair.alt);
+                    if (!complete)
+                    {
+                        break;
+                    }
+                }
+            }
+            return predictions;
+        }
+
+        /// <summary>Evaluate a semantic context within a specific parser context.</summary>
+        /// <remarks>
+        /// Evaluate a semantic context within a specific parser context.
+        /// <p>
+        /// This method might not be called for every semantic context evaluated
+        /// during the prediction process. In particular, we currently do not
+        /// evaluate the following but it may change in the future:</p>
+        /// <ul>
+        /// <li>Precedence predicates (represented by
+        /// <see cref="SemanticContext.PrecedencePredicate"/>
+        /// ) are not currently evaluated
+        /// through this method.</li>
+        /// <li>Operator predicates (represented by
+        /// <see cref="SemanticContext.AND"/>
+        /// and
+        /// <see cref="SemanticContext.OR"/>
+        /// ) are evaluated as a single semantic
+        /// context, rather than evaluating the operands individually.
+        /// Implementations which require evaluation results from individual
+        /// predicates should override this method to explicitly handle evaluation of
+        /// the operands within operator predicates.</li>
+        /// </ul>
+        /// </remarks>
+        /// <param name="pred">The semantic context to evaluate</param>
+        /// <param name="parserCallStack">
+        /// The parser context in which to evaluate the
+        /// semantic context
+        /// </param>
+        /// <param name="alt">
+        /// The alternative which is guarded by
+        /// <paramref name="pred"/>
+        /// </param>
+        /// <since>4.3</since>
+        protected internal virtual bool EvalSemanticContext(SemanticContext pred, ParserRuleContext parserCallStack, int alt)
+        {
+            return pred.Eval(_parser, parserCallStack);
+        }
+
+        protected internal virtual void Closure(ATNConfigSet sourceConfigs, ATNConfigSet configs, bool collectPredicates, bool hasMoreContext, PredictionContextCache contextCache, bool treatEofAsEpsilon)
+        {
+            if (contextCache == null)
+            {
+                contextCache = PredictionContextCache.Uncached;
+            }
+            ATNConfigSet currentConfigs = sourceConfigs;
+            HashSet<ATNConfig> closureBusy = new HashSet<ATNConfig>();
+            while (currentConfigs.Count > 0)
+            {
+                ATNConfigSet intermediate = new ATNConfigSet();
+                foreach (ATNConfig config in currentConfigs)
+                {
+                    Closure(config, configs, intermediate, closureBusy, collectPredicates, hasMoreContext, contextCache, 0, treatEofAsEpsilon);
+                }
+                currentConfigs = intermediate;
+            }
+        }
+
+        protected internal virtual void Closure(ATNConfig config, ATNConfigSet configs, ATNConfigSet intermediate, HashSet<ATNConfig> closureBusy, bool collectPredicates, bool hasMoreContexts, PredictionContextCache contextCache, int depth, bool treatEofAsEpsilon)
+        {
+            if (config.State is RuleStopState)
+            {
+                // We hit rule end. If we have context info, use it
+                if (!config.Context.IsEmpty)
+                {
+                    bool hasEmpty = config.Context.HasEmpty;
+                    int nonEmptySize = config.Context.Size - (hasEmpty ? 1 : 0);
+                    for (int i = 0; i < nonEmptySize; i++)
+                    {
+                        PredictionContext newContext = config.Context.GetParent(i);
+                        // "pop" return state
+                        ATNState returnState = atn.states[config.Context.GetReturnState(i)];
+                        ATNConfig c = ATNConfig.Create(returnState, config.Alt, newContext, config.SemanticContext);
+                        // While we have context to pop back from, we may have
+                        // gotten that context AFTER having fallen off a rule.
+                        // Make sure we track that we are now out of context.
+                        c.OuterContextDepth = config.OuterContextDepth;
+                        c.PrecedenceFilterSuppressed = config.PrecedenceFilterSuppressed;
+                        System.Diagnostics.Debug.Assert(depth > int.MinValue);
+                        Closure(c, configs, intermediate, closureBusy, collectPredicates, hasMoreContexts, contextCache, depth - 1, treatEofAsEpsilon);
+                    }
+                    if (!hasEmpty || !hasMoreContexts)
+                    {
+                        return;
+                    }
+                    config = config.Transform(config.State, PredictionContext.EmptyLocal, false);
+                }
+                else
+                {
+                    if (!hasMoreContexts)
+                    {
+                        configs.Add(config, contextCache);
+                        return;
+                    }
+                    else
+                    {
+                        // else if we have no context info, just chase follow links (if greedy)
+                        if (config.Context == PredictionContext.EmptyFull)
+                        {
+                            // no need to keep full context overhead when we step out
+                            config = config.Transform(config.State, PredictionContext.EmptyLocal, false);
+                        }
+                        else
+                        {
+                            if (!config.ReachesIntoOuterContext && PredictionContext.IsEmptyLocal(config.Context))
+                            {
+                                // add stop state when leaving decision rule for the first time
+                                configs.Add(config, contextCache);
+                            }
+                        }
+                    }
+                }
+            }
+            ATNState p = config.State;
+            // optimization
+            if (!p.OnlyHasEpsilonTransitions)
+            {
+                configs.Add(config, contextCache);
+            }
+            // make sure to not return here, because EOF transitions can act as
+            // both epsilon transitions and non-epsilon transitions.
+            for (int i_1 = 0; i_1 < p.NumberOfOptimizedTransitions; i_1++)
+            {
+                Transition t = p.GetOptimizedTransition(i_1);
+                bool continueCollecting = !(t is Antlr4.Runtime.Atn.ActionTransition) && collectPredicates;
+                ATNConfig c = GetEpsilonTarget(config, t, continueCollecting, depth == 0, contextCache, treatEofAsEpsilon);
+                if (c != null)
+                {
+                    if (t is Antlr4.Runtime.Atn.RuleTransition)
+                    {
+                        if (intermediate != null && !collectPredicates)
+                        {
+                            intermediate.Add(c, contextCache);
+                            continue;
+                        }
+                    }
+                    if (!t.IsEpsilon && !closureBusy.Add(c))
+                    {
+                        // avoid infinite recursion for EOF* and EOF+
+                        continue;
+                    }
+                    int newDepth = depth;
+                    if (config.State is RuleStopState)
+                    {
+                        // target fell off end of rule; mark resulting c as having dipped into outer context
+                        // We can't get here if incoming config was rule stop and we had context
+                        // track how far we dip into outer context.  Might
+                        // come in handy and we avoid evaluating context dependent
+                        // preds if this is > 0.
+                        if (!closureBusy.Add(c))
+                        {
+                            // avoid infinite recursion for right-recursive rules
+                            continue;
+                        }
+                        if (dfa != null && dfa.IsPrecedenceDfa)
+                        {
+                            int outermostPrecedenceReturn = ((EpsilonTransition)t).OutermostPrecedenceReturn;
+                            if (outermostPrecedenceReturn == dfa.atnStartState.ruleIndex)
+                            {
+                                c.PrecedenceFilterSuppressed = true;
+                            }
+                        }
+                        c.OuterContextDepth = c.OuterContextDepth + 1;
+                        System.Diagnostics.Debug.Assert(newDepth > int.MinValue);
+                        newDepth--;
+                    }
+                    else
+                    {
+                        if (t is Antlr4.Runtime.Atn.RuleTransition)
+                        {
+                            if (optimize_tail_calls && ((Antlr4.Runtime.Atn.RuleTransition)t).optimizedTailCall && (!tail_call_preserves_sll || !PredictionContext.IsEmptyLocal(config.Context)))
+                            {
+                                System.Diagnostics.Debug.Assert(c.Context == config.Context);
+                                if (newDepth == 0)
+                                {
+                                    // the pop/push of a tail call would keep the depth
+                                    // constant, except we latch if it goes negative
+                                    newDepth--;
+                                    if (!tail_call_preserves_sll && PredictionContext.IsEmptyLocal(config.Context))
+                                    {
+                                        // make sure the SLL config "dips into the outer context" or prediction may not fall back to LL on conflict
+                                        c.OuterContextDepth = c.OuterContextDepth + 1;
+                                    }
+                                }
+                            }
+                            else
+                            {
+                                // latch when newDepth goes negative - once we step out of the entry context we can't return
+                                if (newDepth >= 0)
+                                {
+                                    newDepth++;
+                                }
+                            }
+                        }
+                    }
+                    Closure(c, configs, intermediate, closureBusy, continueCollecting, hasMoreContexts, contextCache, newDepth, treatEofAsEpsilon);
+                }
+            }
+        }
+
+        [return: NotNull]
+        public virtual string GetRuleName(int index)
+        {
+            if (_parser != null && index >= 0)
+            {
+                return _parser.RuleNames[index];
+            }
+            return "<rule " + index + ">";
+        }
+
+        [return: Nullable]
+        protected internal virtual ATNConfig GetEpsilonTarget(ATNConfig config, Transition t, bool collectPredicates, bool inContext, PredictionContextCache contextCache, bool treatEofAsEpsilon)
+        {
+            switch (t.TransitionType)
+            {
+                case TransitionType.Rule:
+                {
+                    return RuleTransition(config, (Antlr4.Runtime.Atn.RuleTransition)t, contextCache);
+                }
+
+                case TransitionType.Precedence:
+                {
+                    return PrecedenceTransition(config, (PrecedencePredicateTransition)t, collectPredicates, inContext);
+                }
+
+                case TransitionType.Predicate:
+                {
+                    return PredTransition(config, (PredicateTransition)t, collectPredicates, inContext);
+                }
+
+                case TransitionType.Action:
+                {
+                    return ActionTransition(config, (Antlr4.Runtime.Atn.ActionTransition)t);
+                }
+
+                case TransitionType.Epsilon:
+                {
+                    return config.Transform(t.target, false);
+                }
+
+                case TransitionType.Atom:
+                case TransitionType.Range:
+                case TransitionType.Set:
+                {
+                    // EOF transitions act like epsilon transitions after the first EOF
+                    // transition is traversed
+                    if (treatEofAsEpsilon)
+                    {
+                        if (t.Matches(TokenConstants.Eof, 0, 1))
+                        {
+                            return config.Transform(t.target, false);
+                        }
+                    }
+                    return null;
+                }
+
+                default:
+                {
+                    return null;
+                }
+            }
+        }
+
+        [return: NotNull]
+        protected internal virtual ATNConfig ActionTransition(ATNConfig config, Antlr4.Runtime.Atn.ActionTransition t)
+        {
+            return config.Transform(t.target, false);
+        }
+
+        [return: Nullable]
+        protected internal virtual ATNConfig PrecedenceTransition(ATNConfig config, PrecedencePredicateTransition pt, bool collectPredicates, bool inContext)
+        {
+            ATNConfig c;
+            if (collectPredicates && inContext)
+            {
+                SemanticContext newSemCtx = SemanticContext.AndOp(config.SemanticContext, pt.Predicate);
+                c = config.Transform(pt.target, newSemCtx, false);
+            }
+            else
+            {
+                c = config.Transform(pt.target, false);
+            }
+            return c;
+        }
+
+        [return: Nullable]
+        protected internal virtual ATNConfig PredTransition(ATNConfig config, PredicateTransition pt, bool collectPredicates, bool inContext)
+        {
+            ATNConfig c;
+            if (collectPredicates && (!pt.isCtxDependent || (pt.isCtxDependent && inContext)))
+            {
+                SemanticContext newSemCtx = SemanticContext.AndOp(config.SemanticContext, pt.Predicate);
+                c = config.Transform(pt.target, newSemCtx, false);
+            }
+            else
+            {
+                c = config.Transform(pt.target, false);
+            }
+            return c;
+        }
+
+        [return: NotNull]
+        protected internal virtual ATNConfig RuleTransition(ATNConfig config, Antlr4.Runtime.Atn.RuleTransition t, PredictionContextCache contextCache)
+        {
+            ATNState returnState = t.followState;
+            PredictionContext newContext;
+            if (optimize_tail_calls && t.optimizedTailCall && (!tail_call_preserves_sll || !PredictionContext.IsEmptyLocal(config.Context)))
+            {
+                newContext = config.Context;
+            }
+            else
+            {
+                if (contextCache != null)
+                {
+                    newContext = contextCache.GetChild(config.Context, returnState.stateNumber);
+                }
+                else
+                {
+                    newContext = config.Context.GetChild(returnState.stateNumber);
+                }
+            }
+            return config.Transform(t.target, newContext, false);
+        }
+
+        private sealed class _IComparer_1996 : IComparer<ATNConfig>
+        {
+            public _IComparer_1996()
+            {
+            }
+
+            public int Compare(ATNConfig o1, ATNConfig o2)
+            {
+                int diff = o1.State.NonStopStateNumber - o2.State.NonStopStateNumber;
+                if (diff != 0)
+                {
+                    return diff;
+                }
+                diff = o1.Alt - o2.Alt;
+                if (diff != 0)
+                {
+                    return diff;
+                }
+                return 0;
+            }
+        }
+
+        private static readonly IComparer<ATNConfig> StateAltSortComparator = new _IComparer_1996();
+
+        private ConflictInfo IsConflicted(ATNConfigSet configset, PredictionContextCache contextCache)
+        {
+            if (configset.UniqueAlt != ATN.InvalidAltNumber || configset.Count <= 1)
+            {
+                return null;
+            }
+            List<ATNConfig> configs = new List<ATNConfig>(configset);
+            configs.Sort(StateAltSortComparator);
+            bool exact = !configset.DipsIntoOuterContext;
+            BitSet alts = new BitSet();
+            int minAlt = configs[0].Alt;
+            alts.Set(minAlt);
+            // quick check 1 & 2 => if we assume #1 holds and check #2 against the
+            // minAlt from the first state, #2 will fail if the assumption was
+            // incorrect
+            int currentState = configs[0].State.NonStopStateNumber;
+            foreach (ATNConfig config in configs)
+            {
+                int stateNumber = config.State.NonStopStateNumber;
+                if (stateNumber != currentState)
+                {
+                    if (config.Alt != minAlt)
+                    {
+                        return null;
+                    }
+                    currentState = stateNumber;
+                }
+            }
+            BitSet representedAlts;
+            if (exact)
+            {
+                currentState = configs[0].State.NonStopStateNumber;
+                // get the represented alternatives of the first state
+                representedAlts = new BitSet();
+                int maxAlt = minAlt;
+                foreach (ATNConfig config_1 in configs)
+                {
+                    if (config_1.State.NonStopStateNumber != currentState)
+                    {
+                        break;
+                    }
+                    int alt = config_1.Alt;
+                    representedAlts.Set(alt);
+                    maxAlt = alt;
+                }
+                // quick check #3:
+                currentState = configs[0].State.NonStopStateNumber;
+                int currentAlt = minAlt;
+                foreach (ATNConfig config_2 in configs)
+                {
+                    int stateNumber = config_2.State.NonStopStateNumber;
+                    int alt = config_2.Alt;
+                    if (stateNumber != currentState)
+                    {
+                        if (currentAlt != maxAlt)
+                        {
+                            exact = false;
+                            break;
+                        }
+                        currentState = stateNumber;
+                        currentAlt = minAlt;
+                    }
+                    else
+                    {
+                        if (alt != currentAlt)
+                        {
+                            if (alt != representedAlts.NextSetBit(currentAlt + 1))
+                            {
+                                exact = false;
+                                break;
+                            }
+                            currentAlt = alt;
+                        }
+                    }
+                }
+            }
+            currentState = configs[0].State.NonStopStateNumber;
+            int firstIndexCurrentState = 0;
+            int lastIndexCurrentStateMinAlt = 0;
+            PredictionContext joinedCheckContext = configs[0].Context;
+            for (int i = 1; i < configs.Count; i++)
+            {
+                ATNConfig config_1 = configs[i];
+                if (config_1.Alt != minAlt)
+                {
+                    break;
+                }
+                if (config_1.State.NonStopStateNumber != currentState)
+                {
+                    break;
+                }
+                lastIndexCurrentStateMinAlt = i;
+                joinedCheckContext = contextCache.Join(joinedCheckContext, configs[i].Context);
+            }
+            for (int i_1 = lastIndexCurrentStateMinAlt + 1; i_1 < configs.Count; i_1++)
+            {
+                ATNConfig config_1 = configs[i_1];
+                ATNState state = config_1.State;
+                alts.Set(config_1.Alt);
+                if (state.NonStopStateNumber != currentState)
+                {
+                    currentState = state.NonStopStateNumber;
+                    firstIndexCurrentState = i_1;
+                    lastIndexCurrentStateMinAlt = i_1;
+                    joinedCheckContext = config_1.Context;
+                    for (int j = firstIndexCurrentState + 1; j < configs.Count; j++)
+                    {
+                        ATNConfig config2 = configs[j];
+                        if (config2.Alt != minAlt)
+                        {
+                            break;
+                        }
+                        if (config2.State.NonStopStateNumber != currentState)
+                        {
+                            break;
+                        }
+                        lastIndexCurrentStateMinAlt = j;
+                        joinedCheckContext = contextCache.Join(joinedCheckContext, config2.Context);
+                    }
+                    i_1 = lastIndexCurrentStateMinAlt;
+                    continue;
+                }
+                PredictionContext joinedCheckContext2 = config_1.Context;
+                int currentAlt = config_1.Alt;
+                int lastIndexCurrentStateCurrentAlt = i_1;
+                for (int j_1 = lastIndexCurrentStateCurrentAlt + 1; j_1 < configs.Count; j_1++)
+                {
+                    ATNConfig config2 = configs[j_1];
+                    if (config2.Alt != currentAlt)
+                    {
+                        break;
+                    }
+                    if (config2.State.NonStopStateNumber != currentState)
+                    {
+                        break;
+                    }
+                    lastIndexCurrentStateCurrentAlt = j_1;
+                    joinedCheckContext2 = contextCache.Join(joinedCheckContext2, config2.Context);
+                }
+                i_1 = lastIndexCurrentStateCurrentAlt;
+                PredictionContext check = contextCache.Join(joinedCheckContext, joinedCheckContext2);
+                if (!joinedCheckContext.Equals(check))
+                {
+                    return null;
+                }
+                // update exact if necessary
+                exact = exact && joinedCheckContext.Equals(joinedCheckContext2);
+            }
+            return new ConflictInfo(alts, exact);
+        }
+
+        protected internal virtual BitSet GetConflictingAltsFromConfigSet(ATNConfigSet configs)
+        {
+            BitSet conflictingAlts = configs.ConflictingAlts;
+            if (conflictingAlts == null && configs.UniqueAlt != ATN.InvalidAltNumber)
+            {
+                conflictingAlts = new BitSet();
+                conflictingAlts.Set(configs.UniqueAlt);
+            }
+            return conflictingAlts;
+        }
+
+        [return: NotNull]
+        public virtual string GetTokenName(int t)
+        {
+            if (t == TokenConstants.Eof)
+            {
+                return "EOF";
+            }
+            IVocabulary vocabulary = _parser != null ? _parser.Vocabulary : Vocabulary.EmptyVocabulary;
+            string displayName = vocabulary.GetDisplayName(t);
+            if (displayName.Equals(t.ToString(), StringComparison.Ordinal))
+            {
+                return displayName;
+            }
+            return displayName + "<" + t + ">";
+        }
+
+        public virtual string GetLookaheadName(ITokenStream input)
+        {
+            return GetTokenName(input.La(1));
+        }
+
+#if !PORTABLE
+        public virtual void DumpDeadEndConfigs(NoViableAltException nvae)
+        {
+            System.Console.Error.WriteLine("dead end configs: ");
+            foreach (ATNConfig c in nvae.DeadEndConfigs)
+            {
+                string trans = "no edges";
+                if (c.State.NumberOfOptimizedTransitions > 0)
+                {
+                    Transition t = c.State.GetOptimizedTransition(0);
+                    if (t is AtomTransition)
+                    {
+                        AtomTransition at = (AtomTransition)t;
+						trans = "Atom " + GetTokenName(at.token);
+                    }
+                    else
+                    {
+                        if (t is SetTransition)
+                        {
+                            SetTransition st = (SetTransition)t;
+                            bool not = st is NotSetTransition;
+                            trans = (not ? "~" : string.Empty) + "Set " + st.set.ToString();
+                        }
+                    }
+                }
+                System.Console.Error.WriteLine(c.ToString(_parser, true) + ":" + trans);
+            }
+        }
+#endif
+
+        [return: NotNull]
+        protected internal virtual NoViableAltException NoViableAlt(ITokenStream input, ParserRuleContext outerContext, ATNConfigSet configs, int startIndex)
+        {
+            return new NoViableAltException(_parser, input, input.Get(startIndex), input.Lt(1), configs, outerContext);
+        }
+
+        protected internal virtual int GetUniqueAlt(IEnumerable<ATNConfig> configs)
+        {
+            int alt = ATN.InvalidAltNumber;
+            foreach (ATNConfig c in configs)
+            {
+                if (alt == ATN.InvalidAltNumber)
+                {
+                    alt = c.Alt;
+                }
+                else
+                {
+                    // found first alt
+                    if (c.Alt != alt)
+                    {
+                        return ATN.InvalidAltNumber;
+                    }
+                }
+            }
+            return alt;
+        }
+
+        protected internal virtual bool ConfigWithAltAtStopState(IEnumerable<ATNConfig> configs, int alt)
+        {
+            foreach (ATNConfig c in configs)
+            {
+                if (c.Alt == alt)
+                {
+                    if (c.State is RuleStopState)
+                    {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        }
+
+        [return: NotNull]
+        protected internal virtual DFAState AddDFAEdge(DFA dfa, DFAState fromState, int t, List<int> contextTransitions, ATNConfigSet toConfigs, PredictionContextCache contextCache)
+        {
+            System.Diagnostics.Debug.Assert(contextTransitions == null || contextTransitions.Count == 0 || dfa.IsContextSensitive);
+            DFAState from = fromState;
+            DFAState to = AddDFAState(dfa, toConfigs, contextCache);
+            if (contextTransitions != null)
+            {
+                foreach (int context in contextTransitions.ToArray())
+                {
+                    if (context == PredictionContext.EmptyFullStateKey)
+                    {
+                        if (from.configs.IsOutermostConfigSet)
+                        {
+                            continue;
+                        }
+                    }
+                    from.SetContextSensitive(atn);
+                    from.SetContextSymbol(t);
+                    DFAState next = from.GetContextTarget(context);
+                    if (next != null)
+                    {
+                        from = next;
+                        continue;
+                    }
+                    next = AddDFAContextState(dfa, from.configs, context, contextCache);
+                    System.Diagnostics.Debug.Assert(context != PredictionContext.EmptyFullStateKey || next.configs.IsOutermostConfigSet);
+                    from.SetContextTarget(context, next);
+                    from = next;
+                }
+            }
+            AddDFAEdge(from, t, to);
+            return to;
+        }
+
+        protected internal virtual void AddDFAEdge(DFAState p, int t, DFAState q)
+        {
+            if (p != null)
+            {
+                p.SetTarget(t, q);
+            }
+        }
+
+        /// <summary>See comment on LexerInterpreter.addDFAState.</summary>
+        /// <remarks>See comment on LexerInterpreter.addDFAState.</remarks>
+        [return: NotNull]
+        protected internal virtual DFAState AddDFAContextState(DFA dfa, ATNConfigSet configs, int returnContext, PredictionContextCache contextCache)
+        {
+            if (returnContext != PredictionContext.EmptyFullStateKey)
+            {
+                ATNConfigSet contextConfigs = new ATNConfigSet();
+                foreach (ATNConfig config in configs)
+                {
+                    contextConfigs.Add(config.AppendContext(returnContext, contextCache));
+                }
+                return AddDFAState(dfa, contextConfigs, contextCache);
+            }
+            else
+            {
+                System.Diagnostics.Debug.Assert(!configs.IsOutermostConfigSet, "Shouldn't be adding a duplicate edge.");
+                configs = configs.Clone(true);
+                configs.IsOutermostConfigSet = true;
+                return AddDFAState(dfa, configs, contextCache);
+            }
+        }
+
+        /// <summary>See comment on LexerInterpreter.addDFAState.</summary>
+        /// <remarks>See comment on LexerInterpreter.addDFAState.</remarks>
+        [return: NotNull]
+        protected internal virtual DFAState AddDFAState(DFA dfa, ATNConfigSet configs, PredictionContextCache contextCache)
+        {
+            bool enableDfa = enable_global_context_dfa || !configs.IsOutermostConfigSet;
+            if (enableDfa)
+            {
+                if (!configs.IsReadOnly)
+                {
+                    configs.OptimizeConfigs(this);
+                }
+                DFAState proposed = CreateDFAState(dfa, configs);
+                DFAState existing;
+                if (dfa.states.TryGetValue(proposed, out existing))
+                {
+                    return existing;
+                }
+            }
+            if (!configs.IsReadOnly)
+            {
+                if (configs.ConflictInformation == null)
+                {
+                    configs.ConflictInformation = IsConflicted(configs, contextCache);
+                }
+            }
+            DFAState newState = CreateDFAState(dfa, configs.Clone(true));
+            DecisionState decisionState = atn.GetDecisionState(dfa.decision);
+            int predictedAlt = GetUniqueAlt(configs);
+            if (predictedAlt != ATN.InvalidAltNumber)
+            {
+                newState.AcceptStateInfo = new AcceptStateInfo(predictedAlt);
+            }
+            else
+            {
+                if (configs.ConflictingAlts != null)
+                {
+                    newState.AcceptStateInfo = new AcceptStateInfo(newState.configs.ConflictingAlts.NextSetBit(0));
+                }
+            }
+            if (newState.IsAcceptState && configs.HasSemanticContext)
+            {
+                PredicateDFAState(newState, configs, decisionState.NumberOfTransitions);
+            }
+            if (!enableDfa)
+            {
+                return newState;
+            }
+            DFAState added = dfa.AddState(newState);
+#if !PORTABLE
+			#pragma warning disable 162, 429
+			if (debug && added == newState)
+            {
+                System.Console.Out.WriteLine("adding new DFA state: " + newState);
+            }
+			#pragma warning restore 162, 429
+#endif
+            return added;
+        }
+
+        [return: NotNull]
+        protected internal virtual DFAState CreateDFAState(DFA dfa, ATNConfigSet configs)
+        {
+            return new DFAState(dfa, configs);
+        }
+
+        protected internal virtual void ReportAttemptingFullContext(DFA dfa, BitSet conflictingAlts, SimulatorState conflictState, int startIndex, int stopIndex)
+        {
+#if !PORTABLE
+			#pragma warning disable 162, 429
+			if (debug || retry_debug)
+            {
+                Interval interval = Interval.Of(startIndex, stopIndex);
+                System.Console.Out.WriteLine("reportAttemptingFullContext decision=" + dfa.decision + ":" + conflictState.s0.configs + ", input=" + ((ITokenStream)_parser.InputStream).GetText(interval));
+            }
+			#pragma warning restore 162, 429
+#endif
+            if (_parser != null)
+            {
+                ((IParserErrorListener)_parser.ErrorListenerDispatch).ReportAttemptingFullContext(_parser, dfa, startIndex, stopIndex, conflictingAlts, conflictState);
+			}
+        }
+
+        protected internal virtual void ReportContextSensitivity(DFA dfa, int prediction, SimulatorState acceptState, int startIndex, int stopIndex)
+        {
+#if !PORTABLE
+			#pragma warning disable 162, 429
+            if (debug || retry_debug)
+            {
+                Interval interval = Interval.Of(startIndex, stopIndex);
+                System.Console.Out.WriteLine("reportContextSensitivity decision=" + dfa.decision + ":" + acceptState.s0.configs + ", input=" + ((ITokenStream)_parser.InputStream).GetText(interval));
+            }
+			#pragma warning restore 162, 429
+#endif
+            if (_parser != null)
+            {
+                ((IParserErrorListener)_parser.ErrorListenerDispatch).ReportContextSensitivity(_parser, dfa, startIndex, stopIndex, prediction, acceptState);
+            }
+        }
+
+        /// <summary>If context sensitive parsing, we know it's ambiguity not conflict</summary>
+        protected internal virtual void ReportAmbiguity(DFA dfa, DFAState D, int startIndex, int stopIndex, bool exact, BitSet ambigAlts, ATNConfigSet configs)
+        {
+#if !PORTABLE
+			#pragma warning disable 162, 429
+            if (debug || retry_debug)
+            {
+                Interval interval = Interval.Of(startIndex, stopIndex);
+                System.Console.Out.WriteLine("reportAmbiguity " + ambigAlts + ":" + configs + ", input=" + ((ITokenStream)_parser.InputStream).GetText(interval));
+            }
+			#pragma warning restore 162, 429
+#endif
+            if (_parser != null)
+            {
+                ((IParserErrorListener)_parser.ErrorListenerDispatch).ReportAmbiguity(_parser, dfa, startIndex, stopIndex, exact, ambigAlts, configs);
+            }
+        }
+
+        protected internal int GetReturnState(RuleContext context)
+        {
+            if (context.IsEmpty)
+            {
+                return PredictionContext.EmptyFullStateKey;
+            }
+            ATNState state = atn.states[context.invokingState];
+            Antlr4.Runtime.Atn.RuleTransition transition = (Antlr4.Runtime.Atn.RuleTransition)state.Transition(0);
+            return transition.followState.stateNumber;
+        }
+
+        protected internal ParserRuleContext SkipTailCalls(ParserRuleContext context)
+        {
+            if (!optimize_tail_calls)
+            {
+                return context;
+            }
+            while (!context.IsEmpty)
+            {
+                ATNState state = atn.states[context.invokingState];
+                System.Diagnostics.Debug.Assert(state.NumberOfTransitions == 1 && state.Transition(0).TransitionType == TransitionType.Rule);
+                Antlr4.Runtime.Atn.RuleTransition transition = (Antlr4.Runtime.Atn.RuleTransition)state.Transition(0);
+                if (!transition.tailCall)
+                {
+                    break;
+                }
+                context = ((ParserRuleContext)context.Parent);
+            }
+            return context;
+        }
+
+        /// <since>4.3</since>
+        public virtual Antlr4.Runtime.Parser Parser
+        {
+            get
+            {
+                return _parser;
+            }
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/PlusBlockStartState.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/PlusBlockStartState.cs
new file mode 100644
index 000000000..c4a5b323b
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/PlusBlockStartState.cs
@@ -0,0 +1,59 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    /// <summary>
+    /// Start of
+    /// <c>(A|B|...)+</c>
+    /// loop. Technically a decision state, but
+    /// we don't use for code generation; somebody might need it, so I'm defining
+    /// it for completeness. In reality, the
+    /// <see cref="PlusLoopbackState"/>
+    /// node is the
+    /// real decision-making note for
+    /// <c>A+</c>
+    /// .
+    /// </summary>
+    public sealed class PlusBlockStartState : BlockStartState
+    {
+        public PlusLoopbackState loopBackState;
+
+        public override Antlr4.Runtime.Atn.StateType StateType
+        {
+            get
+            {
+                return Antlr4.Runtime.Atn.StateType.PlusBlockStart;
+            }
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/PlusLoopbackState.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/PlusLoopbackState.cs
new file mode 100644
index 000000000..032e26867
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/PlusLoopbackState.cs
@@ -0,0 +1,53 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    /// <summary>
+    /// Decision state for
+    /// <c>A+</c>
+    /// and
+    /// <c>(A|B)+</c>
+    /// .  It has two transitions:
+    /// one to the loop back to start of the block and one to exit.
+    /// </summary>
+    public sealed class PlusLoopbackState : DecisionState
+    {
+        public override Antlr4.Runtime.Atn.StateType StateType
+        {
+            get
+            {
+                return Antlr4.Runtime.Atn.StateType.PlusLoopBack;
+            }
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/PrecedencePredicateTransition.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/PrecedencePredicateTransition.cs
new file mode 100644
index 000000000..05949881f
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/PrecedencePredicateTransition.cs
@@ -0,0 +1,80 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    /// <author>Sam Harwell</author>
+    public sealed class PrecedencePredicateTransition : AbstractPredicateTransition
+    {
+        public readonly int precedence;
+
+        public PrecedencePredicateTransition(ATNState target, int precedence)
+            : base(target)
+        {
+            this.precedence = precedence;
+        }
+
+        public override Antlr4.Runtime.Atn.TransitionType TransitionType
+        {
+            get
+            {
+                return Antlr4.Runtime.Atn.TransitionType.Precedence;
+            }
+        }
+
+        public override bool IsEpsilon
+        {
+            get
+            {
+                return true;
+            }
+        }
+
+        public override bool Matches(int symbol, int minVocabSymbol, int maxVocabSymbol)
+        {
+            return false;
+        }
+
+        public SemanticContext.PrecedencePredicate Predicate
+        {
+            get
+            {
+                return new SemanticContext.PrecedencePredicate(precedence);
+            }
+        }
+
+        public override string ToString()
+        {
+            return precedence + " >= _p";
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/PredicateEvalInfo.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/PredicateEvalInfo.cs
new file mode 100644
index 000000000..67856dd6d
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/PredicateEvalInfo.cs
@@ -0,0 +1,106 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    /// <summary>
+    /// This class represents profiling event information for semantic predicate
+    /// evaluations which occur during prediction.
+    /// </summary>
+    /// <remarks>
+    /// This class represents profiling event information for semantic predicate
+    /// evaluations which occur during prediction.
+    /// </remarks>
+    /// <seealso cref="ParserATNSimulator.EvalSemanticContext(Antlr4.Runtime.Dfa.DFAState.PredPrediction[], Antlr4.Runtime.ParserRuleContext, bool)"/>
+    /// <since>4.3</since>
+    public class PredicateEvalInfo : DecisionEventInfo
+    {
+        /// <summary>The semantic context which was evaluated.</summary>
+        /// <remarks>The semantic context which was evaluated.</remarks>
+        public readonly SemanticContext semctx;
+
+        /// <summary>
+        /// The alternative number for the decision which is guarded by the semantic
+        /// context
+        /// <see cref="semctx"/>
+        /// . Note that other ATN
+        /// configurations may predict the same alternative which are guarded by
+        /// other semantic contexts and/or
+        /// <see cref="SemanticContext.None"/>
+        /// .
+        /// </summary>
+        public readonly int predictedAlt;
+
+        /// <summary>
+        /// The result of evaluating the semantic context
+        /// <see cref="semctx"/>
+        /// .
+        /// </summary>
+        public readonly bool evalResult;
+
+        /// <summary>
+        /// Constructs a new instance of the
+        /// <see cref="PredicateEvalInfo"/>
+        /// class with the
+        /// specified detailed predicate evaluation information.
+        /// </summary>
+        /// <param name="state">The simulator state</param>
+        /// <param name="decision">The decision number</param>
+        /// <param name="input">The input token stream</param>
+        /// <param name="startIndex">The start index for the current prediction</param>
+        /// <param name="stopIndex">
+        /// The index at which the predicate evaluation was
+        /// triggered. Note that the input stream may be reset to other positions for
+        /// the actual evaluation of individual predicates.
+        /// </param>
+        /// <param name="semctx">The semantic context which was evaluated</param>
+        /// <param name="evalResult">The results of evaluating the semantic context</param>
+        /// <param name="predictedAlt">
+        /// The alternative number for the decision which is
+        /// guarded by the semantic context
+        /// <paramref name="semctx"/>
+        /// . See
+        /// <see cref="predictedAlt"/>
+        /// for more information.
+        /// </param>
+        /// <seealso cref="ParserATNSimulator.EvalSemanticContext(SemanticContext, ParserRuleContext, int)"/>
+        /// <seealso cref="SemanticContext.Eval"/>
+        public PredicateEvalInfo(SimulatorState state, int decision, ITokenStream input, int startIndex, int stopIndex, SemanticContext semctx, bool evalResult, int predictedAlt)
+            : base(decision, state, input, startIndex, stopIndex, state.useContext)
+        {
+            this.semctx = semctx;
+            this.evalResult = evalResult;
+            this.predictedAlt = predictedAlt;
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/PredicateTransition.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/PredicateTransition.cs
new file mode 100644
index 000000000..f413b755b
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/PredicateTransition.cs
@@ -0,0 +1,99 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    /// <summary>
+    /// TODO: this is old comment:
+    /// A tree of semantic predicates from the grammar AST if label==SEMPRED.
+    /// </summary>
+    /// <remarks>
+    /// TODO: this is old comment:
+    /// A tree of semantic predicates from the grammar AST if label==SEMPRED.
+    /// In the ATN, labels will always be exactly one predicate, but the DFA
+    /// may have to combine a bunch of them as it collects predicates from
+    /// multiple ATN configurations into a single DFA state.
+    /// </remarks>
+    public sealed class PredicateTransition : AbstractPredicateTransition
+    {
+        public readonly int ruleIndex;
+
+        public readonly int predIndex;
+
+        public readonly bool isCtxDependent;
+
+        public PredicateTransition(ATNState target, int ruleIndex, int predIndex, bool isCtxDependent)
+            : base(target)
+        {
+            // e.g., $i ref in pred
+            this.ruleIndex = ruleIndex;
+            this.predIndex = predIndex;
+            this.isCtxDependent = isCtxDependent;
+        }
+
+        public override Antlr4.Runtime.Atn.TransitionType TransitionType
+        {
+            get
+            {
+                return Antlr4.Runtime.Atn.TransitionType.Predicate;
+            }
+        }
+
+        public override bool IsEpsilon
+        {
+            get
+            {
+                return true;
+            }
+        }
+
+        public override bool Matches(int symbol, int minVocabSymbol, int maxVocabSymbol)
+        {
+            return false;
+        }
+
+        public SemanticContext.Predicate Predicate
+        {
+            get
+            {
+                return new SemanticContext.Predicate(ruleIndex, predIndex, isCtxDependent);
+            }
+        }
+
+        [return: NotNull]
+        public override string ToString()
+        {
+            return "pred_" + ruleIndex + ":" + predIndex;
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/PredictionContext.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/PredictionContext.cs
new file mode 100644
index 000000000..020c5796b
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/PredictionContext.cs
@@ -0,0 +1,513 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Text;
+using Antlr4.Runtime;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    public abstract class PredictionContext
+    {
+        [NotNull]
+        public static readonly Antlr4.Runtime.Atn.PredictionContext EmptyLocal = EmptyPredictionContext.LocalContext;
+
+        [NotNull]
+        public static readonly Antlr4.Runtime.Atn.PredictionContext EmptyFull = EmptyPredictionContext.FullContext;
+
+        public const int EmptyLocalStateKey = int.MinValue;
+
+        public const int EmptyFullStateKey = int.MaxValue;
+
+        private const int InitialHash = 1;
+
+        /// <summary>
+        /// Stores the computed hash code of this
+        /// <see cref="PredictionContext"/>
+        /// . The hash
+        /// code is computed in parts to match the following reference algorithm.
+        /// <pre>
+        /// private int referenceHashCode() {
+        /// int hash =
+        /// <see cref="Antlr4.Runtime.Misc.MurmurHash.Initialize()">MurmurHash.initialize</see>
+        /// (
+        /// <see cref="InitialHash"/>
+        /// );
+        /// for (int i = 0; i &lt;
+        /// <see cref="Size()"/>
+        /// ; i++) {
+        /// hash =
+        /// <see cref="Antlr4.Runtime.Misc.MurmurHash.Update(int, int)">MurmurHash.update</see>
+        /// (hash,
+        /// <see cref="GetParent(int)">getParent</see>
+        /// (i));
+        /// }
+        /// for (int i = 0; i &lt;
+        /// <see cref="Size()"/>
+        /// ; i++) {
+        /// hash =
+        /// <see cref="Antlr4.Runtime.Misc.MurmurHash.Update(int, int)">MurmurHash.update</see>
+        /// (hash,
+        /// <see cref="GetReturnState(int)">getReturnState</see>
+        /// (i));
+        /// }
+        /// hash =
+        /// <see cref="Antlr4.Runtime.Misc.MurmurHash.Finish(int, int)">MurmurHash.finish</see>
+        /// (hash, 2 *
+        /// <see cref="Size()"/>
+        /// );
+        /// return hash;
+        /// }
+        /// </pre>
+        /// </summary>
+        private readonly int cachedHashCode;
+
+        protected internal PredictionContext(int cachedHashCode)
+        {
+            this.cachedHashCode = cachedHashCode;
+        }
+
+        protected internal static int CalculateEmptyHashCode()
+        {
+            int hash = MurmurHash.Initialize(InitialHash);
+            hash = MurmurHash.Finish(hash, 0);
+            return hash;
+        }
+
+        protected internal static int CalculateHashCode(Antlr4.Runtime.Atn.PredictionContext parent, int returnState)
+        {
+            int hash = MurmurHash.Initialize(InitialHash);
+            hash = MurmurHash.Update(hash, parent);
+            hash = MurmurHash.Update(hash, returnState);
+            hash = MurmurHash.Finish(hash, 2);
+            return hash;
+        }
+
+        protected internal static int CalculateHashCode(Antlr4.Runtime.Atn.PredictionContext[] parents, int[] returnStates)
+        {
+            int hash = MurmurHash.Initialize(InitialHash);
+            foreach (Antlr4.Runtime.Atn.PredictionContext parent in parents)
+            {
+                hash = MurmurHash.Update(hash, parent);
+            }
+            foreach (int returnState in returnStates)
+            {
+                hash = MurmurHash.Update(hash, returnState);
+            }
+            hash = MurmurHash.Finish(hash, 2 * parents.Length);
+            return hash;
+        }
+
+        public abstract int Size
+        {
+            get;
+        }
+
+        public abstract int GetReturnState(int index);
+
+        public abstract int FindReturnState(int returnState);
+
+        [return: NotNull]
+        public abstract Antlr4.Runtime.Atn.PredictionContext GetParent(int index);
+
+        protected internal abstract Antlr4.Runtime.Atn.PredictionContext AddEmptyContext();
+
+        protected internal abstract Antlr4.Runtime.Atn.PredictionContext RemoveEmptyContext();
+
+        public static Antlr4.Runtime.Atn.PredictionContext FromRuleContext(ATN atn, RuleContext outerContext)
+        {
+            return FromRuleContext(atn, outerContext, true);
+        }
+
+        public static Antlr4.Runtime.Atn.PredictionContext FromRuleContext(ATN atn, RuleContext outerContext, bool fullContext)
+        {
+            if (outerContext.IsEmpty)
+            {
+                return fullContext ? EmptyFull : EmptyLocal;
+            }
+            Antlr4.Runtime.Atn.PredictionContext parent;
+            if (outerContext.Parent != null)
+            {
+                parent = Antlr4.Runtime.Atn.PredictionContext.FromRuleContext(atn, outerContext.Parent, fullContext);
+            }
+            else
+            {
+                parent = fullContext ? EmptyFull : EmptyLocal;
+            }
+            ATNState state = atn.states[outerContext.invokingState];
+            RuleTransition transition = (RuleTransition)state.Transition(0);
+            return parent.GetChild(transition.followState.stateNumber);
+        }
+
+        private static Antlr4.Runtime.Atn.PredictionContext AddEmptyContext(Antlr4.Runtime.Atn.PredictionContext context)
+        {
+            return context.AddEmptyContext();
+        }
+
+        private static Antlr4.Runtime.Atn.PredictionContext RemoveEmptyContext(Antlr4.Runtime.Atn.PredictionContext context)
+        {
+            return context.RemoveEmptyContext();
+        }
+
+        public static Antlr4.Runtime.Atn.PredictionContext Join(Antlr4.Runtime.Atn.PredictionContext context0, Antlr4.Runtime.Atn.PredictionContext context1)
+        {
+            return Join(context0, context1, PredictionContextCache.Uncached);
+        }
+
+        internal static Antlr4.Runtime.Atn.PredictionContext Join(Antlr4.Runtime.Atn.PredictionContext context0, Antlr4.Runtime.Atn.PredictionContext context1, PredictionContextCache contextCache)
+        {
+            if (context0 == context1)
+            {
+                return context0;
+            }
+            if (context0.IsEmpty)
+            {
+                return IsEmptyLocal(context0) ? context0 : AddEmptyContext(context1);
+            }
+            else
+            {
+                if (context1.IsEmpty)
+                {
+                    return IsEmptyLocal(context1) ? context1 : AddEmptyContext(context0);
+                }
+            }
+            int context0size = context0.Size;
+            int context1size = context1.Size;
+            if (context0size == 1 && context1size == 1 && context0.GetReturnState(0) == context1.GetReturnState(0))
+            {
+                Antlr4.Runtime.Atn.PredictionContext merged = contextCache.Join(context0.GetParent(0), context1.GetParent(0));
+                if (merged == context0.GetParent(0))
+                {
+                    return context0;
+                }
+                else
+                {
+                    if (merged == context1.GetParent(0))
+                    {
+                        return context1;
+                    }
+                    else
+                    {
+                        return merged.GetChild(context0.GetReturnState(0));
+                    }
+                }
+            }
+            int count = 0;
+            Antlr4.Runtime.Atn.PredictionContext[] parentsList = new Antlr4.Runtime.Atn.PredictionContext[context0size + context1size];
+            int[] returnStatesList = new int[parentsList.Length];
+            int leftIndex = 0;
+            int rightIndex = 0;
+            bool canReturnLeft = true;
+            bool canReturnRight = true;
+            while (leftIndex < context0size && rightIndex < context1size)
+            {
+                if (context0.GetReturnState(leftIndex) == context1.GetReturnState(rightIndex))
+                {
+                    parentsList[count] = contextCache.Join(context0.GetParent(leftIndex), context1.GetParent(rightIndex));
+                    returnStatesList[count] = context0.GetReturnState(leftIndex);
+                    canReturnLeft = canReturnLeft && parentsList[count] == context0.GetParent(leftIndex);
+                    canReturnRight = canReturnRight && parentsList[count] == context1.GetParent(rightIndex);
+                    leftIndex++;
+                    rightIndex++;
+                }
+                else
+                {
+                    if (context0.GetReturnState(leftIndex) < context1.GetReturnState(rightIndex))
+                    {
+                        parentsList[count] = context0.GetParent(leftIndex);
+                        returnStatesList[count] = context0.GetReturnState(leftIndex);
+                        canReturnRight = false;
+                        leftIndex++;
+                    }
+                    else
+                    {
+                        System.Diagnostics.Debug.Assert(context1.GetReturnState(rightIndex) < context0.GetReturnState(leftIndex));
+                        parentsList[count] = context1.GetParent(rightIndex);
+                        returnStatesList[count] = context1.GetReturnState(rightIndex);
+                        canReturnLeft = false;
+                        rightIndex++;
+                    }
+                }
+                count++;
+            }
+            while (leftIndex < context0size)
+            {
+                parentsList[count] = context0.GetParent(leftIndex);
+                returnStatesList[count] = context0.GetReturnState(leftIndex);
+                leftIndex++;
+                canReturnRight = false;
+                count++;
+            }
+            while (rightIndex < context1size)
+            {
+                parentsList[count] = context1.GetParent(rightIndex);
+                returnStatesList[count] = context1.GetReturnState(rightIndex);
+                rightIndex++;
+                canReturnLeft = false;
+                count++;
+            }
+            if (canReturnLeft)
+            {
+                return context0;
+            }
+            else
+            {
+                if (canReturnRight)
+                {
+                    return context1;
+                }
+            }
+            if (count < parentsList.Length)
+            {
+                parentsList = Arrays.CopyOf(parentsList, count);
+                returnStatesList = Arrays.CopyOf(returnStatesList, count);
+            }
+            if (parentsList.Length == 0)
+            {
+                // if one of them was EMPTY_LOCAL, it would be empty and handled at the beginning of the method
+                return EmptyFull;
+            }
+            else
+            {
+                if (parentsList.Length == 1)
+                {
+                    return new SingletonPredictionContext(parentsList[0], returnStatesList[0]);
+                }
+                else
+                {
+                    return new ArrayPredictionContext(parentsList, returnStatesList);
+                }
+            }
+        }
+
+        public static bool IsEmptyLocal(Antlr4.Runtime.Atn.PredictionContext context)
+        {
+            return context == EmptyLocal;
+        }
+
+        public static Antlr4.Runtime.Atn.PredictionContext GetCachedContext(Antlr4.Runtime.Atn.PredictionContext context, ConcurrentDictionary<Antlr4.Runtime.Atn.PredictionContext, Antlr4.Runtime.Atn.PredictionContext> contextCache, PredictionContext.IdentityHashMap visited)
+        {
+            if (context.IsEmpty)
+            {
+                return context;
+            }
+            Antlr4.Runtime.Atn.PredictionContext existing;
+            if (visited.TryGetValue(context, out existing))
+            {
+                return existing;
+            }
+            if (contextCache.TryGetValue(context, out existing))
+            {
+                visited[context] = existing;
+                return existing;
+            }
+            bool changed = false;
+            Antlr4.Runtime.Atn.PredictionContext[] parents = new Antlr4.Runtime.Atn.PredictionContext[context.Size];
+            for (int i = 0; i < parents.Length; i++)
+            {
+                Antlr4.Runtime.Atn.PredictionContext parent = GetCachedContext(context.GetParent(i), contextCache, visited);
+                if (changed || parent != context.GetParent(i))
+                {
+                    if (!changed)
+                    {
+                        parents = new Antlr4.Runtime.Atn.PredictionContext[context.Size];
+                        for (int j = 0; j < context.Size; j++)
+                        {
+                            parents[j] = context.GetParent(j);
+                        }
+                        changed = true;
+                    }
+                    parents[i] = parent;
+                }
+            }
+            if (!changed)
+            {
+                existing = contextCache.GetOrAdd(context, context);
+                visited[context] = existing;
+                return context;
+            }
+            // We know parents.length>0 because context.isEmpty() is checked at the beginning of the method.
+            Antlr4.Runtime.Atn.PredictionContext updated;
+            if (parents.Length == 1)
+            {
+                updated = new SingletonPredictionContext(parents[0], context.GetReturnState(0));
+            }
+            else
+            {
+                ArrayPredictionContext arrayPredictionContext = (ArrayPredictionContext)context;
+                updated = new ArrayPredictionContext(parents, arrayPredictionContext.returnStates, context.cachedHashCode);
+            }
+            existing = contextCache.GetOrAdd(updated, updated);
+            visited[updated] = existing;
+            visited[context] = existing;
+            return updated;
+        }
+
+        public virtual Antlr4.Runtime.Atn.PredictionContext AppendContext(int returnContext, PredictionContextCache contextCache)
+        {
+            return AppendContext(Antlr4.Runtime.Atn.PredictionContext.EmptyFull.GetChild(returnContext), contextCache);
+        }
+
+        public abstract Antlr4.Runtime.Atn.PredictionContext AppendContext(Antlr4.Runtime.Atn.PredictionContext suffix, PredictionContextCache contextCache);
+
+        public virtual Antlr4.Runtime.Atn.PredictionContext GetChild(int returnState)
+        {
+            return new SingletonPredictionContext(this, returnState);
+        }
+
+        public abstract bool IsEmpty
+        {
+            get;
+        }
+
+        public abstract bool HasEmpty
+        {
+            get;
+        }
+
+        public sealed override int GetHashCode()
+        {
+            return cachedHashCode;
+        }
+
+        public abstract override bool Equals(object o);
+
+        //@Override
+        //public String toString() {
+        //	return toString(null, Integer.MAX_VALUE);
+        //}
+        public virtual string[] ToStrings(IRecognizer recognizer, int currentState)
+        {
+            return ToStrings(recognizer, Antlr4.Runtime.Atn.PredictionContext.EmptyFull, currentState);
+        }
+
+        public virtual string[] ToStrings(IRecognizer recognizer, Antlr4.Runtime.Atn.PredictionContext stop, int currentState)
+        {
+            List<string> result = new List<string>();
+            for (int perm = 0; ; perm++)
+            {
+                int offset = 0;
+                bool last = true;
+                Antlr4.Runtime.Atn.PredictionContext p = this;
+                int stateNumber = currentState;
+                StringBuilder localBuffer = new StringBuilder();
+                localBuffer.Append("[");
+                while (!p.IsEmpty && p != stop)
+                {
+                    int index = 0;
+                    if (p.Size > 0)
+                    {
+                        int bits = 1;
+                        while ((1 << bits) < p.Size)
+                        {
+                            bits++;
+                        }
+                        int mask = (1 << bits) - 1;
+                        index = (perm >> offset) & mask;
+                        last &= index >= p.Size - 1;
+                        if (index >= p.Size)
+                        {
+                            goto outer_continue;
+                        }
+                        offset += bits;
+                    }
+                    if (recognizer != null)
+                    {
+                        if (localBuffer.Length > 1)
+                        {
+                            // first char is '[', if more than that this isn't the first rule
+                            localBuffer.Append(' ');
+                        }
+                        ATN atn = recognizer.Atn;
+                        ATNState s = atn.states[stateNumber];
+                        string ruleName = recognizer.RuleNames[s.ruleIndex];
+                        localBuffer.Append(ruleName);
+                    }
+                    else
+                    {
+                        if (p.GetReturnState(index) != EmptyFullStateKey)
+                        {
+                            if (!p.IsEmpty)
+                            {
+                                if (localBuffer.Length > 1)
+                                {
+                                    // first char is '[', if more than that this isn't the first rule
+                                    localBuffer.Append(' ');
+                                }
+                                localBuffer.Append(p.GetReturnState(index));
+                            }
+                        }
+                    }
+                    stateNumber = p.GetReturnState(index);
+                    p = p.GetParent(index);
+                }
+                localBuffer.Append("]");
+                result.Add(localBuffer.ToString());
+                if (last)
+                {
+                    break;
+                }
+outer_continue: ;
+            }
+
+            return result.ToArray();
+        }
+
+        public sealed class IdentityHashMap : Dictionary<PredictionContext, PredictionContext>
+        {
+            public IdentityHashMap()
+                : base(PredictionContext.IdentityEqualityComparator.Instance)
+            {
+            }
+        }
+
+        public sealed class IdentityEqualityComparator : EqualityComparer<PredictionContext>
+        {
+            public static readonly PredictionContext.IdentityEqualityComparator Instance = new PredictionContext.IdentityEqualityComparator();
+
+            private IdentityEqualityComparator()
+            {
+            }
+
+            public override int GetHashCode(PredictionContext obj)
+            {
+                return obj.GetHashCode();
+            }
+
+            public override bool Equals(PredictionContext a, PredictionContext b)
+            {
+                return a == b;
+            }
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/PredictionContextCache.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/PredictionContextCache.cs
new file mode 100644
index 000000000..c669273d4
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/PredictionContextCache.cs
@@ -0,0 +1,205 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System.Collections.Generic;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    /// <summary>
+    /// Used to cache
+    /// <see cref="PredictionContext"/>
+    /// objects. Its used for the shared
+    /// context cash associated with contexts in DFA states. This cache
+    /// can be used for both lexers and parsers.
+    /// </summary>
+    /// <author>Sam Harwell</author>
+    public class PredictionContextCache
+    {
+        public static readonly Antlr4.Runtime.Atn.PredictionContextCache Uncached = new Antlr4.Runtime.Atn.PredictionContextCache(false);
+
+        private readonly IDictionary<PredictionContext, PredictionContext> contexts = new Dictionary<PredictionContext, PredictionContext>();
+
+        private readonly IDictionary<PredictionContextCache.PredictionContextAndInt, PredictionContext> childContexts = new Dictionary<PredictionContextCache.PredictionContextAndInt, PredictionContext>();
+
+        private readonly IDictionary<PredictionContextCache.IdentityCommutativePredictionContextOperands, PredictionContext> joinContexts = new Dictionary<PredictionContextCache.IdentityCommutativePredictionContextOperands, PredictionContext>();
+
+        private readonly bool enableCache;
+
+        public PredictionContextCache()
+            : this(true)
+        {
+        }
+
+        private PredictionContextCache(bool enableCache)
+        {
+            this.enableCache = enableCache;
+        }
+
+        public virtual PredictionContext GetAsCached(PredictionContext context)
+        {
+            if (!enableCache)
+            {
+                return context;
+            }
+            PredictionContext result;
+            if (!contexts.TryGetValue(context, out result))
+            {
+                result = context;
+                contexts[context] = context;
+            }
+            return result;
+        }
+
+        public virtual PredictionContext GetChild(PredictionContext context, int invokingState)
+        {
+            if (!enableCache)
+            {
+                return context.GetChild(invokingState);
+            }
+            PredictionContextCache.PredictionContextAndInt operands = new PredictionContextCache.PredictionContextAndInt(context, invokingState);
+            PredictionContext result;
+            if (!childContexts.TryGetValue(operands, out result))
+            {
+                result = context.GetChild(invokingState);
+                result = GetAsCached(result);
+                childContexts[operands] = result;
+            }
+            return result;
+        }
+
+        public virtual PredictionContext Join(PredictionContext x, PredictionContext y)
+        {
+            if (!enableCache)
+            {
+                return PredictionContext.Join(x, y, this);
+            }
+            PredictionContextCache.IdentityCommutativePredictionContextOperands operands = new PredictionContextCache.IdentityCommutativePredictionContextOperands(x, y);
+            PredictionContext result;
+            if (joinContexts.TryGetValue(operands, out result))
+            {
+                return result;
+            }
+            result = PredictionContext.Join(x, y, this);
+            result = GetAsCached(result);
+            joinContexts[operands] = result;
+            return result;
+        }
+
+        protected internal sealed class PredictionContextAndInt
+        {
+            private readonly PredictionContext obj;
+
+            private readonly int value;
+
+            public PredictionContextAndInt(PredictionContext obj, int value)
+            {
+                this.obj = obj;
+                this.value = value;
+            }
+
+            public override bool Equals(object obj)
+            {
+                if (!(obj is PredictionContextCache.PredictionContextAndInt))
+                {
+                    return false;
+                }
+                else
+                {
+                    if (obj == this)
+                    {
+                        return true;
+                    }
+                }
+                PredictionContextCache.PredictionContextAndInt other = (PredictionContextCache.PredictionContextAndInt)obj;
+                return this.value == other.value && (this.obj == other.obj || (this.obj != null && this.obj.Equals(other.obj)));
+            }
+
+            public override int GetHashCode()
+            {
+                int hashCode = 5;
+                hashCode = 7 * hashCode + (obj != null ? obj.GetHashCode() : 0);
+                hashCode = 7 * hashCode + value;
+                return hashCode;
+            }
+        }
+
+        protected internal sealed class IdentityCommutativePredictionContextOperands
+        {
+            private readonly PredictionContext x;
+
+            private readonly PredictionContext y;
+
+            public IdentityCommutativePredictionContextOperands(PredictionContext x, PredictionContext y)
+            {
+                this.x = x;
+                this.y = y;
+            }
+
+            public PredictionContext X
+            {
+                get
+                {
+                    return x;
+                }
+            }
+
+            public PredictionContext Y
+            {
+                get
+                {
+                    return y;
+                }
+            }
+
+            public override bool Equals(object obj)
+            {
+                if (!(obj is PredictionContextCache.IdentityCommutativePredictionContextOperands))
+                {
+                    return false;
+                }
+                else
+                {
+                    if (this == obj)
+                    {
+                        return true;
+                    }
+                }
+                PredictionContextCache.IdentityCommutativePredictionContextOperands other = (PredictionContextCache.IdentityCommutativePredictionContextOperands)obj;
+                return (this.x == other.x && this.y == other.y) || (this.x == other.y && this.y == other.x);
+            }
+
+            public override int GetHashCode()
+            {
+                return x.GetHashCode() ^ y.GetHashCode();
+            }
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/PredictionMode.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/PredictionMode.cs
new file mode 100644
index 000000000..af34ad307
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/PredictionMode.cs
@@ -0,0 +1,913 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System.Collections.Generic;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    /// <summary>
+    /// This enumeration defines the prediction modes available in ANTLR 4 along with
+    /// utility methods for analyzing configuration sets for conflicts and/or
+    /// ambiguities.
+    /// </summary>
+    /// <remarks>
+    /// This enumeration defines the prediction modes available in ANTLR 4 along with
+    /// utility methods for analyzing configuration sets for conflicts and/or
+    /// ambiguities.
+    /// </remarks>
+    [System.Serializable]
+    public sealed class PredictionMode
+    {
+        /// <summary>The SLL(*) prediction mode.</summary>
+        /// <remarks>
+        /// The SLL(*) prediction mode. This prediction mode ignores the current
+        /// parser context when making predictions. This is the fastest prediction
+        /// mode, and provides correct results for many grammars. This prediction
+        /// mode is more powerful than the prediction mode provided by ANTLR 3, but
+        /// may result in syntax errors for grammar and input combinations which are
+        /// not SLL.
+        /// <p>
+        /// When using this prediction mode, the parser will either return a correct
+        /// parse tree (i.e. the same parse tree that would be returned with the
+        /// <see cref="Ll"/>
+        /// prediction mode), or it will report a syntax error. If a
+        /// syntax error is encountered when using the
+        /// <see cref="Sll"/>
+        /// prediction mode,
+        /// it may be due to either an actual syntax error in the input or indicate
+        /// that the particular combination of grammar and input requires the more
+        /// powerful
+        /// <see cref="Ll"/>
+        /// prediction abilities to complete successfully.</p>
+        /// <p>
+        /// This prediction mode does not provide any guarantees for prediction
+        /// behavior for syntactically-incorrect inputs.</p>
+        /// </remarks>
+        public static readonly PredictionMode Sll = new PredictionMode();
+
+        /// <summary>The LL(*) prediction mode.</summary>
+        /// <remarks>
+        /// The LL(*) prediction mode. This prediction mode allows the current parser
+        /// context to be used for resolving SLL conflicts that occur during
+        /// prediction. This is the fastest prediction mode that guarantees correct
+        /// parse results for all combinations of grammars with syntactically correct
+        /// inputs.
+        /// <p>
+        /// When using this prediction mode, the parser will make correct decisions
+        /// for all syntactically-correct grammar and input combinations. However, in
+        /// cases where the grammar is truly ambiguous this prediction mode might not
+        /// report a precise answer for <em>exactly which</em> alternatives are
+        /// ambiguous.</p>
+        /// <p>
+        /// This prediction mode does not provide any guarantees for prediction
+        /// behavior for syntactically-incorrect inputs.</p>
+        /// </remarks>
+        public static readonly PredictionMode Ll = new PredictionMode();
+
+        /// <summary>The LL(*) prediction mode with exact ambiguity detection.</summary>
+        /// <remarks>
+        /// The LL(*) prediction mode with exact ambiguity detection. In addition to
+        /// the correctness guarantees provided by the
+        /// <see cref="Ll"/>
+        /// prediction mode,
+        /// this prediction mode instructs the prediction algorithm to determine the
+        /// complete and exact set of ambiguous alternatives for every ambiguous
+        /// decision encountered while parsing.
+        /// <p>
+        /// This prediction mode may be used for diagnosing ambiguities during
+        /// grammar development. Due to the performance overhead of calculating sets
+        /// of ambiguous alternatives, this prediction mode should be avoided when
+        /// the exact results are not necessary.</p>
+        /// <p>
+        /// This prediction mode does not provide any guarantees for prediction
+        /// behavior for syntactically-incorrect inputs.</p>
+        /// </remarks>
+        public static readonly PredictionMode LlExactAmbigDetection = new PredictionMode();
+
+        /// <summary>A Map that uses just the state and the stack context as the key.</summary>
+        /// <remarks>A Map that uses just the state and the stack context as the key.</remarks>
+        internal class AltAndContextMap : Dictionary<ATNConfig, BitSet>
+        {
+            public AltAndContextMap()
+                : base(PredictionMode.AltAndContextConfigEqualityComparator.Instance)
+            {
+            }
+        }
+
+        private sealed class AltAndContextConfigEqualityComparator : EqualityComparer<ATNConfig>
+        {
+            public static readonly PredictionMode.AltAndContextConfigEqualityComparator Instance = new PredictionMode.AltAndContextConfigEqualityComparator();
+
+            private AltAndContextConfigEqualityComparator()
+            {
+            }
+
+            /// <summary>
+            /// The hash code is only a function of the
+            /// <see cref="ATNState.stateNumber"/>
+            /// and
+            /// <see cref="ATNConfig.Context"/>
+            /// .
+            /// </summary>
+            public override int GetHashCode(ATNConfig o)
+            {
+                int hashCode = MurmurHash.Initialize(7);
+                hashCode = MurmurHash.Update(hashCode, o.State.stateNumber);
+                hashCode = MurmurHash.Update(hashCode, o.Context);
+                hashCode = MurmurHash.Finish(hashCode, 2);
+                return hashCode;
+            }
+
+            public override bool Equals(ATNConfig a, ATNConfig b)
+            {
+                if (a == b)
+                {
+                    return true;
+                }
+                if (a == null || b == null)
+                {
+                    return false;
+                }
+                return a.State.stateNumber == b.State.stateNumber && a.Context.Equals(b.Context);
+            }
+        }
+
+        /// <summary>Computes the SLL prediction termination condition.</summary>
+        /// <remarks>
+        /// Computes the SLL prediction termination condition.
+        /// <p>
+        /// This method computes the SLL prediction termination condition for both of
+        /// the following cases.</p>
+        /// <ul>
+        /// <li>The usual SLL+LL fallback upon SLL conflict</li>
+        /// <li>Pure SLL without LL fallback</li>
+        /// </ul>
+        /// <p><strong>COMBINED SLL+LL PARSING</strong></p>
+        /// <p>When LL-fallback is enabled upon SLL conflict, correct predictions are
+        /// ensured regardless of how the termination condition is computed by this
+        /// method. Due to the substantially higher cost of LL prediction, the
+        /// prediction should only fall back to LL when the additional lookahead
+        /// cannot lead to a unique SLL prediction.</p>
+        /// <p>Assuming combined SLL+LL parsing, an SLL configuration set with only
+        /// conflicting subsets should fall back to full LL, even if the
+        /// configuration sets don't resolve to the same alternative (e.g.
+        /// <c/>
+        /// 
+        /// 1,2}} and
+        /// <c/>
+        /// 
+        /// 3,4}}. If there is at least one non-conflicting
+        /// configuration, SLL could continue with the hopes that more lookahead will
+        /// resolve via one of those non-conflicting configurations.</p>
+        /// <p>Here's the prediction termination rule them: SLL (for SLL+LL parsing)
+        /// stops when it sees only conflicting configuration subsets. In contrast,
+        /// full LL keeps going when there is uncertainty.</p>
+        /// <p><strong>HEURISTIC</strong></p>
+        /// <p>As a heuristic, we stop prediction when we see any conflicting subset
+        /// unless we see a state that only has one alternative associated with it.
+        /// The single-alt-state thing lets prediction continue upon rules like
+        /// (otherwise, it would admit defeat too soon):</p>
+        /// <p>
+        /// <c>[12|1|[], 6|2|[], 12|2|[]]. s : (ID | ID ID?) ';' ;</c>
+        /// </p>
+        /// <p>When the ATN simulation reaches the state before
+        /// <c>';'</c>
+        /// , it has a
+        /// DFA state that looks like:
+        /// <c>[12|1|[], 6|2|[], 12|2|[]]</c>
+        /// . Naturally
+        /// <c>12|1|[]</c>
+        /// and
+        /// <c>12|2|[]</c>
+        /// conflict, but we cannot stop
+        /// processing this node because alternative to has another way to continue,
+        /// via
+        /// <c>[6|2|[]]</c>
+        /// .</p>
+        /// <p>It also let's us continue for this rule:</p>
+        /// <p>
+        /// <c>[1|1|[], 1|2|[], 8|3|[]] a : A | A | A B ;</c>
+        /// </p>
+        /// <p>After matching input A, we reach the stop state for rule A, state 1.
+        /// State 8 is the state right before B. Clearly alternatives 1 and 2
+        /// conflict and no amount of further lookahead will separate the two.
+        /// However, alternative 3 will be able to continue and so we do not stop
+        /// working on this state. In the previous example, we're concerned with
+        /// states associated with the conflicting alternatives. Here alt 3 is not
+        /// associated with the conflicting configs, but since we can continue
+        /// looking for input reasonably, don't declare the state done.</p>
+        /// <p><strong>PURE SLL PARSING</strong></p>
+        /// <p>To handle pure SLL parsing, all we have to do is make sure that we
+        /// combine stack contexts for configurations that differ only by semantic
+        /// predicate. From there, we can do the usual SLL termination heuristic.</p>
+        /// <p><strong>PREDICATES IN SLL+LL PARSING</strong></p>
+        /// <p>SLL decisions don't evaluate predicates until after they reach DFA stop
+        /// states because they need to create the DFA cache that works in all
+        /// semantic situations. In contrast, full LL evaluates predicates collected
+        /// during start state computation so it can ignore predicates thereafter.
+        /// This means that SLL termination detection can totally ignore semantic
+        /// predicates.</p>
+        /// <p>Implementation-wise,
+        /// <see cref="ATNConfigSet"/>
+        /// combines stack contexts but not
+        /// semantic predicate contexts so we might see two configurations like the
+        /// following.</p>
+        /// <p>
+        /// <c/>
+        /// (s, 1, x,
+        /// ), (s, 1, x', {p})}</p>
+        /// <p>Before testing these configurations against others, we have to merge
+        /// <c>x</c>
+        /// and
+        /// <c>x'</c>
+        /// (without modifying the existing configurations).
+        /// For example, we test
+        /// <c>(x+x')==x''</c>
+        /// when looking for conflicts in
+        /// the following configurations.</p>
+        /// <p>
+        /// <c/>
+        /// (s, 1, x,
+        /// ), (s, 1, x', {p}), (s, 2, x'', {})}</p>
+        /// <p>If the configuration set has predicates (as indicated by
+        /// <see cref="ATNConfigSet.HasSemanticContext()"/>
+        /// ), this algorithm makes a copy of
+        /// the configurations to strip out all of the predicates so that a standard
+        /// <see cref="ATNConfigSet"/>
+        /// will merge everything ignoring predicates.</p>
+        /// </remarks>
+        public static bool HasSLLConflictTerminatingPrediction(PredictionMode mode, ATNConfigSet configs)
+        {
+            if (AllConfigsInRuleStopStates(configs))
+            {
+                return true;
+            }
+            // pure SLL mode parsing
+            if (mode == PredictionMode.Sll)
+            {
+                // Don't bother with combining configs from different semantic
+                // contexts if we can fail over to full LL; costs more time
+                // since we'll often fail over anyway.
+                if (configs.HasSemanticContext)
+                {
+                    // dup configs, tossing out semantic predicates
+                    ATNConfigSet dup = new ATNConfigSet();
+                    foreach (ATNConfig c in configs)
+                    {
+                        c.Transform(c.State, SemanticContext.None, false);
+                        dup.Add(c);
+                    }
+                    configs = dup;
+                }
+            }
+            // now we have combined contexts for configs with dissimilar preds
+            // pure SLL or combined SLL+LL mode parsing
+            ICollection<BitSet> altsets = GetConflictingAltSubsets(configs);
+            bool heuristic = HasConflictingAltSet(altsets) && !HasStateAssociatedWithOneAlt(configs);
+            return heuristic;
+        }
+
+        /// <summary>
+        /// Checks if any configuration in
+        /// <paramref name="configs"/>
+        /// is in a
+        /// <see cref="RuleStopState"/>
+        /// . Configurations meeting this condition have reached
+        /// the end of the decision rule (local context) or end of start rule (full
+        /// context).
+        /// </summary>
+        /// <param name="configs">the configuration set to test</param>
+        /// <returns>
+        /// 
+        /// <see langword="true"/>
+        /// if any configuration in
+        /// <paramref name="configs"/>
+        /// is in a
+        /// <see cref="RuleStopState"/>
+        /// , otherwise
+        /// <see langword="false"/>
+        /// </returns>
+        public static bool HasConfigInRuleStopState(IEnumerable<ATNConfig> configs)
+        {
+            foreach (ATNConfig c in configs)
+            {
+                if (c.State is RuleStopState)
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// Checks if all configurations in
+        /// <paramref name="configs"/>
+        /// are in a
+        /// <see cref="RuleStopState"/>
+        /// . Configurations meeting this condition have reached
+        /// the end of the decision rule (local context) or end of start rule (full
+        /// context).
+        /// </summary>
+        /// <param name="configs">the configuration set to test</param>
+        /// <returns>
+        /// 
+        /// <see langword="true"/>
+        /// if all configurations in
+        /// <paramref name="configs"/>
+        /// are in a
+        /// <see cref="RuleStopState"/>
+        /// , otherwise
+        /// <see langword="false"/>
+        /// </returns>
+        public static bool AllConfigsInRuleStopStates(IEnumerable<ATNConfig> configs)
+        {
+            foreach (ATNConfig config in configs)
+            {
+                if (!(config.State is RuleStopState))
+                {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        /// <summary>Full LL prediction termination.</summary>
+        /// <remarks>
+        /// Full LL prediction termination.
+        /// <p>Can we stop looking ahead during ATN simulation or is there some
+        /// uncertainty as to which alternative we will ultimately pick, after
+        /// consuming more input? Even if there are partial conflicts, we might know
+        /// that everything is going to resolve to the same minimum alternative. That
+        /// means we can stop since no more lookahead will change that fact. On the
+        /// other hand, there might be multiple conflicts that resolve to different
+        /// minimums. That means we need more look ahead to decide which of those
+        /// alternatives we should predict.</p>
+        /// <p>The basic idea is to split the set of configurations
+        /// <c>C</c>
+        /// , into
+        /// conflicting subsets
+        /// <c>(s, _, ctx, _)</c>
+        /// and singleton subsets with
+        /// non-conflicting configurations. Two configurations conflict if they have
+        /// identical
+        /// <see cref="ATNConfig.State"/>
+        /// and
+        /// <see cref="ATNConfig.Context"/>
+        /// values
+        /// but different
+        /// <see cref="ATNConfig.Alt"/>
+        /// value, e.g.
+        /// <c>(s, i, ctx, _)</c>
+        /// and
+        /// <c>(s, j, ctx, _)</c>
+        /// for
+        /// <c>i!=j</c>
+        /// .</p>
+        /// <p/>
+        /// Reduce these configuration subsets to the set of possible alternatives.
+        /// You can compute the alternative subsets in one pass as follows:
+        /// <p/>
+        /// <c/>
+        /// A_s,ctx =
+        /// i | (s, i, ctx, _)}} for each configuration in
+        /// <c>C</c>
+        /// holding
+        /// <c>s</c>
+        /// and
+        /// <c>ctx</c>
+        /// fixed.
+        /// <p/>
+        /// Or in pseudo-code, for each configuration
+        /// <c>c</c>
+        /// in
+        /// <c>C</c>
+        /// :
+        /// <pre>
+        /// map[c] U= c.
+        /// <see cref="ATNConfig.Alt()">getAlt()</see>
+        /// # map hash/equals uses s and x, not
+        /// alt and not pred
+        /// </pre>
+        /// <p>The values in
+        /// <c>map</c>
+        /// are the set of
+        /// <c>A_s,ctx</c>
+        /// sets.</p>
+        /// <p>If
+        /// <c>|A_s,ctx|=1</c>
+        /// then there is no conflict associated with
+        /// <c>s</c>
+        /// and
+        /// <c>ctx</c>
+        /// .</p>
+        /// <p>Reduce the subsets to singletons by choosing a minimum of each subset. If
+        /// the union of these alternative subsets is a singleton, then no amount of
+        /// more lookahead will help us. We will always pick that alternative. If,
+        /// however, there is more than one alternative, then we are uncertain which
+        /// alternative to predict and must continue looking for resolution. We may
+        /// or may not discover an ambiguity in the future, even if there are no
+        /// conflicting subsets this round.</p>
+        /// <p>The biggest sin is to terminate early because it means we've made a
+        /// decision but were uncertain as to the eventual outcome. We haven't used
+        /// enough lookahead. On the other hand, announcing a conflict too late is no
+        /// big deal; you will still have the conflict. It's just inefficient. It
+        /// might even look until the end of file.</p>
+        /// <p>No special consideration for semantic predicates is required because
+        /// predicates are evaluated on-the-fly for full LL prediction, ensuring that
+        /// no configuration contains a semantic context during the termination
+        /// check.</p>
+        /// <p><strong>CONFLICTING CONFIGS</strong></p>
+        /// <p>Two configurations
+        /// <c>(s, i, x)</c>
+        /// and
+        /// <c>(s, j, x')</c>
+        /// , conflict
+        /// when
+        /// <c>i!=j</c>
+        /// but
+        /// <c>x=x'</c>
+        /// . Because we merge all
+        /// <c>(s, i, _)</c>
+        /// configurations together, that means that there are at
+        /// most
+        /// <c>n</c>
+        /// configurations associated with state
+        /// <c>s</c>
+        /// for
+        /// <c>n</c>
+        /// possible alternatives in the decision. The merged stacks
+        /// complicate the comparison of configuration contexts
+        /// <c>x</c>
+        /// and
+        /// <c>x'</c>
+        /// . Sam checks to see if one is a subset of the other by calling
+        /// merge and checking to see if the merged result is either
+        /// <c>x</c>
+        /// or
+        /// <c>x'</c>
+        /// . If the
+        /// <c>x</c>
+        /// associated with lowest alternative
+        /// <c>i</c>
+        /// is the superset, then
+        /// <c>i</c>
+        /// is the only possible prediction since the
+        /// others resolve to
+        /// <c>min(i)</c>
+        /// as well. However, if
+        /// <c>x</c>
+        /// is
+        /// associated with
+        /// <c>j&gt;i</c>
+        /// then at least one stack configuration for
+        /// <c>j</c>
+        /// is not in conflict with alternative
+        /// <c>i</c>
+        /// . The algorithm
+        /// should keep going, looking for more lookahead due to the uncertainty.</p>
+        /// <p>For simplicity, I'm doing a equality check between
+        /// <c>x</c>
+        /// and
+        /// <c>x'</c>
+        /// that lets the algorithm continue to consume lookahead longer
+        /// than necessary. The reason I like the equality is of course the
+        /// simplicity but also because that is the test you need to detect the
+        /// alternatives that are actually in conflict.</p>
+        /// <p><strong>CONTINUE/STOP RULE</strong></p>
+        /// <p>Continue if union of resolved alternative sets from non-conflicting and
+        /// conflicting alternative subsets has more than one alternative. We are
+        /// uncertain about which alternative to predict.</p>
+        /// <p>The complete set of alternatives,
+        /// <c>[i for (_,i,_)]</c>
+        /// , tells us which
+        /// alternatives are still in the running for the amount of input we've
+        /// consumed at this point. The conflicting sets let us to strip away
+        /// configurations that won't lead to more states because we resolve
+        /// conflicts to the configuration with a minimum alternate for the
+        /// conflicting set.</p>
+        /// <p><strong>CASES</strong></p>
+        /// <ul>
+        /// <li>no conflicts and more than 1 alternative in set =&gt; continue</li>
+        /// <li>
+        /// <c>(s, 1, x)</c>
+        /// ,
+        /// <c>(s, 2, x)</c>
+        /// ,
+        /// <c>(s, 3, z)</c>
+        /// ,
+        /// <c>(s', 1, y)</c>
+        /// ,
+        /// <c>(s', 2, y)</c>
+        /// yields non-conflicting set
+        /// <c/>
+        /// 
+        /// 3}} U conflicting sets
+        /// <c/>
+        /// min(
+        /// 1,2})} U
+        /// <c/>
+        /// min(
+        /// 1,2})} =
+        /// <c/>
+        /// 
+        /// 1,3}} =&gt; continue
+        /// </li>
+        /// <li>
+        /// <c>(s, 1, x)</c>
+        /// ,
+        /// <c>(s, 2, x)</c>
+        /// ,
+        /// <c>(s', 1, y)</c>
+        /// ,
+        /// <c>(s', 2, y)</c>
+        /// ,
+        /// <c>(s'', 1, z)</c>
+        /// yields non-conflicting set
+        /// <c/>
+        /// 
+        /// 1}} U conflicting sets
+        /// <c/>
+        /// min(
+        /// 1,2})} U
+        /// <c/>
+        /// min(
+        /// 1,2})} =
+        /// <c/>
+        /// 
+        /// 1}} =&gt; stop and predict 1</li>
+        /// <li>
+        /// <c>(s, 1, x)</c>
+        /// ,
+        /// <c>(s, 2, x)</c>
+        /// ,
+        /// <c>(s', 1, y)</c>
+        /// ,
+        /// <c>(s', 2, y)</c>
+        /// yields conflicting, reduced sets
+        /// <c/>
+        /// 
+        /// 1}} U
+        /// <c/>
+        /// 
+        /// 1}} =
+        /// <c/>
+        /// 
+        /// 1}} =&gt; stop and predict 1, can announce
+        /// ambiguity
+        /// <c/>
+        /// 
+        /// 1,2}}</li>
+        /// <li>
+        /// <c>(s, 1, x)</c>
+        /// ,
+        /// <c>(s, 2, x)</c>
+        /// ,
+        /// <c>(s', 2, y)</c>
+        /// ,
+        /// <c>(s', 3, y)</c>
+        /// yields conflicting, reduced sets
+        /// <c/>
+        /// 
+        /// 1}} U
+        /// <c/>
+        /// 
+        /// 2}} =
+        /// <c/>
+        /// 
+        /// 1,2}} =&gt; continue</li>
+        /// <li>
+        /// <c>(s, 1, x)</c>
+        /// ,
+        /// <c>(s, 2, x)</c>
+        /// ,
+        /// <c>(s', 3, y)</c>
+        /// ,
+        /// <c>(s', 4, y)</c>
+        /// yields conflicting, reduced sets
+        /// <c/>
+        /// 
+        /// 1}} U
+        /// <c/>
+        /// 
+        /// 3}} =
+        /// <c/>
+        /// 
+        /// 1,3}} =&gt; continue</li>
+        /// </ul>
+        /// <p><strong>EXACT AMBIGUITY DETECTION</strong></p>
+        /// <p>If all states report the same conflicting set of alternatives, then we
+        /// know we have the exact ambiguity set.</p>
+        /// <p><code>|A_<em>i</em>|&gt;1</code> and
+        /// <code>A_<em>i</em> = A_<em>j</em></code> for all <em>i</em>, <em>j</em>.</p>
+        /// <p>In other words, we continue examining lookahead until all
+        /// <c>A_i</c>
+        /// have more than one alternative and all
+        /// <c>A_i</c>
+        /// are the same. If
+        /// <c/>
+        /// A=
+        /// {1,2}, {1,3}}}, then regular LL prediction would terminate
+        /// because the resolved set is
+        /// <c/>
+        /// 
+        /// 1}}. To determine what the real
+        /// ambiguity is, we have to know whether the ambiguity is between one and
+        /// two or one and three so we keep going. We can only stop prediction when
+        /// we need exact ambiguity detection when the sets look like
+        /// <c/>
+        /// A=
+        /// {1,2}}} or
+        /// <c/>
+        /// 
+        /// {1,2},{1,2}}}, etc...</p>
+        /// </remarks>
+        public static int ResolvesToJustOneViableAlt(IEnumerable<BitSet> altsets)
+        {
+            return GetSingleViableAlt(altsets);
+        }
+
+        /// <summary>
+        /// Determines if every alternative subset in
+        /// <paramref name="altsets"/>
+        /// contains more
+        /// than one alternative.
+        /// </summary>
+        /// <param name="altsets">a collection of alternative subsets</param>
+        /// <returns>
+        /// 
+        /// <see langword="true"/>
+        /// if every
+        /// <see cref="Antlr4.Runtime.Sharpen.BitSet"/>
+        /// in
+        /// <paramref name="altsets"/>
+        /// has
+        /// <see cref="Antlr4.Runtime.Sharpen.BitSet.Cardinality()">cardinality</see>
+        /// &gt; 1, otherwise
+        /// <see langword="false"/>
+        /// </returns>
+        public static bool AllSubsetsConflict(IEnumerable<BitSet> altsets)
+        {
+            return !HasNonConflictingAltSet(altsets);
+        }
+
+        /// <summary>
+        /// Determines if any single alternative subset in
+        /// <paramref name="altsets"/>
+        /// contains
+        /// exactly one alternative.
+        /// </summary>
+        /// <param name="altsets">a collection of alternative subsets</param>
+        /// <returns>
+        /// 
+        /// <see langword="true"/>
+        /// if
+        /// <paramref name="altsets"/>
+        /// contains a
+        /// <see cref="Antlr4.Runtime.Sharpen.BitSet"/>
+        /// with
+        /// <see cref="Antlr4.Runtime.Sharpen.BitSet.Cardinality()">cardinality</see>
+        /// 1, otherwise
+        /// <see langword="false"/>
+        /// </returns>
+        public static bool HasNonConflictingAltSet(IEnumerable<BitSet> altsets)
+        {
+            foreach (BitSet alts in altsets)
+            {
+                if (alts.Cardinality() == 1)
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// Determines if any single alternative subset in
+        /// <paramref name="altsets"/>
+        /// contains
+        /// more than one alternative.
+        /// </summary>
+        /// <param name="altsets">a collection of alternative subsets</param>
+        /// <returns>
+        /// 
+        /// <see langword="true"/>
+        /// if
+        /// <paramref name="altsets"/>
+        /// contains a
+        /// <see cref="Antlr4.Runtime.Sharpen.BitSet"/>
+        /// with
+        /// <see cref="Antlr4.Runtime.Sharpen.BitSet.Cardinality()">cardinality</see>
+        /// &gt; 1, otherwise
+        /// <see langword="false"/>
+        /// </returns>
+        public static bool HasConflictingAltSet(IEnumerable<BitSet> altsets)
+        {
+            foreach (BitSet alts in altsets)
+            {
+                if (alts.Cardinality() > 1)
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// Determines if every alternative subset in
+        /// <paramref name="altsets"/>
+        /// is equivalent.
+        /// </summary>
+        /// <param name="altsets">a collection of alternative subsets</param>
+        /// <returns>
+        /// 
+        /// <see langword="true"/>
+        /// if every member of
+        /// <paramref name="altsets"/>
+        /// is equal to the
+        /// others, otherwise
+        /// <see langword="false"/>
+        /// </returns>
+        public static bool AllSubsetsEqual(IEnumerable<BitSet> altsets)
+        {
+            IEnumerator<BitSet> it = altsets.GetEnumerator();
+            it.MoveNext();
+            BitSet first = it.Current;
+            while (it.MoveNext())
+            {
+                BitSet next = it.Current;
+                if (!next.Equals(first))
+                {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        /// <summary>
+        /// Returns the unique alternative predicted by all alternative subsets in
+        /// <paramref name="altsets"/>
+        /// . If no such alternative exists, this method returns
+        /// <see cref="ATN.InvalidAltNumber"/>
+        /// .
+        /// </summary>
+        /// <param name="altsets">a collection of alternative subsets</param>
+        public static int GetUniqueAlt(IEnumerable<BitSet> altsets)
+        {
+            BitSet all = GetAlts(altsets);
+            if (all.Cardinality() == 1)
+            {
+                return all.NextSetBit(0);
+            }
+            return ATN.InvalidAltNumber;
+        }
+
+        /// <summary>
+        /// Gets the complete set of represented alternatives for a collection of
+        /// alternative subsets.
+        /// </summary>
+        /// <remarks>
+        /// Gets the complete set of represented alternatives for a collection of
+        /// alternative subsets. This method returns the union of each
+        /// <see cref="Antlr4.Runtime.Sharpen.BitSet"/>
+        /// in
+        /// <paramref name="altsets"/>
+        /// .
+        /// </remarks>
+        /// <param name="altsets">a collection of alternative subsets</param>
+        /// <returns>
+        /// the set of represented alternatives in
+        /// <paramref name="altsets"/>
+        /// </returns>
+        public static BitSet GetAlts(IEnumerable<BitSet> altsets)
+        {
+            BitSet all = new BitSet();
+            foreach (BitSet alts in altsets)
+            {
+                all.Or(alts);
+            }
+            return all;
+        }
+
+        /// <summary>This function gets the conflicting alt subsets from a configuration set.</summary>
+        /// <remarks>
+        /// This function gets the conflicting alt subsets from a configuration set.
+        /// For each configuration
+        /// <c>c</c>
+        /// in
+        /// <paramref name="configs"/>
+        /// :
+        /// <pre>
+        /// map[c] U= c.
+        /// <see cref="ATNConfig.Alt()">getAlt()</see>
+        /// # map hash/equals uses s and x, not
+        /// alt and not pred
+        /// </pre>
+        /// </remarks>
+        [return: NotNull]
+        public static ICollection<BitSet> GetConflictingAltSubsets(IEnumerable<ATNConfig> configs)
+        {
+            PredictionMode.AltAndContextMap configToAlts = new PredictionMode.AltAndContextMap();
+            foreach (ATNConfig c in configs)
+            {
+                BitSet alts;
+                if (!configToAlts.TryGetValue(c, out alts))
+                {
+                    alts = new BitSet();
+                    configToAlts[c] = alts;
+                }
+                alts.Set(c.Alt);
+            }
+            return configToAlts.Values;
+        }
+
+        /// <summary>Get a map from state to alt subset from a configuration set.</summary>
+        /// <remarks>
+        /// Get a map from state to alt subset from a configuration set. For each
+        /// configuration
+        /// <c>c</c>
+        /// in
+        /// <paramref name="configs"/>
+        /// :
+        /// <pre>
+        /// map[c.
+        /// <see cref="ATNConfig.State"/>
+        /// ] U= c.
+        /// <see cref="ATNConfig.Alt"/>
+        /// </pre>
+        /// </remarks>
+        [return: NotNull]
+        public static IDictionary<ATNState, BitSet> GetStateToAltMap(IEnumerable<ATNConfig> configs)
+        {
+            IDictionary<ATNState, BitSet> m = new Dictionary<ATNState, BitSet>();
+            foreach (ATNConfig c in configs)
+            {
+                BitSet alts;
+                if (!m.TryGetValue(c.State, out alts))
+                {
+                    alts = new BitSet();
+                    m[c.State] = alts;
+                }
+                alts.Set(c.Alt);
+            }
+            return m;
+        }
+
+        public static bool HasStateAssociatedWithOneAlt(IEnumerable<ATNConfig> configs)
+        {
+            IDictionary<ATNState, BitSet> x = GetStateToAltMap(configs);
+            foreach (BitSet alts in x.Values)
+            {
+                if (alts.Cardinality() == 1)
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        public static int GetSingleViableAlt(IEnumerable<BitSet> altsets)
+        {
+            BitSet viableAlts = new BitSet();
+            foreach (BitSet alts in altsets)
+            {
+                int minAlt = alts.NextSetBit(0);
+                viableAlts.Set(minAlt);
+                if (viableAlts.Cardinality() > 1)
+                {
+                    // more than 1 viable alt
+                    return ATN.InvalidAltNumber;
+                }
+            }
+            return viableAlts.NextSetBit(0);
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/ProfilingATNSimulator.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/ProfilingATNSimulator.cs
new file mode 100644
index 000000000..50c3cc0aa
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/ProfilingATNSimulator.cs
@@ -0,0 +1,274 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System;
+using Antlr4.Runtime;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Dfa;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    /// <since>4.3</since>
+    public class ProfilingATNSimulator : ParserATNSimulator
+    {
+        protected internal readonly Antlr4.Runtime.Atn.DecisionInfo[] decisions;
+
+        protected internal int numDecisions;
+
+        private ITokenStream _input;
+
+		private int _startIndex;
+
+		private int _sllStopIndex;
+
+		private int _llStopIndex;
+
+        protected internal int currentDecision;
+
+        protected internal SimulatorState currentState;
+
+        /// <summary>
+        /// At the point of LL failover, we record how SLL would resolve the conflict so that
+        /// we can determine whether or not a decision / input pair is context-sensitive.
+        /// </summary>
+        /// <remarks>
+        /// At the point of LL failover, we record how SLL would resolve the conflict so that
+        /// we can determine whether or not a decision / input pair is context-sensitive.
+        /// If LL gives a different result than SLL's predicted alternative, we have a
+        /// context sensitivity for sure. The converse is not necessarily true, however.
+        /// It's possible that after conflict resolution chooses minimum alternatives,
+        /// SLL could get the same answer as LL. Regardless of whether or not the result indicates
+        /// an ambiguity, it is not treated as a context sensitivity because LL prediction
+        /// was not required in order to produce a correct prediction for this decision and input sequence.
+        /// It may in fact still be a context sensitivity but we don't know by looking at the
+        /// minimum alternatives for the current input.
+        /// </remarks>
+        protected internal int conflictingAltResolvedBySLL;
+
+        public ProfilingATNSimulator(Parser parser)
+            : base(parser, parser.Interpreter.atn)
+        {
+            optimize_ll1 = false;
+            reportAmbiguities = true;
+            numDecisions = atn.decisionToState.Count;
+            decisions = new Antlr4.Runtime.Atn.DecisionInfo[numDecisions];
+            for (int i = 0; i < numDecisions; i++)
+            {
+                decisions[i] = new Antlr4.Runtime.Atn.DecisionInfo(i);
+            }
+        }
+
+        public override int AdaptivePredict(ITokenStream input, int decision, ParserRuleContext outerContext)
+        {
+            try
+            {
+                this._input = input;
+                this._startIndex = input.Index;
+                // it's possible for SLL to reach a conflict state without consuming any input
+                this._sllStopIndex = _startIndex - 1;
+                this._llStopIndex = -1;
+                this.currentDecision = decision;
+                this.currentState = null;
+                this.conflictingAltResolvedBySLL = ATN.InvalidAltNumber;
+                // expensive but useful info
+                int alt = base.AdaptivePredict(input, decision, outerContext);
+                decisions[decision].invocations++;
+                int SLL_k = _sllStopIndex - _startIndex + 1;
+                decisions[decision].SLL_TotalLook += SLL_k;
+                decisions[decision].SLL_MinLook = decisions[decision].SLL_MinLook == 0 ? SLL_k : Math.Min(decisions[decision].SLL_MinLook, SLL_k);
+                if (SLL_k > decisions[decision].SLL_MaxLook)
+                {
+                    decisions[decision].SLL_MaxLook = SLL_k;
+                    decisions[decision].SLL_MaxLookEvent = new LookaheadEventInfo(decision, null, input, _startIndex, _sllStopIndex, false);
+                }
+                if (_llStopIndex >= 0)
+                {
+                    int LL_k = _llStopIndex - _startIndex + 1;
+                    decisions[decision].LL_TotalLook += LL_k;
+                    decisions[decision].LL_MinLook = decisions[decision].LL_MinLook == 0 ? LL_k : Math.Min(decisions[decision].LL_MinLook, LL_k);
+                    if (LL_k > decisions[decision].LL_MaxLook)
+                    {
+                        decisions[decision].LL_MaxLook = LL_k;
+                        decisions[decision].LL_MaxLookEvent = new LookaheadEventInfo(decision, null, input, _startIndex, _llStopIndex, true);
+                    }
+                }
+                return alt;
+            }
+            finally
+            {
+                this._input = null;
+                this.currentDecision = -1;
+            }
+        }
+
+        protected internal override SimulatorState GetStartState(DFA dfa, ITokenStream input, ParserRuleContext outerContext, bool useContext)
+        {
+            SimulatorState state = base.GetStartState(dfa, input, outerContext, useContext);
+            currentState = state;
+            return state;
+        }
+
+        protected internal override SimulatorState ComputeStartState(DFA dfa, ParserRuleContext globalContext, bool useContext)
+        {
+            SimulatorState state = base.ComputeStartState(dfa, globalContext, useContext);
+            currentState = state;
+            return state;
+        }
+
+        protected internal override SimulatorState ComputeReachSet(DFA dfa, SimulatorState previous, int t, PredictionContextCache contextCache)
+        {
+            SimulatorState reachState = base.ComputeReachSet(dfa, previous, t, contextCache);
+            if (reachState == null)
+            {
+                // no reach on current lookahead symbol. ERROR.
+                decisions[currentDecision].errors.Add(new ErrorInfo(currentDecision, previous, _input, _startIndex, _input.Index));
+            }
+            currentState = reachState;
+            return reachState;
+        }
+
+        protected internal override DFAState GetExistingTargetState(DFAState previousD, int t)
+        {
+            // this method is called after each time the input position advances
+            if (currentState.useContext)
+            {
+                _llStopIndex = _input.Index;
+            }
+            else
+            {
+                _sllStopIndex = _input.Index;
+            }
+            DFAState existingTargetState = base.GetExistingTargetState(previousD, t);
+            if (existingTargetState != null)
+            {
+                // this method is directly called by execDFA; must construct a SimulatorState
+                // to represent the current state for this case
+                currentState = new SimulatorState(currentState.outerContext, existingTargetState, currentState.useContext, currentState.remainingOuterContext);
+                if (currentState.useContext)
+                {
+                    decisions[currentDecision].LL_DFATransitions++;
+                }
+                else
+                {
+                    decisions[currentDecision].SLL_DFATransitions++;
+                }
+                // count only if we transition over a DFA state
+                if (existingTargetState == Error)
+                {
+                    SimulatorState state = new SimulatorState(currentState.outerContext, previousD, currentState.useContext, currentState.remainingOuterContext);
+                    decisions[currentDecision].errors.Add(new ErrorInfo(currentDecision, state, _input, _startIndex, _input.Index));
+                }
+            }
+            return existingTargetState;
+        }
+
+        protected internal override Tuple<DFAState, ParserRuleContext> ComputeTargetState(DFA dfa, DFAState s, ParserRuleContext remainingGlobalContext, int t, bool useContext, PredictionContextCache contextCache)
+        {
+            Tuple<DFAState, ParserRuleContext> targetState = base.ComputeTargetState(dfa, s, remainingGlobalContext, t, useContext, contextCache);
+            if (useContext)
+            {
+                decisions[currentDecision].LL_ATNTransitions++;
+            }
+            else
+            {
+                decisions[currentDecision].SLL_ATNTransitions++;
+            }
+            return targetState;
+        }
+
+        protected internal override bool EvalSemanticContext(SemanticContext pred, ParserRuleContext parserCallStack, int alt)
+        {
+            bool result = base.EvalSemanticContext(pred, parserCallStack, alt);
+            if (!(pred is SemanticContext.PrecedencePredicate))
+            {
+                bool fullContext = _llStopIndex >= 0;
+                int stopIndex = fullContext ? _llStopIndex : _sllStopIndex;
+                decisions[currentDecision].predicateEvals.Add(new PredicateEvalInfo(currentState, currentDecision, _input, _startIndex, stopIndex, pred, result, alt));
+            }
+            return result;
+        }
+
+        protected internal override void ReportContextSensitivity(DFA dfa, int prediction, SimulatorState acceptState, int startIndex, int stopIndex)
+        {
+            if (prediction != conflictingAltResolvedBySLL)
+            {
+                decisions[currentDecision].contextSensitivities.Add(new ContextSensitivityInfo(currentDecision, acceptState, _input, startIndex, stopIndex));
+            }
+            base.ReportContextSensitivity(dfa, prediction, acceptState, startIndex, stopIndex);
+        }
+
+        protected internal override void ReportAttemptingFullContext(DFA dfa, BitSet conflictingAlts, SimulatorState conflictState, int startIndex, int stopIndex)
+        {
+            if (conflictingAlts != null)
+            {
+                conflictingAltResolvedBySLL = conflictingAlts.NextSetBit(0);
+            }
+            else
+            {
+                conflictingAltResolvedBySLL = conflictState.s0.configs.RepresentedAlternatives.NextSetBit(0);
+            }
+            decisions[currentDecision].LL_Fallback++;
+            base.ReportAttemptingFullContext(dfa, conflictingAlts, conflictState, startIndex, stopIndex);
+        }
+
+        protected internal override void ReportAmbiguity(DFA dfa, DFAState D, int startIndex, int stopIndex, bool exact, BitSet ambigAlts, ATNConfigSet configs)
+        {
+            int prediction;
+            if (ambigAlts != null)
+            {
+                prediction = ambigAlts.NextSetBit(0);
+            }
+            else
+            {
+                prediction = configs.RepresentedAlternatives.NextSetBit(0);
+            }
+            if (conflictingAltResolvedBySLL != ATN.InvalidAltNumber && prediction != conflictingAltResolvedBySLL)
+            {
+                // Even though this is an ambiguity we are reporting, we can
+                // still detect some context sensitivities.  Both SLL and LL
+                // are showing a conflict, hence an ambiguity, but if they resolve
+                // to different minimum alternatives we have also identified a
+                // context sensitivity.
+                decisions[currentDecision].contextSensitivities.Add(new ContextSensitivityInfo(currentDecision, currentState, _input, startIndex, stopIndex));
+            }
+            decisions[currentDecision].ambiguities.Add(new AmbiguityInfo(currentDecision, currentState, _input, startIndex, stopIndex));
+            base.ReportAmbiguity(dfa, D, startIndex, stopIndex, exact, ambigAlts, configs);
+        }
+
+        public virtual Antlr4.Runtime.Atn.DecisionInfo[] DecisionInfo
+        {
+            get
+            {
+                // ---------------------------------------------------------------------
+                return decisions;
+            }
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/RangeTransition.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/RangeTransition.cs
new file mode 100644
index 000000000..105335530
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/RangeTransition.cs
@@ -0,0 +1,76 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    public sealed class RangeTransition : Transition
+    {
+        public readonly int from;
+
+        public readonly int to;
+
+        public RangeTransition(ATNState target, int from, int to)
+            : base(target)
+        {
+            this.from = from;
+            this.to = to;
+        }
+
+        public override Antlr4.Runtime.Atn.TransitionType TransitionType
+        {
+            get
+            {
+                return Antlr4.Runtime.Atn.TransitionType.Range;
+            }
+        }
+
+        public override IntervalSet Label
+        {
+            get
+            {
+                return IntervalSet.Of(from, to);
+            }
+        }
+
+        public override bool Matches(int symbol, int minVocabSymbol, int maxVocabSymbol)
+        {
+            return symbol >= from && symbol <= to;
+        }
+
+        [return: NotNull]
+        public override string ToString()
+        {
+            return "'" + (char)from + "'..'" + (char)to + "'";
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/RuleStartState.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/RuleStartState.cs
new file mode 100644
index 000000000..1db03c98f
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/RuleStartState.cs
@@ -0,0 +1,49 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    public sealed class RuleStartState : ATNState
+    {
+        public RuleStopState stopState;
+
+        public bool isPrecedenceRule;
+
+        public override Antlr4.Runtime.Atn.StateType StateType
+        {
+            get
+            {
+                return Antlr4.Runtime.Atn.StateType.RuleStart;
+            }
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/RuleStopState.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/RuleStopState.cs
new file mode 100644
index 000000000..10960878b
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/RuleStopState.cs
@@ -0,0 +1,60 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    /// <summary>The last node in the ATN for a rule, unless that rule is the start symbol.</summary>
+    /// <remarks>
+    /// The last node in the ATN for a rule, unless that rule is the start symbol.
+    /// In that case, there is one transition to EOF. Later, we might encode
+    /// references to all calls to this rule to compute FOLLOW sets for
+    /// error handling.
+    /// </remarks>
+    public sealed class RuleStopState : ATNState
+    {
+        public override int NonStopStateNumber
+        {
+            get
+            {
+                return -1;
+            }
+        }
+
+        public override Antlr4.Runtime.Atn.StateType StateType
+        {
+            get
+            {
+                return Antlr4.Runtime.Atn.StateType.RuleStop;
+            }
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/RuleTransition.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/RuleTransition.cs
new file mode 100644
index 000000000..522fae630
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/RuleTransition.cs
@@ -0,0 +1,88 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    public sealed class RuleTransition : Transition
+    {
+        /// <summary>Ptr to the rule definition object for this rule ref</summary>
+        public readonly int ruleIndex;
+
+        public readonly int precedence;
+
+        /// <summary>What node to begin computations following ref to rule</summary>
+        [NotNull]
+        public ATNState followState;
+
+        public bool tailCall;
+
+        public bool optimizedTailCall;
+
+        [Obsolete(@"UseRuleTransition(RuleStartState, int, int, ATNState) instead.")]
+        public RuleTransition(RuleStartState ruleStart, int ruleIndex, ATNState followState)
+            : this(ruleStart, ruleIndex, 0, followState)
+        {
+        }
+
+        public RuleTransition(RuleStartState ruleStart, int ruleIndex, int precedence, ATNState followState)
+            : base(ruleStart)
+        {
+            // no Rule object at runtime
+            this.ruleIndex = ruleIndex;
+            this.precedence = precedence;
+            this.followState = followState;
+        }
+
+        public override Antlr4.Runtime.Atn.TransitionType TransitionType
+        {
+            get
+            {
+                return Antlr4.Runtime.Atn.TransitionType.Rule;
+            }
+        }
+
+        public override bool IsEpsilon
+        {
+            get
+            {
+                return true;
+            }
+        }
+
+        public override bool Matches(int symbol, int minVocabSymbol, int maxVocabSymbol)
+        {
+            return false;
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/SemanticContext.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/SemanticContext.cs
new file mode 100644
index 000000000..d48e6423b
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/SemanticContext.cs
@@ -0,0 +1,600 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Antlr4.Runtime;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    /// <summary>
+    /// A tree structure used to record the semantic context in which
+    /// an ATN configuration is valid.
+    /// </summary>
+    /// <remarks>
+    /// A tree structure used to record the semantic context in which
+    /// an ATN configuration is valid.  It's either a single predicate,
+    /// a conjunction
+    /// <c>p1&amp;&amp;p2</c>
+    /// , or a sum of products
+    /// <c>p1||p2</c>
+    /// .
+    /// <p>I have scoped the
+    /// <see cref="AND"/>
+    /// ,
+    /// <see cref="OR"/>
+    /// , and
+    /// <see cref="Predicate"/>
+    /// subclasses of
+    /// <see cref="SemanticContext"/>
+    /// within the scope of this outer class.</p>
+    /// </remarks>
+    public abstract class SemanticContext
+    {
+        /// <summary>
+        /// The default
+        /// <see cref="SemanticContext"/>
+        /// , which is semantically equivalent to
+        /// a predicate of the form
+        /// <c/>
+        /// 
+        /// true}?}.
+        /// </summary>
+        public static readonly SemanticContext None = new SemanticContext.Predicate();
+
+        /// <summary>
+        /// For context independent predicates, we evaluate them without a local
+        /// context (i.e., null context).
+        /// </summary>
+        /// <remarks>
+        /// For context independent predicates, we evaluate them without a local
+        /// context (i.e., null context). That way, we can evaluate them without
+        /// having to create proper rule-specific context during prediction (as
+        /// opposed to the parser, which creates them naturally). In a practical
+        /// sense, this avoids a cast exception from RuleContext to myruleContext.
+        /// <p>For context dependent predicates, we must pass in a local context so that
+        /// references such as $arg evaluate properly as _localctx.arg. We only
+        /// capture context dependent predicates in the context in which we begin
+        /// prediction, so we passed in the outer context here in case of context
+        /// dependent predicate evaluation.</p>
+        /// </remarks>
+        public abstract bool Eval<Symbol, ATNInterpreter>(Recognizer<Symbol, ATNInterpreter> parser, RuleContext parserCallStack)
+            where ATNInterpreter : ATNSimulator;
+        /// <summary>Evaluate the precedence predicates for the context and reduce the result.</summary>
+        /// <remarks>Evaluate the precedence predicates for the context and reduce the result.</remarks>
+        /// <param name="parser">The parser instance.</param>
+        /// <param name="parserCallStack"/>
+        /// <returns>
+        /// The simplified semantic context after precedence predicates are
+        /// evaluated, which will be one of the following values.
+        /// <ul>
+        /// <li>
+        /// <see cref="None"/>
+        /// : if the predicate simplifies to
+        /// <see langword="true"/>
+        /// after
+        /// precedence predicates are evaluated.</li>
+        /// <li>
+        /// <see langword="null"/>
+        /// : if the predicate simplifies to
+        /// <see langword="false"/>
+        /// after
+        /// precedence predicates are evaluated.</li>
+        /// <li>
+        /// <c>this</c>
+        /// : if the semantic context is not changed as a result of
+        /// precedence predicate evaluation.</li>
+        /// <li>A non-
+        /// <see langword="null"/>
+        /// 
+        /// <see cref="SemanticContext"/>
+        /// : the new simplified
+        /// semantic context after precedence predicates are evaluated.</li>
+        /// </ul>
+        /// </returns>
+        public virtual SemanticContext EvalPrecedence<Symbol, ATNInterpreter>(Recognizer<Symbol, ATNInterpreter> parser, RuleContext parserCallStack)
+            where ATNInterpreter : ATNSimulator
+        {
+            return this;
+        }
+
+        public class Predicate : SemanticContext
+        {
+            public readonly int ruleIndex;
+
+            public readonly int predIndex;
+
+            public readonly bool isCtxDependent;
+
+            protected internal Predicate()
+            {
+                // e.g., $i ref in pred
+                this.ruleIndex = -1;
+                this.predIndex = -1;
+                this.isCtxDependent = false;
+            }
+
+            public Predicate(int ruleIndex, int predIndex, bool isCtxDependent)
+            {
+                this.ruleIndex = ruleIndex;
+                this.predIndex = predIndex;
+                this.isCtxDependent = isCtxDependent;
+            }
+
+            public override bool Eval<Symbol, ATNInterpreter>(Recognizer<Symbol, ATNInterpreter> parser, RuleContext parserCallStack)
+            {
+                RuleContext localctx = isCtxDependent ? parserCallStack : null;
+                return parser.Sempred(localctx, ruleIndex, predIndex);
+            }
+
+            public override int GetHashCode()
+            {
+                int hashCode = MurmurHash.Initialize();
+                hashCode = MurmurHash.Update(hashCode, ruleIndex);
+                hashCode = MurmurHash.Update(hashCode, predIndex);
+                hashCode = MurmurHash.Update(hashCode, isCtxDependent ? 1 : 0);
+                hashCode = MurmurHash.Finish(hashCode, 3);
+                return hashCode;
+            }
+
+            public override bool Equals(object obj)
+            {
+                if (!(obj is SemanticContext.Predicate))
+                {
+                    return false;
+                }
+                if (this == obj)
+                {
+                    return true;
+                }
+                SemanticContext.Predicate p = (SemanticContext.Predicate)obj;
+                return this.ruleIndex == p.ruleIndex && this.predIndex == p.predIndex && this.isCtxDependent == p.isCtxDependent;
+            }
+
+            public override string ToString()
+            {
+                return "{" + ruleIndex + ":" + predIndex + "}?";
+            }
+        }
+
+        public class PrecedencePredicate : SemanticContext, IComparable<SemanticContext.PrecedencePredicate>
+        {
+            public readonly int precedence;
+
+            protected internal PrecedencePredicate()
+            {
+                this.precedence = 0;
+            }
+
+            public PrecedencePredicate(int precedence)
+            {
+                this.precedence = precedence;
+            }
+
+            public override bool Eval<Symbol, ATNInterpreter>(Recognizer<Symbol, ATNInterpreter> parser, RuleContext parserCallStack)
+            {
+                return parser.Precpred(parserCallStack, precedence);
+            }
+
+            public override SemanticContext EvalPrecedence<Symbol, ATNInterpreter>(Recognizer<Symbol, ATNInterpreter> parser, RuleContext parserCallStack)
+            {
+                if (parser.Precpred(parserCallStack, precedence))
+                {
+                    return SemanticContext.None;
+                }
+                else
+                {
+                    return null;
+                }
+            }
+
+            public virtual int CompareTo(SemanticContext.PrecedencePredicate o)
+            {
+                return precedence - o.precedence;
+            }
+
+            public override int GetHashCode()
+            {
+                int hashCode = 1;
+                hashCode = 31 * hashCode + precedence;
+                return hashCode;
+            }
+
+            public override bool Equals(object obj)
+            {
+                if (!(obj is SemanticContext.PrecedencePredicate))
+                {
+                    return false;
+                }
+                if (this == obj)
+                {
+                    return true;
+                }
+                SemanticContext.PrecedencePredicate other = (SemanticContext.PrecedencePredicate)obj;
+                return this.precedence == other.precedence;
+            }
+
+            public override string ToString()
+            {
+                // precedence >= _precedenceStack.peek()
+                return "{" + precedence + ">=prec}?";
+            }
+        }
+
+        /// <summary>
+        /// This is the base class for semantic context "operators", which operate on
+        /// a collection of semantic context "operands".
+        /// </summary>
+        /// <remarks>
+        /// This is the base class for semantic context "operators", which operate on
+        /// a collection of semantic context "operands".
+        /// </remarks>
+        /// <since>4.3</since>
+        public abstract class Operator : SemanticContext
+        {
+            /// <summary>Gets the operands for the semantic context operator.</summary>
+            /// <remarks>Gets the operands for the semantic context operator.</remarks>
+            /// <returns>
+            /// a collection of
+            /// <see cref="SemanticContext"/>
+            /// operands for the
+            /// operator.
+            /// </returns>
+            /// <since>4.3</since>
+            [NotNull]
+            public abstract ICollection<SemanticContext> Operands
+            {
+                get;
+            }
+        }
+
+        /// <summary>
+        /// A semantic context which is true whenever none of the contained contexts
+        /// is false.
+        /// </summary>
+        /// <remarks>
+        /// A semantic context which is true whenever none of the contained contexts
+        /// is false.
+        /// </remarks>
+        public class AND : SemanticContext.Operator
+        {
+            [NotNull]
+            public readonly SemanticContext[] opnds;
+
+            public AND(SemanticContext a, SemanticContext b)
+            {
+                HashSet<SemanticContext> operands = new HashSet<SemanticContext>();
+                if (a is SemanticContext.AND)
+                {
+                    operands.UnionWith(((AND)a).opnds);
+                }
+                else
+                {
+                    operands.Add(a);
+                }
+                if (b is SemanticContext.AND)
+                {
+                    operands.UnionWith(((AND)b).opnds);
+                }
+                else
+                {
+                    operands.Add(b);
+                }
+                IList<SemanticContext.PrecedencePredicate> precedencePredicates = FilterPrecedencePredicates(operands);
+                if (precedencePredicates.Count > 0)
+                {
+                    // interested in the transition with the lowest precedence
+                    SemanticContext.PrecedencePredicate reduced = precedencePredicates.Min();
+                    operands.Add(reduced);
+                }
+                opnds = operands.ToArray();
+            }
+
+            public override ICollection<SemanticContext> Operands
+            {
+                get
+                {
+                    return Arrays.AsList(opnds);
+                }
+            }
+
+            public override bool Equals(object obj)
+            {
+                if (this == obj)
+                {
+                    return true;
+                }
+                if (!(obj is SemanticContext.AND))
+                {
+                    return false;
+                }
+                SemanticContext.AND other = (SemanticContext.AND)obj;
+                return Arrays.Equals(this.opnds, other.opnds);
+            }
+
+            public override int GetHashCode()
+            {
+                return MurmurHash.HashCode(opnds, typeof(SemanticContext.AND).GetHashCode());
+            }
+
+            /// <summary>
+            /// <inheritDoc/>
+            /// <p>
+            /// The evaluation of predicates by this context is short-circuiting, but
+            /// unordered.</p>
+            /// </summary>
+            public override bool Eval<Symbol, ATNInterpreter>(Recognizer<Symbol, ATNInterpreter> parser, RuleContext parserCallStack)
+            {
+                foreach (SemanticContext opnd in opnds)
+                {
+                    if (!opnd.Eval(parser, parserCallStack))
+                    {
+                        return false;
+                    }
+                }
+                return true;
+            }
+
+            public override SemanticContext EvalPrecedence<Symbol, ATNInterpreter>(Recognizer<Symbol, ATNInterpreter> parser, RuleContext parserCallStack)
+            {
+                bool differs = false;
+                IList<SemanticContext> operands = new List<SemanticContext>();
+                foreach (SemanticContext context in opnds)
+                {
+                    SemanticContext evaluated = context.EvalPrecedence(parser, parserCallStack);
+                    differs |= (evaluated != context);
+                    if (evaluated == null)
+                    {
+                        // The AND context is false if any element is false
+                        return null;
+                    }
+                    else
+                    {
+                        if (evaluated != None)
+                        {
+                            // Reduce the result by skipping true elements
+                            operands.Add(evaluated);
+                        }
+                    }
+                }
+                if (!differs)
+                {
+                    return this;
+                }
+                if (operands.Count == 0)
+                {
+                    // all elements were true, so the AND context is true
+                    return None;
+                }
+                SemanticContext result = operands[0];
+                for (int i = 1; i < operands.Count; i++)
+                {
+                    result = SemanticContext.AndOp(result, operands[i]);
+                }
+                return result;
+            }
+
+            public override string ToString()
+            {
+                return Utils.Join("&&", opnds);
+            }
+        }
+
+        /// <summary>
+        /// A semantic context which is true whenever at least one of the contained
+        /// contexts is true.
+        /// </summary>
+        /// <remarks>
+        /// A semantic context which is true whenever at least one of the contained
+        /// contexts is true.
+        /// </remarks>
+        public class OR : SemanticContext.Operator
+        {
+            [NotNull]
+            public readonly SemanticContext[] opnds;
+
+            public OR(SemanticContext a, SemanticContext b)
+            {
+                HashSet<SemanticContext> operands = new HashSet<SemanticContext>();
+                if (a is SemanticContext.OR)
+                {
+                    operands.UnionWith(((OR)a).opnds);
+                }
+                else
+                {
+                    operands.Add(a);
+                }
+                if (b is SemanticContext.OR)
+                {
+                    operands.UnionWith(((OR)b).opnds);
+                }
+                else
+                {
+                    operands.Add(b);
+                }
+                IList<SemanticContext.PrecedencePredicate> precedencePredicates = FilterPrecedencePredicates(operands);
+                if (precedencePredicates.Count > 0)
+                {
+                    // interested in the transition with the highest precedence
+                    SemanticContext.PrecedencePredicate reduced = precedencePredicates.Max();
+                    operands.Add(reduced);
+                }
+                this.opnds = operands.ToArray();
+            }
+
+            public override ICollection<SemanticContext> Operands
+            {
+                get
+                {
+                    return Arrays.AsList(opnds);
+                }
+            }
+
+            public override bool Equals(object obj)
+            {
+                if (this == obj)
+                {
+                    return true;
+                }
+                if (!(obj is SemanticContext.OR))
+                {
+                    return false;
+                }
+                SemanticContext.OR other = (SemanticContext.OR)obj;
+                return Arrays.Equals(this.opnds, other.opnds);
+            }
+
+            public override int GetHashCode()
+            {
+                return MurmurHash.HashCode(opnds, typeof(SemanticContext.OR).GetHashCode());
+            }
+
+            /// <summary>
+            /// <inheritDoc/>
+            /// <p>
+            /// The evaluation of predicates by this context is short-circuiting, but
+            /// unordered.</p>
+            /// </summary>
+            public override bool Eval<Symbol, ATNInterpreter>(Recognizer<Symbol, ATNInterpreter> parser, RuleContext parserCallStack)
+            {
+                foreach (SemanticContext opnd in opnds)
+                {
+                    if (opnd.Eval(parser, parserCallStack))
+                    {
+                        return true;
+                    }
+                }
+                return false;
+            }
+
+            public override SemanticContext EvalPrecedence<Symbol, ATNInterpreter>(Recognizer<Symbol, ATNInterpreter> parser, RuleContext parserCallStack)
+            {
+                bool differs = false;
+                IList<SemanticContext> operands = new List<SemanticContext>();
+                foreach (SemanticContext context in opnds)
+                {
+                    SemanticContext evaluated = context.EvalPrecedence(parser, parserCallStack);
+                    differs |= (evaluated != context);
+                    if (evaluated == None)
+                    {
+                        // The OR context is true if any element is true
+                        return None;
+                    }
+                    else
+                    {
+                        if (evaluated != null)
+                        {
+                            // Reduce the result by skipping false elements
+                            operands.Add(evaluated);
+                        }
+                    }
+                }
+                if (!differs)
+                {
+                    return this;
+                }
+                if (operands.Count == 0)
+                {
+                    // all elements were false, so the OR context is false
+                    return null;
+                }
+                SemanticContext result = operands[0];
+                for (int i = 1; i < operands.Count; i++)
+                {
+                    result = SemanticContext.OrOp(result, operands[i]);
+                }
+                return result;
+            }
+
+            public override string ToString()
+            {
+                return Utils.Join("||", opnds);
+            }
+        }
+
+        public static SemanticContext AndOp(SemanticContext a, SemanticContext b)
+        {
+            if (a == null || a == None)
+            {
+                return b;
+            }
+            if (b == null || b == None)
+            {
+                return a;
+            }
+            SemanticContext.AND result = new SemanticContext.AND(a, b);
+            if (result.opnds.Length == 1)
+            {
+                return result.opnds[0];
+            }
+            return result;
+        }
+
+        /// <seealso cref="ParserATNSimulator.GetPredsForAmbigAlts(Antlr4.Runtime.Sharpen.BitSet, ATNConfigSet, int)"/>
+        public static SemanticContext OrOp(SemanticContext a, SemanticContext b)
+        {
+            if (a == null)
+            {
+                return b;
+            }
+            if (b == null)
+            {
+                return a;
+            }
+            if (a == None || b == None)
+            {
+                return None;
+            }
+            SemanticContext.OR result = new SemanticContext.OR(a, b);
+            if (result.opnds.Length == 1)
+            {
+                return result.opnds[0];
+            }
+            return result;
+        }
+
+        private static IList<SemanticContext.PrecedencePredicate> FilterPrecedencePredicates(HashSet<SemanticContext> collection)
+        {
+            if (!collection.OfType<PrecedencePredicate>().Any())
+                Collections.EmptyList<PrecedencePredicate>();
+
+            List<PrecedencePredicate> result = collection.OfType<PrecedencePredicate>().ToList();
+#if NET40PLUS
+            collection.ExceptWith(result);
+#else
+            collection.ExceptWith(result.Cast<SemanticContext>());
+#endif
+            return result;
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/SetTransition.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/SetTransition.cs
new file mode 100644
index 000000000..9321ff2b5
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/SetTransition.cs
@@ -0,0 +1,81 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    /// <summary>A transition containing a set of values.</summary>
+    /// <remarks>A transition containing a set of values.</remarks>
+    public class SetTransition : Transition
+    {
+        [NotNull]
+        public readonly IntervalSet set;
+
+        public SetTransition(ATNState target, IntervalSet set)
+            : base(target)
+        {
+            // TODO (sam): should we really allow null here?
+            if (set == null)
+            {
+                set = IntervalSet.Of(TokenConstants.InvalidType);
+            }
+            this.set = set;
+        }
+
+        public override Antlr4.Runtime.Atn.TransitionType TransitionType
+        {
+            get
+            {
+                return Antlr4.Runtime.Atn.TransitionType.Set;
+            }
+        }
+
+        public override IntervalSet Label
+        {
+            get
+            {
+                return set;
+            }
+        }
+
+        public override bool Matches(int symbol, int minVocabSymbol, int maxVocabSymbol)
+        {
+            return set.Contains(symbol);
+        }
+
+        [return: NotNull]
+        public override string ToString()
+        {
+            return set.ToString();
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/SimulatorState.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/SimulatorState.cs
new file mode 100644
index 000000000..d78f3e23f
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/SimulatorState.cs
@@ -0,0 +1,55 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime;
+using Antlr4.Runtime.Dfa;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    /// <author>Sam Harwell</author>
+    public class SimulatorState
+    {
+        public readonly ParserRuleContext outerContext;
+
+        public readonly DFAState s0;
+
+        public readonly bool useContext;
+
+        public readonly ParserRuleContext remainingOuterContext;
+
+        public SimulatorState(ParserRuleContext outerContext, DFAState s0, bool useContext, ParserRuleContext remainingOuterContext)
+        {
+            this.outerContext = outerContext != null ? outerContext : ParserRuleContext.EmptyContext;
+            this.s0 = s0;
+            this.useContext = useContext;
+            this.remainingOuterContext = remainingOuterContext;
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/SingletonPredictionContext.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/SingletonPredictionContext.cs
new file mode 100644
index 000000000..cfc5f8dcd
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/SingletonPredictionContext.cs
@@ -0,0 +1,131 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+#pragma warning disable 0659 // 'class' overrides Object.Equals(object o) but does not override Object.GetHashCode()
+    public class SingletonPredictionContext : PredictionContext
+    {
+        [NotNull]
+        public readonly PredictionContext parent;
+
+        public readonly int returnState;
+
+        internal SingletonPredictionContext(PredictionContext parent, int returnState)
+            : base(CalculateHashCode(parent, returnState))
+        {
+            System.Diagnostics.Debug.Assert(returnState != EmptyFullStateKey && returnState != EmptyLocalStateKey);
+            this.parent = parent;
+            this.returnState = returnState;
+        }
+
+        public override PredictionContext GetParent(int index)
+        {
+            System.Diagnostics.Debug.Assert(index == 0);
+            return parent;
+        }
+
+        public override int GetReturnState(int index)
+        {
+            System.Diagnostics.Debug.Assert(index == 0);
+            return returnState;
+        }
+
+        public override int FindReturnState(int returnState)
+        {
+            return this.returnState == returnState ? 0 : -1;
+        }
+
+        public override int Size
+        {
+            get
+            {
+                return 1;
+            }
+        }
+
+        public override bool IsEmpty
+        {
+            get
+            {
+                return false;
+            }
+        }
+
+        public override bool HasEmpty
+        {
+            get
+            {
+                return false;
+            }
+        }
+
+        public override PredictionContext AppendContext(PredictionContext suffix, PredictionContextCache contextCache)
+        {
+            return contextCache.GetChild(parent.AppendContext(suffix, contextCache), returnState);
+        }
+
+        protected internal override PredictionContext AddEmptyContext()
+        {
+            PredictionContext[] parents = new PredictionContext[] { parent, EmptyFull };
+            int[] returnStates = new int[] { returnState, EmptyFullStateKey };
+            return new ArrayPredictionContext(parents, returnStates);
+        }
+
+        protected internal override PredictionContext RemoveEmptyContext()
+        {
+            return this;
+        }
+
+        public override bool Equals(object o)
+        {
+            if (o == this)
+            {
+                return true;
+            }
+            else
+            {
+                if (!(o is Antlr4.Runtime.Atn.SingletonPredictionContext))
+                {
+                    return false;
+                }
+            }
+            Antlr4.Runtime.Atn.SingletonPredictionContext other = (Antlr4.Runtime.Atn.SingletonPredictionContext)o;
+            if (this.GetHashCode() != other.GetHashCode())
+            {
+                return false;
+            }
+            return returnState == other.returnState && parent.Equals(other.parent);
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/StarBlockStartState.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/StarBlockStartState.cs
new file mode 100644
index 000000000..027800245
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/StarBlockStartState.cs
@@ -0,0 +1,47 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    /// <summary>The block that begins a closure loop.</summary>
+    /// <remarks>The block that begins a closure loop.</remarks>
+    public sealed class StarBlockStartState : BlockStartState
+    {
+        public override Antlr4.Runtime.Atn.StateType StateType
+        {
+            get
+            {
+                return Antlr4.Runtime.Atn.StateType.StarBlockStart;
+            }
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/StarLoopEntryState.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/StarLoopEntryState.cs
new file mode 100644
index 000000000..8b45c7b2e
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/StarLoopEntryState.cs
@@ -0,0 +1,64 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    public sealed class StarLoopEntryState : DecisionState
+    {
+        public StarLoopbackState loopBackState;
+
+        /// <summary>
+        /// Indicates whether this state can benefit from a precedence DFA during SLL
+        /// decision making.
+        /// </summary>
+        /// <remarks>
+        /// Indicates whether this state can benefit from a precedence DFA during SLL
+        /// decision making.
+        /// <p>This is a computed property that is calculated during ATN deserialization
+        /// and stored for use in
+        /// <see cref="ParserATNSimulator"/>
+        /// and
+        /// <see cref="Antlr4.Runtime.ParserInterpreter"/>
+        /// .</p>
+        /// </remarks>
+        /// <seealso cref="Antlr4.Runtime.Dfa.DFA.IsPrecedenceDfa()"/>
+        public bool precedenceRuleDecision;
+
+        public override Antlr4.Runtime.Atn.StateType StateType
+        {
+            get
+            {
+                return Antlr4.Runtime.Atn.StateType.StarLoopEntry;
+            }
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/StarLoopbackState.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/StarLoopbackState.cs
new file mode 100644
index 000000000..e13e3ce13
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/StarLoopbackState.cs
@@ -0,0 +1,53 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    public sealed class StarLoopbackState : ATNState
+    {
+        public StarLoopEntryState LoopEntryState
+        {
+            get
+            {
+                return (StarLoopEntryState)Transition(0).target;
+            }
+        }
+
+        public override Antlr4.Runtime.Atn.StateType StateType
+        {
+            get
+            {
+                return Antlr4.Runtime.Atn.StateType.StarLoopBack;
+            }
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/StateType.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/StateType.cs
new file mode 100644
index 000000000..5e1861e95
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/StateType.cs
@@ -0,0 +1,51 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    public enum StateType
+    {
+        InvalidType,
+        Basic,
+        RuleStart,
+        BlockStart,
+        PlusBlockStart,
+        StarBlockStart,
+        TokenStart,
+        RuleStop,
+        BlockEnd,
+        StarLoopBack,
+        StarLoopEntry,
+        PlusLoopBack,
+        LoopEnd
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/TokensStartState.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/TokensStartState.cs
new file mode 100644
index 000000000..d9c781ffe
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/TokensStartState.cs
@@ -0,0 +1,46 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    /// <summary>The Tokens rule start state linking to each lexer rule start state</summary>
+    public sealed class TokensStartState : DecisionState
+    {
+        public override Antlr4.Runtime.Atn.StateType StateType
+        {
+            get
+            {
+                return Antlr4.Runtime.Atn.StateType.TokenStart;
+            }
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/Transition.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/Transition.cs
new file mode 100644
index 000000000..7d52a96f5
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/Transition.cs
@@ -0,0 +1,108 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    /// <summary>An ATN transition between any two ATN states.</summary>
+    /// <remarks>
+    /// An ATN transition between any two ATN states.  Subclasses define
+    /// atom, set, epsilon, action, predicate, rule transitions.
+    /// <p>This is a one way link.  It emanates from a state (usually via a list of
+    /// transitions) and has a target state.</p>
+    /// <p>Since we never have to change the ATN transitions once we construct it,
+    /// we can fix these transitions as specific classes. The DFA transitions
+    /// on the other hand need to update the labels as it adds transitions to
+    /// the states. We'll use the term Edge for the DFA to distinguish them from
+    /// ATN transitions.</p>
+    /// </remarks>
+    public abstract class Transition
+    {
+        public static readonly ReadOnlyCollection<string> serializationNames = new ReadOnlyCollection<string>(Arrays.AsList("INVALID", "EPSILON", "RANGE", "RULE", "PREDICATE", "ATOM", "ACTION", "SET", "NOT_SET", "WILDCARD", "PRECEDENCE"));
+
+        /// <summary>The target of this transition.</summary>
+        /// <remarks>The target of this transition.</remarks>
+        [NotNull]
+        public ATNState target;
+
+        protected internal Transition(ATNState target)
+        {
+            if (target == null)
+            {
+                throw new ArgumentNullException("target cannot be null.");
+            }
+            this.target = target;
+        }
+
+        public abstract TransitionType TransitionType
+        {
+            get;
+        }
+
+        /// <summary>Determines if the transition is an "epsilon" transition.</summary>
+        /// <remarks>
+        /// Determines if the transition is an "epsilon" transition.
+        /// <p>The default implementation returns
+        /// <see langword="false"/>
+        /// .</p>
+        /// </remarks>
+        /// <returns>
+        /// 
+        /// <see langword="true"/>
+        /// if traversing this transition in the ATN does not
+        /// consume an input symbol; otherwise,
+        /// <see langword="false"/>
+        /// if traversing this
+        /// transition consumes (matches) an input symbol.
+        /// </returns>
+        public virtual bool IsEpsilon
+        {
+            get
+            {
+                return false;
+            }
+        }
+
+        public virtual IntervalSet Label
+        {
+            get
+            {
+                return null;
+            }
+        }
+
+        public abstract bool Matches(int symbol, int minVocabSymbol, int maxVocabSymbol);
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/TransitionType.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/TransitionType.cs
new file mode 100644
index 000000000..dbe6b81b9
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/TransitionType.cs
@@ -0,0 +1,49 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    public enum TransitionType
+    {
+        Invalid,
+        Epsilon,
+        Range,
+        Rule,
+        Predicate,
+        Atom,
+        Action,
+        Set,
+        NotSet,
+        Wildcard,
+        Precedence
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/WildcardTransition.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/WildcardTransition.cs
new file mode 100644
index 000000000..aa545c332
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Atn/WildcardTransition.cs
@@ -0,0 +1,62 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+    public sealed class WildcardTransition : Transition
+    {
+        public WildcardTransition(ATNState target)
+            : base(target)
+        {
+        }
+
+        public override Antlr4.Runtime.Atn.TransitionType TransitionType
+        {
+            get
+            {
+                return Antlr4.Runtime.Atn.TransitionType.Wildcard;
+            }
+        }
+
+        public override bool Matches(int symbol, int minVocabSymbol, int maxVocabSymbol)
+        {
+            return symbol >= minVocabSymbol && symbol <= maxVocabSymbol;
+        }
+
+        [return: NotNull]
+        public override string ToString()
+        {
+            return ".";
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/BailErrorStrategy.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/BailErrorStrategy.cs
new file mode 100644
index 000000000..519699b35
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/BailErrorStrategy.cs
@@ -0,0 +1,119 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime
+{
+    /// <summary>
+    /// This implementation of
+    /// <see cref="IAntlrErrorStrategy"/>
+    /// responds to syntax errors
+    /// by immediately canceling the parse operation with a
+    /// <see cref="ParseCanceledException"/>
+    /// . The implementation ensures that the
+    /// <see cref="ParserRuleContext.exception"/>
+    /// field is set for all parse tree nodes
+    /// that were not completed prior to encountering the error.
+    /// <p>
+    /// This error strategy is useful in the following scenarios.</p>
+    /// <ul>
+    /// <li><strong>Two-stage parsing:</strong> This error strategy allows the first
+    /// stage of two-stage parsing to immediately terminate if an error is
+    /// encountered, and immediately fall back to the second stage. In addition to
+    /// avoiding wasted work by attempting to recover from errors here, the empty
+    /// implementation of
+    /// <see cref="Sync(Parser)"/>
+    /// improves the performance of
+    /// the first stage.</li>
+    /// <li><strong>Silent validation:</strong> When syntax errors are not being
+    /// reported or logged, and the parse result is simply ignored if errors occur,
+    /// the
+    /// <see cref="BailErrorStrategy"/>
+    /// avoids wasting work on recovering from errors
+    /// when the result will be ignored either way.</li>
+    /// </ul>
+    /// <p>
+    /// <c>myparser.setErrorHandler(new BailErrorStrategy());</c>
+    /// </p>
+    /// </summary>
+    /// <seealso cref="Parser.ErrorHandler"/>
+    public class BailErrorStrategy : DefaultErrorStrategy
+    {
+        /// <summary>
+        /// Instead of recovering from exception
+        /// <paramref name="e"/>
+        /// , re-throw it wrapped
+        /// in a
+        /// <see cref="ParseCanceledException"/>
+        /// so it is not caught by the
+        /// rule function catches.  Use
+        /// <see cref="System.Exception.InnerException()"/>
+        /// to get the
+        /// original
+        /// <see cref="RecognitionException"/>
+        /// .
+        /// </summary>
+        public override void Recover(Parser recognizer, RecognitionException e)
+        {
+            for (ParserRuleContext context = recognizer.Context; context != null; context = ((ParserRuleContext)context.Parent))
+            {
+                context.exception = e;
+            }
+            throw new ParseCanceledException(e);
+        }
+
+        /// <summary>
+        /// Make sure we don't attempt to recover inline; if the parser
+        /// successfully recovers, it won't throw an exception.
+        /// </summary>
+        /// <remarks>
+        /// Make sure we don't attempt to recover inline; if the parser
+        /// successfully recovers, it won't throw an exception.
+        /// </remarks>
+        /// <exception cref="Antlr4.Runtime.RecognitionException"/>
+        public override IToken RecoverInline(Parser recognizer)
+        {
+            InputMismatchException e = new InputMismatchException(recognizer);
+            for (ParserRuleContext context = recognizer.Context; context != null; context = ((ParserRuleContext)context.Parent))
+            {
+                context.exception = e;
+            }
+            throw new ParseCanceledException(e);
+        }
+
+        /// <summary>Make sure we don't attempt to recover from problems in subrules.</summary>
+        /// <remarks>Make sure we don't attempt to recover from problems in subrules.</remarks>
+        public override void Sync(Parser recognizer)
+        {
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/BaseErrorListener.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/BaseErrorListener.cs
new file mode 100644
index 000000000..94e267a1a
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/BaseErrorListener.cs
@@ -0,0 +1,63 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Dfa;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime
+{
+    /// <summary>
+    /// Provides an empty default implementation of
+    /// <see cref="IAntlrErrorListener{Symbol}"/>
+    /// . The
+    /// default implementation of each method does nothing, but can be overridden as
+    /// necessary.
+    /// </summary>
+    /// <author>Sam Harwell</author>
+    public class BaseErrorListener : IParserErrorListener
+    {
+        public virtual void SyntaxError(IRecognizer recognizer, IToken offendingSymbol, int line, int charPositionInLine, string msg, RecognitionException e)
+        {
+        }
+
+        public virtual void ReportAmbiguity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, bool exact, BitSet ambigAlts, ATNConfigSet configs)
+        {
+        }
+
+        public virtual void ReportAttemptingFullContext(Parser recognizer, DFA dfa, int startIndex, int stopIndex, BitSet conflictingAlts, SimulatorState conflictState)
+        {
+        }
+
+        public virtual void ReportContextSensitivity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, int prediction, SimulatorState acceptState)
+        {
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/BufferedTokenStream.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/BufferedTokenStream.cs
new file mode 100644
index 000000000..7442d3037
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/BufferedTokenStream.cs
@@ -0,0 +1,725 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Antlr4.Runtime;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime
+{
+    /// <summary>
+    /// This implementation of
+    /// <see cref="ITokenStream"/>
+    /// loads tokens from a
+    /// <see cref="ITokenSource"/>
+    /// on-demand, and places the tokens in a buffer to provide
+    /// access to any previous token by index.
+    /// <p>
+    /// This token stream ignores the value of
+    /// <see cref="IToken.Channel()"/>
+    /// . If your
+    /// parser requires the token stream filter tokens to only those on a particular
+    /// channel, such as
+    /// <see cref="TokenConstants.DefaultChannel"/>
+    /// or
+    /// <see cref="TokenConstants.HiddenChannel"/>
+    /// , use a filtering token stream such a
+    /// <see cref="CommonTokenStream"/>
+    /// .</p>
+    /// </summary>
+    public class BufferedTokenStream : ITokenStream
+    {
+        /// <summary>
+        /// The
+        /// <see cref="ITokenSource"/>
+        /// from which tokens for this stream are fetched.
+        /// </summary>
+        [NotNull]
+        private ITokenSource _tokenSource;
+
+        /// <summary>A collection of all tokens fetched from the token source.</summary>
+        /// <remarks>
+        /// A collection of all tokens fetched from the token source. The list is
+        /// considered a complete view of the input once
+        /// <see cref="fetchedEOF"/>
+        /// is set
+        /// to
+        /// <see langword="true"/>
+        /// .
+        /// </remarks>
+        protected internal IList<IToken> tokens = new List<IToken>(100);
+
+        /// <summary>
+        /// The index into
+        /// <see cref="tokens"/>
+        /// of the current token (next token to
+        /// <see cref="Consume()"/>
+        /// ).
+        /// <see cref="tokens"/>
+        /// <c>[</c>
+        /// <see cref="p"/>
+        /// <c>]</c>
+        /// should be
+        /// <see cref="Lt(int)">LT(1)</see>
+        /// .
+        /// <p>This field is set to -1 when the stream is first constructed or when
+        /// <see cref="SetTokenSource(ITokenSource)"/>
+        /// is called, indicating that the first token has
+        /// not yet been fetched from the token source. For additional information,
+        /// see the documentation of
+        /// <see cref="IIntStream"/>
+        /// for a description of
+        /// Initializing Methods.</p>
+        /// </summary>
+        protected internal int p = -1;
+
+        /// <summary>
+        /// Indicates whether the
+        /// <see cref="TokenConstants.Eof"/>
+        /// token has been fetched from
+        /// <see cref="_tokenSource"/>
+        /// and added to
+        /// <see cref="tokens"/>
+        /// . This field improves
+        /// performance for the following cases:
+        /// <ul>
+        /// <li>
+        /// <see cref="Consume()"/>
+        /// : The lookahead check in
+        /// <see cref="Consume()"/>
+        /// to prevent
+        /// consuming the EOF symbol is optimized by checking the values of
+        /// <see cref="fetchedEOF"/>
+        /// and
+        /// <see cref="p"/>
+        /// instead of calling
+        /// <see cref="La(int)"/>
+        /// .</li>
+        /// <li>
+        /// <see cref="Fetch(int)"/>
+        /// : The check to prevent adding multiple EOF symbols into
+        /// <see cref="tokens"/>
+        /// is trivial with this field.</li>
+        /// </ul>
+        /// </summary>
+        protected internal bool fetchedEOF;
+
+        public BufferedTokenStream(ITokenSource tokenSource)
+        {
+            if (tokenSource == null)
+            {
+                throw new ArgumentNullException("tokenSource cannot be null");
+            }
+            this._tokenSource = tokenSource;
+        }
+
+        public virtual ITokenSource TokenSource
+        {
+            get
+            {
+                return _tokenSource;
+            }
+        }
+
+        public virtual int Index
+        {
+            get
+            {
+                return p;
+            }
+        }
+
+        public virtual int Mark()
+        {
+            return 0;
+        }
+
+        public virtual void Release(int marker)
+        {
+        }
+
+        // no resources to release
+        public virtual void Reset()
+        {
+            Seek(0);
+        }
+
+        public virtual void Seek(int index)
+        {
+            LazyInit();
+            p = AdjustSeekIndex(index);
+        }
+
+        public virtual int Size
+        {
+            get
+            {
+                return tokens.Count;
+            }
+        }
+
+        public virtual void Consume()
+        {
+            bool skipEofCheck;
+            if (p >= 0)
+            {
+                if (fetchedEOF)
+                {
+                    // the last token in tokens is EOF. skip check if p indexes any
+                    // fetched token except the last.
+                    skipEofCheck = p < tokens.Count - 1;
+                }
+                else
+                {
+                    // no EOF token in tokens. skip check if p indexes a fetched token.
+                    skipEofCheck = p < tokens.Count;
+                }
+            }
+            else
+            {
+                // not yet initialized
+                skipEofCheck = false;
+            }
+            if (!skipEofCheck && La(1) == IntStreamConstants.Eof)
+            {
+                throw new InvalidOperationException("cannot consume EOF");
+            }
+            if (Sync(p + 1))
+            {
+                p = AdjustSeekIndex(p + 1);
+            }
+        }
+
+        /// <summary>
+        /// Make sure index
+        /// <paramref name="i"/>
+        /// in tokens has a token.
+        /// </summary>
+        /// <returns>
+        /// 
+        /// <see langword="true"/>
+        /// if a token is located at index
+        /// <paramref name="i"/>
+        /// , otherwise
+        /// <see langword="false"/>
+        /// .
+        /// </returns>
+        /// <seealso cref="Get(int)"/>
+        protected internal virtual bool Sync(int i)
+        {
+            System.Diagnostics.Debug.Assert(i >= 0);
+            int n = i - tokens.Count + 1;
+            // how many more elements we need?
+            //System.out.println("sync("+i+") needs "+n);
+            if (n > 0)
+            {
+                int fetched = Fetch(n);
+                return fetched >= n;
+            }
+            return true;
+        }
+
+        /// <summary>
+        /// Add
+        /// <paramref name="n"/>
+        /// elements to buffer.
+        /// </summary>
+        /// <returns>The actual number of elements added to the buffer.</returns>
+        protected internal virtual int Fetch(int n)
+        {
+            if (fetchedEOF)
+            {
+                return 0;
+            }
+            for (int i = 0; i < n; i++)
+            {
+                IToken t = _tokenSource.NextToken();
+                if (t is IWritableToken)
+                {
+                    ((IWritableToken)t).TokenIndex = tokens.Count;
+                }
+                tokens.Add(t);
+                if (t.Type == TokenConstants.Eof)
+                {
+                    fetchedEOF = true;
+                    return i + 1;
+                }
+            }
+            return n;
+        }
+
+        public virtual IToken Get(int i)
+        {
+            if (i < 0 || i >= tokens.Count)
+            {
+                throw new ArgumentOutOfRangeException("token index " + i + " out of range 0.." + (tokens.Count - 1));
+            }
+            return tokens[i];
+        }
+
+        /// <summary>Get all tokens from start..stop inclusively.</summary>
+        /// <remarks>Get all tokens from start..stop inclusively.</remarks>
+        public virtual IList<IToken> Get(int start, int stop)
+        {
+            if (start < 0 || stop < 0)
+            {
+                return null;
+            }
+            LazyInit();
+            IList<IToken> subset = new List<IToken>();
+            if (stop >= tokens.Count)
+            {
+                stop = tokens.Count - 1;
+            }
+            for (int i = start; i <= stop; i++)
+            {
+                IToken t = tokens[i];
+                if (t.Type == TokenConstants.Eof)
+                {
+                    break;
+                }
+                subset.Add(t);
+            }
+            return subset;
+        }
+
+        public virtual int La(int i)
+        {
+            return Lt(i).Type;
+        }
+
+        protected internal virtual IToken Lb(int k)
+        {
+            if ((p - k) < 0)
+            {
+                return null;
+            }
+            return tokens[p - k];
+        }
+
+        [return: NotNull]
+        public virtual IToken Lt(int k)
+        {
+            LazyInit();
+            if (k == 0)
+            {
+                return null;
+            }
+            if (k < 0)
+            {
+                return Lb(-k);
+            }
+            int i = p + k - 1;
+            Sync(i);
+            if (i >= tokens.Count)
+            {
+                // return EOF token
+                // EOF must be last token
+                return tokens[tokens.Count - 1];
+            }
+            //		if ( i>range ) range = i;
+            return tokens[i];
+        }
+
+        /// <summary>
+        /// Allowed derived classes to modify the behavior of operations which change
+        /// the current stream position by adjusting the target token index of a seek
+        /// operation.
+        /// </summary>
+        /// <remarks>
+        /// Allowed derived classes to modify the behavior of operations which change
+        /// the current stream position by adjusting the target token index of a seek
+        /// operation. The default implementation simply returns
+        /// <paramref name="i"/>
+        /// . If an
+        /// exception is thrown in this method, the current stream index should not be
+        /// changed.
+        /// <p>For example,
+        /// <see cref="CommonTokenStream"/>
+        /// overrides this method to ensure that
+        /// the seek target is always an on-channel token.</p>
+        /// </remarks>
+        /// <param name="i">The target token index.</param>
+        /// <returns>The adjusted target token index.</returns>
+        protected internal virtual int AdjustSeekIndex(int i)
+        {
+            return i;
+        }
+
+        protected internal void LazyInit()
+        {
+            if (p == -1)
+            {
+                Setup();
+            }
+        }
+
+        protected internal virtual void Setup()
+        {
+            Sync(0);
+            p = AdjustSeekIndex(0);
+        }
+
+        /// <summary>Reset this token stream by setting its token source.</summary>
+        /// <remarks>Reset this token stream by setting its token source.</remarks>
+        public virtual void SetTokenSource(ITokenSource tokenSource)
+        {
+            this._tokenSource = tokenSource;
+            tokens.Clear();
+            p = -1;
+        }
+
+        public virtual IList<IToken> GetTokens()
+        {
+            return tokens;
+        }
+
+        public virtual IList<IToken> GetTokens(int start, int stop)
+        {
+            return GetTokens(start, stop, null);
+        }
+
+        /// <summary>
+        /// Given a start and stop index, return a
+        /// <c>List</c>
+        /// of all tokens in
+        /// the token type
+        /// <c>BitSet</c>
+        /// .  Return
+        /// <see langword="null"/>
+        /// if no tokens were found.  This
+        /// method looks at both on and off channel tokens.
+        /// </summary>
+        public virtual IList<IToken> GetTokens(int start, int stop, BitSet types)
+        {
+            LazyInit();
+            if (start < 0 || stop >= tokens.Count || stop < 0 || start >= tokens.Count)
+            {
+                throw new ArgumentOutOfRangeException("start " + start + " or stop " + stop + " not in 0.." + (tokens.Count - 1));
+            }
+            if (start > stop)
+            {
+                return null;
+            }
+            // list = tokens[start:stop]:{T t, t.getType() in types}
+            IList<IToken> filteredTokens = new List<IToken>();
+            for (int i = start; i <= stop; i++)
+            {
+                IToken t = tokens[i];
+                if (types == null || types.Get(t.Type))
+                {
+                    filteredTokens.Add(t);
+                }
+            }
+            if (filteredTokens.Count == 0)
+            {
+                filteredTokens = null;
+            }
+            return filteredTokens;
+        }
+
+        public virtual IList<IToken> GetTokens(int start, int stop, int ttype)
+        {
+            BitSet s = new BitSet(ttype);
+            s.Set(ttype);
+            return GetTokens(start, stop, s);
+        }
+
+        /// <summary>Given a starting index, return the index of the next token on channel.</summary>
+        /// <remarks>
+        /// Given a starting index, return the index of the next token on channel.
+        /// Return
+        /// <paramref name="i"/>
+        /// if
+        /// <c>tokens[i]</c>
+        /// is on channel. Return the index of
+        /// the EOF token if there are no tokens on channel between
+        /// <paramref name="i"/>
+        /// and
+        /// EOF.
+        /// </remarks>
+        protected internal virtual int NextTokenOnChannel(int i, int channel)
+        {
+            Sync(i);
+            if (i >= Size)
+            {
+                return Size - 1;
+            }
+            IToken token = tokens[i];
+            while (token.Channel != channel)
+            {
+                if (token.Type == TokenConstants.Eof)
+                {
+                    return i;
+                }
+                i++;
+                Sync(i);
+                token = tokens[i];
+            }
+            return i;
+        }
+
+        /// <summary>
+        /// Given a starting index, return the index of the previous token on
+        /// channel.
+        /// </summary>
+        /// <remarks>
+        /// Given a starting index, return the index of the previous token on
+        /// channel. Return
+        /// <paramref name="i"/>
+        /// if
+        /// <c>tokens[i]</c>
+        /// is on channel. Return -1
+        /// if there are no tokens on channel between
+        /// <paramref name="i"/>
+        /// and 0.
+        /// <p>
+        /// If
+        /// <paramref name="i"/>
+        /// specifies an index at or after the EOF token, the EOF token
+        /// index is returned. This is due to the fact that the EOF token is treated
+        /// as though it were on every channel.</p>
+        /// </remarks>
+        protected internal virtual int PreviousTokenOnChannel(int i, int channel)
+        {
+            Sync(i);
+            if (i >= Size)
+            {
+                // the EOF token is on every channel
+                return Size - 1;
+            }
+            while (i >= 0)
+            {
+                IToken token = tokens[i];
+                if (token.Type == TokenConstants.Eof || token.Channel == channel)
+                {
+                    return i;
+                }
+                i--;
+            }
+            return i;
+        }
+
+        /// <summary>
+        /// Collect all tokens on specified channel to the right of
+        /// the current token up until we see a token on
+        /// <see cref="Lexer.DefaultTokenChannel"/>
+        /// or
+        /// EOF. If
+        /// <paramref name="channel"/>
+        /// is
+        /// <c>-1</c>
+        /// , find any non default channel token.
+        /// </summary>
+        public virtual IList<IToken> GetHiddenTokensToRight(int tokenIndex, int channel)
+        {
+            LazyInit();
+            if (tokenIndex < 0 || tokenIndex >= tokens.Count)
+            {
+                throw new ArgumentOutOfRangeException(tokenIndex + " not in 0.." + (tokens.Count - 1));
+            }
+            int nextOnChannel = NextTokenOnChannel(tokenIndex + 1, Lexer.DefaultTokenChannel);
+            int to;
+            int from = tokenIndex + 1;
+            // if none onchannel to right, nextOnChannel=-1 so set to = last token
+            if (nextOnChannel == -1)
+            {
+                to = Size - 1;
+            }
+            else
+            {
+                to = nextOnChannel;
+            }
+            return FilterForChannel(from, to, channel);
+        }
+
+        /// <summary>
+        /// Collect all hidden tokens (any off-default channel) to the right of
+        /// the current token up until we see a token on
+        /// <see cref="Lexer.DefaultTokenChannel"/>
+        /// or EOF.
+        /// </summary>
+        public virtual IList<IToken> GetHiddenTokensToRight(int tokenIndex)
+        {
+            return GetHiddenTokensToRight(tokenIndex, -1);
+        }
+
+        /// <summary>
+        /// Collect all tokens on specified channel to the left of
+        /// the current token up until we see a token on
+        /// <see cref="Lexer.DefaultTokenChannel"/>
+        /// .
+        /// If
+        /// <paramref name="channel"/>
+        /// is
+        /// <c>-1</c>
+        /// , find any non default channel token.
+        /// </summary>
+        public virtual IList<IToken> GetHiddenTokensToLeft(int tokenIndex, int channel)
+        {
+            LazyInit();
+            if (tokenIndex < 0 || tokenIndex >= tokens.Count)
+            {
+                throw new ArgumentOutOfRangeException(tokenIndex + " not in 0.." + (tokens.Count - 1));
+            }
+            if (tokenIndex == 0)
+            {
+                // obviously no tokens can appear before the first token
+                return null;
+            }
+            int prevOnChannel = PreviousTokenOnChannel(tokenIndex - 1, Lexer.DefaultTokenChannel);
+            if (prevOnChannel == tokenIndex - 1)
+            {
+                return null;
+            }
+            // if none onchannel to left, prevOnChannel=-1 then from=0
+            int from = prevOnChannel + 1;
+            int to = tokenIndex - 1;
+            return FilterForChannel(from, to, channel);
+        }
+
+        /// <summary>
+        /// Collect all hidden tokens (any off-default channel) to the left of
+        /// the current token up until we see a token on
+        /// <see cref="Lexer.DefaultTokenChannel"/>
+        /// .
+        /// </summary>
+        public virtual IList<IToken> GetHiddenTokensToLeft(int tokenIndex)
+        {
+            return GetHiddenTokensToLeft(tokenIndex, -1);
+        }
+
+        protected internal virtual IList<IToken> FilterForChannel(int from, int to, int channel)
+        {
+            IList<IToken> hidden = new List<IToken>();
+            for (int i = from; i <= to; i++)
+            {
+                IToken t = tokens[i];
+                if (channel == -1)
+                {
+                    if (t.Channel != Lexer.DefaultTokenChannel)
+                    {
+                        hidden.Add(t);
+                    }
+                }
+                else
+                {
+                    if (t.Channel == channel)
+                    {
+                        hidden.Add(t);
+                    }
+                }
+            }
+            if (hidden.Count == 0)
+            {
+                return null;
+            }
+            return hidden;
+        }
+
+        public virtual string SourceName
+        {
+            get
+            {
+                return _tokenSource.SourceName;
+            }
+        }
+
+        /// <summary>Get the text of all tokens in this buffer.</summary>
+        /// <remarks>Get the text of all tokens in this buffer.</remarks>
+        [return: NotNull]
+        public virtual string GetText()
+        {
+            Fill();
+            return GetText(Interval.Of(0, Size - 1));
+        }
+
+        [return: NotNull]
+        public virtual string GetText(Interval interval)
+        {
+            int start = interval.a;
+            int stop = interval.b;
+            if (start < 0 || stop < 0)
+            {
+                return string.Empty;
+            }
+            LazyInit();
+            if (stop >= tokens.Count)
+            {
+                stop = tokens.Count - 1;
+            }
+            StringBuilder buf = new StringBuilder();
+            for (int i = start; i <= stop; i++)
+            {
+                IToken t = tokens[i];
+                if (t.Type == TokenConstants.Eof)
+                {
+                    break;
+                }
+                buf.Append(t.Text);
+            }
+            return buf.ToString();
+        }
+
+        [return: NotNull]
+        public virtual string GetText(RuleContext ctx)
+        {
+            return GetText(ctx.SourceInterval);
+        }
+
+        [return: NotNull]
+        public virtual string GetText(IToken start, IToken stop)
+        {
+            if (start != null && stop != null)
+            {
+                return GetText(Interval.Of(start.TokenIndex, stop.TokenIndex));
+            }
+            return string.Empty;
+        }
+
+        /// <summary>Get all tokens from lexer until EOF.</summary>
+        /// <remarks>Get all tokens from lexer until EOF.</remarks>
+        public virtual void Fill()
+        {
+            LazyInit();
+            int blockSize = 1000;
+            while (true)
+            {
+                int fetched = Fetch(blockSize);
+                if (fetched < blockSize)
+                {
+                    return;
+                }
+            }
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/CommonToken.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/CommonToken.cs
new file mode 100644
index 000000000..090b37183
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/CommonToken.cs
@@ -0,0 +1,378 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System;
+using Antlr4.Runtime;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime
+{
+    [System.Serializable]
+    public class CommonToken : IWritableToken
+    {
+        private const long serialVersionUID = -6708843461296520577L;
+
+        /// <summary>
+        /// An empty
+        /// <see cref="Tuple{T1, T2}"/>
+        /// which is used as the default value of
+        /// <see cref="source"/>
+        /// for tokens that do not have a source.
+        /// </summary>
+        protected internal static readonly Tuple<ITokenSource, ICharStream> EmptySource = Tuple.Create<ITokenSource, ICharStream>(null, null);
+
+        /// <summary>
+        /// This is the backing field for the <see cref="Type"/> property.
+        /// </summary>
+        private int _type;
+
+        /// <summary>
+        /// This is the backing field for the <see cref="Line"/> property.
+        /// </summary>
+        private int _line;
+
+        /// <summary>
+        /// This is the backing field for the <see cref="Column"/> property.
+        /// </summary>
+        protected internal int charPositionInLine = -1;
+
+        /// <summary>
+        /// This is the backing field for the <see cref="Channel"/> property.
+        /// </summary>
+        private int _channel = TokenConstants.DefaultChannel;
+
+        /// <summary>
+        /// This is the backing field for
+        /// <see cref="TokenSource()"/>
+        /// and
+        /// <see cref="InputStream()"/>
+        /// .
+        /// <p>
+        /// These properties share a field to reduce the memory footprint of
+        /// <see cref="CommonToken"/>
+        /// . Tokens created by a
+        /// <see cref="CommonTokenFactory"/>
+        /// from
+        /// the same source and input stream share a reference to the same
+        /// <see cref="Tuple{T1, T2}"/>
+        /// containing these values.</p>
+        /// </summary>
+        [NotNull]
+        protected internal Tuple<ITokenSource, ICharStream> source;
+
+        /// <summary>
+        /// This is the backing field for the <see cref="Text"/> property.
+        /// </summary>
+        /// <seealso cref="Text"/>
+        private string _text;
+
+        /// <summary>
+        /// This is the backing field for the <see cref="TokenIndex"/> property.
+        /// </summary>
+        protected internal int index = -1;
+
+        /// <summary>
+        /// This is the backing field for the <see cref="StartIndex"/> property.
+        /// </summary>
+        protected internal int start;
+
+        /// <summary>
+        /// This is the backing field for the <see cref="StopIndex"/> property.
+        /// </summary>
+        protected internal int stop;
+
+        /// <summary>
+        /// Constructs a new
+        /// <see cref="CommonToken"/>
+        /// with the specified token type.
+        /// </summary>
+        /// <param name="type">The token type.</param>
+        public CommonToken(int type)
+        {
+            // set to invalid position
+            this._type = type;
+            this.source = EmptySource;
+        }
+
+        public CommonToken(Tuple<ITokenSource, ICharStream> source, int type, int channel, int start, int stop)
+        {
+            this.source = source;
+            this._type = type;
+            this._channel = channel;
+            this.start = start;
+            this.stop = stop;
+            if (source.Item1 != null)
+            {
+                this._line = source.Item1.Line;
+                this.charPositionInLine = source.Item1.Column;
+            }
+        }
+
+        /// <summary>
+        /// Constructs a new
+        /// <see cref="CommonToken"/>
+        /// with the specified token type and
+        /// text.
+        /// </summary>
+        /// <param name="type">The token type.</param>
+        /// <param name="text">The text of the token.</param>
+        public CommonToken(int type, string text)
+        {
+            this._type = type;
+            this._channel = TokenConstants.DefaultChannel;
+            this._text = text;
+            this.source = EmptySource;
+        }
+
+        /// <summary>
+        /// Constructs a new
+        /// <see cref="CommonToken"/>
+        /// as a copy of another
+        /// <see cref="IToken"/>
+        /// .
+        /// <p>
+        /// If
+        /// <paramref name="oldToken"/>
+        /// is also a
+        /// <see cref="CommonToken"/>
+        /// instance, the newly
+        /// constructed token will share a reference to the
+        /// <see cref="Text()"/>
+        /// field and
+        /// the
+        /// <see cref="Tuple{T1, T2}"/>
+        /// stored in
+        /// <see cref="source"/>
+        /// . Otherwise,
+        /// <see cref="Text()"/>
+        /// will
+        /// be assigned the result of calling
+        /// <see cref="Text()"/>
+        /// , and
+        /// <see cref="source"/>
+        /// will be constructed from the result of
+        /// <see cref="IToken.TokenSource()"/>
+        /// and
+        /// <see cref="IToken.InputStream()"/>
+        /// .</p>
+        /// </summary>
+        /// <param name="oldToken">The token to copy.</param>
+        public CommonToken(IToken oldToken)
+        {
+            _type = oldToken.Type;
+            _line = oldToken.Line;
+            index = oldToken.TokenIndex;
+            charPositionInLine = oldToken.Column;
+            _channel = oldToken.Channel;
+            start = oldToken.StartIndex;
+            stop = oldToken.StopIndex;
+            if (oldToken is Antlr4.Runtime.CommonToken)
+            {
+                _text = ((Antlr4.Runtime.CommonToken)oldToken)._text;
+                source = ((Antlr4.Runtime.CommonToken)oldToken).source;
+            }
+            else
+            {
+                _text = oldToken.Text;
+                source = Tuple.Create(oldToken.TokenSource, oldToken.InputStream);
+            }
+        }
+
+        public virtual int Type
+        {
+            get
+            {
+                return _type;
+            }
+            set
+            {
+ 				this._type = value;
+            }
+        }
+
+        public virtual int Line
+        {
+            get
+            {
+                return _line;
+            }
+            set
+            {
+ 				this._line = value;
+            }
+        }
+
+        /// <summary>Explicitly set the text for this token.</summary>
+        /// <remarks>
+        /// Explicitly set the text for this token. If {code text} is not
+        /// <see langword="null"/>
+        /// , then
+        /// <see cref="Text()"/>
+        /// will return this value rather than
+        /// extracting the text from the input.
+        /// </remarks>
+        /// <value>
+        /// The explicit text of the token, or
+        /// <see langword="null"/>
+        /// if the text
+        /// should be obtained from the input along with the start and stop indexes
+        /// of the token.
+        /// </value>
+        public virtual string Text
+        {
+            get
+            {
+                if (_text != null)
+                {
+                    return _text;
+                }
+                ICharStream input = InputStream;
+                if (input == null)
+                {
+                    return null;
+                }
+                int n = input.Size;
+                if (start < n && stop < n)
+                {
+                    return input.GetText(Interval.Of(start, stop));
+                }
+                else
+                {
+                    return "<EOF>";
+                }
+            }
+            set
+            {
+ 				this._text = value;
+            }
+        }
+
+        public virtual int Column
+        {
+            get
+            {
+                return charPositionInLine;
+            }
+            set
+            {
+                int charPositionInLine = value;
+                this.charPositionInLine = charPositionInLine;
+            }
+        }
+
+        public virtual int Channel
+        {
+            get
+            {
+                return _channel;
+            }
+            set
+            {
+                this._channel = value;
+            }
+        }
+
+        public virtual int StartIndex
+        {
+            get
+            {
+                return start;
+            }
+            set
+            {
+                int start = value;
+                this.start = start;
+            }
+        }
+
+        public virtual int StopIndex
+        {
+            get
+            {
+                return stop;
+            }
+            set
+            {
+                int stop = value;
+                this.stop = stop;
+            }
+        }
+
+        public virtual int TokenIndex
+        {
+            get
+            {
+                return index;
+            }
+            set
+            {
+                int index = value;
+                this.index = index;
+            }
+        }
+
+        public virtual ITokenSource TokenSource
+        {
+            get
+            {
+                return source.Item1;
+            }
+        }
+
+        public virtual ICharStream InputStream
+        {
+            get
+            {
+                return source.Item2;
+            }
+        }
+
+        public override string ToString()
+        {
+            string channelStr = string.Empty;
+            if (_channel > 0)
+            {
+                channelStr = ",channel=" + _channel;
+            }
+            string txt = Text;
+            if (txt != null)
+            {
+                txt = txt.Replace("\n", "\\n");
+                txt = txt.Replace("\r", "\\r");
+                txt = txt.Replace("\t", "\\t");
+            }
+            else
+            {
+                txt = "<no text>";
+            }
+            return "[@" + TokenIndex + "," + start + ":" + stop + "='" + txt + "',<" + _type + ">" + channelStr + "," + _line + ":" + Column + "]";
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/CommonTokenFactory.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/CommonTokenFactory.cs
new file mode 100644
index 000000000..a3ec8e1bc
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/CommonTokenFactory.cs
@@ -0,0 +1,161 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System;
+using Antlr4.Runtime;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime
+{
+    /// <summary>
+    /// This default implementation of
+    /// <see cref="ITokenFactory"/>
+    /// creates
+    /// <see cref="CommonToken"/>
+    /// objects.
+    /// </summary>
+    public class CommonTokenFactory : ITokenFactory
+    {
+        /// <summary>
+        /// The default
+        /// <see cref="CommonTokenFactory"/>
+        /// instance.
+        /// <p>
+        /// This token factory does not explicitly copy token text when constructing
+        /// tokens.</p>
+        /// </summary>
+        public static readonly ITokenFactory Default = new Antlr4.Runtime.CommonTokenFactory();
+
+        /// <summary>
+        /// Indicates whether
+        /// <see cref="CommonToken.Text"/>
+        /// should be called after
+        /// constructing tokens to explicitly set the text. This is useful for cases
+        /// where the input stream might not be able to provide arbitrary substrings
+        /// of text from the input after the lexer creates a token (e.g. the
+        /// implementation of
+        /// <see cref="ICharStream.GetText(Antlr4.Runtime.Misc.Interval)"/>
+        /// in
+        /// <see cref="UnbufferedCharStream"/>
+        /// throws an
+        /// <see cref="System.NotSupportedException"/>
+        /// ). Explicitly setting the token text
+        /// allows
+        /// <see cref="IToken.Text()"/>
+        /// to be called at any time regardless of the
+        /// input stream implementation.
+        /// <p>
+        /// The default value is
+        /// <see langword="false"/>
+        /// to avoid the performance and memory
+        /// overhead of copying text for every token unless explicitly requested.</p>
+        /// </summary>
+        protected internal readonly bool copyText;
+
+        /// <summary>
+        /// Constructs a
+        /// <see cref="CommonTokenFactory"/>
+        /// with the specified value for
+        /// <see cref="copyText"/>
+        /// .
+        /// <p>
+        /// When
+        /// <paramref name="copyText"/>
+        /// is
+        /// <see langword="false"/>
+        /// , the
+        /// <see cref="Default"/>
+        /// instance
+        /// should be used instead of constructing a new instance.</p>
+        /// </summary>
+        /// <param name="copyText">
+        /// The value for
+        /// <see cref="copyText"/>
+        /// .
+        /// </param>
+        public CommonTokenFactory(bool copyText)
+        {
+            this.copyText = copyText;
+        }
+
+        /// <summary>
+        /// Constructs a
+        /// <see cref="CommonTokenFactory"/>
+        /// with
+        /// <see cref="copyText"/>
+        /// set to
+        /// <see langword="false"/>
+        /// .
+        /// <p>
+        /// The
+        /// <see cref="Default"/>
+        /// instance should be used instead of calling this
+        /// directly.</p>
+        /// </summary>
+        public CommonTokenFactory()
+            : this(false)
+        {
+        }
+
+        public virtual CommonToken Create(Tuple<ITokenSource, ICharStream> source, int type, string text, int channel, int start, int stop, int line, int charPositionInLine)
+        {
+            CommonToken t = new CommonToken(source, type, channel, start, stop);
+            t.Line = line;
+            t.Column = charPositionInLine;
+            if (text != null)
+            {
+                t.Text = text;
+            }
+            else
+            {
+                if (copyText && source.Item2 != null)
+                {
+                    t.Text = source.Item2.GetText(Interval.Of(start, stop));
+                }
+            }
+            return t;
+        }
+
+        IToken ITokenFactory.Create(Tuple<ITokenSource, ICharStream> source, int type, string text, int channel, int start, int stop, int line, int charPositionInLine)
+        {
+            return Create(source, type, text, channel, start, stop, line, charPositionInLine);
+        }
+
+        public virtual CommonToken Create(int type, string text)
+        {
+            return new CommonToken(type, text);
+        }
+
+        IToken ITokenFactory.Create(int type, string text)
+        {
+            return Create(type, text);
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/CommonTokenStream.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/CommonTokenStream.cs
new file mode 100644
index 000000000..c02799aa3
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/CommonTokenStream.cs
@@ -0,0 +1,201 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime
+{
+    /// <summary>
+    /// This class extends
+    /// <see cref="BufferedTokenStream"/>
+    /// with functionality to filter
+    /// token streams to tokens on a particular channel (tokens where
+    /// <see cref="IToken.Channel()"/>
+    /// returns a particular value).
+    /// <p>
+    /// This token stream provides access to all tokens by index or when calling
+    /// methods like
+    /// <see cref="BufferedTokenStream.GetText()"/>
+    /// . The channel filtering is only used for code
+    /// accessing tokens via the lookahead methods
+    /// <see cref="BufferedTokenStream.La(int)"/>
+    /// ,
+    /// <see cref="Lt(int)"/>
+    /// , and
+    /// <see cref="Lb(int)"/>
+    /// .</p>
+    /// <p>
+    /// By default, tokens are placed on the default channel
+    /// (
+    /// <see cref="TokenConstants.DefaultChannel"/>
+    /// ), but may be reassigned by using the
+    /// <c>-&gt;channel(HIDDEN)</c>
+    /// lexer command, or by using an embedded action to
+    /// call
+    /// <see cref="Lexer.Channel"/>
+    /// .
+    /// </p>
+    /// <p>
+    /// Note: lexer rules which use the
+    /// <c>-&gt;skip</c>
+    /// lexer command or call
+    /// <see cref="Lexer.Skip()"/>
+    /// do not produce tokens at all, so input text matched by
+    /// such a rule will not be available as part of the token stream, regardless of
+    /// channel.</p>
+    /// </summary>
+    public class CommonTokenStream : BufferedTokenStream
+    {
+        /// <summary>Specifies the channel to use for filtering tokens.</summary>
+        /// <remarks>
+        /// Specifies the channel to use for filtering tokens.
+        /// <p>
+        /// The default value is
+        /// <see cref="TokenConstants.DefaultChannel"/>
+        /// , which matches the
+        /// default channel assigned to tokens created by the lexer.</p>
+        /// </remarks>
+        protected internal int channel = TokenConstants.DefaultChannel;
+
+        /// <summary>
+        /// Constructs a new
+        /// <see cref="CommonTokenStream"/>
+        /// using the specified token
+        /// source and the default token channel (
+        /// <see cref="TokenConstants.DefaultChannel"/>
+        /// ).
+        /// </summary>
+        /// <param name="tokenSource">The token source.</param>
+        public CommonTokenStream(ITokenSource tokenSource)
+            : base(tokenSource)
+        {
+        }
+
+        /// <summary>
+        /// Constructs a new
+        /// <see cref="CommonTokenStream"/>
+        /// using the specified token
+        /// source and filtering tokens to the specified channel. Only tokens whose
+        /// <see cref="IToken.Channel()"/>
+        /// matches
+        /// <paramref name="channel"/>
+        /// or have the
+        /// <see cref="IToken.Type()"/>
+        /// equal to
+        /// <see cref="TokenConstants.Eof"/>
+        /// will be returned by the
+        /// token stream lookahead methods.
+        /// </summary>
+        /// <param name="tokenSource">The token source.</param>
+        /// <param name="channel">The channel to use for filtering tokens.</param>
+        public CommonTokenStream(ITokenSource tokenSource, int channel)
+            : this(tokenSource)
+        {
+            this.channel = channel;
+        }
+
+        protected internal override int AdjustSeekIndex(int i)
+        {
+            return NextTokenOnChannel(i, channel);
+        }
+
+        protected internal override IToken Lb(int k)
+        {
+            if (k == 0 || (p - k) < 0)
+            {
+                return null;
+            }
+            int i = p;
+            int n = 1;
+            // find k good tokens looking backwards
+            while (n <= k)
+            {
+                // skip off-channel tokens
+                i = PreviousTokenOnChannel(i - 1, channel);
+                n++;
+            }
+            if (i < 0)
+            {
+                return null;
+            }
+            return tokens[i];
+        }
+
+        public override IToken Lt(int k)
+        {
+            //System.out.println("enter LT("+k+")");
+            LazyInit();
+            if (k == 0)
+            {
+                return null;
+            }
+            if (k < 0)
+            {
+                return Lb(-k);
+            }
+            int i = p;
+            int n = 1;
+            // we know tokens[p] is a good one
+            // find k good tokens
+            while (n < k)
+            {
+                // skip off-channel tokens, but make sure to not look past EOF
+                if (Sync(i + 1))
+                {
+                    i = NextTokenOnChannel(i + 1, channel);
+                }
+                n++;
+            }
+            //		if ( i>range ) range = i;
+            return tokens[i];
+        }
+
+        /// <summary>Count EOF just once.</summary>
+        /// <remarks>Count EOF just once.</remarks>
+        public virtual int GetNumberOfOnChannelTokens()
+        {
+            int n = 0;
+            Fill();
+            for (int i = 0; i < tokens.Count; i++)
+            {
+                IToken t = tokens[i];
+                if (t.Channel == channel)
+                {
+                    n++;
+                }
+                if (t.Type == TokenConstants.Eof)
+                {
+                    break;
+                }
+            }
+            return n;
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/ConsoleErrorListener.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/ConsoleErrorListener.cs
new file mode 100644
index 000000000..9af15b8b3
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/ConsoleErrorListener.cs
@@ -0,0 +1,73 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+
+#if !PORTABLE
+
+using Antlr4.Runtime;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime
+{
+    /// <author>Sam Harwell</author>
+    public class ConsoleErrorListener<Symbol> : IAntlrErrorListener<Symbol>
+    {
+        /// <summary>
+        /// Provides a default instance of
+        /// <see cref="ConsoleErrorListener{Symbol}"/>
+        /// .
+        /// </summary>
+        public static readonly ConsoleErrorListener<Symbol> Instance = new ConsoleErrorListener<Symbol>();
+
+        /// <summary>
+        /// <inheritDoc/>
+        /// <p>
+        /// This implementation prints messages to
+        /// <see cref="System.Console.Error"/>
+        /// containing the
+        /// values of
+        /// <paramref name="line"/>
+        /// ,
+        /// <paramref name="charPositionInLine"/>
+        /// , and
+        /// <paramref name="msg"/>
+        /// using
+        /// the following format.</p>
+        /// <pre>
+        /// line <em>line</em>:<em>charPositionInLine</em> <em>msg</em>
+        /// </pre>
+        /// </summary>
+        public virtual void SyntaxError(IRecognizer recognizer, Symbol offendingSymbol, int line, int charPositionInLine, string msg, RecognitionException e)
+        {
+            System.Console.Error.WriteLine("line " + line + ":" + charPositionInLine + " " + msg);
+        }
+    }
+}
+
+#endif
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/DefaultErrorStrategy.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/DefaultErrorStrategy.cs
new file mode 100644
index 000000000..ff8e87c86
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/DefaultErrorStrategy.cs
@@ -0,0 +1,831 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System;
+using Antlr4.Runtime;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime
+{
+    /// <summary>
+    /// This is the default implementation of
+    /// <see cref="IAntlrErrorStrategy"/>
+    /// used for
+    /// error reporting and recovery in ANTLR parsers.
+    /// </summary>
+    public class DefaultErrorStrategy : IAntlrErrorStrategy
+    {
+        /// <summary>
+        /// Indicates whether the error strategy is currently "recovering from an
+        /// error".
+        /// </summary>
+        /// <remarks>
+        /// Indicates whether the error strategy is currently "recovering from an
+        /// error". This is used to suppress reporting multiple error messages while
+        /// attempting to recover from a detected syntax error.
+        /// </remarks>
+        /// <seealso cref="InErrorRecoveryMode(Parser)"/>
+        protected internal bool errorRecoveryMode = false;
+
+        /// <summary>The index into the input stream where the last error occurred.</summary>
+        /// <remarks>
+        /// The index into the input stream where the last error occurred.
+        /// This is used to prevent infinite loops where an error is found
+        /// but no token is consumed during recovery...another error is found,
+        /// ad nauseum.  This is a failsafe mechanism to guarantee that at least
+        /// one token/tree node is consumed for two errors.
+        /// </remarks>
+        protected internal int lastErrorIndex = -1;
+
+        protected internal IntervalSet lastErrorStates;
+
+        /// <summary>
+        /// <inheritDoc/>
+        /// <p>The default implementation simply calls
+        /// <see cref="EndErrorCondition(Parser)"/>
+        /// to
+        /// ensure that the handler is not in error recovery mode.</p>
+        /// </summary>
+        public virtual void Reset(Parser recognizer)
+        {
+            EndErrorCondition(recognizer);
+        }
+
+        /// <summary>
+        /// This method is called to enter error recovery mode when a recognition
+        /// exception is reported.
+        /// </summary>
+        /// <remarks>
+        /// This method is called to enter error recovery mode when a recognition
+        /// exception is reported.
+        /// </remarks>
+        /// <param name="recognizer">the parser instance</param>
+        protected internal virtual void BeginErrorCondition(Parser recognizer)
+        {
+            errorRecoveryMode = true;
+        }
+
+        /// <summary><inheritDoc/></summary>
+        public virtual bool InErrorRecoveryMode(Parser recognizer)
+        {
+            return errorRecoveryMode;
+        }
+
+        /// <summary>
+        /// This method is called to leave error recovery mode after recovering from
+        /// a recognition exception.
+        /// </summary>
+        /// <remarks>
+        /// This method is called to leave error recovery mode after recovering from
+        /// a recognition exception.
+        /// </remarks>
+        /// <param name="recognizer"/>
+        protected internal virtual void EndErrorCondition(Parser recognizer)
+        {
+            errorRecoveryMode = false;
+            lastErrorStates = null;
+            lastErrorIndex = -1;
+        }
+
+        /// <summary>
+        /// <inheritDoc/>
+        /// <p>The default implementation simply calls
+        /// <see cref="EndErrorCondition(Parser)"/>
+        /// .</p>
+        /// </summary>
+        public virtual void ReportMatch(Parser recognizer)
+        {
+            EndErrorCondition(recognizer);
+        }
+
+        /// <summary>
+        /// <inheritDoc/>
+        /// <p>The default implementation returns immediately if the handler is already
+        /// in error recovery mode. Otherwise, it calls
+        /// <see cref="BeginErrorCondition(Parser)"/>
+        /// and dispatches the reporting task based on the runtime type of
+        /// <paramref name="e"/>
+        /// according to the following table.</p>
+        /// <ul>
+        /// <li>
+        /// <see cref="NoViableAltException"/>
+        /// : Dispatches the call to
+        /// <see cref="ReportNoViableAlternative(Parser, NoViableAltException)"/>
+        /// </li>
+        /// <li>
+        /// <see cref="InputMismatchException"/>
+        /// : Dispatches the call to
+        /// <see cref="ReportInputMismatch(Parser, InputMismatchException)"/>
+        /// </li>
+        /// <li>
+        /// <see cref="FailedPredicateException"/>
+        /// : Dispatches the call to
+        /// <see cref="ReportFailedPredicate(Parser, FailedPredicateException)"/>
+        /// </li>
+        /// <li>All other types: calls
+        /// <see cref="Parser.NotifyErrorListeners(string)"/>
+        /// to report
+        /// the exception</li>
+        /// </ul>
+        /// </summary>
+        public virtual void ReportError(Parser recognizer, RecognitionException e)
+        {
+            // if we've already reported an error and have not matched a token
+            // yet successfully, don't report any errors.
+            if (InErrorRecoveryMode(recognizer))
+            {
+                //			System.err.print("[SPURIOUS] ");
+                return;
+            }
+            // don't report spurious errors
+            BeginErrorCondition(recognizer);
+            if (e is NoViableAltException)
+            {
+                ReportNoViableAlternative(recognizer, (NoViableAltException)e);
+            }
+            else
+            {
+                if (e is InputMismatchException)
+                {
+                    ReportInputMismatch(recognizer, (InputMismatchException)e);
+                }
+                else
+                {
+                    if (e is FailedPredicateException)
+                    {
+                        ReportFailedPredicate(recognizer, (FailedPredicateException)e);
+                    }
+                    else
+                    {
+#if !PORTABLE
+                        System.Console.Error.WriteLine("unknown recognition error type: " + e.GetType().FullName);
+#endif
+                        NotifyErrorListeners(recognizer, e.Message, e);
+                    }
+                }
+            }
+        }
+
+        protected internal virtual void NotifyErrorListeners(Parser recognizer, string message, RecognitionException e)
+        {
+            recognizer.NotifyErrorListeners(e.OffendingToken, message, e);
+        }
+
+        /// <summary>
+        /// <inheritDoc/>
+        /// <p>The default implementation resynchronizes the parser by consuming tokens
+        /// until we find one in the resynchronization set--loosely the set of tokens
+        /// that can follow the current rule.</p>
+        /// </summary>
+        public virtual void Recover(Parser recognizer, RecognitionException e)
+        {
+            //		System.out.println("recover in "+recognizer.getRuleInvocationStack()+
+            //						   " index="+recognizer.getInputStream().index()+
+            //						   ", lastErrorIndex="+
+            //						   lastErrorIndex+
+            //						   ", states="+lastErrorStates);
+            if (lastErrorIndex == ((ITokenStream)recognizer.InputStream).Index && lastErrorStates != null && lastErrorStates.Contains(recognizer.State))
+            {
+                // uh oh, another error at same token index and previously-visited
+                // state in ATN; must be a case where LT(1) is in the recovery
+                // token set so nothing got consumed. Consume a single token
+                // at least to prevent an infinite loop; this is a failsafe.
+                //			System.err.println("seen error condition before index="+
+                //							   lastErrorIndex+", states="+lastErrorStates);
+                //			System.err.println("FAILSAFE consumes "+recognizer.getTokenNames()[recognizer.getInputStream().LA(1)]);
+                recognizer.Consume();
+            }
+            lastErrorIndex = ((ITokenStream)recognizer.InputStream).Index;
+            if (lastErrorStates == null)
+            {
+                lastErrorStates = new IntervalSet();
+            }
+            lastErrorStates.Add(recognizer.State);
+            IntervalSet followSet = GetErrorRecoverySet(recognizer);
+            ConsumeUntil(recognizer, followSet);
+        }
+
+        /// <summary>
+        /// The default implementation of
+        /// <see cref="IAntlrErrorStrategy.Sync(Parser)"/>
+        /// makes sure
+        /// that the current lookahead symbol is consistent with what were expecting
+        /// at this point in the ATN. You can call this anytime but ANTLR only
+        /// generates code to check before subrules/loops and each iteration.
+        /// <p>Implements Jim Idle's magic sync mechanism in closures and optional
+        /// subrules. E.g.,</p>
+        /// <pre>
+        /// a : sync ( stuff sync )* ;
+        /// sync : {consume to what can follow sync} ;
+        /// </pre>
+        /// At the start of a sub rule upon error,
+        /// <see cref="Sync(Parser)"/>
+        /// performs single
+        /// token deletion, if possible. If it can't do that, it bails on the current
+        /// rule and uses the default error recovery, which consumes until the
+        /// resynchronization set of the current rule.
+        /// <p>If the sub rule is optional (
+        /// <c>(...)?</c>
+        /// ,
+        /// <c>(...)*</c>
+        /// , or block
+        /// with an empty alternative), then the expected set includes what follows
+        /// the subrule.</p>
+        /// <p>During loop iteration, it consumes until it sees a token that can start a
+        /// sub rule or what follows loop. Yes, that is pretty aggressive. We opt to
+        /// stay in the loop as long as possible.</p>
+        /// <p><strong>ORIGINS</strong></p>
+        /// <p>Previous versions of ANTLR did a poor job of their recovery within loops.
+        /// A single mismatch token or missing token would force the parser to bail
+        /// out of the entire rules surrounding the loop. So, for rule</p>
+        /// <pre>
+        /// classDef : 'class' ID '{' member* '}'
+        /// </pre>
+        /// input with an extra token between members would force the parser to
+        /// consume until it found the next class definition rather than the next
+        /// member definition of the current class.
+        /// <p>This functionality cost a little bit of effort because the parser has to
+        /// compare token set at the start of the loop and at each iteration. If for
+        /// some reason speed is suffering for you, you can turn off this
+        /// functionality by simply overriding this method as a blank { }.</p>
+        /// </summary>
+        /// <exception cref="Antlr4.Runtime.RecognitionException"/>
+        public virtual void Sync(Parser recognizer)
+        {
+            ATNState s = recognizer.Interpreter.atn.states[recognizer.State];
+            //		System.err.println("sync @ "+s.stateNumber+"="+s.getClass().getSimpleName());
+            // If already recovering, don't try to sync
+            if (InErrorRecoveryMode(recognizer))
+            {
+                return;
+            }
+            ITokenStream tokens = ((ITokenStream)recognizer.InputStream);
+            int la = tokens.La(1);
+            // try cheaper subset first; might get lucky. seems to shave a wee bit off
+            if (recognizer.Atn.NextTokens(s).Contains(la) || la == TokenConstants.Eof)
+            {
+                return;
+            }
+            // Return but don't end recovery. only do that upon valid token match
+            if (recognizer.IsExpectedToken(la))
+            {
+                return;
+            }
+            switch (s.StateType)
+            {
+                case StateType.BlockStart:
+                case StateType.StarBlockStart:
+                case StateType.PlusBlockStart:
+                case StateType.StarLoopEntry:
+                {
+                    // report error and recover if possible
+                    if (SingleTokenDeletion(recognizer) != null)
+                    {
+                        return;
+                    }
+                    throw new InputMismatchException(recognizer);
+                }
+
+                case StateType.PlusLoopBack:
+                case StateType.StarLoopBack:
+                {
+                    //			System.err.println("at loop back: "+s.getClass().getSimpleName());
+                    ReportUnwantedToken(recognizer);
+                    IntervalSet expecting = recognizer.GetExpectedTokens();
+                    IntervalSet whatFollowsLoopIterationOrRule = expecting.Or(GetErrorRecoverySet(recognizer));
+                    ConsumeUntil(recognizer, whatFollowsLoopIterationOrRule);
+                    break;
+                }
+
+                default:
+                {
+                    // do nothing if we can't identify the exact kind of ATN state
+                    break;
+                }
+            }
+        }
+
+        /// <summary>
+        /// This is called by
+        /// <see cref="ReportError(Parser, RecognitionException)"/>
+        /// when the exception is a
+        /// <see cref="NoViableAltException"/>
+        /// .
+        /// </summary>
+        /// <seealso cref="ReportError(Parser, RecognitionException)"/>
+        /// <param name="recognizer">the parser instance</param>
+        /// <param name="e">the recognition exception</param>
+        protected internal virtual void ReportNoViableAlternative(Parser recognizer, NoViableAltException e)
+        {
+            ITokenStream tokens = ((ITokenStream)recognizer.InputStream);
+            string input;
+            if (tokens != null)
+            {
+                if (e.StartToken.Type == TokenConstants.Eof)
+                {
+                    input = "<EOF>";
+                }
+                else
+                {
+                    input = tokens.GetText(e.StartToken, e.OffendingToken);
+                }
+            }
+            else
+            {
+                input = "<unknown input>";
+            }
+            string msg = "no viable alternative at input " + EscapeWSAndQuote(input);
+            NotifyErrorListeners(recognizer, msg, e);
+        }
+
+        /// <summary>
+        /// This is called by
+        /// <see cref="ReportError(Parser, RecognitionException)"/>
+        /// when the exception is an
+        /// <see cref="InputMismatchException"/>
+        /// .
+        /// </summary>
+        /// <seealso cref="ReportError(Parser, RecognitionException)"/>
+        /// <param name="recognizer">the parser instance</param>
+        /// <param name="e">the recognition exception</param>
+        protected internal virtual void ReportInputMismatch(Parser recognizer, InputMismatchException e)
+        {
+            string msg = "mismatched input " + GetTokenErrorDisplay(e.OffendingToken) + " expecting " + e.GetExpectedTokens().ToString(recognizer.Vocabulary);
+            NotifyErrorListeners(recognizer, msg, e);
+        }
+
+        /// <summary>
+        /// This is called by
+        /// <see cref="ReportError(Parser, RecognitionException)"/>
+        /// when the exception is a
+        /// <see cref="FailedPredicateException"/>
+        /// .
+        /// </summary>
+        /// <seealso cref="ReportError(Parser, RecognitionException)"/>
+        /// <param name="recognizer">the parser instance</param>
+        /// <param name="e">the recognition exception</param>
+        protected internal virtual void ReportFailedPredicate(Parser recognizer, FailedPredicateException e)
+        {
+			string ruleName = recognizer.RuleNames[recognizer.RuleContext.RuleIndex];
+            string msg = "rule " + ruleName + " " + e.Message;
+            NotifyErrorListeners(recognizer, msg, e);
+        }
+
+        /// <summary>
+        /// This method is called to report a syntax error which requires the removal
+        /// of a token from the input stream.
+        /// </summary>
+        /// <remarks>
+        /// This method is called to report a syntax error which requires the removal
+        /// of a token from the input stream. At the time this method is called, the
+        /// erroneous symbol is current
+        /// <c>LT(1)</c>
+        /// symbol and has not yet been
+        /// removed from the input stream. When this method returns,
+        /// <paramref name="recognizer"/>
+        /// is in error recovery mode.
+        /// <p>This method is called when
+        /// <see cref="SingleTokenDeletion(Parser)"/>
+        /// identifies
+        /// single-token deletion as a viable recovery strategy for a mismatched
+        /// input error.</p>
+        /// <p>The default implementation simply returns if the handler is already in
+        /// error recovery mode. Otherwise, it calls
+        /// <see cref="BeginErrorCondition(Parser)"/>
+        /// to
+        /// enter error recovery mode, followed by calling
+        /// <see cref="Parser.NotifyErrorListeners(string)"/>
+        /// .</p>
+        /// </remarks>
+        /// <param name="recognizer">the parser instance</param>
+        protected internal virtual void ReportUnwantedToken(Parser recognizer)
+        {
+            if (InErrorRecoveryMode(recognizer))
+            {
+                return;
+            }
+            BeginErrorCondition(recognizer);
+            IToken t = recognizer.CurrentToken;
+            string tokenName = GetTokenErrorDisplay(t);
+            IntervalSet expecting = GetExpectedTokens(recognizer);
+            string msg = "extraneous input " + tokenName + " expecting " + expecting.ToString(recognizer.Vocabulary);
+            recognizer.NotifyErrorListeners(t, msg, null);
+        }
+
+        /// <summary>
+        /// This method is called to report a syntax error which requires the
+        /// insertion of a missing token into the input stream.
+        /// </summary>
+        /// <remarks>
+        /// This method is called to report a syntax error which requires the
+        /// insertion of a missing token into the input stream. At the time this
+        /// method is called, the missing token has not yet been inserted. When this
+        /// method returns,
+        /// <paramref name="recognizer"/>
+        /// is in error recovery mode.
+        /// <p>This method is called when
+        /// <see cref="SingleTokenInsertion(Parser)"/>
+        /// identifies
+        /// single-token insertion as a viable recovery strategy for a mismatched
+        /// input error.</p>
+        /// <p>The default implementation simply returns if the handler is already in
+        /// error recovery mode. Otherwise, it calls
+        /// <see cref="BeginErrorCondition(Parser)"/>
+        /// to
+        /// enter error recovery mode, followed by calling
+        /// <see cref="Parser.NotifyErrorListeners(string)"/>
+        /// .</p>
+        /// </remarks>
+        /// <param name="recognizer">the parser instance</param>
+        protected internal virtual void ReportMissingToken(Parser recognizer)
+        {
+            if (InErrorRecoveryMode(recognizer))
+            {
+                return;
+            }
+            BeginErrorCondition(recognizer);
+            IToken t = recognizer.CurrentToken;
+            IntervalSet expecting = GetExpectedTokens(recognizer);
+            string msg = "missing " + expecting.ToString(recognizer.Vocabulary) + " at " + GetTokenErrorDisplay(t);
+            recognizer.NotifyErrorListeners(t, msg, null);
+        }
+
+        /// <summary>
+        /// <inheritDoc/>
+        /// <p>The default implementation attempts to recover from the mismatched input
+        /// by using single token insertion and deletion as described below. If the
+        /// recovery attempt fails, this method throws an
+        /// <see cref="InputMismatchException"/>
+        /// .</p>
+        /// <p><strong>EXTRA TOKEN</strong> (single token deletion)</p>
+        /// <p>
+        /// <c>LA(1)</c>
+        /// is not what we are looking for. If
+        /// <c>LA(2)</c>
+        /// has the
+        /// right token, however, then assume
+        /// <c>LA(1)</c>
+        /// is some extra spurious
+        /// token and delete it. Then consume and return the next token (which was
+        /// the
+        /// <c>LA(2)</c>
+        /// token) as the successful result of the match operation.</p>
+        /// <p>This recovery strategy is implemented by
+        /// <see cref="SingleTokenDeletion(Parser)"/>
+        /// .</p>
+        /// <p><strong>MISSING TOKEN</strong> (single token insertion)</p>
+        /// <p>If current token (at
+        /// <c>LA(1)</c>
+        /// ) is consistent with what could come
+        /// after the expected
+        /// <c>LA(1)</c>
+        /// token, then assume the token is missing
+        /// and use the parser's
+        /// <see cref="ITokenFactory"/>
+        /// to create it on the fly. The
+        /// "insertion" is performed by returning the created token as the successful
+        /// result of the match operation.</p>
+        /// <p>This recovery strategy is implemented by
+        /// <see cref="SingleTokenInsertion(Parser)"/>
+        /// .</p>
+        /// <p><strong>EXAMPLE</strong></p>
+        /// <p>For example, Input
+        /// <c>i=(3;</c>
+        /// is clearly missing the
+        /// <c>')'</c>
+        /// . When
+        /// the parser returns from the nested call to
+        /// <c>expr</c>
+        /// , it will have
+        /// call chain:</p>
+        /// <pre>
+        /// stat &#x2192; expr &#x2192; atom
+        /// </pre>
+        /// and it will be trying to match the
+        /// <c>')'</c>
+        /// at this point in the
+        /// derivation:
+        /// <pre>
+        /// =&gt; ID '=' '(' INT ')' ('+' atom)* ';'
+        /// ^
+        /// </pre>
+        /// The attempt to match
+        /// <c>')'</c>
+        /// will fail when it sees
+        /// <c>';'</c>
+        /// and
+        /// call
+        /// <see cref="RecoverInline(Parser)"/>
+        /// . To recover, it sees that
+        /// <c>LA(1)==';'</c>
+        /// is in the set of tokens that can follow the
+        /// <c>')'</c>
+        /// token reference
+        /// in rule
+        /// <c>atom</c>
+        /// . It can assume that you forgot the
+        /// <c>')'</c>
+        /// .
+        /// </summary>
+        /// <exception cref="Antlr4.Runtime.RecognitionException"/>
+        public virtual IToken RecoverInline(Parser recognizer)
+        {
+            // SINGLE TOKEN DELETION
+            IToken matchedSymbol = SingleTokenDeletion(recognizer);
+            if (matchedSymbol != null)
+            {
+                // we have deleted the extra token.
+                // now, move past ttype token as if all were ok
+                recognizer.Consume();
+                return matchedSymbol;
+            }
+            // SINGLE TOKEN INSERTION
+            if (SingleTokenInsertion(recognizer))
+            {
+                return GetMissingSymbol(recognizer);
+            }
+            // even that didn't work; must throw the exception
+            throw new InputMismatchException(recognizer);
+        }
+
+        /// <summary>
+        /// This method implements the single-token insertion inline error recovery
+        /// strategy.
+        /// </summary>
+        /// <remarks>
+        /// This method implements the single-token insertion inline error recovery
+        /// strategy. It is called by
+        /// <see cref="RecoverInline(Parser)"/>
+        /// if the single-token
+        /// deletion strategy fails to recover from the mismatched input. If this
+        /// method returns
+        /// <see langword="true"/>
+        /// ,
+        /// <paramref name="recognizer"/>
+        /// will be in error recovery
+        /// mode.
+        /// <p>This method determines whether or not single-token insertion is viable by
+        /// checking if the
+        /// <c>LA(1)</c>
+        /// input symbol could be successfully matched
+        /// if it were instead the
+        /// <c>LA(2)</c>
+        /// symbol. If this method returns
+        /// <see langword="true"/>
+        /// , the caller is responsible for creating and inserting a
+        /// token with the correct type to produce this behavior.</p>
+        /// </remarks>
+        /// <param name="recognizer">the parser instance</param>
+        /// <returns>
+        /// 
+        /// <see langword="true"/>
+        /// if single-token insertion is a viable recovery
+        /// strategy for the current mismatched input, otherwise
+        /// <see langword="false"/>
+        /// </returns>
+        protected internal virtual bool SingleTokenInsertion(Parser recognizer)
+        {
+            int currentSymbolType = ((ITokenStream)recognizer.InputStream).La(1);
+            // if current token is consistent with what could come after current
+            // ATN state, then we know we're missing a token; error recovery
+            // is free to conjure up and insert the missing token
+            ATNState currentState = recognizer.Interpreter.atn.states[recognizer.State];
+            ATNState next = currentState.Transition(0).target;
+            ATN atn = recognizer.Interpreter.atn;
+			IntervalSet expectingAtLL2 = atn.NextTokens(next, PredictionContext.FromRuleContext(atn, recognizer.RuleContext));
+            //		System.out.println("LT(2) set="+expectingAtLL2.toString(recognizer.getTokenNames()));
+            if (expectingAtLL2.Contains(currentSymbolType))
+            {
+                ReportMissingToken(recognizer);
+                return true;
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// This method implements the single-token deletion inline error recovery
+        /// strategy.
+        /// </summary>
+        /// <remarks>
+        /// This method implements the single-token deletion inline error recovery
+        /// strategy. It is called by
+        /// <see cref="RecoverInline(Parser)"/>
+        /// to attempt to recover
+        /// from mismatched input. If this method returns null, the parser and error
+        /// handler state will not have changed. If this method returns non-null,
+        /// <paramref name="recognizer"/>
+        /// will <em>not</em> be in error recovery mode since the
+        /// returned token was a successful match.
+        /// <p>If the single-token deletion is successful, this method calls
+        /// <see cref="ReportUnwantedToken(Parser)"/>
+        /// to report the error, followed by
+        /// <see cref="Parser.Consume()"/>
+        /// to actually "delete" the extraneous token. Then,
+        /// before returning
+        /// <see cref="ReportMatch(Parser)"/>
+        /// is called to signal a successful
+        /// match.</p>
+        /// </remarks>
+        /// <param name="recognizer">the parser instance</param>
+        /// <returns>
+        /// the successfully matched
+        /// <see cref="IToken"/>
+        /// instance if single-token
+        /// deletion successfully recovers from the mismatched input, otherwise
+        /// <see langword="null"/>
+        /// </returns>
+        [return: Nullable]
+        protected internal virtual IToken SingleTokenDeletion(Parser recognizer)
+        {
+            int nextTokenType = ((ITokenStream)recognizer.InputStream).La(2);
+            IntervalSet expecting = GetExpectedTokens(recognizer);
+            if (expecting.Contains(nextTokenType))
+            {
+                ReportUnwantedToken(recognizer);
+                recognizer.Consume();
+                // simply delete extra token
+                // we want to return the token we're actually matching
+                IToken matchedSymbol = recognizer.CurrentToken;
+                ReportMatch(recognizer);
+                // we know current token is correct
+                return matchedSymbol;
+            }
+            return null;
+        }
+
+        /// <summary>Conjure up a missing token during error recovery.</summary>
+        /// <remarks>
+        /// Conjure up a missing token during error recovery.
+        /// The recognizer attempts to recover from single missing
+        /// symbols. But, actions might refer to that missing symbol.
+        /// For example, x=ID {f($x);}. The action clearly assumes
+        /// that there has been an identifier matched previously and that
+        /// $x points at that token. If that token is missing, but
+        /// the next token in the stream is what we want we assume that
+        /// this token is missing and we keep going. Because we
+        /// have to return some token to replace the missing token,
+        /// we have to conjure one up. This method gives the user control
+        /// over the tokens returned for missing tokens. Mostly,
+        /// you will want to create something special for identifier
+        /// tokens. For literals such as '{' and ',', the default
+        /// action in the parser or tree parser works. It simply creates
+        /// a CommonToken of the appropriate type. The text will be the token.
+        /// If you change what tokens must be created by the lexer,
+        /// override this method to create the appropriate tokens.
+        /// </remarks>
+        [return: NotNull]
+        protected internal virtual IToken GetMissingSymbol(Parser recognizer)
+        {
+            IToken currentSymbol = recognizer.CurrentToken;
+            IntervalSet expecting = GetExpectedTokens(recognizer);
+            int expectedTokenType = expecting.MinElement;
+            // get any element
+            string tokenText;
+            if (expectedTokenType == TokenConstants.Eof)
+            {
+                tokenText = "<missing EOF>";
+            }
+            else
+            {
+                tokenText = "<missing " + recognizer.Vocabulary.GetDisplayName(expectedTokenType) + ">";
+            }
+            IToken current = currentSymbol;
+            IToken lookback = ((ITokenStream)recognizer.InputStream).Lt(-1);
+            if (current.Type == TokenConstants.Eof && lookback != null)
+            {
+                current = lookback;
+            }
+            return ConstructToken(((ITokenStream)recognizer.InputStream).TokenSource, expectedTokenType, tokenText, current);
+        }
+
+        protected internal virtual IToken ConstructToken(ITokenSource tokenSource, int expectedTokenType, string tokenText, IToken current)
+        {
+            ITokenFactory factory = tokenSource.TokenFactory;
+            return factory.Create(Tuple.Create(tokenSource, current.TokenSource.InputStream), expectedTokenType, tokenText, TokenConstants.DefaultChannel, -1, -1, current.Line, current.Column);
+        }
+
+        [return: NotNull]
+        protected internal virtual IntervalSet GetExpectedTokens(Parser recognizer)
+        {
+            return recognizer.GetExpectedTokens();
+        }
+
+        /// <summary>
+        /// How should a token be displayed in an error message? The default
+        /// is to display just the text, but during development you might
+        /// want to have a lot of information spit out.
+        /// </summary>
+        /// <remarks>
+        /// How should a token be displayed in an error message? The default
+        /// is to display just the text, but during development you might
+        /// want to have a lot of information spit out.  Override in that case
+        /// to use t.toString() (which, for CommonToken, dumps everything about
+        /// the token). This is better than forcing you to override a method in
+        /// your token objects because you don't have to go modify your lexer
+        /// so that it creates a new Java type.
+        /// </remarks>
+        protected internal virtual string GetTokenErrorDisplay(IToken t)
+        {
+            if (t == null)
+            {
+                return "<no token>";
+            }
+            string s = GetSymbolText(t);
+            if (s == null)
+            {
+                if (GetSymbolType(t) == TokenConstants.Eof)
+                {
+                    s = "<EOF>";
+                }
+                else
+                {
+                    s = "<" + GetSymbolType(t) + ">";
+                }
+            }
+            return EscapeWSAndQuote(s);
+        }
+
+        protected internal virtual string GetSymbolText(IToken symbol)
+        {
+            return symbol.Text;
+        }
+
+        protected internal virtual int GetSymbolType(IToken symbol)
+        {
+            return symbol.Type;
+        }
+
+        [return: NotNull]
+        protected internal virtual string EscapeWSAndQuote(string s)
+        {
+            //		if ( s==null ) return s;
+            s = s.Replace("\n", "\\n");
+            s = s.Replace("\r", "\\r");
+            s = s.Replace("\t", "\\t");
+            return "'" + s + "'";
+        }
+
+        [return: NotNull]
+        protected internal virtual IntervalSet GetErrorRecoverySet(Parser recognizer)
+        {
+            ATN atn = recognizer.Interpreter.atn;
+			RuleContext ctx = recognizer.RuleContext;
+            IntervalSet recoverSet = new IntervalSet();
+            while (ctx != null && ctx.invokingState >= 0)
+            {
+                // compute what follows who invoked us
+                ATNState invokingState = atn.states[ctx.invokingState];
+                RuleTransition rt = (RuleTransition)invokingState.Transition(0);
+                IntervalSet follow = atn.NextTokens(rt.followState);
+                recoverSet.AddAll(follow);
+                ctx = ctx.Parent;
+            }
+            recoverSet.Remove(TokenConstants.Epsilon);
+            //		System.out.println("recover set "+recoverSet.toString(recognizer.getTokenNames()));
+            return recoverSet;
+        }
+
+        /// <summary>Consume tokens until one matches the given token set.</summary>
+        /// <remarks>Consume tokens until one matches the given token set.</remarks>
+        protected internal virtual void ConsumeUntil(Parser recognizer, IntervalSet set)
+        {
+            //		System.err.println("consumeUntil("+set.toString(recognizer.getTokenNames())+")");
+            int ttype = ((ITokenStream)recognizer.InputStream).La(1);
+            while (ttype != TokenConstants.Eof && !set.Contains(ttype))
+            {
+                //System.out.println("consume during recover LA(1)="+getTokenNames()[input.LA(1)]);
+                //			recognizer.getInputStream().consume();
+                recognizer.Consume();
+                ttype = ((ITokenStream)recognizer.InputStream).La(1);
+            }
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Dependents.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Dependents.cs
new file mode 100644
index 000000000..e42d9d2bd
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Dependents.cs
@@ -0,0 +1,52 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System;
+using Antlr4.Runtime;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime
+{
+    /// <author>Sam Harwell</author>
+    [Flags]
+    public enum Dependents
+    {
+        None = 0,
+        Self = 1 << 0,
+        Parents = 1 << 1,
+        Children = 1 << 2,
+        Ancestors = 1 << 3,
+        Descendants = 1 << 4,
+        Siblings = 1 << 5,
+        PreceedingSiblings = 1 << 6,
+        FollowingSiblings = 1 << 7,
+        Preceeding = 1 << 8,
+        Following = 1 << 9
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Dfa/AbstractEdgeMap.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Dfa/AbstractEdgeMap.cs
new file mode 100644
index 000000000..921eb41de
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Dfa/AbstractEdgeMap.cs
@@ -0,0 +1,122 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System.Collections;
+using System.Collections.Generic;
+using Antlr4.Runtime.Dfa;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Dfa
+{
+    /// <author>Sam Harwell</author>
+    public abstract class AbstractEdgeMap<T> : IEdgeMap<T>
+        where T : class
+    {
+        protected internal readonly int minIndex;
+
+        protected internal readonly int maxIndex;
+
+        protected AbstractEdgeMap(int minIndex, int maxIndex)
+        {
+            // the allowed range (with minIndex and maxIndex inclusive) should be less than 2^32
+            System.Diagnostics.Debug.Assert(maxIndex - minIndex + 1 >= 0);
+            this.minIndex = minIndex;
+            this.maxIndex = maxIndex;
+        }
+
+        public abstract Antlr4.Runtime.Dfa.AbstractEdgeMap<T> Put(int key, T value);
+
+        IEdgeMap<T> IEdgeMap<T>.Put(int key, T value)
+        {
+            return Put(key, value);
+        }
+
+        public virtual Antlr4.Runtime.Dfa.AbstractEdgeMap<T> PutAll(IEdgeMap<T> m)
+        {
+            Antlr4.Runtime.Dfa.AbstractEdgeMap<T> result = this;
+            foreach (KeyValuePair<int, T> entry in m)
+            {
+                result = result.Put(entry.Key, entry.Value);
+            }
+            return result;
+        }
+
+        IEdgeMap<T> IEdgeMap<T>.PutAll(IEdgeMap<T> m)
+        {
+            return PutAll(m);
+        }
+
+        public abstract Antlr4.Runtime.Dfa.AbstractEdgeMap<T> Clear();
+
+        IEdgeMap<T> IEdgeMap<T>.Clear()
+        {
+            return Clear();
+        }
+
+        public abstract Antlr4.Runtime.Dfa.AbstractEdgeMap<T> Remove(int key);
+
+        IEdgeMap<T> IEdgeMap<T>.Remove(int key)
+        {
+            return Remove(key);
+        }
+
+        public abstract bool ContainsKey(int arg1);
+
+        public abstract T this[int arg1]
+        {
+            get;
+        }
+
+        public abstract bool IsEmpty
+        {
+            get;
+        }
+
+        public abstract int Count
+        {
+            get;
+        }
+
+#if NET45PLUS
+        public abstract IReadOnlyDictionary<int, T> ToMap();
+#else
+        public abstract IDictionary<int, T> ToMap();
+#endif
+
+        public virtual IEnumerator<KeyValuePair<int, T>> GetEnumerator()
+        {
+            return ToMap().GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Dfa/AcceptStateInfo.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Dfa/AcceptStateInfo.cs
new file mode 100644
index 000000000..823ea44d3
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Dfa/AcceptStateInfo.cs
@@ -0,0 +1,96 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Dfa
+{
+    /// <summary>
+    /// Stores information about a
+    /// <see cref="DFAState"/>
+    /// which is an accept state under
+    /// some condition. Certain settings, such as
+    /// <see cref="Antlr4.Runtime.Atn.ParserATNSimulator.PredictionMode()"/>
+    /// , may be used in addition to
+    /// this information to determine whether or not a particular state is an accept
+    /// state.
+    /// </summary>
+    /// <author>Sam Harwell</author>
+    public class AcceptStateInfo
+    {
+        private readonly int prediction;
+
+        private readonly Antlr4.Runtime.Atn.LexerActionExecutor lexerActionExecutor;
+
+        public AcceptStateInfo(int prediction)
+        {
+            this.prediction = prediction;
+            this.lexerActionExecutor = null;
+        }
+
+        public AcceptStateInfo(int prediction, Antlr4.Runtime.Atn.LexerActionExecutor lexerActionExecutor)
+        {
+            this.prediction = prediction;
+            this.lexerActionExecutor = lexerActionExecutor;
+        }
+
+        /// <summary>Gets the prediction made by this accept state.</summary>
+        /// <remarks>
+        /// Gets the prediction made by this accept state. Note that this value
+        /// assumes the predicates, if any, in the
+        /// <see cref="DFAState"/>
+        /// evaluate to
+        /// <see langword="true"/>
+        /// . If predicate evaluation is enabled, the final prediction of
+        /// the accept state will be determined by the result of predicate
+        /// evaluation.
+        /// </remarks>
+        public virtual int Prediction
+        {
+            get
+            {
+                return prediction;
+            }
+        }
+
+        /// <summary>
+        /// Gets the
+        /// <see cref="Antlr4.Runtime.Atn.LexerActionExecutor"/>
+        /// which can be used to execute actions
+        /// and/or commands after the lexer matches a token.
+        /// </summary>
+        public virtual Antlr4.Runtime.Atn.LexerActionExecutor LexerActionExecutor
+        {
+            get
+            {
+                return lexerActionExecutor;
+            }
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Dfa/ArrayEdgeMap.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Dfa/ArrayEdgeMap.cs
new file mode 100644
index 000000000..72702678e
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Dfa/ArrayEdgeMap.cs
@@ -0,0 +1,218 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using Antlr4.Runtime.Dfa;
+using Antlr4.Runtime.Sharpen;
+using Interlocked = System.Threading.Interlocked;
+
+#if NET45PLUS
+using Volatile = System.Threading.Volatile;
+#elif !PORTABLE && !COMPACT
+using Thread = System.Threading.Thread;
+#endif
+
+namespace Antlr4.Runtime.Dfa
+{
+    /// <author>Sam Harwell</author>
+    public sealed class ArrayEdgeMap<T> : AbstractEdgeMap<T>
+        where T : class
+    {
+        private readonly T[] arrayData;
+
+        private int size;
+
+        public ArrayEdgeMap(int minIndex, int maxIndex)
+            : base(minIndex, maxIndex)
+        {
+            arrayData = new T[maxIndex - minIndex + 1];
+        }
+
+        public override int Count
+        {
+            get
+            {
+#if NET45PLUS
+                return Volatile.Read(ref size);
+#elif !PORTABLE && !COMPACT
+                return Thread.VolatileRead(ref size);
+#else
+                return Interlocked.CompareExchange(ref size, 0, 0);
+#endif
+            }
+        }
+
+        public override bool IsEmpty
+        {
+            get
+            {
+                return Count == 0;
+            }
+        }
+
+        public override bool ContainsKey(int key)
+        {
+            return this[key] != null;
+        }
+
+        public override T this[int key]
+        {
+            get
+            {
+                if (key < minIndex || key > maxIndex)
+                {
+                    return null;
+                }
+
+#if NET45PLUS
+                return Volatile.Read(ref arrayData[key - minIndex]);
+#else
+                return Interlocked.CompareExchange(ref arrayData[key - minIndex], null, null);
+#endif
+            }
+        }
+
+        public override AbstractEdgeMap<T> Put(int key, T value)
+        {
+            if (key >= minIndex && key <= maxIndex)
+            {
+                T existing = Interlocked.Exchange(ref arrayData[key - minIndex], value);
+                if (existing == null && value != null)
+                {
+                    Interlocked.Increment(ref size);
+                }
+                else
+                {
+                    if (existing != null && value == null)
+                    {
+                        Interlocked.Decrement(ref size);
+                    }
+                }
+            }
+            return this;
+        }
+
+        public override AbstractEdgeMap<T> Remove(int key)
+        {
+            return Put(key, null);
+        }
+
+        public override AbstractEdgeMap<T> PutAll(IEdgeMap<T> m)
+        {
+            if (m.IsEmpty)
+            {
+                return this;
+            }
+            if (m is Antlr4.Runtime.Dfa.ArrayEdgeMap<T>)
+            {
+                Antlr4.Runtime.Dfa.ArrayEdgeMap<T> other = (Antlr4.Runtime.Dfa.ArrayEdgeMap<T>)m;
+                int minOverlap = Math.Max(minIndex, other.minIndex);
+                int maxOverlap = Math.Min(maxIndex, other.maxIndex);
+                Antlr4.Runtime.Dfa.ArrayEdgeMap<T> result = this;
+                for (int i = minOverlap; i <= maxOverlap; i++)
+                {
+                    result = ((Antlr4.Runtime.Dfa.ArrayEdgeMap<T>)result.Put(i, m[i]));
+                }
+                return result;
+            }
+            else
+            {
+                if (m is SingletonEdgeMap<T>)
+                {
+                    SingletonEdgeMap<T> other = (SingletonEdgeMap<T>)m;
+                    System.Diagnostics.Debug.Assert(!other.IsEmpty);
+                    return Put(other.Key, other.Value);
+                }
+                else
+                {
+                    if (m is SparseEdgeMap<T>)
+                    {
+                        SparseEdgeMap<T> other = (SparseEdgeMap<T>)m;
+                        lock (other)
+                        {
+                            int[] keys = other.Keys;
+                            IList<T> values = other.Values;
+                            Antlr4.Runtime.Dfa.ArrayEdgeMap<T> result = this;
+                            for (int i = 0; i < values.Count; i++)
+                            {
+                                result = ((Antlr4.Runtime.Dfa.ArrayEdgeMap<T>)result.Put(keys[i], values[i]));
+                            }
+                            return result;
+                        }
+                    }
+                    else
+                    {
+                        throw new NotSupportedException(string.Format("EdgeMap of type {0} is supported yet.", m.GetType().FullName));
+                    }
+                }
+            }
+        }
+
+        public override AbstractEdgeMap<T> Clear()
+        {
+            return new EmptyEdgeMap<T>(minIndex, maxIndex);
+        }
+
+#if NET45PLUS
+        public override IReadOnlyDictionary<int, T> ToMap()
+#else
+        public override IDictionary<int, T> ToMap()
+#endif
+        {
+            if (IsEmpty)
+            {
+                return Sharpen.Collections.EmptyMap<int, T>();
+            }
+
+#if COMPACT
+            IDictionary<int, T> result = new SortedList<int, T>();
+#elif PORTABLE && !NET45PLUS
+            IDictionary<int, T> result = new Dictionary<int, T>();
+#else
+            IDictionary<int, T> result = new SortedDictionary<int, T>();
+#endif
+            for (int i = 0; i < arrayData.Length; i++)
+            {
+                T element = arrayData[i];
+                if (element == null)
+                {
+                    continue;
+                }
+                result[i + minIndex] = element;
+            }
+#if NET45PLUS
+            return new ReadOnlyDictionary<int, T>(result);
+#else
+            return result;
+#endif
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Dfa/DFA.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Dfa/DFA.cs
new file mode 100644
index 000000000..2a8d6bbf2
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Dfa/DFA.cs
@@ -0,0 +1,362 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using Antlr4.Runtime;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Dfa;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+using Interlocked = System.Threading.Interlocked;
+
+namespace Antlr4.Runtime.Dfa
+{
+    public class DFA
+    {
+        /// <summary>A set of all DFA states.</summary>
+        /// <remarks>
+        /// A set of all DFA states. Use
+        /// <see cref="System.Collections.Generic.IDictionary{K, V}"/>
+        /// so we can get old state back
+        /// (
+        /// <see cref="HashSet{T}"/>
+        /// only allows you to see if it's there).
+        /// </remarks>
+        [NotNull]
+        public readonly ConcurrentDictionary<DFAState, DFAState> states = new ConcurrentDictionary<DFAState, DFAState>();
+
+        [NotNull]
+        public readonly AtomicReference<DFAState> s0 = new AtomicReference<DFAState>();
+
+        [NotNull]
+        public readonly AtomicReference<DFAState> s0full = new AtomicReference<DFAState>();
+
+        public readonly int decision;
+
+        /// <summary>From which ATN state did we create this DFA?</summary>
+        [NotNull]
+        public readonly ATNState atnStartState;
+
+        private int nextStateNumber;
+
+        private readonly int minDfaEdge;
+
+        private readonly int maxDfaEdge;
+
+        [NotNull]
+        private static readonly Antlr4.Runtime.Dfa.EmptyEdgeMap<DFAState> emptyPrecedenceEdges = new Antlr4.Runtime.Dfa.EmptyEdgeMap<DFAState>(0, 200);
+
+        [NotNull]
+        private readonly Antlr4.Runtime.Dfa.EmptyEdgeMap<DFAState> emptyEdgeMap;
+
+        [NotNull]
+        private readonly Antlr4.Runtime.Dfa.EmptyEdgeMap<DFAState> emptyContextEdgeMap;
+
+        /// <summary>
+        /// <see langword="true"/>
+        /// if this DFA is for a precedence decision; otherwise,
+        /// <see langword="false"/>
+        /// . This is the backing field for <see cref="IsPrecedenceDfa"/>.
+        /// </summary>
+        private volatile bool precedenceDfa;
+
+        public DFA(ATNState atnStartState)
+            : this(atnStartState, 0)
+        {
+        }
+
+        public DFA(ATNState atnStartState, int decision)
+        {
+            this.atnStartState = atnStartState;
+            this.decision = decision;
+            if (this.atnStartState.atn.grammarType == ATNType.Lexer)
+            {
+                minDfaEdge = LexerATNSimulator.MinDfaEdge;
+                maxDfaEdge = LexerATNSimulator.MaxDfaEdge;
+            }
+            else
+            {
+                minDfaEdge = TokenConstants.Eof;
+                maxDfaEdge = atnStartState.atn.maxTokenType;
+            }
+            this.emptyEdgeMap = new Antlr4.Runtime.Dfa.EmptyEdgeMap<DFAState>(minDfaEdge, maxDfaEdge);
+            this.emptyContextEdgeMap = new Antlr4.Runtime.Dfa.EmptyEdgeMap<DFAState>(-1, atnStartState.atn.states.Count - 1);
+        }
+
+        public int MinDfaEdge
+        {
+            get
+            {
+                return minDfaEdge;
+            }
+        }
+
+        public int MaxDfaEdge
+        {
+            get
+            {
+                return maxDfaEdge;
+            }
+        }
+
+        public virtual Antlr4.Runtime.Dfa.EmptyEdgeMap<DFAState> EmptyEdgeMap
+        {
+            get
+            {
+                return emptyEdgeMap;
+            }
+        }
+
+        public virtual Antlr4.Runtime.Dfa.EmptyEdgeMap<DFAState> EmptyContextEdgeMap
+        {
+            get
+            {
+                return emptyContextEdgeMap;
+            }
+        }
+
+        /// <summary>Gets whether this DFA is a precedence DFA.</summary>
+        /// <remarks>
+        /// Gets whether this DFA is a precedence DFA. Precedence DFAs use a special
+        /// start state
+        /// <see cref="s0"/>
+        /// which is not stored in
+        /// <see cref="states"/>
+        /// . The
+        /// <see cref="DFAState.edges"/>
+        /// array for this start state contains outgoing edges
+        /// supplying individual start states corresponding to specific precedence
+        /// values.
+        /// </remarks>
+        /// <returns>
+        /// 
+        /// <see langword="true"/>
+        /// if this is a precedence DFA; otherwise,
+        /// <see langword="false"/>
+        /// .
+        /// </returns>
+        /// <seealso cref="Antlr4.Runtime.Parser.Precedence()"/>
+        /// <summary>Sets whether this is a precedence DFA.</summary>
+        /// <remarks>
+        /// Sets whether this is a precedence DFA. If the specified value differs
+        /// from the current DFA configuration, the following actions are taken;
+        /// otherwise no changes are made to the current DFA.
+        /// <ul>
+        /// <li>The
+        /// <see cref="states"/>
+        /// map is cleared</li>
+        /// <li>If
+        /// <c>precedenceDfa</c>
+        /// is
+        /// <see langword="false"/>
+        /// , the initial state
+        /// <see cref="s0"/>
+        /// is set to
+        /// <see langword="null"/>
+        /// ; otherwise, it is initialized to a new
+        /// <see cref="DFAState"/>
+        /// with an empty outgoing
+        /// <see cref="DFAState.edges"/>
+        /// array to
+        /// store the start states for individual precedence values.</li>
+        /// <li>The
+        /// <see cref="precedenceDfa"/>
+        /// field is updated</li>
+        /// </ul>
+        /// </remarks>
+        /// <value>
+        /// 
+        /// <see langword="true"/>
+        /// if this is a precedence DFA; otherwise,
+        /// <see langword="false"/>
+        /// </value>
+        public bool IsPrecedenceDfa
+        {
+            get
+            {
+                return precedenceDfa;
+            }
+            set
+            {
+                bool precedenceDfa = value;
+                // s0.get() and s0full.get() are never null for a precedence DFA
+                // s0full.get() is never null for a precedence DFA
+                // s0.get() is never null for a precedence DFA
+                lock (this)
+                {
+                    if (this.precedenceDfa != precedenceDfa)
+                    {
+                        this.states.Clear();
+                        if (precedenceDfa)
+                        {
+                            this.s0.Set(new DFAState(emptyPrecedenceEdges, EmptyContextEdgeMap, new ATNConfigSet()));
+                            this.s0full.Set(new DFAState(emptyPrecedenceEdges, EmptyContextEdgeMap, new ATNConfigSet()));
+                        }
+                        else
+                        {
+                            this.s0.Set(null);
+                            this.s0full.Set(null);
+                        }
+                        this.precedenceDfa = precedenceDfa;
+                    }
+                }
+            }
+        }
+
+        /// <summary>Get the start state for a specific precedence value.</summary>
+        /// <remarks>Get the start state for a specific precedence value.</remarks>
+        /// <param name="precedence">The current precedence.</param>
+        /// <param name="fullContext">Whether to get from local of full context.</param>
+        /// <returns>
+        /// The start state corresponding to the specified precedence, or
+        /// <see langword="null"/>
+        /// if no start state exists for the specified precedence.
+        /// </returns>
+        /// <exception cref="System.InvalidOperationException">if this is not a precedence DFA.</exception>
+        /// <seealso cref="IsPrecedenceDfa()"/>
+        public DFAState GetPrecedenceStartState(int precedence, bool fullContext)
+        {
+            if (!IsPrecedenceDfa)
+            {
+                throw new InvalidOperationException("Only precedence DFAs may contain a precedence start state.");
+            }
+            if (fullContext)
+            {
+                return s0full.Get().GetTarget(precedence);
+            }
+            else
+            {
+                return s0.Get().GetTarget(precedence);
+            }
+        }
+
+        /// <summary>Set the start state for a specific precedence value.</summary>
+        /// <remarks>Set the start state for a specific precedence value.</remarks>
+        /// <param name="precedence">The current precedence.</param>
+        /// <param name="fullContext">Whether to set local of full context.</param>
+        /// <param name="startState">
+        /// The start state corresponding to the specified
+        /// precedence.
+        /// </param>
+        /// <exception cref="System.InvalidOperationException">if this is not a precedence DFA.</exception>
+        /// <seealso cref="IsPrecedenceDfa()"/>
+        public void SetPrecedenceStartState(int precedence, bool fullContext, DFAState startState)
+        {
+            if (!IsPrecedenceDfa)
+            {
+                throw new InvalidOperationException("Only precedence DFAs may contain a precedence start state.");
+            }
+            if (precedence < 0)
+            {
+                return;
+            }
+            if (fullContext)
+            {
+                lock (s0full)
+                {
+                    s0full.Get().SetTarget(precedence, startState);
+                }
+            }
+            else
+            {
+                lock (s0)
+                {
+                    s0.Get().SetTarget(precedence, startState);
+                }
+            }
+        }
+
+        public virtual bool IsEmpty
+        {
+            get
+            {
+                if (IsPrecedenceDfa)
+                {
+                    return s0.Get().EdgeMap.Count == 0 && s0full.Get().EdgeMap.Count == 0;
+                }
+                return s0.Get() == null && s0full.Get() == null;
+            }
+        }
+
+        public virtual bool IsContextSensitive
+        {
+            get
+            {
+                if (IsPrecedenceDfa)
+                {
+                    return s0full.Get().EdgeMap.Count != 0;
+                }
+                return s0full.Get() != null;
+            }
+        }
+
+        public virtual DFAState AddState(DFAState state)
+        {
+            state.stateNumber = Interlocked.Increment(ref nextStateNumber) - 1;
+            return states.GetOrAdd(state, state);
+        }
+
+        public override string ToString()
+        {
+            return ToString(Vocabulary.EmptyVocabulary);
+        }
+
+        public virtual string ToString(IVocabulary vocabulary)
+        {
+            if (s0.Get() == null)
+            {
+                return string.Empty;
+            }
+            DFASerializer serializer = new DFASerializer(this, vocabulary);
+            return serializer.ToString();
+        }
+
+        public virtual string ToString(IVocabulary vocabulary, string[] ruleNames)
+        {
+            if (s0.Get() == null)
+            {
+                return string.Empty;
+            }
+            DFASerializer serializer = new DFASerializer(this, vocabulary, ruleNames, atnStartState.atn);
+            return serializer.ToString();
+        }
+
+        public virtual string ToLexerString()
+        {
+            if (s0.Get() == null)
+            {
+                return string.Empty;
+            }
+            DFASerializer serializer = new LexerDFASerializer(this);
+            return serializer.ToString();
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Dfa/DFASerializer.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Dfa/DFASerializer.cs
new file mode 100644
index 000000000..070daeb4e
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Dfa/DFASerializer.cs
@@ -0,0 +1,198 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Antlr4.Runtime;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Dfa;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Dfa
+{
+    /// <summary>A DFA walker that knows how to dump them to serialized strings.</summary>
+    /// <remarks>A DFA walker that knows how to dump them to serialized strings.</remarks>
+    public class DFASerializer
+    {
+        [NotNull]
+        private readonly DFA dfa;
+
+        [NotNull]
+        private readonly IVocabulary vocabulary;
+
+        [Nullable]
+        internal readonly string[] ruleNames;
+
+        [Nullable]
+        internal readonly ATN atn;
+
+        public DFASerializer(DFA dfa, IVocabulary vocabulary)
+            : this(dfa, vocabulary, null, null)
+        {
+        }
+
+        public DFASerializer(DFA dfa, IRecognizer parser)
+            : this(dfa, parser != null ? parser.Vocabulary : Vocabulary.EmptyVocabulary, parser != null ? parser.RuleNames : null, parser != null ? parser.Atn : null)
+        {
+        }
+
+        public DFASerializer(DFA dfa, IVocabulary vocabulary, string[] ruleNames, ATN atn)
+        {
+            this.dfa = dfa;
+            this.vocabulary = vocabulary;
+            this.ruleNames = ruleNames;
+            this.atn = atn;
+        }
+
+        public override string ToString()
+        {
+            if (dfa.s0.Get() == null)
+            {
+                return null;
+            }
+            StringBuilder buf = new StringBuilder();
+            if (dfa.states != null)
+            {
+                List<DFAState> states = new List<DFAState>(dfa.states.Values);
+                states.Sort(new _IComparer_103());
+                foreach (DFAState s in states)
+                {
+                    IEnumerable<KeyValuePair<int, DFAState>> edges = s.EdgeMap;
+                    IEnumerable<KeyValuePair<int, DFAState>> contextEdges = s.ContextEdgeMap;
+                    foreach (KeyValuePair<int, DFAState> entry in edges)
+                    {
+                        if ((entry.Value == null || entry.Value == ATNSimulator.Error) && !s.IsContextSymbol(entry.Key))
+                        {
+                            continue;
+                        }
+                        bool contextSymbol = false;
+                        buf.Append(GetStateString(s)).Append("-").Append(GetEdgeLabel(entry.Key)).Append("->");
+                        if (s.IsContextSymbol(entry.Key))
+                        {
+                            buf.Append("!");
+                            contextSymbol = true;
+                        }
+                        DFAState t = entry.Value;
+                        if (t != null && t.stateNumber != int.MaxValue)
+                        {
+                            buf.Append(GetStateString(t)).Append('\n');
+                        }
+                        else
+                        {
+                            if (contextSymbol)
+                            {
+                                buf.Append("ctx\n");
+                            }
+                        }
+                    }
+                    if (s.IsContextSensitive)
+                    {
+                        foreach (KeyValuePair<int, DFAState> entry_1 in contextEdges)
+                        {
+                            buf.Append(GetStateString(s)).Append("-").Append(GetContextLabel(entry_1.Key)).Append("->").Append(GetStateString(entry_1.Value)).Append("\n");
+                        }
+                    }
+                }
+            }
+            string output = buf.ToString();
+            if (output.Length == 0)
+            {
+                return null;
+            }
+            //return Utils.sortLinesInString(output);
+            return output;
+        }
+
+        private sealed class _IComparer_103 : IComparer<DFAState>
+        {
+            public _IComparer_103()
+            {
+            }
+
+            public int Compare(DFAState o1, DFAState o2)
+            {
+                return o1.stateNumber - o2.stateNumber;
+            }
+        }
+
+        protected internal virtual string GetContextLabel(int i)
+        {
+            if (i == PredictionContext.EmptyFullStateKey)
+            {
+                return "ctx:EMPTY_FULL";
+            }
+            else
+            {
+                if (i == PredictionContext.EmptyLocalStateKey)
+                {
+                    return "ctx:EMPTY_LOCAL";
+                }
+            }
+            if (atn != null && i > 0 && i <= atn.states.Count)
+            {
+                ATNState state = atn.states[i];
+                int ruleIndex = state.ruleIndex;
+                if (ruleNames != null && ruleIndex >= 0 && ruleIndex < ruleNames.Length)
+                {
+                    return "ctx:" + i.ToString() + "(" + ruleNames[ruleIndex] + ")";
+                }
+            }
+            return "ctx:" + i.ToString();
+        }
+
+        protected internal virtual string GetEdgeLabel(int i)
+        {
+            return vocabulary.GetDisplayName(i);
+        }
+
+        internal virtual string GetStateString(DFAState s)
+        {
+            if (s == ATNSimulator.Error)
+            {
+                return "ERROR";
+            }
+
+			int n = s.stateNumber;
+			string baseStateStr = (s.IsAcceptState ? ":" : "") + "s" + n + (s.IsContextSensitive ? "^" : "");
+			if ( s.IsAcceptState ) {
+				if ( s.predicates!=null ) {
+					return baseStateStr + "=>" + Arrays.ToString(s.predicates);
+				}
+				else {
+					return baseStateStr + "=>" + s.Prediction;
+				}
+			}
+			else {
+				return baseStateStr;
+			}
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Dfa/DFAState.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Dfa/DFAState.cs
new file mode 100644
index 000000000..429b9224f
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Dfa/DFAState.cs
@@ -0,0 +1,370 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Text;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Dfa;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Dfa
+{
+    /// <summary>A DFA state represents a set of possible ATN configurations.</summary>
+    /// <remarks>
+    /// A DFA state represents a set of possible ATN configurations.
+    /// As Aho, Sethi, Ullman p. 117 says "The DFA uses its state
+    /// to keep track of all possible states the ATN can be in after
+    /// reading each input symbol.  That is to say, after reading
+    /// input a1a2..an, the DFA is in a state that represents the
+    /// subset T of the states of the ATN that are reachable from the
+    /// ATN's start state along some path labeled a1a2..an."
+    /// In conventional NFA&#x2192;DFA conversion, therefore, the subset T
+    /// would be a bitset representing the set of states the
+    /// ATN could be in.  We need to track the alt predicted by each
+    /// state as well, however.  More importantly, we need to maintain
+    /// a stack of states, tracking the closure operations as they
+    /// jump from rule to rule, emulating rule invocations (method calls).
+    /// I have to add a stack to simulate the proper lookahead sequences for
+    /// the underlying LL grammar from which the ATN was derived.
+    /// <p>I use a set of ATNConfig objects not simple states.  An ATNConfig
+    /// is both a state (ala normal conversion) and a RuleContext describing
+    /// the chain of rules (if any) followed to arrive at that state.</p>
+    /// <p>A DFA state may have multiple references to a particular state,
+    /// but with different ATN contexts (with same or different alts)
+    /// meaning that state was reached via a different set of rule invocations.</p>
+    /// </remarks>
+    public class DFAState
+    {
+        public int stateNumber = -1;
+
+        [NotNull]
+        public readonly ATNConfigSet configs;
+
+        /// <summary>
+        /// <c>edges.get(symbol)</c>
+        /// points to target of symbol.
+        /// </summary>
+        [NotNull]
+        private volatile AbstractEdgeMap<Antlr4.Runtime.Dfa.DFAState> edges;
+
+        private Antlr4.Runtime.Dfa.AcceptStateInfo acceptStateInfo;
+
+        /// <summary>These keys for these edges are the top level element of the global context.</summary>
+        /// <remarks>These keys for these edges are the top level element of the global context.</remarks>
+        [NotNull]
+        private volatile AbstractEdgeMap<Antlr4.Runtime.Dfa.DFAState> contextEdges;
+
+        /// <summary>Symbols in this set require a global context transition before matching an input symbol.</summary>
+        /// <remarks>Symbols in this set require a global context transition before matching an input symbol.</remarks>
+        [Nullable]
+        private BitSet contextSymbols;
+
+		/// <summary>
+        /// This list is computed by
+        /// <see cref="Antlr4.Runtime.Atn.ParserATNSimulator.PredicateDFAState(DFAState, Antlr4.Runtime.Atn.ATNConfigSet, int)"/>
+        /// .
+        /// </summary>
+        [Nullable]
+        public DFAState.PredPrediction[] predicates;
+
+        /// <summary>Map a predicate to a predicted alternative.</summary>
+        /// <remarks>Map a predicate to a predicted alternative.</remarks>
+        public class PredPrediction
+        {
+            [NotNull]
+            public SemanticContext pred;
+
+            public int alt;
+
+            public PredPrediction(SemanticContext pred, int alt)
+            {
+                // never null; at least SemanticContext.NONE
+                this.alt = alt;
+                this.pred = pred;
+            }
+
+            public override string ToString()
+            {
+                return "(" + pred + ", " + alt + ")";
+            }
+        }
+
+        public DFAState(DFA dfa, ATNConfigSet configs)
+            : this(dfa.EmptyEdgeMap, dfa.EmptyContextEdgeMap, configs)
+        {
+        }
+
+        public DFAState(EmptyEdgeMap<DFAState> emptyEdges, EmptyEdgeMap<DFAState> emptyContextEdges, ATNConfigSet configs)
+        {
+            this.configs = configs;
+            this.edges = emptyEdges;
+            this.contextEdges = emptyContextEdges;
+        }
+
+        public bool IsContextSensitive
+        {
+            get
+            {
+                return contextSymbols != null;
+            }
+        }
+
+        public bool IsContextSymbol(int symbol)
+        {
+            if (!IsContextSensitive || symbol < edges.minIndex)
+            {
+                return false;
+            }
+            return contextSymbols.Get(symbol - edges.minIndex);
+        }
+
+        public void SetContextSymbol(int symbol)
+        {
+            System.Diagnostics.Debug.Assert(IsContextSensitive);
+            if (symbol < edges.minIndex)
+            {
+                return;
+            }
+            contextSymbols.Set(symbol - edges.minIndex);
+        }
+
+        public virtual void SetContextSensitive(ATN atn)
+        {
+            System.Diagnostics.Debug.Assert(!configs.IsOutermostConfigSet);
+            if (IsContextSensitive)
+            {
+                return;
+            }
+            lock (this)
+            {
+                if (contextSymbols == null)
+                {
+                    contextSymbols = new BitSet();
+                }
+            }
+        }
+
+        public AcceptStateInfo AcceptStateInfo
+        {
+            get
+            {
+                return acceptStateInfo;
+            }
+            set
+            {
+                AcceptStateInfo acceptStateInfo = value;
+                this.acceptStateInfo = acceptStateInfo;
+            }
+        }
+
+        public bool IsAcceptState
+        {
+            get
+            {
+                return acceptStateInfo != null;
+            }
+        }
+
+        public int Prediction
+        {
+            get
+            {
+                if (acceptStateInfo == null)
+                {
+                    return ATN.InvalidAltNumber;
+                }
+                return acceptStateInfo.Prediction;
+            }
+        }
+
+        public LexerActionExecutor LexerActionExecutor
+        {
+            get
+            {
+                if (acceptStateInfo == null)
+                {
+                    return null;
+                }
+                return acceptStateInfo.LexerActionExecutor;
+            }
+        }
+
+        public virtual DFAState GetTarget(int symbol)
+        {
+            return edges[symbol];
+        }
+
+        public virtual void SetTarget(int symbol, DFAState target)
+        {
+            edges = edges.Put(symbol, target);
+        }
+
+#if NET45PLUS
+        public virtual IReadOnlyDictionary<int, DFAState> EdgeMap
+#else
+        public virtual IDictionary<int, DFAState> EdgeMap
+#endif
+        {
+            get
+            {
+                return edges.ToMap();
+            }
+        }
+
+        public virtual DFAState GetContextTarget(int invokingState)
+        {
+            lock (this)
+            {
+                if (invokingState == PredictionContext.EmptyFullStateKey)
+                {
+                    invokingState = -1;
+                }
+                return contextEdges[invokingState];
+            }
+        }
+
+        public virtual void SetContextTarget(int invokingState, DFAState target)
+        {
+            lock (this)
+            {
+                if (!IsContextSensitive)
+                {
+                    throw new InvalidOperationException("The state is not context sensitive.");
+                }
+                if (invokingState == PredictionContext.EmptyFullStateKey)
+                {
+                    invokingState = -1;
+                }
+                contextEdges = contextEdges.Put(invokingState, target);
+            }
+        }
+
+#if NET45PLUS
+        public virtual IReadOnlyDictionary<int, DFAState> ContextEdgeMap
+#else
+        public virtual IDictionary<int, DFAState> ContextEdgeMap
+#endif
+        {
+            get
+            {
+                var map = contextEdges.ToMap();
+                if (map.ContainsKey(-1))
+                {
+                    if (map.Count == 1)
+                    {
+                        return Sharpen.Collections.SingletonMap(PredictionContext.EmptyFullStateKey, map[-1]);
+                    }
+                    else
+                    {
+#if NET45PLUS
+                        Dictionary<int, DFAState> result = map.ToDictionary(i => i.Key, i => i.Value);
+#else
+                        Dictionary<int, DFAState> result = new Dictionary<int, DFAState>(map);
+#endif
+                        result.Add(PredictionContext.EmptyFullStateKey, result[-1]);
+                        result.Remove(-1);
+#if NET45PLUS
+                        map = new ReadOnlyDictionary<int, DFAState>(new SortedDictionary<int, DFAState>(result));
+#elif COMPACT
+                        map = new SortedList<int, DFAState>(result);
+#elif PORTABLE && !NET45PLUS
+                        map = new Dictionary<int, DFAState>(result);
+#else
+                        map = new SortedDictionary<int, DFAState>(result);
+#endif
+                    }
+                }
+                return map;
+            }
+        }
+
+        public override int GetHashCode()
+        {
+            int hash = MurmurHash.Initialize(7);
+            hash = MurmurHash.Update(hash, configs.GetHashCode());
+            hash = MurmurHash.Finish(hash, 1);
+            return hash;
+        }
+
+        /// <summary>
+        /// Two
+        /// <see cref="DFAState"/>
+        /// instances are equal if their ATN configuration sets
+        /// are the same. This method is used to see if a state already exists.
+        /// <p>Because the number of alternatives and number of ATN configurations are
+        /// finite, there is a finite number of DFA states that can be processed.
+        /// This is necessary to show that the algorithm terminates.</p>
+        /// <p>Cannot test the DFA state numbers here because in
+        /// <see cref="Antlr4.Runtime.Atn.ParserATNSimulator.AddDFAState(DFA, Antlr4.Runtime.Atn.ATNConfigSet, Antlr4.Runtime.Atn.PredictionContextCache)"/>
+        /// we need to know if any other state
+        /// exists that has this exact set of ATN configurations. The
+        /// <see cref="stateNumber"/>
+        /// is irrelevant.</p>
+        /// </summary>
+        public override bool Equals(object o)
+        {
+            // compare set of ATN configurations in this set with other
+            if (this == o)
+            {
+                return true;
+            }
+            if (!(o is DFAState))
+            {
+                return false;
+            }
+            DFAState other = (DFAState)o;
+            bool sameSet = this.configs.Equals(other.configs);
+            //		System.out.println("DFAState.equals: "+configs+(sameSet?"==":"!=")+other.configs);
+            return sameSet;
+        }
+
+        public override string ToString()
+        {
+            StringBuilder buf = new StringBuilder();
+            buf.Append(stateNumber).Append(":").Append(configs);
+            if (IsAcceptState)
+            {
+                buf.Append("=>");
+                if (predicates != null)
+                {
+                    buf.Append(Arrays.ToString(predicates));
+                }
+                else
+                {
+                    buf.Append(Prediction);
+                }
+            }
+            return buf.ToString();
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Dfa/EmptyEdgeMap.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Dfa/EmptyEdgeMap.cs
new file mode 100644
index 000000000..dacc49936
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Dfa/EmptyEdgeMap.cs
@@ -0,0 +1,117 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System.Collections.Generic;
+using Antlr4.Runtime.Dfa;
+using Antlr4.Runtime.Sharpen;
+
+#if NET45PLUS
+using System.Collections.ObjectModel;
+#endif
+
+namespace Antlr4.Runtime.Dfa
+{
+    /// <summary>
+    /// This implementation of
+    /// <see cref="AbstractEdgeMap{T}"/>
+    /// represents an empty edge map.
+    /// </summary>
+    /// <author>Sam Harwell</author>
+    public sealed class EmptyEdgeMap<T> : AbstractEdgeMap<T>
+        where T : class
+    {
+        public EmptyEdgeMap(int minIndex, int maxIndex)
+            : base(minIndex, maxIndex)
+        {
+        }
+
+        public override AbstractEdgeMap<T> Put(int key, T value)
+        {
+            if (value == null || key < minIndex || key > maxIndex)
+            {
+                // remains empty
+                return this;
+            }
+            return new SingletonEdgeMap<T>(minIndex, maxIndex, key, value);
+        }
+
+        public override AbstractEdgeMap<T> Clear()
+        {
+            return this;
+        }
+
+        public override AbstractEdgeMap<T> Remove(int key)
+        {
+            return this;
+        }
+
+        public override int Count
+        {
+            get
+            {
+                return 0;
+            }
+        }
+
+        public override bool IsEmpty
+        {
+            get
+            {
+                return true;
+            }
+        }
+
+        public override bool ContainsKey(int key)
+        {
+            return false;
+        }
+
+        public override T this[int key]
+        {
+            get
+            {
+                return null;
+            }
+        }
+
+#if NET45PLUS
+        public override IReadOnlyDictionary<int, T> ToMap()
+#else
+        public override IDictionary<int, T> ToMap()
+#endif
+        {
+            Dictionary<int, T> result = new Dictionary<int, T>();
+#if NET45PLUS
+            return new ReadOnlyDictionary<int, T>(result);
+#else
+            return result;
+#endif
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Dfa/IEdgeMap.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Dfa/IEdgeMap.cs
new file mode 100644
index 000000000..a679fdf46
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Dfa/IEdgeMap.cs
@@ -0,0 +1,77 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System.Collections.Generic;
+using Antlr4.Runtime.Dfa;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Dfa
+{
+    /// <author>Sam Harwell</author>
+    public interface IEdgeMap<T> : IEnumerable<KeyValuePair<int, T>>
+    {
+        int Count
+        {
+            get;
+        }
+
+        bool IsEmpty
+        {
+            get;
+        }
+
+        bool ContainsKey(int key);
+
+        T this[int key]
+        {
+            get;
+        }
+
+        [return: NotNull]
+        IEdgeMap<T> Put(int key, T value);
+
+        [return: NotNull]
+        IEdgeMap<T> Remove(int key);
+
+        [return: NotNull]
+        IEdgeMap<T> PutAll(IEdgeMap<T> m);
+
+        [return: NotNull]
+        IEdgeMap<T> Clear();
+
+#if NET45PLUS
+        [return: NotNull]
+        IReadOnlyDictionary<int, T> ToMap();
+#else
+        [return: NotNull]
+        IDictionary<int, T> ToMap();
+#endif
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Dfa/LexerDFASerializer.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Dfa/LexerDFASerializer.cs
new file mode 100644
index 000000000..2644aceee
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Dfa/LexerDFASerializer.cs
@@ -0,0 +1,50 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime;
+using Antlr4.Runtime.Dfa;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Dfa
+{
+    public class LexerDFASerializer : DFASerializer
+    {
+        public LexerDFASerializer(DFA dfa)
+            : base(dfa, Vocabulary.EmptyVocabulary)
+        {
+        }
+
+        [return: NotNull]
+        protected internal override string GetEdgeLabel(int i)
+        {
+            return "'" + (char)i + "'";
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Dfa/SingletonEdgeMap.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Dfa/SingletonEdgeMap.cs
new file mode 100644
index 000000000..6fa8ba2df
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Dfa/SingletonEdgeMap.cs
@@ -0,0 +1,165 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System.Collections.Generic;
+using Antlr4.Runtime.Dfa;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Dfa
+{
+    /// <author>Sam Harwell</author>
+    public sealed class SingletonEdgeMap<T> : AbstractEdgeMap<T>
+        where T : class
+    {
+        private readonly int key;
+
+        private readonly T value;
+
+        public SingletonEdgeMap(int minIndex, int maxIndex, int key, T value)
+            : base(minIndex, maxIndex)
+        {
+            if (key >= minIndex && key <= maxIndex)
+            {
+                this.key = key;
+                this.value = value;
+            }
+            else
+            {
+                this.key = 0;
+                this.value = null;
+            }
+        }
+
+        public int Key
+        {
+            get
+            {
+                return key;
+            }
+        }
+
+        public T Value
+        {
+            get
+            {
+                return value;
+            }
+        }
+
+        public override int Count
+        {
+            get
+            {
+                return value != null ? 1 : 0;
+            }
+        }
+
+        public override bool IsEmpty
+        {
+            get
+            {
+                return value == null;
+            }
+        }
+
+        public override bool ContainsKey(int key)
+        {
+            return key == this.key && value != null;
+        }
+
+        public override T this[int key]
+        {
+            get
+            {
+                if (key == this.key)
+                {
+                    return value;
+                }
+                return null;
+            }
+        }
+
+        public override AbstractEdgeMap<T> Put(int key, T value)
+        {
+            if (key < minIndex || key > maxIndex)
+            {
+                return this;
+            }
+            if (key == this.key || this.value == null)
+            {
+                return new Antlr4.Runtime.Dfa.SingletonEdgeMap<T>(minIndex, maxIndex, key, value);
+            }
+            else
+            {
+                if (value != null)
+                {
+                    AbstractEdgeMap<T> result = new SparseEdgeMap<T>(minIndex, maxIndex);
+                    result = result.Put(this.key, this.value);
+                    result = result.Put(key, value);
+                    return result;
+                }
+                else
+                {
+                    return this;
+                }
+            }
+        }
+
+        public override AbstractEdgeMap<T> Remove(int key)
+        {
+            if (key == this.key && this.value != null)
+            {
+                return new EmptyEdgeMap<T>(minIndex, maxIndex);
+            }
+            return this;
+        }
+
+        public override AbstractEdgeMap<T> Clear()
+        {
+            if (this.value != null)
+            {
+                return new EmptyEdgeMap<T>(minIndex, maxIndex);
+            }
+            return this;
+        }
+
+#if NET45PLUS
+        public override IReadOnlyDictionary<int, T> ToMap()
+#else
+        public override IDictionary<int, T> ToMap()
+#endif
+        {
+            if (IsEmpty)
+            {
+                return Sharpen.Collections.EmptyMap<int, T>();
+            }
+            return Antlr4.Runtime.Sharpen.Collections.SingletonMap(key, value);
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Dfa/SparseEdgeMap.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Dfa/SparseEdgeMap.cs
new file mode 100644
index 000000000..c2fd9bc78
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Dfa/SparseEdgeMap.cs
@@ -0,0 +1,241 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using Antlr4.Runtime.Dfa;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Dfa
+{
+    /// <author>Sam Harwell</author>
+    public sealed class SparseEdgeMap<T> : AbstractEdgeMap<T>
+        where T : class
+    {
+        private const int DefaultMaxSize = 5;
+
+        private readonly int[] keys;
+
+        private readonly List<T> values;
+
+        public SparseEdgeMap(int minIndex, int maxIndex)
+            : this(minIndex, maxIndex, DefaultMaxSize)
+        {
+        }
+
+        public SparseEdgeMap(int minIndex, int maxIndex, int maxSparseSize)
+            : base(minIndex, maxIndex)
+        {
+            this.keys = new int[maxSparseSize];
+            this.values = new List<T>(maxSparseSize);
+        }
+
+        private SparseEdgeMap(Antlr4.Runtime.Dfa.SparseEdgeMap<T> map, int maxSparseSize)
+            : base(map.minIndex, map.maxIndex)
+        {
+            lock (map)
+            {
+                if (maxSparseSize < map.values.Count)
+                {
+                    throw new ArgumentException();
+                }
+                keys = Arrays.CopyOf(map.keys, maxSparseSize);
+                values = new List<T>(maxSparseSize);
+                values.AddRange(map.Values);
+            }
+        }
+
+        public int[] Keys
+        {
+            get
+            {
+                return keys;
+            }
+        }
+
+        public IList<T> Values
+        {
+            get
+            {
+                return values;
+            }
+        }
+
+        public int MaxSparseSize
+        {
+            get
+            {
+                return keys.Length;
+            }
+        }
+
+        public override int Count
+        {
+            get
+            {
+                return values.Count;
+            }
+        }
+
+        public override bool IsEmpty
+        {
+            get
+            {
+                return values.Count == 0;
+            }
+        }
+
+        public override bool ContainsKey(int key)
+        {
+            return this[key] != null;
+        }
+
+        public override T this[int key]
+        {
+            get
+            {
+                // Special property of this collection: values are only even added to
+                // the end, else a new object is returned from put(). Therefore no lock
+                // is required in this method.
+                int index = System.Array.BinarySearch(keys, 0, Count, key);
+                if (index < 0)
+                {
+                    return null;
+                }
+                return values[index];
+            }
+        }
+
+        public override AbstractEdgeMap<T> Put(int key, T value)
+        {
+            if (key < minIndex || key > maxIndex)
+            {
+                return this;
+            }
+            if (value == null)
+            {
+                return Remove(key);
+            }
+            lock (this)
+            {
+                int index = System.Array.BinarySearch(keys, 0, Count, key);
+                if (index >= 0)
+                {
+                    // replace existing entry
+                    values[index] = value;
+                    return this;
+                }
+                System.Diagnostics.Debug.Assert(index < 0 && value != null);
+                int insertIndex = -index - 1;
+                if (Count < MaxSparseSize && insertIndex == Count)
+                {
+                    // stay sparse and add new entry
+                    keys[insertIndex] = key;
+                    values.Add(value);
+                    return this;
+                }
+                int desiredSize = Count >= MaxSparseSize ? MaxSparseSize * 2 : MaxSparseSize;
+                int space = maxIndex - minIndex + 1;
+                // SparseEdgeMap only uses less memory than ArrayEdgeMap up to half the size of the symbol space
+                if (desiredSize >= space / 2)
+                {
+                    ArrayEdgeMap<T> arrayMap = new ArrayEdgeMap<T>(minIndex, maxIndex);
+                    arrayMap = ((ArrayEdgeMap<T>)arrayMap.PutAll(this));
+                    arrayMap.Put(key, value);
+                    return arrayMap;
+                }
+                else
+                {
+                    Antlr4.Runtime.Dfa.SparseEdgeMap<T> resized = new Antlr4.Runtime.Dfa.SparseEdgeMap<T>(this, desiredSize);
+                    System.Array.Copy(resized.keys, insertIndex, resized.keys, insertIndex + 1, Count - insertIndex);
+                    resized.keys[insertIndex] = key;
+                    resized.values.Insert(insertIndex, value);
+                    return resized;
+                }
+            }
+        }
+
+        public override AbstractEdgeMap<T> Remove(int key)
+        {
+            lock (this)
+            {
+                int index = System.Array.BinarySearch(keys, 0, Count, key);
+                if (index < 0)
+                {
+                    return this;
+                }
+                Antlr4.Runtime.Dfa.SparseEdgeMap<T> result = new Antlr4.Runtime.Dfa.SparseEdgeMap<T>(this, MaxSparseSize);
+                System.Array.Copy(result.keys, index + 1, result.keys, index, Count - index - 1);
+                result.values.RemoveAt(index);
+                return result;
+            }
+        }
+
+        public override AbstractEdgeMap<T> Clear()
+        {
+            if (IsEmpty)
+            {
+                return this;
+            }
+            return new EmptyEdgeMap<T>(minIndex, maxIndex);
+        }
+
+#if NET45PLUS
+        public override IReadOnlyDictionary<int, T> ToMap()
+#else
+        public override IDictionary<int, T> ToMap()
+#endif
+        {
+            if (IsEmpty)
+            {
+                return Sharpen.Collections.EmptyMap<int, T>();
+            }
+            lock (this)
+            {
+#if COMPACT
+                IDictionary<int, T> result = new SortedList<int, T>();
+#elif PORTABLE && !NET45PLUS
+                IDictionary<int, T> result = new Dictionary<int, T>();
+#else
+                IDictionary<int, T> result = new SortedDictionary<int, T>();
+#endif
+                for (int i = 0; i < Count; i++)
+                {
+                    result[keys[i]] = values[i];
+                }
+#if NET45PLUS
+                return new ReadOnlyDictionary<int, T>(result);
+#else
+                return result;
+#endif
+            }
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/DiagnosticErrorListener.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/DiagnosticErrorListener.cs
new file mode 100644
index 000000000..34c0e5413
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/DiagnosticErrorListener.cs
@@ -0,0 +1,188 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Dfa;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime
+{
+    /// <summary>
+    /// This implementation of
+    /// <see cref="IAntlrErrorListener{Symbol}"/>
+    /// can be used to identify
+    /// certain potential correctness and performance problems in grammars. "Reports"
+    /// are made by calling
+    /// <see cref="Parser.NotifyErrorListeners(string)"/>
+    /// with the appropriate
+    /// message.
+    /// <ul>
+    /// <li><b>Ambiguities</b>: These are cases where more than one path through the
+    /// grammar can match the input.</li>
+    /// <li><b>Weak context sensitivity</b>: These are cases where full-context
+    /// prediction resolved an SLL conflict to a unique alternative which equaled the
+    /// minimum alternative of the SLL conflict.</li>
+    /// <li><b>Strong (forced) context sensitivity</b>: These are cases where the
+    /// full-context prediction resolved an SLL conflict to a unique alternative,
+    /// <em>and</em> the minimum alternative of the SLL conflict was found to not be
+    /// a truly viable alternative. Two-stage parsing cannot be used for inputs where
+    /// this situation occurs.</li>
+    /// </ul>
+    /// </summary>
+    /// <author>Sam Harwell</author>
+    public class DiagnosticErrorListener : BaseErrorListener
+    {
+        /// <summary>
+        /// When
+        /// <see langword="true"/>
+        /// , only exactly known ambiguities are reported.
+        /// </summary>
+        protected internal readonly bool exactOnly;
+
+        /// <summary>
+        /// Initializes a new instance of
+        /// <see cref="DiagnosticErrorListener"/>
+        /// which only
+        /// reports exact ambiguities.
+        /// </summary>
+        public DiagnosticErrorListener()
+            : this(true)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of
+        /// <see cref="DiagnosticErrorListener"/>
+        /// , specifying
+        /// whether all ambiguities or only exact ambiguities are reported.
+        /// </summary>
+        /// <param name="exactOnly">
+        /// 
+        /// <see langword="true"/>
+        /// to report only exact ambiguities, otherwise
+        /// <see langword="false"/>
+        /// to report all ambiguities.
+        /// </param>
+        public DiagnosticErrorListener(bool exactOnly)
+        {
+            this.exactOnly = exactOnly;
+        }
+
+        public override void ReportAmbiguity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, bool exact, BitSet ambigAlts, ATNConfigSet configs)
+        {
+            if (exactOnly && !exact)
+            {
+                return;
+            }
+            string format = "reportAmbiguity d={0}: ambigAlts={1}, input='{2}'";
+            string decision = GetDecisionDescription(recognizer, dfa);
+            BitSet conflictingAlts = GetConflictingAlts(ambigAlts, configs);
+            string text = ((ITokenStream)recognizer.InputStream).GetText(Interval.Of(startIndex, stopIndex));
+            string message = string.Format(format, decision, conflictingAlts, text);
+            recognizer.NotifyErrorListeners(message);
+        }
+
+        public override void ReportAttemptingFullContext(Parser recognizer, DFA dfa, int startIndex, int stopIndex, BitSet conflictingAlts, SimulatorState conflictState)
+        {
+            string format = "reportAttemptingFullContext d={0}, input='{1}'";
+            string decision = GetDecisionDescription(recognizer, dfa);
+            string text = ((ITokenStream)recognizer.InputStream).GetText(Interval.Of(startIndex, stopIndex));
+            string message = string.Format(format, decision, text);
+            recognizer.NotifyErrorListeners(message);
+        }
+
+        public override void ReportContextSensitivity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, int prediction, SimulatorState acceptState)
+        {
+            string format = "reportContextSensitivity d={0}, input='{1}'";
+            string decision = GetDecisionDescription(recognizer, dfa);
+            string text = ((ITokenStream)recognizer.InputStream).GetText(Interval.Of(startIndex, stopIndex));
+            string message = string.Format(format, decision, text);
+            recognizer.NotifyErrorListeners(message);
+        }
+
+        protected internal virtual string GetDecisionDescription(Parser recognizer, DFA dfa)
+        {
+            int decision = dfa.decision;
+            int ruleIndex = dfa.atnStartState.ruleIndex;
+            string[] ruleNames = recognizer.RuleNames;
+            if (ruleIndex < 0 || ruleIndex >= ruleNames.Length)
+            {
+                return decision.ToString();
+            }
+            string ruleName = ruleNames[ruleIndex];
+            if (string.IsNullOrEmpty(ruleName))
+            {
+                return decision.ToString();
+            }
+            return string.Format("{0} ({1})", decision, ruleName);
+        }
+
+        /// <summary>
+        /// Computes the set of conflicting or ambiguous alternatives from a
+        /// configuration set, if that information was not already provided by the
+        /// parser.
+        /// </summary>
+        /// <remarks>
+        /// Computes the set of conflicting or ambiguous alternatives from a
+        /// configuration set, if that information was not already provided by the
+        /// parser.
+        /// </remarks>
+        /// <param name="reportedAlts">
+        /// The set of conflicting or ambiguous alternatives, as
+        /// reported by the parser.
+        /// </param>
+        /// <param name="configs">The conflicting or ambiguous configuration set.</param>
+        /// <returns>
+        /// Returns
+        /// <paramref name="reportedAlts"/>
+        /// if it is not
+        /// <see langword="null"/>
+        /// , otherwise
+        /// returns the set of alternatives represented in
+        /// <paramref name="configs"/>
+        /// .
+        /// </returns>
+        [return: NotNull]
+        protected internal virtual BitSet GetConflictingAlts(BitSet reportedAlts, ATNConfigSet configs)
+        {
+            if (reportedAlts != null)
+            {
+                return reportedAlts;
+            }
+            BitSet result = new BitSet();
+            foreach (ATNConfig config in configs)
+            {
+                result.Set(config.Alt);
+            }
+            return result;
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/FailedPredicateException.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/FailedPredicateException.cs
new file mode 100644
index 000000000..ce33b266e
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/FailedPredicateException.cs
@@ -0,0 +1,120 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System.Globalization;
+using Antlr4.Runtime;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime
+{
+    /// <summary>A semantic predicate failed during validation.</summary>
+    /// <remarks>
+    /// A semantic predicate failed during validation.  Validation of predicates
+    /// occurs when normally parsing the alternative just like matching a token.
+    /// Disambiguating predicate evaluation occurs when we test a predicate during
+    /// prediction.
+    /// </remarks>
+    [System.Serializable]
+    public class FailedPredicateException : RecognitionException
+    {
+        private const long serialVersionUID = 5379330841495778709L;
+
+        private readonly int ruleIndex;
+
+        private readonly int predicateIndex;
+
+        private readonly string predicate;
+
+        public FailedPredicateException(Parser recognizer)
+            : this(recognizer, null)
+        {
+        }
+
+        public FailedPredicateException(Parser recognizer, string predicate)
+            : this(recognizer, predicate, null)
+        {
+        }
+
+        public FailedPredicateException(Parser recognizer, string predicate, string message)
+			: base(FormatMessage(predicate, message), recognizer, ((ITokenStream)recognizer.InputStream), recognizer.RuleContext)
+        {
+            ATNState s = recognizer.Interpreter.atn.states[recognizer.State];
+            AbstractPredicateTransition trans = (AbstractPredicateTransition)s.Transition(0);
+            if (trans is PredicateTransition)
+            {
+                this.ruleIndex = ((PredicateTransition)trans).ruleIndex;
+                this.predicateIndex = ((PredicateTransition)trans).predIndex;
+            }
+            else
+            {
+                this.ruleIndex = 0;
+                this.predicateIndex = 0;
+            }
+            this.predicate = predicate;
+            this.OffendingToken = recognizer.CurrentToken;
+        }
+
+        public virtual int RuleIndex
+        {
+            get
+            {
+                return ruleIndex;
+            }
+        }
+
+        public virtual int PredIndex
+        {
+            get
+            {
+                return predicateIndex;
+            }
+        }
+
+        [Nullable]
+        public virtual string Predicate
+        {
+            get
+            {
+                return predicate;
+            }
+        }
+
+        [return: NotNull]
+        private static string FormatMessage(string predicate, string message)
+        {
+            if (message != null)
+            {
+                return message;
+            }
+            return string.Format(CultureInfo.CurrentCulture, "failed predicate: {{{0}}}?", predicate);
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/IAntlrErrorListener.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/IAntlrErrorListener.cs
new file mode 100644
index 000000000..3ffc4e7ab
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/IAntlrErrorListener.cs
@@ -0,0 +1,82 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime
+{
+    /// <summary>How to emit recognition errors.</summary>
+    /// <remarks>How to emit recognition errors.</remarks>
+#if COMPACT
+    public interface IAntlrErrorListener<TSymbol>
+#else
+    public interface IAntlrErrorListener<in TSymbol>
+#endif
+    {
+        /// <summary>Upon syntax error, notify any interested parties.</summary>
+        /// <remarks>
+        /// Upon syntax error, notify any interested parties. This is not how to
+        /// recover from errors or compute error messages.
+        /// <see cref="IAntlrErrorStrategy"/>
+        /// specifies how to recover from syntax errors and how to compute error
+        /// messages. This listener's job is simply to emit a computed message,
+        /// though it has enough information to create its own message in many cases.
+        /// <p>The
+        /// <see cref="RecognitionException"/>
+        /// is non-null for all syntax errors except
+        /// when we discover mismatched token errors that we can recover from
+        /// in-line, without returning from the surrounding rule (via the single
+        /// token insertion and deletion mechanism).</p>
+        /// </remarks>
+        /// <param name="recognizer">
+        /// What parser got the error. From this
+        /// object, you can access the context as well
+        /// as the input stream.
+        /// </param>
+        /// <param name="offendingSymbol">
+        /// The offending token in the input token
+        /// stream, unless recognizer is a lexer (then it's null). If
+        /// no viable alternative error,
+        /// <paramref name="e"/>
+        /// has token at which we
+        /// started production for the decision.
+        /// </param>
+        /// <param name="line">The line number in the input where the error occurred.</param>
+        /// <param name="charPositionInLine">The character position within that line where the error occurred.</param>
+        /// <param name="msg">The message to emit.</param>
+        /// <param name="e">
+        /// The exception generated by the parser that led to
+        /// the reporting of an error. It is null in the case where
+        /// the parser was able to recover in line without exiting the
+        /// surrounding rule.
+        /// </param>
+        void SyntaxError(IRecognizer recognizer, TSymbol offendingSymbol, int line, int charPositionInLine, string msg, RecognitionException e);
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/IAntlrErrorStrategy.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/IAntlrErrorStrategy.cs
new file mode 100644
index 000000000..8d1b826ee
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/IAntlrErrorStrategy.cs
@@ -0,0 +1,180 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime
+{
+    /// <summary>
+    /// The interface for defining strategies to deal with syntax errors encountered
+    /// during a parse by ANTLR-generated parsers.
+    /// </summary>
+    /// <remarks>
+    /// The interface for defining strategies to deal with syntax errors encountered
+    /// during a parse by ANTLR-generated parsers. We distinguish between three
+    /// different kinds of errors:
+    /// <ul>
+    /// <li>The parser could not figure out which path to take in the ATN (none of
+    /// the available alternatives could possibly match)</li>
+    /// <li>The current input does not match what we were looking for</li>
+    /// <li>A predicate evaluated to false</li>
+    /// </ul>
+    /// Implementations of this interface report syntax errors by calling
+    /// <see cref="Parser.NotifyErrorListeners(string)"/>
+    /// .
+    /// <p>TODO: what to do about lexers</p>
+    /// </remarks>
+    public interface IAntlrErrorStrategy
+    {
+        /// <summary>
+        /// Reset the error handler state for the specified
+        /// <paramref name="recognizer"/>
+        /// .
+        /// </summary>
+        /// <param name="recognizer">the parser instance</param>
+        void Reset(Parser recognizer);
+
+        /// <summary>
+        /// This method is called when an unexpected symbol is encountered during an
+        /// inline match operation, such as
+        /// <see cref="Parser.Match(int)"/>
+        /// . If the error
+        /// strategy successfully recovers from the match failure, this method
+        /// returns the
+        /// <see cref="IToken"/>
+        /// instance which should be treated as the
+        /// successful result of the match.
+        /// <p>Note that the calling code will not report an error if this method
+        /// returns successfully. The error strategy implementation is responsible
+        /// for calling
+        /// <see cref="Parser.NotifyErrorListeners(string)"/>
+        /// as appropriate.</p>
+        /// </summary>
+        /// <param name="recognizer">the parser instance</param>
+        /// <exception cref="RecognitionException">
+        /// if the error strategy was not able to
+        /// recover from the unexpected input symbol
+        /// </exception>
+        /// <exception cref="Antlr4.Runtime.RecognitionException"/>
+        [return: NotNull]
+        IToken RecoverInline(Parser recognizer);
+
+        /// <summary>
+        /// This method is called to recover from exception
+        /// <paramref name="e"/>
+        /// . This method is
+        /// called after
+        /// <see cref="ReportError(Parser, RecognitionException)"/>
+        /// by the default exception handler
+        /// generated for a rule method.
+        /// </summary>
+        /// <seealso cref="ReportError(Parser, RecognitionException)"/>
+        /// <param name="recognizer">the parser instance</param>
+        /// <param name="e">the recognition exception to recover from</param>
+        /// <exception cref="RecognitionException">
+        /// if the error strategy could not recover from
+        /// the recognition exception
+        /// </exception>
+        /// <exception cref="Antlr4.Runtime.RecognitionException"/>
+        void Recover(Parser recognizer, RecognitionException e);
+
+        /// <summary>
+        /// This method provides the error handler with an opportunity to handle
+        /// syntactic or semantic errors in the input stream before they result in a
+        /// <see cref="RecognitionException"/>
+        /// .
+        /// <p>The generated code currently contains calls to
+        /// <see cref="Sync(Parser)"/>
+        /// after
+        /// entering the decision state of a closure block (
+        /// <c>(...)*</c>
+        /// or
+        /// <c>(...)+</c>
+        /// ).</p>
+        /// <p>For an implementation based on Jim Idle's "magic sync" mechanism, see
+        /// <see cref="DefaultErrorStrategy.Sync(Parser)"/>
+        /// .</p>
+        /// </summary>
+        /// <seealso cref="DefaultErrorStrategy.Sync(Parser)"/>
+        /// <param name="recognizer">the parser instance</param>
+        /// <exception cref="RecognitionException">
+        /// if an error is detected by the error
+        /// strategy but cannot be automatically recovered at the current state in
+        /// the parsing process
+        /// </exception>
+        /// <exception cref="Antlr4.Runtime.RecognitionException"/>
+        void Sync(Parser recognizer);
+
+        /// <summary>
+        /// Tests whether or not
+        /// <paramref name="recognizer"/>
+        /// is in the process of recovering
+        /// from an error. In error recovery mode,
+        /// <see cref="Parser.Consume()"/>
+        /// adds
+        /// symbols to the parse tree by calling
+        /// <see cref="ParserRuleContext.AddErrorNode(IToken)"/>
+        /// instead of
+        /// <see cref="ParserRuleContext.AddChild(IToken)"/>
+        /// .
+        /// </summary>
+        /// <param name="recognizer">the parser instance</param>
+        /// <returns>
+        /// 
+        /// <see langword="true"/>
+        /// if the parser is currently recovering from a parse
+        /// error, otherwise
+        /// <see langword="false"/>
+        /// </returns>
+        bool InErrorRecoveryMode(Parser recognizer);
+
+        /// <summary>
+        /// This method is called by when the parser successfully matches an input
+        /// symbol.
+        /// </summary>
+        /// <remarks>
+        /// This method is called by when the parser successfully matches an input
+        /// symbol.
+        /// </remarks>
+        /// <param name="recognizer">the parser instance</param>
+        void ReportMatch(Parser recognizer);
+
+        /// <summary>
+        /// Report any kind of
+        /// <see cref="RecognitionException"/>
+        /// . This method is called by
+        /// the default exception handler generated for a rule method.
+        /// </summary>
+        /// <param name="recognizer">the parser instance</param>
+        /// <param name="e">the recognition exception to report</param>
+        void ReportError(Parser recognizer, RecognitionException e);
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/ICharStream.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/ICharStream.cs
new file mode 100644
index 000000000..c3141f25d
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/ICharStream.cs
@@ -0,0 +1,79 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime
+{
+    /// <summary>A source of characters for an ANTLR lexer.</summary>
+    /// <remarks>A source of characters for an ANTLR lexer.</remarks>
+    public interface ICharStream : IIntStream
+    {
+        /// <summary>
+        /// This method returns the text for a range of characters within this input
+        /// stream.
+        /// </summary>
+        /// <remarks>
+        /// This method returns the text for a range of characters within this input
+        /// stream. This method is guaranteed to not throw an exception if the
+        /// specified
+        /// <paramref name="interval"/>
+        /// lies entirely within a marked range. For more
+        /// information about marked ranges, see
+        /// <see cref="IIntStream.Mark()"/>
+        /// .
+        /// </remarks>
+        /// <param name="interval">an interval within the stream</param>
+        /// <returns>the text of the specified interval</returns>
+        /// <exception cref="System.ArgumentNullException">
+        /// if
+        /// <paramref name="interval"/>
+        /// is
+        /// <see langword="null"/>
+        /// </exception>
+        /// <exception cref="System.ArgumentException">
+        /// if
+        /// <c>interval.a &lt; 0</c>
+        /// , or if
+        /// <c>interval.b &lt; interval.a - 1</c>
+        /// , or if
+        /// <c>interval.b</c>
+        /// lies at or
+        /// past the end of the stream
+        /// </exception>
+        /// <exception cref="System.NotSupportedException">
+        /// if the stream does not support
+        /// getting the text of the specified interval
+        /// </exception>
+        [return: NotNull]
+        string GetText(Interval interval);
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/IIntStream.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/IIntStream.cs
new file mode 100644
index 000000000..c45607467
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/IIntStream.cs
@@ -0,0 +1,363 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime
+{
+    /// <summary>A simple stream of symbols whose values are represented as integers.</summary>
+    /// <remarks>
+    /// A simple stream of symbols whose values are represented as integers. This
+    /// interface provides <em>marked ranges</em> with support for a minimum level
+    /// of buffering necessary to implement arbitrary lookahead during prediction.
+    /// For more information on marked ranges, see
+    /// <see cref="Mark()"/>
+    /// .
+    /// <p><strong>Initializing Methods:</strong> Some methods in this interface have
+    /// unspecified behavior if no call to an initializing method has occurred after
+    /// the stream was constructed. The following is a list of initializing methods:</p>
+    /// <ul>
+    /// <li>
+    /// <see cref="La(int)"/>
+    /// </li>
+    /// <li>
+    /// <see cref="Consume()"/>
+    /// </li>
+    /// <li>
+    /// <see cref="Size()"/>
+    /// </li>
+    /// </ul>
+    /// </remarks>
+    public interface IIntStream
+    {
+        /// <summary>Consumes the current symbol in the stream.</summary>
+        /// <remarks>
+        /// Consumes the current symbol in the stream. This method has the following
+        /// effects:
+        /// <ul>
+        /// <li><strong>Forward movement:</strong> The value of
+        /// <see cref="Index()">index()</see>
+        /// before calling this method is less than the value of
+        /// <c>index()</c>
+        /// after calling this method.</li>
+        /// <li><strong>Ordered lookahead:</strong> The value of
+        /// <c>LA(1)</c>
+        /// before
+        /// calling this method becomes the value of
+        /// <c>LA(-1)</c>
+        /// after calling
+        /// this method.</li>
+        /// </ul>
+        /// Note that calling this method does not guarantee that
+        /// <c>index()</c>
+        /// is
+        /// incremented by exactly 1, as that would preclude the ability to implement
+        /// filtering streams (e.g.
+        /// <see cref="CommonTokenStream"/>
+        /// which distinguishes
+        /// between "on-channel" and "off-channel" tokens).
+        /// </remarks>
+        /// <exception cref="System.InvalidOperationException">
+        /// if an attempt is made to consume the the
+        /// end of the stream (i.e. if
+        /// <c>LA(1)==</c>
+        /// <see cref="IntStreamConstants.Eof">EOF</see>
+        /// before calling
+        /// <c>consume</c>
+        /// ).
+        /// </exception>
+        void Consume();
+
+        /// <summary>
+        /// Gets the value of the symbol at offset
+        /// <paramref name="i"/>
+        /// from the current
+        /// position. When
+        /// <c>i==1</c>
+        /// , this method returns the value of the current
+        /// symbol in the stream (which is the next symbol to be consumed). When
+        /// <c>i==-1</c>
+        /// , this method returns the value of the previously read
+        /// symbol in the stream. It is not valid to call this method with
+        /// <c>i==0</c>
+        /// , but the specific behavior is unspecified because this
+        /// method is frequently called from performance-critical code.
+        /// <p>This method is guaranteed to succeed if any of the following are true:</p>
+        /// <ul>
+        /// <li>
+        /// <c>i&gt;0</c>
+        /// </li>
+        /// <li>
+        /// <c>i==-1</c>
+        /// and
+        /// <see cref="Index()">index()</see>
+        /// returns a value greater
+        /// than the value of
+        /// <c>index()</c>
+        /// after the stream was constructed
+        /// and
+        /// <c>LA(1)</c>
+        /// was called in that order. Specifying the current
+        /// <c>index()</c>
+        /// relative to the index after the stream was created
+        /// allows for filtering implementations that do not return every symbol
+        /// from the underlying source. Specifying the call to
+        /// <c>LA(1)</c>
+        /// allows for lazily initialized streams.</li>
+        /// <li>
+        /// <c>LA(i)</c>
+        /// refers to a symbol consumed within a marked region
+        /// that has not yet been released.</li>
+        /// </ul>
+        /// <p>If
+        /// <paramref name="i"/>
+        /// represents a position at or beyond the end of the stream,
+        /// this method returns
+        /// <see cref="IntStreamConstants.Eof"/>
+        /// .</p>
+        /// <p>The return value is unspecified if
+        /// <c>i&lt;0</c>
+        /// and fewer than
+        /// <c>-i</c>
+        /// calls to
+        /// <see cref="Consume()">consume()</see>
+        /// have occurred from the beginning of
+        /// the stream before calling this method.</p>
+        /// </summary>
+        /// <exception cref="System.NotSupportedException">
+        /// if the stream does not support
+        /// retrieving the value of the specified symbol
+        /// </exception>
+        int La(int i);
+
+        /// <summary>
+        /// A mark provides a guarantee that
+        /// <see cref="Seek(int)">seek()</see>
+        /// operations will be
+        /// valid over a "marked range" extending from the index where
+        /// <c>mark()</c>
+        /// was called to the current
+        /// <see cref="Index()">index()</see>
+        /// . This allows the use of
+        /// streaming input sources by specifying the minimum buffering requirements
+        /// to support arbitrary lookahead during prediction.
+        /// <p>The returned mark is an opaque handle (type
+        /// <c>int</c>
+        /// ) which is passed
+        /// to
+        /// <see cref="Release(int)">release()</see>
+        /// when the guarantees provided by the marked
+        /// range are no longer necessary. When calls to
+        /// <c>mark()</c>
+        /// /
+        /// <c>release()</c>
+        /// are nested, the marks must be released
+        /// in reverse order of which they were obtained. Since marked regions are
+        /// used during performance-critical sections of prediction, the specific
+        /// behavior of invalid usage is unspecified (i.e. a mark is not released, or
+        /// a mark is released twice, or marks are not released in reverse order from
+        /// which they were created).</p>
+        /// <p>The behavior of this method is unspecified if no call to an
+        /// <see cref="IIntStream">initializing method</see>
+        /// has occurred after this stream was
+        /// constructed.</p>
+        /// <p>This method does not change the current position in the input stream.</p>
+        /// <p>The following example shows the use of
+        /// <see cref="Mark()">mark()</see>
+        /// ,
+        /// <see cref="Release(int)">release(mark)</see>
+        /// ,
+        /// <see cref="Index()">index()</see>
+        /// , and
+        /// <see cref="Seek(int)">seek(index)</see>
+        /// as part of an operation to safely work within a
+        /// marked region, then restore the stream position to its original value and
+        /// release the mark.</p>
+        /// <pre>
+        /// IntStream stream = ...;
+        /// int index = -1;
+        /// int mark = stream.mark();
+        /// try {
+        /// index = stream.index();
+        /// // perform work here...
+        /// } finally {
+        /// if (index != -1) {
+        /// stream.seek(index);
+        /// }
+        /// stream.release(mark);
+        /// }
+        /// </pre>
+        /// </summary>
+        /// <returns>
+        /// An opaque marker which should be passed to
+        /// <see cref="Release(int)">release()</see>
+        /// when the marked range is no longer required.
+        /// </returns>
+        int Mark();
+
+        /// <summary>
+        /// This method releases a marked range created by a call to
+        /// <see cref="Mark()">mark()</see>
+        /// . Calls to
+        /// <c>release()</c>
+        /// must appear in the
+        /// reverse order of the corresponding calls to
+        /// <c>mark()</c>
+        /// . If a mark is
+        /// released twice, or if marks are not released in reverse order of the
+        /// corresponding calls to
+        /// <c>mark()</c>
+        /// , the behavior is unspecified.
+        /// <p>For more information and an example, see
+        /// <see cref="Mark()"/>
+        /// .</p>
+        /// </summary>
+        /// <param name="marker">
+        /// A marker returned by a call to
+        /// <c>mark()</c>
+        /// .
+        /// </param>
+        /// <seealso cref="Mark()"/>
+        void Release(int marker);
+
+        /// <summary>
+        /// Return the index into the stream of the input symbol referred to by
+        /// <c>LA(1)</c>
+        /// .
+        /// <p>The behavior of this method is unspecified if no call to an
+        /// <see cref="IIntStream">initializing method</see>
+        /// has occurred after this stream was
+        /// constructed.</p>
+        /// </summary>
+        int Index
+        {
+            get;
+        }
+
+        /// <summary>
+        /// Set the input cursor to the position indicated by
+        /// <paramref name="index"/>
+        /// . If the
+        /// specified index lies past the end of the stream, the operation behaves as
+        /// though
+        /// <paramref name="index"/>
+        /// was the index of the EOF symbol. After this method
+        /// returns without throwing an exception, the at least one of the following
+        /// will be true.
+        /// <ul>
+        /// <li>
+        /// <see cref="Index()">index()</see>
+        /// will return the index of the first symbol
+        /// appearing at or after the specified
+        /// <paramref name="index"/>
+        /// . Specifically,
+        /// implementations which filter their sources should automatically
+        /// adjust
+        /// <paramref name="index"/>
+        /// forward the minimum amount required for the
+        /// operation to target a non-ignored symbol.</li>
+        /// <li>
+        /// <c>LA(1)</c>
+        /// returns
+        /// <see cref="IntStreamConstants.Eof"/>
+        /// </li>
+        /// </ul>
+        /// This operation is guaranteed to not throw an exception if
+        /// <paramref name="index"/>
+        /// lies within a marked region. For more information on marked regions, see
+        /// <see cref="Mark()"/>
+        /// . The behavior of this method is unspecified if no call to
+        /// an
+        /// <see cref="IIntStream">initializing method</see>
+        /// has occurred after this stream
+        /// was constructed.
+        /// </summary>
+        /// <param name="index">The absolute index to seek to.</param>
+        /// <exception cref="System.ArgumentException">
+        /// if
+        /// <paramref name="index"/>
+        /// is less than 0
+        /// </exception>
+        /// <exception cref="System.NotSupportedException">
+        /// if the stream does not support
+        /// seeking to the specified index
+        /// </exception>
+        void Seek(int index);
+
+        /// <summary>
+        /// Returns the total number of symbols in the stream, including a single EOF
+        /// symbol.
+        /// </summary>
+        /// <remarks>
+        /// Returns the total number of symbols in the stream, including a single EOF
+        /// symbol.
+        /// </remarks>
+        /// <exception cref="System.NotSupportedException">
+        /// if the size of the stream is
+        /// unknown.
+        /// </exception>
+        int Size
+        {
+            get;
+        }
+
+        /// <summary>Gets the name of the underlying symbol source.</summary>
+        /// <remarks>
+        /// Gets the name of the underlying symbol source. This method returns a
+        /// non-null, non-empty string. If such a name is not known, this method
+        /// returns
+        /// <see cref="IntStreamConstants.UnknownSourceName"/>
+        /// .
+        /// </remarks>
+        string SourceName
+        {
+            get;
+        }
+    }
+
+    public static class IntStreamConstants
+    {
+        /// <summary>
+        /// The value returned by
+        /// <see cref="IIntStream.La(int)">LA()</see>
+        /// when the end of the stream is
+        /// reached.
+        /// </summary>
+        public const int Eof = -1;
+
+        /// <summary>
+        /// The value returned by
+        /// <see cref="IIntStream.SourceName"/>
+        /// when the actual name of the
+        /// underlying source is not known.
+        /// </summary>
+        public const string UnknownSourceName = "<unknown>";
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/IParserErrorListener.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/IParserErrorListener.cs
new file mode 100644
index 000000000..2a977b57f
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/IParserErrorListener.cs
@@ -0,0 +1,203 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Dfa;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime
+{
+    /// <summary>How to emit recognition errors for parsers.</summary>
+    /// <remarks>How to emit recognition errors for parsers.</remarks>
+    public interface IParserErrorListener : IAntlrErrorListener<IToken>
+    {
+        /// <summary>
+        /// This method is called by the parser when a full-context prediction
+        /// results in an ambiguity.
+        /// </summary>
+        /// <remarks>
+        /// This method is called by the parser when a full-context prediction
+        /// results in an ambiguity.
+        /// <p>Each full-context prediction which does not result in a syntax error
+        /// will call either
+        /// <see cref="ReportContextSensitivity(Parser, Antlr4.Runtime.Dfa.DFA, int, int, int, Antlr4.Runtime.Atn.SimulatorState)"/>
+        /// or
+        /// <see cref="ReportAmbiguity(Parser, Antlr4.Runtime.Dfa.DFA, int, int, bool, Antlr4.Runtime.Sharpen.BitSet, Antlr4.Runtime.Atn.ATNConfigSet)"/>
+        /// .</p>
+        /// <p>
+        /// When
+        /// <paramref name="ambigAlts"/>
+        /// is not null, it contains the set of potentially
+        /// viable alternatives identified by the prediction algorithm. When
+        /// <paramref name="ambigAlts"/>
+        /// is null, use
+        /// <see cref="Antlr4.Runtime.Atn.ATNConfigSet.RepresentedAlternatives()"/>
+        /// to obtain the represented
+        /// alternatives from the
+        /// <paramref name="configs"/>
+        /// argument.</p>
+        /// <p>When
+        /// <paramref name="exact"/>
+        /// is
+        /// <see langword="true"/>
+        /// , <em>all</em> of the potentially
+        /// viable alternatives are truly viable, i.e. this is reporting an exact
+        /// ambiguity. When
+        /// <paramref name="exact"/>
+        /// is
+        /// <see langword="false"/>
+        /// , <em>at least two</em> of
+        /// the potentially viable alternatives are viable for the current input, but
+        /// the prediction algorithm terminated as soon as it determined that at
+        /// least the <em>minimum</em> potentially viable alternative is truly
+        /// viable.</p>
+        /// <p>When the
+        /// <see cref="Antlr4.Runtime.Atn.PredictionMode.LlExactAmbigDetection"/>
+        /// prediction
+        /// mode is used, the parser is required to identify exact ambiguities so
+        /// <paramref name="exact"/>
+        /// will always be
+        /// <see langword="true"/>
+        /// .</p>
+        /// </remarks>
+        /// <param name="recognizer">the parser instance</param>
+        /// <param name="dfa">the DFA for the current decision</param>
+        /// <param name="startIndex">the input index where the decision started</param>
+        /// <param name="stopIndex">the input input where the ambiguity was identified</param>
+        /// <param name="exact">
+        /// 
+        /// <see langword="true"/>
+        /// if the ambiguity is exactly known, otherwise
+        /// <see langword="false"/>
+        /// . This is always
+        /// <see langword="true"/>
+        /// when
+        /// <see cref="Antlr4.Runtime.Atn.PredictionMode.LlExactAmbigDetection"/>
+        /// is used.
+        /// </param>
+        /// <param name="ambigAlts">
+        /// the potentially ambiguous alternatives, or
+        /// <see langword="null"/>
+        /// to indicate that the potentially ambiguous alternatives are the complete
+        /// set of represented alternatives in
+        /// <paramref name="configs"/>
+        /// </param>
+        /// <param name="configs">
+        /// the ATN configuration set where the ambiguity was
+        /// identified
+        /// </param>
+        void ReportAmbiguity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, bool exact, BitSet ambigAlts, ATNConfigSet configs);
+
+        /// <summary>
+        /// This method is called when an SLL conflict occurs and the parser is about
+        /// to use the full context information to make an LL decision.
+        /// </summary>
+        /// <remarks>
+        /// This method is called when an SLL conflict occurs and the parser is about
+        /// to use the full context information to make an LL decision.
+        /// <p>If one or more configurations in
+        /// <c>configs</c>
+        /// contains a semantic
+        /// predicate, the predicates are evaluated before this method is called. The
+        /// subset of alternatives which are still viable after predicates are
+        /// evaluated is reported in
+        /// <paramref name="conflictingAlts"/>
+        /// .</p>
+        /// </remarks>
+        /// <param name="recognizer">the parser instance</param>
+        /// <param name="dfa">the DFA for the current decision</param>
+        /// <param name="startIndex">the input index where the decision started</param>
+        /// <param name="stopIndex">the input index where the SLL conflict occurred</param>
+        /// <param name="conflictingAlts">
+        /// The specific conflicting alternatives. If this is
+        /// <see langword="null"/>
+        /// , the conflicting alternatives are all alternatives
+        /// represented in
+        /// <c>configs</c>
+        /// .
+        /// </param>
+        /// <param name="conflictState">
+        /// the simulator state when the SLL conflict was
+        /// detected
+        /// </param>
+        void ReportAttemptingFullContext(Parser recognizer, DFA dfa, int startIndex, int stopIndex, BitSet conflictingAlts, SimulatorState conflictState);
+
+        /// <summary>
+        /// This method is called by the parser when a full-context prediction has a
+        /// unique result.
+        /// </summary>
+        /// <remarks>
+        /// This method is called by the parser when a full-context prediction has a
+        /// unique result.
+        /// <p>Each full-context prediction which does not result in a syntax error
+        /// will call either
+        /// <see cref="ReportContextSensitivity(Parser, Antlr4.Runtime.Dfa.DFA, int, int, int, Antlr4.Runtime.Atn.SimulatorState)"/>
+        /// or
+        /// <see cref="ReportAmbiguity(Parser, Antlr4.Runtime.Dfa.DFA, int, int, bool, Antlr4.Runtime.Sharpen.BitSet, Antlr4.Runtime.Atn.ATNConfigSet)"/>
+        /// .</p>
+        /// <p>For prediction implementations that only evaluate full-context
+        /// predictions when an SLL conflict is found (including the default
+        /// <see cref="Antlr4.Runtime.Atn.ParserATNSimulator"/>
+        /// implementation), this method reports cases
+        /// where SLL conflicts were resolved to unique full-context predictions,
+        /// i.e. the decision was context-sensitive. This report does not necessarily
+        /// indicate a problem, and it may appear even in completely unambiguous
+        /// grammars.</p>
+        /// <p>
+        /// <c>configs</c>
+        /// may have more than one represented alternative if the
+        /// full-context prediction algorithm does not evaluate predicates before
+        /// beginning the full-context prediction. In all cases, the final prediction
+        /// is passed as the
+        /// <paramref name="prediction"/>
+        /// argument.</p>
+        /// <p>Note that the definition of "context sensitivity" in this method
+        /// differs from the concept in
+        /// <see cref="Antlr4.Runtime.Atn.DecisionInfo.contextSensitivities"/>
+        /// .
+        /// This method reports all instances where an SLL conflict occurred but LL
+        /// parsing produced a unique result, whether or not that unique result
+        /// matches the minimum alternative in the SLL conflicting set.</p>
+        /// </remarks>
+        /// <param name="recognizer">the parser instance</param>
+        /// <param name="dfa">the DFA for the current decision</param>
+        /// <param name="startIndex">the input index where the decision started</param>
+        /// <param name="stopIndex">
+        /// the input index where the context sensitivity was
+        /// finally determined
+        /// </param>
+        /// <param name="prediction">the unambiguous result of the full-context prediction</param>
+        /// <param name="acceptState">
+        /// the simulator state when the unambiguous prediction
+        /// was determined
+        /// </param>
+        void ReportContextSensitivity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, int prediction, SimulatorState acceptState);
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/IRecognizer.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/IRecognizer.cs
new file mode 100644
index 000000000..ca0c692cd
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/IRecognizer.cs
@@ -0,0 +1,67 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+namespace Antlr4.Runtime
+{
+    using System;
+    using Antlr4.Runtime.Atn;
+
+    public interface IRecognizer
+    {
+        IVocabulary Vocabulary
+        {
+            get;
+        }
+
+        string[] RuleNames
+        {
+            get;
+        }
+
+        string GrammarFileName
+        {
+            get;
+        }
+
+        ATN Atn
+        {
+            get;
+        }
+
+        int State
+        {
+            get;
+        }
+
+        IIntStream InputStream
+        {
+            get;
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/IToken.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/IToken.cs
new file mode 100644
index 000000000..8081ee1c9
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/IToken.cs
@@ -0,0 +1,206 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime
+{
+    /// <summary>
+    /// A token has properties: text, type, line, character position in the line
+    /// (so we can ignore tabs), token channel, index, and source from which
+    /// we obtained this token.
+    /// </summary>
+    /// <remarks>
+    /// A token has properties: text, type, line, character position in the line
+    /// (so we can ignore tabs), token channel, index, and source from which
+    /// we obtained this token.
+    /// </remarks>
+    public interface IToken
+    {
+        /// <summary>Get the text of the token.</summary>
+        /// <remarks>Get the text of the token.</remarks>
+        string Text
+        {
+            get;
+        }
+
+        /// <summary>Get the token type of the token.</summary>
+        /// <remarks>Get the token type of the token.</remarks>
+        int Type
+        {
+            get;
+        }
+
+        /// <summary>
+        /// The line number on which the 1st character of this token was matched,
+        /// line=1..n
+        /// </summary>
+        int Line
+        {
+            get;
+        }
+
+        /// <summary>
+        /// The index of the first character of this token relative to the
+        /// beginning of the line at which it occurs, 0..n-1
+        /// </summary>
+        int Column
+        {
+            get;
+        }
+
+        /// <summary>Return the channel this token.</summary>
+        /// <remarks>
+        /// Return the channel this token. Each token can arrive at the parser
+        /// on a different channel, but the parser only "tunes" to a single channel.
+        /// The parser ignores everything not on DEFAULT_CHANNEL.
+        /// </remarks>
+        int Channel
+        {
+            get;
+        }
+
+        /// <summary>An index from 0..n-1 of the token object in the input stream.</summary>
+        /// <remarks>
+        /// An index from 0..n-1 of the token object in the input stream.
+        /// This must be valid in order to print token streams and
+        /// use TokenRewriteStream.
+        /// Return -1 to indicate that this token was conjured up since
+        /// it doesn't have a valid index.
+        /// </remarks>
+        int TokenIndex
+        {
+            get;
+        }
+
+        /// <summary>
+        /// The starting character index of the token
+        /// This method is optional; return -1 if not implemented.
+        /// </summary>
+        /// <remarks>
+        /// The starting character index of the token
+        /// This method is optional; return -1 if not implemented.
+        /// </remarks>
+        int StartIndex
+        {
+            get;
+        }
+
+        /// <summary>The last character index of the token.</summary>
+        /// <remarks>
+        /// The last character index of the token.
+        /// This method is optional; return -1 if not implemented.
+        /// </remarks>
+        int StopIndex
+        {
+            get;
+        }
+
+        /// <summary>
+        /// Gets the
+        /// <see cref="ITokenSource"/>
+        /// which created this token.
+        /// </summary>
+        ITokenSource TokenSource
+        {
+            get;
+        }
+
+        /// <summary>
+        /// Gets the
+        /// <see cref="ICharStream"/>
+        /// from which this token was derived.
+        /// </summary>
+        ICharStream InputStream
+        {
+            get;
+        }
+    }
+
+    public static class TokenConstants
+    {
+        public const int InvalidType = 0;
+
+        /// <summary>
+        /// During lookahead operations, this "token" signifies we hit rule end ATN state
+        /// and did not follow it despite needing to.
+        /// </summary>
+        /// <remarks>
+        /// During lookahead operations, this "token" signifies we hit rule end ATN state
+        /// and did not follow it despite needing to.
+        /// </remarks>
+        public const int Epsilon = -2;
+
+        public const int MinUserTokenType = 1;
+
+        public const int Eof = IntStreamConstants.Eof;
+
+        /// <summary>
+        /// All tokens go to the parser (unless skip() is called in that rule)
+        /// on a particular "channel".
+        /// </summary>
+        /// <remarks>
+        /// All tokens go to the parser (unless skip() is called in that rule)
+        /// on a particular "channel".  The parser tunes to a particular channel
+        /// so that whitespace etc... can go to the parser on a "hidden" channel.
+        /// </remarks>
+        public const int DefaultChannel = 0;
+
+        /// <summary>
+        /// Anything on different channel than DEFAULT_CHANNEL is not parsed
+        /// by parser.
+        /// </summary>
+        /// <remarks>
+        /// Anything on different channel than DEFAULT_CHANNEL is not parsed
+        /// by parser.
+        /// </remarks>
+        public const int HiddenChannel = 1;
+
+        /// <summary>
+        /// This is the minimum constant value which can be assigned to a
+        /// user-defined token channel.
+        /// </summary>
+        /// <remarks>
+        /// This is the minimum constant value which can be assigned to a
+        /// user-defined token channel.
+        /// <p>
+        /// The non-negative numbers less than
+        /// <see cref="MinUserChannelValue"/>
+        /// are
+        /// assigned to the predefined channels
+        /// <see cref="DefaultChannel"/>
+        /// and
+        /// <see cref="HiddenChannel"/>
+        /// .</p>
+        /// </remarks>
+        /// <seealso cref="IToken.Channel"/>
+        public const int MinUserChannelValue = 2;
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/ITokenFactory.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/ITokenFactory.cs
new file mode 100644
index 000000000..4f6b61e8d
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/ITokenFactory.cs
@@ -0,0 +1,61 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System;
+using Antlr4.Runtime;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime
+{
+    /// <summary>The default mechanism for creating tokens.</summary>
+    /// <remarks>
+    /// The default mechanism for creating tokens. It's used by default in Lexer and
+    /// the error handling strategy (to create missing tokens).  Notifying the parser
+    /// of a new factory means that it notifies it's token source and error strategy.
+    /// </remarks>
+    public interface ITokenFactory
+    {
+        /// <summary>
+        /// This is the method used to create tokens in the lexer and in the
+        /// error handling strategy.
+        /// </summary>
+        /// <remarks>
+        /// This is the method used to create tokens in the lexer and in the
+        /// error handling strategy. If text!=null, than the start and stop positions
+        /// are wiped to -1 in the text override is set in the CommonToken.
+        /// </remarks>
+        [return: NotNull]
+        IToken Create(Tuple<ITokenSource, ICharStream> source, int type, string text, int channel, int start, int stop, int line, int charPositionInLine);
+
+        /// <summary>Generically useful</summary>
+        [return: NotNull]
+        IToken Create(int type, string text);
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/ITokenSource.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/ITokenSource.cs
new file mode 100644
index 000000000..42e8c4e83
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/ITokenSource.cs
@@ -0,0 +1,166 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime
+{
+    /// <summary>
+    /// A source of tokens must provide a sequence of tokens via
+    /// <see cref="NextToken()"/>
+    /// and also must reveal it's source of characters;
+    /// <see cref="CommonToken"/>
+    /// 's text is
+    /// computed from a
+    /// <see cref="ICharStream"/>
+    /// ; it only store indices into the char
+    /// stream.
+    /// <p>Errors from the lexer are never passed to the parser. Either you want to keep
+    /// going or you do not upon token recognition error. If you do not want to
+    /// continue lexing then you do not want to continue parsing. Just throw an
+    /// exception not under
+    /// <see cref="RecognitionException"/>
+    /// and Java will naturally toss
+    /// you all the way out of the recognizers. If you want to continue lexing then
+    /// you should not throw an exception to the parser--it has already requested a
+    /// token. Keep lexing until you get a valid one. Just report errors and keep
+    /// going, looking for a valid token.</p>
+    /// </summary>
+    public interface ITokenSource
+    {
+        /// <summary>
+        /// Return a
+        /// <see cref="IToken"/>
+        /// object from your input stream (usually a
+        /// <see cref="ICharStream"/>
+        /// ). Do not fail/return upon lexing error; keep chewing
+        /// on the characters until you get a good one; errors are not passed through
+        /// to the parser.
+        /// </summary>
+        [return: NotNull]
+        IToken NextToken();
+
+        /// <summary>Get the line number for the current position in the input stream.</summary>
+        /// <remarks>
+        /// Get the line number for the current position in the input stream. The
+        /// first line in the input is line 1.
+        /// </remarks>
+        /// <returns>
+        /// The line number for the current position in the input stream, or
+        /// 0 if the current token source does not track line numbers.
+        /// </returns>
+        int Line
+        {
+            get;
+        }
+
+        /// <summary>
+        /// Get the index into the current line for the current position in the input
+        /// stream.
+        /// </summary>
+        /// <remarks>
+        /// Get the index into the current line for the current position in the input
+        /// stream. The first character on a line has position 0.
+        /// </remarks>
+        /// <returns>
+        /// The line number for the current position in the input stream, or
+        /// -1 if the current token source does not track character positions.
+        /// </returns>
+        int Column
+        {
+            get;
+        }
+
+        /// <summary>
+        /// Get the
+        /// <see cref="ICharStream"/>
+        /// from which this token source is currently
+        /// providing tokens.
+        /// </summary>
+        /// <returns>
+        /// The
+        /// <see cref="ICharStream"/>
+        /// associated with the current position in
+        /// the input, or
+        /// <see langword="null"/>
+        /// if no input stream is available for the token
+        /// source.
+        /// </returns>
+        ICharStream InputStream
+        {
+            get;
+        }
+
+        /// <summary>Gets the name of the underlying input source.</summary>
+        /// <remarks>
+        /// Gets the name of the underlying input source. This method returns a
+        /// non-null, non-empty string. If such a name is not known, this method
+        /// returns
+        /// <see cref="IntStreamConstants.UnknownSourceName"/>
+        /// .
+        /// </remarks>
+        string SourceName
+        {
+            get;
+        }
+
+        /// <summary>
+        /// Set the
+        /// <see cref="ITokenFactory"/>
+        /// this token source should use for creating
+        /// <see cref="IToken"/>
+        /// objects from the input.
+        /// </summary>
+        /// <value>
+        /// The
+        /// <see cref="ITokenFactory"/>
+        /// to use for creating tokens.
+        /// </value>
+        /// <summary>
+        /// Gets the
+        /// <see cref="ITokenFactory"/>
+        /// this token source is currently using for
+        /// creating
+        /// <see cref="IToken"/>
+        /// objects from the input.
+        /// </summary>
+        /// <returns>
+        /// The
+        /// <see cref="ITokenFactory"/>
+        /// currently used by this token source.
+        /// </returns>
+        ITokenFactory TokenFactory
+        {
+            get;
+            set;
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/ITokenStream.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/ITokenStream.cs
new file mode 100644
index 000000000..c9ad0edb9
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/ITokenStream.cs
@@ -0,0 +1,240 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime
+{
+    /// <summary>
+    /// An
+    /// <see cref="IIntStream"/>
+    /// whose symbols are
+    /// <see cref="IToken"/>
+    /// instances.
+    /// </summary>
+    public interface ITokenStream : IIntStream
+    {
+        /// <summary>
+        /// Get the
+        /// <see cref="IToken"/>
+        /// instance associated with the value returned by
+        /// <see cref="IIntStream.La(int)">LA(k)</see>
+        /// . This method has the same pre- and post-conditions as
+        /// <see cref="IIntStream.La(int)"/>
+        /// . In addition, when the preconditions of this method
+        /// are met, the return value is non-null and the value of
+        /// <c>LT(k).getType()==LA(k)</c>
+        /// .
+        /// </summary>
+        /// <seealso cref="IIntStream.La(int)"/>
+        [return: NotNull]
+        IToken Lt(int k);
+
+        /// <summary>
+        /// Gets the
+        /// <see cref="IToken"/>
+        /// at the specified
+        /// <c>index</c>
+        /// in the stream. When
+        /// the preconditions of this method are met, the return value is non-null.
+        /// <p>The preconditions for this method are the same as the preconditions of
+        /// <see cref="IIntStream.Seek(int)"/>
+        /// . If the behavior of
+        /// <c>seek(index)</c>
+        /// is
+        /// unspecified for the current state and given
+        /// <c>index</c>
+        /// , then the
+        /// behavior of this method is also unspecified.</p>
+        /// <p>The symbol referred to by
+        /// <c>index</c>
+        /// differs from
+        /// <c>seek()</c>
+        /// only
+        /// in the case of filtering streams where
+        /// <c>index</c>
+        /// lies before the end
+        /// of the stream. Unlike
+        /// <c>seek()</c>
+        /// , this method does not adjust
+        /// <c>index</c>
+        /// to point to a non-ignored symbol.</p>
+        /// </summary>
+        /// <exception cref="System.ArgumentException">if {code index} is less than 0</exception>
+        /// <exception cref="System.NotSupportedException">
+        /// if the stream does not support
+        /// retrieving the token at the specified index
+        /// </exception>
+        [return: NotNull]
+        IToken Get(int i);
+
+        /// <summary>
+        /// Gets the underlying
+        /// <see cref="ITokenSource"/>
+        /// which provides tokens for this
+        /// stream.
+        /// </summary>
+        ITokenSource TokenSource
+        {
+            get;
+        }
+
+        /// <summary>
+        /// Return the text of all tokens within the specified
+        /// <paramref name="interval"/>
+        /// . This
+        /// method behaves like the following code (including potential exceptions
+        /// for violating preconditions of
+        /// <see cref="Get(int)"/>
+        /// , but may be optimized by the
+        /// specific implementation.
+        /// <pre>
+        /// TokenStream stream = ...;
+        /// String text = "";
+        /// for (int i = interval.a; i &lt;= interval.b; i++) {
+        /// text += stream.get(i).getText();
+        /// }
+        /// </pre>
+        /// </summary>
+        /// <param name="interval">
+        /// The interval of tokens within this stream to get text
+        /// for.
+        /// </param>
+        /// <returns>
+        /// The text of all tokens within the specified interval in this
+        /// stream.
+        /// </returns>
+        /// <exception cref="System.ArgumentNullException">
+        /// if
+        /// <paramref name="interval"/>
+        /// is
+        /// <see langword="null"/>
+        /// </exception>
+        [return: NotNull]
+        string GetText(Interval interval);
+
+        /// <summary>Return the text of all tokens in the stream.</summary>
+        /// <remarks>
+        /// Return the text of all tokens in the stream. This method behaves like the
+        /// following code, including potential exceptions from the calls to
+        /// <see cref="IIntStream.Size()"/>
+        /// and
+        /// <see cref="GetText(Antlr4.Runtime.Misc.Interval)"/>
+        /// , but may be
+        /// optimized by the specific implementation.
+        /// <pre>
+        /// TokenStream stream = ...;
+        /// String text = stream.getText(new Interval(0, stream.size()));
+        /// </pre>
+        /// </remarks>
+        /// <returns>The text of all tokens in the stream.</returns>
+        [return: NotNull]
+        string GetText();
+
+        /// <summary>
+        /// Return the text of all tokens in the source interval of the specified
+        /// context.
+        /// </summary>
+        /// <remarks>
+        /// Return the text of all tokens in the source interval of the specified
+        /// context. This method behaves like the following code, including potential
+        /// exceptions from the call to
+        /// <see cref="GetText(Antlr4.Runtime.Misc.Interval)"/>
+        /// , but may be
+        /// optimized by the specific implementation.
+        /// <p>If
+        /// <c>ctx.getSourceInterval()</c>
+        /// does not return a valid interval of
+        /// tokens provided by this stream, the behavior is unspecified.</p>
+        /// <pre>
+        /// TokenStream stream = ...;
+        /// String text = stream.getText(ctx.getSourceInterval());
+        /// </pre>
+        /// </remarks>
+        /// <param name="ctx">
+        /// The context providing the source interval of tokens to get
+        /// text for.
+        /// </param>
+        /// <returns>
+        /// The text of all tokens within the source interval of
+        /// <paramref name="ctx"/>
+        /// .
+        /// </returns>
+        [return: NotNull]
+        string GetText(RuleContext ctx);
+
+        /// <summary>
+        /// Return the text of all tokens in this stream between
+        /// <paramref name="start"/>
+        /// and
+        /// <paramref name="stop"/>
+        /// (inclusive).
+        /// <p>If the specified
+        /// <paramref name="start"/>
+        /// or
+        /// <paramref name="stop"/>
+        /// token was not provided by
+        /// this stream, or if the
+        /// <paramref name="stop"/>
+        /// occurred before the
+        /// <paramref name="start"/>
+        /// token, the behavior is unspecified.</p>
+        /// <p>For streams which ensure that the
+        /// <see cref="IToken.TokenIndex()"/>
+        /// method is
+        /// accurate for all of its provided tokens, this method behaves like the
+        /// following code. Other streams may implement this method in other ways
+        /// provided the behavior is consistent with this at a high level.</p>
+        /// <pre>
+        /// TokenStream stream = ...;
+        /// String text = "";
+        /// for (int i = start.getTokenIndex(); i &lt;= stop.getTokenIndex(); i++) {
+        /// text += stream.get(i).getText();
+        /// }
+        /// </pre>
+        /// </summary>
+        /// <param name="start">The first token in the interval to get text for.</param>
+        /// <param name="stop">The last token in the interval to get text for (inclusive).</param>
+        /// <returns>
+        /// The text of all tokens lying between the specified
+        /// <paramref name="start"/>
+        /// and
+        /// <paramref name="stop"/>
+        /// tokens.
+        /// </returns>
+        /// <exception cref="System.NotSupportedException">
+        /// if this stream does not support
+        /// this method for the specified tokens
+        /// </exception>
+        [return: NotNull]
+        string GetText(IToken start, IToken stop);
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/IVocabulary.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/IVocabulary.cs
new file mode 100644
index 000000000..f9988a4c9
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/IVocabulary.cs
@@ -0,0 +1,198 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime
+{
+    /// <summary>
+    /// This interface provides information about the vocabulary used by a
+    /// recognizer.
+    /// </summary>
+    /// <remarks>
+    /// This interface provides information about the vocabulary used by a
+    /// recognizer.
+    /// </remarks>
+    /// <seealso cref="Recognizer{Symbol, ATNInterpreter}.Vocabulary()"/>
+    /// <author>Sam Harwell</author>
+    public interface IVocabulary
+    {
+        /// <summary>Gets the string literal associated with a token type.</summary>
+        /// <remarks>
+        /// Gets the string literal associated with a token type. The string returned
+        /// by this method, when not
+        /// <see langword="null"/>
+        /// , can be used unaltered in a parser
+        /// grammar to represent this token type.
+        /// <p>The following table shows examples of lexer rules and the literal
+        /// names assigned to the corresponding token types.</p>
+        /// <table>
+        /// <tr>
+        /// <th>Rule</th>
+        /// <th>Literal Name</th>
+        /// <th>Java String Literal</th>
+        /// </tr>
+        /// <tr>
+        /// <td>
+        /// <c>THIS : 'this';</c>
+        /// </td>
+        /// <td>
+        /// <c>'this'</c>
+        /// </td>
+        /// <td>
+        /// <c>"'this'"</c>
+        /// </td>
+        /// </tr>
+        /// <tr>
+        /// <td>
+        /// <c>SQUOTE : '\'';</c>
+        /// </td>
+        /// <td>
+        /// <c>'\''</c>
+        /// </td>
+        /// <td>
+        /// <c>"'\\''"</c>
+        /// </td>
+        /// </tr>
+        /// <tr>
+        /// <td>
+        /// <c>ID : [A-Z]+;</c>
+        /// </td>
+        /// <td>n/a</td>
+        /// <td>
+        /// <see langword="null"/>
+        /// </td>
+        /// </tr>
+        /// </table>
+        /// </remarks>
+        /// <param name="tokenType">The token type.</param>
+        /// <returns>
+        /// The string literal associated with the specified token type, or
+        /// <see langword="null"/>
+        /// if no string literal is associated with the type.
+        /// </returns>
+        [return: Nullable]
+        string GetLiteralName(int tokenType);
+
+        /// <summary>Gets the symbolic name associated with a token type.</summary>
+        /// <remarks>
+        /// Gets the symbolic name associated with a token type. The string returned
+        /// by this method, when not
+        /// <see langword="null"/>
+        /// , can be used unaltered in a parser
+        /// grammar to represent this token type.
+        /// <p>This method supports token types defined by any of the following
+        /// methods:</p>
+        /// <ul>
+        /// <li>Tokens created by lexer rules.</li>
+        /// <li>Tokens defined in a
+        /// <c/>
+        /// tokens
+        /// block in a lexer or parser
+        /// grammar.</li>
+        /// <li>The implicitly defined
+        /// <c>EOF</c>
+        /// token, which has the token type
+        /// <see cref="TokenConstants.Eof"/>
+        /// .</li>
+        /// </ul>
+        /// <p>The following table shows examples of lexer rules and the literal
+        /// names assigned to the corresponding token types.</p>
+        /// <table>
+        /// <tr>
+        /// <th>Rule</th>
+        /// <th>Symbolic Name</th>
+        /// </tr>
+        /// <tr>
+        /// <td>
+        /// <c>THIS : 'this';</c>
+        /// </td>
+        /// <td>
+        /// <c>THIS</c>
+        /// </td>
+        /// </tr>
+        /// <tr>
+        /// <td>
+        /// <c>SQUOTE : '\'';</c>
+        /// </td>
+        /// <td>
+        /// <c>SQUOTE</c>
+        /// </td>
+        /// </tr>
+        /// <tr>
+        /// <td>
+        /// <c>ID : [A-Z]+;</c>
+        /// </td>
+        /// <td>
+        /// <c>ID</c>
+        /// </td>
+        /// </tr>
+        /// </table>
+        /// </remarks>
+        /// <param name="tokenType">The token type.</param>
+        /// <returns>
+        /// The symbolic name associated with the specified token type, or
+        /// <see langword="null"/>
+        /// if no symbolic name is associated with the type.
+        /// </returns>
+        [return: Nullable]
+        string GetSymbolicName(int tokenType);
+
+        /// <summary>Gets the display name of a token type.</summary>
+        /// <remarks>
+        /// Gets the display name of a token type.
+        /// <p>ANTLR provides a default implementation of this method, but
+        /// applications are free to override the behavior in any manner which makes
+        /// sense for the application. The default implementation returns the first
+        /// result from the following list which produces a non-
+        /// <see langword="null"/>
+        /// result.</p>
+        /// <ol>
+        /// <li>The result of
+        /// <see cref="GetLiteralName(int)"/>
+        /// </li>
+        /// <li>The result of
+        /// <see cref="GetSymbolicName(int)"/>
+        /// </li>
+        /// <li>The result of
+        /// <see cref="int.ToString()"/>
+        /// </li>
+        /// </ol>
+        /// </remarks>
+        /// <param name="tokenType">The token type.</param>
+        /// <returns>
+        /// The display name of the token type, for use in error reporting or
+        /// other user-visible messages which reference specific token types.
+        /// </returns>
+        [return: NotNull]
+        string GetDisplayName(int tokenType);
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/IWritableToken.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/IWritableToken.cs
new file mode 100644
index 000000000..6e6c481fa
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/IWritableToken.cs
@@ -0,0 +1,67 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime
+{
+    public interface IWritableToken : IToken
+    {
+        new string Text
+        {
+            set;
+        }
+
+        new int Type
+        {
+            set;
+        }
+
+        new int Line
+        {
+            set;
+        }
+
+        new int Column
+        {
+            set;
+        }
+
+        new int Channel
+        {
+            set;
+        }
+
+        new int TokenIndex
+        {
+            set;
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/InputMismatchException.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/InputMismatchException.cs
new file mode 100644
index 000000000..b03969d08
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/InputMismatchException.cs
@@ -0,0 +1,54 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime
+{
+    /// <summary>
+    /// This signifies any kind of mismatched input exceptions such as
+    /// when the current input does not match the expected token.
+    /// </summary>
+    /// <remarks>
+    /// This signifies any kind of mismatched input exceptions such as
+    /// when the current input does not match the expected token.
+    /// </remarks>
+    [System.Serializable]
+    public class InputMismatchException : RecognitionException
+    {
+        private const long serialVersionUID = 1532568338707443067L;
+
+        public InputMismatchException(Parser recognizer)
+			: base(recognizer, ((ITokenStream)recognizer.InputStream), recognizer.RuleContext)
+        {
+            this.OffendingToken = recognizer.CurrentToken;
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/InterpreterRuleContext.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/InterpreterRuleContext.cs
new file mode 100644
index 000000000..685171bc7
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/InterpreterRuleContext.cs
@@ -0,0 +1,83 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime
+{
+    /// <summary>
+    /// This class extends
+    /// <see cref="ParserRuleContext"/>
+    /// by allowing the value of
+    /// <see cref="RuleIndex()"/>
+    /// to be explicitly set for the context.
+    /// <p>
+    /// <see cref="ParserRuleContext"/>
+    /// does not include field storage for the rule index
+    /// since the context classes created by the code generator override the
+    /// <see cref="RuleIndex()"/>
+    /// method to return the correct value for that context.
+    /// Since the parser interpreter does not use the context classes generated for a
+    /// parser, this class (with slightly more memory overhead per node) is used to
+    /// provide equivalent functionality.</p>
+    /// </summary>
+    public class InterpreterRuleContext : ParserRuleContext
+    {
+        /// <summary>
+        /// This is the backing field for
+        /// <see cref="RuleIndex()"/>
+        /// .
+        /// </summary>
+        private readonly int ruleIndex;
+
+        /// <summary>
+        /// Constructs a new
+        /// <see cref="InterpreterRuleContext"/>
+        /// with the specified
+        /// parent, invoking state, and rule index.
+        /// </summary>
+        /// <param name="parent">The parent context.</param>
+        /// <param name="invokingStateNumber">The invoking state number.</param>
+        /// <param name="ruleIndex">The rule index for the current context.</param>
+        public InterpreterRuleContext(ParserRuleContext parent, int invokingStateNumber, int ruleIndex)
+            : base(parent, invokingStateNumber)
+        {
+            this.ruleIndex = ruleIndex;
+        }
+
+        public override int RuleIndex
+        {
+            get
+            {
+                return ruleIndex;
+            }
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Lexer.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Lexer.cs
new file mode 100644
index 000000000..8725b2b6e
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Lexer.cs
@@ -0,0 +1,640 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Antlr4.Runtime;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime
+{
+    /// <summary>A lexer is recognizer that draws input symbols from a character stream.</summary>
+    /// <remarks>
+    /// A lexer is recognizer that draws input symbols from a character stream.
+    /// lexer grammars result in a subclass of this object. A Lexer object
+    /// uses simplified match() and error recovery mechanisms in the interest
+    /// of speed.
+    /// </remarks>
+    public abstract class Lexer : Recognizer<int, LexerATNSimulator>, ITokenSource
+    {
+        public const int DefaultMode = 0;
+
+        public const int DefaultTokenChannel = TokenConstants.DefaultChannel;
+
+        public const int Hidden = TokenConstants.HiddenChannel;
+
+        public const int MinCharValue = '\u0000';
+
+        public const int MaxCharValue = '\uFFFE';
+
+        private ICharStream _input;
+
+		private Tuple<ITokenSource, ICharStream> _tokenFactorySourcePair;
+
+        /// <summary>How to create token objects</summary>
+		private ITokenFactory _factory = CommonTokenFactory.Default;
+
+        /// <summary>The goal of all lexer rules/methods is to create a token object.</summary>
+        /// <remarks>
+        /// The goal of all lexer rules/methods is to create a token object.
+        /// This is an instance variable as multiple rules may collaborate to
+        /// create a single token.  nextToken will return this object after
+        /// matching lexer rule(s).  If you subclass to allow multiple token
+        /// emissions, then set this to the last token to be matched or
+        /// something nonnull so that the auto token emit mechanism will not
+        /// emit another token.
+        /// </remarks>
+        private IToken _token;
+
+        /// <summary>
+        /// What character index in the stream did the current token start at?
+        /// Needed, for example, to get the text for current token.
+        /// </summary>
+        /// <remarks>
+        /// What character index in the stream did the current token start at?
+        /// Needed, for example, to get the text for current token.  Set at
+        /// the start of nextToken.
+        /// </remarks>
+        private int _tokenStartCharIndex = -1;
+
+        /// <summary>The line on which the first character of the token resides</summary>
+		private int _tokenStartLine;
+
+        /// <summary>The character position of first character within the line</summary>
+		private int _tokenStartColumn;
+
+        /// <summary>Once we see EOF on char stream, next token will be EOF.</summary>
+        /// <remarks>
+        /// Once we see EOF on char stream, next token will be EOF.
+        /// If you have DONE : EOF ; then you see DONE EOF.
+        /// </remarks>
+		private bool _hitEOF;
+
+        /// <summary>The channel number for the current token</summary>
+		private int _channel;
+
+        /// <summary>The token type for the current token</summary>
+		private int _type;
+
+        private readonly Stack<int> _modeStack = new Stack<int>();
+
+		private int _mode = Antlr4.Runtime.Lexer.DefaultMode;
+
+        /// <summary>
+        /// You can set the text for the current token to override what is in
+        /// the input char buffer.
+        /// </summary>
+        /// <remarks>
+        /// You can set the text for the current token to override what is in
+        /// the input char buffer.  Use setText() or can set this instance var.
+        /// </remarks>
+		private string _text;
+
+        public Lexer(ICharStream input)
+        {
+            this._input = input;
+            this._tokenFactorySourcePair = Tuple.Create((ITokenSource)this, input);
+        }
+
+        public virtual void Reset()
+        {
+            // wack Lexer state variables
+            if (_input != null)
+            {
+                _input.Seek(0);
+            }
+            // rewind the input
+            _token = null;
+            _type = TokenConstants.InvalidType;
+            _channel = TokenConstants.DefaultChannel;
+            _tokenStartCharIndex = -1;
+            _tokenStartColumn = -1;
+            _tokenStartLine = -1;
+            _text = null;
+            _hitEOF = false;
+            _mode = Antlr4.Runtime.Lexer.DefaultMode;
+            _modeStack.Clear();
+            Interpreter.Reset();
+        }
+
+        /// <summary>
+        /// Return a token from this source; i.e., match a token on the char
+        /// stream.
+        /// </summary>
+        /// <remarks>
+        /// Return a token from this source; i.e., match a token on the char
+        /// stream.
+        /// </remarks>
+        public virtual IToken NextToken()
+        {
+            if (_input == null)
+            {
+                throw new InvalidOperationException("nextToken requires a non-null input stream.");
+            }
+            // Mark start location in char stream so unbuffered streams are
+            // guaranteed at least have text of current token
+            int tokenStartMarker = _input.Mark();
+            try
+            {
+                while (true)
+                {
+                    if (_hitEOF)
+                    {
+                        EmitEOF();
+                        return _token;
+                    }
+                    _token = null;
+                    _channel = TokenConstants.DefaultChannel;
+                    _tokenStartCharIndex = _input.Index;
+                    _tokenStartColumn = Interpreter.Column;
+                    _tokenStartLine = Interpreter.Line;
+                    _text = null;
+                    do
+                    {
+                        _type = TokenConstants.InvalidType;
+                        //				System.out.println("nextToken line "+tokenStartLine+" at "+((char)input.LA(1))+
+                        //								   " in mode "+mode+
+                        //								   " at index "+input.index());
+                        int ttype;
+                        try
+                        {
+                            ttype = Interpreter.Match(_input, _mode);
+                        }
+                        catch (LexerNoViableAltException e)
+                        {
+                            NotifyListeners(e);
+                            // report error
+                            Recover(e);
+                            ttype = TokenTypes.Skip;
+                        }
+                        if (_input.La(1) == IntStreamConstants.Eof)
+                        {
+                            _hitEOF = true;
+                        }
+                        if (_type == TokenConstants.InvalidType)
+                        {
+                            _type = ttype;
+                        }
+                        if (_type == TokenTypes.Skip)
+                        {
+                            goto outer_continue;
+                        }
+                    }
+                    while (_type == TokenTypes.More);
+                    if (_token == null)
+                    {
+                        Emit();
+                    }
+                    return _token;
+outer_continue: ;
+                }
+            }
+            finally
+            {
+                // make sure we release marker after match or
+                // unbuffered char stream will keep buffering
+                _input.Release(tokenStartMarker);
+            }
+        }
+
+        /// <summary>
+        /// Instruct the lexer to skip creating a token for current lexer rule
+        /// and look for another token.
+        /// </summary>
+        /// <remarks>
+        /// Instruct the lexer to skip creating a token for current lexer rule
+        /// and look for another token.  nextToken() knows to keep looking when
+        /// a lexer rule finishes with token set to SKIP_TOKEN.  Recall that
+        /// if token==null at end of any token rule, it creates one for you
+        /// and emits it.
+        /// </remarks>
+        public virtual void Skip()
+        {
+            _type = TokenTypes.Skip;
+        }
+
+        public virtual void More()
+        {
+            _type = TokenTypes.More;
+        }
+
+        public virtual void Mode(int m)
+        {
+            _mode = m;
+        }
+
+        public virtual void PushMode(int m)
+        {
+            _modeStack.Push(_mode);
+            Mode(m);
+        }
+
+        public virtual int PopMode()
+        {
+            if (_modeStack.Count == 0)
+            {
+                throw new InvalidOperationException();
+            }
+
+            int mode = _modeStack.Pop();
+            Mode(mode);
+            return _mode;
+        }
+
+        public virtual ITokenFactory TokenFactory
+        {
+            get
+            {
+                return _factory;
+            }
+            set
+            {
+                ITokenFactory factory = value;
+                this._factory = factory;
+            }
+        }
+
+        /// <summary>Set the char stream and reset the lexer</summary>
+        public virtual void SetInputStream(ICharStream input)
+        {
+            this._input = null;
+            this._tokenFactorySourcePair = Tuple.Create((ITokenSource)this, _input);
+            Reset();
+            this._input = input;
+            this._tokenFactorySourcePair = Tuple.Create((ITokenSource)this, _input);
+        }
+
+        public virtual string SourceName
+        {
+            get
+            {
+                return _input.SourceName;
+            }
+        }
+
+        public override IIntStream InputStream
+        {
+            get
+            {
+                return _input;
+            }
+        }
+
+        ICharStream ITokenSource.InputStream
+        {
+            get
+            {
+				return _input;
+            }
+        }
+
+        /// <summary>
+        /// By default does not support multiple emits per nextToken invocation
+        /// for efficiency reasons.
+        /// </summary>
+        /// <remarks>
+        /// By default does not support multiple emits per nextToken invocation
+        /// for efficiency reasons.  Subclass and override this method, nextToken,
+        /// and getToken (to push tokens into a list and pull from that list
+        /// rather than a single variable as this implementation does).
+        /// </remarks>
+        public virtual void Emit(IToken token)
+        {
+            //System.err.println("emit "+token);
+            this._token = token;
+        }
+
+        /// <summary>
+        /// The standard method called to automatically emit a token at the
+        /// outermost lexical rule.
+        /// </summary>
+        /// <remarks>
+        /// The standard method called to automatically emit a token at the
+        /// outermost lexical rule.  The token object should point into the
+        /// char buffer start..stop.  If there is a text override in 'text',
+        /// use that to set the token's text.  Override this method to emit
+        /// custom Token objects or provide a new factory.
+        /// </remarks>
+        public virtual IToken Emit()
+        {
+            IToken t = _factory.Create(_tokenFactorySourcePair, _type, _text, _channel, _tokenStartCharIndex, CharIndex - 1, _tokenStartLine, _tokenStartColumn);
+            Emit(t);
+            return t;
+        }
+
+        public virtual IToken EmitEOF()
+        {
+            int cpos = Column;
+			int line = Line;
+            IToken eof = _factory.Create(_tokenFactorySourcePair, TokenConstants.Eof, null, TokenConstants.DefaultChannel, _input.Index, _input.Index - 1, line, cpos);
+            Emit(eof);
+            return eof;
+        }
+
+        public virtual int Line
+        {
+            get
+            {
+                return Interpreter.Line;
+            }
+            set
+            {
+                int line = value;
+                Interpreter.Line = line;
+            }
+        }
+
+        public virtual int Column
+        {
+            get
+            {
+                return Interpreter.Column;
+            }
+            set
+            {
+                int charPositionInLine = value;
+                Interpreter.Column = charPositionInLine;
+            }
+        }
+
+        /// <summary>What is the index of the current character of lookahead?</summary>
+        public virtual int CharIndex
+        {
+            get
+            {
+                return _input.Index;
+            }
+        }
+
+		public virtual int TokenStartCharIndex
+		{
+			get 
+			{
+				return _tokenStartCharIndex;
+			}
+		}
+
+		public virtual int TokenStartLine
+		{
+			get 
+			{
+				return _tokenStartLine;
+			}
+		}
+
+		public virtual int TokenStartColumn
+		{
+			get 
+			{
+				return _tokenStartColumn;
+			}
+		}
+
+        /// <summary>
+        /// Return the text matched so far for the current token or any text
+        /// override.
+        /// </summary>
+        /// <remarks>
+        /// Return the text matched so far for the current token or any text
+        /// override.
+        /// </remarks>
+        /// <summary>
+        /// Set the complete text of this token; it wipes any previous changes to the
+        /// text.
+        /// </summary>
+        /// <remarks>
+        /// Set the complete text of this token; it wipes any previous changes to the
+        /// text.
+        /// </remarks>
+        public virtual string Text
+        {
+            get
+            {
+                if (_text != null)
+                {
+                    return _text;
+                }
+                return Interpreter.GetText(_input);
+            }
+            set
+            {
+                string text = value;
+                this._text = text;
+            }
+        }
+
+        /// <summary>Override if emitting multiple tokens.</summary>
+        /// <remarks>Override if emitting multiple tokens.</remarks>
+        public virtual IToken Token
+        {
+            get
+            {
+                return _token;
+            }
+            set
+            {
+                IToken _token = value;
+                this._token = _token;
+            }
+        }
+
+        public virtual int Type
+        {
+            get
+            {
+                return _type;
+            }
+            set
+            {
+                int ttype = value;
+                _type = ttype;
+            }
+        }
+
+        public virtual int Channel
+        {
+            get
+            {
+                return _channel;
+            }
+            set
+            {
+                int channel = value;
+                _channel = channel;
+            }
+        }
+
+        public virtual Stack<int> ModeStack
+        {
+            get
+            {
+                return _modeStack;
+            }
+        }
+
+        public virtual int CurrentMode
+        {
+            get
+            {
+                return _mode;
+            }
+            set
+            {
+                int mode = value;
+                _mode = mode;
+            }
+        }
+
+        public virtual bool HitEOF
+        {
+            get
+            {
+                return _hitEOF;
+            }
+            set
+            {
+                bool hitEOF = value;
+                _hitEOF = hitEOF;
+            }
+        }
+
+        public virtual string[] ModeNames
+        {
+            get
+            {
+                return null;
+            }
+        }
+
+
+        /// <summary>Return a list of all Token objects in input char stream.</summary>
+        /// <remarks>
+        /// Return a list of all Token objects in input char stream.
+        /// Forces load of all tokens. Does not include EOF token.
+        /// </remarks>
+        public virtual IList<IToken> GetAllTokens()
+        {
+            IList<IToken> tokens = new List<IToken>();
+            IToken t = NextToken();
+            while (t.Type != TokenConstants.Eof)
+            {
+                tokens.Add(t);
+                t = NextToken();
+            }
+            return tokens;
+        }
+
+        public virtual void Recover(LexerNoViableAltException e)
+        {
+            if (_input.La(1) != IntStreamConstants.Eof)
+            {
+                // skip a char and try again
+                Interpreter.Consume(_input);
+            }
+        }
+
+        public virtual void NotifyListeners(LexerNoViableAltException e)
+        {
+            string text = _input.GetText(Interval.Of(_tokenStartCharIndex, _input.Index));
+            string msg = "token recognition error at: '" + GetErrorDisplay(text) + "'";
+            IAntlrErrorListener<int> listener = ErrorListenerDispatch;
+            listener.SyntaxError(this, 0, _tokenStartLine, _tokenStartColumn, msg, e);
+        }
+
+        public virtual string GetErrorDisplay(string s)
+        {
+            StringBuilder buf = new StringBuilder();
+            foreach (char c in s.ToCharArray())
+            {
+                buf.Append(GetErrorDisplay(c));
+            }
+            return buf.ToString();
+        }
+
+        public virtual string GetErrorDisplay(int c)
+        {
+            string s = ((char)c).ToString();
+            switch (c)
+            {
+                case TokenConstants.Eof:
+                {
+                    s = "<EOF>";
+                    break;
+                }
+
+                case '\n':
+                {
+                    s = "\\n";
+                    break;
+                }
+
+                case '\t':
+                {
+                    s = "\\t";
+                    break;
+                }
+
+                case '\r':
+                {
+                    s = "\\r";
+                    break;
+                }
+            }
+            return s;
+        }
+
+        public virtual string GetCharErrorDisplay(int c)
+        {
+            string s = GetErrorDisplay(c);
+            return "'" + s + "'";
+        }
+
+        /// <summary>
+        /// Lexers can normally match any char in it's vocabulary after matching
+        /// a token, so do the easy thing and just kill a character and hope
+        /// it all works out.
+        /// </summary>
+        /// <remarks>
+        /// Lexers can normally match any char in it's vocabulary after matching
+        /// a token, so do the easy thing and just kill a character and hope
+        /// it all works out.  You can instead use the rule invocation stack
+        /// to do sophisticated error recovery if you are in a fragment rule.
+        /// </remarks>
+        public virtual void Recover(RecognitionException re)
+        {
+            //System.out.println("consuming char "+(char)input.LA(1)+" during recovery");
+            //re.printStackTrace();
+            // TODO: Do we lose character or line position information?
+            _input.Consume();
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/LexerInterpreter.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/LexerInterpreter.cs
new file mode 100644
index 000000000..4677d7504
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/LexerInterpreter.cs
@@ -0,0 +1,108 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Antlr4.Runtime;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime
+{
+    public class LexerInterpreter : Lexer
+    {
+		private readonly string grammarFileName;
+
+		private readonly ATN atn;
+
+		private readonly string[] ruleNames;
+
+		private readonly string[] modeNames;
+
+        [NotNull]
+        private readonly IVocabulary vocabulary;
+
+        public LexerInterpreter(string grammarFileName, IVocabulary vocabulary, IEnumerable<string> ruleNames, IEnumerable<string> modeNames, ATN atn, ICharStream input)
+            : base(input)
+        {
+            if (atn.grammarType != ATNType.Lexer)
+            {
+                throw new ArgumentException("The ATN must be a lexer ATN.");
+            }
+            this.grammarFileName = grammarFileName;
+            this.atn = atn;
+            this.ruleNames = ruleNames.ToArray();
+            this.modeNames = modeNames.ToArray();
+            this.vocabulary = vocabulary;
+            this.Interpreter = new LexerATNSimulator(this, atn);
+        }
+
+        public override ATN Atn
+        {
+            get
+            {
+                return atn;
+            }
+        }
+
+        public override string GrammarFileName
+        {
+            get
+            {
+                return grammarFileName;
+            }
+        }
+
+        public override string[] RuleNames
+        {
+            get
+            {
+                return ruleNames;
+            }
+        }
+
+        public override string[] ModeNames
+        {
+            get
+            {
+                return modeNames;
+            }
+        }
+
+        public override IVocabulary Vocabulary
+        {
+            get
+            {
+                return vocabulary;
+            }
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/LexerNoViableAltException.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/LexerNoViableAltException.cs
new file mode 100644
index 000000000..64592647a
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/LexerNoViableAltException.cs
@@ -0,0 +1,93 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System.Globalization;
+using Antlr4.Runtime;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime
+{
+    [System.Serializable]
+    public class LexerNoViableAltException : RecognitionException
+    {
+        private const long serialVersionUID = -730999203913001726L;
+
+        /// <summary>Matching attempted at what input index?</summary>
+        private readonly int startIndex;
+
+        /// <summary>Which configurations did we try at input.index() that couldn't match input.LA(1)?</summary>
+        [Nullable]
+        private readonly ATNConfigSet deadEndConfigs;
+
+        public LexerNoViableAltException(Lexer lexer, ICharStream input, int startIndex, ATNConfigSet deadEndConfigs)
+            : base(lexer, input)
+        {
+            this.startIndex = startIndex;
+            this.deadEndConfigs = deadEndConfigs;
+        }
+
+        public virtual int StartIndex
+        {
+            get
+            {
+                return startIndex;
+            }
+        }
+
+        [Nullable]
+        public virtual ATNConfigSet DeadEndConfigs
+        {
+            get
+            {
+                return deadEndConfigs;
+            }
+        }
+
+        public override IIntStream InputStream
+        {
+            get
+            {
+                return (ICharStream)base.InputStream;
+            }
+        }
+
+        public override string ToString()
+        {
+            string symbol = string.Empty;
+            if (startIndex >= 0 && startIndex < ((ICharStream)InputStream).Size)
+            {
+                symbol = ((ICharStream)InputStream).GetText(Interval.Of(startIndex, startIndex));
+                symbol = Utils.EscapeWhitespace(symbol, false);
+            }
+            return string.Format(CultureInfo.CurrentCulture, "{0}('{1}')", typeof(Antlr4.Runtime.LexerNoViableAltException).Name, symbol);
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/ListTokenSource.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/ListTokenSource.cs
new file mode 100644
index 000000000..4c3b507db
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/ListTokenSource.cs
@@ -0,0 +1,345 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System;
+using System.Collections.Generic;
+using Antlr4.Runtime;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime
+{
+    /// <summary>
+    /// Provides an implementation of
+    /// <see cref="ITokenSource"/>
+    /// as a wrapper around a list
+    /// of
+    /// <see cref="IToken"/>
+    /// objects.
+    /// <p>If the final token in the list is an
+    /// <see cref="TokenConstants.Eof"/>
+    /// token, it will be used
+    /// as the EOF token for every call to
+    /// <see cref="NextToken()"/>
+    /// after the end of the
+    /// list is reached. Otherwise, an EOF token will be created.</p>
+    /// </summary>
+    public class ListTokenSource : ITokenSource
+    {
+        /// <summary>
+        /// The wrapped collection of
+        /// <see cref="IToken"/>
+        /// objects to return.
+        /// </summary>
+        protected internal readonly IList<IToken> tokens;
+
+        /// <summary>The name of the input source.</summary>
+        /// <remarks>
+        /// The name of the input source. If this value is
+        /// <see langword="null"/>
+        /// , a call to
+        /// <see cref="SourceName()"/>
+        /// should return the source name used to create the
+        /// the next token in
+        /// <see cref="tokens"/>
+        /// (or the previous token if the end of
+        /// the input has been reached).
+        /// </remarks>
+        private readonly string sourceName;
+
+        /// <summary>
+        /// The index into
+        /// <see cref="tokens"/>
+        /// of token to return by the next call to
+        /// <see cref="NextToken()"/>
+        /// . The end of the input is indicated by this value
+        /// being greater than or equal to the number of items in
+        /// <see cref="tokens"/>
+        /// .
+        /// </summary>
+        protected internal int i;
+
+        /// <summary>This field caches the EOF token for the token source.</summary>
+        /// <remarks>This field caches the EOF token for the token source.</remarks>
+        protected internal IToken eofToken;
+
+        /// <summary>
+        /// This is the backing field for the <see cref="TokenFactory"/> property.
+        /// </summary>
+        private ITokenFactory _factory = CommonTokenFactory.Default;
+
+        /// <summary>
+        /// Constructs a new
+        /// <see cref="ListTokenSource"/>
+        /// instance from the specified
+        /// collection of
+        /// <see cref="IToken"/>
+        /// objects.
+        /// </summary>
+        /// <param name="tokens">
+        /// The collection of
+        /// <see cref="IToken"/>
+        /// objects to provide as a
+        /// <see cref="ITokenSource"/>
+        /// .
+        /// </param>
+        /// <exception>
+        /// NullPointerException
+        /// if
+        /// <paramref name="tokens"/>
+        /// is
+        /// <see langword="null"/>
+        /// </exception>
+        public ListTokenSource(IList<IToken> tokens)
+            : this(tokens, null)
+        {
+        }
+
+        /// <summary>
+        /// Constructs a new
+        /// <see cref="ListTokenSource"/>
+        /// instance from the specified
+        /// collection of
+        /// <see cref="IToken"/>
+        /// objects and source name.
+        /// </summary>
+        /// <param name="tokens">
+        /// The collection of
+        /// <see cref="IToken"/>
+        /// objects to provide as a
+        /// <see cref="ITokenSource"/>
+        /// .
+        /// </param>
+        /// <param name="sourceName">
+        /// The name of the
+        /// <see cref="ITokenSource"/>
+        /// . If this value is
+        /// <see langword="null"/>
+        /// ,
+        /// <see cref="SourceName()"/>
+        /// will attempt to infer the name from
+        /// the next
+        /// <see cref="IToken"/>
+        /// (or the previous token if the end of the input has
+        /// been reached).
+        /// </param>
+        /// <exception>
+        /// NullPointerException
+        /// if
+        /// <paramref name="tokens"/>
+        /// is
+        /// <see langword="null"/>
+        /// </exception>
+        public ListTokenSource(IList<IToken> tokens, string sourceName)
+        {
+            if (tokens == null)
+            {
+                throw new ArgumentNullException("tokens cannot be null");
+            }
+            this.tokens = tokens;
+            this.sourceName = sourceName;
+        }
+
+        /// <summary><inheritDoc/></summary>
+        public virtual int Column
+        {
+            get
+            {
+                if (i < tokens.Count)
+                {
+                    return tokens[i].Column;
+                }
+                else
+                {
+                    if (eofToken != null)
+                    {
+                        return eofToken.Column;
+                    }
+                    else
+                    {
+                        if (tokens.Count > 0)
+                        {
+                            // have to calculate the result from the line/column of the previous
+                            // token, along with the text of the token.
+                            IToken lastToken = tokens[tokens.Count - 1];
+                            string tokenText = lastToken.Text;
+                            if (tokenText != null)
+                            {
+                                int lastNewLine = tokenText.LastIndexOf('\n');
+                                if (lastNewLine >= 0)
+                                {
+                                    return tokenText.Length - lastNewLine - 1;
+                                }
+                            }
+                            return lastToken.Column + lastToken.StopIndex - lastToken.StartIndex + 1;
+                        }
+                    }
+                }
+                // only reach this if tokens is empty, meaning EOF occurs at the first
+                // position in the input
+                return 0;
+            }
+        }
+
+        /// <summary><inheritDoc/></summary>
+        public virtual IToken NextToken()
+        {
+            if (i >= tokens.Count)
+            {
+                if (eofToken == null)
+                {
+                    int start = -1;
+                    if (tokens.Count > 0)
+                    {
+                        int previousStop = tokens[tokens.Count - 1].StopIndex;
+                        if (previousStop != -1)
+                        {
+                            start = previousStop + 1;
+                        }
+                    }
+                    int stop = Math.Max(-1, start - 1);
+                    eofToken = _factory.Create(Tuple.Create((ITokenSource)this, InputStream), TokenConstants.Eof, "EOF", TokenConstants.DefaultChannel, start, stop, Line, Column);
+                }
+                return eofToken;
+            }
+            IToken t = tokens[i];
+            if (i == tokens.Count - 1 && t.Type == TokenConstants.Eof)
+            {
+                eofToken = t;
+            }
+            i++;
+            return t;
+        }
+
+        /// <summary><inheritDoc/></summary>
+        public virtual int Line
+        {
+            get
+            {
+                if (i < tokens.Count)
+                {
+                    return tokens[i].Line;
+                }
+                else
+                {
+                    if (eofToken != null)
+                    {
+                        return eofToken.Line;
+                    }
+                    else
+                    {
+                        if (tokens.Count > 0)
+                        {
+                            // have to calculate the result from the line/column of the previous
+                            // token, along with the text of the token.
+                            IToken lastToken = tokens[tokens.Count - 1];
+                            int line = lastToken.Line;
+                            string tokenText = lastToken.Text;
+                            if (tokenText != null)
+                            {
+                                for (int j = 0; j < tokenText.Length; j++)
+                                {
+                                    if (tokenText[j] == '\n')
+                                    {
+                                        line++;
+                                    }
+                                }
+                            }
+                            // if no text is available, assume the token did not contain any newline characters.
+                            return line;
+                        }
+                    }
+                }
+                // only reach this if tokens is empty, meaning EOF occurs at the first
+                // position in the input
+                return 1;
+            }
+        }
+
+        /// <summary><inheritDoc/></summary>
+        public virtual ICharStream InputStream
+        {
+            get
+            {
+                if (i < tokens.Count)
+                {
+                    return tokens[i].InputStream;
+                }
+                else
+                {
+                    if (eofToken != null)
+                    {
+                        return eofToken.InputStream;
+                    }
+                    else
+                    {
+                        if (tokens.Count > 0)
+                        {
+                            return tokens[tokens.Count - 1].InputStream;
+                        }
+                    }
+                }
+                // no input stream information is available
+                return null;
+            }
+        }
+
+        /// <summary><inheritDoc/></summary>
+        public virtual string SourceName
+        {
+            get
+            {
+                if (sourceName != null)
+                {
+                    return sourceName;
+                }
+                ICharStream inputStream = InputStream;
+                if (inputStream != null)
+                {
+                    return inputStream.SourceName;
+                }
+                return "List";
+            }
+        }
+
+        /// <summary><inheritDoc/></summary>
+        /// <summary><inheritDoc/></summary>
+        public virtual ITokenFactory TokenFactory
+        {
+            get
+            {
+                return _factory;
+            }
+            set
+            {
+                ITokenFactory factory = value;
+                this._factory = factory;
+            }
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Misc/Args.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Misc/Args.cs
new file mode 100644
index 000000000..98186cad5
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Misc/Args.cs
@@ -0,0 +1,53 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Misc
+{
+    /// <author>Sam Harwell</author>
+    public static class Args
+    {
+        /// <exception cref="System.ArgumentNullException">
+        /// if
+        /// <paramref name="value"/>
+        /// is
+        /// <see langword="null"/>
+        /// .
+        /// </exception>
+        public static void NotNull(string parameterName, object value)
+        {
+            if (value == null)
+            {
+                throw new ArgumentNullException(parameterName);
+            }
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Misc/IIntSet.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Misc/IIntSet.cs
new file mode 100644
index 000000000..962811861
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Misc/IIntSet.cs
@@ -0,0 +1,313 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System.Collections.Generic;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Misc
+{
+    /// <summary>A generic set of integers.</summary>
+    /// <remarks>A generic set of integers.</remarks>
+    /// <seealso cref="IntervalSet"/>
+    public interface IIntSet
+    {
+        /// <summary>Adds the specified value to the current set.</summary>
+        /// <remarks>Adds the specified value to the current set.</remarks>
+        /// <param name="el">the value to add</param>
+        /// <exception>
+        /// IllegalStateException
+        /// if the current set is read-only
+        /// </exception>
+        void Add(int el);
+
+        /// <summary>
+        /// Modify the current
+        /// <see cref="IIntSet"/>
+        /// object to contain all elements that are
+        /// present in itself, the specified
+        /// <paramref name="set"/>
+        /// , or both.
+        /// </summary>
+        /// <param name="set">
+        /// The set to add to the current set. A
+        /// <see langword="null"/>
+        /// argument is
+        /// treated as though it were an empty set.
+        /// </param>
+        /// <returns>
+        /// 
+        /// <c>this</c>
+        /// (to support chained calls)
+        /// </returns>
+        /// <exception>
+        /// IllegalStateException
+        /// if the current set is read-only
+        /// </exception>
+        [return: NotNull]
+        IIntSet AddAll(IIntSet set);
+
+        /// <summary>
+        /// Return a new
+        /// <see cref="IIntSet"/>
+        /// object containing all elements that are
+        /// present in both the current set and the specified set
+        /// <paramref name="a"/>
+        /// .
+        /// </summary>
+        /// <param name="a">
+        /// The set to intersect with the current set. A
+        /// <see langword="null"/>
+        /// argument is treated as though it were an empty set.
+        /// </param>
+        /// <returns>
+        /// A new
+        /// <see cref="IIntSet"/>
+        /// instance containing the intersection of the
+        /// current set and
+        /// <paramref name="a"/>
+        /// . The value
+        /// <see langword="null"/>
+        /// may be returned in
+        /// place of an empty result set.
+        /// </returns>
+        [return: Nullable]
+        IIntSet And(IIntSet a);
+
+        /// <summary>
+        /// Return a new
+        /// <see cref="IIntSet"/>
+        /// object containing all elements that are
+        /// present in
+        /// <paramref name="elements"/>
+        /// but not present in the current set. The
+        /// following expressions are equivalent for input non-null
+        /// <see cref="IIntSet"/>
+        /// instances
+        /// <c>x</c>
+        /// and
+        /// <c>y</c>
+        /// .
+        /// <ul>
+        /// <li>
+        /// <c>x.complement(y)</c>
+        /// </li>
+        /// <li>
+        /// <c>y.subtract(x)</c>
+        /// </li>
+        /// </ul>
+        /// </summary>
+        /// <param name="elements">
+        /// The set to compare with the current set. A
+        /// <see langword="null"/>
+        /// argument is treated as though it were an empty set.
+        /// </param>
+        /// <returns>
+        /// A new
+        /// <see cref="IIntSet"/>
+        /// instance containing the elements present in
+        /// <paramref name="elements"/>
+        /// but not present in the current set. The value
+        /// <see langword="null"/>
+        /// may be returned in place of an empty result set.
+        /// </returns>
+        [return: Nullable]
+        IIntSet Complement(IIntSet elements);
+
+        /// <summary>
+        /// Return a new
+        /// <see cref="IIntSet"/>
+        /// object containing all elements that are
+        /// present in the current set, the specified set
+        /// <paramref name="a"/>
+        /// , or both.
+        /// <p>
+        /// This method is similar to
+        /// <see cref="AddAll(IIntSet)"/>
+        /// , but returns a new
+        /// <see cref="IIntSet"/>
+        /// instance instead of modifying the current set.</p>
+        /// </summary>
+        /// <param name="a">
+        /// The set to union with the current set. A
+        /// <see langword="null"/>
+        /// argument
+        /// is treated as though it were an empty set.
+        /// </param>
+        /// <returns>
+        /// A new
+        /// <see cref="IIntSet"/>
+        /// instance containing the union of the current
+        /// set and
+        /// <paramref name="a"/>
+        /// . The value
+        /// <see langword="null"/>
+        /// may be returned in place of an
+        /// empty result set.
+        /// </returns>
+        [return: Nullable]
+        IIntSet Or(IIntSet a);
+
+        /// <summary>
+        /// Return a new
+        /// <see cref="IIntSet"/>
+        /// object containing all elements that are
+        /// present in the current set but not present in the input set
+        /// <paramref name="a"/>
+        /// .
+        /// The following expressions are equivalent for input non-null
+        /// <see cref="IIntSet"/>
+        /// instances
+        /// <c>x</c>
+        /// and
+        /// <c>y</c>
+        /// .
+        /// <ul>
+        /// <li>
+        /// <c>y.subtract(x)</c>
+        /// </li>
+        /// <li>
+        /// <c>x.complement(y)</c>
+        /// </li>
+        /// </ul>
+        /// </summary>
+        /// <param name="a">
+        /// The set to compare with the current set. A
+        /// <see langword="null"/>
+        /// argument is treated as though it were an empty set.
+        /// </param>
+        /// <returns>
+        /// A new
+        /// <see cref="IIntSet"/>
+        /// instance containing the elements present in
+        /// <c>elements</c>
+        /// but not present in the current set. The value
+        /// <see langword="null"/>
+        /// may be returned in place of an empty result set.
+        /// </returns>
+        [return: Nullable]
+        IIntSet Subtract(IIntSet a);
+
+        /// <summary>Return the total number of elements represented by the current set.</summary>
+        /// <remarks>Return the total number of elements represented by the current set.</remarks>
+        /// <returns>
+        /// the total number of elements represented by the current set,
+        /// regardless of the manner in which the elements are stored.
+        /// </returns>
+        int Count
+        {
+            get;
+        }
+
+        /// <summary>
+        /// Returns
+        /// <see langword="true"/>
+        /// if this set contains no elements.
+        /// </summary>
+        /// <returns>
+        /// 
+        /// <see langword="true"/>
+        /// if the current set contains no elements; otherwise,
+        /// <see langword="false"/>
+        /// .
+        /// </returns>
+        bool IsNil
+        {
+            get;
+        }
+
+        /// <summary><inheritDoc/></summary>
+        bool Equals(object obj);
+
+        /// <summary>
+        /// Returns the single value contained in the set, if
+        /// <see cref="Count()"/>
+        /// is 1;
+        /// otherwise, returns
+        /// <see cref="TokenConstants.InvalidType"/>
+        /// .
+        /// </summary>
+        /// <returns>
+        /// the single value contained in the set, if
+        /// <see cref="Count()"/>
+        /// is 1;
+        /// otherwise, returns
+        /// <see cref="TokenConstants.InvalidType"/>
+        /// .
+        /// </returns>
+        int SingleElement
+        {
+            get;
+        }
+
+        /// <summary>
+        /// Returns
+        /// <see langword="true"/>
+        /// if the set contains the specified element.
+        /// </summary>
+        /// <param name="el">The element to check for.</param>
+        /// <returns>
+        /// 
+        /// <see langword="true"/>
+        /// if the set contains
+        /// <paramref name="el"/>
+        /// ; otherwise
+        /// <see langword="false"/>
+        /// .
+        /// </returns>
+        bool Contains(int el);
+
+        /// <summary>Removes the specified value from the current set.</summary>
+        /// <remarks>
+        /// Removes the specified value from the current set. If the current set does
+        /// not contain the element, no changes are made.
+        /// </remarks>
+        /// <param name="el">the value to remove</param>
+        /// <exception>
+        /// IllegalStateException
+        /// if the current set is read-only
+        /// </exception>
+        void Remove(int el);
+
+        /// <summary>Return a list containing the elements represented by the current set.</summary>
+        /// <remarks>
+        /// Return a list containing the elements represented by the current set. The
+        /// list is returned in ascending numerical order.
+        /// </remarks>
+        /// <returns>
+        /// A list containing all element present in the current set, sorted
+        /// in ascending numerical order.
+        /// </returns>
+        [return: NotNull]
+        IList<int> ToList();
+
+        /// <summary><inheritDoc/></summary>
+        string ToString();
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Misc/Interval.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Misc/Interval.cs
new file mode 100644
index 000000000..bd7b3219a
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Misc/Interval.cs
@@ -0,0 +1,204 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Misc
+{
+    /// <summary>An immutable inclusive interval a..b.</summary>
+    /// <remarks>An immutable inclusive interval a..b.</remarks>
+    public struct Interval
+    {
+        public static readonly Antlr4.Runtime.Misc.Interval Invalid = new Antlr4.Runtime.Misc.Interval(-1, -2);
+
+        /// <summary>The start of the interval.</summary>
+        /// <remarks>The start of the interval.</remarks>
+        public readonly int a;
+
+        /// <summary>The end of the interval (inclusive).</summary>
+        /// <remarks>The end of the interval (inclusive).</remarks>
+        public readonly int b;
+
+        public Interval(int a, int b)
+        {
+            this.a = a;
+            this.b = b;
+        }
+
+        /// <summary>
+        /// Interval objects are used readonly so share all with the
+        /// same single value a==b up to some max size.
+        /// </summary>
+        /// <remarks>
+        /// Interval objects are used readonly so share all with the
+        /// same single value a==b up to some max size.  Use an array as a perfect hash.
+        /// Return shared object for 0..INTERVAL_POOL_MAX_VALUE or a new
+        /// Interval object with a..a in it.  On Java.g4, 218623 IntervalSets
+        /// have a..a (set with 1 element).
+        /// </remarks>
+        public static Antlr4.Runtime.Misc.Interval Of(int a, int b)
+        {
+            return new Antlr4.Runtime.Misc.Interval(a, b);
+        }
+
+        /// <summary>return number of elements between a and b inclusively.</summary>
+        /// <remarks>
+        /// return number of elements between a and b inclusively. x..x is length 1.
+        /// if b &lt; a, then length is 0. 9..10 has length 2.
+        /// </remarks>
+        public int Length
+        {
+            get
+            {
+                if (b < a)
+                {
+                    return 0;
+                }
+                return b - a + 1;
+            }
+        }
+
+        public override bool Equals(object o)
+        {
+            if (!(o is Antlr4.Runtime.Misc.Interval))
+            {
+                return false;
+            }
+
+            Antlr4.Runtime.Misc.Interval other = (Antlr4.Runtime.Misc.Interval)o;
+            return this.a == other.a && this.b == other.b;
+        }
+
+        public override int GetHashCode()
+        {
+            int hash = 23;
+            hash = hash * 31 + a;
+            hash = hash * 31 + b;
+            return hash;
+        }
+
+        /// <summary>Does this start completely before other? Disjoint</summary>
+        public bool StartsBeforeDisjoint(Antlr4.Runtime.Misc.Interval other)
+        {
+            return this.a < other.a && this.b < other.a;
+        }
+
+        /// <summary>Does this start at or before other? Nondisjoint</summary>
+        public bool StartsBeforeNonDisjoint(Antlr4.Runtime.Misc.Interval other)
+        {
+            return this.a <= other.a && this.b >= other.a;
+        }
+
+        /// <summary>Does this.a start after other.b? May or may not be disjoint</summary>
+        public bool StartsAfter(Antlr4.Runtime.Misc.Interval other)
+        {
+            return this.a > other.a;
+        }
+
+        /// <summary>Does this start completely after other? Disjoint</summary>
+        public bool StartsAfterDisjoint(Antlr4.Runtime.Misc.Interval other)
+        {
+            return this.a > other.b;
+        }
+
+        /// <summary>Does this start after other? NonDisjoint</summary>
+        public bool StartsAfterNonDisjoint(Antlr4.Runtime.Misc.Interval other)
+        {
+            return this.a > other.a && this.a <= other.b;
+        }
+
+        // this.b>=other.b implied
+        /// <summary>Are both ranges disjoint? I.e., no overlap?</summary>
+        public bool Disjoint(Antlr4.Runtime.Misc.Interval other)
+        {
+            return StartsBeforeDisjoint(other) || StartsAfterDisjoint(other);
+        }
+
+        /// <summary>Are two intervals adjacent such as 0..41 and 42..42?</summary>
+        public bool Adjacent(Antlr4.Runtime.Misc.Interval other)
+        {
+            return this.a == other.b + 1 || this.b == other.a - 1;
+        }
+
+        public bool ProperlyContains(Antlr4.Runtime.Misc.Interval other)
+        {
+            return other.a >= this.a && other.b <= this.b;
+        }
+
+        /// <summary>Return the interval computed from combining this and other</summary>
+        public Antlr4.Runtime.Misc.Interval Union(Antlr4.Runtime.Misc.Interval other)
+        {
+            return Antlr4.Runtime.Misc.Interval.Of(Math.Min(a, other.a), Math.Max(b, other.b));
+        }
+
+        /// <summary>Return the interval in common between this and o</summary>
+        public Antlr4.Runtime.Misc.Interval Intersection(Antlr4.Runtime.Misc.Interval other)
+        {
+            return Antlr4.Runtime.Misc.Interval.Of(Math.Max(a, other.a), Math.Min(b, other.b));
+        }
+
+        /// <summary>
+        /// Return the interval with elements from
+        /// <c>this</c>
+        /// not in
+        /// <paramref name="other"/>
+        /// ;
+        /// <paramref name="other"/>
+        /// must not be totally enclosed (properly contained)
+        /// within
+        /// <c>this</c>
+        /// , which would result in two disjoint intervals
+        /// instead of the single one returned by this method.
+        /// </summary>
+        public Antlr4.Runtime.Misc.Interval? DifferenceNotProperlyContained(Antlr4.Runtime.Misc.Interval other)
+        {
+            Antlr4.Runtime.Misc.Interval? diff = null;
+            // other.a to left of this.a (or same)
+            if (other.StartsBeforeNonDisjoint(this))
+            {
+                diff = Antlr4.Runtime.Misc.Interval.Of(Math.Max(this.a, other.b + 1), this.b);
+            }
+            else
+            {
+                // other.a to right of this.a
+                if (other.StartsAfterNonDisjoint(this))
+                {
+                    diff = Antlr4.Runtime.Misc.Interval.Of(this.a, other.a - 1);
+                }
+            }
+            return diff;
+        }
+
+        public override string ToString()
+        {
+            return a + ".." + b;
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Misc/IntervalSet.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Misc/IntervalSet.cs
new file mode 100644
index 000000000..e41cc1049
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Misc/IntervalSet.cs
@@ -0,0 +1,930 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Antlr4.Runtime;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Misc
+{
+    /// <summary>
+    /// This class implements the
+    /// <see cref="IIntSet"/>
+    /// backed by a sorted array of
+    /// non-overlapping intervals. It is particularly efficient for representing
+    /// large collections of numbers, where the majority of elements appear as part
+    /// of a sequential range of numbers that are all part of the set. For example,
+    /// the set { 1, 2, 3, 4, 7, 8 } may be represented as { [1, 4], [7, 8] }.
+    /// <p>
+    /// This class is able to represent sets containing any combination of values in
+    /// the range
+    /// <see cref="int.MinValue"/>
+    /// to
+    /// <see cref="int.MaxValue"/>
+    /// (inclusive).</p>
+    /// </summary>
+    public class IntervalSet : IIntSet
+    {
+        public static readonly Antlr4.Runtime.Misc.IntervalSet CompleteCharSet = Antlr4.Runtime.Misc.IntervalSet.Of(Lexer.MinCharValue, Lexer.MaxCharValue);
+
+        public static readonly Antlr4.Runtime.Misc.IntervalSet EmptySet = new Antlr4.Runtime.Misc.IntervalSet();
+
+        static IntervalSet()
+        {
+            CompleteCharSet.SetReadonly(true);
+            EmptySet.SetReadonly(true);
+        }
+
+        /// <summary>The list of sorted, disjoint intervals.</summary>
+        /// <remarks>The list of sorted, disjoint intervals.</remarks>
+        protected internal IList<Interval> intervals;
+
+        protected internal bool @readonly;
+
+        public IntervalSet(IList<Interval> intervals)
+        {
+            this.intervals = intervals;
+        }
+
+        public IntervalSet(Antlr4.Runtime.Misc.IntervalSet set)
+            : this()
+        {
+            AddAll(set);
+        }
+
+        public IntervalSet(params int[] els)
+        {
+            if (els == null)
+            {
+                intervals = new List<Interval>(2);
+            }
+            else
+            {
+                // most sets are 1 or 2 elements
+                intervals = new List<Interval>(els.Length);
+                foreach (int e in els)
+                {
+                    Add(e);
+                }
+            }
+        }
+
+        /// <summary>Create a set with a single element, el.</summary>
+        /// <remarks>Create a set with a single element, el.</remarks>
+        [return: NotNull]
+        public static Antlr4.Runtime.Misc.IntervalSet Of(int a)
+        {
+            Antlr4.Runtime.Misc.IntervalSet s = new Antlr4.Runtime.Misc.IntervalSet();
+            s.Add(a);
+            return s;
+        }
+
+        /// <summary>Create a set with all ints within range [a..b] (inclusive)</summary>
+        public static Antlr4.Runtime.Misc.IntervalSet Of(int a, int b)
+        {
+            Antlr4.Runtime.Misc.IntervalSet s = new Antlr4.Runtime.Misc.IntervalSet();
+            s.Add(a, b);
+            return s;
+        }
+
+        public virtual void Clear()
+        {
+            if (@readonly)
+            {
+                throw new InvalidOperationException("can't alter readonly IntervalSet");
+            }
+            intervals.Clear();
+        }
+
+        /// <summary>Add a single element to the set.</summary>
+        /// <remarks>
+        /// Add a single element to the set.  An isolated element is stored
+        /// as a range el..el.
+        /// </remarks>
+        public virtual void Add(int el)
+        {
+            if (@readonly)
+            {
+                throw new InvalidOperationException("can't alter readonly IntervalSet");
+            }
+            Add(el, el);
+        }
+
+        /// <summary>Add interval; i.e., add all integers from a to b to set.</summary>
+        /// <remarks>
+        /// Add interval; i.e., add all integers from a to b to set.
+        /// If b&lt;a, do nothing.
+        /// Keep list in sorted order (by left range value).
+        /// If overlap, combine ranges.  For example,
+        /// If this is {1..5, 10..20}, adding 6..7 yields
+        /// {1..5, 6..7, 10..20}.  Adding 4..8 yields {1..8, 10..20}.
+        /// </remarks>
+        public virtual void Add(int a, int b)
+        {
+            Add(Interval.Of(a, b));
+        }
+
+        // copy on write so we can cache a..a intervals and sets of that
+        protected internal virtual void Add(Interval addition)
+        {
+            if (@readonly)
+            {
+                throw new InvalidOperationException("can't alter readonly IntervalSet");
+            }
+            //System.out.println("add "+addition+" to "+intervals.toString());
+            if (addition.b < addition.a)
+            {
+                return;
+            }
+            // find position in list
+            // Use iterators as we modify list in place
+            for (int i = 0; i < intervals.Count; i++)
+            {
+                Interval r = intervals[i];
+                if (addition.Equals(r))
+                {
+                    return;
+                }
+                if (addition.Adjacent(r) || !addition.Disjoint(r))
+                {
+                    // next to each other, make a single larger interval
+                    Interval bigger = addition.Union(r);
+                    intervals[i] = bigger;
+                    // make sure we didn't just create an interval that
+                    // should be merged with next interval in list
+                    while (i < intervals.Count - 1)
+                    {
+                        i++;
+                        Interval next = intervals[i];
+                        if (!bigger.Adjacent(next) && bigger.Disjoint(next))
+                        {
+                            break;
+                        }
+                        // if we bump up against or overlap next, merge
+                        intervals.RemoveAt(i);
+                        // remove this one
+                        i--;
+                        // move backwards to what we just set
+                        intervals[i] = bigger.Union(next);
+                        // set to 3 merged ones
+                    }
+                    // first call to next after previous duplicates the result
+                    return;
+                }
+                if (addition.StartsBeforeDisjoint(r))
+                {
+                    // insert before r
+                    intervals.Insert(i, addition);
+                    return;
+                }
+            }
+            // if disjoint and after r, a future iteration will handle it
+            // ok, must be after last interval (and disjoint from last interval)
+            // just add it
+            intervals.Add(addition);
+        }
+
+        /// <summary>combine all sets in the array returned the or'd value</summary>
+        public static Antlr4.Runtime.Misc.IntervalSet Or(Antlr4.Runtime.Misc.IntervalSet[] sets)
+        {
+            Antlr4.Runtime.Misc.IntervalSet r = new Antlr4.Runtime.Misc.IntervalSet();
+            foreach (Antlr4.Runtime.Misc.IntervalSet s in sets)
+            {
+                r.AddAll(s);
+            }
+            return r;
+        }
+
+        public virtual Antlr4.Runtime.Misc.IntervalSet AddAll(IIntSet set)
+        {
+            if (set == null)
+            {
+                return this;
+            }
+            if (set is Antlr4.Runtime.Misc.IntervalSet)
+            {
+                Antlr4.Runtime.Misc.IntervalSet other = (Antlr4.Runtime.Misc.IntervalSet)set;
+                // walk set and add each interval
+                int n = other.intervals.Count;
+                for (int i = 0; i < n; i++)
+                {
+                    Interval I = other.intervals[i];
+                    this.Add(I.a, I.b);
+                }
+            }
+            else
+            {
+                foreach (int value in set.ToList())
+                {
+                    Add(value);
+                }
+            }
+            return this;
+        }
+
+        public virtual Antlr4.Runtime.Misc.IntervalSet Complement(int minElement, int maxElement)
+        {
+            return this.Complement(Antlr4.Runtime.Misc.IntervalSet.Of(minElement, maxElement));
+        }
+
+        /// <summary>
+        /// <inheritDoc/>
+        /// 
+        /// </summary>
+        public virtual Antlr4.Runtime.Misc.IntervalSet Complement(IIntSet vocabulary)
+        {
+            if (vocabulary == null || vocabulary.IsNil)
+            {
+                return null;
+            }
+            // nothing in common with null set
+            Antlr4.Runtime.Misc.IntervalSet vocabularyIS;
+            if (vocabulary is Antlr4.Runtime.Misc.IntervalSet)
+            {
+                vocabularyIS = (Antlr4.Runtime.Misc.IntervalSet)vocabulary;
+            }
+            else
+            {
+                vocabularyIS = new Antlr4.Runtime.Misc.IntervalSet();
+                vocabularyIS.AddAll(vocabulary);
+            }
+            return vocabularyIS.Subtract(this);
+        }
+
+        public virtual Antlr4.Runtime.Misc.IntervalSet Subtract(IIntSet a)
+        {
+            if (a == null || a.IsNil)
+            {
+                return new Antlr4.Runtime.Misc.IntervalSet(this);
+            }
+            if (a is Antlr4.Runtime.Misc.IntervalSet)
+            {
+                return Subtract(this, (Antlr4.Runtime.Misc.IntervalSet)a);
+            }
+            Antlr4.Runtime.Misc.IntervalSet other = new Antlr4.Runtime.Misc.IntervalSet();
+            other.AddAll(a);
+            return Subtract(this, other);
+        }
+
+        /// <summary>Compute the set difference between two interval sets.</summary>
+        /// <remarks>
+        /// Compute the set difference between two interval sets. The specific
+        /// operation is
+        /// <c>left - right</c>
+        /// . If either of the input sets is
+        /// <see langword="null"/>
+        /// , it is treated as though it was an empty set.
+        /// </remarks>
+        [return: NotNull]
+        public static Antlr4.Runtime.Misc.IntervalSet Subtract(Antlr4.Runtime.Misc.IntervalSet left, Antlr4.Runtime.Misc.IntervalSet right)
+        {
+            if (left == null || left.IsNil)
+            {
+                return new Antlr4.Runtime.Misc.IntervalSet();
+            }
+            Antlr4.Runtime.Misc.IntervalSet result = new Antlr4.Runtime.Misc.IntervalSet(left);
+            if (right == null || right.IsNil)
+            {
+                // right set has no elements; just return the copy of the current set
+                return result;
+            }
+            int resultI = 0;
+            int rightI = 0;
+            while (resultI < result.intervals.Count && rightI < right.intervals.Count)
+            {
+                Interval resultInterval = result.intervals[resultI];
+                Interval rightInterval = right.intervals[rightI];
+                // operation: (resultInterval - rightInterval) and update indexes
+                if (rightInterval.b < resultInterval.a)
+                {
+                    rightI++;
+                    continue;
+                }
+                if (rightInterval.a > resultInterval.b)
+                {
+                    resultI++;
+                    continue;
+                }
+                Interval? beforeCurrent = null;
+                Interval? afterCurrent = null;
+                if (rightInterval.a > resultInterval.a)
+                {
+                    beforeCurrent = new Interval(resultInterval.a, rightInterval.a - 1);
+                }
+                if (rightInterval.b < resultInterval.b)
+                {
+                    afterCurrent = new Interval(rightInterval.b + 1, resultInterval.b);
+                }
+                if (beforeCurrent != null)
+                {
+                    if (afterCurrent != null)
+                    {
+                        // split the current interval into two
+                        result.intervals[resultI] = beforeCurrent.Value;
+                        result.intervals.Insert(resultI + 1, afterCurrent.Value);
+                        resultI++;
+                        rightI++;
+                        continue;
+                    }
+                    else
+                    {
+                        // replace the current interval
+                        result.intervals[resultI] = beforeCurrent.Value;
+                        resultI++;
+                        continue;
+                    }
+                }
+                else
+                {
+                    if (afterCurrent != null)
+                    {
+                        // replace the current interval
+                        result.intervals[resultI] = afterCurrent.Value;
+                        rightI++;
+                        continue;
+                    }
+                    else
+                    {
+                        // remove the current interval (thus no need to increment resultI)
+                        result.intervals.RemoveAt(resultI);
+                        continue;
+                    }
+                }
+            }
+            // If rightI reached right.intervals.size(), no more intervals to subtract from result.
+            // If resultI reached result.intervals.size(), we would be subtracting from an empty set.
+            // Either way, we are done.
+            return result;
+        }
+
+        public virtual Antlr4.Runtime.Misc.IntervalSet Or(IIntSet a)
+        {
+            Antlr4.Runtime.Misc.IntervalSet o = new Antlr4.Runtime.Misc.IntervalSet();
+            o.AddAll(this);
+            o.AddAll(a);
+            return o;
+        }
+
+        /// <summary>
+        /// <inheritDoc/>
+        /// 
+        /// </summary>
+        public virtual Antlr4.Runtime.Misc.IntervalSet And(IIntSet other)
+        {
+            if (other == null)
+            {
+                //|| !(other instanceof IntervalSet) ) {
+                return null;
+            }
+            // nothing in common with null set
+            IList<Interval> myIntervals = this.intervals;
+            IList<Interval> theirIntervals = ((Antlr4.Runtime.Misc.IntervalSet)other).intervals;
+            Antlr4.Runtime.Misc.IntervalSet intersection = null;
+            int mySize = myIntervals.Count;
+            int theirSize = theirIntervals.Count;
+            int i = 0;
+            int j = 0;
+            // iterate down both interval lists looking for nondisjoint intervals
+            while (i < mySize && j < theirSize)
+            {
+                Interval mine = myIntervals[i];
+                Interval theirs = theirIntervals[j];
+                //System.out.println("mine="+mine+" and theirs="+theirs);
+                if (mine.StartsBeforeDisjoint(theirs))
+                {
+                    // move this iterator looking for interval that might overlap
+                    i++;
+                }
+                else
+                {
+                    if (theirs.StartsBeforeDisjoint(mine))
+                    {
+                        // move other iterator looking for interval that might overlap
+                        j++;
+                    }
+                    else
+                    {
+                        if (mine.ProperlyContains(theirs))
+                        {
+                            // overlap, add intersection, get next theirs
+                            if (intersection == null)
+                            {
+                                intersection = new Antlr4.Runtime.Misc.IntervalSet();
+                            }
+                            intersection.Add(mine.Intersection(theirs));
+                            j++;
+                        }
+                        else
+                        {
+                            if (theirs.ProperlyContains(mine))
+                            {
+                                // overlap, add intersection, get next mine
+                                if (intersection == null)
+                                {
+                                    intersection = new Antlr4.Runtime.Misc.IntervalSet();
+                                }
+                                intersection.Add(mine.Intersection(theirs));
+                                i++;
+                            }
+                            else
+                            {
+                                if (!mine.Disjoint(theirs))
+                                {
+                                    // overlap, add intersection
+                                    if (intersection == null)
+                                    {
+                                        intersection = new Antlr4.Runtime.Misc.IntervalSet();
+                                    }
+                                    intersection.Add(mine.Intersection(theirs));
+                                    // Move the iterator of lower range [a..b], but not
+                                    // the upper range as it may contain elements that will collide
+                                    // with the next iterator. So, if mine=[0..115] and
+                                    // theirs=[115..200], then intersection is 115 and move mine
+                                    // but not theirs as theirs may collide with the next range
+                                    // in thisIter.
+                                    // move both iterators to next ranges
+                                    if (mine.StartsAfterNonDisjoint(theirs))
+                                    {
+                                        j++;
+                                    }
+                                    else
+                                    {
+                                        if (theirs.StartsAfterNonDisjoint(mine))
+                                        {
+                                            i++;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            if (intersection == null)
+            {
+                return new Antlr4.Runtime.Misc.IntervalSet();
+            }
+            return intersection;
+        }
+
+        /// <summary>
+        /// <inheritDoc/>
+        /// 
+        /// </summary>
+        public virtual bool Contains(int el)
+        {
+            int n = intervals.Count;
+            for (int i = 0; i < n; i++)
+            {
+                Interval I = intervals[i];
+                int a = I.a;
+                int b = I.b;
+                if (el < a)
+                {
+                    break;
+                }
+                // list is sorted and el is before this interval; not here
+                if (el >= a && el <= b)
+                {
+                    return true;
+                }
+            }
+            // found in this interval
+            return false;
+        }
+
+        /// <summary>
+        /// <inheritDoc/>
+        /// 
+        /// </summary>
+        public virtual bool IsNil
+        {
+            get
+            {
+                return intervals == null || intervals.Count == 0;
+            }
+        }
+
+        /// <summary>
+        /// <inheritDoc/>
+        /// 
+        /// </summary>
+        public virtual int SingleElement
+        {
+            get
+            {
+                if (intervals != null && intervals.Count == 1)
+                {
+                    Interval I = intervals[0];
+                    if (I.a == I.b)
+                    {
+                        return I.a;
+                    }
+                }
+                return TokenConstants.InvalidType;
+            }
+        }
+
+        /// <summary>Returns the maximum value contained in the set.</summary>
+        /// <remarks>Returns the maximum value contained in the set.</remarks>
+        /// <returns>
+        /// the maximum value contained in the set. If the set is empty, this
+        /// method returns
+        /// <see cref="TokenConstants.InvalidType"/>
+        /// .
+        /// </returns>
+        public virtual int MaxElement
+        {
+            get
+            {
+                if (IsNil)
+                {
+                    return TokenConstants.InvalidType;
+                }
+                Interval last = intervals[intervals.Count - 1];
+                return last.b;
+            }
+        }
+
+        /// <summary>Returns the minimum value contained in the set.</summary>
+        /// <remarks>Returns the minimum value contained in the set.</remarks>
+        /// <returns>
+        /// the minimum value contained in the set. If the set is empty, this
+        /// method returns
+        /// <see cref="TokenConstants.InvalidType"/>
+        /// .
+        /// </returns>
+        public virtual int MinElement
+        {
+            get
+            {
+                if (IsNil)
+                {
+                    return TokenConstants.InvalidType;
+                }
+                return intervals[0].a;
+            }
+        }
+
+        /// <summary>Return a list of Interval objects.</summary>
+        /// <remarks>Return a list of Interval objects.</remarks>
+        public virtual IList<Interval> GetIntervals()
+        {
+            return intervals;
+        }
+
+        public override int GetHashCode()
+        {
+            int hash = MurmurHash.Initialize();
+            foreach (Interval I in intervals)
+            {
+                hash = MurmurHash.Update(hash, I.a);
+                hash = MurmurHash.Update(hash, I.b);
+            }
+            hash = MurmurHash.Finish(hash, intervals.Count * 2);
+            return hash;
+        }
+
+        /// <summary>
+        /// Are two IntervalSets equal?  Because all intervals are sorted
+        /// and disjoint, equals is a simple linear walk over both lists
+        /// to make sure they are the same.
+        /// </summary>
+        /// <remarks>
+        /// Are two IntervalSets equal?  Because all intervals are sorted
+        /// and disjoint, equals is a simple linear walk over both lists
+        /// to make sure they are the same.  Interval.equals() is used
+        /// by the List.equals() method to check the ranges.
+        /// </remarks>
+        public override bool Equals(object obj)
+        {
+            if (obj == null || !(obj is Antlr4.Runtime.Misc.IntervalSet))
+            {
+                return false;
+            }
+            Antlr4.Runtime.Misc.IntervalSet other = (Antlr4.Runtime.Misc.IntervalSet)obj;
+            return this.intervals.SequenceEqual(other.intervals);
+        }
+
+        public override string ToString()
+        {
+            return ToString(false);
+        }
+
+        public virtual string ToString(bool elemAreChar)
+        {
+            StringBuilder buf = new StringBuilder();
+            if (this.intervals == null || this.intervals.Count == 0)
+            {
+                return "{}";
+            }
+            if (this.Count > 1)
+            {
+                buf.Append("{");
+            }
+
+            bool first = true;
+            foreach (Interval I in intervals)
+            {
+                if (!first)
+                    buf.Append(", ");
+
+                first = false;
+                int a = I.a;
+                int b = I.b;
+                if (a == b)
+                {
+                    if (a == TokenConstants.Eof)
+                    {
+                        buf.Append("<EOF>");
+                    }
+                    else
+                    {
+                        if (elemAreChar)
+                        {
+                            buf.Append("'").Append((char)a).Append("'");
+                        }
+                        else
+                        {
+                            buf.Append(a);
+                        }
+                    }
+                }
+                else
+                {
+                    if (elemAreChar)
+                    {
+                        buf.Append("'").Append((char)a).Append("'..'").Append((char)b).Append("'");
+                    }
+                    else
+                    {
+                        buf.Append(a).Append("..").Append(b);
+                    }
+                }
+            }
+            if (this.Count > 1)
+            {
+                buf.Append("}");
+            }
+            return buf.ToString();
+        }
+
+        public virtual string ToString(IVocabulary vocabulary)
+        {
+            StringBuilder buf = new StringBuilder();
+            if (this.intervals == null || this.intervals.Count == 0)
+            {
+                return "{}";
+            }
+            if (this.Count > 1)
+            {
+                buf.Append("{");
+            }
+
+            bool first = true;
+            foreach (Interval I in intervals)
+            {
+                if (!first)
+                    buf.Append(", ");
+
+                first = false;
+                int a = I.a;
+                int b = I.b;
+                if (a == b)
+                {
+                    buf.Append(ElementName(vocabulary, a));
+                }
+                else
+                {
+                    for (int i = a; i <= b; i++)
+                    {
+                        if (i > a)
+                        {
+                            buf.Append(", ");
+                        }
+                        buf.Append(ElementName(vocabulary, i));
+                    }
+                }
+            }
+            if (this.Count > 1)
+            {
+                buf.Append("}");
+            }
+            return buf.ToString();
+        }
+
+        [return: NotNull]
+        protected internal virtual string ElementName(IVocabulary vocabulary, int a)
+        {
+            if (a == TokenConstants.Eof)
+            {
+                return "<EOF>";
+            }
+            else
+            {
+                if (a == TokenConstants.Epsilon)
+                {
+                    return "<EPSILON>";
+                }
+                else
+                {
+                    return vocabulary.GetDisplayName(a);
+                }
+            }
+        }
+
+        public virtual int Count
+        {
+            get
+            {
+                int n = 0;
+                int numIntervals = intervals.Count;
+                if (numIntervals == 1)
+                {
+                    Interval firstInterval = this.intervals[0];
+                    return firstInterval.b - firstInterval.a + 1;
+                }
+                for (int i = 0; i < numIntervals; i++)
+                {
+                    Interval I = intervals[i];
+                    n += (I.b - I.a + 1);
+                }
+                return n;
+            }
+        }
+
+        public virtual List<int> ToIntegerList()
+        {
+            List<int> values = new List<int>(Count);
+            int n = intervals.Count;
+            for (int i = 0; i < n; i++)
+            {
+                Interval I = intervals[i];
+                int a = I.a;
+                int b = I.b;
+                for (int v = a; v <= b; v++)
+                {
+                    values.Add(v);
+                }
+            }
+            return values;
+        }
+
+        public virtual IList<int> ToList()
+        {
+            IList<int> values = new List<int>();
+            int n = intervals.Count;
+            for (int i = 0; i < n; i++)
+            {
+                Interval I = intervals[i];
+                int a = I.a;
+                int b = I.b;
+                for (int v = a; v <= b; v++)
+                {
+                    values.Add(v);
+                }
+            }
+            return values;
+        }
+
+        public virtual HashSet<int> ToSet()
+        {
+            HashSet<int> s = new HashSet<int>();
+            foreach (Interval I in intervals)
+            {
+                int a = I.a;
+                int b = I.b;
+                for (int v = a; v <= b; v++)
+                {
+                    s.Add(v);
+                }
+            }
+            return s;
+        }
+
+        public virtual int[] ToArray()
+        {
+            return ToIntegerList().ToArray();
+        }
+
+        public virtual void Remove(int el)
+        {
+            if (@readonly)
+            {
+                throw new InvalidOperationException("can't alter readonly IntervalSet");
+            }
+            int n = intervals.Count;
+            for (int i = 0; i < n; i++)
+            {
+                Interval I = intervals[i];
+                int a = I.a;
+                int b = I.b;
+                if (el < a)
+                {
+                    break;
+                }
+                // list is sorted and el is before this interval; not here
+                // if whole interval x..x, rm
+                if (el == a && el == b)
+                {
+                    intervals.RemoveAt(i);
+                    break;
+                }
+                // if on left edge x..b, adjust left
+                if (el == a)
+                {
+                    intervals[i] = Interval.Of(I.a + 1, I.b);
+                    break;
+                }
+                // if on right edge a..x, adjust right
+                if (el == b)
+                {
+                    intervals[i] = Interval.Of(I.a, I.b - 1);
+                    break;
+                }
+                // if in middle a..x..b, split interval
+                if (el > a && el < b)
+                {
+                    // found in this interval
+                    int oldb = I.b;
+                    intervals[i] = Interval.Of(I.a, el - 1);
+                    // [a..x-1]
+                    Add(el + 1, oldb);
+                }
+            }
+        }
+
+        public virtual bool IsReadOnly
+        {
+            get
+            {
+                // add [x+1..b]
+                return @readonly;
+            }
+        }
+
+        public virtual void SetReadonly(bool @readonly)
+        {
+            if (this.@readonly && !@readonly)
+            {
+                throw new InvalidOperationException("can't alter readonly IntervalSet");
+            }
+            this.@readonly = @readonly;
+        }
+
+        IIntSet IIntSet.AddAll(IIntSet set)
+        {
+            return AddAll(set);
+        }
+
+        IIntSet IIntSet.And(IIntSet a)
+        {
+            return And(a);
+        }
+
+        IIntSet IIntSet.Complement(IIntSet elements)
+        {
+            return Complement(elements);
+        }
+
+        IIntSet IIntSet.Or(IIntSet a)
+        {
+            return Or(a);
+        }
+
+        IIntSet IIntSet.Subtract(IIntSet a)
+        {
+            return Subtract(a);
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Misc/MultiMap.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Misc/MultiMap.cs
new file mode 100644
index 000000000..e5b8ebea6
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Misc/MultiMap.cs
@@ -0,0 +1,67 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System;
+using System.Collections.Generic;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Misc
+{
+    [System.Serializable]
+    public class MultiMap<K, V> : Dictionary<K, IList<V>>
+    {
+        private const long serialVersionUID = -4956746660057462312L;
+
+        public virtual void Map(K key, V value)
+        {
+            IList<V> elementsForKey;
+            if (!TryGetValue(key, out elementsForKey))
+            {
+                elementsForKey = new List<V>();
+                this[key] = elementsForKey;
+            }
+            elementsForKey.Add(value);
+        }
+
+        public virtual IList<Tuple<K, V>> GetPairs()
+        {
+            IList<Tuple<K, V>> pairs = new List<Tuple<K, V>>();
+            foreach (KeyValuePair<K, IList<V>> pair in this)
+            {
+                foreach (V value in pair.Value)
+                {
+                    pairs.Add(Tuple.Create(pair.Key, value));
+                }
+            }
+
+            return pairs;
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Misc/MurmurHash.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Misc/MurmurHash.cs
new file mode 100644
index 000000000..9a9fcc828
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Misc/MurmurHash.cs
@@ -0,0 +1,143 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Misc
+{
+    /// <author>Sam Harwell</author>
+    public sealed class MurmurHash
+    {
+        private const int DefaultSeed = 0;
+
+        /// <summary>Initialize the hash using the default seed value.</summary>
+        /// <remarks>Initialize the hash using the default seed value.</remarks>
+        /// <returns>the intermediate hash value</returns>
+        public static int Initialize()
+        {
+            return Initialize(DefaultSeed);
+        }
+
+        /// <summary>
+        /// Initialize the hash using the specified
+        /// <paramref name="seed"/>
+        /// .
+        /// </summary>
+        /// <param name="seed">the seed</param>
+        /// <returns>the intermediate hash value</returns>
+        public static int Initialize(int seed)
+        {
+            return seed;
+        }
+
+        /// <summary>
+        /// Update the intermediate hash value for the next input
+        /// <paramref name="value"/>
+        /// .
+        /// </summary>
+        /// <param name="hash">the intermediate hash value</param>
+        /// <param name="value">the value to add to the current hash</param>
+        /// <returns>the updated intermediate hash value</returns>
+        public static int Update(int hash, int value)
+        {
+            int c1 = unchecked((int)(0xCC9E2D51));
+            int c2 = unchecked((int)(0x1B873593));
+            int r1 = 15;
+            int r2 = 13;
+            int m = 5;
+            int n = unchecked((int)(0xE6546B64));
+            int k = value;
+            k = k * c1;
+            k = (k << r1) | ((int)(((uint)k) >> (32 - r1)));
+            k = k * c2;
+            hash = hash ^ k;
+            hash = (hash << r2) | ((int)(((uint)hash) >> (32 - r2)));
+            hash = hash * m + n;
+            return hash;
+        }
+
+        /// <summary>
+        /// Update the intermediate hash value for the next input
+        /// <paramref name="value"/>
+        /// .
+        /// </summary>
+        /// <param name="hash">the intermediate hash value</param>
+        /// <param name="value">the value to add to the current hash</param>
+        /// <returns>the updated intermediate hash value</returns>
+        public static int Update(int hash, object value)
+        {
+            return Update(hash, value != null ? value.GetHashCode() : 0);
+        }
+
+        /// <summary>
+        /// Apply the final computation steps to the intermediate value
+        /// <paramref name="hash"/>
+        /// to form the final result of the MurmurHash 3 hash function.
+        /// </summary>
+        /// <param name="hash">the intermediate hash value</param>
+        /// <param name="numberOfWords">the number of integer values added to the hash</param>
+        /// <returns>the final hash result</returns>
+        public static int Finish(int hash, int numberOfWords)
+        {
+            hash = hash ^ (numberOfWords * 4);
+            hash = hash ^ ((int)(((uint)hash) >> 16));
+            hash = hash * unchecked((int)(0x85EBCA6B));
+            hash = hash ^ ((int)(((uint)hash) >> 13));
+            hash = hash * unchecked((int)(0xC2B2AE35));
+            hash = hash ^ ((int)(((uint)hash) >> 16));
+            return hash;
+        }
+
+        /// <summary>
+        /// Utility function to compute the hash code of an array using the
+        /// MurmurHash algorithm.
+        /// </summary>
+        /// <remarks>
+        /// Utility function to compute the hash code of an array using the
+        /// MurmurHash algorithm.
+        /// </remarks>
+        /// <param name="data">the array data</param>
+        /// <param name="seed">the seed for the MurmurHash algorithm</param>
+        /// <returns>the hash code of the data</returns>
+        public static int HashCode<T>(T[] data, int seed)
+        {
+            int hash = Initialize(seed);
+            foreach (T value in data)
+            {
+                hash = Update(hash, value);
+            }
+            hash = Finish(hash, data.Length);
+            return hash;
+        }
+
+        private MurmurHash()
+        {
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Misc/NotNullAttribute.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Misc/NotNullAttribute.cs
new file mode 100644
index 000000000..2e888289d
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Misc/NotNullAttribute.cs
@@ -0,0 +1,38 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+namespace Antlr4.Runtime.Misc
+{
+    using System;
+
+    [AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.Property, Inherited = true, AllowMultiple = false)]
+    public sealed class NotNullAttribute : Attribute
+    {
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Misc/NullableAttribute.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Misc/NullableAttribute.cs
new file mode 100644
index 000000000..31a0fe2d9
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Misc/NullableAttribute.cs
@@ -0,0 +1,38 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+namespace Antlr4.Runtime.Misc
+{
+    using System;
+
+    [AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.Property, Inherited = true, AllowMultiple = false)]
+    public sealed class NullableAttribute : Attribute
+    {
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Misc/ParseCanceledException.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Misc/ParseCanceledException.cs
new file mode 100644
index 000000000..9595d377a
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Misc/ParseCanceledException.cs
@@ -0,0 +1,73 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System;
+using Antlr4.Runtime.Sharpen;
+
+#if COMPACT
+using OperationCanceledException = System.Exception;
+#endif
+
+namespace Antlr4.Runtime.Misc
+{
+    /// <summary>This exception is thrown to cancel a parsing operation.</summary>
+    /// <remarks>
+    /// This exception is thrown to cancel a parsing operation. This exception does
+    /// not extend
+    /// <see cref="Antlr4.Runtime.RecognitionException"/>
+    /// , allowing it to bypass the standard
+    /// error recovery mechanisms.
+    /// <see cref="Antlr4.Runtime.BailErrorStrategy"/>
+    /// throws this exception in
+    /// response to a parse error.
+    /// </remarks>
+    /// <author>Sam Harwell</author>
+    [System.Serializable]
+    public class ParseCanceledException : OperationCanceledException
+    {
+        public ParseCanceledException()
+        {
+        }
+
+        public ParseCanceledException(string message)
+            : base(message)
+        {
+        }
+
+        public ParseCanceledException(Exception cause)
+            : base("The parse operation was cancelled.", cause)
+        {
+        }
+
+        public ParseCanceledException(string message, Exception cause)
+            : base(message, cause)
+        {
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Misc/RuleDependencyChecker.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Misc/RuleDependencyChecker.cs
new file mode 100644
index 000000000..e78b6bbff
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Misc/RuleDependencyChecker.cs
@@ -0,0 +1,1136 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+
+#if NET45PLUS
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Security;
+using System.Text;
+using Antlr4.Runtime;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Misc
+{
+    /// <author>Sam Harwell</author>
+    public class RuleDependencyChecker
+    {
+        private static readonly HashSet<string> checkedAssemblies = new HashSet<string>();
+
+        public static void CheckDependencies(Assembly assembly)
+        {
+            if (IsChecked(assembly))
+            {
+                return;
+            }
+
+            IEnumerable<TypeInfo> typesToCheck = GetTypesToCheck(assembly);
+            List<Tuple<RuleDependencyAttribute, ICustomAttributeProvider>> dependencies = new List<Tuple<RuleDependencyAttribute, ICustomAttributeProvider>>();
+            foreach (TypeInfo clazz in typesToCheck)
+            {
+                dependencies.AddRange(GetDependencies(clazz));
+            }
+
+            if (dependencies.Count > 0)
+            {
+                IDictionary<TypeInfo, IList<Tuple<RuleDependencyAttribute, ICustomAttributeProvider>>> recognizerDependencies = new Dictionary<TypeInfo, IList<Tuple<RuleDependencyAttribute, ICustomAttributeProvider>>>();
+                foreach (Tuple<RuleDependencyAttribute, ICustomAttributeProvider> dependency in dependencies)
+                {
+                    TypeInfo recognizerType = dependency.Item1.Recognizer.GetTypeInfo();
+                    IList<Tuple<RuleDependencyAttribute, ICustomAttributeProvider>> list;
+                    if (!recognizerDependencies.TryGetValue(recognizerType, out list))
+                    {
+                        list = new List<Tuple<RuleDependencyAttribute, ICustomAttributeProvider>>();
+                        recognizerDependencies[recognizerType] = list;
+                    }
+                    list.Add(dependency);
+                }
+
+                foreach (KeyValuePair<TypeInfo, IList<Tuple<RuleDependencyAttribute, ICustomAttributeProvider>>> entry in recognizerDependencies)
+                {
+                    //processingEnv.getMessager().printMessage(Diagnostic.Kind.NOTE, String.format("ANTLR 4: Validating {0} dependencies on rules in {1}.", entry.getValue().size(), entry.getKey().toString()));
+                    CheckDependencies(entry.Value, entry.Key);
+                }
+            }
+
+            MarkChecked(assembly);
+        }
+
+        private static IEnumerable<TypeInfo> GetTypesToCheck(Assembly assembly)
+        {
+            return assembly.DefinedTypes;
+        }
+
+        private static bool IsChecked(Assembly assembly)
+        {
+            lock (checkedAssemblies)
+            {
+                return checkedAssemblies.Contains(assembly.FullName);
+            }
+        }
+
+        private static void MarkChecked(Assembly assembly)
+        {
+            lock (checkedAssemblies)
+            {
+                checkedAssemblies.Add(assembly.FullName);
+            }
+        }
+
+        private static void CheckDependencies(IList<Tuple<RuleDependencyAttribute, ICustomAttributeProvider>> dependencies, TypeInfo recognizerType)
+        {
+            string[] ruleNames = GetRuleNames(recognizerType);
+            int[] ruleVersions = GetRuleVersions(recognizerType, ruleNames);
+            RuleDependencyChecker.RuleRelations relations = ExtractRuleRelations(recognizerType);
+            StringBuilder errors = new StringBuilder();
+            foreach (Tuple<RuleDependencyAttribute, ICustomAttributeProvider> dependency in dependencies)
+            {
+                if (!dependency.Item1.Recognizer.GetTypeInfo().IsAssignableFrom(recognizerType))
+                {
+                    continue;
+                }
+                // this is the rule in the dependency set with the highest version number
+                int effectiveRule = dependency.Item1.Rule;
+                if (effectiveRule < 0 || effectiveRule >= ruleVersions.Length)
+                {
+                    string message = string.Format("Rule dependency on unknown rule {0}@{1} in {2}", dependency.Item1.Rule, dependency.Item1.Version, dependency.Item1.Recognizer.ToString());
+                    errors.AppendLine(dependency.Item2.ToString());
+                    errors.AppendLine(message);
+                    continue;
+                }
+                Dependents dependents = Dependents.Self | dependency.Item1.Dependents;
+                ReportUnimplementedDependents(errors, dependency, dependents);
+                BitSet @checked = new BitSet();
+                int highestRequiredDependency = CheckDependencyVersion(errors, dependency, ruleNames, ruleVersions, effectiveRule, null);
+                if ((dependents & Dependents.Parents) != 0)
+                {
+                    BitSet parents = relations.parents[dependency.Item1.Rule];
+                    for (int parent = parents.NextSetBit(0); parent >= 0; parent = parents.NextSetBit(parent + 1))
+                    {
+                        if (parent < 0 || parent >= ruleVersions.Length || @checked.Get(parent))
+                        {
+                            continue;
+                        }
+                        @checked.Set(parent);
+                        int required = CheckDependencyVersion(errors, dependency, ruleNames, ruleVersions, parent, "parent");
+                        highestRequiredDependency = Math.Max(highestRequiredDependency, required);
+                    }
+                }
+                if ((dependents & Dependents.Children) != 0)
+                {
+                    BitSet children = relations.children[dependency.Item1.Rule];
+                    for (int child = children.NextSetBit(0); child >= 0; child = children.NextSetBit(child + 1))
+                    {
+                        if (child < 0 || child >= ruleVersions.Length || @checked.Get(child))
+                        {
+                            continue;
+                        }
+                        @checked.Set(child);
+                        int required = CheckDependencyVersion(errors, dependency, ruleNames, ruleVersions, child, "child");
+                        highestRequiredDependency = Math.Max(highestRequiredDependency, required);
+                    }
+                }
+                if ((dependents & Dependents.Ancestors) != 0)
+                {
+                    BitSet ancestors = relations.GetAncestors(dependency.Item1.Rule);
+                    for (int ancestor = ancestors.NextSetBit(0); ancestor >= 0; ancestor = ancestors.NextSetBit(ancestor + 1))
+                    {
+                        if (ancestor < 0 || ancestor >= ruleVersions.Length || @checked.Get(ancestor))
+                        {
+                            continue;
+                        }
+                        @checked.Set(ancestor);
+                        int required = CheckDependencyVersion(errors, dependency, ruleNames, ruleVersions, ancestor, "ancestor");
+                        highestRequiredDependency = Math.Max(highestRequiredDependency, required);
+                    }
+                }
+                if ((dependents & Dependents.Descendants) != 0)
+                {
+                    BitSet descendants = relations.GetDescendants(dependency.Item1.Rule);
+                    for (int descendant = descendants.NextSetBit(0); descendant >= 0; descendant = descendants.NextSetBit(descendant + 1))
+                    {
+                        if (descendant < 0 || descendant >= ruleVersions.Length || @checked.Get(descendant))
+                        {
+                            continue;
+                        }
+                        @checked.Set(descendant);
+                        int required = CheckDependencyVersion(errors, dependency, ruleNames, ruleVersions, descendant, "descendant");
+                        highestRequiredDependency = Math.Max(highestRequiredDependency, required);
+                    }
+                }
+                int declaredVersion = dependency.Item1.Version;
+                if (declaredVersion > highestRequiredDependency)
+                {
+                    string message = string.Format("Rule dependency version mismatch: {0} has maximum dependency version {1} (expected {2}) in {3}", ruleNames[dependency.Item1.Rule], highestRequiredDependency, declaredVersion, dependency.Item1.Recognizer.ToString());
+                    errors.AppendLine(dependency.Item2.ToString());
+                    errors.AppendLine(message);
+                }
+            }
+            if (errors.Length > 0)
+            {
+                throw new InvalidOperationException(errors.ToString());
+            }
+        }
+
+        private static readonly Dependents ImplementedDependents = Dependents.Self | Dependents.Parents | Dependents.Children | Dependents.Ancestors | Dependents.Descendants;
+
+        private static void ReportUnimplementedDependents(StringBuilder errors, Tuple<RuleDependencyAttribute, ICustomAttributeProvider> dependency, Dependents dependents)
+        {
+            Dependents unimplemented = dependents;
+            unimplemented &= ~ImplementedDependents;
+            if (unimplemented != Dependents.None)
+            {
+                string message = string.Format("Cannot validate the following dependents of rule {0}: {1}", dependency.Item1.Rule, unimplemented);
+                errors.AppendLine(message);
+            }
+        }
+
+        private static int CheckDependencyVersion(StringBuilder errors, Tuple<RuleDependencyAttribute, ICustomAttributeProvider> dependency, string[] ruleNames, int[] ruleVersions, int relatedRule, string relation)
+        {
+            string ruleName = ruleNames[dependency.Item1.Rule];
+            string path;
+            if (relation == null)
+            {
+                path = ruleName;
+            }
+            else
+            {
+                string mismatchedRuleName = ruleNames[relatedRule];
+                path = string.Format("rule {0} ({1} of {2})", mismatchedRuleName, relation, ruleName);
+            }
+            int declaredVersion = dependency.Item1.Version;
+            int actualVersion = ruleVersions[relatedRule];
+            if (actualVersion > declaredVersion)
+            {
+                string message = string.Format("Rule dependency version mismatch: {0} has version {1} (expected <= {2}) in {3}", path, actualVersion, declaredVersion, dependency.Item1.Recognizer.ToString());
+                errors.AppendLine(dependency.Item2.ToString());
+                errors.AppendLine(message);
+            }
+            return actualVersion;
+        }
+
+        private static int[] GetRuleVersions(TypeInfo recognizerClass, string[] ruleNames)
+        {
+            int[] versions = new int[ruleNames.Length];
+            IEnumerable<FieldInfo> fields = recognizerClass.DeclaredFields;
+            foreach (FieldInfo field in fields)
+            {
+                bool isStatic = field.IsStatic;
+                bool isInteger = field.FieldType == typeof(int);
+                if (isStatic && isInteger && field.Name.StartsWith("RULE_"))
+                {
+                    try
+                    {
+                        string name = field.Name.Substring("RULE_".Length);
+                        if (name.Length == 0 || !System.Char.IsLower(name[0]))
+                        {
+                            continue;
+                        }
+                        int index = (int)field.GetValue(null);
+                        if (index < 0 || index >= versions.Length)
+                        {
+                            object[] @params = new object[] { index, field.Name, recognizerClass.Name };
+#if false
+                            Logger.Log(Level.Warning, "Rule index {0} for rule ''{1}'' out of bounds for recognizer {2}.", @params);
+#endif
+                            continue;
+                        }
+                        MethodInfo ruleMethod = GetRuleMethod(recognizerClass, name);
+                        if (ruleMethod == null)
+                        {
+                            object[] @params = new object[] { name, recognizerClass.Name };
+#if false
+                            Logger.Log(Level.Warning, "Could not find rule method for rule ''{0}'' in recognizer {1}.", @params);
+#endif
+                            continue;
+                        }
+                        RuleVersionAttribute ruleVersion = ruleMethod.GetCustomAttribute<RuleVersionAttribute>();
+                        int version = ruleVersion != null ? ruleVersion.Version : 0;
+                        versions[index] = version;
+                    }
+                    catch (ArgumentException)
+                    {
+#if false
+                        Logger.Log(Level.Warning, null, ex);
+#else
+                        throw;
+#endif
+                    }
+                    catch (MemberAccessException)
+                    {
+#if false
+                        Logger.Log(Level.Warning, null, ex);
+#else
+                        throw;
+#endif
+                    }
+                }
+            }
+            return versions;
+        }
+
+        private static MethodInfo GetRuleMethod(TypeInfo recognizerClass, string name)
+        {
+            IEnumerable<MethodInfo> declaredMethods = recognizerClass.DeclaredMethods;
+            foreach (MethodInfo method in declaredMethods)
+            {
+                if (method.Name.Equals(name) && method.GetCustomAttribute<RuleVersionAttribute>() != null)
+                {
+                    return method;
+                }
+            }
+            return null;
+        }
+
+        private static string[] GetRuleNames(TypeInfo recognizerClass)
+        {
+            FieldInfo ruleNames = recognizerClass.DeclaredFields.First(i => i.Name == "ruleNames");
+            return (string[])ruleNames.GetValue(null);
+        }
+
+        public static IList<Tuple<RuleDependencyAttribute, ICustomAttributeProvider>> GetDependencies(TypeInfo clazz)
+        {
+            IList<Tuple<RuleDependencyAttribute, ICustomAttributeProvider>> result = new List<Tuple<RuleDependencyAttribute, ICustomAttributeProvider>>();
+
+            GetElementDependencies(AsCustomAttributeProvider(clazz), result);
+            foreach (ConstructorInfo ctor in clazz.DeclaredConstructors)
+            {
+                GetElementDependencies(AsCustomAttributeProvider(ctor), result);
+                foreach (ParameterInfo parameter in ctor.GetParameters())
+                    GetElementDependencies(AsCustomAttributeProvider(parameter), result);
+            }
+
+            foreach (FieldInfo field in clazz.DeclaredFields)
+            {
+                GetElementDependencies(AsCustomAttributeProvider(field), result);
+            }
+
+            foreach (MethodInfo method in clazz.DeclaredMethods)
+            {
+                GetElementDependencies(AsCustomAttributeProvider(method), result);
+#if COMPACT
+                if (method.ReturnTypeCustomAttributes != null)
+                    GetElementDependencies(AsCustomAttributeProvider(method.ReturnTypeCustomAttributes), result);
+#else
+                if (method.ReturnParameter != null)
+                    GetElementDependencies(AsCustomAttributeProvider(method.ReturnParameter), result);
+#endif
+
+                foreach (ParameterInfo parameter in method.GetParameters())
+                    GetElementDependencies(AsCustomAttributeProvider(parameter), result);
+            }
+
+            return result;
+        }
+
+        private static void GetElementDependencies(ICustomAttributeProvider annotatedElement, IList<Tuple<RuleDependencyAttribute, ICustomAttributeProvider>> result)
+        {
+            foreach (RuleDependencyAttribute dependency in annotatedElement.GetCustomAttributes(typeof(RuleDependencyAttribute), true))
+            {
+                result.Add(Tuple.Create(dependency, annotatedElement));
+            }
+        }
+
+        private static RuleDependencyChecker.RuleRelations ExtractRuleRelations(TypeInfo recognizer)
+        {
+            string serializedATN = GetSerializedATN(recognizer);
+            if (serializedATN == null)
+            {
+                return null;
+            }
+            ATN atn = new ATNDeserializer().Deserialize(serializedATN.ToCharArray());
+            RuleDependencyChecker.RuleRelations relations = new RuleDependencyChecker.RuleRelations(atn.ruleToStartState.Length);
+            foreach (ATNState state in atn.states)
+            {
+                if (!state.epsilonOnlyTransitions)
+                {
+                    continue;
+                }
+                foreach (Transition transition in state.transitions)
+                {
+                    if (transition.TransitionType != TransitionType.Rule)
+                    {
+                        continue;
+                    }
+                    RuleTransition ruleTransition = (RuleTransition)transition;
+                    relations.AddRuleInvocation(state.ruleIndex, ruleTransition.target.ruleIndex);
+                }
+            }
+            return relations;
+        }
+
+        private static string GetSerializedATN(TypeInfo recognizerClass)
+        {
+            FieldInfo serializedAtnField = recognizerClass.DeclaredFields.First(i => i.Name == "_serializedATN");
+            if (serializedAtnField != null)
+                return (string)serializedAtnField.GetValue(null);
+
+            if (recognizerClass.BaseType != null)
+                return GetSerializedATN(recognizerClass.BaseType.GetTypeInfo());
+
+            return null;
+        }
+
+        private sealed class RuleRelations
+        {
+            public readonly BitSet[] parents;
+
+            public readonly BitSet[] children;
+
+            public RuleRelations(int ruleCount)
+            {
+                parents = new BitSet[ruleCount];
+                for (int i = 0; i < ruleCount; i++)
+                {
+                    parents[i] = new BitSet();
+                }
+                children = new BitSet[ruleCount];
+                for (int i_1 = 0; i_1 < ruleCount; i_1++)
+                {
+                    children[i_1] = new BitSet();
+                }
+            }
+
+            public bool AddRuleInvocation(int caller, int callee)
+            {
+                if (caller < 0)
+                {
+                    // tokens rule
+                    return false;
+                }
+                if (children[caller].Get(callee))
+                {
+                    // already added
+                    return false;
+                }
+                children[caller].Set(callee);
+                parents[callee].Set(caller);
+                return true;
+            }
+
+            public BitSet GetAncestors(int rule)
+            {
+                BitSet ancestors = new BitSet();
+                ancestors.Or(parents[rule]);
+                while (true)
+                {
+                    int cardinality = ancestors.Cardinality();
+                    for (int i = ancestors.NextSetBit(0); i >= 0; i = ancestors.NextSetBit(i + 1))
+                    {
+                        ancestors.Or(parents[i]);
+                    }
+                    if (ancestors.Cardinality() == cardinality)
+                    {
+                        // nothing changed
+                        break;
+                    }
+                }
+                return ancestors;
+            }
+
+            public BitSet GetDescendants(int rule)
+            {
+                BitSet descendants = new BitSet();
+                descendants.Or(children[rule]);
+                while (true)
+                {
+                    int cardinality = descendants.Cardinality();
+                    for (int i = descendants.NextSetBit(0); i >= 0; i = descendants.NextSetBit(i + 1))
+                    {
+                        descendants.Or(children[i]);
+                    }
+                    if (descendants.Cardinality() == cardinality)
+                    {
+                        // nothing changed
+                        break;
+                    }
+                }
+                return descendants;
+            }
+        }
+
+        private RuleDependencyChecker()
+        {
+        }
+
+#if PORTABLE
+        public interface ICustomAttributeProvider
+        {
+            object[] GetCustomAttributes(Type attributeType, bool inherit);
+        }
+
+        protected static ICustomAttributeProvider AsCustomAttributeProvider(TypeInfo type)
+        {
+            return new TypeCustomAttributeProvider(type);
+        }
+
+        protected static ICustomAttributeProvider AsCustomAttributeProvider(MethodBase method)
+        {
+            return new MethodBaseCustomAttributeProvider(method);
+        }
+
+        protected static ICustomAttributeProvider AsCustomAttributeProvider(ParameterInfo parameter)
+        {
+            return new ParameterInfoCustomAttributeProvider(parameter);
+        }
+
+        protected static ICustomAttributeProvider AsCustomAttributeProvider(FieldInfo field)
+        {
+            return new FieldInfoCustomAttributeProvider(field);
+        }
+
+        protected sealed class TypeCustomAttributeProvider : ICustomAttributeProvider
+        {
+            private readonly TypeInfo _provider;
+
+            public TypeCustomAttributeProvider(TypeInfo provider)
+            {
+                _provider = provider;
+            }
+
+            public object[] GetCustomAttributes(Type attributeType, bool inherit)
+            {
+                return _provider.GetCustomAttributes(attributeType, inherit).ToArray();
+            }
+        }
+
+        protected sealed class MethodBaseCustomAttributeProvider : ICustomAttributeProvider
+        {
+            private readonly MethodBase _provider;
+
+            public MethodBaseCustomAttributeProvider(MethodBase provider)
+            {
+                _provider = provider;
+            }
+
+            public object[] GetCustomAttributes(Type attributeType, bool inherit)
+            {
+                return _provider.GetCustomAttributes(attributeType, inherit).ToArray();
+            }
+        }
+
+        protected sealed class ParameterInfoCustomAttributeProvider : ICustomAttributeProvider
+        {
+            private readonly ParameterInfo _provider;
+
+            public ParameterInfoCustomAttributeProvider(ParameterInfo provider)
+            {
+                _provider = provider;
+            }
+
+            public object[] GetCustomAttributes(Type attributeType, bool inherit)
+            {
+                return _provider.GetCustomAttributes(attributeType, inherit).ToArray();
+            }
+        }
+
+        protected sealed class FieldInfoCustomAttributeProvider : ICustomAttributeProvider
+        {
+            private readonly FieldInfo _provider;
+
+            public FieldInfoCustomAttributeProvider(FieldInfo provider)
+            {
+                _provider = provider;
+            }
+
+            public object[] GetCustomAttributes(Type attributeType, bool inherit)
+            {
+                return _provider.GetCustomAttributes(attributeType, inherit).ToArray();
+            }
+        }
+#else
+        protected static ICustomAttributeProvider AsCustomAttributeProvider(ICustomAttributeProvider obj)
+        {
+            return obj;
+        }
+#endif
+    }
+}
+
+#else
+
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Security;
+using System.Text;
+using Antlr4.Runtime;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Misc
+{
+    /// <author>Sam Harwell</author>
+    public class RuleDependencyChecker
+    {
+#if false
+        private static readonly Logger Logger = Logger.GetLogger(typeof(Antlr4.Runtime.Misc.RuleDependencyChecker).FullName);
+#endif
+
+        private const BindingFlags AllDeclaredStaticMembers = BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static;
+        private const BindingFlags AllDeclaredMembers = AllDeclaredStaticMembers | BindingFlags.Instance;
+        private static readonly HashSet<string> checkedAssemblies = new HashSet<string>();
+
+        public static void CheckDependencies(Assembly assembly)
+        {
+            if (IsChecked(assembly))
+            {
+                return;
+            }
+
+            IList<Type> typesToCheck = GetTypesToCheck(assembly);
+            List<Tuple<RuleDependencyAttribute, ICustomAttributeProvider>> dependencies = new List<Tuple<RuleDependencyAttribute, ICustomAttributeProvider>>();
+            foreach (Type clazz in typesToCheck)
+            {
+                dependencies.AddRange(GetDependencies(clazz));
+            }
+
+            if (dependencies.Count > 0)
+            {
+                IDictionary<Type, IList<Tuple<RuleDependencyAttribute, ICustomAttributeProvider>>> recognizerDependencies = new Dictionary<Type, IList<Tuple<RuleDependencyAttribute, ICustomAttributeProvider>>>();
+                foreach (Tuple<RuleDependencyAttribute, ICustomAttributeProvider> dependency in dependencies)
+                {
+                    Type recognizerType = dependency.Item1.Recognizer;
+                    IList<Tuple<RuleDependencyAttribute, ICustomAttributeProvider>> list;
+                    if (!recognizerDependencies.TryGetValue(recognizerType, out list))
+                    {
+                        list = new List<Tuple<RuleDependencyAttribute, ICustomAttributeProvider>>();
+                        recognizerDependencies[recognizerType] = list;
+                    }
+                    list.Add(dependency);
+                }
+
+                foreach (KeyValuePair<Type, IList<Tuple<RuleDependencyAttribute, ICustomAttributeProvider>>> entry in recognizerDependencies)
+                {
+                    //processingEnv.getMessager().printMessage(Diagnostic.Kind.NOTE, String.format("ANTLR 4: Validating {0} dependencies on rules in {1}.", entry.getValue().size(), entry.getKey().toString()));
+                    CheckDependencies(entry.Value, entry.Key);
+                }
+            }
+
+            MarkChecked(assembly);
+        }
+
+        private static IList<Type> GetTypesToCheck(Assembly assembly)
+        {
+            return assembly.GetTypes();
+        }
+
+        private static bool IsChecked(Assembly assembly)
+        {
+            lock (checkedAssemblies)
+            {
+                return checkedAssemblies.Contains(assembly.FullName);
+            }
+        }
+
+        private static void MarkChecked(Assembly assembly)
+        {
+            lock (checkedAssemblies)
+            {
+                checkedAssemblies.Add(assembly.FullName);
+            }
+        }
+
+        private static void CheckDependencies(IList<Tuple<RuleDependencyAttribute, ICustomAttributeProvider>> dependencies, Type recognizerType)
+        {
+            string[] ruleNames = GetRuleNames(recognizerType);
+            int[] ruleVersions = GetRuleVersions(recognizerType, ruleNames);
+            RuleDependencyChecker.RuleRelations relations = ExtractRuleRelations(recognizerType);
+            StringBuilder errors = new StringBuilder();
+            foreach (Tuple<RuleDependencyAttribute, ICustomAttributeProvider> dependency in dependencies)
+            {
+                if (!dependency.Item1.Recognizer.IsAssignableFrom(recognizerType))
+                {
+                    continue;
+                }
+                // this is the rule in the dependency set with the highest version number
+                int effectiveRule = dependency.Item1.Rule;
+                if (effectiveRule < 0 || effectiveRule >= ruleVersions.Length)
+                {
+                    string message = string.Format("Rule dependency on unknown rule {0}@{1} in {2}", dependency.Item1.Rule, dependency.Item1.Version, dependency.Item1.Recognizer.ToString());
+                    errors.AppendLine(dependency.Item2.ToString());
+                    errors.AppendLine(message);
+                    continue;
+                }
+                Dependents dependents = Dependents.Self | dependency.Item1.Dependents;
+                ReportUnimplementedDependents(errors, dependency, dependents);
+                BitSet @checked = new BitSet();
+                int highestRequiredDependency = CheckDependencyVersion(errors, dependency, ruleNames, ruleVersions, effectiveRule, null);
+                if ((dependents & Dependents.Parents) != 0)
+                {
+                    BitSet parents = relations.parents[dependency.Item1.Rule];
+                    for (int parent = parents.NextSetBit(0); parent >= 0; parent = parents.NextSetBit(parent + 1))
+                    {
+                        if (parent < 0 || parent >= ruleVersions.Length || @checked.Get(parent))
+                        {
+                            continue;
+                        }
+                        @checked.Set(parent);
+                        int required = CheckDependencyVersion(errors, dependency, ruleNames, ruleVersions, parent, "parent");
+                        highestRequiredDependency = Math.Max(highestRequiredDependency, required);
+                    }
+                }
+                if ((dependents & Dependents.Children) != 0)
+                {
+                    BitSet children = relations.children[dependency.Item1.Rule];
+                    for (int child = children.NextSetBit(0); child >= 0; child = children.NextSetBit(child + 1))
+                    {
+                        if (child < 0 || child >= ruleVersions.Length || @checked.Get(child))
+                        {
+                            continue;
+                        }
+                        @checked.Set(child);
+                        int required = CheckDependencyVersion(errors, dependency, ruleNames, ruleVersions, child, "child");
+                        highestRequiredDependency = Math.Max(highestRequiredDependency, required);
+                    }
+                }
+                if ((dependents & Dependents.Ancestors) != 0)
+                {
+                    BitSet ancestors = relations.GetAncestors(dependency.Item1.Rule);
+                    for (int ancestor = ancestors.NextSetBit(0); ancestor >= 0; ancestor = ancestors.NextSetBit(ancestor + 1))
+                    {
+                        if (ancestor < 0 || ancestor >= ruleVersions.Length || @checked.Get(ancestor))
+                        {
+                            continue;
+                        }
+                        @checked.Set(ancestor);
+                        int required = CheckDependencyVersion(errors, dependency, ruleNames, ruleVersions, ancestor, "ancestor");
+                        highestRequiredDependency = Math.Max(highestRequiredDependency, required);
+                    }
+                }
+                if ((dependents & Dependents.Descendants) != 0)
+                {
+                    BitSet descendants = relations.GetDescendants(dependency.Item1.Rule);
+                    for (int descendant = descendants.NextSetBit(0); descendant >= 0; descendant = descendants.NextSetBit(descendant + 1))
+                    {
+                        if (descendant < 0 || descendant >= ruleVersions.Length || @checked.Get(descendant))
+                        {
+                            continue;
+                        }
+                        @checked.Set(descendant);
+                        int required = CheckDependencyVersion(errors, dependency, ruleNames, ruleVersions, descendant, "descendant");
+                        highestRequiredDependency = Math.Max(highestRequiredDependency, required);
+                    }
+                }
+                int declaredVersion = dependency.Item1.Version;
+                if (declaredVersion > highestRequiredDependency)
+                {
+                    string message = string.Format("Rule dependency version mismatch: {0} has maximum dependency version {1} (expected {2}) in {3}", ruleNames[dependency.Item1.Rule], highestRequiredDependency, declaredVersion, dependency.Item1.Recognizer.ToString());
+                    errors.AppendLine(dependency.Item2.ToString());
+                    errors.AppendLine(message);
+                }
+            }
+            if (errors.Length > 0)
+            {
+                throw new InvalidOperationException(errors.ToString());
+            }
+        }
+
+        private static readonly Dependents ImplementedDependents = Dependents.Self | Dependents.Parents | Dependents.Children | Dependents.Ancestors | Dependents.Descendants;
+
+        private static void ReportUnimplementedDependents(StringBuilder errors, Tuple<RuleDependencyAttribute, ICustomAttributeProvider> dependency, Dependents dependents)
+        {
+            Dependents unimplemented = dependents;
+            unimplemented &= ~ImplementedDependents;
+            if (unimplemented != Dependents.None)
+            {
+                string message = string.Format("Cannot validate the following dependents of rule {0}: {1}", dependency.Item1.Rule, unimplemented);
+                errors.AppendLine(message);
+            }
+        }
+
+        private static int CheckDependencyVersion(StringBuilder errors, Tuple<RuleDependencyAttribute, ICustomAttributeProvider> dependency, string[] ruleNames, int[] ruleVersions, int relatedRule, string relation)
+        {
+            string ruleName = ruleNames[dependency.Item1.Rule];
+            string path;
+            if (relation == null)
+            {
+                path = ruleName;
+            }
+            else
+            {
+                string mismatchedRuleName = ruleNames[relatedRule];
+                path = string.Format("rule {0} ({1} of {2})", mismatchedRuleName, relation, ruleName);
+            }
+            int declaredVersion = dependency.Item1.Version;
+            int actualVersion = ruleVersions[relatedRule];
+            if (actualVersion > declaredVersion)
+            {
+                string message = string.Format("Rule dependency version mismatch: {0} has version {1} (expected <= {2}) in {3}", path, actualVersion, declaredVersion, dependency.Item1.Recognizer.ToString());
+                errors.AppendLine(dependency.Item2.ToString());
+                errors.AppendLine(message);
+            }
+            return actualVersion;
+        }
+
+        private static int[] GetRuleVersions(Type recognizerClass, string[] ruleNames)
+        {
+            int[] versions = new int[ruleNames.Length];
+            FieldInfo[] fields = recognizerClass.GetFields();
+            foreach (FieldInfo field in fields)
+            {
+                bool isStatic = field.IsStatic;
+                bool isInteger = field.FieldType == typeof(int);
+                if (isStatic && isInteger && field.Name.StartsWith("RULE_"))
+                {
+                    try
+                    {
+                        string name = field.Name.Substring("RULE_".Length);
+                        if (name.Length == 0 || !System.Char.IsLower(name[0]))
+                        {
+                            continue;
+                        }
+                        int index = (int)field.GetValue(null);
+                        if (index < 0 || index >= versions.Length)
+                        {
+#if false
+							object[] @params = new object[] { index, field.Name, recognizerClass.Name };
+                            Logger.Log(Level.Warning, "Rule index {0} for rule ''{1}'' out of bounds for recognizer {2}.", @params);
+#endif
+                            continue;
+                        }
+                        MethodInfo ruleMethod = GetRuleMethod(recognizerClass, name);
+                        if (ruleMethod == null)
+                        {
+#if false
+							object[] @params = new object[] { name, recognizerClass.Name };
+                            Logger.Log(Level.Warning, "Could not find rule method for rule ''{0}'' in recognizer {1}.", @params);
+#endif
+                            continue;
+                        }
+                        RuleVersionAttribute ruleVersion = (RuleVersionAttribute)Attribute.GetCustomAttribute(ruleMethod, typeof(RuleVersionAttribute));
+                        int version = ruleVersion != null ? ruleVersion.Version : 0;
+                        versions[index] = version;
+                    }
+                    catch (ArgumentException)
+                    {
+#if false
+                        Logger.Log(Level.Warning, null, ex);
+#else
+                        throw;
+#endif
+                    }
+                    catch (MemberAccessException)
+                    {
+#if false
+                        Logger.Log(Level.Warning, null, ex);
+#else
+                        throw;
+#endif
+                    }
+                }
+            }
+            return versions;
+        }
+
+        private static MethodInfo GetRuleMethod(Type recognizerClass, string name)
+        {
+            MethodInfo[] declaredMethods = recognizerClass.GetMethods();
+            foreach (MethodInfo method in declaredMethods)
+            {
+                if (method.Name.Equals(name) && Attribute.IsDefined(method, typeof(RuleVersionAttribute)))
+                {
+                    return method;
+                }
+            }
+            return null;
+        }
+
+        private static string[] GetRuleNames(Type recognizerClass)
+        {
+            FieldInfo ruleNames = recognizerClass.GetField("ruleNames");
+            return (string[])ruleNames.GetValue(null);
+        }
+
+        public static IList<Tuple<RuleDependencyAttribute, ICustomAttributeProvider>> GetDependencies(Type clazz)
+        {
+            IList<Tuple<RuleDependencyAttribute, ICustomAttributeProvider>> result = new List<Tuple<RuleDependencyAttribute, ICustomAttributeProvider>>();
+
+            GetElementDependencies(AsCustomAttributeProvider(clazz), result);
+            foreach (ConstructorInfo ctor in clazz.GetConstructors(AllDeclaredMembers))
+            {
+                GetElementDependencies(AsCustomAttributeProvider(ctor), result);
+                foreach (ParameterInfo parameter in ctor.GetParameters())
+                    GetElementDependencies(AsCustomAttributeProvider(parameter), result);
+            }
+
+            foreach (FieldInfo field in clazz.GetFields(AllDeclaredMembers))
+            {
+                GetElementDependencies(AsCustomAttributeProvider(field), result);
+            }
+
+            foreach (MethodInfo method in clazz.GetMethods(AllDeclaredMembers))
+            {
+                GetElementDependencies(AsCustomAttributeProvider(method), result);
+#if COMPACT
+                if (method.ReturnTypeCustomAttributes != null)
+                    GetElementDependencies(AsCustomAttributeProvider(method.ReturnTypeCustomAttributes), result);
+#else
+                if (method.ReturnParameter != null)
+                    GetElementDependencies(AsCustomAttributeProvider(method.ReturnParameter), result);
+#endif
+
+                foreach (ParameterInfo parameter in method.GetParameters())
+                    GetElementDependencies(AsCustomAttributeProvider(parameter), result);
+            }
+
+            return result;
+        }
+
+        private static void GetElementDependencies(ICustomAttributeProvider annotatedElement, IList<Tuple<RuleDependencyAttribute, ICustomAttributeProvider>> result)
+        {
+            foreach (RuleDependencyAttribute dependency in annotatedElement.GetCustomAttributes(typeof(RuleDependencyAttribute), true))
+            {
+                result.Add(Tuple.Create(dependency, annotatedElement));
+            }
+        }
+
+        private static RuleDependencyChecker.RuleRelations ExtractRuleRelations(Type recognizer)
+        {
+            string serializedATN = GetSerializedATN(recognizer);
+            if (serializedATN == null)
+            {
+                return null;
+            }
+            ATN atn = new ATNDeserializer().Deserialize(serializedATN.ToCharArray());
+            RuleDependencyChecker.RuleRelations relations = new RuleDependencyChecker.RuleRelations(atn.ruleToStartState.Length);
+            foreach (ATNState state in atn.states)
+            {
+                if (!state.epsilonOnlyTransitions)
+                {
+                    continue;
+                }
+                foreach (Transition transition in state.transitions)
+                {
+                    if (transition.TransitionType != TransitionType.Rule)
+                    {
+                        continue;
+                    }
+                    RuleTransition ruleTransition = (RuleTransition)transition;
+                    relations.AddRuleInvocation(state.ruleIndex, ruleTransition.target.ruleIndex);
+                }
+            }
+            return relations;
+        }
+
+        private static string GetSerializedATN(Type recognizerClass)
+        {
+            FieldInfo serializedAtnField = recognizerClass.GetField("_serializedATN", AllDeclaredStaticMembers);
+            if (serializedAtnField != null)
+                return (string)serializedAtnField.GetValue(null);
+
+            if (recognizerClass.BaseType != null)
+                return GetSerializedATN(recognizerClass.BaseType);
+
+            return null;
+        }
+
+        private sealed class RuleRelations
+        {
+            public readonly BitSet[] parents;
+
+            public readonly BitSet[] children;
+
+            public RuleRelations(int ruleCount)
+            {
+                parents = new BitSet[ruleCount];
+                for (int i = 0; i < ruleCount; i++)
+                {
+                    parents[i] = new BitSet();
+                }
+                children = new BitSet[ruleCount];
+                for (int i_1 = 0; i_1 < ruleCount; i_1++)
+                {
+                    children[i_1] = new BitSet();
+                }
+            }
+
+            public bool AddRuleInvocation(int caller, int callee)
+            {
+                if (caller < 0)
+                {
+                    // tokens rule
+                    return false;
+                }
+                if (children[caller].Get(callee))
+                {
+                    // already added
+                    return false;
+                }
+                children[caller].Set(callee);
+                parents[callee].Set(caller);
+                return true;
+            }
+
+            public BitSet GetAncestors(int rule)
+            {
+                BitSet ancestors = new BitSet();
+                ancestors.Or(parents[rule]);
+                while (true)
+                {
+                    int cardinality = ancestors.Cardinality();
+                    for (int i = ancestors.NextSetBit(0); i >= 0; i = ancestors.NextSetBit(i + 1))
+                    {
+                        ancestors.Or(parents[i]);
+                    }
+                    if (ancestors.Cardinality() == cardinality)
+                    {
+                        // nothing changed
+                        break;
+                    }
+                }
+                return ancestors;
+            }
+
+            public BitSet GetDescendants(int rule)
+            {
+                BitSet descendants = new BitSet();
+                descendants.Or(children[rule]);
+                while (true)
+                {
+                    int cardinality = descendants.Cardinality();
+                    for (int i = descendants.NextSetBit(0); i >= 0; i = descendants.NextSetBit(i + 1))
+                    {
+                        descendants.Or(children[i]);
+                    }
+                    if (descendants.Cardinality() == cardinality)
+                    {
+                        // nothing changed
+                        break;
+                    }
+                }
+                return descendants;
+            }
+        }
+
+        private RuleDependencyChecker()
+        {
+        }
+
+#if PORTABLE
+        public interface ICustomAttributeProvider
+        {
+            object[] GetCustomAttributes(Type attributeType, bool inherit);
+        }
+
+        protected static ICustomAttributeProvider AsCustomAttributeProvider(Type type)
+        {
+            return new TypeCustomAttributeProvider(type);
+        }
+
+        protected static ICustomAttributeProvider AsCustomAttributeProvider(MethodBase method)
+        {
+            return new MethodBaseCustomAttributeProvider(method);
+        }
+
+        protected static ICustomAttributeProvider AsCustomAttributeProvider(ParameterInfo parameter)
+        {
+            return new ParameterInfoCustomAttributeProvider(parameter);
+        }
+
+        protected static ICustomAttributeProvider AsCustomAttributeProvider(FieldInfo field)
+        {
+            return new FieldInfoCustomAttributeProvider(field);
+        }
+
+        protected sealed class TypeCustomAttributeProvider : ICustomAttributeProvider
+        {
+            private readonly Type _provider;
+
+            public TypeCustomAttributeProvider(Type provider)
+            {
+                _provider = provider;
+            }
+
+            public object[] GetCustomAttributes(Type attributeType, bool inherit)
+            {
+                return Attribute.GetCustomAttributes(_provider, attributeType, inherit);
+            }
+        }
+
+        protected sealed class MethodBaseCustomAttributeProvider : ICustomAttributeProvider
+        {
+            private readonly MethodBase _provider;
+
+            public MethodBaseCustomAttributeProvider(MethodBase provider)
+            {
+                _provider = provider;
+            }
+
+            public object[] GetCustomAttributes(Type attributeType, bool inherit)
+            {
+                return Attribute.GetCustomAttributes(_provider, attributeType, inherit);
+            }
+        }
+
+        protected sealed class ParameterInfoCustomAttributeProvider : ICustomAttributeProvider
+        {
+            private readonly ParameterInfo _provider;
+
+            public ParameterInfoCustomAttributeProvider(ParameterInfo provider)
+            {
+                _provider = provider;
+            }
+
+            public object[] GetCustomAttributes(Type attributeType, bool inherit)
+            {
+                return Attribute.GetCustomAttributes(_provider, attributeType, inherit);
+            }
+        }
+
+        protected sealed class FieldInfoCustomAttributeProvider : ICustomAttributeProvider
+        {
+            private readonly FieldInfo _provider;
+
+            public FieldInfoCustomAttributeProvider(FieldInfo provider)
+            {
+                _provider = provider;
+            }
+
+            public object[] GetCustomAttributes(Type attributeType, bool inherit)
+            {
+                return Attribute.GetCustomAttributes(_provider, attributeType, inherit);
+            }
+        }
+#else
+        protected static ICustomAttributeProvider AsCustomAttributeProvider(ICustomAttributeProvider obj)
+        {
+            return obj;
+        }
+#endif
+    }
+}
+
+#endif
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Misc/Utils.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Misc/Utils.cs
new file mode 100644
index 000000000..7968d1783
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Misc/Utils.cs
@@ -0,0 +1,175 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Misc
+{
+    public class Utils
+    {
+        public static string Join<T>(string separator, IEnumerable<T> items)
+        {
+#if NET40PLUS
+            return string.Join(separator, items);
+#else
+            List<string> elements = new List<string>();
+            foreach (T item in items)
+            {
+                if (item == null)
+                    elements.Add("");
+                else
+                    elements.Add(item.ToString());
+            }
+
+            return string.Join(separator, elements.ToArray());
+#endif
+        }
+
+        public static int NumNonnull(object[] data)
+        {
+            int n = 0;
+            if (data == null)
+            {
+                return n;
+            }
+            foreach (object o in data)
+            {
+                if (o != null)
+                {
+                    n++;
+                }
+            }
+            return n;
+        }
+
+        public static void RemoveAllElements<T>(ICollection<T> data, T value)
+        {
+            if (data == null)
+            {
+                return;
+            }
+            while (data.Contains(value))
+            {
+                data.Remove(value);
+            }
+        }
+
+        public static string EscapeWhitespace(string s, bool escapeSpaces)
+        {
+            StringBuilder buf = new StringBuilder();
+            foreach (char c in s.ToCharArray())
+            {
+                if (c == ' ' && escapeSpaces)
+                {
+                    buf.Append('\u00B7');
+                }
+                else
+                {
+                    if (c == '\t')
+                    {
+                        buf.Append("\\t");
+                    }
+                    else
+                    {
+                        if (c == '\n')
+                        {
+                            buf.Append("\\n");
+                        }
+                        else
+                        {
+                            if (c == '\r')
+                            {
+                                buf.Append("\\r");
+                            }
+                            else
+                            {
+                                buf.Append(c);
+                            }
+                        }
+                    }
+                }
+            }
+            return buf.ToString();
+        }
+
+        public static void RemoveAll<T>(IList<T> list, Predicate<T> predicate)
+        {
+            int j = 0;
+            for (int i = 0; i < list.Count; i++)
+            {
+                T item = list[i];
+                if (!predicate(item))
+                {
+                    if (j != i)
+                    {
+                        list[j] = item;
+                    }
+                    j++;
+                }
+            }
+            while (j < list.Count)
+            {
+                list.RemoveAt(list.Count - 1);
+            }
+        }
+
+        /// <summary>Convert array of strings to string&#x2192;index map.</summary>
+        /// <remarks>
+        /// Convert array of strings to string&#x2192;index map. Useful for
+        /// converting rulenames to name&#x2192;ruleindex map.
+        /// </remarks>
+        public static IDictionary<string, int> ToMap(string[] keys)
+        {
+            IDictionary<string, int> m = new Dictionary<string, int>();
+            for (int i = 0; i < keys.Length; i++)
+            {
+                m[keys[i]] = i;
+            }
+            return m;
+        }
+
+        public static char[] ToCharArray(List<int> data)
+        {
+            if (data == null)
+            {
+                return null;
+            }
+            char[] cdata = new char[data.Count];
+            for (int i = 0; i < data.Count; i++)
+            {
+                cdata[i] = (char)data[i];
+            }
+            return cdata;
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/NoViableAltException.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/NoViableAltException.cs
new file mode 100644
index 000000000..48cc248c9
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/NoViableAltException.cs
@@ -0,0 +1,100 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime
+{
+    /// <summary>
+    /// Indicates that the parser could not decide which of two or more paths
+    /// to take based upon the remaining input.
+    /// </summary>
+    /// <remarks>
+    /// Indicates that the parser could not decide which of two or more paths
+    /// to take based upon the remaining input. It tracks the starting token
+    /// of the offending input and also knows where the parser was
+    /// in the various paths when the error. Reported by reportNoViableAlternative()
+    /// </remarks>
+    [System.Serializable]
+    public class NoViableAltException : RecognitionException
+    {
+        private const long serialVersionUID = 5096000008992867052L;
+
+        /// <summary>Which configurations did we try at input.index() that couldn't match input.LT(1)?</summary>
+        [Nullable]
+        private readonly ATNConfigSet deadEndConfigs;
+
+        /// <summary>
+        /// The token object at the start index; the input stream might
+        /// not be buffering tokens so get a reference to it.
+        /// </summary>
+        /// <remarks>
+        /// The token object at the start index; the input stream might
+        /// not be buffering tokens so get a reference to it. (At the
+        /// time the error occurred, of course the stream needs to keep a
+        /// buffer all of the tokens but later we might not have access to those.)
+        /// </remarks>
+        [NotNull]
+        private readonly IToken startToken;
+
+        public NoViableAltException(Parser recognizer)
+			: this(recognizer, ((ITokenStream)recognizer.InputStream), recognizer.CurrentToken, recognizer.CurrentToken, null, recognizer.RuleContext)
+        {
+        }
+
+        public NoViableAltException(IRecognizer recognizer, ITokenStream input, IToken startToken, IToken offendingToken, ATNConfigSet deadEndConfigs, ParserRuleContext ctx)
+            : base(recognizer, input, ctx)
+        {
+            // LL(1) error
+            this.deadEndConfigs = deadEndConfigs;
+            this.startToken = startToken;
+            this.OffendingToken = offendingToken;
+        }
+
+        public virtual IToken StartToken
+        {
+            get
+            {
+                return startToken;
+            }
+        }
+
+        [Nullable]
+        public virtual ATNConfigSet DeadEndConfigs
+        {
+            get
+            {
+                return deadEndConfigs;
+            }
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Parser.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Parser.cs
new file mode 100644
index 000000000..9df0b4270
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Parser.cs
@@ -0,0 +1,1274 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System;
+using System.Text;
+using System.Collections;
+using System.Collections.Generic;
+using Antlr4.Runtime;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Dfa;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+using Antlr4.Runtime.Tree;
+using Antlr4.Runtime.Tree.Pattern;
+
+namespace Antlr4.Runtime
+{
+    /// <summary>This is all the parsing support code essentially; most of it is error recovery stuff.</summary>
+    /// <remarks>This is all the parsing support code essentially; most of it is error recovery stuff.</remarks>
+    public abstract class Parser : Recognizer<IToken, ParserATNSimulator>
+    {
+#if !PORTABLE
+        public class TraceListener : IParseTreeListener
+        {
+            public virtual void EnterEveryRule(ParserRuleContext ctx)
+            {
+                System.Console.Out.WriteLine("enter   " + this._enclosing.RuleNames[ctx.RuleIndex] + ", LT(1)=" + this._enclosing._input.Lt(1).Text);
+            }
+
+            public virtual void ExitEveryRule(ParserRuleContext ctx)
+            {
+                System.Console.Out.WriteLine("exit    " + this._enclosing.RuleNames[ctx.RuleIndex] + ", LT(1)=" + this._enclosing._input.Lt(1).Text);
+            }
+
+            public virtual void VisitErrorNode(IErrorNode node)
+            {
+            }
+
+            public virtual void VisitTerminal(ITerminalNode node)
+            {
+                ParserRuleContext parent = (ParserRuleContext)((IRuleNode)node.Parent).RuleContext;
+                IToken token = node.Symbol;
+                System.Console.Out.WriteLine("consume " + token + " rule " + this._enclosing.RuleNames[parent.RuleIndex]);
+            }
+
+            internal TraceListener(Parser _enclosing)
+            {
+                this._enclosing = _enclosing;
+            }
+
+            private readonly Parser _enclosing;
+        }
+#endif
+
+        public class TrimToSizeListener : IParseTreeListener
+        {
+            public static readonly Parser.TrimToSizeListener Instance = new Parser.TrimToSizeListener();
+
+            public virtual void VisitTerminal(ITerminalNode node)
+            {
+            }
+
+            public virtual void VisitErrorNode(IErrorNode node)
+            {
+            }
+
+            public virtual void EnterEveryRule(ParserRuleContext ctx)
+            {
+            }
+
+            public virtual void ExitEveryRule(ParserRuleContext ctx)
+            {
+                if (ctx.children is List<IParseTree>)
+                {
+                    ((List<IParseTree>)ctx.children).TrimExcess();
+                }
+            }
+        }
+
+        /// <summary>
+        /// This field maps from the serialized ATN string to the deserialized
+        /// <see cref="Antlr4.Runtime.Atn.ATN"/>
+        /// with
+        /// bypass alternatives.
+        /// </summary>
+        /// <seealso cref="Antlr4.Runtime.Atn.ATNDeserializationOptions.GenerateRuleBypassTransitions()"/>
+        private static readonly IDictionary<string, ATN> bypassAltsAtnCache = new Dictionary<string, ATN>();
+
+        /// <summary>The error handling strategy for the parser.</summary>
+        /// <remarks>
+        /// The error handling strategy for the parser. The default value is a new
+        /// instance of
+        /// <see cref="DefaultErrorStrategy"/>
+        /// .
+        /// </remarks>
+        /// <seealso cref="ErrorHandler"/>
+        [NotNull]
+		private IAntlrErrorStrategy _errHandler = new DefaultErrorStrategy();
+
+        /// <summary>The input stream.</summary>
+        /// <remarks>The input stream.</remarks>
+        /// <seealso cref="InputStream()"/>
+    	private ITokenStream _input;
+
+		private readonly List<int> _precedenceStack = new List<int> { 0 };
+
+        /// <summary>
+        /// The
+        /// <see cref="ParserRuleContext"/>
+        /// object for the currently executing rule.
+        /// This is always non-null during the parsing process.
+        /// </summary>
+        private ParserRuleContext _ctx;
+
+        /// <summary>
+        /// Specifies whether or not the parser should construct a parse tree during
+        /// the parsing process.
+        /// </summary>
+        /// <remarks>
+        /// Specifies whether or not the parser should construct a parse tree during
+        /// the parsing process. The default value is
+        /// <see langword="true"/>
+        /// .
+        /// </remarks>
+        /// <seealso cref="BuildParseTree"/>
+        private bool _buildParseTrees = true;
+
+#if !PORTABLE
+        /// <summary>
+        /// When
+        /// <see cref="Trace"/>
+        /// <c>(true)</c>
+        /// is called, a reference to the
+        /// <see cref="TraceListener"/>
+        /// is stored here so it can be easily removed in a
+        /// later call to
+        /// <see cref="Trace"/>
+        /// <c>(false)</c>
+        /// . The listener itself is
+        /// implemented as a parser listener so this field is not directly used by
+        /// other parser methods.
+        /// </summary>
+        private Parser.TraceListener _tracer;
+#endif
+
+        /// <summary>
+        /// The list of
+        /// <see cref="Antlr4.Runtime.Tree.IParseTreeListener"/>
+        /// listeners registered to receive
+        /// events during the parse.
+        /// </summary>
+        /// <seealso cref="AddParseListener(Antlr4.Runtime.Tree.IParseTreeListener)"/>
+        [Nullable]
+        private IList<IParseTreeListener> _parseListeners;
+
+        /// <summary>The number of syntax errors reported during parsing.</summary>
+        /// <remarks>
+        /// The number of syntax errors reported during parsing. This value is
+        /// incremented each time
+        /// <see cref="NotifyErrorListeners(string)"/>
+        /// is called.
+        /// </remarks>
+        private int _syntaxErrors;
+
+        public Parser(ITokenStream input)
+        {
+            TokenStream = input;
+        }
+
+        /// <summary>reset the parser's state</summary>
+        public virtual void Reset()
+        {
+            if (((ITokenStream)InputStream) != null)
+            {
+                ((ITokenStream)InputStream).Seek(0);
+            }
+            _errHandler.Reset(this);
+            _ctx = null;
+            _syntaxErrors = 0;
+#if !PORTABLE
+            Trace = false;
+#endif
+            _precedenceStack.Clear();
+            _precedenceStack.Add(0);
+            ATNSimulator interpreter = Interpreter;
+            if (interpreter != null)
+            {
+                interpreter.Reset();
+            }
+        }
+
+        /// <summary>
+        /// Match current input symbol against
+        /// <paramref name="ttype"/>
+        /// . If the symbol type
+        /// matches,
+        /// <see cref="IAntlrErrorStrategy.ReportMatch(Parser)"/>
+        /// and
+        /// <see cref="Consume()"/>
+        /// are
+        /// called to complete the match process.
+        /// <p>If the symbol type does not match,
+        /// <see cref="IAntlrErrorStrategy.RecoverInline(Parser)"/>
+        /// is called on the current error
+        /// strategy to attempt recovery. If
+        /// <see cref="BuildParseTree()"/>
+        /// is
+        /// <see langword="true"/>
+        /// and the token index of the symbol returned by
+        /// <see cref="IAntlrErrorStrategy.RecoverInline(Parser)"/>
+        /// is -1, the symbol is added to
+        /// the parse tree by calling
+        /// <see cref="ParserRuleContext.AddErrorNode(IToken)"/>
+        /// .</p>
+        /// </summary>
+        /// <param name="ttype">the token type to match</param>
+        /// <returns>the matched symbol</returns>
+        /// <exception cref="RecognitionException">
+        /// if the current input symbol did not match
+        /// <paramref name="ttype"/>
+        /// and the error strategy could not recover from the
+        /// mismatched symbol
+        /// </exception>
+        /// <exception cref="Antlr4.Runtime.RecognitionException"/>
+        [return: NotNull]
+        public virtual IToken Match(int ttype)
+        {
+            IToken t = CurrentToken;
+            if (t.Type == ttype)
+            {
+                _errHandler.ReportMatch(this);
+                Consume();
+            }
+            else
+            {
+                t = _errHandler.RecoverInline(this);
+                if (_buildParseTrees && t.TokenIndex == -1)
+                {
+                    // we must have conjured up a new token during single token insertion
+                    // if it's not the current symbol
+                    _ctx.AddErrorNode(t);
+                }
+            }
+            return t;
+        }
+
+        /// <summary>Match current input symbol as a wildcard.</summary>
+        /// <remarks>
+        /// Match current input symbol as a wildcard. If the symbol type matches
+        /// (i.e. has a value greater than 0),
+        /// <see cref="IAntlrErrorStrategy.ReportMatch(Parser)"/>
+        /// and
+        /// <see cref="Consume()"/>
+        /// are called to complete the match process.
+        /// <p>If the symbol type does not match,
+        /// <see cref="IAntlrErrorStrategy.RecoverInline(Parser)"/>
+        /// is called on the current error
+        /// strategy to attempt recovery. If
+        /// <see cref="BuildParseTree()"/>
+        /// is
+        /// <see langword="true"/>
+        /// and the token index of the symbol returned by
+        /// <see cref="IAntlrErrorStrategy.RecoverInline(Parser)"/>
+        /// is -1, the symbol is added to
+        /// the parse tree by calling
+        /// <see cref="ParserRuleContext.AddErrorNode(IToken)"/>
+        /// .</p>
+        /// </remarks>
+        /// <returns>the matched symbol</returns>
+        /// <exception cref="RecognitionException">
+        /// if the current input symbol did not match
+        /// a wildcard and the error strategy could not recover from the mismatched
+        /// symbol
+        /// </exception>
+        /// <exception cref="Antlr4.Runtime.RecognitionException"/>
+        [return: NotNull]
+        public virtual IToken MatchWildcard()
+        {
+            IToken t = CurrentToken;
+            if (t.Type > 0)
+            {
+                _errHandler.ReportMatch(this);
+                Consume();
+            }
+            else
+            {
+                t = _errHandler.RecoverInline(this);
+                if (_buildParseTrees && t.TokenIndex == -1)
+                {
+                    // we must have conjured up a new token during single token insertion
+                    // if it's not the current symbol
+                    _ctx.AddErrorNode(t);
+                }
+            }
+            return t;
+        }
+
+        /// <summary>
+        /// Track the
+        /// <see cref="ParserRuleContext"/>
+        /// objects during the parse and hook
+        /// them up using the
+        /// <see cref="ParserRuleContext.children"/>
+        /// list so that it
+        /// forms a parse tree. The
+        /// <see cref="ParserRuleContext"/>
+        /// returned from the start
+        /// rule represents the root of the parse tree.
+        /// <p>Note that if we are not building parse trees, rule contexts only point
+        /// upwards. When a rule exits, it returns the context but that gets garbage
+        /// collected if nobody holds a reference. It points upwards but nobody
+        /// points at it.</p>
+        /// <p>When we build parse trees, we are adding all of these contexts to
+        /// <see cref="ParserRuleContext.children"/>
+        /// list. Contexts are then not candidates
+        /// for garbage collection.</p>
+        /// </summary>
+        /// <summary>
+        /// Gets whether or not a complete parse tree will be constructed while
+        /// parsing.
+        /// </summary>
+        /// <remarks>
+        /// Gets whether or not a complete parse tree will be constructed while
+        /// parsing. This property is
+        /// <see langword="true"/>
+        /// for a newly constructed parser.
+        /// </remarks>
+        /// <returns>
+        ///
+        /// <see langword="true"/>
+        /// if a complete parse tree will be constructed while
+        /// parsing, otherwise
+        /// <see langword="false"/>
+        /// </returns>
+        public virtual bool BuildParseTree
+        {
+            get
+            {
+                return _buildParseTrees;
+            }
+            set
+            {
+				this._buildParseTrees = value;
+            }
+        }
+
+        /// <summary>Trim the internal lists of the parse tree during parsing to conserve memory.</summary>
+        /// <remarks>
+        /// Trim the internal lists of the parse tree during parsing to conserve memory.
+        /// This property is set to
+        /// <see langword="false"/>
+        /// by default for a newly constructed parser.
+        /// </remarks>
+        /// <value>
+        ///
+        /// <see langword="true"/>
+        /// to trim the capacity of the
+        /// <see cref="ParserRuleContext.children"/>
+        /// list to its size after a rule is parsed.
+        /// </value>
+        /// <returns>
+        ///
+        /// <see langword="true"/>
+        /// if the
+        /// <see cref="ParserRuleContext.children"/>
+        /// list is trimmed
+        /// using the default
+        /// <see cref="TrimToSizeListener"/>
+        /// during the parse process.
+        /// </returns>
+        public virtual bool TrimParseTree
+        {
+            get
+            {
+                return ParseListeners.Contains(Parser.TrimToSizeListener.Instance);
+            }
+            set
+            {
+                bool trimParseTrees = value;
+                if (trimParseTrees)
+                {
+                    if (TrimParseTree)
+                    {
+                        return;
+                    }
+                    AddParseListener(Parser.TrimToSizeListener.Instance);
+                }
+                else
+                {
+                    RemoveParseListener(Parser.TrimToSizeListener.Instance);
+                }
+            }
+        }
+
+        public virtual IList<IParseTreeListener> ParseListeners
+        {
+            get
+            {
+                IList<IParseTreeListener> listeners = _parseListeners;
+                if (listeners == null)
+                {
+                    return Sharpen.Collections.EmptyList<IParseTreeListener>();
+                }
+                return listeners;
+            }
+        }
+
+        /// <summary>
+        /// Registers
+        /// <paramref name="listener"/>
+        /// to receive events during the parsing process.
+        /// <p>To support output-preserving grammar transformations (including but not
+        /// limited to left-recursion removal, automated left-factoring, and
+        /// optimized code generation), calls to listener methods during the parse
+        /// may differ substantially from calls made by
+        /// <see cref="Antlr4.Runtime.Tree.ParseTreeWalker.Default"/>
+        /// used after the parse is complete. In
+        /// particular, rule entry and exit events may occur in a different order
+        /// during the parse than after the parser. In addition, calls to certain
+        /// rule entry methods may be omitted.</p>
+        /// <p>With the following specific exceptions, calls to listener events are
+        /// <em>deterministic</em>, i.e. for identical input the calls to listener
+        /// methods will be the same.</p>
+        /// <ul>
+        /// <li>Alterations to the grammar used to generate code may change the
+        /// behavior of the listener calls.</li>
+        /// <li>Alterations to the command line options passed to ANTLR 4 when
+        /// generating the parser may change the behavior of the listener calls.</li>
+        /// <li>Changing the version of the ANTLR Tool used to generate the parser
+        /// may change the behavior of the listener calls.</li>
+        /// </ul>
+        /// </summary>
+        /// <param name="listener">the listener to add</param>
+        /// <exception cref="System.ArgumentNullException">
+        /// if
+        /// <c/>
+        /// listener is
+        /// <see langword="null"/>
+        /// </exception>
+        public virtual void AddParseListener(IParseTreeListener listener)
+        {
+            if (listener == null)
+            {
+                throw new ArgumentNullException("listener");
+            }
+            if (_parseListeners == null)
+            {
+                _parseListeners = new List<IParseTreeListener>();
+            }
+            this._parseListeners.Add(listener);
+        }
+
+        /// <summary>
+        /// Remove
+        /// <paramref name="listener"/>
+        /// from the list of parse listeners.
+        /// <p>If
+        /// <paramref name="listener"/>
+        /// is
+        /// <see langword="null"/>
+        /// or has not been added as a parse
+        /// listener, this method does nothing.</p>
+        /// </summary>
+        /// <seealso cref="AddParseListener(Antlr4.Runtime.Tree.IParseTreeListener)"/>
+        /// <param name="listener">the listener to remove</param>
+        public virtual void RemoveParseListener(IParseTreeListener listener)
+        {
+            if (_parseListeners != null)
+            {
+                if (_parseListeners.Remove(listener))
+                {
+                    if (_parseListeners.Count == 0)
+                    {
+                        _parseListeners = null;
+                    }
+                }
+            }
+        }
+
+        /// <summary>Remove all parse listeners.</summary>
+        /// <remarks>Remove all parse listeners.</remarks>
+        /// <seealso cref="AddParseListener(Antlr4.Runtime.Tree.IParseTreeListener)"/>
+        public virtual void RemoveParseListeners()
+        {
+            _parseListeners = null;
+        }
+
+        /// <summary>Notify any parse listeners of an enter rule event.</summary>
+        /// <remarks>Notify any parse listeners of an enter rule event.</remarks>
+        /// <seealso cref="AddParseListener(Antlr4.Runtime.Tree.IParseTreeListener)"/>
+        protected internal virtual void TriggerEnterRuleEvent()
+        {
+            foreach (IParseTreeListener listener in _parseListeners)
+            {
+                listener.EnterEveryRule(_ctx);
+                _ctx.EnterRule(listener);
+            }
+        }
+
+        /// <summary>Notify any parse listeners of an exit rule event.</summary>
+        /// <remarks>Notify any parse listeners of an exit rule event.</remarks>
+        /// <seealso cref="AddParseListener(Antlr4.Runtime.Tree.IParseTreeListener)"/>
+        protected internal virtual void TriggerExitRuleEvent()
+        {
+            // reverse order walk of listeners
+			if (_parseListeners != null) {
+				for (int i = _parseListeners.Count - 1; i >= 0; i--) {
+					IParseTreeListener listener = _parseListeners [i];
+					_ctx.ExitRule (listener);
+					listener.ExitEveryRule (_ctx);
+				}
+			}
+        }
+
+        /// <summary>Gets the number of syntax errors reported during parsing.</summary>
+        /// <remarks>
+        /// Gets the number of syntax errors reported during parsing. This value is
+        /// incremented each time
+        /// <see cref="NotifyErrorListeners(string)"/>
+        /// is called.
+        /// </remarks>
+        /// <seealso cref="NotifyErrorListeners(string)"/>
+        public virtual int NumberOfSyntaxErrors
+        {
+            get
+            {
+                return _syntaxErrors;
+            }
+        }
+
+        public virtual ITokenFactory TokenFactory
+        {
+            get
+            {
+                return _input.TokenSource.TokenFactory;
+            }
+        }
+
+        /// <summary>
+        /// The ATN with bypass alternatives is expensive to create so we create it
+        /// lazily.
+        /// </summary>
+        /// <remarks>
+        /// The ATN with bypass alternatives is expensive to create so we create it
+        /// lazily.
+        /// </remarks>
+        /// <exception cref="System.NotSupportedException">
+        /// if the current parser does not
+        /// implement the
+        /// <see cref="Recognizer{Symbol, ATNInterpreter}.SerializedAtn()"/>
+        /// method.
+        /// </exception>
+        [return: NotNull]
+        public virtual ATN GetATNWithBypassAlts()
+        {
+            string serializedAtn = SerializedAtn;
+            if (serializedAtn == null)
+            {
+                throw new NotSupportedException("The current parser does not support an ATN with bypass alternatives.");
+            }
+            lock (bypassAltsAtnCache)
+            {
+                ATN result = bypassAltsAtnCache.Get(serializedAtn);
+                if (result == null)
+                {
+                    ATNDeserializationOptions deserializationOptions = new ATNDeserializationOptions();
+                    deserializationOptions.GenerateRuleBypassTransitions = true;
+                    result = new ATNDeserializer(deserializationOptions).Deserialize(serializedAtn.ToCharArray());
+                    bypassAltsAtnCache.Put(serializedAtn, result);
+                }
+                return result;
+            }
+        }
+
+        /// <summary>The preferred method of getting a tree pattern.</summary>
+        /// <remarks>
+        /// The preferred method of getting a tree pattern. For example, here's a
+        /// sample use:
+        /// <pre>
+        /// ParseTree t = parser.expr();
+        /// ParseTreePattern p = parser.compileParseTreePattern("&lt;ID&gt;+0", MyParser.RULE_expr);
+        /// ParseTreeMatch m = p.match(t);
+        /// String id = m.get("ID");
+        /// </pre>
+        /// </remarks>
+        public virtual ParseTreePattern CompileParseTreePattern(string pattern, int patternRuleIndex)
+        {
+            if (((ITokenStream)InputStream) != null)
+            {
+                ITokenSource tokenSource = ((ITokenStream)InputStream).TokenSource;
+                if (tokenSource is Lexer)
+                {
+                    Lexer lexer = (Lexer)tokenSource;
+                    return CompileParseTreePattern(pattern, patternRuleIndex, lexer);
+                }
+            }
+            throw new NotSupportedException("Parser can't discover a lexer to use");
+        }
+
+        /// <summary>
+        /// The same as
+        /// <see cref="CompileParseTreePattern(string, int)"/>
+        /// but specify a
+        /// <see cref="Lexer"/>
+        /// rather than trying to deduce it from this parser.
+        /// </summary>
+        public virtual ParseTreePattern CompileParseTreePattern(string pattern, int patternRuleIndex, Lexer lexer)
+        {
+            ParseTreePatternMatcher m = new ParseTreePatternMatcher(lexer, this);
+            return m.Compile(pattern, patternRuleIndex);
+        }
+
+        public virtual IAntlrErrorStrategy ErrorHandler
+        {
+            get
+            {
+                return _errHandler;
+            }
+            set
+            {
+                IAntlrErrorStrategy handler = value;
+                this._errHandler = handler;
+            }
+        }
+
+        public override IIntStream InputStream
+		{
+			get
+			{
+				return _input;
+			}
+		}
+
+		public ITokenStream TokenStream
+		{
+			get
+			{
+				return _input;
+			}
+			set
+			{
+				this._input = null;
+				Reset ();
+				this._input = value;
+			}
+		}
+
+        /// <summary>
+        /// Match needs to return the current input symbol, which gets put
+        /// into the label for the associated token ref; e.g., x=ID.
+        /// </summary>
+        /// <remarks>
+        /// Match needs to return the current input symbol, which gets put
+        /// into the label for the associated token ref; e.g., x=ID.
+        /// </remarks>
+        public virtual IToken CurrentToken
+        {
+            get
+            {
+                return _input.Lt(1);
+            }
+        }
+
+        public void NotifyErrorListeners(string msg)
+        {
+            NotifyErrorListeners(CurrentToken, msg, null);
+        }
+
+        public virtual void NotifyErrorListeners(IToken offendingToken, string msg, RecognitionException e)
+        {
+            _syntaxErrors++;
+            int line = -1;
+            int charPositionInLine = -1;
+            if (offendingToken != null)
+            {
+                line = offendingToken.Line;
+                charPositionInLine = offendingToken.Column;
+            }
+            IAntlrErrorListener<IToken> listener = ((IParserErrorListener)ErrorListenerDispatch);
+            listener.SyntaxError(this, offendingToken, line, charPositionInLine, msg, e);
+        }
+
+        /// <summary>
+        /// Consume and return the
+        /// <linkplain>
+        /// #getCurrentToken
+        /// current symbol
+        /// </linkplain>
+        /// .
+        /// <p>E.g., given the following input with
+        /// <c>A</c>
+        /// being the current
+        /// lookahead symbol, this function moves the cursor to
+        /// <c>B</c>
+        /// and returns
+        /// <c>A</c>
+        /// .</p>
+        /// <pre>
+        /// A B
+        /// ^
+        /// </pre>
+        /// If the parser is not in error recovery mode, the consumed symbol is added
+        /// to the parse tree using
+        /// <see cref="ParserRuleContext.AddChild(IToken)"/>
+        /// , and
+        /// <see cref="Antlr4.Runtime.Tree.IParseTreeListener.VisitTerminal(Antlr4.Runtime.Tree.ITerminalNode)"/>
+        /// is called on any parse listeners.
+        /// If the parser <em>is</em> in error recovery mode, the consumed symbol is
+        /// added to the parse tree using
+        /// <see cref="ParserRuleContext.AddErrorNode(IToken)"/>
+        /// , and
+        /// <see cref="Antlr4.Runtime.Tree.IParseTreeListener.VisitErrorNode(Antlr4.Runtime.Tree.IErrorNode)"/>
+        /// is called on any parse
+        /// listeners.
+        /// </summary>
+        public virtual IToken Consume()
+        {
+            IToken o = CurrentToken;
+            if (o.Type != Eof)
+            {
+                ((ITokenStream)InputStream).Consume();
+            }
+            bool hasListener = _parseListeners != null && _parseListeners.Count != 0;
+            if (_buildParseTrees || hasListener)
+            {
+                if (_errHandler.InErrorRecoveryMode(this))
+                {
+                    IErrorNode node = _ctx.AddErrorNode(o);
+                    if (_parseListeners != null)
+                    {
+                        foreach (IParseTreeListener listener in _parseListeners)
+                        {
+                            listener.VisitErrorNode(node);
+                        }
+                    }
+                }
+                else
+                {
+                    ITerminalNode node = _ctx.AddChild(o);
+                    if (_parseListeners != null)
+                    {
+                        foreach (IParseTreeListener listener in _parseListeners)
+                        {
+                            listener.VisitTerminal(node);
+                        }
+                    }
+                }
+            }
+            return o;
+        }
+
+        protected internal virtual void AddContextToParseTree()
+        {
+            ParserRuleContext parent = (ParserRuleContext)_ctx.Parent;
+            // add current context to parent if we have a parent
+            if (parent != null)
+            {
+                parent.AddChild(_ctx);
+            }
+        }
+
+        /// <summary>Always called by generated parsers upon entry to a rule.</summary>
+        /// <remarks>
+        /// Always called by generated parsers upon entry to a rule. Access field
+        /// <see cref="_ctx"/>
+        /// get the current context.
+        /// </remarks>
+        public virtual void EnterRule(ParserRuleContext localctx, int state, int ruleIndex)
+        {
+            State = state;
+            _ctx = localctx;
+            _ctx.Start = _input.Lt(1);
+            if (_buildParseTrees)
+            {
+                AddContextToParseTree();
+            }
+            if (_parseListeners != null)
+            {
+                TriggerEnterRuleEvent();
+            }
+        }
+
+        public virtual void EnterLeftFactoredRule(ParserRuleContext localctx, int state, int ruleIndex)
+        {
+            State = state;
+            if (_buildParseTrees)
+            {
+                ParserRuleContext factoredContext = (ParserRuleContext)_ctx.GetChild(_ctx.ChildCount - 1);
+                _ctx.RemoveLastChild();
+                factoredContext.Parent = localctx;
+                localctx.AddChild(factoredContext);
+            }
+            _ctx = localctx;
+            _ctx.Start = _input.Lt(1);
+            if (_buildParseTrees)
+            {
+                AddContextToParseTree();
+            }
+            if (_parseListeners != null)
+            {
+                TriggerEnterRuleEvent();
+            }
+        }
+
+        public virtual void ExitRule()
+        {
+            _ctx.Stop = _input.Lt(-1);
+            // trigger event on _ctx, before it reverts to parent
+            if (_parseListeners != null)
+            {
+                TriggerExitRuleEvent();
+            }
+            State = _ctx.invokingState;
+            _ctx = (ParserRuleContext)_ctx.Parent;
+        }
+
+        public virtual void EnterOuterAlt(ParserRuleContext localctx, int altNum)
+        {
+        	localctx.setAltNumber(altNum);
+            // if we have new localctx, make sure we replace existing ctx
+            // that is previous child of parse tree
+            if (_buildParseTrees && _ctx != localctx)
+            {
+                ParserRuleContext parent = (ParserRuleContext)_ctx.Parent;
+                if (parent != null)
+                {
+                    parent.RemoveLastChild();
+                    parent.AddChild(localctx);
+                }
+            }
+            _ctx = localctx;
+        }
+
+        /// <summary>Get the precedence level for the top-most precedence rule.</summary>
+        /// <remarks>Get the precedence level for the top-most precedence rule.</remarks>
+        /// <returns>
+        /// The precedence level for the top-most precedence rule, or -1 if
+        /// the parser context is not nested within a precedence rule.
+        /// </returns>
+        public int Precedence
+        {
+            get
+            {
+                if (_precedenceStack.Count == 0)
+                {
+                    return -1;
+                }
+                return _precedenceStack[_precedenceStack.Count - 1];
+            }
+        }
+
+        [Obsolete(@"UseEnterRecursionRule(ParserRuleContext, int, int, int) instead.")]
+        public virtual void EnterRecursionRule(ParserRuleContext localctx, int ruleIndex)
+        {
+            EnterRecursionRule(localctx, Atn.ruleToStartState[ruleIndex].stateNumber, ruleIndex, 0);
+        }
+
+        public virtual void EnterRecursionRule(ParserRuleContext localctx, int state, int ruleIndex, int precedence)
+        {
+            State = state;
+            _precedenceStack.Add(precedence);
+            _ctx = localctx;
+            _ctx.Start = _input.Lt(1);
+            if (_parseListeners != null)
+            {
+                TriggerEnterRuleEvent();
+            }
+        }
+
+        // simulates rule entry for left-recursive rules
+        /// <summary>
+        /// Like
+        /// <see cref="EnterRule(ParserRuleContext, int, int)"/>
+        /// but for recursive rules.
+        /// </summary>
+        public virtual void PushNewRecursionContext(ParserRuleContext localctx, int state, int ruleIndex)
+        {
+            ParserRuleContext previous = _ctx;
+            previous.Parent = localctx;
+            previous.invokingState = state;
+            previous.Stop = _input.Lt(-1);
+            _ctx = localctx;
+            _ctx.Start = previous.Start;
+            if (_buildParseTrees)
+            {
+                _ctx.AddChild(previous);
+            }
+            if (_parseListeners != null)
+            {
+                TriggerEnterRuleEvent();
+            }
+        }
+
+        // simulates rule entry for left-recursive rules
+        public virtual void UnrollRecursionContexts(ParserRuleContext _parentctx)
+        {
+            _precedenceStack.RemoveAt(_precedenceStack.Count - 1);
+            _ctx.Stop = _input.Lt(-1);
+            ParserRuleContext retctx = _ctx;
+            // save current ctx (return value)
+            // unroll so _ctx is as it was before call to recursive method
+            if (_parseListeners != null)
+            {
+                while (_ctx != _parentctx)
+                {
+                    TriggerExitRuleEvent();
+                    _ctx = (ParserRuleContext)_ctx.Parent;
+                }
+            }
+            else
+            {
+                _ctx = _parentctx;
+            }
+            // hook into tree
+            retctx.Parent = _parentctx;
+            if (_buildParseTrees && _parentctx != null)
+            {
+                // add return ctx into invoking rule's tree
+                _parentctx.AddChild(retctx);
+            }
+        }
+
+        public virtual ParserRuleContext GetInvokingContext(int ruleIndex)
+        {
+            ParserRuleContext p = _ctx;
+            while (p != null)
+            {
+                if (p.RuleIndex == ruleIndex)
+                {
+                    return p;
+                }
+                p = (ParserRuleContext)p.Parent;
+            }
+            return null;
+        }
+
+        public virtual ParserRuleContext Context
+        {
+            get
+            {
+                return _ctx;
+            }
+            set
+            {
+                ParserRuleContext ctx = value;
+                _ctx = ctx;
+            }
+        }
+
+        public override bool Precpred(RuleContext localctx, int precedence)
+        {
+            return precedence >= _precedenceStack[_precedenceStack.Count - 1];
+        }
+
+        public override IAntlrErrorListener<IToken> ErrorListenerDispatch
+        {
+            get
+            {
+                return new ProxyParserErrorListener(ErrorListeners);
+            }
+        }
+
+        public virtual bool InContext(string context)
+        {
+            // TODO: useful in parser?
+            return false;
+        }
+
+        /// <summary>
+        /// Checks whether or not
+        /// <paramref name="symbol"/>
+        /// can follow the current state in the
+        /// ATN. The behavior of this method is equivalent to the following, but is
+        /// implemented such that the complete context-sensitive follow set does not
+        /// need to be explicitly constructed.
+        /// <pre>
+        /// return getExpectedTokens().contains(symbol);
+        /// </pre>
+        /// </summary>
+        /// <param name="symbol">the symbol type to check</param>
+        /// <returns>
+        ///
+        /// <see langword="true"/>
+        /// if
+        /// <paramref name="symbol"/>
+        /// can follow the current state in
+        /// the ATN, otherwise
+        /// <see langword="false"/>
+        /// .
+        /// </returns>
+        public virtual bool IsExpectedToken(int symbol)
+        {
+            //   		return getInterpreter().atn.nextTokens(_ctx);
+            ATN atn = Interpreter.atn;
+            ParserRuleContext ctx = _ctx;
+            ATNState s = atn.states[State];
+            IntervalSet following = atn.NextTokens(s);
+            if (following.Contains(symbol))
+            {
+                return true;
+            }
+            //        System.out.println("following "+s+"="+following);
+            if (!following.Contains(TokenConstants.Epsilon))
+            {
+                return false;
+            }
+            while (ctx != null && ctx.invokingState >= 0 && following.Contains(TokenConstants.Epsilon))
+            {
+                ATNState invokingState = atn.states[ctx.invokingState];
+                RuleTransition rt = (RuleTransition)invokingState.Transition(0);
+                following = atn.NextTokens(rt.followState);
+                if (following.Contains(symbol))
+                {
+                    return true;
+                }
+                ctx = (ParserRuleContext)ctx.Parent;
+            }
+            if (following.Contains(TokenConstants.Epsilon) && symbol == TokenConstants.Eof)
+            {
+                return true;
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// Computes the set of input symbols which could follow the current parser
+        /// state and context, as given by
+        /// <see cref="Recognizer{Symbol, ATNInterpreter}.State()"/>
+        /// and
+        /// <see cref="Context()"/>
+        /// ,
+        /// respectively.
+        /// </summary>
+        /// <seealso cref="Antlr4.Runtime.Atn.ATN.GetExpectedTokens(int, RuleContext)"/>
+        [return: NotNull]
+        public virtual IntervalSet GetExpectedTokens()
+        {
+            return Atn.GetExpectedTokens(State, Context);
+        }
+
+        [return: NotNull]
+        public virtual IntervalSet GetExpectedTokensWithinCurrentRule()
+        {
+            ATN atn = Interpreter.atn;
+            ATNState s = atn.states[State];
+            return atn.NextTokens(s);
+        }
+
+        /// <summary>
+        /// Get a rule's index (i.e.,
+        /// <c>RULE_ruleName</c>
+        /// field) or -1 if not found.
+        /// </summary>
+        public virtual int GetRuleIndex(string ruleName)
+        {
+            int ruleIndex;
+            if (RuleIndexMap.TryGetValue(ruleName, out ruleIndex))
+            {
+                return ruleIndex;
+            }
+            return -1;
+        }
+
+        public virtual ParserRuleContext RuleContext
+        {
+            get
+            {
+                return _ctx;
+            }
+        }
+
+        /// <summary>
+        /// Return List&lt;String&gt; of the rule names in your parser instance
+        /// leading up to a call to the current rule.
+        /// </summary>
+        /// <remarks>
+        /// Return List&lt;String&gt; of the rule names in your parser instance
+        /// leading up to a call to the current rule.  You could override if
+        /// you want more details such as the file/line info of where
+        /// in the ATN a rule is invoked.
+        /// This is very useful for error messages.
+        /// </remarks>
+        public virtual IList<string> GetRuleInvocationStack()
+        {
+            return GetRuleInvocationStack(_ctx);
+        }
+
+		public virtual string GetRuleInvocationStackAsString()
+		{
+			StringBuilder sb = new StringBuilder ("[");
+			foreach (string s in GetRuleInvocationStack()) {
+				sb.Append (s);
+				sb.Append (", ");
+			}
+			sb.Length = sb.Length - 2;
+			sb.Append ("]");
+			return sb.ToString ();
+		}
+
+        public virtual IList<string> GetRuleInvocationStack(RuleContext p)
+        {
+            string[] ruleNames = RuleNames;
+            IList<string> stack = new List<string>();
+            while (p != null)
+            {
+                // compute what follows who invoked us
+                int ruleIndex = p.RuleIndex;
+                if (ruleIndex < 0)
+                {
+                    stack.Add("n/a");
+                }
+                else
+                {
+                    stack.Add(ruleNames[ruleIndex]);
+                }
+                p = p.Parent;
+            }
+            return stack;
+        }
+
+        /// <summary>For debugging and other purposes.</summary>
+        /// <remarks>For debugging and other purposes.</remarks>
+        public virtual IList<string> GetDFAStrings()
+        {
+            IList<string> s = new List<string>();
+            for (int d = 0; d < Interpreter.atn.decisionToDFA.Length; d++)
+            {
+				DFA dfa = Interpreter.atn.decisionToDFA[d];
+                s.Add(dfa.ToString(Vocabulary, RuleNames));
+            }
+            return s;
+        }
+
+#if !PORTABLE
+        /// <summary>For debugging and other purposes.</summary>
+        /// <remarks>For debugging and other purposes.</remarks>
+        public virtual void DumpDFA()
+        {
+            bool seenOne = false;
+			for (int d = 0; d < Interpreter.atn.decisionToDFA.Length; d++)
+            {
+				DFA dfa = Interpreter.atn.decisionToDFA[d];
+                if (!dfa.IsEmpty)
+                {
+                    if (seenOne)
+                    {
+                        System.Console.Out.WriteLine();
+                    }
+                    System.Console.Out.WriteLine("Decision " + dfa.decision + ":");
+                    System.Console.Out.Write(dfa.ToString(Vocabulary, RuleNames));
+                    seenOne = true;
+                }
+            }
+        }
+#endif
+
+        public virtual string SourceName
+        {
+            get
+            {
+                return _input.SourceName;
+            }
+        }
+
+        public override ParseInfo ParseInfo
+        {
+            get
+            {
+                ParserATNSimulator interp = Interpreter;
+                if (interp is ProfilingATNSimulator)
+                {
+                    return new ParseInfo((ProfilingATNSimulator)interp);
+                }
+                return null;
+            }
+        }
+
+        /// <since>4.3</since>
+        public virtual bool Profile
+        {
+            set
+            {
+                bool profile = value;
+                ParserATNSimulator interp = Interpreter;
+                if (profile)
+                {
+                    if (!(interp is ProfilingATNSimulator))
+                    {
+                        Interpreter = new ProfilingATNSimulator(this);
+                    }
+                }
+                else
+                {
+                    if (interp is ProfilingATNSimulator)
+                    {
+                        Interpreter = new ParserATNSimulator(this, Atn);
+                    }
+                }
+            }
+        }
+
+#if !PORTABLE
+        /// <summary>
+        /// During a parse is sometimes useful to listen in on the rule entry and exit
+        /// events as well as token matches.
+        /// </summary>
+        /// <remarks>
+        /// During a parse is sometimes useful to listen in on the rule entry and exit
+        /// events as well as token matches. This is for quick and dirty debugging.
+        /// </remarks>
+        public virtual bool Trace
+        {
+            get
+            {
+                foreach (object o in ParseListeners)
+                {
+                    if (o is Parser.TraceListener)
+                    {
+                        return true;
+                    }
+                }
+                return false;
+            }
+            set
+            {
+                bool trace = value;
+                if (!trace)
+                {
+                    RemoveParseListener(_tracer);
+                    _tracer = null;
+                }
+                else
+                {
+                    if (_tracer != null)
+                    {
+                        RemoveParseListener(_tracer);
+                    }
+                    else
+                    {
+                        _tracer = new Parser.TraceListener(this);
+                    }
+                    AddParseListener(_tracer);
+                }
+            }
+        }
+#endif
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/ParserInterpreter.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/ParserInterpreter.cs
new file mode 100644
index 000000000..a5fb41ff4
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/ParserInterpreter.cs
@@ -0,0 +1,315 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Antlr4.Runtime;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime
+{
+    /// <summary>
+    /// A parser simulator that mimics what ANTLR's generated
+    /// parser code does.
+    /// </summary>
+    /// <remarks>
+    /// A parser simulator that mimics what ANTLR's generated
+    /// parser code does. A ParserATNSimulator is used to make
+    /// predictions via adaptivePredict but this class moves a pointer through the
+    /// ATN to simulate parsing. ParserATNSimulator just
+    /// makes us efficient rather than having to backtrack, for example.
+    /// This properly creates parse trees even for left recursive rules.
+    /// We rely on the left recursive rule invocation and special predicate
+    /// transitions to make left recursive rules work.
+    /// See TestParserInterpreter for examples.
+    /// </remarks>
+    public class ParserInterpreter : Parser
+    {
+        private readonly string _grammarFileName;
+
+        private readonly ATN _atn;
+
+        protected internal readonly BitSet pushRecursionContextStates;
+
+		private readonly string[] _ruleNames;
+
+        [NotNull]
+        private readonly IVocabulary vocabulary;
+
+        private readonly Stack<Tuple<ParserRuleContext, int>> _parentContextStack = new Stack<Tuple<ParserRuleContext, int>>();
+
+        public ParserInterpreter(string grammarFileName, IVocabulary vocabulary, IEnumerable<string> ruleNames, ATN atn, ITokenStream input)
+            : base(input)
+        {
+            this._grammarFileName = grammarFileName;
+            this._atn = atn;
+            this._ruleNames = ruleNames.ToArray();
+            this.vocabulary = vocabulary;
+            // identify the ATN states where pushNewRecursionContext must be called
+            this.pushRecursionContextStates = new BitSet(atn.states.Count);
+            foreach (ATNState state in atn.states)
+            {
+                if (!(state is StarLoopEntryState))
+                {
+                    continue;
+                }
+                if (((StarLoopEntryState)state).precedenceRuleDecision)
+                {
+                    this.pushRecursionContextStates.Set(state.stateNumber);
+                }
+            }
+            // get atn simulator that knows how to do predictions
+            Interpreter = new ParserATNSimulator(this, atn);
+        }
+
+        public override ATN Atn
+        {
+            get
+            {
+                return _atn;
+            }
+        }
+
+        public override IVocabulary Vocabulary
+        {
+            get
+            {
+                return vocabulary;
+            }
+        }
+
+        public override string[] RuleNames
+        {
+            get
+            {
+                return _ruleNames;
+            }
+        }
+
+        public override string GrammarFileName
+        {
+            get
+            {
+                return _grammarFileName;
+            }
+        }
+
+        /// <summary>Begin parsing at startRuleIndex</summary>
+        public virtual ParserRuleContext Parse(int startRuleIndex)
+        {
+            RuleStartState startRuleStartState = _atn.ruleToStartState[startRuleIndex];
+            InterpreterRuleContext rootContext = new InterpreterRuleContext(null, ATNState.InvalidStateNumber, startRuleIndex);
+            if (startRuleStartState.isPrecedenceRule)
+            {
+                EnterRecursionRule(rootContext, startRuleStartState.stateNumber, startRuleIndex, 0);
+            }
+            else
+            {
+                EnterRule(rootContext, startRuleStartState.stateNumber, startRuleIndex);
+            }
+            while (true)
+            {
+                ATNState p = AtnState;
+                switch (p.StateType)
+                {
+                    case StateType.RuleStop:
+                    {
+                        // pop; return from rule
+						if (RuleContext.IsEmpty)
+                        {
+                            if (startRuleStartState.isPrecedenceRule)
+                            {
+								ParserRuleContext result = RuleContext;
+                                Tuple<ParserRuleContext, int> parentContext = _parentContextStack.Pop();
+                                UnrollRecursionContexts(parentContext.Item1);
+                                return result;
+                            }
+                            else
+                            {
+                                ExitRule();
+                                return rootContext;
+                            }
+                        }
+                        VisitRuleStopState(p);
+                        break;
+                    }
+
+                    default:
+                    {
+                        try
+                        {
+                            VisitState(p);
+                        }
+                        catch (RecognitionException e)
+                        {
+                            State = _atn.ruleToStopState[p.ruleIndex].stateNumber;
+                            Context.exception = e;
+                            ErrorHandler.ReportError(this, e);
+                            ErrorHandler.Recover(this, e);
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+
+        public override void EnterRecursionRule(ParserRuleContext localctx, int state, int ruleIndex, int precedence)
+        {
+			_parentContextStack.Push(Tuple.Create(RuleContext, localctx.invokingState));
+            base.EnterRecursionRule(localctx, state, ruleIndex, precedence);
+        }
+
+        protected internal virtual ATNState AtnState
+        {
+            get
+            {
+                return _atn.states[State];
+            }
+        }
+
+        protected internal virtual void VisitState(ATNState p)
+        {
+            int edge;
+            if (p.NumberOfTransitions > 1)
+            {
+                ErrorHandler.Sync(this);
+				edge = Interpreter.AdaptivePredict(TokenStream, ((DecisionState)p).decision, RuleContext);
+            }
+            else
+            {
+                edge = 1;
+            }
+            Transition transition = p.Transition(edge - 1);
+            switch (transition.TransitionType)
+            {
+                case TransitionType.Epsilon:
+                {
+                    if (pushRecursionContextStates.Get(p.stateNumber) && !(transition.target is LoopEndState))
+                    {
+						InterpreterRuleContext ctx = new InterpreterRuleContext(_parentContextStack.Peek().Item1, _parentContextStack.Peek().Item2, RuleContext.RuleIndex);
+						PushNewRecursionContext(ctx, _atn.ruleToStartState[p.ruleIndex].stateNumber, RuleContext.RuleIndex);
+                    }
+                    break;
+                }
+
+                case TransitionType.Atom:
+                {
+					Match(((AtomTransition)transition).token);
+                    break;
+                }
+
+                case TransitionType.Range:
+                case TransitionType.Set:
+                case TransitionType.NotSet:
+                {
+                    if (!transition.Matches(TokenStream.La(1), TokenConstants.MinUserTokenType, 65535))
+                    {
+						ErrorHandler.RecoverInline(this);
+                    }
+                    MatchWildcard();
+                    break;
+                }
+
+                case TransitionType.Wildcard:
+                {
+                    MatchWildcard();
+                    break;
+                }
+
+                case TransitionType.Rule:
+                {
+                    RuleStartState ruleStartState = (RuleStartState)transition.target;
+                    int ruleIndex = ruleStartState.ruleIndex;
+					InterpreterRuleContext ctx_1 = new InterpreterRuleContext(RuleContext, p.stateNumber, ruleIndex);
+                    if (ruleStartState.isPrecedenceRule)
+                    {
+                        EnterRecursionRule(ctx_1, ruleStartState.stateNumber, ruleIndex, ((RuleTransition)transition).precedence);
+                    }
+                    else
+                    {
+                        EnterRule(ctx_1, transition.target.stateNumber, ruleIndex);
+                    }
+                    break;
+                }
+
+                case TransitionType.Predicate:
+                {
+                    PredicateTransition predicateTransition = (PredicateTransition)transition;
+					if (!Sempred(RuleContext, predicateTransition.ruleIndex, predicateTransition.predIndex))
+                    {
+                        throw new FailedPredicateException(this);
+                    }
+                    break;
+                }
+
+                case TransitionType.Action:
+                {
+                    ActionTransition actionTransition = (ActionTransition)transition;
+					Action(RuleContext, actionTransition.ruleIndex, actionTransition.actionIndex);
+                    break;
+                }
+
+                case TransitionType.Precedence:
+                {
+					if (!Precpred(RuleContext, ((PrecedencePredicateTransition)transition).precedence))
+                    {
+                        throw new FailedPredicateException(this, string.Format("precpred(_ctx, {0})", ((PrecedencePredicateTransition)transition).precedence));
+                    }
+                    break;
+                }
+
+                default:
+                {
+                    throw new NotSupportedException("Unrecognized ATN transition type.");
+                }
+            }
+            State = transition.target.stateNumber;
+        }
+
+        protected internal virtual void VisitRuleStopState(ATNState p)
+        {
+            RuleStartState ruleStartState = _atn.ruleToStartState[p.ruleIndex];
+            if (ruleStartState.isPrecedenceRule)
+            {
+                Tuple<ParserRuleContext, int> parentContext = _parentContextStack.Pop();
+                UnrollRecursionContexts(parentContext.Item1);
+                State = parentContext.Item2;
+            }
+            else
+            {
+                ExitRule();
+            }
+            RuleTransition ruleTransition = (RuleTransition)_atn.states[State].Transition(0);
+            State = ruleTransition.followState.stateNumber;
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/ParserRuleContext.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/ParserRuleContext.cs
new file mode 100644
index 000000000..9a2210f14
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/ParserRuleContext.cs
@@ -0,0 +1,411 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System;
+using System.Collections.Generic;
+using Antlr4.Runtime;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+using Antlr4.Runtime.Tree;
+
+namespace Antlr4.Runtime
+{
+    /// <summary>A rule invocation record for parsing.</summary>
+    /// <remarks>
+    /// A rule invocation record for parsing.
+    /// Contains all of the information about the current rule not stored in the
+    /// RuleContext. It handles parse tree children list, Any ATN state
+    /// tracing, and the default values available for rule indications:
+    /// start, stop, rule index, current alt number, current
+    /// ATN state.
+    /// Subclasses made for each rule and grammar track the parameters,
+    /// return values, locals, and labels specific to that rule. These
+    /// are the objects that are returned from rules.
+    /// Note text is not an actual field of a rule return value; it is computed
+    /// from start and stop using the input stream's toString() method.  I
+    /// could add a ctor to this so that we can pass in and store the input
+    /// stream, but I'm not sure we want to do that.  It would seem to be undefined
+    /// to get the .text property anyway if the rule matches tokens from multiple
+    /// input streams.
+    /// I do not use getters for fields of objects that are used simply to
+    /// group values such as this aggregate.  The getters/setters are there to
+    /// satisfy the superclass interface.
+    /// </remarks>
+    public class ParserRuleContext : RuleContext
+    {
+        private static readonly Antlr4.Runtime.ParserRuleContext Empty = new Antlr4.Runtime.ParserRuleContext();
+
+        /// <summary>
+        /// If we are debugging or building a parse tree for a visitor,
+        /// we need to track all of the tokens and rule invocations associated
+        /// with this rule's context.
+        /// </summary>
+        /// <remarks>
+        /// If we are debugging or building a parse tree for a visitor,
+        /// we need to track all of the tokens and rule invocations associated
+        /// with this rule's context. This is empty for parsing w/o tree constr.
+        /// operation because we don't the need to track the details about
+        /// how we parse this rule.
+        /// </remarks>
+        public IList<IParseTree> children;
+
+        /// <summary>
+        /// For debugging/tracing purposes, we want to track all of the nodes in
+        /// the ATN traversed by the parser for a particular rule.
+        /// </summary>
+        /// <remarks>
+        /// For debugging/tracing purposes, we want to track all of the nodes in
+        /// the ATN traversed by the parser for a particular rule.
+        /// This list indicates the sequence of ATN nodes used to match
+        /// the elements of the children list. This list does not include
+        /// ATN nodes and other rules used to match rule invocations. It
+        /// traces the rule invocation node itself but nothing inside that
+        /// other rule's ATN submachine.
+        /// There is NOT a one-to-one correspondence between the children and
+        /// states list. There are typically many nodes in the ATN traversed
+        /// for each element in the children list. For example, for a rule
+        /// invocation there is the invoking state and the following state.
+        /// The parser setState() method updates field s and adds it to this list
+        /// if we are debugging/tracing.
+        /// This does not trace states visited during prediction.
+        /// </remarks>
+        private IToken _start;
+
+        /// <summary>
+        /// For debugging/tracing purposes, we want to track all of the nodes in
+        /// the ATN traversed by the parser for a particular rule.
+        /// </summary>
+        /// <remarks>
+        /// For debugging/tracing purposes, we want to track all of the nodes in
+        /// the ATN traversed by the parser for a particular rule.
+        /// This list indicates the sequence of ATN nodes used to match
+        /// the elements of the children list. This list does not include
+        /// ATN nodes and other rules used to match rule invocations. It
+        /// traces the rule invocation node itself but nothing inside that
+        /// other rule's ATN submachine.
+        /// There is NOT a one-to-one correspondence between the children and
+        /// states list. There are typically many nodes in the ATN traversed
+        /// for each element in the children list. For example, for a rule
+        /// invocation there is the invoking state and the following state.
+        /// The parser setState() method updates field s and adds it to this list
+        /// if we are debugging/tracing.
+        /// This does not trace states visited during prediction.
+        /// </remarks>
+        private IToken _stop;
+
+        /// <summary>The exception that forced this rule to return.</summary>
+        /// <remarks>
+        /// The exception that forced this rule to return. If the rule successfully
+        /// completed, this is
+        /// <see langword="null"/>
+        /// .
+        /// </remarks>
+        public RecognitionException exception;
+
+        public ParserRuleContext()
+        {
+        }
+
+        public static Antlr4.Runtime.ParserRuleContext EmptyContext
+        {
+            get
+            {
+                //	public List<Integer> states;
+                return Empty;
+            }
+        }
+
+        /// <summary>COPY a ctx (I'm deliberately not using copy constructor)</summary>
+        public virtual void CopyFrom(Antlr4.Runtime.ParserRuleContext ctx)
+        {
+            // from RuleContext
+            this.Parent = ctx.Parent;
+            this.invokingState = ctx.invokingState;
+            this._start = ctx._start;
+            this._stop = ctx._stop;
+        }
+
+        public ParserRuleContext(Antlr4.Runtime.ParserRuleContext parent, int invokingStateNumber)
+            : base(parent, invokingStateNumber)
+        {
+        }
+
+        // Double dispatch methods for listeners
+        public virtual void EnterRule(IParseTreeListener listener)
+        {
+        }
+
+        public virtual void ExitRule(IParseTreeListener listener)
+        {
+        }
+
+        /// <summary>Does not set parent link; other add methods do that</summary>
+        public virtual void AddChild(ITerminalNode t)
+        {
+            if (children == null)
+            {
+                children = new List<IParseTree>();
+            }
+            children.Add(t);
+        }
+
+        public virtual void AddChild(RuleContext ruleInvocation)
+        {
+            if (children == null)
+            {
+                children = new List<IParseTree>();
+            }
+            children.Add(ruleInvocation);
+        }
+
+        /// <summary>
+        /// Used by enterOuterAlt to toss out a RuleContext previously added as
+        /// we entered a rule.
+        /// </summary>
+        /// <remarks>
+        /// Used by enterOuterAlt to toss out a RuleContext previously added as
+        /// we entered a rule. If we have # label, we will need to remove
+        /// generic ruleContext object.
+        /// </remarks>
+        public virtual void RemoveLastChild()
+        {
+            if (children != null)
+            {
+                children.RemoveAt(children.Count - 1);
+            }
+        }
+
+        //	public void trace(int s) {
+        //		if ( states==null ) states = new ArrayList<Integer>();
+        //		states.add(s);
+        //	}
+        public virtual ITerminalNode AddChild(IToken matchedToken)
+        {
+            TerminalNodeImpl t = new TerminalNodeImpl(matchedToken);
+            AddChild(t);
+            t.Parent = this;
+            return t;
+        }
+
+        public virtual IErrorNode AddErrorNode(IToken badToken)
+        {
+            ErrorNodeImpl t = new ErrorNodeImpl(badToken);
+            AddChild(t);
+            t.Parent = this;
+            return t;
+        }
+
+
+        public override IParseTree GetChild(int i)
+        {
+            return children != null && i >= 0 && i < children.Count ? children[i] : null;
+        }
+
+        public virtual T GetChild<T>(int i)
+            where T : IParseTree
+        {
+            if (children == null || i < 0 || i >= children.Count)
+            {
+                return default(T);
+            }
+            int j = -1;
+            // what element have we found with ctxType?
+            foreach (IParseTree o in children)
+            {
+                if (o is T)
+                {
+                    j++;
+                    if (j == i)
+                    {
+                        return (T)o;
+                    }
+                }
+            }
+            return default(T);
+        }
+
+        public virtual ITerminalNode GetToken(int ttype, int i)
+        {
+            if (children == null || i < 0 || i >= children.Count)
+            {
+                return null;
+            }
+            int j = -1;
+            // what token with ttype have we found?
+            foreach (IParseTree o in children)
+            {
+                if (o is ITerminalNode)
+                {
+                    ITerminalNode tnode = (ITerminalNode)o;
+                    IToken symbol = tnode.Symbol;
+                    if (symbol.Type == ttype)
+                    {
+                        j++;
+                        if (j == i)
+                        {
+                            return tnode;
+                        }
+                    }
+                }
+            }
+            return null;
+        }
+
+#if NET45PLUS
+        public virtual IReadOnlyList<ITerminalNode> GetTokens(int ttype)
+#else
+        public virtual ITerminalNode[] GetTokens(int ttype)
+#endif
+        {
+            if (children == null)
+            {
+                return Collections.EmptyList<ITerminalNode>();
+            }
+            List<ITerminalNode> tokens = null;
+            foreach (IParseTree o in children)
+            {
+                if (o is ITerminalNode)
+                {
+                    ITerminalNode tnode = (ITerminalNode)o;
+                    IToken symbol = tnode.Symbol;
+                    if (symbol.Type == ttype)
+                    {
+                        if (tokens == null)
+                        {
+                            tokens = new List<ITerminalNode>();
+                        }
+                        tokens.Add(tnode);
+                    }
+                }
+            }
+            if (tokens == null)
+            {
+                return Collections.EmptyList<ITerminalNode>();
+            }
+#if NET45PLUS
+            return tokens;
+#else
+            return tokens.ToArray();
+#endif
+        }
+
+        public virtual T GetRuleContext<T>(int i)
+            where T : Antlr4.Runtime.ParserRuleContext
+        {
+            return GetChild<T>(i);
+        }
+
+#if NET45PLUS
+        public virtual IReadOnlyList<T> GetRuleContexts<T>()
+            where T : Antlr4.Runtime.ParserRuleContext
+#else
+        public virtual T[] GetRuleContexts<T>()
+            where T : Antlr4.Runtime.ParserRuleContext
+#endif
+        {
+            if (children == null)
+            {
+                return Collections.EmptyList<T>();
+            }
+            List<T> contexts = null;
+            foreach (IParseTree o in children)
+            {
+                if (o is T)
+                {
+                    if (contexts == null)
+                    {
+                        contexts = new List<T>();
+                    }
+                    contexts.Add((T)o);
+                }
+            }
+            if (contexts == null)
+            {
+                return Collections.EmptyList<T>();
+            }
+#if NET45PLUS
+            return contexts;
+#else
+            return contexts.ToArray();
+#endif
+        }
+
+        public override int ChildCount
+        {
+            get
+            {
+                return children != null ? children.Count : 0;
+            }
+        }
+
+        public override Interval SourceInterval
+        {
+            get
+            {
+                if (_start == null || _stop == null)
+                {
+                    return Interval.Invalid;
+                }
+                return Interval.Of(_start.TokenIndex, _stop.TokenIndex);
+            }
+        }
+
+        public virtual IToken Start
+        {
+            get
+            {
+                return _start;
+            }
+			set 
+			{
+				_start = value;
+			}
+        }
+
+        public virtual IToken Stop
+        {
+            get
+            {
+                return _stop;
+            }
+			set 
+			{
+				_stop = value;
+			}
+        }
+
+        /// <summary>Used for rule context info debugging during parse-time, not so much for ATN debugging</summary>
+        public virtual string ToInfoString(Parser recognizer)
+        {
+            List<string> rules = new List<string>(recognizer.GetRuleInvocationStack(this));
+            rules.Reverse();
+            return "ParserRuleContext" + rules + "{" + "start=" + _start + ", stop=" + _stop + '}';
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Properties/AssemblyInfo.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Properties/AssemblyInfo.cs
new file mode 100644
index 000000000..af3305927
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Properties/AssemblyInfo.cs
@@ -0,0 +1,74 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("Antlr4.Runtime")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("Antlr organization")]
+[assembly: AssemblyProduct("Antlr4.Runtime")]
+[assembly: AssemblyCopyright("Antlr organization")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+[assembly: CLSCompliant(true)]
+
+#if !PORTABLE || NET45PLUS
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+#if !PORTABLE
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("bc228eb9-e79c-4e5a-a1b9-0434ea566bab")]
+#endif
+#endif
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("4.5.3.0")]
+#if !COMPACT
+[assembly: AssemblyFileVersion("4.5.3.0")]
+[assembly: AssemblyInformationalVersion("4.5.3.0")]
+#endif
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/ProxyErrorListener.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/ProxyErrorListener.cs
new file mode 100644
index 000000000..ec20f41b7
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/ProxyErrorListener.cs
@@ -0,0 +1,74 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System;
+using System.Collections.Generic;
+using Antlr4.Runtime;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime
+{
+    /// <summary>
+    /// This implementation of
+    /// <see cref="IAntlrErrorListener{Symbol}"/>
+    /// dispatches all calls to a
+    /// collection of delegate listeners. This reduces the effort required to support multiple
+    /// listeners.
+    /// </summary>
+    /// <author>Sam Harwell</author>
+    public class ProxyErrorListener<Symbol> : IAntlrErrorListener<Symbol>
+    {
+        private readonly IEnumerable<IAntlrErrorListener<Symbol>> delegates;
+
+        public ProxyErrorListener(IEnumerable<IAntlrErrorListener<Symbol>> delegates)
+        {
+            if (delegates == null)
+            {
+                throw new ArgumentNullException("delegates");
+            }
+            this.delegates = delegates;
+        }
+
+        protected internal virtual IEnumerable<IAntlrErrorListener<Symbol>> Delegates
+        {
+            get
+            {
+                return delegates;
+            }
+        }
+
+        public virtual void SyntaxError(IRecognizer recognizer, Symbol offendingSymbol, int line, int charPositionInLine, string msg, RecognitionException e)
+        {
+            foreach (IAntlrErrorListener<Symbol> listener in delegates)
+            {
+                listener.SyntaxError(recognizer, offendingSymbol, line, charPositionInLine, msg, e);
+            }
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/ProxyParserErrorListener.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/ProxyParserErrorListener.cs
new file mode 100644
index 000000000..4a144fe54
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/ProxyParserErrorListener.cs
@@ -0,0 +1,85 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System.Collections.Generic;
+using Antlr4.Runtime;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Dfa;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime
+{
+    /// <author>Sam Harwell</author>
+    public class ProxyParserErrorListener : ProxyErrorListener<IToken>, IParserErrorListener
+    {
+        public ProxyParserErrorListener(ICollection<IAntlrErrorListener<IToken>> delegates)
+            : base(delegates)
+        {
+        }
+
+        public virtual void ReportAmbiguity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, bool exact, BitSet ambigAlts, ATNConfigSet configs)
+        {
+            foreach (IAntlrErrorListener<IToken> listener in Delegates)
+            {
+                if (!(listener is IParserErrorListener))
+                {
+                    continue;
+                }
+                IParserErrorListener parserErrorListener = (IParserErrorListener)listener;
+                parserErrorListener.ReportAmbiguity(recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs);
+            }
+        }
+
+        public virtual void ReportAttemptingFullContext(Parser recognizer, DFA dfa, int startIndex, int stopIndex, BitSet conflictingAlts, SimulatorState conflictState)
+        {
+            foreach (IAntlrErrorListener<IToken> listener in Delegates)
+            {
+                if (!(listener is IParserErrorListener))
+                {
+                    continue;
+                }
+                IParserErrorListener parserErrorListener = (IParserErrorListener)listener;
+                parserErrorListener.ReportAttemptingFullContext(recognizer, dfa, startIndex, stopIndex, conflictingAlts, conflictState);
+            }
+        }
+
+        public virtual void ReportContextSensitivity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, int prediction, SimulatorState acceptState)
+        {
+            foreach (IAntlrErrorListener<IToken> listener in Delegates)
+            {
+                if (!(listener is IParserErrorListener))
+                {
+                    continue;
+                }
+                IParserErrorListener parserErrorListener = (IParserErrorListener)listener;
+                parserErrorListener.ReportContextSensitivity(recognizer, dfa, startIndex, stopIndex, prediction, acceptState);
+            }
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/RecognitionException.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/RecognitionException.cs
new file mode 100644
index 000000000..fe7f61794
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/RecognitionException.cs
@@ -0,0 +1,249 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+
+using System;
+using Antlr4.Runtime;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime
+{
+    /// <summary>The root of the ANTLR exception hierarchy.</summary>
+    /// <remarks>
+    /// The root of the ANTLR exception hierarchy. In general, ANTLR tracks just
+    /// 3 kinds of errors: prediction errors, failed predicate errors, and
+    /// mismatched input errors. In each case, the parser knows where it is
+    /// in the input, where it is in the ATN, the rule invocation stack,
+    /// and what kind of problem occurred.
+    /// </remarks>
+    [System.Serializable]
+    public class RecognitionException : Exception
+    {
+        private const long serialVersionUID = -3861826954750022374L;
+
+        /// <summary>
+        /// The
+        /// <see cref="IRecognizer"/>
+        /// where this exception originated.
+        /// </summary>
+        [Nullable]
+        private readonly IRecognizer recognizer;
+
+        [Nullable]
+        private readonly RuleContext ctx;
+
+        [Nullable]
+        private readonly IIntStream input;
+
+        /// <summary>
+        /// The current
+        /// <see cref="IToken"/>
+        /// when an error occurred. Since not all streams
+        /// support accessing symbols by index, we have to track the
+        /// <see cref="IToken"/>
+        /// instance itself.
+        /// </summary>
+        private IToken offendingToken;
+
+        private int offendingState = -1;
+
+        public RecognitionException(Lexer lexer, ICharStream input)
+        {
+            this.recognizer = lexer;
+            this.input = input;
+            this.ctx = null;
+        }
+
+        public RecognitionException(IRecognizer recognizer, IIntStream input, ParserRuleContext ctx)
+        {
+            this.recognizer = recognizer;
+            this.input = input;
+            this.ctx = ctx;
+            if (recognizer != null)
+            {
+                this.offendingState = recognizer.State;
+            }
+        }
+
+        public RecognitionException(string message, IRecognizer recognizer, IIntStream input, ParserRuleContext ctx)
+            : base(message)
+        {
+            this.recognizer = recognizer;
+            this.input = input;
+            this.ctx = ctx;
+            if (recognizer != null)
+            {
+                this.offendingState = recognizer.State;
+            }
+        }
+
+        /// <summary>
+        /// Get the ATN state number the parser was in at the time the error
+        /// occurred.
+        /// </summary>
+        /// <remarks>
+        /// Get the ATN state number the parser was in at the time the error
+        /// occurred. For
+        /// <see cref="NoViableAltException"/>
+        /// and
+        /// <see cref="LexerNoViableAltException"/>
+        /// exceptions, this is the
+        /// <see cref="Antlr4.Runtime.Atn.DecisionState"/>
+        /// number. For others, it is the state whose outgoing
+        /// edge we couldn't match.
+        /// <p>If the state number is not known, this method returns -1.</p>
+        /// </remarks>
+        public int OffendingState
+        {
+            get
+            {
+                return offendingState;
+            }
+            protected set
+            {
+                int offendingState = value;
+                this.offendingState = offendingState;
+            }
+        }
+
+        /// <summary>
+        /// Gets the set of input symbols which could potentially follow the
+        /// previously matched symbol at the time this exception was thrown.
+        /// </summary>
+        /// <remarks>
+        /// Gets the set of input symbols which could potentially follow the
+        /// previously matched symbol at the time this exception was thrown.
+        /// <p>If the set of expected tokens is not known and could not be computed,
+        /// this method returns
+        /// <see langword="null"/>
+        /// .</p>
+        /// </remarks>
+        /// <returns>
+        /// The set of token types that could potentially follow the current
+        /// state in the ATN, or
+        /// <see langword="null"/>
+        /// if the information is not available.
+        /// </returns>
+        [return: Nullable]
+        public virtual IntervalSet GetExpectedTokens()
+        {
+            if (recognizer != null)
+            {
+                return recognizer.Atn.GetExpectedTokens(offendingState, ctx);
+            }
+            return null;
+        }
+
+        /// <summary>
+        /// Gets the
+        /// <see cref="RuleContext"/>
+        /// at the time this exception was thrown.
+        /// <p>If the context is not available, this method returns
+        /// <see langword="null"/>
+        /// .</p>
+        /// </summary>
+        /// <returns>
+        /// The
+        /// <see cref="RuleContext"/>
+        /// at the time this exception was thrown.
+        /// If the context is not available, this method returns
+        /// <see langword="null"/>
+        /// .
+        /// </returns>
+        public virtual RuleContext Context
+        {
+            get
+            {
+                return ctx;
+            }
+        }
+
+        /// <summary>
+        /// Gets the input stream which is the symbol source for the recognizer where
+        /// this exception was thrown.
+        /// </summary>
+        /// <remarks>
+        /// Gets the input stream which is the symbol source for the recognizer where
+        /// this exception was thrown.
+        /// <p>If the input stream is not available, this method returns
+        /// <see langword="null"/>
+        /// .</p>
+        /// </remarks>
+        /// <returns>
+        /// The input stream which is the symbol source for the recognizer
+        /// where this exception was thrown, or
+        /// <see langword="null"/>
+        /// if the stream is not
+        /// available.
+        /// </returns>
+        public virtual IIntStream InputStream
+        {
+            get
+            {
+                return input;
+            }
+        }
+
+        public IToken OffendingToken
+        {
+            get
+            {
+                return offendingToken;
+            }
+            protected set
+            {
+                IToken offendingToken = value;
+                this.offendingToken = offendingToken;
+            }
+        }
+
+        /// <summary>
+        /// Gets the
+        /// <see cref="IRecognizer"/>
+        /// where this exception occurred.
+        /// <p>If the recognizer is not available, this method returns
+        /// <see langword="null"/>
+        /// .</p>
+        /// </summary>
+        /// <returns>
+        /// The recognizer where this exception occurred, or
+        /// <see langword="null"/>
+        /// if
+        /// the recognizer is not available.
+        /// </returns>
+        public virtual IRecognizer Recognizer
+        {
+            get
+            {
+                return recognizer;
+            }
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Recognizer.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Recognizer.cs
new file mode 100644
index 000000000..83bdc1c42
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Recognizer.cs
@@ -0,0 +1,398 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System;
+using System.Collections.Generic;
+using Antlr4.Runtime;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+#if NET40PLUS
+using System.Runtime.CompilerServices;
+#endif
+
+namespace Antlr4.Runtime
+{
+    public abstract class Recognizer<Symbol, ATNInterpreter> : IRecognizer
+        where ATNInterpreter : ATNSimulator
+    {
+        public const int Eof = -1;
+
+#if NET40PLUS
+        private static readonly ConditionalWeakTable<IVocabulary, IDictionary<string, int>> tokenTypeMapCache = new ConditionalWeakTable<IVocabulary, IDictionary<string, int>>();
+        private static readonly ConditionalWeakTable<string[], IDictionary<string, int>> ruleIndexMapCache = new ConditionalWeakTable<string[], IDictionary<string, int>>();
+#endif
+
+        [NotNull]
+        private IAntlrErrorListener<Symbol>[] _listeners =
+        {
+#if !PORTABLE
+            ConsoleErrorListener<Symbol>.Instance
+#endif
+        };
+
+        private ATNInterpreter _interp;
+
+        private int _stateNumber = -1;
+
+        /// <summary>
+        /// Used to print out token names like ID during debugging and
+        /// error reporting.
+        /// </summary>
+        /// <remarks>
+        /// Used to print out token names like ID during debugging and
+        /// error reporting.  The generated parsers implement a method
+        /// that overrides this to point to their String[] tokenNames.
+        /// </remarks>
+
+        public abstract string[] RuleNames
+        {
+            get;
+        }
+
+
+        /// <summary>Get the vocabulary used by the recognizer.</summary>
+        /// <remarks>Get the vocabulary used by the recognizer.</remarks>
+        /// <returns>
+        /// A
+        /// <see cref="IVocabulary"/>
+        /// instance providing information about the
+        /// vocabulary used by the grammar.
+        /// </returns>
+        public abstract IVocabulary Vocabulary
+        {
+			get;
+       }
+
+        /// <summary>Get a map from token names to token types.</summary>
+        /// <remarks>
+        /// Get a map from token names to token types.
+        /// <p>Used for XPath and tree pattern compilation.</p>
+        /// </remarks>
+        [NotNull]
+        public virtual IDictionary<string, int> TokenTypeMap
+        {
+            get
+            {
+#if NET40PLUS
+                return tokenTypeMapCache.GetValue(Vocabulary, CreateTokenTypeMap);
+#else
+                return CreateTokenTypeMap(Vocabulary);
+#endif
+            }
+        }
+
+        protected virtual IDictionary<string, int> CreateTokenTypeMap(IVocabulary vocabulary)
+        {
+            var result = new Dictionary<string, int>();
+            for (int i = 0; i < Atn.maxTokenType; i++)
+            {
+                string literalName = vocabulary.GetLiteralName(i);
+                if (literalName != null)
+                {
+                    result[literalName] = i;
+                }
+                string symbolicName = vocabulary.GetSymbolicName(i);
+                if (symbolicName != null)
+                {
+                    result[symbolicName] = i;
+                }
+            }
+            result["EOF"] = TokenConstants.Eof;
+            return result;
+        }
+
+        /// <summary>Get a map from rule names to rule indexes.</summary>
+        /// <remarks>
+        /// Get a map from rule names to rule indexes.
+        /// <p>Used for XPath and tree pattern compilation.</p>
+        /// </remarks>
+        [NotNull]
+        public virtual IDictionary<string, int> RuleIndexMap
+        {
+            get
+            {
+                string[] ruleNames = RuleNames;
+                if (ruleNames == null)
+                {
+                    throw new NotSupportedException("The current recognizer does not provide a list of rule names.");
+                }
+#if NET40PLUS
+                return ruleIndexMapCache.GetValue(ruleNames, Utils.ToMap);
+#else
+                return Utils.ToMap(ruleNames);
+#endif
+            }
+        }
+
+        public virtual int GetTokenType(string tokenName)
+        {
+            int ttype;
+            if (TokenTypeMap.TryGetValue(tokenName, out ttype))
+            {
+                return ttype;
+            }
+            return TokenConstants.InvalidType;
+        }
+
+        /// <summary>
+        /// If this recognizer was generated, it will have a serialized ATN
+        /// representation of the grammar.
+        /// </summary>
+        /// <remarks>
+        /// If this recognizer was generated, it will have a serialized ATN
+        /// representation of the grammar.
+        /// <p>For interpreters, we don't know their serialized ATN despite having
+        /// created the interpreter from it.</p>
+        /// </remarks>
+        public virtual string SerializedAtn
+        {
+            [return: NotNull]
+            get
+            {
+                throw new NotSupportedException("there is no serialized ATN");
+            }
+        }
+
+        /// <summary>For debugging and other purposes, might want the grammar name.</summary>
+        /// <remarks>
+        /// For debugging and other purposes, might want the grammar name.
+        /// Have ANTLR generate an implementation for this method.
+        /// </remarks>
+        public abstract string GrammarFileName
+        {
+            get;
+        }
+
+        /// <summary>
+        /// Get the
+        /// <see cref="Antlr4.Runtime.Atn.ATN"/>
+        /// used by the recognizer for prediction.
+        /// </summary>
+        /// <returns>
+        /// The
+        /// <see cref="Antlr4.Runtime.Atn.ATN"/>
+        /// used by the recognizer for prediction.
+        /// </returns>
+        public virtual ATN Atn
+        {
+            get
+            {
+                return _interp.atn;
+            }
+        }
+
+        /// <summary>Get the ATN interpreter used by the recognizer for prediction.</summary>
+        /// <remarks>Get the ATN interpreter used by the recognizer for prediction.</remarks>
+        /// <returns>The ATN interpreter used by the recognizer for prediction.</returns>
+        /// <summary>Set the ATN interpreter used by the recognizer for prediction.</summary>
+        /// <remarks>Set the ATN interpreter used by the recognizer for prediction.</remarks>
+        /// <value>
+        /// The ATN interpreter used by the recognizer for
+        /// prediction.
+        /// </value>
+        public virtual ATNInterpreter Interpreter
+        {
+            get
+            {
+                return _interp;
+            }
+            protected set
+            {
+				_interp = value;
+            }
+        }
+
+        /// <summary>
+        /// If profiling during the parse/lex, this will return DecisionInfo records
+        /// for each decision in recognizer in a ParseInfo object.
+        /// </summary>
+        /// <remarks>
+        /// If profiling during the parse/lex, this will return DecisionInfo records
+        /// for each decision in recognizer in a ParseInfo object.
+        /// </remarks>
+        /// <since>4.3</since>
+        public virtual Antlr4.Runtime.Atn.ParseInfo ParseInfo
+        {
+            get
+            {
+                return null;
+            }
+        }
+
+        /// <summary>What is the error header, normally line/character position information?</summary>
+        [return: NotNull]
+        public virtual string GetErrorHeader(RecognitionException e)
+        {
+            int line = e.OffendingToken.Line;
+            int charPositionInLine = e.OffendingToken.Column;
+            return "line " + line + ":" + charPositionInLine;
+        }
+
+        /// <summary>
+        /// How should a token be displayed in an error message? The default
+        /// is to display just the text, but during development you might
+        /// want to have a lot of information spit out.
+        /// </summary>
+        /// <remarks>
+        /// How should a token be displayed in an error message? The default
+        /// is to display just the text, but during development you might
+        /// want to have a lot of information spit out.  Override in that case
+        /// to use t.toString() (which, for CommonToken, dumps everything about
+        /// the token). This is better than forcing you to override a method in
+        /// your token objects because you don't have to go modify your lexer
+        /// so that it creates a new Java type.
+        /// </remarks>
+        [ObsoleteAttribute(@"This method is not called by the ANTLR 4 Runtime. Specific implementations of IAntlrErrorStrategy may provide a similar feature when necessary. For example, see DefaultErrorStrategy.GetTokenErrorDisplay(IToken).")]
+        public virtual string GetTokenErrorDisplay(IToken t)
+        {
+            if (t == null)
+            {
+                return "<no token>";
+            }
+            string s = t.Text;
+            if (s == null)
+            {
+                if (t.Type == TokenConstants.Eof)
+                {
+                    s = "<EOF>";
+                }
+                else
+                {
+                    s = "<" + t.Type + ">";
+                }
+            }
+            s = s.Replace("\n", "\\n");
+            s = s.Replace("\r", "\\r");
+            s = s.Replace("\t", "\\t");
+            return "'" + s + "'";
+        }
+
+        /// <exception>
+        /// NullPointerException
+        /// if
+        /// <paramref name="listener"/>
+        /// is
+        /// <see langword="null"/>
+        /// .
+        /// </exception>
+        public virtual void AddErrorListener(IAntlrErrorListener<Symbol> listener)
+        {
+            Args.NotNull("listener", listener);
+
+            IAntlrErrorListener<Symbol>[] listeners = _listeners;
+            Array.Resize(ref listeners, listeners.Length + 1);
+            listeners[listeners.Length - 1] = listener;
+            _listeners = listeners;
+        }
+
+        public virtual void RemoveErrorListener(IAntlrErrorListener<Symbol> listener)
+        {
+            IAntlrErrorListener<Symbol>[] listeners = _listeners;
+            int removeIndex = Array.IndexOf(listeners, listener);
+            if (removeIndex < 0)
+                return;
+
+            Array.Copy(listeners, removeIndex + 1, listeners, removeIndex, listeners.Length - removeIndex - 1);
+            Array.Resize(ref listeners, listeners.Length - 1);
+            _listeners = listeners;
+        }
+
+        public virtual void RemoveErrorListeners()
+        {
+            _listeners = new IAntlrErrorListener<Symbol>[0];
+        }
+
+        [NotNull]
+        public virtual IList<IAntlrErrorListener<Symbol>> ErrorListeners
+        {
+            get
+            {
+                return new List<IAntlrErrorListener<Symbol>>(_listeners);
+            }
+        }
+
+        public virtual IAntlrErrorListener<Symbol> ErrorListenerDispatch
+        {
+            get
+            {
+                return new ProxyErrorListener<Symbol>(ErrorListeners);
+            }
+        }
+
+        // subclass needs to override these if there are sempreds or actions
+        // that the ATN interp needs to execute
+        public virtual bool Sempred(RuleContext _localctx, int ruleIndex, int actionIndex)
+        {
+            return true;
+        }
+
+        public virtual bool Precpred(RuleContext localctx, int precedence)
+        {
+            return true;
+        }
+
+        public virtual void Action(RuleContext _localctx, int ruleIndex, int actionIndex)
+        {
+        }
+
+        /// <summary>
+        /// Indicate that the recognizer has changed internal state that is
+        /// consistent with the ATN state passed in.
+        /// </summary>
+        /// <remarks>
+        /// Indicate that the recognizer has changed internal state that is
+        /// consistent with the ATN state passed in.  This way we always know
+        /// where we are in the ATN as the parser goes along. The rule
+        /// context objects form a stack that lets us see the stack of
+        /// invoking rules. Combine this and we have complete ATN
+        /// configuration information.
+        /// </remarks>
+        public int State
+        {
+            get
+            {
+                return _stateNumber;
+            }
+            set
+            {
+                int atnState = value;
+                //		System.err.println("setState "+atnState);
+                _stateNumber = atnState;
+            }
+        }
+
+        public abstract IIntStream InputStream
+        {
+            get;
+        }
+        //		if ( traceATNStates ) _ctx.trace(atnState);
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/RuleContext.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/RuleContext.cs
new file mode 100644
index 000000000..54a968ffa
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/RuleContext.cs
@@ -0,0 +1,345 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System.Collections.Generic;
+using System.Text;
+using Antlr4.Runtime;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+using Antlr4.Runtime.Tree;
+
+namespace Antlr4.Runtime
+{
+    /// <summary>A rule context is a record of a single rule invocation.</summary>
+    /// <remarks>
+    /// A rule context is a record of a single rule invocation. It knows
+    /// which context invoked it, if any. If there is no parent context, then
+    /// naturally the invoking state is not valid.  The parent link
+    /// provides a chain upwards from the current rule invocation to the root
+    /// of the invocation tree, forming a stack. We actually carry no
+    /// information about the rule associated with this context (except
+    /// when parsing). We keep only the state number of the invoking state from
+    /// the ATN submachine that invoked this. Contrast this with the s
+    /// pointer inside ParserRuleContext that tracks the current state
+    /// being "executed" for the current rule.
+    /// The parent contexts are useful for computing lookahead sets and
+    /// getting error information.
+    /// These objects are used during parsing and prediction.
+    /// For the special case of parsers, we use the subclass
+    /// ParserRuleContext.
+    /// </remarks>
+    /// <seealso cref="ParserRuleContext"/>
+    public class RuleContext : IRuleNode
+    {
+        /// <summary>What context invoked this rule?</summary>
+        private Antlr4.Runtime.RuleContext _parent;
+
+        /// <summary>
+        /// What state invoked the rule associated with this context?
+        /// The "return address" is the followState of invokingState
+        /// If parent is null, this should be -1.
+        /// </summary>
+        /// <remarks>
+        /// What state invoked the rule associated with this context?
+        /// The "return address" is the followState of invokingState
+        /// If parent is null, this should be -1.
+        /// </remarks>
+        public int invokingState = -1;
+
+        public RuleContext()
+        {
+        }
+
+        public RuleContext(Antlr4.Runtime.RuleContext parent, int invokingState)
+        {
+            this._parent = parent;
+            //if ( parent!=null ) System.out.println("invoke "+stateNumber+" from "+parent);
+            this.invokingState = invokingState;
+        }
+
+        public static Antlr4.Runtime.RuleContext GetChildContext(Antlr4.Runtime.RuleContext parent, int invokingState)
+        {
+            return new Antlr4.Runtime.RuleContext(parent, invokingState);
+        }
+
+        public virtual int Depth()
+        {
+            int n = 0;
+            Antlr4.Runtime.RuleContext p = this;
+            while (p != null)
+            {
+                p = p._parent;
+                n++;
+            }
+            return n;
+        }
+
+        /// <summary>
+        /// A context is empty if there is no invoking state; meaning nobody call
+        /// current context.
+        /// </summary>
+        /// <remarks>
+        /// A context is empty if there is no invoking state; meaning nobody call
+        /// current context.
+        /// </remarks>
+        public virtual bool IsEmpty
+        {
+            get
+            {
+                return invokingState == -1;
+            }
+        }
+
+        public virtual Interval SourceInterval
+        {
+            get
+            {
+                // satisfy the ParseTree / SyntaxTree interface
+                return Interval.Invalid;
+            }
+        }
+
+        RuleContext IRuleNode.RuleContext
+        {
+            get
+            {
+                return this;
+            }
+        }
+
+        public virtual Antlr4.Runtime.RuleContext Parent
+        {
+            get
+            {
+                return _parent;
+            }
+			set
+			{
+				_parent = value;
+			}
+        }
+
+        IRuleNode IRuleNode.Parent
+        {
+            get
+            {
+                return Parent;
+            }
+        }
+
+        IParseTree IParseTree.Parent
+        {
+            get
+            {
+                return Parent;
+            }
+        }
+
+        ITree ITree.Parent
+        {
+            get
+            {
+                return Parent;
+            }
+        }
+
+        public virtual Antlr4.Runtime.RuleContext Payload
+        {
+            get
+            {
+                return this;
+            }
+        }
+
+        object ITree.Payload
+        {
+            get
+            {
+                return Payload;
+            }
+        }
+
+        /// <summary>Return the combined text of all child nodes.</summary>
+        /// <remarks>
+        /// Return the combined text of all child nodes. This method only considers
+        /// tokens which have been added to the parse tree.
+        /// <p/>
+        /// Since tokens on hidden channels (e.g. whitespace or comments) are not
+        /// added to the parse trees, they will not appear in the output of this
+        /// method.
+        /// </remarks>
+        public virtual string GetText()
+        {
+            if (ChildCount == 0)
+            {
+                return string.Empty;
+            }
+            StringBuilder builder = new StringBuilder();
+            for (int i = 0; i < ChildCount; i++)
+            {
+                builder.Append(GetChild(i).GetText());
+            }
+            return builder.ToString();
+        }
+
+        public virtual int RuleIndex
+        {
+            get
+            {
+                return -1;
+            }
+        }
+
+	/* For rule associated with this parse tree internal node, return
+	 * the outer alternative number used to match the input. Default
+	 * implementation does not compute nor store this alt num. Create
+	 * a subclass of ParserRuleContext with backing field and set
+	 * option contextSuperClass.
+	 * to set it.
+	 */
+	public virtual int getAltNumber() { return Atn.ATN.InvalidAltNumber; }
+
+	/* Set the outer alternative number for this context node. Default
+	 * implementation does nothing to avoid backing field overhead for
+	 * trees that don't need it.  Create
+     * a subclass of ParserRuleContext with backing field and set
+     * option contextSuperClass.
+	 */
+	public virtual void setAltNumber(int altNumber) { }
+
+        public virtual IParseTree GetChild(int i)
+        {
+            return null;
+        }
+
+        ITree ITree.GetChild(int i)
+        {
+            return GetChild(i);
+        }
+
+        public virtual int ChildCount
+        {
+            get
+            {
+                return 0;
+            }
+        }
+
+        public virtual T Accept<T>(IParseTreeVisitor<T> visitor)
+        {
+            return visitor.VisitChildren(this);
+        }
+
+        /// <summary>
+        /// Print out a whole tree, not just a node, in LISP format
+        /// (root child1 ..
+        /// </summary>
+        /// <remarks>
+        /// Print out a whole tree, not just a node, in LISP format
+        /// (root child1 .. childN). Print just a node if this is a leaf.
+        /// We have to know the recognizer so we can get rule names.
+        /// </remarks>
+        public virtual string ToStringTree(Parser recog)
+        {
+            return Trees.ToStringTree(this, recog);
+        }
+
+        /// <summary>
+        /// Print out a whole tree, not just a node, in LISP format
+        /// (root child1 ..
+        /// </summary>
+        /// <remarks>
+        /// Print out a whole tree, not just a node, in LISP format
+        /// (root child1 .. childN). Print just a node if this is a leaf.
+        /// </remarks>
+        public virtual string ToStringTree(IList<string> ruleNames)
+        {
+            return Trees.ToStringTree(this, ruleNames);
+        }
+
+        public virtual string ToStringTree()
+        {
+            return ToStringTree((IList<string>)null);
+        }
+
+        public override string ToString()
+        {
+            return ToString((IList<string>)null, (Antlr4.Runtime.RuleContext)null);
+        }
+
+        public string ToString(IRecognizer recog)
+        {
+            return ToString(recog, ParserRuleContext.EmptyContext);
+        }
+
+        public string ToString(IList<string> ruleNames)
+        {
+            return ToString(ruleNames, null);
+        }
+
+        // recog null unless ParserRuleContext, in which case we use subclass toString(...)
+        public virtual string ToString(IRecognizer recog, Antlr4.Runtime.RuleContext stop)
+        {
+            string[] ruleNames = recog != null ? recog.RuleNames : null;
+            IList<string> ruleNamesList = ruleNames != null ? Arrays.AsList(ruleNames) : null;
+            return ToString(ruleNamesList, stop);
+        }
+
+        public virtual string ToString(IList<string> ruleNames, Antlr4.Runtime.RuleContext stop)
+        {
+            StringBuilder buf = new StringBuilder();
+            Antlr4.Runtime.RuleContext p = this;
+            buf.Append("[");
+            while (p != null && p != stop)
+            {
+                if (ruleNames == null)
+                {
+                    if (!p.IsEmpty)
+                    {
+                        buf.Append(p.invokingState);
+                    }
+                }
+                else
+                {
+                    int ruleIndex = p.RuleIndex;
+                    string ruleName = ruleIndex >= 0 && ruleIndex < ruleNames.Count ? ruleNames[ruleIndex] : ruleIndex.ToString();
+                    buf.Append(ruleName);
+                }
+                if (p.Parent != null && (ruleNames != null || !p.Parent.IsEmpty))
+                {
+                    buf.Append(" ");
+                }
+                p = p.Parent;
+            }
+            buf.Append("]");
+            return buf.ToString();
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/RuleDependencyAttribute.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/RuleDependencyAttribute.cs
new file mode 100644
index 000000000..a3a9f59b1
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/RuleDependencyAttribute.cs
@@ -0,0 +1,61 @@
+namespace Antlr4.Runtime
+{
+    using System;
+
+    [AttributeUsage(AttributeTargets.All, Inherited = false, AllowMultiple = true)]
+    public sealed class RuleDependencyAttribute : Attribute
+    {
+        private readonly Type _recognizer;
+        private readonly int _rule;
+        private readonly int _version;
+        private readonly Dependents _dependents;
+
+        public RuleDependencyAttribute(Type recognizer, int rule, int version)
+        {
+            this._recognizer = recognizer;
+            this._rule = rule;
+            this._version = version;
+            this._dependents = Dependents.Parents | Dependents.Self;
+        }
+
+        public RuleDependencyAttribute(Type recognizer, int rule, int version, Dependents dependents)
+        {
+            this._recognizer = recognizer;
+            this._rule = rule;
+            this._version = version;
+            this._dependents = dependents | Dependents.Self;
+        }
+
+        public Type Recognizer
+        {
+            get
+            {
+                return _recognizer;
+            }
+        }
+
+        public int Rule
+        {
+            get
+            {
+                return _rule;
+            }
+        }
+
+        public int Version
+        {
+            get
+            {
+                return _version;
+            }
+        }
+
+        public Dependents Dependents
+        {
+            get
+            {
+                return _dependents;
+            }
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/RuleVersionAttribute.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/RuleVersionAttribute.cs
new file mode 100644
index 000000000..2fa8ed137
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/RuleVersionAttribute.cs
@@ -0,0 +1,23 @@
+namespace Antlr4.Runtime
+{
+    using System;
+
+    [AttributeUsage(AttributeTargets.Method, Inherited = false, AllowMultiple = false)]
+    public sealed class RuleVersionAttribute : Attribute
+    {
+        private readonly int _version;
+
+        public RuleVersionAttribute(int version)
+        {
+            _version = version;
+        }
+
+        public int Version
+        {
+            get
+            {
+                return _version;
+            }
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Sharpen/Arrays.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Sharpen/Arrays.cs
new file mode 100644
index 000000000..13aaddffe
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Sharpen/Arrays.cs
@@ -0,0 +1,112 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+namespace Antlr4.Runtime.Sharpen
+{
+    using System;
+    using System.Collections.Generic;
+    using StringBuilder = System.Text.StringBuilder;
+
+    internal static class Arrays
+    {
+        public static T[] CopyOf<T>(T[] array, int newSize)
+        {
+            if (array.Length == newSize)
+                return (T[])array.Clone();
+
+            Array.Resize(ref array, newSize);
+            return array;
+        }
+
+        public static IList<T> AsList<T>(params T[] array)
+        {
+            return array;
+        }
+
+        public static void Fill<T>(T[] array, T value)
+        {
+            for (int i = 0; i < array.Length; i++)
+                array[i] = value;
+        }
+
+        public static int HashCode<T>(T[] array)
+        {
+            if (array == null)
+                return 0;
+
+            int result = 1;
+            foreach (object o in array)
+                result = 31 * result + (o == null ? 0 : o.GetHashCode());
+
+            return result;
+        }
+
+        public static bool Equals<T>(T[] left, T[] right)
+        {
+            if (left == right)
+                return true;
+            else if (left == null || right == null)
+                return false;
+
+            if (left.Length != right.Length)
+                return false;
+
+            for (int i = 0; i < left.Length; i++)
+            {
+                if (!object.Equals(left[i], right[i]))
+                    return false;
+            }
+
+            return true;
+        }
+
+        public static string ToString<T>(T[] array)
+        {
+            if (array == null)
+                return "null";
+
+            StringBuilder builder = new StringBuilder();
+            builder.Append('[');
+            for (int i = 0; i < array.Length; i++)
+            {
+                if (i > 0)
+                    builder.Append(", ");
+
+                T o = array[i];
+                if (o == null)
+                    builder.Append("null");
+                else
+                    builder.Append(o);
+            }
+
+            builder.Append(']');
+            return builder.ToString();
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Sharpen/AtomicReference.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Sharpen/AtomicReference.cs
new file mode 100644
index 000000000..0377b9265
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Sharpen/AtomicReference.cs
@@ -0,0 +1,69 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+namespace Antlr4.Runtime.Sharpen
+{
+    using Interlocked = System.Threading.Interlocked;
+
+    public class AtomicReference<T>
+        where T : class
+    {
+#pragma warning disable 0420 // 'fieldname': a reference to a volatile field will not be treated as volatile
+        private volatile T _value;
+
+        public AtomicReference()
+        {
+        }
+
+        public AtomicReference(T value)
+        {
+            _value = value;
+        }
+
+        public T Get()
+        {
+            return _value;
+        }
+
+        public void Set(T value)
+        {
+            _value = value;
+        }
+
+        public bool CompareAndSet(T expect, T update)
+        {
+            return Interlocked.CompareExchange(ref _value, update, expect) == expect;
+        }
+
+        public T GetAndSet(T value)
+        {
+            return Interlocked.Exchange(ref _value, value);
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Sharpen/BitSet.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Sharpen/BitSet.cs
new file mode 100644
index 000000000..9d6e75b41
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Sharpen/BitSet.cs
@@ -0,0 +1,313 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+namespace Antlr4.Runtime.Sharpen
+{
+    using System;
+    using System.Text;
+
+    public class BitSet
+    {
+        private static readonly ulong[] EmptyBits = new ulong[0];
+        private const int BitsPerElement = 8 * sizeof(ulong);
+
+        private ulong[] _data = EmptyBits;
+
+        public BitSet()
+        {
+        }
+
+        public BitSet(int nbits)
+        {
+            if (nbits < 0)
+                throw new ArgumentOutOfRangeException("nbits");
+
+            if (nbits > 0)
+            {
+                int length = (nbits + BitsPerElement - 1) / BitsPerElement;
+                _data = new ulong[length];
+            }
+        }
+
+        private static int GetBitCount(ulong[] value)
+        {
+            int data = 0;
+            uint size = (uint)value.Length;
+            const ulong m1 = 0x5555555555555555;
+            const ulong m2 = 0x3333333333333333;
+            const ulong m4 = 0x0F0F0F0F0F0F0F0F;
+            const ulong m8 = 0x00FF00FF00FF00FF;
+            const ulong m16 = 0x0000FFFF0000FFFF;
+            const ulong h01 = 0x0101010101010101;
+
+            uint bitCount = 0;
+            uint limit30 = size - size % 30;
+
+            // 64-bit tree merging (merging3)
+            for (uint i = 0; i < limit30; i += 30, data += 30)
+            {
+                ulong acc = 0;
+                for (uint j = 0; j < 30; j += 3)
+                {
+                    ulong count1 = value[data + j];
+                    ulong count2 = value[data + j + 1];
+                    ulong half1 = value[data + j + 2];
+                    ulong half2 = half1;
+                    half1 &= m1;
+                    half2 = (half2 >> 1) & m1;
+                    count1 -= (count1 >> 1) & m1;
+                    count2 -= (count2 >> 1) & m1;
+                    count1 += half1;
+                    count2 += half2;
+                    count1 = (count1 & m2) + ((count1 >> 2) & m2);
+                    count1 += (count2 & m2) + ((count2 >> 2) & m2);
+                    acc += (count1 & m4) + ((count1 >> 4) & m4);
+                }
+
+                acc = (acc & m8) + ((acc >> 8) & m8);
+                acc = (acc + (acc >> 16)) & m16;
+                acc = acc + (acc >> 32);
+                bitCount += (uint)acc;
+            }
+
+            // count the bits of the remaining bytes (MAX 29*8) using 
+            // "Counting bits set, in parallel" from the "Bit Twiddling Hacks",
+            // the code uses wikipedia's 64-bit popcount_3() implementation:
+            // http://en.wikipedia.org/wiki/Hamming_weight#Efficient_implementation
+            for (uint i = 0; i < size - limit30; i++)
+            {
+                ulong x = value[data + i];
+                x = x - ((x >> 1) & m1);
+                x = (x & m2) + ((x >> 2) & m2);
+                x = (x + (x >> 4)) & m4;
+                bitCount += (uint)((x * h01) >> 56);
+            }
+
+            return (int)bitCount;
+        }
+
+        private static readonly int[] index64 =
+        {
+            0, 47,  1, 56, 48, 27,  2, 60,
+           57, 49, 41, 37, 28, 16,  3, 61,
+           54, 58, 35, 52, 50, 42, 21, 44,
+           38, 32, 29, 23, 17, 11,  4, 62,
+           46, 55, 26, 59, 40, 36, 15, 53,
+           34, 51, 20, 43, 31, 22, 10, 45,
+           25, 39, 14, 33, 19, 30,  9, 24,
+           13, 18,  8, 12,  7,  6,  5, 63
+        };
+
+        private static int BitScanForward(ulong value)
+        {
+            if (value == 0)
+                return -1;
+
+            const ulong debruijn64 = 0x03f79d71b4cb0a89;
+            return index64[((value ^ (value - 1)) * debruijn64) >> 58];
+        }
+
+        public BitSet Clone()
+        {
+            BitSet result = new BitSet();
+            result._data = (ulong[])_data.Clone();
+            return result;
+        }
+
+        public void Clear(int index)
+        {
+            if (index < 0)
+                throw new ArgumentOutOfRangeException("index");
+
+            int element = index / BitsPerElement;
+            if (element >= _data.Length)
+                return;
+
+            _data[element] &= ~(1UL << (index % BitsPerElement));
+        }
+
+        public bool Get(int index)
+        {
+            if (index < 0)
+                throw new ArgumentOutOfRangeException("index");
+
+            int element = index / BitsPerElement;
+            if (element >= _data.Length)
+                return false;
+
+            return (_data[element] & (1UL << (index % BitsPerElement))) != 0;
+        }
+
+        public void Set(int index)
+        {
+            if (index < 0)
+                throw new ArgumentOutOfRangeException("index");
+
+            int element = index / BitsPerElement;
+            if (element >= _data.Length)
+                Array.Resize(ref _data, Math.Max(_data.Length * 2, element + 1));
+
+            _data[element] |= 1UL << (index % BitsPerElement);
+        }
+
+        public bool IsEmpty()
+        {
+            for (int i = 0; i < _data.Length; i++)
+            {
+                if (_data[i] != 0)
+                    return false;
+            }
+
+            return true;
+        }
+
+        public int Cardinality()
+        {
+            return GetBitCount(_data);
+        }
+
+        public int NextSetBit(int fromIndex)
+        {
+            if (fromIndex < 0)
+                throw new ArgumentOutOfRangeException("fromIndex");
+
+            if (IsEmpty())
+                return -1;
+
+            int i = fromIndex / BitsPerElement;
+            if (i >= _data.Length)
+                return -1;
+
+            ulong current = _data[i] & ~((1UL << (fromIndex % BitsPerElement)) - 1);
+
+            while (true)
+            {
+                int bit = BitScanForward(current);
+                if (bit >= 0)
+                    return bit + i * BitsPerElement;
+
+                i++;
+                if (i >= _data.Length)
+                    break;
+
+                current = _data[i];
+            }
+
+            return -1;
+        }
+
+        public void And(BitSet set)
+        {
+            if (set == null)
+                throw new ArgumentNullException("set");
+
+            int length = Math.Min(_data.Length, set._data.Length);
+            for (int i = 0; i < length; i++)
+                _data[i] &= set._data[i];
+
+            for (int i = length; i < _data.Length; i++)
+                _data[i] = 0;
+        }
+
+        public void Or(BitSet set)
+        {
+            if (set == null)
+                throw new ArgumentNullException("set");
+
+            if (set._data.Length > _data.Length)
+                Array.Resize(ref _data, set._data.Length);
+
+            for (int i = 0; i < set._data.Length; i++)
+                _data[i] |= set._data[i];
+        }
+
+        public override bool Equals(object obj)
+        {
+            BitSet other = obj as BitSet;
+            if (other == null)
+                return false;
+
+            if (IsEmpty())
+                return other.IsEmpty();
+
+            int minLength = Math.Min(_data.Length, other._data.Length);
+            for (int i = 0; i < minLength; i++)
+            {
+                if (_data[i] != other._data[i])
+                    return false;
+            }
+
+            for (int i = minLength; i < _data.Length; i++)
+            {
+                if (_data[i] != 0)
+                    return false;
+            }
+
+            for (int i = minLength; i < other._data.Length; i++)
+            {
+                if (other._data[i] != 0)
+                    return false;
+            }
+
+            return true;
+        }
+
+        public override int GetHashCode()
+        {
+            ulong result = 1;
+            for (uint i = 0; i < _data.Length; i++)
+            {
+                if (_data[i] != 0)
+                {
+                    result = result * 31 ^ i;
+                    result = result * 31 ^ _data[i];
+                }
+            }
+
+            return result.GetHashCode();
+        }
+
+        public override string ToString()
+        {
+            StringBuilder builder = new StringBuilder();
+            builder.Append('{');
+
+            for (int i = NextSetBit(0); i >= 0; i = NextSetBit(i + 1))
+            {
+                if (builder.Length > 1)
+                    builder.Append(", ");
+
+                builder.Append(i);
+            }
+
+            builder.Append('}');
+            return builder.ToString();
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Sharpen/Collections.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Sharpen/Collections.cs
new file mode 100644
index 000000000..45cef1426
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Sharpen/Collections.cs
@@ -0,0 +1,92 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+namespace Antlr4.Runtime.Sharpen
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Collections.ObjectModel;
+
+    internal static class Collections
+    {
+        public static T[] EmptyList<T>()
+        {
+            return EmptyListImpl<T>.Instance;
+        }
+
+#if NET45PLUS
+        public static ReadOnlyDictionary<TKey, TValue> EmptyMap<TKey, TValue>()
+#else
+        public static IDictionary<TKey, TValue> EmptyMap<TKey, TValue>()
+#endif
+        {
+            return EmptyMapImpl<TKey, TValue>.Instance;
+        }
+
+        public static ReadOnlyCollection<T> SingletonList<T>(T item)
+        {
+            return new ReadOnlyCollection<T>(new T[] { item });
+        }
+
+#if NET45PLUS
+        public static ReadOnlyDictionary<TKey, TValue> SingletonMap<TKey, TValue>(TKey key, TValue value)
+#else
+        public static IDictionary<TKey, TValue> SingletonMap<TKey, TValue>(TKey key, TValue value)
+#endif
+        {
+#if NET45PLUS
+            return new ReadOnlyDictionary<TKey,TValue>(new Dictionary<TKey, TValue> { { key, value } });
+#else
+            return new Dictionary<TKey, TValue> { { key, value } };
+#endif
+        }
+
+        private static class EmptyListImpl<T>
+        {
+            public static readonly T[] Instance = new T[0];
+        }
+
+        private static class EmptyMapImpl<TKey, TValue>
+        {
+#if NET45PLUS
+            public static readonly ReadOnlyDictionary<TKey, TValue> Instance =
+                new ReadOnlyDictionary<TKey, TValue>(new Dictionary<TKey, TValue>());
+#else
+            public static IDictionary<TKey, TValue> Instance
+            {
+                get
+                {
+                    return new Dictionary<TKey, TValue>();
+                }
+            }
+#endif
+        }
+    }
+
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Sharpen/Compat/CollectionDebuggerView.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Sharpen/Compat/CollectionDebuggerView.cs
new file mode 100644
index 000000000..b1c0c8664
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Sharpen/Compat/CollectionDebuggerView.cs
@@ -0,0 +1,83 @@
+//
+// CollectionDebuggerView.cs
+//
+// Authors:
+//	Marek Safar  <marek.safar@gmail.com>
+//
+// Copyright (C) 2009 Novell, Inc (http://www.novell.com)
+//
+// 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.
+//
+
+#if !NET40PLUS || (PORTABLE && !WINRT)
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+
+namespace Antlr4.Runtime.Sharpen
+{
+	//
+	// Custom debugger type proxy to display collections as arrays
+	//
+	internal sealed class CollectionDebuggerView<T>
+	{
+		readonly ICollection<T> c;
+
+		public CollectionDebuggerView (ICollection<T> col)
+		{
+			this.c = col;
+		}
+		
+#if !COMPACT
+		[DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
+#endif
+		public T[] Items {
+			get {
+				var o = new T [c.Count];
+				c.CopyTo (o, 0);
+				return o;
+			}
+		}
+	}
+	
+	internal sealed class CollectionDebuggerView<T, U>
+	{
+		readonly ICollection<KeyValuePair<T, U>> c;
+
+		public CollectionDebuggerView (ICollection<KeyValuePair<T, U>> col)
+		{
+			this.c = col;
+		}
+
+#if !COMPACT
+		[DebuggerBrowsable (DebuggerBrowsableState.RootHidden)]
+#endif
+		public KeyValuePair<T, U>[] Items {
+			get {
+				var o = new KeyValuePair<T, U> [c.Count];
+				c.CopyTo (o, 0);
+				return o;
+			}
+		}
+	}	
+}
+
+#endif
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Sharpen/Compat/ConcurrentDictionary.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Sharpen/Compat/ConcurrentDictionary.cs
new file mode 100644
index 000000000..a79467d86
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Sharpen/Compat/ConcurrentDictionary.cs
@@ -0,0 +1,468 @@
+// ConcurrentDictionary.cs
+//
+// Copyright (c) 2009 Jérémie "Garuma" Laval
+//
+// 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.
+//
+//
+
+#if !NET40PLUS || (PORTABLE && !WINRT)
+
+using System;
+using System.Threading;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Runtime.Serialization;
+using System.Diagnostics;
+
+// declare the namespace so Sharpen-generated using declarations will not produce errors
+namespace System.Collections.Concurrent
+{
+}
+
+namespace Antlr4.Runtime.Sharpen
+{
+#if !COMPACT
+	[DebuggerDisplay ("Count={Count}")]
+	[DebuggerTypeProxy (typeof (CollectionDebuggerView<,>))]
+#endif
+	public class ConcurrentDictionary<TKey, TValue> : IDictionary<TKey, TValue>,
+	  ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>,
+	  IDictionary, ICollection, IEnumerable
+	{
+		IEqualityComparer<TKey> comparer;
+
+		SplitOrderedList<TKey, KeyValuePair<TKey, TValue>> internalDictionary;
+
+		public ConcurrentDictionary () : this (EqualityComparer<TKey>.Default)
+		{
+		}
+
+		public ConcurrentDictionary (IEnumerable<KeyValuePair<TKey, TValue>> collection)
+			: this (collection, EqualityComparer<TKey>.Default)
+		{
+		}
+
+		public ConcurrentDictionary (IEqualityComparer<TKey> comparer)
+		{
+			this.comparer = comparer;
+			this.internalDictionary = new SplitOrderedList<TKey, KeyValuePair<TKey, TValue>> (comparer);
+		}
+
+		public ConcurrentDictionary (IEnumerable<KeyValuePair<TKey, TValue>> collection, IEqualityComparer<TKey> comparer)
+			: this (comparer)
+		{
+			foreach (KeyValuePair<TKey, TValue> pair in collection)
+				Add (pair.Key, pair.Value);
+		}
+
+		// Parameters unused
+		public ConcurrentDictionary (int concurrencyLevel, int capacity)
+			: this (EqualityComparer<TKey>.Default)
+		{
+
+		}
+
+		public ConcurrentDictionary (int concurrencyLevel,
+		                             IEnumerable<KeyValuePair<TKey, TValue>> collection,
+		                             IEqualityComparer<TKey> comparer)
+			: this (collection, comparer)
+		{
+
+		}
+
+		// Parameters unused
+		public ConcurrentDictionary (int concurrencyLevel, int capacity, IEqualityComparer<TKey> comparer)
+			: this (comparer)
+		{
+
+		}
+
+		void CheckKey (TKey key)
+		{
+			if (key == null)
+				throw new ArgumentNullException ("key");
+		}
+
+		void Add (TKey key, TValue value)
+		{
+			while (!TryAdd (key, value));
+		}
+
+		void IDictionary<TKey, TValue>.Add (TKey key, TValue value)
+		{
+			Add (key, value);
+		}
+
+		public bool TryAdd (TKey key, TValue value)
+		{
+			CheckKey (key);
+			return internalDictionary.Insert (Hash (key), key, Make (key, value));
+		}
+
+		void ICollection<KeyValuePair<TKey,TValue>>.Add (KeyValuePair<TKey, TValue> pair)
+		{
+			Add (pair.Key, pair.Value);
+		}
+
+		public TValue AddOrUpdate (TKey key, Func<TKey, TValue> addValueFactory, Func<TKey, TValue, TValue> updateValueFactory)
+		{
+			CheckKey (key);
+			if (addValueFactory == null)
+				throw new ArgumentNullException ("addValueFactory");
+			if (updateValueFactory == null)
+				throw new ArgumentNullException ("updateValueFactory");
+			return internalDictionary.InsertOrUpdate (Hash (key),
+			                                          key,
+			                                          () => Make (key, addValueFactory (key)),
+			                                          (e) => Make (key, updateValueFactory (key, e.Value))).Value;
+		}
+
+		public TValue AddOrUpdate (TKey key, TValue addValue, Func<TKey, TValue, TValue> updateValueFactory)
+		{
+			return AddOrUpdate (key, (_) => addValue, updateValueFactory);
+		}
+
+		TValue AddOrUpdate (TKey key, TValue addValue, TValue updateValue)
+		{
+			CheckKey (key);
+			return internalDictionary.InsertOrUpdate (Hash (key),
+			                                          key,
+			                                          Make (key, addValue),
+			                                          Make (key, updateValue)).Value;
+		}
+
+		TValue GetValue (TKey key)
+		{
+			TValue temp;
+			if (!TryGetValue (key, out temp))
+				throw new KeyNotFoundException (key.ToString ());
+			return temp;
+		}
+
+		public bool TryGetValue (TKey key, out TValue value)
+		{
+			CheckKey (key);
+			KeyValuePair<TKey, TValue> pair;
+			bool result = internalDictionary.Find (Hash (key), key, out pair);
+			value = pair.Value;
+
+			return result;
+		}
+
+		public bool TryUpdate (TKey key, TValue newValue, TValue comparisonValue)
+		{
+			CheckKey (key);
+			return internalDictionary.CompareExchange (Hash (key), key, Make (key, newValue), (e) => e.Value.Equals (comparisonValue));
+		}
+
+		public TValue this[TKey key] {
+			get {
+				return GetValue (key);
+			}
+			set {
+				AddOrUpdate (key, value, value);
+			}
+		}
+
+		public TValue GetOrAdd (TKey key, Func<TKey, TValue> valueFactory)
+		{
+			CheckKey (key);
+			return internalDictionary.InsertOrGet (Hash (key), key, Make (key, default(TValue)), () => Make (key, valueFactory (key))).Value;
+		}
+
+		public TValue GetOrAdd (TKey key, TValue value)
+		{
+			CheckKey (key);
+			return internalDictionary.InsertOrGet (Hash (key), key, Make (key, value), null).Value;
+		}
+
+		public bool TryRemove (TKey key, out TValue value)
+		{
+			CheckKey (key);
+			KeyValuePair<TKey, TValue> data;
+			bool result = internalDictionary.Delete (Hash (key), key, out data);
+			value = data.Value;
+			return result;
+		}
+
+		bool Remove (TKey key)
+		{
+			TValue dummy;
+
+			return TryRemove (key, out dummy);
+		}
+
+		bool IDictionary<TKey, TValue>.Remove (TKey key)
+		{
+			return Remove (key);
+		}
+
+		bool ICollection<KeyValuePair<TKey,TValue>>.Remove (KeyValuePair<TKey,TValue> pair)
+		{
+			return Remove (pair.Key);
+		}
+
+		public bool ContainsKey (TKey key)
+		{
+			CheckKey (key);
+			KeyValuePair<TKey, TValue> dummy;
+			return internalDictionary.Find (Hash (key), key, out dummy);
+		}
+
+		bool IDictionary.Contains (object key)
+		{
+			if (!(key is TKey))
+				return false;
+
+			return ContainsKey ((TKey)key);
+		}
+
+		void IDictionary.Remove (object key)
+		{
+			if (!(key is TKey))
+				return;
+
+			Remove ((TKey)key);
+		}
+
+		object IDictionary.this [object key]
+		{
+			get {
+				if (!(key is TKey))
+					throw new ArgumentException ("key isn't of correct type", "key");
+
+				return this[(TKey)key];
+			}
+			set {
+				if (!(key is TKey) || !(value is TValue))
+					throw new ArgumentException ("key or value aren't of correct type");
+
+				this[(TKey)key] = (TValue)value;
+			}
+		}
+
+		void IDictionary.Add (object key, object value)
+		{
+			if (!(key is TKey) || !(value is TValue))
+				throw new ArgumentException ("key or value aren't of correct type");
+
+			Add ((TKey)key, (TValue)value);
+		}
+
+		bool ICollection<KeyValuePair<TKey,TValue>>.Contains (KeyValuePair<TKey, TValue> pair)
+		{
+			return ContainsKey (pair.Key);
+		}
+
+		public KeyValuePair<TKey,TValue>[] ToArray ()
+		{
+			// This is most certainly not optimum but there is
+			// not a lot of possibilities
+
+			return new List<KeyValuePair<TKey,TValue>> (this).ToArray ();
+		}
+
+		public void Clear()
+		{
+			// Pronk
+			internalDictionary = new SplitOrderedList<TKey, KeyValuePair<TKey, TValue>> (comparer);
+		}
+
+		public int Count {
+			get {
+				return internalDictionary.Count;
+			}
+		}
+
+		public bool IsEmpty {
+			get {
+				return Count == 0;
+			}
+		}
+
+		bool ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly {
+			get {
+				return false;
+			}
+		}
+
+		bool IDictionary.IsReadOnly {
+			get {
+				return false;
+			}
+		}
+
+		public ICollection<TKey> Keys {
+			get {
+				return GetPart<TKey> ((kvp) => kvp.Key);
+			}
+		}
+
+		public ICollection<TValue> Values {
+			get {
+				return GetPart<TValue> ((kvp) => kvp.Value);
+			}
+		}
+
+		ICollection IDictionary.Keys {
+			get {
+				return (ICollection)Keys;
+			}
+		}
+
+		ICollection IDictionary.Values {
+			get {
+				return (ICollection)Values;
+			}
+		}
+
+		ICollection<T> GetPart<T> (Func<KeyValuePair<TKey, TValue>, T> extractor)
+		{
+			List<T> temp = new List<T> ();
+
+			foreach (KeyValuePair<TKey, TValue> kvp in this)
+				temp.Add (extractor (kvp));
+
+			return new ReadOnlyCollection<T>(temp);
+		}
+
+		void ICollection.CopyTo (Array array, int startIndex)
+		{
+			KeyValuePair<TKey, TValue>[] arr = array as KeyValuePair<TKey, TValue>[];
+			if (arr == null)
+				return;
+
+			CopyTo (arr, startIndex, Count);
+		}
+
+		void CopyTo (KeyValuePair<TKey, TValue>[] array, int startIndex)
+		{
+			CopyTo (array, startIndex, Count);
+		}
+
+		void ICollection<KeyValuePair<TKey, TValue>>.CopyTo (KeyValuePair<TKey, TValue>[] array, int startIndex)
+		{
+			CopyTo (array, startIndex);
+		}
+
+		void CopyTo (KeyValuePair<TKey, TValue>[] array, int startIndex, int num)
+		{
+			foreach (var kvp in this) {
+				array [startIndex++] = kvp;
+
+				if (--num <= 0)
+					return;
+			}
+		}
+
+		public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator ()
+		{
+			return GetEnumeratorInternal ();
+		}
+
+		IEnumerator IEnumerable.GetEnumerator ()
+		{
+			return (IEnumerator)GetEnumeratorInternal ();
+		}
+
+		IEnumerator<KeyValuePair<TKey, TValue>> GetEnumeratorInternal ()
+		{
+			return internalDictionary.GetEnumerator ();
+		}
+
+		IDictionaryEnumerator IDictionary.GetEnumerator ()
+		{
+			return new ConcurrentDictionaryEnumerator (GetEnumeratorInternal ());
+		}
+
+		class ConcurrentDictionaryEnumerator : IDictionaryEnumerator
+		{
+			IEnumerator<KeyValuePair<TKey, TValue>> internalEnum;
+
+			public ConcurrentDictionaryEnumerator (IEnumerator<KeyValuePair<TKey, TValue>> internalEnum)
+			{
+				this.internalEnum = internalEnum;
+			}
+
+			public bool MoveNext ()
+			{
+				return internalEnum.MoveNext ();
+			}
+
+			public void Reset ()
+			{
+				internalEnum.Reset ();
+			}
+
+			public object Current {
+				get {
+					return Entry;
+				}
+			}
+
+			public DictionaryEntry Entry {
+				get {
+					KeyValuePair<TKey, TValue> current = internalEnum.Current;
+					return new DictionaryEntry (current.Key, current.Value);
+				}
+			}
+
+			public object Key {
+				get {
+					return internalEnum.Current.Key;
+				}
+			}
+
+			public object Value {
+				get {
+					return internalEnum.Current.Value;
+				}
+			}
+		}
+
+		object ICollection.SyncRoot {
+			get {
+				return this;
+			}
+		}
+
+		bool IDictionary.IsFixedSize {
+			get {
+				return false;
+			}
+		}
+
+		bool ICollection.IsSynchronized {
+			get { return true; }
+		}
+
+		static KeyValuePair<U, V> Make<U, V> (U key, V value)
+		{
+			return new KeyValuePair<U, V> (key, value);
+		}
+
+		uint Hash (TKey key)
+		{
+			return (uint)comparer.GetHashCode (key);
+		}
+	}
+}
+#endif
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Sharpen/Compat/Funcs.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Sharpen/Compat/Funcs.cs
new file mode 100644
index 000000000..9b1c974b6
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Sharpen/Compat/Funcs.cs
@@ -0,0 +1,41 @@
+//
+// System.Func.cs
+//
+// Authors:
+//      Alejandro Serrano "Serras" (trupill@yahoo.es)
+//	Marek Safar (marek.safar@gmail.com)
+//
+
+// 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 TArg 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
+//
+
+#if !NET35PLUS
+
+using System.Runtime.CompilerServices;
+
+namespace Antlr4.Runtime.Sharpen {
+
+	public delegate TResult Func<TResult> ();
+	
+	public delegate TResult Func<T, TResult> (T arg);
+	
+	public delegate TResult Func<in T1, in T2, out TResult> (T1 arg1, T2 arg2);
+}
+
+#endif
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Sharpen/Compat/IStructuralComparable.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Sharpen/Compat/IStructuralComparable.cs
new file mode 100644
index 000000000..0f6b37205
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Sharpen/Compat/IStructuralComparable.cs
@@ -0,0 +1,41 @@
+//
+// IStructuralComparable.cs
+//
+// Authors:
+//  Zoltan Varga (vargaz@gmail.com)
+//
+// Copyright (C) 2009 Novell
+//
+// 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.
+//
+
+#if !NET40PLUS
+
+using System;
+using System.Collections;
+
+namespace Antlr4.Runtime.Sharpen
+{
+	internal interface IStructuralComparable {
+		int CompareTo (object other, IComparer comparer);
+	}
+}
+
+#endif
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Sharpen/Compat/IStructuralEquatable.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Sharpen/Compat/IStructuralEquatable.cs
new file mode 100644
index 000000000..7e8cb1605
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Sharpen/Compat/IStructuralEquatable.cs
@@ -0,0 +1,43 @@
+//
+// IStructuralEquatable.cs
+//
+// Authors:
+//  Zoltan Varga (vargaz@gmail.com)
+//
+// Copyright (C) 2009 Novell
+//
+// 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.
+//
+
+#if !NET40PLUS
+
+using System;
+using System.Collections;
+
+namespace Antlr4.Runtime.Sharpen
+{
+	internal interface IStructuralEquatable {
+		bool Equals (object other, IEqualityComparer comparer);
+
+		int GetHashCode (IEqualityComparer comparer);
+	}
+}
+
+#endif
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Sharpen/Compat/SerializableAttribute.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Sharpen/Compat/SerializableAttribute.cs
new file mode 100644
index 000000000..2855d2831
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Sharpen/Compat/SerializableAttribute.cs
@@ -0,0 +1,11 @@
+#if PORTABLE
+
+namespace System
+{
+    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Delegate, Inherited = false)]
+    internal sealed class SerializableAttribute : Attribute
+    {
+    }
+}
+
+#endif
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Sharpen/Compat/SplitOrderedList.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Sharpen/Compat/SplitOrderedList.cs
new file mode 100644
index 000000000..59b0a3395
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Sharpen/Compat/SplitOrderedList.cs
@@ -0,0 +1,552 @@
+// SplitOrderedList.cs
+//
+// Copyright (c) 2010 Jérémie "Garuma" Laval
+//
+// 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.
+//
+//
+
+#if !NET40PLUS || (PORTABLE && !WINRT)
+
+using System;
+using System.Threading;
+using System.Collections;
+using System.Collections.Generic;
+using System.Runtime.Serialization;
+
+namespace Antlr4.Runtime.Sharpen
+{
+	internal class SplitOrderedList<TKey, T>
+	{
+		class Node
+		{
+			public bool Marked;
+			public ulong Key;
+			public TKey SubKey;
+			public T Data;
+			public Node Next;
+
+			public Node Init (ulong key, TKey subKey, T data)
+			{
+				this.Key = key;
+				this.SubKey = subKey;
+				this.Data = data;
+
+				this.Marked = false;
+				this.Next = null;
+
+				return this;
+			}
+
+			// Used to create dummy node
+			public Node Init (ulong key)
+			{
+				this.Key = key;
+				this.Data = default (T);
+
+				this.Next = null;
+				this.Marked = false;
+				this.SubKey = default (TKey);
+
+				return this;
+			}
+
+			// Used to create marked node
+			public Node Init (Node wrapped)
+			{
+				this.Marked = true;
+				this.Next = wrapped;
+
+				this.Key = 0;
+				this.Data = default (T);
+				this.SubKey = default (TKey);
+
+				return this;
+			}
+		}
+
+		const int MaxLoad = 5;
+		const uint BucketSize = 512;
+
+		Node head;
+		Node tail;
+
+		Node[] buckets = new Node [BucketSize];
+		int count;
+		int size = 2;
+
+		SimpleRwLock slim = new SimpleRwLock ();
+
+		readonly IEqualityComparer<TKey> comparer;
+
+		public SplitOrderedList (IEqualityComparer<TKey> comparer)
+		{
+			this.comparer = comparer;
+			head = new Node ().Init (0);
+			tail = new Node ().Init (ulong.MaxValue);
+			head.Next = tail;
+			SetBucket (0, head);
+		}
+
+		public int Count {
+			get {
+				return count;
+			}
+		}
+
+		public T InsertOrUpdate (uint key, TKey subKey, Func<T> addGetter, Func<T, T> updateGetter)
+		{
+			Node current;
+			bool result = InsertInternal (key, subKey, default (T), addGetter, out current);
+
+			if (result)
+				return current.Data;
+
+			// FIXME: this should have a CAS-like behavior
+			return current.Data = updateGetter (current.Data);
+		}
+
+		public T InsertOrUpdate (uint key, TKey subKey, T addValue, T updateValue)
+		{
+			Node current;
+			if (InsertInternal (key, subKey, addValue, null, out current))
+				return current.Data;
+
+			// FIXME: this should have a CAS-like behavior
+			return current.Data = updateValue;
+		}
+		
+		public bool Insert (uint key, TKey subKey, T data)
+		{
+			Node current;
+			return InsertInternal (key, subKey, data, null, out current);
+		}
+
+		public T InsertOrGet (uint key, TKey subKey, T data, Func<T> dataCreator)
+		{
+			Node current;
+			InsertInternal (key, subKey, data, dataCreator, out current);
+			return current.Data;
+		}
+
+		bool InsertInternal (uint key, TKey subKey, T data, Func<T> dataCreator, out Node current)
+		{
+			Node node = new Node ().Init (ComputeRegularKey (key), subKey, data);
+
+			uint b = key % (uint)size;
+			Node bucket;
+
+			if ((bucket = GetBucket (b)) == null)
+				bucket = InitializeBucket (b);
+
+			if (!ListInsert (node, bucket, out current, dataCreator))
+				return false;
+
+			int csize = size;
+			if (Interlocked.Increment (ref count) / csize > MaxLoad && (csize & 0x40000000) == 0)
+				Interlocked.CompareExchange (ref size, 2 * csize, csize);
+
+			current = node;
+
+			return true;
+		}
+		
+		public bool Find (uint key, TKey subKey, out T data)
+		{
+			Node node;
+			uint b = key % (uint)size;
+			data = default (T);
+			Node bucket;
+
+			if ((bucket = GetBucket (b)) == null)
+				bucket = InitializeBucket (b);
+
+			if (!ListFind (ComputeRegularKey (key), subKey, bucket, out node))
+				return false;
+
+			data = node.Data;
+
+			return !node.Marked;
+		}
+
+		public bool CompareExchange (uint key, TKey subKey, T data, Func<T, bool> check)
+		{
+			Node node;
+			uint b = key % (uint)size;
+			Node bucket;
+
+			if ((bucket = GetBucket (b)) == null)
+				bucket = InitializeBucket (b);
+
+			if (!ListFind (ComputeRegularKey (key), subKey, bucket, out node))
+				return false;
+
+			if (!check (node.Data))
+				return false;
+
+			node.Data = data;
+
+			return true;
+		}
+
+		public bool Delete (uint key, TKey subKey, out T data)
+		{
+			uint b = key % (uint)size;
+			Node bucket;
+
+			if ((bucket = GetBucket (b)) == null)
+				bucket = InitializeBucket (b);
+
+			if (!ListDelete (bucket, ComputeRegularKey (key), subKey, out data))
+				return false;
+
+			Interlocked.Decrement (ref count);
+			return true;
+		}
+
+		public IEnumerator<T> GetEnumerator ()
+		{
+			Node node = head.Next;
+
+			while (node != tail) {
+				while (node.Marked || (node.Key & 1) == 0) {
+					node = node.Next;
+					if (node == tail)
+						yield break;
+				}
+				yield return node.Data;
+				node = node.Next;
+			}
+		}
+
+		Node InitializeBucket (uint b)
+		{
+			Node current;
+			uint parent = GetParent (b);
+			Node bucket;
+
+			if ((bucket = GetBucket (parent)) == null)
+				bucket = InitializeBucket (parent);
+
+			Node dummy = new Node ().Init (ComputeDummyKey (b));
+			if (!ListInsert (dummy, bucket, out current, null))
+				return current;
+
+			return SetBucket (b, dummy);
+		}
+		
+		// Turn v's MSB off
+		static uint GetParent (uint v)
+		{
+			uint t, tt;
+			
+			// Find MSB position in v
+			var pos = (tt = v >> 16) > 0 ?
+				(t = tt >> 8) > 0 ? 24 + logTable[t] : 16 + logTable[tt] :
+				(t = v >> 8) > 0 ? 8 + logTable[t] : logTable[v];
+
+			return (uint)(v & ~(1 << pos));
+		}
+
+		// Reverse integer bits and make sure LSB is set
+		static ulong ComputeRegularKey (uint key)
+		{
+			return ComputeDummyKey (key) | 1;
+		}
+		
+		// Reverse integer bits
+		static ulong ComputeDummyKey (uint key)
+		{
+			return ((ulong)(((uint)reverseTable[key & 0xff] << 24) |
+			                ((uint)reverseTable[(key >> 8) & 0xff] << 16) |
+			                ((uint)reverseTable[(key >> 16) & 0xff] << 8) |
+			                ((uint)reverseTable[(key >> 24) & 0xff]))) << 1;
+		}
+
+		// Bucket storage is abstracted in a simple two-layer tree to avoid too much memory resize
+		Node GetBucket (uint index)
+		{
+			if (index >= buckets.Length)
+				return null;
+			return buckets[index];
+		}
+
+		Node SetBucket (uint index, Node node)
+		{
+			try {
+				slim.EnterReadLock ();
+				CheckSegment (index, true);
+
+				Interlocked.CompareExchange (ref buckets[index], node, null);
+				return buckets[index];
+			} finally {
+				slim.ExitReadLock ();
+			}
+		}
+
+		// When we run out of space for bucket storage, we use a lock-based array resize
+		void CheckSegment (uint segment, bool readLockTaken)
+		{
+			if (segment < buckets.Length)
+				return;
+
+			if (readLockTaken)
+				slim.ExitReadLock ();
+			try {
+				slim.EnterWriteLock ();
+				while (segment >= buckets.Length)
+					Array.Resize (ref buckets, buckets.Length * 2);
+			} finally {
+				slim.ExitWriteLock ();
+			}
+			if (readLockTaken)
+				slim.EnterReadLock ();
+		}
+
+		Node ListSearch (ulong key, TKey subKey, ref Node left, Node h)
+		{
+			Node leftNodeNext = null, rightNode = null;
+
+			do {
+				Node t = h;
+				Node tNext = t.Next;
+				do {
+					if (!tNext.Marked) {
+						left = t;
+						leftNodeNext = tNext;
+					}
+					t = tNext.Marked ? tNext.Next : tNext;
+					if (t == tail)
+						break;
+					
+					tNext = t.Next;
+				} while (tNext.Marked || t.Key < key || (tNext.Key == key && !comparer.Equals (subKey, t.SubKey)));
+				
+				rightNode = t;
+				
+				if (leftNodeNext == rightNode) {
+					if (rightNode != tail && rightNode.Next.Marked)
+						continue;
+					else 
+						return rightNode;
+				}
+				
+				if (Interlocked.CompareExchange (ref left.Next, rightNode, leftNodeNext) == leftNodeNext) {
+					if (rightNode != tail && rightNode.Next.Marked)
+						continue;
+					else
+						return rightNode;
+				}
+			} while (true);
+		}
+
+		bool ListDelete (Node startPoint, ulong key, TKey subKey, out T data)
+		{
+			Node rightNode = null, rightNodeNext = null, leftNode = null;
+			data = default (T);
+			Node markedNode = null;
+			
+			do {
+				rightNode = ListSearch (key, subKey, ref leftNode, startPoint);
+				if (rightNode == tail || rightNode.Key != key || !comparer.Equals (subKey, rightNode.SubKey))
+					return false;
+
+				data = rightNode.Data;
+				rightNodeNext = rightNode.Next;
+
+				if (!rightNodeNext.Marked) {
+					if (markedNode == null)
+						markedNode = new Node ();
+					markedNode.Init (rightNodeNext);
+
+					if (Interlocked.CompareExchange (ref rightNode.Next, markedNode, rightNodeNext) == rightNodeNext)
+						break;
+				}
+			} while (true);
+			
+			if (Interlocked.CompareExchange (ref leftNode.Next, rightNodeNext, rightNode) != rightNode)
+				ListSearch (rightNode.Key, subKey, ref leftNode, startPoint);
+			
+			return true;
+		}
+		
+		bool ListInsert (Node newNode, Node startPoint, out Node current, Func<T> dataCreator)
+		{
+			ulong key = newNode.Key;
+			Node rightNode = null, leftNode = null;
+			
+			do {
+				rightNode = current = ListSearch (key, newNode.SubKey, ref leftNode, startPoint);
+				if (rightNode != tail && rightNode.Key == key && comparer.Equals (newNode.SubKey, rightNode.SubKey))
+					return false;
+				
+				newNode.Next = rightNode;
+				if (dataCreator != null)
+					newNode.Data = dataCreator ();
+				if (Interlocked.CompareExchange (ref leftNode.Next, newNode, rightNode) == rightNode)
+					return true;
+			} while (true);
+		}
+		
+		bool ListFind (ulong key, TKey subKey, Node startPoint, out Node data)
+		{
+			Node rightNode = null, leftNode = null;
+			data = null;
+			
+			rightNode = ListSearch (key, subKey, ref leftNode, startPoint);
+			data = rightNode;
+			
+			return rightNode != tail && rightNode.Key == key && comparer.Equals (subKey, rightNode.SubKey);
+		}
+
+		static readonly byte[] reverseTable = {
+			0, 128, 64, 192, 32, 160, 96, 224, 16, 144, 80, 208, 48, 176, 112, 240, 8, 136, 72, 200, 40, 168, 104, 232, 24, 152, 88, 216, 56, 184, 120, 248, 4, 132, 68, 196, 36, 164, 100, 228, 20, 148, 84, 212, 52, 180, 116, 244, 12, 140, 76, 204, 44, 172, 108, 236, 28, 156, 92, 220, 60, 188, 124, 252, 2, 130, 66, 194, 34, 162, 98, 226, 18, 146, 82, 210, 50, 178, 114, 242, 10, 138, 74, 202, 42, 170, 106, 234, 26, 154, 90, 218, 58, 186, 122, 250, 6, 134, 70, 198, 38, 166, 102, 230, 22, 150, 86, 214, 54, 182, 118, 246, 14, 142, 78, 206, 46, 174, 110, 238, 30, 158, 94, 222, 62, 190, 126, 254, 1, 129, 65, 193, 33, 161, 97, 225, 17, 145, 81, 209, 49, 177, 113, 241, 9, 137, 73, 201, 41, 169, 105, 233, 25, 153, 89, 217, 57, 185, 121, 249, 5, 133, 69, 197, 37, 165, 101, 229, 21, 149, 85, 213, 53, 181, 117, 245, 13, 141, 77, 205, 45, 173, 109, 237, 29, 157, 93, 221, 61, 189, 125, 253, 3, 131, 67, 195, 35, 163, 99, 227, 19, 147, 83, 211, 51, 179, 115, 243, 11, 139, 75, 203, 43, 171, 107, 235, 27, 155, 91, 219, 59, 187, 123, 251, 7, 135, 71, 199, 39, 167, 103, 231, 23, 151, 87, 215, 55, 183, 119, 247, 15, 143, 79, 207, 47, 175, 111, 239, 31, 159, 95, 223, 63, 191, 127, 255
+		};
+
+		static readonly byte[] logTable = {
+			0xFF, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7
+		};
+
+		struct SimpleRwLock
+		{
+			const int RwWait = 1;
+			const int RwWrite = 2;
+			const int RwRead = 4;
+
+			int rwlock;
+
+			public void EnterReadLock ()
+			{
+				SpinWait sw = new SpinWait ();
+				do {
+					while ((rwlock & (RwWrite | RwWait)) > 0)
+						sw.SpinOnce ();
+
+#if COMPACT
+					if ((InterlockedAdd (ref rwlock, RwRead) & (RwWait | RwWait)) == 0)
+						return;
+
+					InterlockedAdd (ref rwlock, -RwRead);
+#else
+					if ((Interlocked.Add (ref rwlock, RwRead) & (RwWait | RwWait)) == 0)
+						return;
+
+					Interlocked.Add (ref rwlock, -RwRead);
+#endif
+				} while (true);
+			}
+
+			public void ExitReadLock ()
+			{
+#if COMPACT
+				InterlockedAdd (ref rwlock, -RwRead);
+#else
+				Interlocked.Add (ref rwlock, -RwRead);
+#endif
+			}
+
+			public void EnterWriteLock ()
+			{
+				SpinWait sw = new SpinWait ();
+				do {
+					int state = rwlock;
+					if (state < RwWrite) {
+						if (Interlocked.CompareExchange (ref rwlock, RwWrite, state) == state)
+							return;
+						state = rwlock;
+					}
+					// We register our interest in taking the Write lock (if upgradeable it's already done)
+					while ((state & RwWait) == 0 && Interlocked.CompareExchange (ref rwlock, state | RwWait, state) != state)
+						state = rwlock;
+					// Before falling to sleep
+					while (rwlock > RwWait)
+						sw.SpinOnce ();
+				} while (true);
+			}
+
+			public void ExitWriteLock ()
+			{
+#if COMPACT
+				InterlockedAdd (ref rwlock, -RwWrite);
+#else
+				Interlocked.Add (ref rwlock, -RwWrite);
+#endif
+			}
+
+#if COMPACT
+			/// <summary>
+			/// Adds two 32-bit integers and replaces the first integer with the sum, as an atomic operation.
+			/// </summary>
+			/// <param name="location1">A variable containing the first value to be added. The sum of the two values is stored in <paramref name="location1"/>.</param>
+			/// <param name="value">The value to be added to the integer at <paramref name="location1"/>.</param>
+			/// <returns>The new value stored at <paramref name="location1"/>.</returns>
+			private static int InterlockedAdd(ref int location1, int value)
+			{
+#if false // the code calling this private method will never make use of this optimization
+				if (value == 1)
+					return Interlocked.Increment(ref location1);
+				else if (value == -1)
+					return Interlocked.Decrement(ref location1);
+#endif
+
+				while (true)
+				{
+					int previous = location1;
+					if (Interlocked.CompareExchange(ref location1, previous + value, previous) == previous)
+						return previous + value;
+				}
+			}
+#endif
+		}
+	}
+
+	internal struct SpinWait
+	{
+		// The number of step until SpinOnce yield on multicore machine
+		const           int  step = 10;
+		const           int  maxTime = 200;
+#if !COMPACT
+		static readonly bool isSingleCpu = (Environment.ProcessorCount == 1);
+#endif
+
+		int ntime;
+
+		public void SpinOnce ()
+		{
+			ntime += 1;
+#if COMPACT
+			Thread.Sleep(0);
+#else
+			ManualResetEvent mre = new ManualResetEvent (false);
+			if (isSingleCpu) {
+				// On a single-CPU system, spinning does no good
+				mre.WaitOne (0);
+			} else {
+				if (ntime % step == 0)
+					mre.WaitOne (0);
+				else
+					// Multi-CPU system might be hyper-threaded, let other thread run
+					mre.WaitOne (Math.Min (ntime, maxTime) << 1);
+			}
+#endif
+		}
+	}
+}
+
+#endif
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Sharpen/Compat/Tuple.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Sharpen/Compat/Tuple.cs
new file mode 100644
index 000000000..ae7979d40
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Sharpen/Compat/Tuple.cs
@@ -0,0 +1,115 @@
+//
+// Tuple.cs
+//
+// Authors:
+//  Zoltan Varga (vargaz@gmail.com)
+//
+// Copyright (C) 2009 Novell
+//
+// 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.
+//
+
+#if !NET40PLUS
+
+using System;
+
+namespace Antlr4.Runtime.Sharpen
+{
+	internal static class Tuple
+	{
+		public static Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8>> Create<T1, T2, T3, T4, T5, T6, T7, T8>
+			(
+			 T1 item1,
+			 T2 item2,
+			 T3 item3,
+			 T4 item4,
+			 T5 item5,
+			 T6 item6,
+			 T7 item7,
+			 T8 item8) {
+			return new Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8>> (item1, item2, item3, item4, item5, item6, item7, new Tuple<T8> (item8));
+		}
+
+		public static Tuple<T1, T2, T3, T4, T5, T6, T7> Create<T1, T2, T3, T4, T5, T6, T7>
+			(
+			 T1 item1,
+			 T2 item2,
+			 T3 item3,
+			 T4 item4,
+			 T5 item5,
+			 T6 item6,
+			 T7 item7) {
+			return new Tuple<T1, T2, T3, T4, T5, T6, T7> (item1, item2, item3, item4, item5, item6, item7);
+		}
+
+		public static Tuple<T1, T2, T3, T4, T5, T6> Create<T1, T2, T3, T4, T5, T6>
+			(
+			 T1 item1,
+			 T2 item2,
+			 T3 item3,
+			 T4 item4,
+			 T5 item5,
+			 T6 item6) {
+			return new Tuple<T1, T2, T3, T4, T5, T6> (item1, item2, item3, item4, item5, item6);
+		}
+
+		public static Tuple<T1, T2, T3, T4, T5> Create<T1, T2, T3, T4, T5>
+			(
+			 T1 item1,
+			 T2 item2,
+			 T3 item3,
+			 T4 item4,
+			 T5 item5) {
+			return new Tuple<T1, T2, T3, T4, T5> (item1, item2, item3, item4, item5);
+		}
+
+		public static Tuple<T1, T2, T3, T4> Create<T1, T2, T3, T4>
+			(
+			 T1 item1,
+			 T2 item2,
+			 T3 item3,
+			 T4 item4) {
+			return new Tuple<T1, T2, T3, T4> (item1, item2, item3, item4);
+		}
+
+		public static Tuple<T1, T2, T3> Create<T1, T2, T3>
+			(
+			 T1 item1,
+			 T2 item2,
+			 T3 item3) {
+			return new Tuple<T1, T2, T3> (item1, item2, item3);
+		}
+
+		public static Tuple<T1, T2> Create<T1, T2>
+			(
+			 T1 item1,
+			 T2 item2) {
+			return new Tuple<T1, T2> (item1, item2);
+		}
+
+		public static Tuple<T1> Create<T1>
+			(
+			 T1 item1) {
+			return new Tuple<T1> (item1);
+		}
+	}		
+}
+	
+#endif
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Sharpen/Compat/Tuples.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Sharpen/Compat/Tuples.cs
new file mode 100644
index 000000000..dda3a9cce
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Sharpen/Compat/Tuples.cs
@@ -0,0 +1,995 @@
+//
+// Tuples.cs
+//
+// Authors:
+//  Zoltan Varga (vargaz@gmail.com)
+//  Marek Safar (marek.safar@gmail.com)
+//
+// Copyright (C) 2009 Novell
+//
+// 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.
+//
+
+#if !NET40PLUS
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace Antlr4.Runtime.Sharpen
+{
+	internal partial class Tuple<T1, T2, T3, T4, T5, T6, T7, TRest>
+	{
+		public Tuple (T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7, TRest rest)
+		{
+			this.item1 = item1;
+			this.item2 = item2;
+			this.item3 = item3;
+			this.item4 = item4;
+			this.item5 = item5;
+			this.item6 = item6;
+			this.item7 = item7;
+			this.rest = rest;
+
+			bool ok = true;
+			if (!typeof (TRest).IsGenericType)
+				ok = false;
+			if (ok) {
+				Type t = typeof (TRest).GetGenericTypeDefinition ();
+				if (!(t == typeof (Tuple<>) || t == typeof (Tuple<,>) || t == typeof (Tuple<,,>) || t == typeof (Tuple<,,,>) || t == typeof (Tuple<,,,,>) || t == typeof (Tuple <,,,,,>) || t == typeof (Tuple<,,,,,,>) || t == typeof (Tuple<,,,,,,,>)))
+					ok = false;
+			}
+			if (!ok)
+				throw new ArgumentException ("rest", "The last element of an eight element tuple must be a Tuple.");
+		}
+	}
+
+	/* The rest is generated by the script at the bottom */
+
+	[Serializable]
+	internal class Tuple<T1> : IStructuralEquatable, IStructuralComparable, IComparable
+	{
+		T1 item1;
+
+		public Tuple (T1 item1)
+		{
+			 this.item1 = item1;
+		}
+
+		public T1 Item1 {
+			get { return item1; }
+		}
+
+		int IComparable.CompareTo (object obj)
+		{
+			return ((IStructuralComparable) this).CompareTo (obj, Comparer<object>.Default);
+		}
+
+		int IStructuralComparable.CompareTo (object other, IComparer comparer)
+		{
+			var t = other as Tuple<T1>;
+			if (t == null) {
+				if (other == null) return 1;
+				throw new ArgumentException ("other");
+			}
+
+			return comparer.Compare (item1, t.item1);
+		}
+
+		public override bool Equals (object obj)
+		{
+			return ((IStructuralEquatable) this).Equals (obj, EqualityComparer<object>.Default);
+		}
+
+		bool IStructuralEquatable.Equals (object other, IEqualityComparer comparer)
+		{
+			var t = other as Tuple<T1>;
+			if (t == null)
+				return false;
+
+			return comparer.Equals (item1, t.item1);
+		}
+
+		public override int GetHashCode ()
+		{
+			return ((IStructuralEquatable) this).GetHashCode (EqualityComparer<object>.Default);
+		}
+
+		int IStructuralEquatable.GetHashCode (IEqualityComparer comparer)
+		{
+			return comparer.GetHashCode (item1);
+		}
+
+		public override string ToString ()
+		{
+			return String.Format ("({0})", item1);
+		}
+	}
+
+	[Serializable]
+	public class Tuple<T1, T2> : IStructuralEquatable, IStructuralComparable, IComparable
+	{
+		T1 item1;
+		T2 item2;
+
+		public Tuple (T1 item1, T2 item2)
+		{
+			 this.item1 = item1;
+			 this.item2 = item2;
+		}
+
+		public T1 Item1 {
+			get { return item1; }
+		}
+
+		public T2 Item2 {
+			get { return item2; }
+		}
+
+		int IComparable.CompareTo (object obj)
+		{
+			return ((IStructuralComparable) this).CompareTo (obj, Comparer<object>.Default);
+		}
+
+		int IStructuralComparable.CompareTo (object other, IComparer comparer)
+		{
+			var t = other as Tuple<T1, T2>;
+			if (t == null) {
+				if (other == null) return 1;
+				throw new ArgumentException ("other");
+			}
+
+			int res = comparer.Compare (item1, t.item1);
+			if (res != 0) return res;
+			return comparer.Compare (item2, t.item2);
+		}
+
+		public override bool Equals (object obj)
+		{
+			return ((IStructuralEquatable) this).Equals (obj, EqualityComparer<object>.Default);
+		}
+
+		bool IStructuralEquatable.Equals (object other, IEqualityComparer comparer)
+		{
+			var t = other as Tuple<T1, T2>;
+			if (t == null)
+				return false;
+
+			return comparer.Equals (item1, t.item1) &&
+				comparer.Equals (item2, t.item2);
+		}
+
+		public override int GetHashCode ()
+		{
+			return ((IStructuralEquatable) this).GetHashCode (EqualityComparer<object>.Default);
+		}
+
+		int IStructuralEquatable.GetHashCode (IEqualityComparer comparer)
+		{
+			int h = comparer.GetHashCode (item1);
+			h = (h << 5) - h + comparer.GetHashCode (item2);
+			return h;
+		}
+
+		public override string ToString ()
+		{
+			return String.Format ("({0}, {1})", item1, item2);
+		}
+	}
+
+	[Serializable]
+	internal class Tuple<T1, T2, T3> : IStructuralEquatable, IStructuralComparable, IComparable
+	{
+		T1 item1;
+		T2 item2;
+		T3 item3;
+
+		public Tuple (T1 item1, T2 item2, T3 item3)
+		{
+			 this.item1 = item1;
+			 this.item2 = item2;
+			 this.item3 = item3;
+		}
+
+		public T1 Item1 {
+			get { return item1; }
+		}
+
+		public T2 Item2 {
+			get { return item2; }
+		}
+
+		public T3 Item3 {
+			get { return item3; }
+		}
+
+		int IComparable.CompareTo (object obj)
+		{
+			return ((IStructuralComparable) this).CompareTo (obj, Comparer<object>.Default);
+		}
+
+		int IStructuralComparable.CompareTo (object other, IComparer comparer)
+		{
+			var t = other as Tuple<T1, T2, T3>;
+			if (t == null) {
+				if (other == null) return 1;
+				throw new ArgumentException ("other");
+			}
+
+			int res = comparer.Compare (item1, t.item1);
+			if (res != 0) return res;
+			res = comparer.Compare (item2, t.item2);
+			if (res != 0) return res;
+			return comparer.Compare (item3, t.item3);
+		}
+
+		public override bool Equals (object obj)
+		{
+			return ((IStructuralEquatable) this).Equals (obj, EqualityComparer<object>.Default);
+		}
+
+		bool IStructuralEquatable.Equals (object other, IEqualityComparer comparer)
+		{
+			var t = other as Tuple<T1, T2, T3>;
+			if (t == null)
+				return false;
+
+			return comparer.Equals (item1, t.item1) &&
+				comparer.Equals (item2, t.item2) &&
+				comparer.Equals (item3, t.item3);
+		}
+
+		public override int GetHashCode ()
+		{
+			return ((IStructuralEquatable) this).GetHashCode (EqualityComparer<object>.Default);
+		}
+
+		int IStructuralEquatable.GetHashCode (IEqualityComparer comparer)
+		{
+			int h = comparer.GetHashCode (item1);
+			h = (h << 5) - h + comparer.GetHashCode (item2);
+			h = (h << 5) - h + comparer.GetHashCode (item3);
+			return h;
+		}
+
+		public override string ToString ()
+		{
+			return String.Format ("({0}, {1}, {2})", item1, item2, item3);
+		}
+	}
+
+	[Serializable]
+	internal class Tuple<T1, T2, T3, T4> : IStructuralEquatable, IStructuralComparable, IComparable
+	{
+		T1 item1;
+		T2 item2;
+		T3 item3;
+		T4 item4;
+
+		public Tuple (T1 item1, T2 item2, T3 item3, T4 item4)
+		{
+			 this.item1 = item1;
+			 this.item2 = item2;
+			 this.item3 = item3;
+			 this.item4 = item4;
+		}
+
+		public T1 Item1 {
+			get { return item1; }
+		}
+
+		public T2 Item2 {
+			get { return item2; }
+		}
+
+		public T3 Item3 {
+			get { return item3; }
+		}
+
+		public T4 Item4 {
+			get { return item4; }
+		}
+
+		int IComparable.CompareTo (object obj)
+		{
+			return ((IStructuralComparable) this).CompareTo (obj, Comparer<object>.Default);
+		}
+
+		int IStructuralComparable.CompareTo (object other, IComparer comparer)
+		{
+			var t = other as Tuple<T1, T2, T3, T4>;
+			if (t == null) {
+				if (other == null) return 1;
+				throw new ArgumentException ("other");
+			}
+
+			int res = comparer.Compare (item1, t.item1);
+			if (res != 0) return res;
+			res = comparer.Compare (item2, t.item2);
+			if (res != 0) return res;
+			res = comparer.Compare (item3, t.item3);
+			if (res != 0) return res;
+			return comparer.Compare (item4, t.item4);
+		}
+
+		public override bool Equals (object obj)
+		{
+			return ((IStructuralEquatable) this).Equals (obj, EqualityComparer<object>.Default);
+		}
+
+		bool IStructuralEquatable.Equals (object other, IEqualityComparer comparer)
+		{
+			var t = other as Tuple<T1, T2, T3, T4>;
+			if (t == null)
+				return false;
+
+			return comparer.Equals (item1, t.item1) &&
+				comparer.Equals (item2, t.item2) &&
+				comparer.Equals (item3, t.item3) &&
+				comparer.Equals (item4, t.item4);
+		}
+
+		public override int GetHashCode ()
+		{
+			return ((IStructuralEquatable) this).GetHashCode (EqualityComparer<object>.Default);
+		}
+
+		int IStructuralEquatable.GetHashCode (IEqualityComparer comparer)
+		{
+			int h = comparer.GetHashCode (item1);
+			h = (h << 5) - h + comparer.GetHashCode (item2);
+			h = (h << 5) - h + comparer.GetHashCode (item3);
+			h = (h << 5) - h + comparer.GetHashCode (item4);
+			return h;
+		}
+
+		public override string ToString ()
+		{
+			return String.Format ("({0}, {1}, {2}, {3})", item1, item2, item3, item4);
+		}
+	}
+
+	[Serializable]
+	internal class Tuple<T1, T2, T3, T4, T5> : IStructuralEquatable, IStructuralComparable, IComparable
+	{
+		T1 item1;
+		T2 item2;
+		T3 item3;
+		T4 item4;
+		T5 item5;
+
+		public Tuple (T1 item1, T2 item2, T3 item3, T4 item4, T5 item5)
+		{
+			 this.item1 = item1;
+			 this.item2 = item2;
+			 this.item3 = item3;
+			 this.item4 = item4;
+			 this.item5 = item5;
+		}
+
+		public T1 Item1 {
+			get { return item1; }
+		}
+
+		public T2 Item2 {
+			get { return item2; }
+		}
+
+		public T3 Item3 {
+			get { return item3; }
+		}
+
+		public T4 Item4 {
+			get { return item4; }
+		}
+
+		public T5 Item5 {
+			get { return item5; }
+		}
+
+		int IComparable.CompareTo (object obj)
+		{
+			return ((IStructuralComparable) this).CompareTo (obj, Comparer<object>.Default);
+		}
+
+		int IStructuralComparable.CompareTo (object other, IComparer comparer)
+		{
+			var t = other as Tuple<T1, T2, T3, T4, T5>;
+			if (t == null) {
+				if (other == null) return 1;
+				throw new ArgumentException ("other");
+			}
+
+			int res = comparer.Compare (item1, t.item1);
+			if (res != 0) return res;
+			res = comparer.Compare (item2, t.item2);
+			if (res != 0) return res;
+			res = comparer.Compare (item3, t.item3);
+			if (res != 0) return res;
+			res = comparer.Compare (item4, t.item4);
+			if (res != 0) return res;
+			return comparer.Compare (item5, t.item5);
+		}
+
+		public override bool Equals (object obj)
+		{
+			return ((IStructuralEquatable) this).Equals (obj, EqualityComparer<object>.Default);
+		}
+
+		bool IStructuralEquatable.Equals (object other, IEqualityComparer comparer)
+		{
+			var t = other as Tuple<T1, T2, T3, T4, T5>;
+			if (t == null)
+				return false;
+
+			return comparer.Equals (item1, t.item1) &&
+				comparer.Equals (item2, t.item2) &&
+				comparer.Equals (item3, t.item3) &&
+				comparer.Equals (item4, t.item4) &&
+				comparer.Equals (item5, t.item5);
+		}
+
+		public override int GetHashCode ()
+		{
+			return ((IStructuralEquatable) this).GetHashCode (EqualityComparer<object>.Default);
+		}
+
+		int IStructuralEquatable.GetHashCode (IEqualityComparer comparer)
+		{
+			int h = comparer.GetHashCode (item1);
+			h = (h << 5) - h + comparer.GetHashCode (item2);
+			h = (h << 5) - h + comparer.GetHashCode (item3);
+			h = (h << 5) - h + comparer.GetHashCode (item4);
+			h = (h << 5) - h + comparer.GetHashCode (item5);
+			return h;
+		}
+
+		public override string ToString ()
+		{
+			return String.Format ("({0}, {1}, {2}, {3}, {4})", item1, item2, item3, item4, item5);
+		}
+	}
+
+	[Serializable]
+	internal class Tuple<T1, T2, T3, T4, T5, T6> : IStructuralEquatable, IStructuralComparable, IComparable
+	{
+		T1 item1;
+		T2 item2;
+		T3 item3;
+		T4 item4;
+		T5 item5;
+		T6 item6;
+
+		public Tuple (T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6)
+		{
+			 this.item1 = item1;
+			 this.item2 = item2;
+			 this.item3 = item3;
+			 this.item4 = item4;
+			 this.item5 = item5;
+			 this.item6 = item6;
+		}
+
+		public T1 Item1 {
+			get { return item1; }
+		}
+
+		public T2 Item2 {
+			get { return item2; }
+		}
+
+		public T3 Item3 {
+			get { return item3; }
+		}
+
+		public T4 Item4 {
+			get { return item4; }
+		}
+
+		public T5 Item5 {
+			get { return item5; }
+		}
+
+		public T6 Item6 {
+			get { return item6; }
+		}
+
+		int IComparable.CompareTo (object obj)
+		{
+			return ((IStructuralComparable) this).CompareTo (obj, Comparer<object>.Default);
+		}
+
+		int IStructuralComparable.CompareTo (object other, IComparer comparer)
+		{
+			var t = other as Tuple<T1, T2, T3, T4, T5, T6>;
+			if (t == null) {
+				if (other == null) return 1;
+				throw new ArgumentException ("other");
+			}
+
+			int res = comparer.Compare (item1, t.item1);
+			if (res != 0) return res;
+			res = comparer.Compare (item2, t.item2);
+			if (res != 0) return res;
+			res = comparer.Compare (item3, t.item3);
+			if (res != 0) return res;
+			res = comparer.Compare (item4, t.item4);
+			if (res != 0) return res;
+			res = comparer.Compare (item5, t.item5);
+			if (res != 0) return res;
+			return comparer.Compare (item6, t.item6);
+		}
+
+		public override bool Equals (object obj)
+		{
+			return ((IStructuralEquatable) this).Equals (obj, EqualityComparer<object>.Default);
+		}
+
+		bool IStructuralEquatable.Equals (object other, IEqualityComparer comparer)
+		{
+			var t = other as Tuple<T1, T2, T3, T4, T5, T6>;
+			if (t == null)
+				return false;
+
+			return comparer.Equals (item1, t.item1) &&
+				comparer.Equals (item2, t.item2) &&
+				comparer.Equals (item3, t.item3) &&
+				comparer.Equals (item4, t.item4) &&
+				comparer.Equals (item5, t.item5) &&
+				comparer.Equals (item6, t.item6);
+		}
+
+		public override int GetHashCode ()
+		{
+			return ((IStructuralEquatable) this).GetHashCode (EqualityComparer<object>.Default);
+		}
+
+		int IStructuralEquatable.GetHashCode (IEqualityComparer comparer)
+		{
+			int h = comparer.GetHashCode (item1);
+			h = (h << 5) - h + comparer.GetHashCode (item2);
+			h = (h << 5) - h + comparer.GetHashCode (item3);
+			h = (h << 5) - h + comparer.GetHashCode (item4);
+			h = (h << 5) - h + comparer.GetHashCode (item5);
+			h = (h << 5) - h + comparer.GetHashCode (item6);
+			return h;
+		}
+
+		public override string ToString ()
+		{
+			return String.Format ("({0}, {1}, {2}, {3}, {4}, {5})", item1, item2, item3, item4, item5, item6);
+		}
+	}
+
+	[Serializable]
+	internal class Tuple<T1, T2, T3, T4, T5, T6, T7> : IStructuralEquatable, IStructuralComparable, IComparable
+	{
+		T1 item1;
+		T2 item2;
+		T3 item3;
+		T4 item4;
+		T5 item5;
+		T6 item6;
+		T7 item7;
+
+		public Tuple (T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7)
+		{
+			 this.item1 = item1;
+			 this.item2 = item2;
+			 this.item3 = item3;
+			 this.item4 = item4;
+			 this.item5 = item5;
+			 this.item6 = item6;
+			 this.item7 = item7;
+		}
+
+		public T1 Item1 {
+			get { return item1; }
+		}
+
+		public T2 Item2 {
+			get { return item2; }
+		}
+
+		public T3 Item3 {
+			get { return item3; }
+		}
+
+		public T4 Item4 {
+			get { return item4; }
+		}
+
+		public T5 Item5 {
+			get { return item5; }
+		}
+
+		public T6 Item6 {
+			get { return item6; }
+		}
+
+		public T7 Item7 {
+			get { return item7; }
+		}
+
+		int IComparable.CompareTo (object obj)
+		{
+			return ((IStructuralComparable) this).CompareTo (obj, Comparer<object>.Default);
+		}
+
+		int IStructuralComparable.CompareTo (object other, IComparer comparer)
+		{
+			var t = other as Tuple<T1, T2, T3, T4, T5, T6, T7>;
+			if (t == null) {
+				if (other == null) return 1;
+				throw new ArgumentException ("other");
+			}
+
+			int res = comparer.Compare (item1, t.item1);
+			if (res != 0) return res;
+			res = comparer.Compare (item2, t.item2);
+			if (res != 0) return res;
+			res = comparer.Compare (item3, t.item3);
+			if (res != 0) return res;
+			res = comparer.Compare (item4, t.item4);
+			if (res != 0) return res;
+			res = comparer.Compare (item5, t.item5);
+			if (res != 0) return res;
+			res = comparer.Compare (item6, t.item6);
+			if (res != 0) return res;
+			return comparer.Compare (item7, t.item7);
+		}
+
+		public override bool Equals (object obj)
+		{
+			return ((IStructuralEquatable) this).Equals (obj, EqualityComparer<object>.Default);
+		}
+
+		bool IStructuralEquatable.Equals (object other, IEqualityComparer comparer)
+		{
+			var t = other as Tuple<T1, T2, T3, T4, T5, T6, T7>;
+			if (t == null)
+				return false;
+
+			return comparer.Equals (item1, t.item1) &&
+				comparer.Equals (item2, t.item2) &&
+				comparer.Equals (item3, t.item3) &&
+				comparer.Equals (item4, t.item4) &&
+				comparer.Equals (item5, t.item5) &&
+				comparer.Equals (item6, t.item6) &&
+				comparer.Equals (item7, t.item7);
+		}
+
+		public override int GetHashCode ()
+		{
+			return ((IStructuralEquatable) this).GetHashCode (EqualityComparer<object>.Default);
+		}
+
+		int IStructuralEquatable.GetHashCode (IEqualityComparer comparer)
+		{
+			int h = comparer.GetHashCode (item1);
+			h = (h << 5) - h + comparer.GetHashCode (item2);
+			h = (h << 5) - h + comparer.GetHashCode (item3);
+			h = (h << 5) - h + comparer.GetHashCode (item4);
+			h = (h << 5) - h + comparer.GetHashCode (item5);
+			h = (h << 5) - h + comparer.GetHashCode (item6);
+			h = (h << 5) - h + comparer.GetHashCode (item7);
+			return h;
+		}
+
+		public override string ToString ()
+		{
+			return String.Format ("({0}, {1}, {2}, {3}, {4}, {5}, {6})", item1, item2, item3, item4, item5, item6, item7);
+		}
+	}
+
+	[Serializable]
+	internal partial class Tuple<T1, T2, T3, T4, T5, T6, T7, TRest> : IStructuralEquatable, IStructuralComparable, IComparable
+	{
+		T1 item1;
+		T2 item2;
+		T3 item3;
+		T4 item4;
+		T5 item5;
+		T6 item6;
+		T7 item7;
+		TRest rest;
+
+		public T1 Item1 {
+			get { return item1; }
+		}
+
+		public T2 Item2 {
+			get { return item2; }
+		}
+
+		public T3 Item3 {
+			get { return item3; }
+		}
+
+		public T4 Item4 {
+			get { return item4; }
+		}
+
+		public T5 Item5 {
+			get { return item5; }
+		}
+
+		public T6 Item6 {
+			get { return item6; }
+		}
+
+		public T7 Item7 {
+			get { return item7; }
+		}
+
+		public TRest Rest {
+			get { return rest; }
+		}
+
+		int IComparable.CompareTo (object obj)
+		{
+			return ((IStructuralComparable) this).CompareTo (obj, Comparer<object>.Default);
+		}
+
+		int IStructuralComparable.CompareTo (object other, IComparer comparer)
+		{
+			var t = other as Tuple<T1, T2, T3, T4, T5, T6, T7, TRest>;
+			if (t == null) {
+				if (other == null) return 1;
+				throw new ArgumentException ("other");
+			}
+
+			int res = comparer.Compare (item1, t.item1);
+			if (res != 0) return res;
+			res = comparer.Compare (item2, t.item2);
+			if (res != 0) return res;
+			res = comparer.Compare (item3, t.item3);
+			if (res != 0) return res;
+			res = comparer.Compare (item4, t.item4);
+			if (res != 0) return res;
+			res = comparer.Compare (item5, t.item5);
+			if (res != 0) return res;
+			res = comparer.Compare (item6, t.item6);
+			if (res != 0) return res;
+			res = comparer.Compare (item7, t.item7);
+			if (res != 0) return res;
+			return comparer.Compare (rest, t.rest);
+		}
+
+		public override bool Equals (object obj)
+		{
+			return ((IStructuralEquatable) this).Equals (obj, EqualityComparer<object>.Default);
+		}
+
+		bool IStructuralEquatable.Equals (object other, IEqualityComparer comparer)
+		{
+			var t = other as Tuple<T1, T2, T3, T4, T5, T6, T7, TRest>;
+			if (t == null)
+				return false;
+
+			return comparer.Equals (item1, t.item1) &&
+				comparer.Equals (item2, t.item2) &&
+				comparer.Equals (item3, t.item3) &&
+				comparer.Equals (item4, t.item4) &&
+				comparer.Equals (item5, t.item5) &&
+				comparer.Equals (item6, t.item6) &&
+				comparer.Equals (item7, t.item7) &&
+				comparer.Equals (rest, t.rest);
+		}
+
+		public override int GetHashCode ()
+		{
+			return ((IStructuralEquatable) this).GetHashCode (EqualityComparer<object>.Default);
+		}
+
+		int IStructuralEquatable.GetHashCode (IEqualityComparer comparer)
+		{
+			int h = comparer.GetHashCode (item1);
+			h = (h << 5) - h + comparer.GetHashCode (item2);
+			h = (h << 5) - h + comparer.GetHashCode (item3);
+			h = (h << 5) - h + comparer.GetHashCode (item4);
+			h = (h << 5) - h + comparer.GetHashCode (item5);
+			h = (h << 5) - h + comparer.GetHashCode (item6);
+			h = (h << 5) - h + comparer.GetHashCode (item7);
+			h = (h << 5) - h + comparer.GetHashCode (rest);
+			return h;
+		}
+
+		public override string ToString ()
+		{
+			return String.Format ("({0}, {1}, {2}, {3}, {4}, {5}, {6}, {7})", item1, item2, item3, item4, item5, item6, item7, rest);
+		}
+	}
+
+}
+	
+#endif
+
+#if FALSE
+
+//
+// generator script
+//
+
+using System;
+using System.Text;
+
+public class TupleGen
+{
+	public static void Main () {
+		for (int arity = 1; arity < 9; ++arity) {
+			string type_name = GetTypeName (arity);
+
+			Console.WriteLine ("\t[Serializable]");
+			Console.Write ("\tpublic {0}class ", arity < 8 ? null : "partial ");
+			Console.Write (type_name);
+			Console.WriteLine (" : IStructuralEquatable, IStructuralComparable, IComparable");
+			Console.WriteLine ("\t{");
+			for (int i = 1; i <= arity; ++i)
+				Console.WriteLine ("\t\t{0} {1};", GetItemTypeName (i), GetItemName (i));
+				
+			if (arity < 8) {
+				Console.WriteLine ();
+				Console.Write ("\t\tpublic Tuple (");
+				for (int i = 1; i <= arity; ++i) {
+					Console.Write ("{0} {1}", GetItemTypeName (i), GetItemName (i));
+					if (i < arity)
+						Console.Write (", ");
+				}
+				Console.WriteLine (")");
+				Console.WriteLine ("\t\t{");
+				for (int i = 1; i <= arity; ++i)
+					Console.WriteLine ("\t\t\t this.{0} = {0};", GetItemName (i));
+				Console.WriteLine ("\t\t}");
+			}
+
+			for (int i = 1; i <= arity; ++i) {
+				Console.WriteLine ();
+				Console.WriteLine ("\t\tpublic {0} {1} {{", GetItemTypeName (i),
+					System.Globalization.CultureInfo.InvariantCulture.TextInfo.ToTitleCase (GetItemName (i)));
+				Console.Write ("\t\t\tget { ");
+				Console.WriteLine ("return {0}; }}", GetItemName (i));
+				Console.WriteLine ("\t\t}");
+			}
+
+			Console.WriteLine ();
+			Console.WriteLine ("\t\tint IComparable.CompareTo (object obj)");
+			Console.WriteLine ("\t\t{");
+			Console.WriteLine ("\t\t\treturn ((IStructuralComparable) this).CompareTo (obj, Comparer<object>.Default);");
+			Console.WriteLine ("\t\t}");
+			
+			Console.WriteLine ();
+			Console.WriteLine ("\t\tint IStructuralComparable.CompareTo (object other, IComparer comparer)");
+			Console.WriteLine ("\t\t{");
+			Console.WriteLine ("\t\t\tvar t = other as {0};", type_name);
+			Console.WriteLine ("\t\t\tif (t == null) {");
+			Console.WriteLine ("\t\t\t\tif (other == null) return 1;");
+			Console.WriteLine ("\t\t\t\tthrow new ArgumentException ("other");");
+			Console.WriteLine ("\t\t\t}");
+			Console.WriteLine ();
+			
+			for (int i = 1; i < arity; ++i) {
+				Console.Write ("\t\t\t");
+				if (i == 1)
+					Console.Write ("int ");
+
+				Console.WriteLine ("res = comparer.Compare ({0}, t.{0});", GetItemName (i));
+				Console.WriteLine ("\t\t\tif (res != 0) return res;");
+			}
+			Console.WriteLine ("\t\t\treturn comparer.Compare ({0}, t.{0});", GetItemName (arity));
+			Console.WriteLine ("\t\t}");			
+			
+			Console.WriteLine ();
+			Console.WriteLine ("\t\tpublic override bool Equals (object obj)");
+			Console.WriteLine ("\t\t{");
+			Console.WriteLine ("\t\t\treturn ((IStructuralEquatable) this).Equals (obj, EqualityComparer<object>.Default);");
+			Console.WriteLine ("\t\t}");
+			
+			Console.WriteLine ();
+			Console.WriteLine ("\t\tbool IStructuralEquatable.Equals (object other, IEqualityComparer comparer)");
+			Console.WriteLine ("\t\t{");
+			Console.WriteLine ("\t\t\tvar t = other as {0};", type_name);
+			Console.WriteLine ("\t\t\tif (t == null)");
+			Console.WriteLine ("\t\t\t\treturn false;");
+			Console.WriteLine ();
+			Console.Write ("\t\t\treturn");
+			
+			for (int i = 1; i <= arity; ++i) {
+				if (i == 1)
+					Console.Write (" ");
+				else
+					Console.Write ("\t\t\t\t");
+
+				Console.Write ("comparer.Equals ({0}, t.{0})", GetItemName (i));
+				if (i != arity)
+					Console.WriteLine (" &&");
+				else
+					Console.WriteLine (";");
+			}
+			Console.WriteLine ("\t\t}");
+			
+			Console.WriteLine ();
+			Console.WriteLine ("\t\tpublic override int GetHashCode ()");
+			Console.WriteLine ("\t\t{");
+			Console.WriteLine ("\t\t\treturn ((IStructuralEquatable) this).GetHashCode (EqualityComparer<object>.Default);");
+			Console.WriteLine ("\t\t}");
+			
+			Console.WriteLine ();
+			Console.WriteLine ("\t\tint IStructuralEquatable.GetHashCode (IEqualityComparer comparer)");
+			Console.WriteLine ("\t\t{");
+			if (arity == 1) {
+				Console.WriteLine ("\t\t\treturn comparer.GetHashCode ({0});", GetItemName (arity));
+			} else {
+				Console.WriteLine ("\t\t\tint h = comparer.GetHashCode ({0});", GetItemName (1));
+				for (int i = 2; i <= arity; ++i)
+					Console.WriteLine ("\t\t\th = (h << 5) - h + comparer.GetHashCode ({0});", GetItemName (i));
+				Console.WriteLine ("\t\t\treturn h;");
+			}
+
+			Console.WriteLine ("\t\t}");
+
+			Console.WriteLine ();
+			Console.WriteLine ("\t\tpublic override string ToString ()");
+			Console.WriteLine ("\t\t{");
+			Console.Write ("\t\t\treturn String.Format (\"(");
+			for (int i = 1; i <= arity; ++i) {
+				Console.Write ("{" + (i - 1) + "}");
+				if (i < arity)
+					Console.Write (", ");
+			}
+			Console.Write (")\", ");
+			for (int i = 1; i <= arity; ++i) {
+				Console.Write (GetItemName (i));
+				if (i < arity)
+					Console.Write (", ");
+			}
+			Console.WriteLine (");");
+			Console.WriteLine ("\t\t}");
+
+			Console.WriteLine ("\t}\n");
+		}
+	}
+
+	static string GetTypeName (int arity)
+	{
+		StringBuilder sb = new StringBuilder ();
+		sb.Append ("Tuple<");
+		for (int i = 1; i <= arity; ++i) {
+			sb.Append (GetItemTypeName (i));
+			if (i < arity)
+				sb.Append (", ");
+		}
+		sb.Append (">");
+		
+		return sb.ToString ();
+	}
+	
+	static string GetItemName (int arity)
+	{
+		return arity < 8 ? "item" + arity.ToString () : "rest";
+	}
+	
+	static string GetItemTypeName (int arity)
+	{
+		return arity < 8 ? "T" + arity.ToString () : "TRest";
+	}
+}
+
+#endif
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Sharpen/DictionaryExtensions.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Sharpen/DictionaryExtensions.cs
new file mode 100644
index 000000000..45c99ed28
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Sharpen/DictionaryExtensions.cs
@@ -0,0 +1,57 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+namespace Antlr4.Runtime.Sharpen
+{
+    using System.Collections.Generic;
+
+    internal static class DictionaryExtensions
+    {
+        public static TValue Get<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, TKey key)
+            where TValue : class
+        {
+            TValue value;
+            if (!dictionary.TryGetValue(key, out value))
+                return null;
+
+            return value;
+        }
+
+        public static TValue Put<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, TKey key, TValue value)
+            where TValue : class
+        {
+            TValue previous;
+            if (!dictionary.TryGetValue(key, out previous))
+                previous = null;
+
+            dictionary[key] = value;
+            return previous;
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Sharpen/ListExtensions.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Sharpen/ListExtensions.cs
new file mode 100644
index 000000000..ba6c4575e
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Sharpen/ListExtensions.cs
@@ -0,0 +1,44 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+namespace Antlr4.Runtime.Sharpen
+{
+    using System.Collections.Generic;
+
+    internal static class ListExtensions
+    {
+        public static T Set<T>(this IList<T> list, int index, T value)
+            where T : class
+        {
+            T previous = list[index];
+            list[index] = value;
+            return previous;
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Sharpen/Runtime.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Sharpen/Runtime.cs
new file mode 100644
index 000000000..139e463c4
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Sharpen/Runtime.cs
@@ -0,0 +1,44 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+namespace Antlr4.Runtime.Sharpen
+{
+    using System;
+
+    internal static class Runtime
+    {
+        public static string Substring(string str, int beginOffset, int endOffset)
+        {
+            if (str == null)
+                throw new ArgumentNullException("str");
+
+            return str.Substring(beginOffset, endOffset - beginOffset);
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Sharpen/SequenceEqualityComparer.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Sharpen/SequenceEqualityComparer.cs
new file mode 100644
index 000000000..f3f351157
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Sharpen/SequenceEqualityComparer.cs
@@ -0,0 +1,52 @@
+namespace Antlr4.Runtime.Sharpen
+{
+    using System.Collections.Generic;
+    using System.Linq;
+
+    internal class SequenceEqualityComparer<T> : EqualityComparer<IEnumerable<T>>
+    {
+        private static readonly SequenceEqualityComparer<T> _default = new SequenceEqualityComparer<T>();
+
+        private readonly IEqualityComparer<T> _elementEqualityComparer = EqualityComparer<T>.Default;
+
+        public SequenceEqualityComparer()
+            : this(null)
+        {
+        }
+
+        public SequenceEqualityComparer(IEqualityComparer<T> elementComparer)
+        {
+            _elementEqualityComparer = elementComparer ?? EqualityComparer<T>.Default;
+        }
+
+        public new static SequenceEqualityComparer<T> Default
+        {
+            get
+            {
+                return _default;
+            }
+        }
+
+        public override bool Equals(IEnumerable<T> x, IEnumerable<T> y)
+        {
+            if (x == y)
+                return true;
+            if (x == null || y == null)
+                return false;
+
+            return x.SequenceEqual(y, _elementEqualityComparer);
+        }
+
+        public override int GetHashCode(IEnumerable<T> obj)
+        {
+            if (obj == null)
+                return 0;
+
+            int hashCode = 1;
+            foreach (T element in obj)
+                hashCode = 31 * hashCode + _elementEqualityComparer.GetHashCode(element);
+
+            return hashCode;
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/TokenStreamRewriter.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/TokenStreamRewriter.cs
new file mode 100644
index 000000000..0746719c1
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/TokenStreamRewriter.cs
@@ -0,0 +1,750 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Antlr4.Runtime;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime
+{
+    /// <summary>
+    /// Useful for rewriting out a buffered input token stream after doing some
+    /// augmentation or other manipulations on it.
+    /// </summary>
+    /// <remarks>
+    /// Useful for rewriting out a buffered input token stream after doing some
+    /// augmentation or other manipulations on it.
+    /// <p>
+    /// You can insert stuff, replace, and delete chunks. Note that the operations
+    /// are done lazily--only if you convert the buffer to a
+    /// <see cref="string"/>
+    /// with
+    /// <see cref="ITokenStream.GetText()"/>
+    /// . This is very efficient because you are not
+    /// moving data around all the time. As the buffer of tokens is converted to
+    /// strings, the
+    /// <see cref="GetText()"/>
+    /// method(s) scan the input token stream and
+    /// check to see if there is an operation at the current index. If so, the
+    /// operation is done and then normal
+    /// <see cref="string"/>
+    /// rendering continues on the
+    /// buffer. This is like having multiple Turing machine instruction streams
+    /// (programs) operating on a single input tape. :)</p>
+    /// <p>
+    /// This rewriter makes no modifications to the token stream. It does not ask the
+    /// stream to fill itself up nor does it advance the input cursor. The token
+    /// stream
+    /// <see cref="IIntStream.Index()"/>
+    /// will return the same value before and
+    /// after any
+    /// <see cref="GetText()"/>
+    /// call.</p>
+    /// <p>
+    /// The rewriter only works on tokens that you have in the buffer and ignores the
+    /// current input cursor. If you are buffering tokens on-demand, calling
+    /// <see cref="GetText()"/>
+    /// halfway through the input will only do rewrites for those
+    /// tokens in the first half of the file.</p>
+    /// <p>
+    /// Since the operations are done lazily at
+    /// <see cref="GetText()"/>
+    /// -time, operations do
+    /// not screw up the token index values. That is, an insert operation at token
+    /// index
+    /// <c>i</c>
+    /// does not change the index values for tokens
+    /// <c>i</c>
+    /// +1..n-1.</p>
+    /// <p>
+    /// Because operations never actually alter the buffer, you may always get the
+    /// original token stream back without undoing anything. Since the instructions
+    /// are queued up, you can easily simulate transactions and roll back any changes
+    /// if there is an error just by removing instructions. For example,</p>
+    /// <pre>
+    /// CharStream input = new ANTLRFileStream("input");
+    /// TLexer lex = new TLexer(input);
+    /// CommonTokenStream tokens = new CommonTokenStream(lex);
+    /// T parser = new T(tokens);
+    /// TokenStreamRewriter rewriter = new TokenStreamRewriter(tokens);
+    /// parser.startRule();
+    /// </pre>
+    /// <p>
+    /// Then in the rules, you can execute (assuming rewriter is visible):</p>
+    /// <pre>
+    /// Token t,u;
+    /// ...
+    /// rewriter.insertAfter(t, "text to put after t");}
+    /// rewriter.insertAfter(u, "text after u");}
+    /// System.out.println(tokens.toString());
+    /// </pre>
+    /// <p>
+    /// You can also have multiple "instruction streams" and get multiple rewrites
+    /// from a single pass over the input. Just name the instruction streams and use
+    /// that name again when printing the buffer. This could be useful for generating
+    /// a C file and also its header file--all from the same buffer:</p>
+    /// <pre>
+    /// tokens.insertAfter("pass1", t, "text to put after t");}
+    /// tokens.insertAfter("pass2", u, "text after u");}
+    /// System.out.println(tokens.toString("pass1"));
+    /// System.out.println(tokens.toString("pass2"));
+    /// </pre>
+    /// <p>
+    /// If you don't use named rewrite streams, a "default" stream is used as the
+    /// first example shows.</p>
+    /// </remarks>
+    public class TokenStreamRewriter
+    {
+        public const string DefaultProgramName = "default";
+
+        public const int ProgramInitSize = 100;
+
+        public const int MinTokenIndex = 0;
+
+        public class RewriteOperation
+        {
+            protected internal readonly ITokenStream tokens;
+
+            /// <summary>What index into rewrites List are we?</summary>
+            protected internal int instructionIndex;
+
+            /// <summary>Token buffer index.</summary>
+            /// <remarks>Token buffer index.</remarks>
+            protected internal int index;
+
+            protected internal object text;
+
+            protected internal RewriteOperation(ITokenStream tokens, int index)
+            {
+                // Define the rewrite operation hierarchy
+                this.tokens = tokens;
+                this.index = index;
+            }
+
+            protected internal RewriteOperation(ITokenStream tokens, int index, object text)
+            {
+                this.tokens = tokens;
+                this.index = index;
+                this.text = text;
+            }
+
+            /// <summary>Execute the rewrite operation by possibly adding to the buffer.</summary>
+            /// <remarks>
+            /// Execute the rewrite operation by possibly adding to the buffer.
+            /// Return the index of the next token to operate on.
+            /// </remarks>
+            public virtual int Execute(StringBuilder buf)
+            {
+                return index;
+            }
+
+            public override string ToString()
+            {
+                string opName = GetType().FullName;
+                int index = opName.IndexOf('$');
+                opName = Sharpen.Runtime.Substring(opName, index + 1, opName.Length);
+                return "<" + opName + "@" + tokens.Get(this.index) + ":\"" + text + "\">";
+            }
+        }
+
+        internal class InsertBeforeOp : TokenStreamRewriter.RewriteOperation
+        {
+            public InsertBeforeOp(ITokenStream tokens, int index, object text)
+                : base(tokens, index, text)
+            {
+            }
+
+            public override int Execute(StringBuilder buf)
+            {
+                buf.Append(text);
+                if (tokens.Get(index).Type != TokenConstants.Eof)
+                {
+                    buf.Append(tokens.Get(index).Text);
+                }
+                return index + 1;
+            }
+        }
+
+        /// <summary>
+        /// I'm going to try replacing range from x..y with (y-x)+1 ReplaceOp
+        /// instructions.
+        /// </summary>
+        /// <remarks>
+        /// I'm going to try replacing range from x..y with (y-x)+1 ReplaceOp
+        /// instructions.
+        /// </remarks>
+        internal class ReplaceOp : TokenStreamRewriter.RewriteOperation
+        {
+            protected internal int lastIndex;
+
+            public ReplaceOp(ITokenStream tokens, int from, int to, object text)
+                : base(tokens, from, text)
+            {
+                lastIndex = to;
+            }
+
+            public override int Execute(StringBuilder buf)
+            {
+                if (text != null)
+                {
+                    buf.Append(text);
+                }
+                return lastIndex + 1;
+            }
+
+            public override string ToString()
+            {
+                if (text == null)
+                {
+                    return "<DeleteOp@" + tokens.Get(index) + ".." + tokens.Get(lastIndex) + ">";
+                }
+                return "<ReplaceOp@" + tokens.Get(index) + ".." + tokens.Get(lastIndex) + ":\"" + text + "\">";
+            }
+        }
+
+        /// <summary>Our source stream</summary>
+        protected internal readonly ITokenStream tokens;
+
+        /// <summary>You may have multiple, named streams of rewrite operations.</summary>
+        /// <remarks>
+        /// You may have multiple, named streams of rewrite operations.
+        /// I'm calling these things "programs."
+        /// Maps String (name) &#x2192; rewrite (List)
+        /// </remarks>
+        protected internal readonly IDictionary<string, IList<TokenStreamRewriter.RewriteOperation>> programs;
+
+        /// <summary>Map String (program name) &#x2192; Integer index</summary>
+        protected internal readonly IDictionary<string, int> lastRewriteTokenIndexes;
+
+        public TokenStreamRewriter(ITokenStream tokens)
+        {
+            this.tokens = tokens;
+            programs = new Dictionary<string, IList<TokenStreamRewriter.RewriteOperation>>();
+            programs[DefaultProgramName] = new List<TokenStreamRewriter.RewriteOperation>(ProgramInitSize);
+            lastRewriteTokenIndexes = new Dictionary<string, int>();
+        }
+
+        public ITokenStream TokenStream
+        {
+            get
+            {
+                return tokens;
+            }
+        }
+
+        public virtual void Rollback(int instructionIndex)
+        {
+            Rollback(DefaultProgramName, instructionIndex);
+        }
+
+        /// <summary>
+        /// Rollback the instruction stream for a program so that
+        /// the indicated instruction (via instructionIndex) is no
+        /// longer in the stream.
+        /// </summary>
+        /// <remarks>
+        /// Rollback the instruction stream for a program so that
+        /// the indicated instruction (via instructionIndex) is no
+        /// longer in the stream. UNTESTED!
+        /// </remarks>
+        public virtual void Rollback(string programName, int instructionIndex)
+        {
+            IList<TokenStreamRewriter.RewriteOperation> @is;
+            if (programs.TryGetValue(programName, out @is))
+            {
+                programs[programName] = new List<RewriteOperation>(@is.Skip(MinTokenIndex).Take(instructionIndex - MinTokenIndex));
+            }
+        }
+
+        public virtual void DeleteProgram()
+        {
+            DeleteProgram(DefaultProgramName);
+        }
+
+        /// <summary>Reset the program so that no instructions exist</summary>
+        public virtual void DeleteProgram(string programName)
+        {
+            Rollback(programName, MinTokenIndex);
+        }
+
+        public virtual void InsertAfter(IToken t, object text)
+        {
+            InsertAfter(DefaultProgramName, t, text);
+        }
+
+        public virtual void InsertAfter(int index, object text)
+        {
+            InsertAfter(DefaultProgramName, index, text);
+        }
+
+        public virtual void InsertAfter(string programName, IToken t, object text)
+        {
+            InsertAfter(programName, t.TokenIndex, text);
+        }
+
+        public virtual void InsertAfter(string programName, int index, object text)
+        {
+            // to insert after, just insert before next index (even if past end)
+            InsertBefore(programName, index + 1, text);
+        }
+
+        public virtual void InsertBefore(IToken t, object text)
+        {
+            InsertBefore(DefaultProgramName, t, text);
+        }
+
+        public virtual void InsertBefore(int index, object text)
+        {
+            InsertBefore(DefaultProgramName, index, text);
+        }
+
+        public virtual void InsertBefore(string programName, IToken t, object text)
+        {
+            InsertBefore(programName, t.TokenIndex, text);
+        }
+
+        public virtual void InsertBefore(string programName, int index, object text)
+        {
+            TokenStreamRewriter.RewriteOperation op = new TokenStreamRewriter.InsertBeforeOp(tokens, index, text);
+            IList<TokenStreamRewriter.RewriteOperation> rewrites = GetProgram(programName);
+            op.instructionIndex = rewrites.Count;
+            rewrites.Add(op);
+        }
+
+        public virtual void Replace(int index, object text)
+        {
+            Replace(DefaultProgramName, index, index, text);
+        }
+
+        public virtual void Replace(int from, int to, object text)
+        {
+            Replace(DefaultProgramName, from, to, text);
+        }
+
+        public virtual void Replace(IToken indexT, object text)
+        {
+            Replace(DefaultProgramName, indexT, indexT, text);
+        }
+
+        public virtual void Replace(IToken from, IToken to, object text)
+        {
+            Replace(DefaultProgramName, from, to, text);
+        }
+
+        public virtual void Replace(string programName, int from, int to, object text)
+        {
+            if (from > to || from < 0 || to < 0 || to >= tokens.Size)
+            {
+                throw new ArgumentException("replace: range invalid: " + from + ".." + to + "(size=" + tokens.Size + ")");
+            }
+            TokenStreamRewriter.RewriteOperation op = new TokenStreamRewriter.ReplaceOp(tokens, from, to, text);
+            IList<TokenStreamRewriter.RewriteOperation> rewrites = GetProgram(programName);
+            op.instructionIndex = rewrites.Count;
+            rewrites.Add(op);
+        }
+
+        public virtual void Replace(string programName, IToken from, IToken to, object text)
+        {
+            Replace(programName, from.TokenIndex, to.TokenIndex, text);
+        }
+
+        public virtual void Delete(int index)
+        {
+            Delete(DefaultProgramName, index, index);
+        }
+
+        public virtual void Delete(int from, int to)
+        {
+            Delete(DefaultProgramName, from, to);
+        }
+
+        public virtual void Delete(IToken indexT)
+        {
+            Delete(DefaultProgramName, indexT, indexT);
+        }
+
+        public virtual void Delete(IToken from, IToken to)
+        {
+            Delete(DefaultProgramName, from, to);
+        }
+
+        public virtual void Delete(string programName, int from, int to)
+        {
+            Replace(programName, from, to, null);
+        }
+
+        public virtual void Delete(string programName, IToken from, IToken to)
+        {
+            Replace(programName, from, to, null);
+        }
+
+        public virtual int LastRewriteTokenIndex
+        {
+            get
+            {
+                return GetLastRewriteTokenIndex(DefaultProgramName);
+            }
+        }
+
+        protected internal virtual int GetLastRewriteTokenIndex(string programName)
+        {
+            int I;
+            if (!lastRewriteTokenIndexes.TryGetValue(programName, out I))
+            {
+                return -1;
+            }
+            return I;
+        }
+
+        protected internal virtual void SetLastRewriteTokenIndex(string programName, int i)
+        {
+            lastRewriteTokenIndexes[programName] = i;
+        }
+
+        protected internal virtual IList<TokenStreamRewriter.RewriteOperation> GetProgram(string name)
+        {
+            IList<TokenStreamRewriter.RewriteOperation> @is;
+            if (!programs.TryGetValue(name, out @is))
+            {
+                @is = InitializeProgram(name);
+            }
+            return @is;
+        }
+
+        private IList<TokenStreamRewriter.RewriteOperation> InitializeProgram(string name)
+        {
+            IList<TokenStreamRewriter.RewriteOperation> @is = new List<TokenStreamRewriter.RewriteOperation>(ProgramInitSize);
+            programs[name] = @is;
+            return @is;
+        }
+
+        /// <summary>
+        /// Return the text from the original tokens altered per the
+        /// instructions given to this rewriter.
+        /// </summary>
+        /// <remarks>
+        /// Return the text from the original tokens altered per the
+        /// instructions given to this rewriter.
+        /// </remarks>
+        public virtual string GetText()
+        {
+            return GetText(DefaultProgramName, Interval.Of(0, tokens.Size - 1));
+        }
+
+        /// <summary>
+        /// Return the text associated with the tokens in the interval from the
+        /// original token stream but with the alterations given to this rewriter.
+        /// </summary>
+        /// <remarks>
+        /// Return the text associated with the tokens in the interval from the
+        /// original token stream but with the alterations given to this rewriter.
+        /// The interval refers to the indexes in the original token stream.
+        /// We do not alter the token stream in any way, so the indexes
+        /// and intervals are still consistent. Includes any operations done
+        /// to the first and last token in the interval. So, if you did an
+        /// insertBefore on the first token, you would get that insertion.
+        /// The same is true if you do an insertAfter the stop token.
+        /// </remarks>
+        public virtual string GetText(Interval interval)
+        {
+            return GetText(DefaultProgramName, interval);
+        }
+
+        public virtual string GetText(string programName, Interval interval)
+        {
+            IList<TokenStreamRewriter.RewriteOperation> rewrites;
+            if (!programs.TryGetValue(programName, out rewrites))
+                rewrites = null;
+
+            int start = interval.a;
+            int stop = interval.b;
+            // ensure start/end are in range
+            if (stop > tokens.Size - 1)
+            {
+                stop = tokens.Size - 1;
+            }
+            if (start < 0)
+            {
+                start = 0;
+            }
+            if (rewrites == null || rewrites.Count == 0)
+            {
+                return tokens.GetText(interval);
+            }
+            // no instructions to execute
+            StringBuilder buf = new StringBuilder();
+            // First, optimize instruction stream
+            IDictionary<int, TokenStreamRewriter.RewriteOperation> indexToOp = ReduceToSingleOperationPerIndex(rewrites);
+            // Walk buffer, executing instructions and emitting tokens
+            int i = start;
+            while (i <= stop && i < tokens.Size)
+            {
+                TokenStreamRewriter.RewriteOperation op;
+                if (indexToOp.TryGetValue(i, out op))
+                    indexToOp.Remove(i);
+
+                // remove so any left have index size-1
+                IToken t = tokens.Get(i);
+                if (op == null)
+                {
+                    // no operation at that index, just dump token
+                    if (t.Type != TokenConstants.Eof)
+                    {
+                        buf.Append(t.Text);
+                    }
+                    i++;
+                }
+                else
+                {
+                    // move to next token
+                    i = op.Execute(buf);
+                }
+            }
+            // execute operation and skip
+            // include stuff after end if it's last index in buffer
+            // So, if they did an insertAfter(lastValidIndex, "foo"), include
+            // foo if end==lastValidIndex.
+            if (stop == tokens.Size - 1)
+            {
+                // Scan any remaining operations after last token
+                // should be included (they will be inserts).
+                foreach (TokenStreamRewriter.RewriteOperation op in indexToOp.Values)
+                {
+                    if (op.index >= tokens.Size - 1)
+                    {
+                        buf.Append(op.text);
+                    }
+                }
+            }
+            return buf.ToString();
+        }
+
+        /// <summary>
+        /// We need to combine operations and report invalid operations (like
+        /// overlapping replaces that are not completed nested).
+        /// </summary>
+        /// <remarks>
+        /// We need to combine operations and report invalid operations (like
+        /// overlapping replaces that are not completed nested). Inserts to
+        /// same index need to be combined etc...  Here are the cases:
+        /// I.i.u I.j.v								leave alone, nonoverlapping
+        /// I.i.u I.i.v								combine: Iivu
+        /// R.i-j.u R.x-y.v	| i-j in x-y			delete first R
+        /// R.i-j.u R.i-j.v							delete first R
+        /// R.i-j.u R.x-y.v	| x-y in i-j			ERROR
+        /// R.i-j.u R.x-y.v	| boundaries overlap	ERROR
+        /// Delete special case of replace (text==null):
+        /// D.i-j.u D.x-y.v	| boundaries overlap	combine to max(min)..max(right)
+        /// I.i.u R.x-y.v | i in (x+1)-y			delete I (since insert before
+        /// we're not deleting i)
+        /// I.i.u R.x-y.v | i not in (x+1)-y		leave alone, nonoverlapping
+        /// R.x-y.v I.i.u | i in x-y				ERROR
+        /// R.x-y.v I.x.u 							R.x-y.uv (combine, delete I)
+        /// R.x-y.v I.i.u | i not in x-y			leave alone, nonoverlapping
+        /// I.i.u = insert u before op @ index i
+        /// R.x-y.u = replace x-y indexed tokens with u
+        /// First we need to examine replaces. For any replace op:
+        /// 1. wipe out any insertions before op within that range.
+        /// 2. Drop any replace op before that is contained completely within
+        /// that range.
+        /// 3. Throw exception upon boundary overlap with any previous replace.
+        /// Then we can deal with inserts:
+        /// 1. for any inserts to same index, combine even if not adjacent.
+        /// 2. for any prior replace with same left boundary, combine this
+        /// insert with replace and delete this replace.
+        /// 3. throw exception if index in same range as previous replace
+        /// Don't actually delete; make op null in list. Easier to walk list.
+        /// Later we can throw as we add to index &#x2192; op map.
+        /// Note that I.2 R.2-2 will wipe out I.2 even though, technically, the
+        /// inserted stuff would be before the replace range. But, if you
+        /// add tokens in front of a method body '{' and then delete the method
+        /// body, I think the stuff before the '{' you added should disappear too.
+        /// Return a map from token index to operation.
+        /// </remarks>
+        protected internal virtual IDictionary<int, TokenStreamRewriter.RewriteOperation> ReduceToSingleOperationPerIndex(IList<TokenStreamRewriter.RewriteOperation> rewrites)
+        {
+            //		System.out.println("rewrites="+rewrites);
+            // WALK REPLACES
+            for (int i = 0; i < rewrites.Count; i++)
+            {
+                TokenStreamRewriter.RewriteOperation op = rewrites[i];
+                if (op == null)
+                {
+                    continue;
+                }
+                if (!(op is TokenStreamRewriter.ReplaceOp))
+                {
+                    continue;
+                }
+                TokenStreamRewriter.ReplaceOp rop = (TokenStreamRewriter.ReplaceOp)rewrites[i];
+                // Wipe prior inserts within range
+                IList<TokenStreamRewriter.InsertBeforeOp> inserts = GetKindOfOps<TokenStreamRewriter.InsertBeforeOp>(rewrites, i);
+                foreach (TokenStreamRewriter.InsertBeforeOp iop in inserts)
+                {
+                    if (iop.index == rop.index)
+                    {
+                        // E.g., insert before 2, delete 2..2; update replace
+                        // text to include insert before, kill insert
+                        rewrites[iop.instructionIndex] = null;
+                        rop.text = iop.text.ToString() + (rop.text != null ? rop.text.ToString() : string.Empty);
+                    }
+                    else
+                    {
+                        if (iop.index > rop.index && iop.index <= rop.lastIndex)
+                        {
+                            // delete insert as it's a no-op.
+                            rewrites[iop.instructionIndex] = null;
+                        }
+                    }
+                }
+                // Drop any prior replaces contained within
+                IList<TokenStreamRewriter.ReplaceOp> prevReplaces = GetKindOfOps<TokenStreamRewriter.ReplaceOp>(rewrites, i);
+                foreach (TokenStreamRewriter.ReplaceOp prevRop in prevReplaces)
+                {
+                    if (prevRop.index >= rop.index && prevRop.lastIndex <= rop.lastIndex)
+                    {
+                        // delete replace as it's a no-op.
+                        rewrites[prevRop.instructionIndex] = null;
+                        continue;
+                    }
+                    // throw exception unless disjoint or identical
+                    bool disjoint = prevRop.lastIndex < rop.index || prevRop.index > rop.lastIndex;
+                    bool same = prevRop.index == rop.index && prevRop.lastIndex == rop.lastIndex;
+                    // Delete special case of replace (text==null):
+                    // D.i-j.u D.x-y.v	| boundaries overlap	combine to max(min)..max(right)
+                    if (prevRop.text == null && rop.text == null && !disjoint)
+                    {
+                        //System.out.println("overlapping deletes: "+prevRop+", "+rop);
+                        rewrites[prevRop.instructionIndex] = null;
+                        // kill first delete
+                        rop.index = Math.Min(prevRop.index, rop.index);
+                        rop.lastIndex = Math.Max(prevRop.lastIndex, rop.lastIndex);
+#if !PORTABLE
+                        System.Console.Out.WriteLine("new rop " + rop);
+#endif
+                    }
+                    else
+                    {
+                        if (!disjoint && !same)
+                        {
+                            throw new ArgumentException("replace op boundaries of " + rop + " overlap with previous " + prevRop);
+                        }
+                    }
+                }
+            }
+            // WALK INSERTS
+            for (int i_1 = 0; i_1 < rewrites.Count; i_1++)
+            {
+                TokenStreamRewriter.RewriteOperation op = rewrites[i_1];
+                if (op == null)
+                {
+                    continue;
+                }
+                if (!(op is TokenStreamRewriter.InsertBeforeOp))
+                {
+                    continue;
+                }
+                TokenStreamRewriter.InsertBeforeOp iop = (TokenStreamRewriter.InsertBeforeOp)rewrites[i_1];
+                // combine current insert with prior if any at same index
+                IList<TokenStreamRewriter.InsertBeforeOp> prevInserts = GetKindOfOps<TokenStreamRewriter.InsertBeforeOp>(rewrites, i_1);
+                foreach (TokenStreamRewriter.InsertBeforeOp prevIop in prevInserts)
+                {
+                    if (prevIop.index == iop.index)
+                    {
+                        // combine objects
+                        // convert to strings...we're in process of toString'ing
+                        // whole token buffer so no lazy eval issue with any templates
+                        iop.text = CatOpText(iop.text, prevIop.text);
+                        // delete redundant prior insert
+                        rewrites[prevIop.instructionIndex] = null;
+                    }
+                }
+                // look for replaces where iop.index is in range; error
+                IList<TokenStreamRewriter.ReplaceOp> prevReplaces = GetKindOfOps<TokenStreamRewriter.ReplaceOp>(rewrites, i_1);
+                foreach (TokenStreamRewriter.ReplaceOp rop in prevReplaces)
+                {
+                    if (iop.index == rop.index)
+                    {
+                        rop.text = CatOpText(iop.text, rop.text);
+                        rewrites[i_1] = null;
+                        // delete current insert
+                        continue;
+                    }
+                    if (iop.index >= rop.index && iop.index <= rop.lastIndex)
+                    {
+                        throw new ArgumentException("insert op " + iop + " within boundaries of previous " + rop);
+                    }
+                }
+            }
+            // System.out.println("rewrites after="+rewrites);
+            IDictionary<int, TokenStreamRewriter.RewriteOperation> m = new Dictionary<int, TokenStreamRewriter.RewriteOperation>();
+            for (int i_2 = 0; i_2 < rewrites.Count; i_2++)
+            {
+                TokenStreamRewriter.RewriteOperation op = rewrites[i_2];
+                if (op == null)
+                {
+                    continue;
+                }
+                // ignore deleted ops
+                if (m.ContainsKey(op.index))
+                {
+                    throw new InvalidOperationException("should only be one op per index");
+                }
+                m[op.index] = op;
+            }
+            //System.out.println("index to op: "+m);
+            return m;
+        }
+
+        protected internal virtual string CatOpText(object a, object b)
+        {
+            string x = string.Empty;
+            string y = string.Empty;
+            if (a != null)
+            {
+                x = a.ToString();
+            }
+            if (b != null)
+            {
+                y = b.ToString();
+            }
+            return x + y;
+        }
+
+        /// <summary>Get all operations before an index of a particular kind</summary>
+        protected internal virtual IList<T> GetKindOfOps<T>(IList<RewriteOperation> rewrites, int before)
+        {
+            return rewrites.Take(before).OfType<T>().ToList();
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/TokenTypes.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/TokenTypes.cs
new file mode 100644
index 000000000..4ee1bc2bd
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/TokenTypes.cs
@@ -0,0 +1,38 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+namespace Antlr4.Runtime
+{
+    public static class TokenTypes
+    {
+        public const int More = -2;
+
+        public const int Skip = -3;
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/AbstractParseTreeVisitor.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/AbstractParseTreeVisitor.cs
new file mode 100644
index 000000000..bb7d2edf8
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/AbstractParseTreeVisitor.cs
@@ -0,0 +1,215 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime.Sharpen;
+using Antlr4.Runtime.Tree;
+
+namespace Antlr4.Runtime.Tree
+{
+    public abstract class AbstractParseTreeVisitor<Result> : IParseTreeVisitor<Result>
+    {
+        /// <summary>
+        /// <inheritDoc/>
+        /// <p>The default implementation calls
+        /// <see cref="IParseTree.Accept{T}(IParseTreeVisitor{T})"/>
+        /// on the
+        /// specified tree.</p>
+        /// </summary>
+        public virtual Result Visit(IParseTree tree)
+        {
+            return tree.Accept(this);
+        }
+
+        /// <summary>
+        /// <inheritDoc/>
+        /// <p>The default implementation initializes the aggregate result to
+        /// <see cref="AbstractParseTreeVisitor{Result}.DefaultResult()">defaultResult()</see>
+        /// . Before visiting each child, it
+        /// calls
+        /// <see cref="AbstractParseTreeVisitor{Result}.ShouldVisitNextChild(IRuleNode, Result)">shouldVisitNextChild</see>
+        /// ; if the result
+        /// is
+        /// <see langword="false"/>
+        /// no more children are visited and the current aggregate
+        /// result is returned. After visiting a child, the aggregate result is
+        /// updated by calling
+        /// <see cref="AbstractParseTreeVisitor{Result}.AggregateResult(Result, Result)">aggregateResult</see>
+        /// with the
+        /// previous aggregate result and the result of visiting the child.</p>
+        /// <p>The default implementation is not safe for use in visitors that modify
+        /// the tree structure. Visitors that modify the tree should override this
+        /// method to behave properly in respect to the specific algorithm in use.</p>
+        /// </summary>
+        public virtual Result VisitChildren(IRuleNode node)
+        {
+            Result result = DefaultResult;
+            int n = node.ChildCount;
+            for (int i = 0; i < n; i++)
+            {
+                if (!ShouldVisitNextChild(node, result))
+                {
+                    break;
+                }
+                IParseTree c = node.GetChild(i);
+                Result childResult = c.Accept(this);
+                result = AggregateResult(result, childResult);
+            }
+            return result;
+        }
+
+        /// <summary>
+        /// <inheritDoc/>
+        /// <p>The default implementation returns the result of
+        /// <see cref="AbstractParseTreeVisitor{Result}.DefaultResult()">defaultResult</see>
+        /// .</p>
+        /// </summary>
+        public virtual Result VisitTerminal(ITerminalNode node)
+        {
+            return DefaultResult;
+        }
+
+        /// <summary>
+        /// <inheritDoc/>
+        /// <p>The default implementation returns the result of
+        /// <see cref="AbstractParseTreeVisitor{Result}.DefaultResult()">defaultResult</see>
+        /// .</p>
+        /// </summary>
+        public virtual Result VisitErrorNode(IErrorNode node)
+        {
+            return DefaultResult;
+        }
+
+        /// <summary>Gets the default value returned by visitor methods.</summary>
+        /// <remarks>
+        /// Gets the default value returned by visitor methods. This value is
+        /// returned by the default implementations of
+        /// <see cref="AbstractParseTreeVisitor{Result}.VisitTerminal(ITerminalNode)">visitTerminal</see>
+        /// ,
+        /// <see cref="AbstractParseTreeVisitor{Result}.VisitErrorNode(IErrorNode)">visitErrorNode</see>
+        /// .
+        /// The default implementation of
+        /// <see cref="AbstractParseTreeVisitor{Result}.VisitChildren(IRuleNode)">visitChildren</see>
+        /// initializes its aggregate result to this value.
+        /// <p>The base implementation returns
+        /// <see langword="null"/>
+        /// .</p>
+        /// </remarks>
+        /// <returns>The default value returned by visitor methods.</returns>
+        protected internal virtual Result DefaultResult
+        {
+            get
+            {
+                return default(Result);
+            }
+        }
+
+        /// <summary>Aggregates the results of visiting multiple children of a node.</summary>
+        /// <remarks>
+        /// Aggregates the results of visiting multiple children of a node. After
+        /// either all children are visited or
+        /// <see cref="AbstractParseTreeVisitor{Result}.ShouldVisitNextChild(IRuleNode, Result)"/>
+        /// returns
+        /// <see langword="false"/>
+        /// , the aggregate value is returned as the result of
+        /// <see cref="AbstractParseTreeVisitor{Result}.VisitChildren(IRuleNode)"/>
+        /// .
+        /// <p>The default implementation returns
+        /// <paramref name="nextResult"/>
+        /// , meaning
+        /// <see cref="AbstractParseTreeVisitor{Result}.VisitChildren(IRuleNode)"/>
+        /// will return the result of the last child visited
+        /// (or return the initial value if the node has no children).</p>
+        /// </remarks>
+        /// <param name="aggregate">
+        /// The previous aggregate value. In the default
+        /// implementation, the aggregate value is initialized to
+        /// <see cref="AbstractParseTreeVisitor{Result}.DefaultResult()"/>
+        /// , which is passed as the
+        /// <paramref name="aggregate"/>
+        /// argument
+        /// to this method after the first child node is visited.
+        /// </param>
+        /// <param name="nextResult">
+        /// The result of the immediately preceeding call to visit
+        /// a child node.
+        /// </param>
+        /// <returns>The updated aggregate result.</returns>
+        protected internal virtual Result AggregateResult(Result aggregate, Result nextResult)
+        {
+            return nextResult;
+        }
+
+        /// <summary>
+        /// This method is called after visiting each child in
+        /// <see cref="AbstractParseTreeVisitor{Result}.VisitChildren(IRuleNode)"/>
+        /// . This method is first called before the first
+        /// child is visited; at that point
+        /// <paramref name="currentResult"/>
+        /// will be the initial
+        /// value (in the default implementation, the initial value is returned by a
+        /// call to
+        /// <see cref="AbstractParseTreeVisitor{Result}.DefaultResult()"/>
+        /// . This method is not called after the last
+        /// child is visited.
+        /// <p>The default implementation always returns
+        /// <see langword="true"/>
+        /// , indicating that
+        /// <c>visitChildren</c>
+        /// should only return after all children are visited.
+        /// One reason to override this method is to provide a "short circuit"
+        /// evaluation option for situations where the result of visiting a single
+        /// child has the potential to determine the result of the visit operation as
+        /// a whole.</p>
+        /// </summary>
+        /// <param name="node">
+        /// The
+        /// <see cref="IRuleNode"/>
+        /// whose children are currently being
+        /// visited.
+        /// </param>
+        /// <param name="currentResult">
+        /// The current aggregate result of the children visited
+        /// to the current point.
+        /// </param>
+        /// <returns>
+        /// 
+        /// <see langword="true"/>
+        /// to continue visiting children. Otherwise return
+        /// <see langword="false"/>
+        /// to stop visiting children and immediately return the
+        /// current aggregate result from
+        /// <see cref="AbstractParseTreeVisitor{Result}.VisitChildren(IRuleNode)"/>
+        /// .
+        /// </returns>
+        protected internal virtual bool ShouldVisitNextChild(IRuleNode node, Result currentResult)
+        {
+            return true;
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/ErrorNodeImpl.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/ErrorNodeImpl.cs
new file mode 100644
index 000000000..fb50baa56
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/ErrorNodeImpl.cs
@@ -0,0 +1,59 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime;
+using Antlr4.Runtime.Sharpen;
+using Antlr4.Runtime.Tree;
+
+namespace Antlr4.Runtime.Tree
+{
+    /// <summary>
+    /// Represents a token that was consumed during resynchronization
+    /// rather than during a valid match operation.
+    /// </summary>
+    /// <remarks>
+    /// Represents a token that was consumed during resynchronization
+    /// rather than during a valid match operation. For example,
+    /// we will create this kind of a node during single token insertion
+    /// and deletion as well as during "consume until error recovery set"
+    /// upon no viable alternative exceptions.
+    /// </remarks>
+    public class ErrorNodeImpl : TerminalNodeImpl, IErrorNode
+    {
+        public ErrorNodeImpl(IToken token)
+            : base(token)
+        {
+        }
+
+        public override T Accept<T>(IParseTreeVisitor<T> visitor)
+        {
+            return visitor.VisitErrorNode(this);
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/IErrorNode.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/IErrorNode.cs
new file mode 100644
index 000000000..8f15e0612
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/IErrorNode.cs
@@ -0,0 +1,38 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime.Sharpen;
+using Antlr4.Runtime.Tree;
+
+namespace Antlr4.Runtime.Tree
+{
+    public interface IErrorNode : ITerminalNode
+    {
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/IParseTree.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/IParseTree.cs
new file mode 100644
index 000000000..02a645af7
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/IParseTree.cs
@@ -0,0 +1,84 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime;
+using Antlr4.Runtime.Sharpen;
+using Antlr4.Runtime.Tree;
+
+namespace Antlr4.Runtime.Tree
+{
+    /// <summary>
+    /// An interface to access the tree of
+    /// <see cref="Antlr4.Runtime.RuleContext"/>
+    /// objects created
+    /// during a parse that makes the data structure look like a simple parse tree.
+    /// This node represents both internal nodes, rule invocations,
+    /// and leaf nodes, token matches.
+    /// <p>The payload is either a
+    /// <see cref="Antlr4.Runtime.IToken"/>
+    /// or a
+    /// <see cref="Antlr4.Runtime.RuleContext"/>
+    /// object.</p>
+    /// </summary>
+    public interface IParseTree : ISyntaxTree
+    {
+        new IParseTree Parent
+        {
+            get;
+        }
+
+        // the following methods narrow the return type; they are not additional methods
+        new IParseTree GetChild(int i);
+
+        /// <summary>
+        /// The
+        /// <see cref="IParseTreeVisitor{Result}"/>
+        /// needs a double dispatch method.
+        /// </summary>
+        T Accept<T>(IParseTreeVisitor<T> visitor);
+
+        /// <summary>Return the combined text of all leaf nodes.</summary>
+        /// <remarks>
+        /// Return the combined text of all leaf nodes. Does not get any
+        /// off-channel tokens (if any) so won't return whitespace and
+        /// comments if they are sent to parser on hidden channel.
+        /// </remarks>
+        string GetText();
+
+        /// <summary>
+        /// Specialize toStringTree so that it can print out more information
+        /// based upon the parser.
+        /// </summary>
+        /// <remarks>
+        /// Specialize toStringTree so that it can print out more information
+        /// based upon the parser.
+        /// </remarks>
+        string ToStringTree(Parser parser);
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/IParseTreeListener.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/IParseTreeListener.cs
new file mode 100644
index 000000000..8edb50e93
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/IParseTreeListener.cs
@@ -0,0 +1,46 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime;
+using Antlr4.Runtime.Sharpen;
+using Antlr4.Runtime.Tree;
+
+namespace Antlr4.Runtime.Tree
+{
+    public interface IParseTreeListener
+    {
+        void VisitTerminal(ITerminalNode node);
+
+        void VisitErrorNode(IErrorNode node);
+
+        void EnterEveryRule(ParserRuleContext ctx);
+
+        void ExitEveryRule(ParserRuleContext ctx);
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/IParseTreeVisitor.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/IParseTreeVisitor.cs
new file mode 100644
index 000000000..be7fbfffc
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/IParseTreeVisitor.cs
@@ -0,0 +1,98 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime.Sharpen;
+using Antlr4.Runtime.Tree;
+
+namespace Antlr4.Runtime.Tree
+{
+    /// <summary>This interface defines the basic notion of a parse tree visitor.</summary>
+    /// <remarks>
+    /// This interface defines the basic notion of a parse tree visitor. Generated
+    /// visitors implement this interface and the
+    /// <c>XVisitor</c>
+    /// interface for
+    /// grammar
+    /// <c>X</c>
+    /// .
+    /// </remarks>
+    /// <author>Sam Harwell</author>
+#if COMPACT
+    public interface IParseTreeVisitor<Result>
+#else
+    public interface IParseTreeVisitor<out Result>
+#endif
+    {
+        /// <summary>Visit a parse tree, and return a user-defined result of the operation.</summary>
+        /// <remarks>Visit a parse tree, and return a user-defined result of the operation.</remarks>
+        /// <param name="tree">
+        /// The
+        /// <see cref="IParseTree"/>
+        /// to visit.
+        /// </param>
+        /// <returns>The result of visiting the parse tree.</returns>
+        Result Visit(IParseTree tree);
+
+        /// <summary>
+        /// Visit the children of a node, and return a user-defined result
+        /// of the operation.
+        /// </summary>
+        /// <remarks>
+        /// Visit the children of a node, and return a user-defined result
+        /// of the operation.
+        /// </remarks>
+        /// <param name="node">
+        /// The
+        /// <see cref="IRuleNode"/>
+        /// whose children should be visited.
+        /// </param>
+        /// <returns>The result of visiting the children of the node.</returns>
+        Result VisitChildren(IRuleNode node);
+
+        /// <summary>Visit a terminal node, and return a user-defined result of the operation.</summary>
+        /// <remarks>Visit a terminal node, and return a user-defined result of the operation.</remarks>
+        /// <param name="node">
+        /// The
+        /// <see cref="ITerminalNode"/>
+        /// to visit.
+        /// </param>
+        /// <returns>The result of visiting the node.</returns>
+        Result VisitTerminal(ITerminalNode node);
+
+        /// <summary>Visit an error node, and return a user-defined result of the operation.</summary>
+        /// <remarks>Visit an error node, and return a user-defined result of the operation.</remarks>
+        /// <param name="node">
+        /// The
+        /// <see cref="IErrorNode"/>
+        /// to visit.
+        /// </param>
+        /// <returns>The result of visiting the node.</returns>
+        Result VisitErrorNode(IErrorNode node);
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/IRuleNode.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/IRuleNode.cs
new file mode 100644
index 000000000..24085ff05
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/IRuleNode.cs
@@ -0,0 +1,47 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime.Sharpen;
+using Antlr4.Runtime.Tree;
+
+namespace Antlr4.Runtime.Tree
+{
+    public interface IRuleNode : IParseTree
+    {
+        Antlr4.Runtime.RuleContext RuleContext
+        {
+            get;
+        }
+
+        new IRuleNode Parent
+        {
+            get;
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/ISyntaxTree.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/ISyntaxTree.cs
new file mode 100644
index 000000000..78be0ca5b
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/ISyntaxTree.cs
@@ -0,0 +1,64 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+using Antlr4.Runtime.Tree;
+
+namespace Antlr4.Runtime.Tree
+{
+    /// <summary>
+    /// A tree that knows about an interval in a token stream
+    /// is some kind of syntax tree.
+    /// </summary>
+    /// <remarks>
+    /// A tree that knows about an interval in a token stream
+    /// is some kind of syntax tree. Subinterfaces distinguish
+    /// between parse trees and other kinds of syntax trees we might want to create.
+    /// </remarks>
+    public interface ISyntaxTree : ITree
+    {
+        /// <summary>
+        /// Return an
+        /// <see cref="Antlr4.Runtime.Misc.Interval"/>
+        /// indicating the index in the
+        /// <see cref="Antlr4.Runtime.ITokenStream"/>
+        /// of the first and last token associated with this
+        /// subtree. If this node is a leaf, then the interval represents a single
+        /// token.
+        /// <p>If source interval is unknown, this returns
+        /// <see cref="Antlr4.Runtime.Misc.Interval.Invalid"/>
+        /// .</p>
+        /// </summary>
+        Interval SourceInterval
+        {
+            get;
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/ITerminalNode.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/ITerminalNode.cs
new file mode 100644
index 000000000..39842b030
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/ITerminalNode.cs
@@ -0,0 +1,48 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime;
+using Antlr4.Runtime.Sharpen;
+using Antlr4.Runtime.Tree;
+
+namespace Antlr4.Runtime.Tree
+{
+    public interface ITerminalNode : IParseTree
+    {
+        IToken Symbol
+        {
+            get;
+        }
+
+        new IRuleNode Parent
+        {
+            get;
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/ITree.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/ITree.cs
new file mode 100644
index 000000000..f3619305d
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/ITree.cs
@@ -0,0 +1,97 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime.Sharpen;
+using Antlr4.Runtime.Tree;
+
+namespace Antlr4.Runtime.Tree
+{
+    /// <summary>The basic notion of a tree has a parent, a payload, and a list of children.</summary>
+    /// <remarks>
+    /// The basic notion of a tree has a parent, a payload, and a list of children.
+    /// It is the most abstract interface for all the trees used by ANTLR.
+    /// </remarks>
+    public interface ITree
+    {
+        /// <summary>The parent of this node.</summary>
+        /// <remarks>
+        /// The parent of this node. If the return value is null, then this
+        /// node is the root of the tree.
+        /// </remarks>
+        ITree Parent
+        {
+            get;
+        }
+
+        /// <summary>This method returns whatever object represents the data at this note.</summary>
+        /// <remarks>
+        /// This method returns whatever object represents the data at this note. For
+        /// example, for parse trees, the payload can be a
+        /// <see cref="Antlr4.Runtime.IToken"/>
+        /// representing
+        /// a leaf node or a
+        /// <see cref="Antlr4.Runtime.RuleContext"/>
+        /// object representing a rule
+        /// invocation. For abstract syntax trees (ASTs), this is a
+        /// <see cref="Antlr4.Runtime.IToken"/>
+        /// object.
+        /// </remarks>
+        object Payload
+        {
+            get;
+        }
+
+        /// <summary>
+        /// If there are children, get the
+        /// <paramref name="i"/>
+        /// th value indexed from 0.
+        /// </summary>
+        ITree GetChild(int i);
+
+        /// <summary>
+        /// How many children are there? If there is none, then this
+        /// node represents a leaf node.
+        /// </summary>
+        /// <remarks>
+        /// How many children are there? If there is none, then this
+        /// node represents a leaf node.
+        /// </remarks>
+        int ChildCount
+        {
+            get;
+        }
+
+        /// <summary>
+        /// Print out a whole tree, not just a node, in LISP format
+        /// <c>(root child1 .. childN)</c>
+        /// . Print just a node if this is a leaf.
+        /// </summary>
+        string ToStringTree();
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/ParseTreeProperty.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/ParseTreeProperty.cs
new file mode 100644
index 000000000..3622aefd8
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/ParseTreeProperty.cs
@@ -0,0 +1,79 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using Antlr4.Runtime.Sharpen;
+using Antlr4.Runtime.Tree;
+
+namespace Antlr4.Runtime.Tree
+{
+    /// <summary>Associate a property with a parse tree node.</summary>
+    /// <remarks>
+    /// Associate a property with a parse tree node. Useful with parse tree listeners
+    /// that need to associate values with particular tree nodes, kind of like
+    /// specifying a return value for the listener event method that visited a
+    /// particular node. Example:
+    /// <pre>
+    /// ParseTreeProperty&lt;Integer&gt; values = new ParseTreeProperty&lt;Integer&gt;();
+    /// values.put(tree, 36);
+    /// int x = values.get(tree);
+    /// values.removeFrom(tree);
+    /// </pre>
+    /// You would make one decl (values here) in the listener and use lots of times
+    /// in your event methods.
+    /// </remarks>
+    public class ParseTreeProperty<V>
+    {
+        protected internal ConcurrentDictionary<IParseTree, V> annotations = new ConcurrentDictionary<IParseTree, V>();
+
+        public virtual V Get(IParseTree node)
+        {
+            V value;
+            if (!annotations.TryGetValue(node, out value))
+                return default(V);
+
+            return value;
+        }
+
+        public virtual void Put(IParseTree node, V value)
+        {
+            annotations[node] = value;
+        }
+
+        public virtual V RemoveFrom(IParseTree node)
+        {
+            V value;
+            if (!annotations.TryRemove(node, out value))
+                return default(V);
+
+            return value;
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/ParseTreeWalker.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/ParseTreeWalker.cs
new file mode 100644
index 000000000..4e31fa8b8
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/ParseTreeWalker.cs
@@ -0,0 +1,87 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime;
+using Antlr4.Runtime.Sharpen;
+using Antlr4.Runtime.Tree;
+
+namespace Antlr4.Runtime.Tree
+{
+    public class ParseTreeWalker
+    {
+        public static readonly ParseTreeWalker Default = new ParseTreeWalker();
+
+        public virtual void Walk(IParseTreeListener listener, IParseTree t)
+        {
+            if (t is IErrorNode)
+            {
+                listener.VisitErrorNode((IErrorNode)t);
+                return;
+            }
+            else
+            {
+                if (t is ITerminalNode)
+                {
+                    listener.VisitTerminal((ITerminalNode)t);
+                    return;
+                }
+            }
+            IRuleNode r = (IRuleNode)t;
+            EnterRule(listener, r);
+            int n = r.ChildCount;
+            for (int i = 0; i < n; i++)
+            {
+                Walk(listener, r.GetChild(i));
+            }
+            ExitRule(listener, r);
+        }
+
+        /// <summary>
+        /// The discovery of a rule node, involves sending two events: the generic
+        /// <see cref="IParseTreeListener.EnterEveryRule(Antlr4.Runtime.ParserRuleContext)"/>
+        /// and a
+        /// <see cref="Antlr4.Runtime.RuleContext"/>
+        /// -specific event. First we trigger the generic and then
+        /// the rule specific. We to them in reverse order upon finishing the node.
+        /// </summary>
+        protected internal virtual void EnterRule(IParseTreeListener listener, IRuleNode r)
+        {
+            ParserRuleContext ctx = (ParserRuleContext)r.RuleContext;
+            listener.EnterEveryRule(ctx);
+            ctx.EnterRule(listener);
+        }
+
+        protected internal virtual void ExitRule(IParseTreeListener listener, IRuleNode r)
+        {
+            ParserRuleContext ctx = (ParserRuleContext)r.RuleContext;
+            ctx.ExitRule(listener);
+            listener.ExitEveryRule(ctx);
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Pattern/Chunk.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Pattern/Chunk.cs
new file mode 100644
index 000000000..53d48e909
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Pattern/Chunk.cs
@@ -0,0 +1,61 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime.Sharpen;
+using Antlr4.Runtime.Tree.Pattern;
+
+namespace Antlr4.Runtime.Tree.Pattern
+{
+    /// <summary>
+    /// A chunk is either a token tag, a rule tag, or a span of literal text within a
+    /// tree pattern.
+    /// </summary>
+    /// <remarks>
+    /// A chunk is either a token tag, a rule tag, or a span of literal text within a
+    /// tree pattern.
+    /// <p>The method
+    /// <see cref="ParseTreePatternMatcher.Split(string)"/>
+    /// returns a list of
+    /// chunks in preparation for creating a token stream by
+    /// <see cref="ParseTreePatternMatcher.Tokenize(string)"/>
+    /// . From there, we get a parse
+    /// tree from with
+    /// <see cref="ParseTreePatternMatcher.Compile(string, int)"/>
+    /// . These
+    /// chunks are converted to
+    /// <see cref="RuleTagToken"/>
+    /// ,
+    /// <see cref="TokenTagToken"/>
+    /// , or the
+    /// regular tokens of the text surrounding the tags.</p>
+    /// </remarks>
+    internal abstract class Chunk
+    {
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Pattern/ParseTreeMatch.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Pattern/ParseTreeMatch.cs
new file mode 100644
index 000000000..162eb5684
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Pattern/ParseTreeMatch.cs
@@ -0,0 +1,319 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System;
+using System.Collections.Generic;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+using Antlr4.Runtime.Tree;
+using Antlr4.Runtime.Tree.Pattern;
+
+namespace Antlr4.Runtime.Tree.Pattern
+{
+    /// <summary>
+    /// Represents the result of matching a
+    /// <see cref="Antlr4.Runtime.Tree.IParseTree"/>
+    /// against a tree pattern.
+    /// </summary>
+    public class ParseTreeMatch
+    {
+        /// <summary>
+        /// This is the backing field for
+        /// <see cref="Tree()"/>
+        /// .
+        /// </summary>
+        private readonly IParseTree tree;
+
+        /// <summary>
+        /// This is the backing field for
+        /// <see cref="Pattern()"/>
+        /// .
+        /// </summary>
+        private readonly ParseTreePattern pattern;
+
+        /// <summary>
+        /// This is the backing field for
+        /// <see cref="Labels()"/>
+        /// .
+        /// </summary>
+        private readonly MultiMap<string, IParseTree> labels;
+
+        /// <summary>
+        /// This is the backing field for
+        /// <see cref="MismatchedNode()"/>
+        /// .
+        /// </summary>
+        private readonly IParseTree mismatchedNode;
+
+        /// <summary>
+        /// Constructs a new instance of
+        /// <see cref="ParseTreeMatch"/>
+        /// from the specified
+        /// parse tree and pattern.
+        /// </summary>
+        /// <param name="tree">The parse tree to match against the pattern.</param>
+        /// <param name="pattern">The parse tree pattern.</param>
+        /// <param name="labels">
+        /// A mapping from label names to collections of
+        /// <see cref="Antlr4.Runtime.Tree.IParseTree"/>
+        /// objects located by the tree pattern matching process.
+        /// </param>
+        /// <param name="mismatchedNode">
+        /// The first node which failed to match the tree
+        /// pattern during the matching process.
+        /// </param>
+        /// <exception>
+        /// IllegalArgumentException
+        /// if
+        /// <paramref name="tree"/>
+        /// is
+        /// <see langword="null"/>
+        /// </exception>
+        /// <exception>
+        /// IllegalArgumentException
+        /// if
+        /// <paramref name="pattern"/>
+        /// is
+        /// <see langword="null"/>
+        /// </exception>
+        /// <exception>
+        /// IllegalArgumentException
+        /// if
+        /// <paramref name="labels"/>
+        /// is
+        /// <see langword="null"/>
+        /// </exception>
+        public ParseTreeMatch(IParseTree tree, ParseTreePattern pattern, MultiMap<string, IParseTree> labels, IParseTree mismatchedNode)
+        {
+            if (tree == null)
+            {
+                throw new ArgumentException("tree cannot be null");
+            }
+            if (pattern == null)
+            {
+                throw new ArgumentException("pattern cannot be null");
+            }
+            if (labels == null)
+            {
+                throw new ArgumentException("labels cannot be null");
+            }
+            this.tree = tree;
+            this.pattern = pattern;
+            this.labels = labels;
+            this.mismatchedNode = mismatchedNode;
+        }
+
+        /// <summary>
+        /// Get the last node associated with a specific
+        /// <paramref name="label"/>
+        /// .
+        /// <p>For example, for pattern
+        /// <c>&lt;id:ID&gt;</c>
+        /// ,
+        /// <c>get("id")</c>
+        /// returns the
+        /// node matched for that
+        /// <c>ID</c>
+        /// . If more than one node
+        /// matched the specified label, only the last is returned. If there is
+        /// no node associated with the label, this returns
+        /// <see langword="null"/>
+        /// .</p>
+        /// <p>Pattern tags like
+        /// <c>&lt;ID&gt;</c>
+        /// and
+        /// <c>&lt;expr&gt;</c>
+        /// without labels are
+        /// considered to be labeled with
+        /// <c>ID</c>
+        /// and
+        /// <c>expr</c>
+        /// , respectively.</p>
+        /// </summary>
+        /// <param name="label">The label to check.</param>
+        /// <returns>
+        /// The last
+        /// <see cref="Antlr4.Runtime.Tree.IParseTree"/>
+        /// to match a tag with the specified
+        /// label, or
+        /// <see langword="null"/>
+        /// if no parse tree matched a tag with the label.
+        /// </returns>
+        [return: Nullable]
+        public virtual IParseTree Get(string label)
+        {
+            IList<IParseTree> parseTrees = labels.Get(label);
+            if (parseTrees == null || parseTrees.Count == 0)
+            {
+                return null;
+            }
+            return parseTrees[parseTrees.Count - 1];
+        }
+
+        // return last if multiple
+        /// <summary>Return all nodes matching a rule or token tag with the specified label.</summary>
+        /// <remarks>
+        /// Return all nodes matching a rule or token tag with the specified label.
+        /// <p>If the
+        /// <paramref name="label"/>
+        /// is the name of a parser rule or token in the
+        /// grammar, the resulting list will contain both the parse trees matching
+        /// rule or tags explicitly labeled with the label and the complete set of
+        /// parse trees matching the labeled and unlabeled tags in the pattern for
+        /// the parser rule or token. For example, if
+        /// <paramref name="label"/>
+        /// is
+        /// <c>"foo"</c>
+        /// ,
+        /// the result will contain <em>all</em> of the following.</p>
+        /// <ul>
+        /// <li>Parse tree nodes matching tags of the form
+        /// <c>&lt;foo:anyRuleName&gt;</c>
+        /// and
+        /// <c>&lt;foo:AnyTokenName&gt;</c>
+        /// .</li>
+        /// <li>Parse tree nodes matching tags of the form
+        /// <c>&lt;anyLabel:foo&gt;</c>
+        /// .</li>
+        /// <li>Parse tree nodes matching tags of the form
+        /// <c>&lt;foo&gt;</c>
+        /// .</li>
+        /// </ul>
+        /// </remarks>
+        /// <param name="label">The label.</param>
+        /// <returns>
+        /// A collection of all
+        /// <see cref="Antlr4.Runtime.Tree.IParseTree"/>
+        /// nodes matching tags with
+        /// the specified
+        /// <paramref name="label"/>
+        /// . If no nodes matched the label, an empty list
+        /// is returned.
+        /// </returns>
+        [return: NotNull]
+        public virtual IList<IParseTree> GetAll(string label)
+        {
+            IList<IParseTree> nodes = labels.Get(label);
+            if (nodes == null)
+            {
+                return Sharpen.Collections.EmptyList<IParseTree>();
+            }
+            return nodes;
+        }
+
+        /// <summary>Return a mapping from label &#x2192; [list of nodes].</summary>
+        /// <remarks>
+        /// Return a mapping from label &#x2192; [list of nodes].
+        /// <p>The map includes special entries corresponding to the names of rules and
+        /// tokens referenced in tags in the original pattern. For additional
+        /// information, see the description of
+        /// <see cref="GetAll(string)"/>
+        /// .</p>
+        /// </remarks>
+        /// <returns>
+        /// A mapping from labels to parse tree nodes. If the parse tree
+        /// pattern did not contain any rule or token tags, this map will be empty.
+        /// </returns>
+        [NotNull]
+        public virtual MultiMap<string, IParseTree> Labels
+        {
+            get
+            {
+                return labels;
+            }
+        }
+
+        /// <summary>Get the node at which we first detected a mismatch.</summary>
+        /// <remarks>Get the node at which we first detected a mismatch.</remarks>
+        /// <returns>
+        /// the node at which we first detected a mismatch, or
+        /// <see langword="null"/>
+        /// if the match was successful.
+        /// </returns>
+        [Nullable]
+        public virtual IParseTree MismatchedNode
+        {
+            get
+            {
+                return mismatchedNode;
+            }
+        }
+
+        /// <summary>Gets a value indicating whether the match operation succeeded.</summary>
+        /// <remarks>Gets a value indicating whether the match operation succeeded.</remarks>
+        /// <returns>
+        /// 
+        /// <see langword="true"/>
+        /// if the match operation succeeded; otherwise,
+        /// <see langword="false"/>
+        /// .
+        /// </returns>
+        public virtual bool Succeeded
+        {
+            get
+            {
+                return mismatchedNode == null;
+            }
+        }
+
+        /// <summary>Get the tree pattern we are matching against.</summary>
+        /// <remarks>Get the tree pattern we are matching against.</remarks>
+        /// <returns>The tree pattern we are matching against.</returns>
+        [NotNull]
+        public virtual ParseTreePattern Pattern
+        {
+            get
+            {
+                return pattern;
+            }
+        }
+
+        /// <summary>Get the parse tree we are trying to match to a pattern.</summary>
+        /// <remarks>Get the parse tree we are trying to match to a pattern.</remarks>
+        /// <returns>
+        /// The
+        /// <see cref="Antlr4.Runtime.Tree.IParseTree"/>
+        /// we are trying to match to a pattern.
+        /// </returns>
+        [NotNull]
+        public virtual IParseTree Tree
+        {
+            get
+            {
+                return tree;
+            }
+        }
+
+        /// <summary><inheritDoc/></summary>
+        public override string ToString()
+        {
+            return string.Format("Match {0}; found {1} labels", Succeeded ? "succeeded" : "failed", Labels.Count);
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Pattern/ParseTreePattern.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Pattern/ParseTreePattern.cs
new file mode 100644
index 000000000..a70cc8a0b
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Pattern/ParseTreePattern.cs
@@ -0,0 +1,260 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System.Collections.Generic;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+using Antlr4.Runtime.Tree;
+using Antlr4.Runtime.Tree.Pattern;
+using Antlr4.Runtime.Tree.Xpath;
+
+namespace Antlr4.Runtime.Tree.Pattern
+{
+    /// <summary>
+    /// A pattern like
+    /// <c>&lt;ID&gt; = &lt;expr&gt;;</c>
+    /// converted to a
+    /// <see cref="Antlr4.Runtime.Tree.IParseTree"/>
+    /// by
+    /// <see cref="ParseTreePatternMatcher.Compile(string, int)"/>
+    /// .
+    /// </summary>
+    public class ParseTreePattern
+    {
+        /// <summary>
+        /// This is the backing field for
+        /// <see cref="PatternRuleIndex()"/>
+        /// .
+        /// </summary>
+        private readonly int patternRuleIndex;
+
+        /// <summary>
+        /// This is the backing field for
+        /// <see cref="Pattern()"/>
+        /// .
+        /// </summary>
+        [NotNull]
+        private readonly string pattern;
+
+        /// <summary>
+        /// This is the backing field for
+        /// <see cref="PatternTree()"/>
+        /// .
+        /// </summary>
+        [NotNull]
+        private readonly IParseTree patternTree;
+
+        /// <summary>
+        /// This is the backing field for
+        /// <see cref="Matcher()"/>
+        /// .
+        /// </summary>
+        [NotNull]
+        private readonly ParseTreePatternMatcher matcher;
+
+        /// <summary>
+        /// Construct a new instance of the
+        /// <see cref="ParseTreePattern"/>
+        /// class.
+        /// </summary>
+        /// <param name="matcher">
+        /// The
+        /// <see cref="ParseTreePatternMatcher"/>
+        /// which created this
+        /// tree pattern.
+        /// </param>
+        /// <param name="pattern">The tree pattern in concrete syntax form.</param>
+        /// <param name="patternRuleIndex">
+        /// The parser rule which serves as the root of the
+        /// tree pattern.
+        /// </param>
+        /// <param name="patternTree">
+        /// The tree pattern in
+        /// <see cref="Antlr4.Runtime.Tree.IParseTree"/>
+        /// form.
+        /// </param>
+        public ParseTreePattern(ParseTreePatternMatcher matcher, string pattern, int patternRuleIndex, IParseTree patternTree)
+        {
+            this.matcher = matcher;
+            this.patternRuleIndex = patternRuleIndex;
+            this.pattern = pattern;
+            this.patternTree = patternTree;
+        }
+
+        /// <summary>Match a specific parse tree against this tree pattern.</summary>
+        /// <remarks>Match a specific parse tree against this tree pattern.</remarks>
+        /// <param name="tree">The parse tree to match against this tree pattern.</param>
+        /// <returns>
+        /// A
+        /// <see cref="ParseTreeMatch"/>
+        /// object describing the result of the
+        /// match operation. The
+        /// <see cref="ParseTreeMatch.Succeeded()"/>
+        /// method can be
+        /// used to determine whether or not the match was successful.
+        /// </returns>
+        [return: NotNull]
+        public virtual ParseTreeMatch Match(IParseTree tree)
+        {
+            return matcher.Match(tree, this);
+        }
+
+        /// <summary>Determine whether or not a parse tree matches this tree pattern.</summary>
+        /// <remarks>Determine whether or not a parse tree matches this tree pattern.</remarks>
+        /// <param name="tree">The parse tree to match against this tree pattern.</param>
+        /// <returns>
+        /// 
+        /// <see langword="true"/>
+        /// if
+        /// <paramref name="tree"/>
+        /// is a match for the current tree
+        /// pattern; otherwise,
+        /// <see langword="false"/>
+        /// .
+        /// </returns>
+        public virtual bool Matches(IParseTree tree)
+        {
+            return matcher.Match(tree, this).Succeeded;
+        }
+
+        /// <summary>
+        /// Find all nodes using XPath and then try to match those subtrees against
+        /// this tree pattern.
+        /// </summary>
+        /// <remarks>
+        /// Find all nodes using XPath and then try to match those subtrees against
+        /// this tree pattern.
+        /// </remarks>
+        /// <param name="tree">
+        /// The
+        /// <see cref="Antlr4.Runtime.Tree.IParseTree"/>
+        /// to match against this pattern.
+        /// </param>
+        /// <param name="xpath">An expression matching the nodes</param>
+        /// <returns>
+        /// A collection of
+        /// <see cref="ParseTreeMatch"/>
+        /// objects describing the
+        /// successful matches. Unsuccessful matches are omitted from the result,
+        /// regardless of the reason for the failure.
+        /// </returns>
+        [return: NotNull]
+        public virtual IList<ParseTreeMatch> FindAll(IParseTree tree, string xpath)
+        {
+            ICollection<IParseTree> subtrees = XPath.FindAll(tree, xpath, matcher.Parser);
+            IList<ParseTreeMatch> matches = new List<ParseTreeMatch>();
+            foreach (IParseTree t in subtrees)
+            {
+                ParseTreeMatch match = Match(t);
+                if (match.Succeeded)
+                {
+                    matches.Add(match);
+                }
+            }
+            return matches;
+        }
+
+        /// <summary>
+        /// Get the
+        /// <see cref="ParseTreePatternMatcher"/>
+        /// which created this tree pattern.
+        /// </summary>
+        /// <returns>
+        /// The
+        /// <see cref="ParseTreePatternMatcher"/>
+        /// which created this tree
+        /// pattern.
+        /// </returns>
+        [NotNull]
+        public virtual ParseTreePatternMatcher Matcher
+        {
+            get
+            {
+                return matcher;
+            }
+        }
+
+        /// <summary>Get the tree pattern in concrete syntax form.</summary>
+        /// <remarks>Get the tree pattern in concrete syntax form.</remarks>
+        /// <returns>The tree pattern in concrete syntax form.</returns>
+        [NotNull]
+        public virtual string Pattern
+        {
+            get
+            {
+                return pattern;
+            }
+        }
+
+        /// <summary>
+        /// Get the parser rule which serves as the outermost rule for the tree
+        /// pattern.
+        /// </summary>
+        /// <remarks>
+        /// Get the parser rule which serves as the outermost rule for the tree
+        /// pattern.
+        /// </remarks>
+        /// <returns>
+        /// The parser rule which serves as the outermost rule for the tree
+        /// pattern.
+        /// </returns>
+        public virtual int PatternRuleIndex
+        {
+            get
+            {
+                return patternRuleIndex;
+            }
+        }
+
+        /// <summary>
+        /// Get the tree pattern as a
+        /// <see cref="Antlr4.Runtime.Tree.IParseTree"/>
+        /// . The rule and token tags from
+        /// the pattern are present in the parse tree as terminal nodes with a symbol
+        /// of type
+        /// <see cref="RuleTagToken"/>
+        /// or
+        /// <see cref="TokenTagToken"/>
+        /// .
+        /// </summary>
+        /// <returns>
+        /// The tree pattern as a
+        /// <see cref="Antlr4.Runtime.Tree.IParseTree"/>
+        /// .
+        /// </returns>
+        [NotNull]
+        public virtual IParseTree PatternTree
+        {
+            get
+            {
+                return patternTree;
+            }
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Pattern/ParseTreePatternMatcher.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Pattern/ParseTreePatternMatcher.cs
new file mode 100644
index 000000000..a5b22af99
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Pattern/ParseTreePatternMatcher.cs
@@ -0,0 +1,728 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Antlr4.Runtime;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+using Antlr4.Runtime.Tree;
+using Antlr4.Runtime.Tree.Pattern;
+
+namespace Antlr4.Runtime.Tree.Pattern
+{
+    /// <summary>
+    /// A tree pattern matching mechanism for ANTLR
+    /// <see cref="Antlr4.Runtime.Tree.IParseTree"/>
+    /// s.
+    /// <p>Patterns are strings of source input text with special tags representing
+    /// token or rule references such as:</p>
+    /// <p>
+    /// <c>&lt;ID&gt; = &lt;expr&gt;;</c>
+    /// </p>
+    /// <p>Given a pattern start rule such as
+    /// <c>statement</c>
+    /// , this object constructs
+    /// a
+    /// <see cref="Antlr4.Runtime.Tree.IParseTree"/>
+    /// with placeholders for the
+    /// <c>ID</c>
+    /// and
+    /// <c>expr</c>
+    /// subtree. Then the
+    /// <see cref="Match(Antlr4.Runtime.Tree.IParseTree, ParseTreePattern)"/>
+    /// routines can compare an actual
+    /// <see cref="Antlr4.Runtime.Tree.IParseTree"/>
+    /// from a parse with this pattern. Tag
+    /// <c>&lt;ID&gt;</c>
+    /// matches
+    /// any
+    /// <c>ID</c>
+    /// token and tag
+    /// <c>&lt;expr&gt;</c>
+    /// references the result of the
+    /// <c>expr</c>
+    /// rule (generally an instance of
+    /// <c>ExprContext</c>
+    /// .</p>
+    /// <p>Pattern
+    /// <c>x = 0;</c>
+    /// is a similar pattern that matches the same pattern
+    /// except that it requires the identifier to be
+    /// <c>x</c>
+    /// and the expression to
+    /// be
+    /// <c>0</c>
+    /// .</p>
+    /// <p>The
+    /// <see cref="Matches(Antlr4.Runtime.Tree.IParseTree, ParseTreePattern)"/>
+    /// routines return
+    /// <see langword="true"/>
+    /// or
+    /// <see langword="false"/>
+    /// based
+    /// upon a match for the tree rooted at the parameter sent in. The
+    /// <see cref="Match(Antlr4.Runtime.Tree.IParseTree, ParseTreePattern)"/>
+    /// routines return a
+    /// <see cref="ParseTreeMatch"/>
+    /// object that
+    /// contains the parse tree, the parse tree pattern, and a map from tag name to
+    /// matched nodes (more below). A subtree that fails to match, returns with
+    /// <see cref="ParseTreeMatch.MismatchedNode"/>
+    /// set to the first tree node that did not
+    /// match.</p>
+    /// <p>For efficiency, you can compile a tree pattern in string form to a
+    /// <see cref="ParseTreePattern"/>
+    /// object.</p>
+    /// <p>See
+    /// <c>TestParseTreeMatcher</c>
+    /// for lots of examples.
+    /// <see cref="ParseTreePattern"/>
+    /// has two static helper methods:
+    /// <see cref="ParseTreePattern.FindAll(Antlr4.Runtime.Tree.IParseTree, string)"/>
+    /// and
+    /// <see cref="ParseTreePattern.Match(Antlr4.Runtime.Tree.IParseTree)"/>
+    /// that
+    /// are easy to use but not super efficient because they create new
+    /// <see cref="ParseTreePatternMatcher"/>
+    /// objects each time and have to compile the
+    /// pattern in string form before using it.</p>
+    /// <p>The lexer and parser that you pass into the
+    /// <see cref="ParseTreePatternMatcher"/>
+    /// constructor are used to parse the pattern in string form. The lexer converts
+    /// the
+    /// <c>&lt;ID&gt; = &lt;expr&gt;;</c>
+    /// into a sequence of four tokens (assuming lexer
+    /// throws out whitespace or puts it on a hidden channel). Be aware that the
+    /// input stream is reset for the lexer (but not the parser; a
+    /// <see cref="Antlr4.Runtime.ParserInterpreter"/>
+    /// is created to parse the input.). Any user-defined
+    /// fields you have put into the lexer might get changed when this mechanism asks
+    /// it to scan the pattern string.</p>
+    /// <p>Normally a parser does not accept token
+    /// <c>&lt;expr&gt;</c>
+    /// as a valid
+    /// <c>expr</c>
+    /// but, from the parser passed in, we create a special version of
+    /// the underlying grammar representation (an
+    /// <see cref="Antlr4.Runtime.Atn.ATN"/>
+    /// ) that allows imaginary
+    /// tokens representing rules (
+    /// <c>&lt;expr&gt;</c>
+    /// ) to match entire rules. We call
+    /// these <em>bypass alternatives</em>.</p>
+    /// <p>Delimiters are
+    /// <c>&lt;</c>
+    /// and
+    /// <c>&gt;</c>
+    /// , with
+    /// <c>\</c>
+    /// as the escape string
+    /// by default, but you can set them to whatever you want using
+    /// <see cref="SetDelimiters(string, string, string)"/>
+    /// . You must escape both start and stop strings
+    /// <c>\&lt;</c>
+    /// and
+    /// <c>\&gt;</c>
+    /// .</p>
+    /// </summary>
+    public class ParseTreePatternMatcher
+    {
+        [System.Serializable]
+        public class CannotInvokeStartRule : Exception
+        {
+            public CannotInvokeStartRule(Exception e)
+                : base(e.Message, e)
+            {
+            }
+        }
+
+        [System.Serializable]
+        public class StartRuleDoesNotConsumeFullPattern : Exception
+        {
+            // Fixes https://github.com/antlr/antlr4/issues/413
+            // "Tree pattern compilation doesn't check for a complete parse"
+        }
+
+        /// <summary>
+        /// This is the backing field for
+        /// <see cref="Lexer()"/>
+        /// .
+        /// </summary>
+        private readonly Lexer lexer;
+
+        /// <summary>
+        /// This is the backing field for
+        /// <see cref="Parser()"/>
+        /// .
+        /// </summary>
+        private readonly Parser parser;
+
+        protected internal string start = "<";
+
+        protected internal string stop = ">";
+
+        protected internal string escape = "\\";
+
+        /// <summary>
+        /// Constructs a
+        /// <see cref="ParseTreePatternMatcher"/>
+        /// or from a
+        /// <see cref="Antlr4.Runtime.Lexer"/>
+        /// and
+        /// <see cref="Antlr4.Runtime.Parser"/>
+        /// object. The lexer input stream is altered for tokenizing
+        /// the tree patterns. The parser is used as a convenient mechanism to get
+        /// the grammar name, plus token, rule names.
+        /// </summary>
+        public ParseTreePatternMatcher(Lexer lexer, Parser parser)
+        {
+            // e.g., \< and \> must escape BOTH!
+            this.lexer = lexer;
+            this.parser = parser;
+        }
+
+        /// <summary>
+        /// Set the delimiters used for marking rule and token tags within concrete
+        /// syntax used by the tree pattern parser.
+        /// </summary>
+        /// <remarks>
+        /// Set the delimiters used for marking rule and token tags within concrete
+        /// syntax used by the tree pattern parser.
+        /// </remarks>
+        /// <param name="start">The start delimiter.</param>
+        /// <param name="stop">The stop delimiter.</param>
+        /// <param name="escapeLeft">The escape sequence to use for escaping a start or stop delimiter.</param>
+        /// <exception>
+        /// IllegalArgumentException
+        /// if
+        /// <paramref name="start"/>
+        /// is
+        /// <see langword="null"/>
+        /// or empty.
+        /// </exception>
+        /// <exception>
+        /// IllegalArgumentException
+        /// if
+        /// <paramref name="stop"/>
+        /// is
+        /// <see langword="null"/>
+        /// or empty.
+        /// </exception>
+        public virtual void SetDelimiters(string start, string stop, string escapeLeft)
+        {
+            if (string.IsNullOrEmpty(start))
+            {
+                throw new ArgumentException("start cannot be null or empty");
+            }
+            if (string.IsNullOrEmpty(stop))
+            {
+                throw new ArgumentException("stop cannot be null or empty");
+            }
+            this.start = start;
+            this.stop = stop;
+            this.escape = escapeLeft;
+        }
+
+        /// <summary>
+        /// Does
+        /// <paramref name="pattern"/>
+        /// matched as rule
+        /// <paramref name="patternRuleIndex"/>
+        /// match
+        /// <paramref name="tree"/>
+        /// ?
+        /// </summary>
+        public virtual bool Matches(IParseTree tree, string pattern, int patternRuleIndex)
+        {
+            ParseTreePattern p = Compile(pattern, patternRuleIndex);
+            return Matches(tree, p);
+        }
+
+        /// <summary>
+        /// Does
+        /// <paramref name="pattern"/>
+        /// matched as rule patternRuleIndex match tree? Pass in a
+        /// compiled pattern instead of a string representation of a tree pattern.
+        /// </summary>
+        public virtual bool Matches(IParseTree tree, ParseTreePattern pattern)
+        {
+            MultiMap<string, IParseTree> labels = new MultiMap<string, IParseTree>();
+            IParseTree mismatchedNode = MatchImpl(tree, pattern.PatternTree, labels);
+            return mismatchedNode == null;
+        }
+
+        /// <summary>
+        /// Compare
+        /// <paramref name="pattern"/>
+        /// matched as rule
+        /// <paramref name="patternRuleIndex"/>
+        /// against
+        /// <paramref name="tree"/>
+        /// and return a
+        /// <see cref="ParseTreeMatch"/>
+        /// object that contains the
+        /// matched elements, or the node at which the match failed.
+        /// </summary>
+        public virtual ParseTreeMatch Match(IParseTree tree, string pattern, int patternRuleIndex)
+        {
+            ParseTreePattern p = Compile(pattern, patternRuleIndex);
+            return Match(tree, p);
+        }
+
+        /// <summary>
+        /// Compare
+        /// <paramref name="pattern"/>
+        /// matched against
+        /// <paramref name="tree"/>
+        /// and return a
+        /// <see cref="ParseTreeMatch"/>
+        /// object that contains the matched elements, or the
+        /// node at which the match failed. Pass in a compiled pattern instead of a
+        /// string representation of a tree pattern.
+        /// </summary>
+        [return: NotNull]
+        public virtual ParseTreeMatch Match(IParseTree tree, ParseTreePattern pattern)
+        {
+            MultiMap<string, IParseTree> labels = new MultiMap<string, IParseTree>();
+            IParseTree mismatchedNode = MatchImpl(tree, pattern.PatternTree, labels);
+            return new ParseTreeMatch(tree, pattern, labels, mismatchedNode);
+        }
+
+        /// <summary>
+        /// For repeated use of a tree pattern, compile it to a
+        /// <see cref="ParseTreePattern"/>
+        /// using this method.
+        /// </summary>
+        public virtual ParseTreePattern Compile(string pattern, int patternRuleIndex)
+        {
+            IList<IToken> tokenList = Tokenize(pattern);
+            ListTokenSource tokenSrc = new ListTokenSource(tokenList);
+            CommonTokenStream tokens = new CommonTokenStream(tokenSrc);
+            ParserInterpreter parserInterp = new ParserInterpreter(parser.GrammarFileName, parser.Vocabulary, Arrays.AsList(parser.RuleNames), parser.GetATNWithBypassAlts(), tokens);
+            IParseTree tree = null;
+            try
+            {
+                parserInterp.ErrorHandler = new BailErrorStrategy();
+                tree = parserInterp.Parse(patternRuleIndex);
+            }
+            catch (ParseCanceledException e)
+            {
+                //			System.out.println("pattern tree = "+tree.toStringTree(parserInterp));
+                throw (RecognitionException)e.InnerException;
+            }
+            catch (RecognitionException)
+            {
+                throw;
+            }
+            catch (Exception e)
+            {
+                throw new ParseTreePatternMatcher.CannotInvokeStartRule(e);
+            }
+            // Make sure tree pattern compilation checks for a complete parse
+            if (tokens.La(1) != TokenConstants.Eof)
+            {
+                throw new ParseTreePatternMatcher.StartRuleDoesNotConsumeFullPattern();
+            }
+            return new ParseTreePattern(this, pattern, patternRuleIndex, tree);
+        }
+
+        /// <summary>Used to convert the tree pattern string into a series of tokens.</summary>
+        /// <remarks>
+        /// Used to convert the tree pattern string into a series of tokens. The
+        /// input stream is reset.
+        /// </remarks>
+        [NotNull]
+        public virtual Lexer Lexer
+        {
+            get
+            {
+                return lexer;
+            }
+        }
+
+        /// <summary>
+        /// Used to collect to the grammar file name, token names, rule names for
+        /// used to parse the pattern into a parse tree.
+        /// </summary>
+        /// <remarks>
+        /// Used to collect to the grammar file name, token names, rule names for
+        /// used to parse the pattern into a parse tree.
+        /// </remarks>
+        [NotNull]
+        public virtual Parser Parser
+        {
+            get
+            {
+                return parser;
+            }
+        }
+
+        // ---- SUPPORT CODE ----
+        /// <summary>
+        /// Recursively walk
+        /// <paramref name="tree"/>
+        /// against
+        /// <paramref name="patternTree"/>
+        /// , filling
+        /// <c>match.</c>
+        /// <see cref="ParseTreeMatch.Labels"/>
+        /// .
+        /// </summary>
+        /// <returns>
+        /// the first node encountered in
+        /// <paramref name="tree"/>
+        /// which does not match
+        /// a corresponding node in
+        /// <paramref name="patternTree"/>
+        /// , or
+        /// <see langword="null"/>
+        /// if the match
+        /// was successful. The specific node returned depends on the matching
+        /// algorithm used by the implementation, and may be overridden.
+        /// </returns>
+        [return: Nullable]
+        protected internal virtual IParseTree MatchImpl(IParseTree tree, IParseTree patternTree, MultiMap<string, IParseTree> labels)
+        {
+            if (tree == null)
+            {
+                throw new ArgumentException("tree cannot be null");
+            }
+            if (patternTree == null)
+            {
+                throw new ArgumentException("patternTree cannot be null");
+            }
+            // x and <ID>, x and y, or x and x; or could be mismatched types
+            if (tree is ITerminalNode && patternTree is ITerminalNode)
+            {
+                ITerminalNode t1 = (ITerminalNode)tree;
+                ITerminalNode t2 = (ITerminalNode)patternTree;
+                IParseTree mismatchedNode = null;
+                // both are tokens and they have same type
+                if (t1.Symbol.Type == t2.Symbol.Type)
+                {
+                    if (t2.Symbol is TokenTagToken)
+                    {
+                        // x and <ID>
+                        TokenTagToken tokenTagToken = (TokenTagToken)t2.Symbol;
+                        // track label->list-of-nodes for both token name and label (if any)
+
+                        labels.Map(tokenTagToken.TokenName, tree);
+                        if (tokenTagToken.Label != null)
+                        {
+                            labels.Map(tokenTagToken.Label, tree);
+                        }
+                    }
+                    else
+                    {
+                        if (t1.GetText().Equals(t2.GetText(), StringComparison.Ordinal))
+                        {
+                        }
+                        else
+                        {
+                            // x and x
+                            // x and y
+                            if (mismatchedNode == null)
+                            {
+                                mismatchedNode = t1;
+                            }
+                        }
+                    }
+                }
+                else
+                {
+                    if (mismatchedNode == null)
+                    {
+                        mismatchedNode = t1;
+                    }
+                }
+                return mismatchedNode;
+            }
+            if (tree is ParserRuleContext && patternTree is ParserRuleContext)
+            {
+                ParserRuleContext r1 = (ParserRuleContext)tree;
+                ParserRuleContext r2 = (ParserRuleContext)patternTree;
+                IParseTree mismatchedNode = null;
+                // (expr ...) and <expr>
+                RuleTagToken ruleTagToken = GetRuleTagToken(r2);
+                if (ruleTagToken != null)
+                {
+                    if (r1.RuleIndex == r2.RuleIndex)
+                    {
+                        // track label->list-of-nodes for both rule name and label (if any)
+                        labels.Map(ruleTagToken.RuleName, tree);
+                        if (ruleTagToken.Label != null)
+                        {
+                            labels.Map(ruleTagToken.Label, tree);
+                        }
+                    }
+                    else
+                    {
+                        if (mismatchedNode == null)
+                        {
+                            mismatchedNode = r1;
+                        }
+                    }
+                    return mismatchedNode;
+                }
+                // (expr ...) and (expr ...)
+                if (r1.ChildCount != r2.ChildCount)
+                {
+                    if (mismatchedNode == null)
+                    {
+                        mismatchedNode = r1;
+                    }
+                    return mismatchedNode;
+                }
+                int n = r1.ChildCount;
+                for (int i = 0; i < n; i++)
+                {
+                    IParseTree childMatch = MatchImpl(r1.GetChild(i), patternTree.GetChild(i), labels);
+                    if (childMatch != null)
+                    {
+                        return childMatch;
+                    }
+                }
+                return mismatchedNode;
+            }
+            // if nodes aren't both tokens or both rule nodes, can't match
+            return tree;
+        }
+
+        /// <summary>
+        /// Is
+        /// <paramref name="t"/>
+        /// 
+        /// <c>(expr &lt;expr&gt;)</c>
+        /// subtree?
+        /// </summary>
+        protected internal virtual RuleTagToken GetRuleTagToken(IParseTree t)
+        {
+            if (t is IRuleNode)
+            {
+                IRuleNode r = (IRuleNode)t;
+                if (r.ChildCount == 1 && r.GetChild(0) is ITerminalNode)
+                {
+                    ITerminalNode c = (ITerminalNode)r.GetChild(0);
+                    if (c.Symbol is RuleTagToken)
+                    {
+                        //					System.out.println("rule tag subtree "+t.toStringTree(parser));
+                        return (RuleTagToken)c.Symbol;
+                    }
+                }
+            }
+            return null;
+        }
+
+        public virtual IList<IToken> Tokenize(string pattern)
+        {
+            // split pattern into chunks: sea (raw input) and islands (<ID>, <expr>)
+            IList<Chunk> chunks = Split(pattern);
+            // create token stream from text and tags
+            IList<IToken> tokens = new List<IToken>();
+            foreach (Chunk chunk in chunks)
+            {
+                if (chunk is TagChunk)
+                {
+                    TagChunk tagChunk = (TagChunk)chunk;
+                    // add special rule token or conjure up new token from name
+                    if (System.Char.IsUpper(tagChunk.Tag[0]))
+                    {
+                        int ttype = parser.GetTokenType(tagChunk.Tag);
+                        if (ttype == TokenConstants.InvalidType)
+                        {
+                            throw new ArgumentException("Unknown token " + tagChunk.Tag + " in pattern: " + pattern);
+                        }
+                        TokenTagToken t = new TokenTagToken(tagChunk.Tag, ttype, tagChunk.Label);
+                        tokens.Add(t);
+                    }
+                    else
+                    {
+                        if (System.Char.IsLower(tagChunk.Tag[0]))
+                        {
+                            int ruleIndex = parser.GetRuleIndex(tagChunk.Tag);
+                            if (ruleIndex == -1)
+                            {
+                                throw new ArgumentException("Unknown rule " + tagChunk.Tag + " in pattern: " + pattern);
+                            }
+                            int ruleImaginaryTokenType = parser.GetATNWithBypassAlts().ruleToTokenType[ruleIndex];
+                            tokens.Add(new RuleTagToken(tagChunk.Tag, ruleImaginaryTokenType, tagChunk.Label));
+                        }
+                        else
+                        {
+                            throw new ArgumentException("invalid tag: " + tagChunk.Tag + " in pattern: " + pattern);
+                        }
+                    }
+                }
+                else
+                {
+                    TextChunk textChunk = (TextChunk)chunk;
+                    AntlrInputStream @in = new AntlrInputStream(textChunk.Text);
+                    lexer.SetInputStream(@in);
+                    IToken t = lexer.NextToken();
+                    while (t.Type != TokenConstants.Eof)
+                    {
+                        tokens.Add(t);
+                        t = lexer.NextToken();
+                    }
+                }
+            }
+            //		System.out.println("tokens="+tokens);
+            return tokens;
+        }
+
+        /// <summary>
+        /// Split
+        /// <c>&lt;ID&gt; = &lt;e:expr&gt; ;</c>
+        /// into 4 chunks for tokenizing by
+        /// <see cref="Tokenize(string)"/>
+        /// .
+        /// </summary>
+        internal virtual IList<Chunk> Split(string pattern)
+        {
+            int p = 0;
+            int n = pattern.Length;
+            IList<Chunk> chunks = new List<Chunk>();
+            // find all start and stop indexes first, then collect
+            IList<int> starts = new List<int>();
+            IList<int> stops = new List<int>();
+            while (p < n)
+            {
+                if (p == pattern.IndexOf(escape + start, p))
+                {
+                    p += escape.Length + start.Length;
+                }
+                else
+                {
+                    if (p == pattern.IndexOf(escape + stop, p))
+                    {
+                        p += escape.Length + stop.Length;
+                    }
+                    else
+                    {
+                        if (p == pattern.IndexOf(start, p))
+                        {
+                            starts.Add(p);
+                            p += start.Length;
+                        }
+                        else
+                        {
+                            if (p == pattern.IndexOf(stop, p))
+                            {
+                                stops.Add(p);
+                                p += stop.Length;
+                            }
+                            else
+                            {
+                                p++;
+                            }
+                        }
+                    }
+                }
+            }
+            //		System.out.println("");
+            //		System.out.println(starts);
+            //		System.out.println(stops);
+            if (starts.Count > stops.Count)
+            {
+                throw new ArgumentException("unterminated tag in pattern: " + pattern);
+            }
+            if (starts.Count < stops.Count)
+            {
+                throw new ArgumentException("missing start tag in pattern: " + pattern);
+            }
+            int ntags = starts.Count;
+            for (int i = 0; i < ntags; i++)
+            {
+                if (starts[i] >= stops[i])
+                {
+                    throw new ArgumentException("tag delimiters out of order in pattern: " + pattern);
+                }
+            }
+            // collect into chunks now
+            if (ntags == 0)
+            {
+                string text = Sharpen.Runtime.Substring(pattern, 0, n);
+                chunks.Add(new TextChunk(text));
+            }
+            if (ntags > 0 && starts[0] > 0)
+            {
+                // copy text up to first tag into chunks
+                string text = Sharpen.Runtime.Substring(pattern, 0, starts[0]);
+                chunks.Add(new TextChunk(text));
+            }
+            for (int i_1 = 0; i_1 < ntags; i_1++)
+            {
+                // copy inside of <tag>
+                string tag = Sharpen.Runtime.Substring(pattern, starts[i_1] + start.Length, stops[i_1]);
+                string ruleOrToken = tag;
+                string label = null;
+                int colon = tag.IndexOf(':');
+                if (colon >= 0)
+                {
+                    label = Sharpen.Runtime.Substring(tag, 0, colon);
+                    ruleOrToken = Sharpen.Runtime.Substring(tag, colon + 1, tag.Length);
+                }
+                chunks.Add(new TagChunk(label, ruleOrToken));
+                if (i_1 + 1 < ntags)
+                {
+                    // copy from end of <tag> to start of next
+                    string text = Sharpen.Runtime.Substring(pattern, stops[i_1] + stop.Length, starts[i_1 + 1]);
+                    chunks.Add(new TextChunk(text));
+                }
+            }
+            if (ntags > 0)
+            {
+                int afterLastTag = stops[ntags - 1] + stop.Length;
+                if (afterLastTag < n)
+                {
+                    // copy text from end of last tag to end
+                    string text = Sharpen.Runtime.Substring(pattern, afterLastTag, n);
+                    chunks.Add(new TextChunk(text));
+                }
+            }
+            // strip out the escape sequences from text chunks but not tags
+            for (int i_2 = 0; i_2 < chunks.Count; i_2++)
+            {
+                Chunk c = chunks[i_2];
+                if (c is TextChunk)
+                {
+                    TextChunk tc = (TextChunk)c;
+                    string unescaped = tc.Text.Replace(escape, string.Empty);
+                    if (unescaped.Length < tc.Text.Length)
+                    {
+                        chunks.Set(i_2, new TextChunk(unescaped));
+                    }
+                }
+            }
+            return chunks;
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Pattern/RuleTagToken.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Pattern/RuleTagToken.cs
new file mode 100644
index 000000000..c2d4e4f05
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Pattern/RuleTagToken.cs
@@ -0,0 +1,314 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System;
+using Antlr4.Runtime;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Tree.Pattern
+{
+    /// <summary>
+    /// A
+    /// <see cref="Antlr4.Runtime.IToken"/>
+    /// object representing an entire subtree matched by a parser
+    /// rule; e.g.,
+    /// <c>&lt;expr&gt;</c>
+    /// . These tokens are created for
+    /// <see cref="TagChunk"/>
+    /// chunks where the tag corresponds to a parser rule.
+    /// </summary>
+    public class RuleTagToken : IToken
+    {
+        /// <summary>
+        /// This is the backing field for
+        /// <see cref="RuleName()"/>
+        /// .
+        /// </summary>
+        private readonly string ruleName;
+
+        /// <summary>The token type for the current token.</summary>
+        /// <remarks>
+        /// The token type for the current token. This is the token type assigned to
+        /// the bypass alternative for the rule during ATN deserialization.
+        /// </remarks>
+        private readonly int bypassTokenType;
+
+        /// <summary>
+        /// This is the backing field for
+        /// <see cref="Label()"/>
+        /// .
+        /// </summary>
+        private readonly string label;
+
+        /// <summary>
+        /// Constructs a new instance of
+        /// <see cref="RuleTagToken"/>
+        /// with the specified rule
+        /// name and bypass token type and no label.
+        /// </summary>
+        /// <param name="ruleName">The name of the parser rule this rule tag matches.</param>
+        /// <param name="bypassTokenType">The bypass token type assigned to the parser rule.</param>
+        /// <exception>
+        /// IllegalArgumentException
+        /// if
+        /// <paramref name="ruleName"/>
+        /// is
+        /// <see langword="null"/>
+        /// or empty.
+        /// </exception>
+        public RuleTagToken(string ruleName, int bypassTokenType)
+            : this(ruleName, bypassTokenType, null)
+        {
+        }
+
+        /// <summary>
+        /// Constructs a new instance of
+        /// <see cref="RuleTagToken"/>
+        /// with the specified rule
+        /// name, bypass token type, and label.
+        /// </summary>
+        /// <param name="ruleName">The name of the parser rule this rule tag matches.</param>
+        /// <param name="bypassTokenType">The bypass token type assigned to the parser rule.</param>
+        /// <param name="label">
+        /// The label associated with the rule tag, or
+        /// <see langword="null"/>
+        /// if
+        /// the rule tag is unlabeled.
+        /// </param>
+        /// <exception>
+        /// IllegalArgumentException
+        /// if
+        /// <paramref name="ruleName"/>
+        /// is
+        /// <see langword="null"/>
+        /// or empty.
+        /// </exception>
+        public RuleTagToken(string ruleName, int bypassTokenType, string label)
+        {
+            if (string.IsNullOrEmpty(ruleName))
+            {
+                throw new ArgumentException("ruleName cannot be null or empty.");
+            }
+            this.ruleName = ruleName;
+            this.bypassTokenType = bypassTokenType;
+            this.label = label;
+        }
+
+        /// <summary>Gets the name of the rule associated with this rule tag.</summary>
+        /// <remarks>Gets the name of the rule associated with this rule tag.</remarks>
+        /// <returns>The name of the parser rule associated with this rule tag.</returns>
+        [NotNull]
+        public string RuleName
+        {
+            get
+            {
+                return ruleName;
+            }
+        }
+
+        /// <summary>Gets the label associated with the rule tag.</summary>
+        /// <remarks>Gets the label associated with the rule tag.</remarks>
+        /// <returns>
+        /// The name of the label associated with the rule tag, or
+        /// <see langword="null"/>
+        /// if this is an unlabeled rule tag.
+        /// </returns>
+        [Nullable]
+        public string Label
+        {
+            get
+            {
+                return label;
+            }
+        }
+
+        /// <summary>
+        /// <inheritDoc/>
+        /// <p>Rule tag tokens are always placed on the
+        /// <see cref="TokenConstants.DefaultChannel"/>
+        /// .</p>
+        /// </summary>
+        public virtual int Channel
+        {
+            get
+            {
+                return TokenConstants.DefaultChannel;
+            }
+        }
+
+        /// <summary>
+        /// <inheritDoc/>
+        /// <p>This method returns the rule tag formatted with
+        /// <c>&lt;</c>
+        /// and
+        /// <c>&gt;</c>
+        /// delimiters.</p>
+        /// </summary>
+        public virtual string Text
+        {
+            get
+            {
+                if (label != null)
+                {
+                    return "<" + label + ":" + ruleName + ">";
+                }
+                return "<" + ruleName + ">";
+            }
+        }
+
+        /// <summary>
+        /// <inheritDoc/>
+        /// <p>Rule tag tokens have types assigned according to the rule bypass
+        /// transitions created during ATN deserialization.</p>
+        /// </summary>
+        public virtual int Type
+        {
+            get
+            {
+                return bypassTokenType;
+            }
+        }
+
+        /// <summary>
+        /// <inheritDoc/>
+        /// <p>The implementation for
+        /// <see cref="RuleTagToken"/>
+        /// always returns 0.</p>
+        /// </summary>
+        public virtual int Line
+        {
+            get
+            {
+                return 0;
+            }
+        }
+
+        /// <summary>
+        /// <inheritDoc/>
+        /// <p>The implementation for
+        /// <see cref="RuleTagToken"/>
+        /// always returns -1.</p>
+        /// </summary>
+        public virtual int Column
+        {
+            get
+            {
+                return -1;
+            }
+        }
+
+        /// <summary>
+        /// <inheritDoc/>
+        /// <p>The implementation for
+        /// <see cref="RuleTagToken"/>
+        /// always returns -1.</p>
+        /// </summary>
+        public virtual int TokenIndex
+        {
+            get
+            {
+                return -1;
+            }
+        }
+
+        /// <summary>
+        /// <inheritDoc/>
+        /// <p>The implementation for
+        /// <see cref="RuleTagToken"/>
+        /// always returns -1.</p>
+        /// </summary>
+        public virtual int StartIndex
+        {
+            get
+            {
+                return -1;
+            }
+        }
+
+        /// <summary>
+        /// <inheritDoc/>
+        /// <p>The implementation for
+        /// <see cref="RuleTagToken"/>
+        /// always returns -1.</p>
+        /// </summary>
+        public virtual int StopIndex
+        {
+            get
+            {
+                return -1;
+            }
+        }
+
+        /// <summary>
+        /// <inheritDoc/>
+        /// <p>The implementation for
+        /// <see cref="RuleTagToken"/>
+        /// always returns
+        /// <see langword="null"/>
+        /// .</p>
+        /// </summary>
+        public virtual ITokenSource TokenSource
+        {
+            get
+            {
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// <inheritDoc/>
+        /// <p>The implementation for
+        /// <see cref="RuleTagToken"/>
+        /// always returns
+        /// <see langword="null"/>
+        /// .</p>
+        /// </summary>
+        public virtual ICharStream InputStream
+        {
+            get
+            {
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// <inheritDoc/>
+        /// <p>The implementation for
+        /// <see cref="RuleTagToken"/>
+        /// returns a string of the form
+        /// <c>ruleName:bypassTokenType</c>
+        /// .</p>
+        /// </summary>
+        public override string ToString()
+        {
+            return ruleName + ":" + bypassTokenType;
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Pattern/TagChunk.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Pattern/TagChunk.cs
new file mode 100644
index 000000000..eb2d6c985
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Pattern/TagChunk.cs
@@ -0,0 +1,188 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+using Antlr4.Runtime.Tree.Pattern;
+
+namespace Antlr4.Runtime.Tree.Pattern
+{
+    /// <summary>Represents a placeholder tag in a tree pattern.</summary>
+    /// <remarks>
+    /// Represents a placeholder tag in a tree pattern. A tag can have any of the
+    /// following forms.
+    /// <ul>
+    /// <li>
+    /// <c>expr</c>
+    /// : An unlabeled placeholder for a parser rule
+    /// <c>expr</c>
+    /// .</li>
+    /// <li>
+    /// <c>ID</c>
+    /// : An unlabeled placeholder for a token of type
+    /// <c>ID</c>
+    /// .</li>
+    /// <li>
+    /// <c>e:expr</c>
+    /// : A labeled placeholder for a parser rule
+    /// <c>expr</c>
+    /// .</li>
+    /// <li>
+    /// <c>id:ID</c>
+    /// : A labeled placeholder for a token of type
+    /// <c>ID</c>
+    /// .</li>
+    /// </ul>
+    /// This class does not perform any validation on the tag or label names aside
+    /// from ensuring that the tag is a non-null, non-empty string.
+    /// </remarks>
+    internal class TagChunk : Chunk
+    {
+        /// <summary>
+        /// This is the backing field for
+        /// <see cref="Tag()"/>
+        /// .
+        /// </summary>
+        private readonly string tag;
+
+        /// <summary>
+        /// This is the backing field for
+        /// <see cref="Label()"/>
+        /// .
+        /// </summary>
+        private readonly string label;
+
+        /// <summary>
+        /// Construct a new instance of
+        /// <see cref="TagChunk"/>
+        /// using the specified tag and
+        /// no label.
+        /// </summary>
+        /// <param name="tag">
+        /// The tag, which should be the name of a parser rule or token
+        /// type.
+        /// </param>
+        /// <exception>
+        /// IllegalArgumentException
+        /// if
+        /// <paramref name="tag"/>
+        /// is
+        /// <see langword="null"/>
+        /// or
+        /// empty.
+        /// </exception>
+        public TagChunk(string tag)
+            : this(null, tag)
+        {
+        }
+
+        /// <summary>
+        /// Construct a new instance of
+        /// <see cref="TagChunk"/>
+        /// using the specified label
+        /// and tag.
+        /// </summary>
+        /// <param name="label">
+        /// The label for the tag. If this is
+        /// <see langword="null"/>
+        /// , the
+        /// <see cref="TagChunk"/>
+        /// represents an unlabeled tag.
+        /// </param>
+        /// <param name="tag">
+        /// The tag, which should be the name of a parser rule or token
+        /// type.
+        /// </param>
+        /// <exception>
+        /// IllegalArgumentException
+        /// if
+        /// <paramref name="tag"/>
+        /// is
+        /// <see langword="null"/>
+        /// or
+        /// empty.
+        /// </exception>
+        public TagChunk(string label, string tag)
+        {
+            if (string.IsNullOrEmpty(tag))
+            {
+                throw new ArgumentException("tag cannot be null or empty");
+            }
+            this.label = label;
+            this.tag = tag;
+        }
+
+        /// <summary>Get the tag for this chunk.</summary>
+        /// <remarks>Get the tag for this chunk.</remarks>
+        /// <returns>The tag for the chunk.</returns>
+        [NotNull]
+        public string Tag
+        {
+            get
+            {
+                return tag;
+            }
+        }
+
+        /// <summary>Get the label, if any, assigned to this chunk.</summary>
+        /// <remarks>Get the label, if any, assigned to this chunk.</remarks>
+        /// <returns>
+        /// The label assigned to this chunk, or
+        /// <see langword="null"/>
+        /// if no label is
+        /// assigned to the chunk.
+        /// </returns>
+        [Nullable]
+        public string Label
+        {
+            get
+            {
+                return label;
+            }
+        }
+
+        /// <summary>This method returns a text representation of the tag chunk.</summary>
+        /// <remarks>
+        /// This method returns a text representation of the tag chunk. Labeled tags
+        /// are returned in the form
+        /// <c>label:tag</c>
+        /// , and unlabeled tags are
+        /// returned as just the tag name.
+        /// </remarks>
+        public override string ToString()
+        {
+            if (label != null)
+            {
+                return label + ":" + tag;
+            }
+            return tag;
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Pattern/TextChunk.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Pattern/TextChunk.cs
new file mode 100644
index 000000000..c98612bf6
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Pattern/TextChunk.cs
@@ -0,0 +1,103 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+using Antlr4.Runtime.Tree.Pattern;
+
+namespace Antlr4.Runtime.Tree.Pattern
+{
+    /// <summary>
+    /// Represents a span of raw text (concrete syntax) between tags in a tree
+    /// pattern string.
+    /// </summary>
+    /// <remarks>
+    /// Represents a span of raw text (concrete syntax) between tags in a tree
+    /// pattern string.
+    /// </remarks>
+    internal class TextChunk : Chunk
+    {
+        /// <summary>
+        /// This is the backing field for
+        /// <see cref="Text()"/>
+        /// .
+        /// </summary>
+        [NotNull]
+        private readonly string text;
+
+        /// <summary>
+        /// Constructs a new instance of
+        /// <see cref="TextChunk"/>
+        /// with the specified text.
+        /// </summary>
+        /// <param name="text">The text of this chunk.</param>
+        /// <exception>
+        /// IllegalArgumentException
+        /// if
+        /// <paramref name="text"/>
+        /// is
+        /// <see langword="null"/>
+        /// .
+        /// </exception>
+        public TextChunk(string text)
+        {
+            if (text == null)
+            {
+                throw new ArgumentException("text cannot be null");
+            }
+            this.text = text;
+        }
+
+        /// <summary>Gets the raw text of this chunk.</summary>
+        /// <remarks>Gets the raw text of this chunk.</remarks>
+        /// <returns>The text of the chunk.</returns>
+        [NotNull]
+        public string Text
+        {
+            get
+            {
+                return text;
+            }
+        }
+
+        /// <summary>
+        /// <inheritDoc/>
+        /// <p>The implementation for
+        /// <see cref="TextChunk"/>
+        /// returns the result of
+        /// <see cref="Text()"/>
+        /// in single quotes.</p>
+        /// </summary>
+        public override string ToString()
+        {
+            return "'" + text + "'";
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Pattern/TokenTagToken.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Pattern/TokenTagToken.cs
new file mode 100644
index 000000000..e844cad4b
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Pattern/TokenTagToken.cs
@@ -0,0 +1,163 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime.Tree.Pattern
+{
+    /// <summary>
+    /// A
+    /// <see cref="Antlr4.Runtime.IToken"/>
+    /// object representing a token of a particular type; e.g.,
+    /// <c>&lt;ID&gt;</c>
+    /// . These tokens are created for
+    /// <see cref="TagChunk"/>
+    /// chunks where the
+    /// tag corresponds to a lexer rule or token type.
+    /// </summary>
+    [System.Serializable]
+    public class TokenTagToken : CommonToken
+    {
+        /// <summary>
+        /// This is the backing field for
+        /// <see cref="TokenName()"/>
+        /// .
+        /// </summary>
+        [NotNull]
+        private readonly string tokenName;
+
+        /// <summary>
+        /// This is the backing field for
+        /// <see cref="Label()"/>
+        /// .
+        /// </summary>
+        [Nullable]
+        private readonly string label;
+
+        /// <summary>
+        /// Constructs a new instance of
+        /// <see cref="TokenTagToken"/>
+        /// for an unlabeled tag
+        /// with the specified token name and type.
+        /// </summary>
+        /// <param name="tokenName">The token name.</param>
+        /// <param name="type">The token type.</param>
+        public TokenTagToken(string tokenName, int type)
+            : this(tokenName, type, null)
+        {
+        }
+
+        /// <summary>
+        /// Constructs a new instance of
+        /// <see cref="TokenTagToken"/>
+        /// with the specified
+        /// token name, type, and label.
+        /// </summary>
+        /// <param name="tokenName">The token name.</param>
+        /// <param name="type">The token type.</param>
+        /// <param name="label">
+        /// The label associated with the token tag, or
+        /// <see langword="null"/>
+        /// if
+        /// the token tag is unlabeled.
+        /// </param>
+        public TokenTagToken(string tokenName, int type, string label)
+            : base(type)
+        {
+            this.tokenName = tokenName;
+            this.label = label;
+        }
+
+        /// <summary>Gets the token name.</summary>
+        /// <remarks>Gets the token name.</remarks>
+        /// <returns>The token name.</returns>
+        [NotNull]
+        public string TokenName
+        {
+            get
+            {
+                return tokenName;
+            }
+        }
+
+        /// <summary>Gets the label associated with the rule tag.</summary>
+        /// <remarks>Gets the label associated with the rule tag.</remarks>
+        /// <returns>
+        /// The name of the label associated with the rule tag, or
+        /// <see langword="null"/>
+        /// if this is an unlabeled rule tag.
+        /// </returns>
+        [Nullable]
+        public string Label
+        {
+            get
+            {
+                return label;
+            }
+        }
+
+        /// <summary>
+        /// <inheritDoc/>
+        /// <p>The implementation for
+        /// <see cref="TokenTagToken"/>
+        /// returns the token tag
+        /// formatted with
+        /// <c>&lt;</c>
+        /// and
+        /// <c>&gt;</c>
+        /// delimiters.</p>
+        /// </summary>
+        public override string Text
+        {
+            get
+            {
+                if (label != null)
+                {
+                    return "<" + label + ":" + tokenName + ">";
+                }
+                return "<" + tokenName + ">";
+            }
+        }
+
+        /// <summary>
+        /// <inheritDoc/>
+        /// <p>The implementation for
+        /// <see cref="TokenTagToken"/>
+        /// returns a string of the form
+        /// <c>tokenName:type</c>
+        /// .</p>
+        /// </summary>
+        public override string ToString()
+        {
+            return tokenName + ":" + Type;
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/TerminalNodeImpl.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/TerminalNodeImpl.cs
new file mode 100644
index 000000000..15c83dd9b
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/TerminalNodeImpl.cs
@@ -0,0 +1,171 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+using Antlr4.Runtime.Tree;
+
+namespace Antlr4.Runtime.Tree
+{
+    public class TerminalNodeImpl : ITerminalNode
+    {
+        private IToken _symbol;
+
+        private IRuleNode _parent;
+
+        public TerminalNodeImpl(IToken symbol)
+        {
+            this._symbol = symbol;
+        }
+
+        public virtual IParseTree GetChild(int i)
+        {
+            return null;
+        }
+
+        ITree ITree.GetChild(int i)
+        {
+            return GetChild(i);
+        }
+
+        public virtual IToken Symbol
+        {
+            get
+            {
+                return _symbol;
+            }
+        }
+
+        public virtual IRuleNode Parent
+        {
+            get
+            {
+                return _parent;
+            }
+			set 
+			{
+				_parent = value;
+			}
+        }
+
+        IParseTree IParseTree.Parent
+        {
+            get
+            {
+                return Parent;
+            }
+        }
+
+        ITree ITree.Parent
+        {
+            get
+            {
+                return Parent;
+            }
+        }
+
+        public virtual IToken Payload
+        {
+            get
+            {
+                return Symbol;
+            }
+        }
+
+        object ITree.Payload
+        {
+            get
+            {
+                return Payload;
+            }
+        }
+
+        public virtual Interval SourceInterval
+        {
+            get
+            {
+                if (Symbol != null)
+                {
+                    int tokenIndex = Symbol.TokenIndex;
+                    return new Interval(tokenIndex, tokenIndex);
+                }
+                return Interval.Invalid;
+            }
+        }
+
+        public virtual int ChildCount
+        {
+            get
+            {
+                return 0;
+            }
+        }
+
+        public virtual T Accept<T>(IParseTreeVisitor<T> visitor)
+        {
+            return visitor.VisitTerminal(this);
+        }
+
+        public virtual string GetText()
+        {
+            if (Symbol != null)
+            {
+                return Symbol.Text;
+            }
+            return null;
+        }
+
+        public virtual string ToStringTree(Parser parser)
+        {
+            return ToString();
+        }
+
+        public override string ToString()
+        {
+            if (Symbol != null)
+            {
+                if (Symbol.Type == TokenConstants.Eof)
+                {
+                    return "<EOF>";
+                }
+                return Symbol.Text;
+            }
+            else
+            {
+                return "<null>";
+            }
+        }
+
+        public virtual string ToStringTree()
+        {
+            return ToString();
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Trees.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Trees.cs
new file mode 100644
index 000000000..c77866920
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Trees.cs
@@ -0,0 +1,250 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System.Collections.Generic;
+using System.Text;
+using Antlr4.Runtime;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+using Antlr4.Runtime.Tree;
+
+namespace Antlr4.Runtime.Tree
+{
+    /// <summary>A set of utility routines useful for all kinds of ANTLR trees.</summary>
+    /// <remarks>A set of utility routines useful for all kinds of ANTLR trees.</remarks>
+    public class Trees
+    {
+        /// <summary>Print out a whole tree in LISP form.</summary>
+        /// <remarks>
+        /// Print out a whole tree in LISP form.
+        /// <see cref="GetNodeText(ITree, Antlr4.Runtime.Parser)"/>
+        /// is used on the
+        /// node payloads to get the text for the nodes.  Detect
+        /// parse trees and extract data appropriately.
+        /// </remarks>
+        public static string ToStringTree(ITree t)
+        {
+            return ToStringTree(t, (IList<string>)null);
+        }
+
+        /// <summary>Print out a whole tree in LISP form.</summary>
+        /// <remarks>
+        /// Print out a whole tree in LISP form.
+        /// <see cref="GetNodeText(ITree, Antlr4.Runtime.Parser)"/>
+        /// is used on the
+        /// node payloads to get the text for the nodes.  Detect
+        /// parse trees and extract data appropriately.
+        /// </remarks>
+        public static string ToStringTree(ITree t, Parser recog)
+        {
+            string[] ruleNames = recog != null ? recog.RuleNames : null;
+            IList<string> ruleNamesList = ruleNames != null ? Arrays.AsList(ruleNames) : null;
+            return ToStringTree(t, ruleNamesList);
+        }
+
+        /// <summary>Print out a whole tree in LISP form.</summary>
+        /// <remarks>
+        /// Print out a whole tree in LISP form.
+        /// <see cref="GetNodeText(ITree, Antlr4.Runtime.Parser)"/>
+        /// is used on the
+        /// node payloads to get the text for the nodes.  Detect
+        /// parse trees and extract data appropriately.
+        /// </remarks>
+        public static string ToStringTree(ITree t, IList<string> ruleNames)
+        {
+            string s = Utils.EscapeWhitespace(GetNodeText(t, ruleNames), false);
+            if (t.ChildCount == 0)
+            {
+                return s;
+            }
+            StringBuilder buf = new StringBuilder();
+            buf.Append("(");
+            s = Utils.EscapeWhitespace(GetNodeText(t, ruleNames), false);
+            buf.Append(s);
+            buf.Append(' ');
+            for (int i = 0; i < t.ChildCount; i++)
+            {
+                if (i > 0)
+                {
+                    buf.Append(' ');
+                }
+                buf.Append(ToStringTree(t.GetChild(i), ruleNames));
+            }
+            buf.Append(")");
+            return buf.ToString();
+        }
+
+        public static string GetNodeText(ITree t, Parser recog)
+        {
+            string[] ruleNames = recog != null ? recog.RuleNames : null;
+            IList<string> ruleNamesList = ruleNames != null ? Arrays.AsList(ruleNames) : null;
+            return GetNodeText(t, ruleNamesList);
+        }
+
+        public static string GetNodeText(ITree t, IList<string> ruleNames)
+        {
+            if (ruleNames != null)
+            {
+                if (t is RuleContext)
+                {
+                    int ruleIndex = ((RuleContext)t).RuleIndex;
+                    string ruleName = ruleNames[ruleIndex];
+					int altNumber = ((RuleContext)t).getAltNumber();
+					if ( altNumber!=Atn.ATN.InvalidAltNumber ) {
+						return ruleName+":"+altNumber;
+					}
+                    return ruleName;
+                }
+                else
+                {
+                    if (t is IErrorNode)
+                    {
+                        return t.ToString();
+                    }
+                    else
+                    {
+                        if (t is ITerminalNode)
+                        {
+                            IToken symbol = ((ITerminalNode)t).Symbol;
+                            if (symbol != null)
+                            {
+                                string s = symbol.Text;
+                                return s;
+                            }
+                        }
+                    }
+                }
+            }
+            // no recog for rule names
+            object payload = t.Payload;
+            if (payload is IToken)
+            {
+                return ((IToken)payload).Text;
+            }
+            return t.Payload.ToString();
+        }
+
+        /// <summary>Return ordered list of all children of this node</summary>
+        public static IList<ITree> GetChildren(ITree t)
+        {
+            IList<ITree> kids = new List<ITree>();
+            for (int i = 0; i < t.ChildCount; i++)
+            {
+                kids.Add(t.GetChild(i));
+            }
+            return kids;
+        }
+
+        /// <summary>Return a list of all ancestors of this node.</summary>
+        /// <remarks>
+        /// Return a list of all ancestors of this node.  The first node of
+        /// list is the root and the last is the parent of this node.
+        /// </remarks>
+        [return: NotNull]
+        public static IList<ITree> GetAncestors(ITree t)
+        {
+            if (t.Parent == null)
+            {
+                return Collections.EmptyList<ITree>();
+            }
+            IList<ITree> ancestors = new List<ITree>();
+            t = t.Parent;
+            while (t != null)
+            {
+                ancestors.Insert(0, t);
+                // insert at start
+                t = t.Parent;
+            }
+            return ancestors;
+        }
+
+        public static ICollection<IParseTree> FindAllTokenNodes(IParseTree t, int ttype)
+        {
+            return FindAllNodes(t, ttype, true);
+        }
+
+        public static ICollection<IParseTree> FindAllRuleNodes(IParseTree t, int ruleIndex)
+        {
+            return FindAllNodes(t, ruleIndex, false);
+        }
+
+        public static IList<IParseTree> FindAllNodes(IParseTree t, int index, bool findTokens)
+        {
+            IList<IParseTree> nodes = new List<IParseTree>();
+            _findAllNodes(t, index, findTokens, nodes);
+            return nodes;
+        }
+
+        private static void _findAllNodes(IParseTree t, int index, bool findTokens, IList<IParseTree> nodes)
+        {
+            // check this node (the root) first
+            if (findTokens && t is ITerminalNode)
+            {
+                ITerminalNode tnode = (ITerminalNode)t;
+                if (tnode.Symbol.Type == index)
+                {
+                    nodes.Add(t);
+                }
+            }
+            else
+            {
+                if (!findTokens && t is ParserRuleContext)
+                {
+                    ParserRuleContext ctx = (ParserRuleContext)t;
+                    if (ctx.RuleIndex == index)
+                    {
+                        nodes.Add(t);
+                    }
+                }
+            }
+            // check children
+            for (int i = 0; i < t.ChildCount; i++)
+            {
+                _findAllNodes(t.GetChild(i), index, findTokens, nodes);
+            }
+        }
+
+        public static IList<IParseTree> Descendants(IParseTree t)
+        {
+            List<IParseTree> nodes = new List<IParseTree>();
+            nodes.Add(t);
+            int n = t.ChildCount;
+            for (int i = 0; i < n; i++)
+            {
+                nodes.AddRange(Descendants(t.GetChild(i)));
+            }
+            return nodes;
+        }
+
+        private Trees()
+        {
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Xpath/XPath.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Xpath/XPath.cs
new file mode 100644
index 000000000..bc4905d06
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Xpath/XPath.cs
@@ -0,0 +1,310 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using Antlr4.Runtime;
+using Antlr4.Runtime.Sharpen;
+using Antlr4.Runtime.Tree;
+using Antlr4.Runtime.Tree.Xpath;
+
+namespace Antlr4.Runtime.Tree.Xpath
+{
+    /// <summary>
+    /// Represent a subset of XPath XML path syntax for use in identifying nodes in
+    /// parse trees.
+    /// </summary>
+    /// <remarks>
+    /// Represent a subset of XPath XML path syntax for use in identifying nodes in
+    /// parse trees.
+    /// <p>
+    /// Split path into words and separators
+    /// <c>/</c>
+    /// and
+    /// <c>//</c>
+    /// via ANTLR
+    /// itself then walk path elements from left to right. At each separator-word
+    /// pair, find set of nodes. Next stage uses those as work list.</p>
+    /// <p>
+    /// The basic interface is
+    /// <see cref="FindAll(Antlr4.Runtime.Tree.IParseTree, string, Antlr4.Runtime.Parser)">ParseTree.findAll</see>
+    /// <c>(tree, pathString, parser)</c>
+    /// .
+    /// But that is just shorthand for:</p>
+    /// <pre>
+    /// <see cref="XPath"/>
+    /// p = new
+    /// <see cref="XPath(Antlr4.Runtime.Parser, string)">XPath</see>
+    /// (parser, pathString);
+    /// return p.
+    /// <see cref="Evaluate(Antlr4.Runtime.Tree.IParseTree)">evaluate</see>
+    /// (tree);
+    /// </pre>
+    /// <p>
+    /// See
+    /// <c>org.antlr.v4.test.TestXPath</c>
+    /// for descriptions. In short, this
+    /// allows operators:</p>
+    /// <dl>
+    /// <dt>/</dt> <dd>root</dd>
+    /// <dt>//</dt> <dd>anywhere</dd>
+    /// <dt>!</dt> <dd>invert; this must appear directly after root or anywhere
+    /// operator</dd>
+    /// </dl>
+    /// <p>
+    /// and path elements:</p>
+    /// <dl>
+    /// <dt>ID</dt> <dd>token name</dd>
+    /// <dt>'string'</dt> <dd>any string literal token from the grammar</dd>
+    /// <dt>expr</dt> <dd>rule name</dd>
+    /// <dt>*</dt> <dd>wildcard matching any node</dd>
+    /// </dl>
+    /// <p>
+    /// Whitespace is not allowed.</p>
+    /// </remarks>
+    public class XPath
+    {
+        public const string Wildcard = "*";
+
+        public const string Not = "!";
+
+        protected internal string path;
+
+        protected internal XPathElement[] elements;
+
+        protected internal Parser parser;
+
+        public XPath(Parser parser, string path)
+        {
+            // word not operator/separator
+            // word for invert operator
+            this.parser = parser;
+            this.path = path;
+            elements = Split(path);
+        }
+
+        //		System.out.println(Arrays.toString(elements));
+        // TODO: check for invalid token/rule names, bad syntax
+        public virtual XPathElement[] Split(string path)
+        {
+            AntlrInputStream @in;
+            try
+            {
+                @in = new AntlrInputStream(new StringReader(path));
+            }
+            catch (IOException ioe)
+            {
+                throw new ArgumentException("Could not read path: " + path, ioe);
+            }
+            XPathLexer lexer = new _XPathLexer_87(@in);
+            lexer.RemoveErrorListeners();
+            lexer.AddErrorListener(new XPathLexerErrorListener());
+            CommonTokenStream tokenStream = new CommonTokenStream(lexer);
+            try
+            {
+                tokenStream.Fill();
+            }
+            catch (LexerNoViableAltException e)
+            {
+                int pos = lexer.Column;
+                string msg = "Invalid tokens or characters at index " + pos + " in path '" + path + "'";
+                throw new ArgumentException(msg, e);
+            }
+            IList<IToken> tokens = tokenStream.GetTokens();
+            //		System.out.println("path="+path+"=>"+tokens);
+            IList<XPathElement> elements = new List<XPathElement>();
+            int n = tokens.Count;
+            int i = 0;
+            while (i < n)
+            {
+                IToken el = tokens[i];
+                IToken next = null;
+                switch (el.Type)
+                {
+                    case XPathLexer.Root:
+                    case XPathLexer.Anywhere:
+                    {
+                        bool anywhere = el.Type == XPathLexer.Anywhere;
+                        i++;
+                        next = tokens[i];
+                        bool invert = next.Type == XPathLexer.Bang;
+                        if (invert)
+                        {
+                            i++;
+                            next = tokens[i];
+                        }
+                        XPathElement pathElement = GetXPathElement(next, anywhere);
+                        pathElement.invert = invert;
+                        elements.Add(pathElement);
+                        i++;
+                        break;
+                    }
+
+                    case XPathLexer.TokenRef:
+                    case XPathLexer.RuleRef:
+                    case XPathLexer.Wildcard:
+                    {
+                        elements.Add(GetXPathElement(el, false));
+                        i++;
+                        break;
+                    }
+
+                    case TokenConstants.Eof:
+                    {
+                        goto loop_break;
+                    }
+
+                    default:
+                    {
+                        throw new ArgumentException("Unknowth path element " + el);
+                    }
+                }
+            }
+loop_break: ;
+            return elements.ToArray();
+        }
+
+        private sealed class _XPathLexer_87 : XPathLexer
+        {
+            public _XPathLexer_87(ICharStream baseArg1)
+                : base(baseArg1)
+            {
+            }
+
+            public override void Recover(LexerNoViableAltException e)
+            {
+                throw e;
+            }
+        }
+
+        /// <summary>
+        /// Convert word like
+        /// <c>*</c>
+        /// or
+        /// <c>ID</c>
+        /// or
+        /// <c>expr</c>
+        /// to a path
+        /// element.
+        /// <paramref name="anywhere"/>
+        /// is
+        /// <see langword="true"/>
+        /// if
+        /// <c>//</c>
+        /// precedes the
+        /// word.
+        /// </summary>
+        protected internal virtual XPathElement GetXPathElement(IToken wordToken, bool anywhere)
+        {
+            if (wordToken.Type == TokenConstants.Eof)
+            {
+                throw new ArgumentException("Missing path element at end of path");
+            }
+            string word = wordToken.Text;
+            int ttype = parser.GetTokenType(word);
+            int ruleIndex = parser.GetRuleIndex(word);
+            switch (wordToken.Type)
+            {
+                case XPathLexer.Wildcard:
+                {
+                    return anywhere ? new XPathWildcardAnywhereElement() : (XPathElement)new XPathWildcardElement();
+                }
+
+                case XPathLexer.TokenRef:
+                case XPathLexer.String:
+                {
+                    if (ttype == TokenConstants.InvalidType)
+                    {
+                        throw new ArgumentException(word + " at index " + wordToken.StartIndex + " isn't a valid token name");
+                    }
+                    return anywhere ? new XPathTokenAnywhereElement(word, ttype) : (XPathElement)new XPathTokenElement(word, ttype);
+                }
+
+                default:
+                {
+                    if (ruleIndex == -1)
+                    {
+                        throw new ArgumentException(word + " at index " + wordToken.StartIndex + " isn't a valid rule name");
+                    }
+                    return anywhere ? new XPathRuleAnywhereElement(word, ruleIndex) : (XPathElement)new XPathRuleElement(word, ruleIndex);
+                }
+            }
+        }
+
+        public static ICollection<IParseTree> FindAll(IParseTree tree, string xpath, Parser parser)
+        {
+            Antlr4.Runtime.Tree.Xpath.XPath p = new Antlr4.Runtime.Tree.Xpath.XPath(parser, xpath);
+            return p.Evaluate(tree);
+        }
+
+        /// <summary>
+        /// Return a list of all nodes starting at
+        /// <paramref name="t"/>
+        /// as root that satisfy the
+        /// path. The root
+        /// <c>/</c>
+        /// is relative to the node passed to
+        /// <see cref="Evaluate(Antlr4.Runtime.Tree.IParseTree)"/>
+        /// .
+        /// </summary>
+        public virtual ICollection<IParseTree> Evaluate(IParseTree t)
+        {
+            ParserRuleContext dummyRoot = new ParserRuleContext();
+            dummyRoot.children = Antlr4.Runtime.Sharpen.Collections.SingletonList(t);
+            // don't set t's parent.
+            ICollection<IParseTree> work = new[] { dummyRoot };
+            int i = 0;
+            while (i < elements.Length)
+            {
+                HashSet<IParseTree> visited = new HashSet<IParseTree>();
+                ICollection<IParseTree> next = new List<IParseTree>();
+                foreach (IParseTree node in work)
+                {
+                    if (node.ChildCount > 0)
+                    {
+                        // only try to match next element if it has children
+                        // e.g., //func/*/stat might have a token node for which
+                        // we can't go looking for stat nodes.
+                        ICollection<IParseTree> matching = elements[i].Evaluate(node);
+                        foreach (IParseTree parseTree in matching)
+                        {
+                            if (visited.Add(parseTree))
+                                next.Add(parseTree);
+                        }
+                    }
+                }
+                i++;
+                work = next;
+            }
+            return work;
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Xpath/XPathElement.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Xpath/XPathElement.cs
new file mode 100644
index 000000000..c1c646894
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Xpath/XPathElement.cs
@@ -0,0 +1,71 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System.Collections.Generic;
+using Antlr4.Runtime.Sharpen;
+using Antlr4.Runtime.Tree;
+
+namespace Antlr4.Runtime.Tree.Xpath
+{
+    public abstract class XPathElement
+    {
+        protected internal string nodeName;
+
+        protected internal bool invert;
+
+        /// <summary>
+        /// Construct element like
+        /// <c>/ID</c>
+        /// or
+        /// <c>ID</c>
+        /// or
+        /// <c>/*</c>
+        /// etc...
+        /// op is null if just node
+        /// </summary>
+        public XPathElement(string nodeName)
+        {
+            this.nodeName = nodeName;
+        }
+
+        /// <summary>
+        /// Given tree rooted at
+        /// <paramref name="t"/>
+        /// return all nodes matched by this path
+        /// element.
+        /// </summary>
+        public abstract ICollection<IParseTree> Evaluate(IParseTree t);
+
+        public override string ToString()
+        {
+            string inv = invert ? "!" : string.Empty;
+            return GetType().Name + "[" + inv + nodeName + "]";
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Xpath/XPathLexer.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Xpath/XPathLexer.cs
new file mode 100644
index 000000000..b7bea17b8
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Xpath/XPathLexer.cs
@@ -0,0 +1,115 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//     ANTLR Version: 4.4.1-dev
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Generated from /Users/ericvergnaud/Development/antlr4/antlr/antlr4-csharp/runtime/CSharp/Antlr4.Runtime/Tree/Xpath/XPathLexer.g4 by ANTLR 4.4.1-dev
+
+// Unreachable code detected
+#pragma warning disable 0162
+// The variable '...' is assigned but its value is never used
+#pragma warning disable 0219
+// Missing XML comment for publicly visible type or member '...'
+#pragma warning disable 1591
+
+
+using System; 
+
+using Antlr4.Runtime;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Misc;
+using DFA = Antlr4.Runtime.Dfa.DFA;
+
+[System.CLSCompliant(false)]
+public partial class XPathLexer : Lexer {
+	public const int
+		TokenRef=1, RuleRef=2, Anywhere=3, Root=4, Wildcard=5, Bang=6, ID=7, String=8;
+	public static string[] modeNames = {
+		"DEFAULT_MODE"
+	};
+
+	public static readonly string[] ruleNames = {
+		"Anywhere", "Root", "Wildcard", "Bang", "ID", "NameChar", "NameStartChar", 
+		"String"
+	};
+
+
+	public XPathLexer(ICharStream input)
+		: base(input)
+	{
+		Interpreter = new LexerATNSimulator(this,_ATN);
+	}
+
+	private static readonly string[] _LiteralNames = {
+		null, null, null, "'//'", "'/'", "'*'", "'!'"
+	};
+	private static readonly string[] _SymbolicNames = {
+		null, "TokenRef", "RuleRef", "Anywhere", "Root", "Wildcard", "Bang", "ID", 
+		"String"
+	};
+	public static readonly IVocabulary DefaultVocabulary = new Vocabulary(_LiteralNames, _SymbolicNames);
+
+	[NotNull]
+	public override IVocabulary Vocabulary
+	{
+		get
+		{
+			return DefaultVocabulary;
+		}
+	}
+
+	public override string GrammarFileName { get { return "XPathLexer.g4"; } }
+
+	public override string[] RuleNames { get { return ruleNames; } }
+
+	public override string[] ModeNames { get { return modeNames; } }
+
+	public override string SerializedAtn { get { return _serializedATN; } }
+
+	public override void Action(RuleContext _localctx, int ruleIndex, int actionIndex) {
+		switch (ruleIndex) {
+		case 4 : ID_action(_localctx, actionIndex); break;
+		}
+	}
+	private void ID_action(RuleContext _localctx, int actionIndex) {
+		switch (actionIndex) {
+		case 0: 
+						String text = Text;
+						if ( Char.IsUpper(text[0]) ) 
+							Type = TokenRef;
+						else 
+							Type = RuleRef;
+						 break;
+		}
+	}
+
+	public static readonly string _serializedATN =
+		"\x3\x430\xD6D1\x8206\xAD2D\x4417\xAEF1\x8D80\xAADD\x2\n\x34\b\x1\x4\x2"+
+		"\t\x2\x4\x3\t\x3\x4\x4\t\x4\x4\x5\t\x5\x4\x6\t\x6\x4\a\t\a\x4\b\t\b\x4"+
+		"\t\t\t\x3\x2\x3\x2\x3\x2\x3\x3\x3\x3\x3\x4\x3\x4\x3\x5\x3\x5\x3\x6\x3"+
+		"\x6\a\x6\x1F\n\x6\f\x6\xE\x6\"\v\x6\x3\x6\x3\x6\x3\a\x3\a\x5\a(\n\a\x3"+
+		"\b\x3\b\x3\t\x3\t\a\t.\n\t\f\t\xE\t\x31\v\t\x3\t\x3\t\x3/\x2\n\x3\x5\x5"+
+		"\x6\a\a\t\b\v\t\r\x2\xF\x2\x11\n\x3\x2\x4\a\x2\x32;\x61\x61\xB9\xB9\x302"+
+		"\x371\x2041\x2042\xF\x2\x43\\\x63|\xC2\xD8\xDA\xF8\xFA\x301\x372\x37F"+
+		"\x381\x2001\x200E\x200F\x2072\x2191\x2C02\x2FF1\x3003\xD801\xF902\xFDD1"+
+		"\xFDF2\xFFFF\x34\x2\x3\x3\x2\x2\x2\x2\x5\x3\x2\x2\x2\x2\a\x3\x2\x2\x2"+
+		"\x2\t\x3\x2\x2\x2\x2\v\x3\x2\x2\x2\x2\x11\x3\x2\x2\x2\x3\x13\x3\x2\x2"+
+		"\x2\x5\x16\x3\x2\x2\x2\a\x18\x3\x2\x2\x2\t\x1A\x3\x2\x2\x2\v\x1C\x3\x2"+
+		"\x2\x2\r\'\x3\x2\x2\x2\xF)\x3\x2\x2\x2\x11+\x3\x2\x2\x2\x13\x14\a\x31"+
+		"\x2\x2\x14\x15\a\x31\x2\x2\x15\x4\x3\x2\x2\x2\x16\x17\a\x31\x2\x2\x17"+
+		"\x6\x3\x2\x2\x2\x18\x19\a,\x2\x2\x19\b\x3\x2\x2\x2\x1A\x1B\a#\x2\x2\x1B"+
+		"\n\x3\x2\x2\x2\x1C \x5\xF\b\x2\x1D\x1F\x5\r\a\x2\x1E\x1D\x3\x2\x2\x2\x1F"+
+		"\"\x3\x2\x2\x2 \x1E\x3\x2\x2\x2 !\x3\x2\x2\x2!#\x3\x2\x2\x2\" \x3\x2\x2"+
+		"\x2#$\b\x6\x2\x2$\f\x3\x2\x2\x2%(\x5\xF\b\x2&(\t\x2\x2\x2\'%\x3\x2\x2"+
+		"\x2\'&\x3\x2\x2\x2(\xE\x3\x2\x2\x2)*\t\x3\x2\x2*\x10\x3\x2\x2\x2+/\a)"+
+		"\x2\x2,.\v\x2\x2\x2-,\x3\x2\x2\x2.\x31\x3\x2\x2\x2/\x30\x3\x2\x2\x2/-"+
+		"\x3\x2\x2\x2\x30\x32\x3\x2\x2\x2\x31/\x3\x2\x2\x2\x32\x33\a)\x2\x2\x33"+
+		"\x12\x3\x2\x2\x2\x6\x2 \'/\x3\x3\x6\x2";
+	public static readonly ATN _ATN =
+		new ATNDeserializer().Deserialize(_serializedATN.ToCharArray());
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Xpath/XPathLexer.g4 b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Xpath/XPathLexer.g4
new file mode 100644
index 000000000..d5cf9991f
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Xpath/XPathLexer.g4
@@ -0,0 +1,69 @@
+lexer grammar XPathLexer;
+
+@header {
+using System; 
+}
+
+tokens { TokenRef, RuleRef }
+
+/*
+path : separator? word (separator word)* EOF ;
+
+separator
+	:	'/'  '!'
+	|	'//' '!'
+	|	'/'
+	|	'//'
+	;
+
+word:	TokenRef
+	|	RuleRef
+	|	String
+	|	'*'
+	;
+*/
+
+Anywhere : '//' ;
+Root	 : '/' ;
+Wildcard : '*' ;
+Bang	 : '!' ;
+
+ID			:	NameStartChar NameChar*
+				{
+				String text = Text;
+				if ( Char.IsUpper(text[0]) ) 
+					Type = TokenRef;
+				else 
+					Type = RuleRef;
+				}
+			;
+
+fragment
+NameChar    :   NameStartChar
+            |   '0'..'9'
+            |   '_'
+            |   '\u00B7'
+            |   '\u0300'..'\u036F'
+            |   '\u203F'..'\u2040'
+            ;
+
+fragment
+NameStartChar
+            :   'A'..'Z' | 'a'..'z'
+            |   '\u00C0'..'\u00D6'
+            |   '\u00D8'..'\u00F6'
+            |   '\u00F8'..'\u02FF'
+            |   '\u0370'..'\u037D'
+            |   '\u037F'..'\u1FFF'
+            |   '\u200C'..'\u200D'
+            |   '\u2070'..'\u218F'
+            |   '\u2C00'..'\u2FEF'
+            |   '\u3001'..'\uD7FF'
+            |   '\uF900'..'\uFDCF'
+            |   '\uFDF0'..'\uFFFD'
+            ; // ignores | ['\u10000-'\uEFFFF] ;
+
+String : '\'' .*? '\'' ;
+
+//Ws : [ \t\r\n]+ -> skip ;
+
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Xpath/XPathLexer.tokens b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Xpath/XPathLexer.tokens
new file mode 100644
index 000000000..7c98df37b
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Xpath/XPathLexer.tokens
@@ -0,0 +1,12 @@
+TokenRef=1
+RuleRef=2
+Anywhere=3
+Root=4
+Wildcard=5
+Bang=6
+ID=7
+String=8
+'//'=3
+'/'=4
+'*'=5
+'!'=6
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Xpath/XPathLexerErrorListener.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Xpath/XPathLexerErrorListener.cs
new file mode 100644
index 000000000..48ad5ca59
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Xpath/XPathLexerErrorListener.cs
@@ -0,0 +1,42 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime;
+using Antlr4.Runtime.Sharpen;
+using Antlr4.Runtime.Tree.Xpath;
+
+namespace Antlr4.Runtime.Tree.Xpath
+{
+    public class XPathLexerErrorListener : IAntlrErrorListener<int>
+    {
+        public virtual void SyntaxError(IRecognizer recognizer, int offendingSymbol, int line, int charPositionInLine, string msg, RecognitionException e)
+        {
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Xpath/XPathRuleAnywhereElement.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Xpath/XPathRuleAnywhereElement.cs
new file mode 100644
index 000000000..2fe44f594
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Xpath/XPathRuleAnywhereElement.cs
@@ -0,0 +1,59 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System.Collections.Generic;
+using Antlr4.Runtime.Sharpen;
+using Antlr4.Runtime.Tree;
+using Antlr4.Runtime.Tree.Xpath;
+
+namespace Antlr4.Runtime.Tree.Xpath
+{
+    /// <summary>
+    /// Either
+    /// <c>ID</c>
+    /// at start of path or
+    /// <c>...//ID</c>
+    /// in middle of path.
+    /// </summary>
+    public class XPathRuleAnywhereElement : XPathElement
+    {
+        protected internal int ruleIndex;
+
+        public XPathRuleAnywhereElement(string ruleName, int ruleIndex)
+            : base(ruleName)
+        {
+            this.ruleIndex = ruleIndex;
+        }
+
+        public override ICollection<IParseTree> Evaluate(IParseTree t)
+        {
+            return Trees.FindAllRuleNodes(t, ruleIndex);
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Xpath/XPathRuleElement.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Xpath/XPathRuleElement.cs
new file mode 100644
index 000000000..32e99050d
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Xpath/XPathRuleElement.cs
@@ -0,0 +1,66 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System.Collections.Generic;
+using Antlr4.Runtime;
+using Antlr4.Runtime.Sharpen;
+using Antlr4.Runtime.Tree;
+using Antlr4.Runtime.Tree.Xpath;
+
+namespace Antlr4.Runtime.Tree.Xpath
+{
+    public class XPathRuleElement : XPathElement
+    {
+        protected internal int ruleIndex;
+
+        public XPathRuleElement(string ruleName, int ruleIndex)
+            : base(ruleName)
+        {
+            this.ruleIndex = ruleIndex;
+        }
+
+        public override ICollection<IParseTree> Evaluate(IParseTree t)
+        {
+            // return all children of t that match nodeName
+            IList<IParseTree> nodes = new List<IParseTree>();
+            foreach (ITree c in Trees.GetChildren(t))
+            {
+                if (c is ParserRuleContext)
+                {
+                    ParserRuleContext ctx = (ParserRuleContext)c;
+                    if ((ctx.RuleIndex == ruleIndex && !invert) || (ctx.RuleIndex != ruleIndex && invert))
+                    {
+                        nodes.Add(ctx);
+                    }
+                }
+            }
+            return nodes;
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Xpath/XPathTokenAnywhereElement.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Xpath/XPathTokenAnywhereElement.cs
new file mode 100644
index 000000000..bda8b4878
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Xpath/XPathTokenAnywhereElement.cs
@@ -0,0 +1,52 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System.Collections.Generic;
+using Antlr4.Runtime.Sharpen;
+using Antlr4.Runtime.Tree;
+using Antlr4.Runtime.Tree.Xpath;
+
+namespace Antlr4.Runtime.Tree.Xpath
+{
+    public class XPathTokenAnywhereElement : XPathElement
+    {
+        protected internal int tokenType;
+
+        public XPathTokenAnywhereElement(string tokenName, int tokenType)
+            : base(tokenName)
+        {
+            this.tokenType = tokenType;
+        }
+
+        public override ICollection<IParseTree> Evaluate(IParseTree t)
+        {
+            return Trees.FindAllTokenNodes(t, tokenType);
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Xpath/XPathTokenElement.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Xpath/XPathTokenElement.cs
new file mode 100644
index 000000000..7f573a2e3
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Xpath/XPathTokenElement.cs
@@ -0,0 +1,65 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System.Collections.Generic;
+using Antlr4.Runtime.Sharpen;
+using Antlr4.Runtime.Tree;
+using Antlr4.Runtime.Tree.Xpath;
+
+namespace Antlr4.Runtime.Tree.Xpath
+{
+    public class XPathTokenElement : XPathElement
+    {
+        protected internal int tokenType;
+
+        public XPathTokenElement(string tokenName, int tokenType)
+            : base(tokenName)
+        {
+            this.tokenType = tokenType;
+        }
+
+        public override ICollection<IParseTree> Evaluate(IParseTree t)
+        {
+            // return all children of t that match nodeName
+            IList<IParseTree> nodes = new List<IParseTree>();
+            foreach (ITree c in Trees.GetChildren(t))
+            {
+                if (c is ITerminalNode)
+                {
+                    ITerminalNode tnode = (ITerminalNode)c;
+                    if ((tnode.Symbol.Type == tokenType && !invert) || (tnode.Symbol.Type != tokenType && invert))
+                    {
+                        nodes.Add(tnode);
+                    }
+                }
+            }
+            return nodes;
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Xpath/XPathWildcardAnywhereElement.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Xpath/XPathWildcardAnywhereElement.cs
new file mode 100644
index 000000000..262dc1485
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Xpath/XPathWildcardAnywhereElement.cs
@@ -0,0 +1,54 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System.Collections.Generic;
+using Antlr4.Runtime.Sharpen;
+using Antlr4.Runtime.Tree;
+using Antlr4.Runtime.Tree.Xpath;
+
+namespace Antlr4.Runtime.Tree.Xpath
+{
+    public class XPathWildcardAnywhereElement : XPathElement
+    {
+        public XPathWildcardAnywhereElement()
+            : base(XPath.Wildcard)
+        {
+        }
+
+        public override ICollection<IParseTree> Evaluate(IParseTree t)
+        {
+            if (invert)
+            {
+                return new List<IParseTree>();
+            }
+            // !* is weird but valid (empty)
+            return Trees.Descendants(t);
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Xpath/XPathWildcardElement.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Xpath/XPathWildcardElement.cs
new file mode 100644
index 000000000..7046c11b8
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Tree/Xpath/XPathWildcardElement.cs
@@ -0,0 +1,59 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System.Collections.Generic;
+using Antlr4.Runtime.Sharpen;
+using Antlr4.Runtime.Tree;
+using Antlr4.Runtime.Tree.Xpath;
+
+namespace Antlr4.Runtime.Tree.Xpath
+{
+    public class XPathWildcardElement : XPathElement
+    {
+        public XPathWildcardElement()
+            : base(XPath.Wildcard)
+        {
+        }
+
+        public override ICollection<IParseTree> Evaluate(IParseTree t)
+        {
+            if (invert)
+            {
+                return new List<IParseTree>();
+            }
+            // !* is weird but valid (empty)
+            IList<IParseTree> kids = new List<IParseTree>();
+            foreach (ITree c in Trees.GetChildren(t))
+            {
+                kids.Add((IParseTree)c);
+            }
+            return kids;
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/UnbufferedCharStream.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/UnbufferedCharStream.cs
new file mode 100644
index 000000000..f2901059f
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/UnbufferedCharStream.cs
@@ -0,0 +1,447 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System;
+using System.IO;
+using Antlr4.Runtime;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime
+{
+    /// <summary>Do not buffer up the entire char stream.</summary>
+    /// <remarks>
+    /// Do not buffer up the entire char stream. It does keep a small buffer
+    /// for efficiency and also buffers while a mark exists (set by the
+    /// lookahead prediction in parser). "Unbuffered" here refers to fact
+    /// that it doesn't buffer all data, not that's it's on demand loading of char.
+    /// </remarks>
+    public class UnbufferedCharStream : ICharStream
+    {
+        /// <summary>A moving window buffer of the data being scanned.</summary>
+        /// <remarks>
+        /// A moving window buffer of the data being scanned. While there's a marker,
+        /// we keep adding to buffer. Otherwise,
+        /// <see cref="Consume()">consume()</see>
+        /// resets so
+        /// we start filling at index 0 again.
+        /// </remarks>
+        protected internal char[] data;
+
+        /// <summary>
+        /// The number of characters currently in
+        /// <see cref="data">data</see>
+        /// .
+        /// <p>This is not the buffer capacity, that's
+        /// <c>data.length</c>
+        /// .</p>
+        /// </summary>
+        protected internal int n;
+
+        /// <summary>
+        /// 0..n-1 index into
+        /// <see cref="data">data</see>
+        /// of next character.
+        /// <p>The
+        /// <c>LA(1)</c>
+        /// character is
+        /// <c>data[p]</c>
+        /// . If
+        /// <c>p == n</c>
+        /// , we are
+        /// out of buffered characters.</p>
+        /// </summary>
+        protected internal int p = 0;
+
+        /// <summary>
+        /// Count up with
+        /// <see cref="Mark()">mark()</see>
+        /// and down with
+        /// <see cref="Release(int)">release()</see>
+        /// . When we
+        /// <c>release()</c>
+        /// the last mark,
+        /// <c>numMarkers</c>
+        /// reaches 0 and we reset the buffer. Copy
+        /// <c>data[p]..data[n-1]</c>
+        /// to
+        /// <c>data[0]..data[(n-1)-p]</c>
+        /// .
+        /// </summary>
+        protected internal int numMarkers = 0;
+
+        /// <summary>
+        /// This is the
+        /// <c>LA(-1)</c>
+        /// character for the current position.
+        /// </summary>
+        protected internal int lastChar = -1;
+
+        /// <summary>
+        /// When
+        /// <c>numMarkers &gt; 0</c>
+        /// , this is the
+        /// <c>LA(-1)</c>
+        /// character for the
+        /// first character in
+        /// <see cref="data">data</see>
+        /// . Otherwise, this is unspecified.
+        /// </summary>
+        protected internal int lastCharBufferStart;
+
+        /// <summary>Absolute character index.</summary>
+        /// <remarks>
+        /// Absolute character index. It's the index of the character about to be
+        /// read via
+        /// <c>LA(1)</c>
+        /// . Goes from 0 to the number of characters in the
+        /// entire stream, although the stream size is unknown before the end is
+        /// reached.
+        /// </remarks>
+        protected internal int currentCharIndex = 0;
+
+        protected internal TextReader input;
+
+        /// <summary>The name or source of this char stream.</summary>
+        /// <remarks>The name or source of this char stream.</remarks>
+        public string name;
+
+        /// <summary>Useful for subclasses that pull char from other than this.input.</summary>
+        /// <remarks>Useful for subclasses that pull char from other than this.input.</remarks>
+        public UnbufferedCharStream()
+            : this(256)
+        {
+        }
+
+        /// <summary>Useful for subclasses that pull char from other than this.input.</summary>
+        /// <remarks>Useful for subclasses that pull char from other than this.input.</remarks>
+        public UnbufferedCharStream(int bufferSize)
+        {
+            n = 0;
+            data = new char[bufferSize];
+        }
+
+        public UnbufferedCharStream(Stream input)
+            : this(input, 256)
+        {
+        }
+
+        public UnbufferedCharStream(TextReader input)
+            : this(input, 256)
+        {
+        }
+
+        public UnbufferedCharStream(Stream input, int bufferSize)
+            : this(bufferSize)
+        {
+            this.input = new StreamReader(input);
+            Fill(1);
+        }
+
+        public UnbufferedCharStream(TextReader input, int bufferSize)
+            : this(bufferSize)
+        {
+            // prime
+            this.input = input;
+            Fill(1);
+        }
+
+        // prime
+        public virtual void Consume()
+        {
+            if (La(1) == IntStreamConstants.Eof)
+            {
+                throw new InvalidOperationException("cannot consume EOF");
+            }
+            // buf always has at least data[p==0] in this method due to ctor
+            lastChar = data[p];
+            // track last char for LA(-1)
+            if (p == n - 1 && numMarkers == 0)
+            {
+                n = 0;
+                p = -1;
+                // p++ will leave this at 0
+                lastCharBufferStart = lastChar;
+            }
+            p++;
+            currentCharIndex++;
+            Sync(1);
+        }
+
+        /// <summary>
+        /// Make sure we have 'need' elements from current position
+        /// <see cref="p">p</see>
+        /// .
+        /// Last valid
+        /// <c>p</c>
+        /// index is
+        /// <c>data.length-1</c>
+        /// .
+        /// <c>p+need-1</c>
+        /// is
+        /// the char index 'need' elements ahead. If we need 1 element,
+        /// <c>(p+1-1)==p</c>
+        /// must be less than
+        /// <c>data.length</c>
+        /// .
+        /// </summary>
+        protected internal virtual void Sync(int want)
+        {
+            int need = (p + want - 1) - n + 1;
+            // how many more elements we need?
+            if (need > 0)
+            {
+                Fill(need);
+            }
+        }
+
+        /// <summary>
+        /// Add
+        /// <paramref name="n"/>
+        /// characters to the buffer. Returns the number of characters
+        /// actually added to the buffer. If the return value is less than
+        /// <paramref name="n"/>
+        /// ,
+        /// then EOF was reached before
+        /// <paramref name="n"/>
+        /// characters could be added.
+        /// </summary>
+        protected internal virtual int Fill(int n)
+        {
+            for (int i = 0; i < n; i++)
+            {
+                if (this.n > 0 && data[this.n - 1] == unchecked((char)IntStreamConstants.Eof))
+                {
+                    return i;
+                }
+
+                int c = NextChar();
+                Add(c);
+            }
+            return n;
+        }
+
+        /// <summary>
+        /// Override to provide different source of characters than
+        /// <see cref="input">input</see>
+        /// .
+        /// </summary>
+        /// <exception cref="System.IO.IOException"/>
+        protected internal virtual int NextChar()
+        {
+            return input.Read();
+        }
+
+        protected internal virtual void Add(int c)
+        {
+            if (n >= data.Length)
+            {
+                data = Arrays.CopyOf(data, data.Length * 2);
+            }
+            data[n++] = (char)c;
+        }
+
+        public virtual int La(int i)
+        {
+            if (i == -1)
+            {
+                return lastChar;
+            }
+            // special case
+            Sync(i);
+            int index = p + i - 1;
+            if (index < 0)
+            {
+                throw new ArgumentOutOfRangeException();
+            }
+            if (index >= n)
+            {
+                return IntStreamConstants.Eof;
+            }
+            char c = data[index];
+            if (c == unchecked((char)IntStreamConstants.Eof))
+            {
+                return IntStreamConstants.Eof;
+            }
+            return c;
+        }
+
+        /// <summary>Return a marker that we can release later.</summary>
+        /// <remarks>
+        /// Return a marker that we can release later.
+        /// <p>The specific marker value used for this class allows for some level of
+        /// protection against misuse where
+        /// <c>seek()</c>
+        /// is called on a mark or
+        /// <c>release()</c>
+        /// is called in the wrong order.</p>
+        /// </remarks>
+        public virtual int Mark()
+        {
+            if (numMarkers == 0)
+            {
+                lastCharBufferStart = lastChar;
+            }
+            int mark = -numMarkers - 1;
+            numMarkers++;
+            return mark;
+        }
+
+        /// <summary>Decrement number of markers, resetting buffer if we hit 0.</summary>
+        /// <remarks>Decrement number of markers, resetting buffer if we hit 0.</remarks>
+        /// <param name="marker"/>
+        public virtual void Release(int marker)
+        {
+            int expectedMark = -numMarkers;
+            if (marker != expectedMark)
+            {
+                throw new InvalidOperationException("release() called with an invalid marker.");
+            }
+            numMarkers--;
+            if (numMarkers == 0 && p > 0)
+            {
+                // release buffer when we can, but don't do unnecessary work
+                // Copy data[p]..data[n-1] to data[0]..data[(n-1)-p], reset ptrs
+                // p is last valid char; move nothing if p==n as we have no valid char
+                System.Array.Copy(data, p, data, 0, n - p);
+                // shift n-p char from p to 0
+                n = n - p;
+                p = 0;
+                lastCharBufferStart = lastChar;
+            }
+        }
+
+        public virtual int Index
+        {
+            get
+            {
+                return currentCharIndex;
+            }
+        }
+
+        /// <summary>
+        /// Seek to absolute character index, which might not be in the current
+        /// sliding window.
+        /// </summary>
+        /// <remarks>
+        /// Seek to absolute character index, which might not be in the current
+        /// sliding window.  Move
+        /// <c>p</c>
+        /// to
+        /// <c>index-bufferStartIndex</c>
+        /// .
+        /// </remarks>
+        public virtual void Seek(int index)
+        {
+            if (index == currentCharIndex)
+            {
+                return;
+            }
+            if (index > currentCharIndex)
+            {
+                Sync(index - currentCharIndex);
+                index = Math.Min(index, BufferStartIndex + n - 1);
+            }
+            // index == to bufferStartIndex should set p to 0
+            int i = index - BufferStartIndex;
+            if (i < 0)
+            {
+                throw new ArgumentException("cannot seek to negative index " + index);
+            }
+            else
+            {
+                if (i >= n)
+                {
+                    throw new NotSupportedException("seek to index outside buffer: " + index + " not in " + BufferStartIndex + ".." + (BufferStartIndex + n));
+                }
+            }
+            p = i;
+            currentCharIndex = index;
+            if (p == 0)
+            {
+                lastChar = lastCharBufferStart;
+            }
+            else
+            {
+                lastChar = data[p - 1];
+            }
+        }
+
+        public virtual int Size
+        {
+            get
+            {
+                throw new NotSupportedException("Unbuffered stream cannot know its size");
+            }
+        }
+
+        public virtual string SourceName
+        {
+            get
+            {
+                if (string.IsNullOrEmpty(name))
+                {
+                    return IntStreamConstants.UnknownSourceName;
+                }
+                return name;
+            }
+        }
+
+        public virtual string GetText(Interval interval)
+        {
+            if (interval.a < 0 || interval.b < interval.a - 1)
+            {
+                throw new ArgumentException("invalid interval");
+            }
+            int bufferStartIndex = BufferStartIndex;
+            if (n > 0 && data[n - 1] == char.MaxValue)
+            {
+                if (interval.a + interval.Length > bufferStartIndex + n)
+                {
+                    throw new ArgumentException("the interval extends past the end of the stream");
+                }
+            }
+            if (interval.a < bufferStartIndex || interval.b >= bufferStartIndex + n)
+            {
+                throw new NotSupportedException("interval " + interval + " outside buffer: " + bufferStartIndex + ".." + (bufferStartIndex + n - 1));
+            }
+            // convert from absolute to local index
+            int i = interval.a - bufferStartIndex;
+            return new string(data, i, interval.Length);
+        }
+
+        protected internal int BufferStartIndex
+        {
+            get
+            {
+                return currentCharIndex - p;
+            }
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/UnbufferedTokenStream.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/UnbufferedTokenStream.cs
new file mode 100644
index 000000000..b6d0c73f0
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/UnbufferedTokenStream.cs
@@ -0,0 +1,430 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using System;
+using System.Text;
+using Antlr4.Runtime;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime
+{
+    public class UnbufferedTokenStream : ITokenStream
+    {
+        private ITokenSource _tokenSource;
+
+        /// <summary>A moving window buffer of the data being scanned.</summary>
+        /// <remarks>
+        /// A moving window buffer of the data being scanned. While there's a marker,
+        /// we keep adding to buffer. Otherwise,
+        /// <see cref="Consume()">consume()</see>
+        /// resets so
+        /// we start filling at index 0 again.
+        /// </remarks>
+        protected internal IToken[] tokens;
+
+        /// <summary>
+        /// The number of tokens currently in
+        /// <see cref="tokens">tokens</see>
+        /// .
+        /// <p>This is not the buffer capacity, that's
+        /// <c>tokens.length</c>
+        /// .</p>
+        /// </summary>
+        protected internal int n;
+
+        /// <summary>
+        /// 0..n-1 index into
+        /// <see cref="tokens">tokens</see>
+        /// of next token.
+        /// <p>The
+        /// <c>LT(1)</c>
+        /// token is
+        /// <c>tokens[p]</c>
+        /// . If
+        /// <c>p == n</c>
+        /// , we are
+        /// out of buffered tokens.</p>
+        /// </summary>
+        protected internal int p = 0;
+
+        /// <summary>
+        /// Count up with
+        /// <see cref="Mark()">mark()</see>
+        /// and down with
+        /// <see cref="Release(int)">release()</see>
+        /// . When we
+        /// <c>release()</c>
+        /// the last mark,
+        /// <c>numMarkers</c>
+        /// reaches 0 and we reset the buffer. Copy
+        /// <c>tokens[p]..tokens[n-1]</c>
+        /// to
+        /// <c>tokens[0]..tokens[(n-1)-p]</c>
+        /// .
+        /// </summary>
+        protected internal int numMarkers = 0;
+
+        /// <summary>
+        /// This is the
+        /// <c>LT(-1)</c>
+        /// token for the current position.
+        /// </summary>
+        protected internal IToken lastToken;
+
+        /// <summary>
+        /// When
+        /// <c>numMarkers &gt; 0</c>
+        /// , this is the
+        /// <c>LT(-1)</c>
+        /// token for the
+        /// first token in
+        /// <see cref="tokens"/>
+        /// . Otherwise, this is
+        /// <see langword="null"/>
+        /// .
+        /// </summary>
+        protected internal IToken lastTokenBufferStart;
+
+        /// <summary>Absolute token index.</summary>
+        /// <remarks>
+        /// Absolute token index. It's the index of the token about to be read via
+        /// <c>LT(1)</c>
+        /// . Goes from 0 to the number of tokens in the entire stream,
+        /// although the stream size is unknown before the end is reached.
+        /// <p>This value is used to set the token indexes if the stream provides tokens
+        /// that implement
+        /// <see cref="IWritableToken"/>
+        /// .</p>
+        /// </remarks>
+        protected internal int currentTokenIndex = 0;
+
+        public UnbufferedTokenStream(ITokenSource tokenSource)
+            : this(tokenSource, 256)
+        {
+        }
+
+        public UnbufferedTokenStream(ITokenSource tokenSource, int bufferSize)
+        {
+            this.TokenSource = tokenSource;
+            this.tokens = new IToken[bufferSize];
+            n = 0;
+            Fill(1);
+        }
+
+        // prime the pump
+        public virtual IToken Get(int i)
+        {
+            int bufferStartIndex = GetBufferStartIndex();
+            if (i < bufferStartIndex || i >= bufferStartIndex + n)
+            {
+                throw new ArgumentOutOfRangeException("get(" + i + ") outside buffer: " + bufferStartIndex + ".." + (bufferStartIndex + n));
+            }
+            return tokens[i - bufferStartIndex];
+        }
+
+        public virtual IToken Lt(int i)
+        {
+            if (i == -1)
+            {
+                return lastToken;
+            }
+            Sync(i);
+            int index = p + i - 1;
+            if (index < 0)
+            {
+                throw new ArgumentOutOfRangeException("LT(" + i + ") gives negative index");
+            }
+            if (index >= n)
+            {
+                System.Diagnostics.Debug.Assert(n > 0 && tokens[n - 1].Type == TokenConstants.Eof);
+                return tokens[n - 1];
+            }
+            return tokens[index];
+        }
+
+        public virtual int La(int i)
+        {
+            return Lt(i).Type;
+        }
+
+        public virtual ITokenSource TokenSource
+        {
+            get
+            {
+                return _tokenSource;
+            }
+			set 
+			{
+				_tokenSource = value;
+			}
+        }
+
+        [return: NotNull]
+        public virtual string GetText()
+        {
+            return string.Empty;
+        }
+
+        [return: NotNull]
+        public virtual string GetText(RuleContext ctx)
+        {
+            return GetText(ctx.SourceInterval);
+        }
+
+        [return: NotNull]
+        public virtual string GetText(IToken start, IToken stop)
+        {
+            if (start != null && stop != null)
+            {
+                return GetText(Interval.Of(start.TokenIndex, stop.TokenIndex));
+            }
+            throw new NotSupportedException("The specified start and stop symbols are not supported.");
+        }
+
+        public virtual void Consume()
+        {
+            if (La(1) == TokenConstants.Eof)
+            {
+                throw new InvalidOperationException("cannot consume EOF");
+            }
+            // buf always has at least tokens[p==0] in this method due to ctor
+            lastToken = tokens[p];
+            // track last token for LT(-1)
+            // if we're at last token and no markers, opportunity to flush buffer
+            if (p == n - 1 && numMarkers == 0)
+            {
+                n = 0;
+                p = -1;
+                // p++ will leave this at 0
+                lastTokenBufferStart = lastToken;
+            }
+            p++;
+            currentTokenIndex++;
+            Sync(1);
+        }
+
+        /// <summary>
+        /// Make sure we have 'need' elements from current position
+        /// <see cref="p">p</see>
+        /// . Last valid
+        /// <c>p</c>
+        /// index is
+        /// <c>tokens.length-1</c>
+        /// .
+        /// <c>p+need-1</c>
+        /// is the tokens index 'need' elements
+        /// ahead.  If we need 1 element,
+        /// <c>(p+1-1)==p</c>
+        /// must be less than
+        /// <c>tokens.length</c>
+        /// .
+        /// </summary>
+        protected internal virtual void Sync(int want)
+        {
+            int need = (p + want - 1) - n + 1;
+            // how many more elements we need?
+            if (need > 0)
+            {
+                Fill(need);
+            }
+        }
+
+        /// <summary>
+        /// Add
+        /// <paramref name="n"/>
+        /// elements to the buffer. Returns the number of tokens
+        /// actually added to the buffer. If the return value is less than
+        /// <paramref name="n"/>
+        /// ,
+        /// then EOF was reached before
+        /// <paramref name="n"/>
+        /// tokens could be added.
+        /// </summary>
+        protected internal virtual int Fill(int n)
+        {
+            for (int i = 0; i < n; i++)
+            {
+                if (this.n > 0 && tokens[this.n - 1].Type == TokenConstants.Eof)
+                {
+                    return i;
+                }
+                IToken t = TokenSource.NextToken();
+                Add(t);
+            }
+            return n;
+        }
+
+        protected internal virtual void Add(IToken t)
+        {
+            if (n >= tokens.Length)
+            {
+                tokens = Arrays.CopyOf(tokens, tokens.Length * 2);
+            }
+            if (t is IWritableToken)
+            {
+                ((IWritableToken)t).TokenIndex = GetBufferStartIndex() + n;
+            }
+            tokens[n++] = t;
+        }
+
+        /// <summary>Return a marker that we can release later.</summary>
+        /// <remarks>
+        /// Return a marker that we can release later.
+        /// <p>The specific marker value used for this class allows for some level of
+        /// protection against misuse where
+        /// <c>seek()</c>
+        /// is called on a mark or
+        /// <c>release()</c>
+        /// is called in the wrong order.</p>
+        /// </remarks>
+        public virtual int Mark()
+        {
+            if (numMarkers == 0)
+            {
+                lastTokenBufferStart = lastToken;
+            }
+            int mark = -numMarkers - 1;
+            numMarkers++;
+            return mark;
+        }
+
+        public virtual void Release(int marker)
+        {
+            int expectedMark = -numMarkers;
+            if (marker != expectedMark)
+            {
+                throw new InvalidOperationException("release() called with an invalid marker.");
+            }
+            numMarkers--;
+            if (numMarkers == 0)
+            {
+                // can we release buffer?
+                if (p > 0)
+                {
+                    // Copy tokens[p]..tokens[n-1] to tokens[0]..tokens[(n-1)-p], reset ptrs
+                    // p is last valid token; move nothing if p==n as we have no valid char
+                    System.Array.Copy(tokens, p, tokens, 0, n - p);
+                    // shift n-p tokens from p to 0
+                    n = n - p;
+                    p = 0;
+                }
+                lastTokenBufferStart = lastToken;
+            }
+        }
+
+        public virtual int Index
+        {
+            get
+            {
+                return currentTokenIndex;
+            }
+        }
+
+        public virtual void Seek(int index)
+        {
+            // seek to absolute index
+            if (index == currentTokenIndex)
+            {
+                return;
+            }
+            if (index > currentTokenIndex)
+            {
+                Sync(index - currentTokenIndex);
+                index = Math.Min(index, GetBufferStartIndex() + n - 1);
+            }
+            int bufferStartIndex = GetBufferStartIndex();
+            int i = index - bufferStartIndex;
+            if (i < 0)
+            {
+                throw new ArgumentException("cannot seek to negative index " + index);
+            }
+            else
+            {
+                if (i >= n)
+                {
+                    throw new NotSupportedException("seek to index outside buffer: " + index + " not in " + bufferStartIndex + ".." + (bufferStartIndex + n));
+                }
+            }
+            p = i;
+            currentTokenIndex = index;
+            if (p == 0)
+            {
+                lastToken = lastTokenBufferStart;
+            }
+            else
+            {
+                lastToken = tokens[p - 1];
+            }
+        }
+
+        public virtual int Size
+        {
+            get
+            {
+                throw new NotSupportedException("Unbuffered stream cannot know its size");
+            }
+        }
+
+        public virtual string SourceName
+        {
+            get
+            {
+                return TokenSource.SourceName;
+            }
+        }
+
+        [return: NotNull]
+        public virtual string GetText(Interval interval)
+        {
+            int bufferStartIndex = GetBufferStartIndex();
+            int bufferStopIndex = bufferStartIndex + tokens.Length - 1;
+            int start = interval.a;
+            int stop = interval.b;
+            if (start < bufferStartIndex || stop > bufferStopIndex)
+            {
+                throw new NotSupportedException("interval " + interval + " not in token buffer window: " + bufferStartIndex + ".." + bufferStopIndex);
+            }
+            int a = start - bufferStartIndex;
+            int b = stop - bufferStartIndex;
+            StringBuilder buf = new StringBuilder();
+            for (int i = a; i <= b; i++)
+            {
+                IToken t = tokens[i];
+                buf.Append(t.Text);
+            }
+            return buf.ToString();
+        }
+
+        protected internal int GetBufferStartIndex()
+        {
+            return currentTokenIndex - p;
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Vocabulary.cs b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Vocabulary.cs
new file mode 100644
index 000000000..0f7b8057e
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.Runtime/Vocabulary.cs
@@ -0,0 +1,194 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+using Antlr4.Runtime;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Sharpen;
+
+namespace Antlr4.Runtime
+{
+    /// <summary>
+    /// This class provides a default implementation of the
+    /// <see cref="IVocabulary"/>
+    /// interface.
+    /// </summary>
+    /// <author>Sam Harwell</author>
+    public class Vocabulary : IVocabulary
+    {
+        private static readonly string[] EmptyNames = new string[0];
+
+        /// <summary>
+        /// Gets an empty
+        /// <see cref="IVocabulary"/>
+        /// instance.
+        /// <p>
+        /// No literal or symbol names are assigned to token types, so
+        /// <see cref="GetDisplayName(int)"/>
+        /// returns the numeric value for all tokens
+        /// except
+        /// <see cref="TokenConstants.Eof"/>
+        /// .</p>
+        /// </summary>
+        [NotNull]
+        public static readonly Vocabulary EmptyVocabulary = new Vocabulary(EmptyNames, EmptyNames, EmptyNames);
+
+        [NotNull]
+        private readonly string[] literalNames;
+
+        [NotNull]
+        private readonly string[] symbolicNames;
+
+        [NotNull]
+        private readonly string[] displayNames;
+
+        private readonly int maxTokenType;
+
+        /// <summary>
+        /// Constructs a new instance of
+        /// <see cref="Vocabulary"/>
+        /// from the specified
+        /// literal and symbolic token names.
+        /// </summary>
+        /// <param name="literalNames">
+        /// The literal names assigned to tokens, or
+        /// <see langword="null"/>
+        /// if no literal names are assigned.
+        /// </param>
+        /// <param name="symbolicNames">
+        /// The symbolic names assigned to tokens, or
+        /// <see langword="null"/>
+        /// if no symbolic names are assigned.
+        /// </param>
+        /// <seealso cref="GetLiteralName(int)"/>
+        /// <seealso cref="GetSymbolicName(int)"/>
+        public Vocabulary(string[] literalNames, string[] symbolicNames)
+            : this(literalNames, symbolicNames, null)
+        {
+        }
+
+        /// <summary>
+        /// Constructs a new instance of
+        /// <see cref="Vocabulary"/>
+        /// from the specified
+        /// literal, symbolic, and display token names.
+        /// </summary>
+        /// <param name="literalNames">
+        /// The literal names assigned to tokens, or
+        /// <see langword="null"/>
+        /// if no literal names are assigned.
+        /// </param>
+        /// <param name="symbolicNames">
+        /// The symbolic names assigned to tokens, or
+        /// <see langword="null"/>
+        /// if no symbolic names are assigned.
+        /// </param>
+        /// <param name="displayNames">
+        /// The display names assigned to tokens, or
+        /// <see langword="null"/>
+        /// to use the values in
+        /// <paramref name="literalNames"/>
+        /// and
+        /// <paramref name="symbolicNames"/>
+        /// as
+        /// the source of display names, as described in
+        /// <see cref="GetDisplayName(int)"/>
+        /// .
+        /// </param>
+        /// <seealso cref="GetLiteralName(int)"/>
+        /// <seealso cref="GetSymbolicName(int)"/>
+        /// <seealso cref="GetDisplayName(int)"/>
+        public Vocabulary(string[] literalNames, string[] symbolicNames, string[] displayNames)
+        {
+            this.literalNames = literalNames != null ? literalNames : EmptyNames;
+            this.symbolicNames = symbolicNames != null ? symbolicNames : EmptyNames;
+            this.displayNames = displayNames != null ? displayNames : EmptyNames;
+			this.maxTokenType =
+				System.Math.Max(this.displayNames.Length,
+						 System.Math.Max(this.literalNames.Length, this.symbolicNames.Length)) - 1;
+
+        }
+
+		/// <summary>
+		/// Returns the highest token type value. It can be used to iterate from
+		/// zero to that number, inclusively, thus querying all stored entries.
+		/// </summary>
+        public virtual int getMaxTokenType()
+        {
+        	return maxTokenType;
+        }
+
+        [return: Nullable]
+        public virtual string GetLiteralName(int tokenType)
+        {
+            if (tokenType >= 0 && tokenType < literalNames.Length)
+            {
+                return literalNames[tokenType];
+            }
+            return null;
+        }
+
+        [return: Nullable]
+        public virtual string GetSymbolicName(int tokenType)
+        {
+            if (tokenType >= 0 && tokenType < symbolicNames.Length)
+            {
+                return symbolicNames[tokenType];
+            }
+            if (tokenType == TokenConstants.Eof)
+            {
+                return "EOF";
+            }
+            return null;
+        }
+
+        [return: NotNull]
+        public virtual string GetDisplayName(int tokenType)
+        {
+            if (tokenType >= 0 && tokenType < displayNames.Length)
+            {
+                string displayName = displayNames[tokenType];
+                if (displayName != null)
+                {
+                    return displayName;
+                }
+            }
+            string literalName = GetLiteralName(tokenType);
+            if (literalName != null)
+            {
+                return literalName;
+            }
+            string symbolicName = GetSymbolicName(tokenType);
+            if (symbolicName != null)
+            {
+                return symbolicName;
+            }
+            return tokenType.ToString();
+        }
+    }
+}
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.mono.sln b/runtime/CSharp/runtime/CSharp/Antlr4.mono.sln
new file mode 100644
index 000000000..535f9d1ac
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.mono.sln
@@ -0,0 +1,45 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2012
+VisualStudioVersion = 12.0.30110.0
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{47C0086D-577C-43DA-ADC7-544F27656E45}"
+	ProjectSection(SolutionItems) = preProject
+		..\..\tool\resources\org\antlr\v4\tool\templates\codegen\CSharp\CSharp.stg = ..\..\tool\resources\org\antlr\v4\tool\templates\codegen\CSharp\CSharp.stg
+		..\..\tool\src\org\antlr\v4\codegen\CSharpTarget.java = ..\..\tool\src\org\antlr\v4\codegen\CSharpTarget.java
+		..\..\Readme.md = ..\..\Readme.md
+	EndProjectSection
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "build", "build", "{4CE79A54-058D-4940-875E-7F6AA9922A7D}"
+	ProjectSection(SolutionItems) = preProject
+		..\..\build\Antlr4.nuspec = ..\..\build\Antlr4.nuspec
+		..\..\build\Antlr4.Runtime.nuspec = ..\..\build\Antlr4.Runtime.nuspec
+		..\..\build\Antlr4.VS2008.nuspec = ..\..\build\Antlr4.VS2008.nuspec
+		..\..\build\build.ps1 = ..\..\build\build.ps1
+		..\..\build\check-key.ps1 = ..\..\build\check-key.ps1
+		build\KeyReporting.targets = build\KeyReporting.targets
+		..\..\build\keys.ps1 = ..\..\build\keys.ps1
+		..\..\build\push.ps1 = ..\..\build\push.ps1
+		..\..\build\version.ps1 = ..\..\build\version.ps1
+	EndProjectSection
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Antlr4.Runtime.mono", "Antlr4.Runtime\Antlr4.Runtime.mono.csproj", "{E1A46D9D-66CB-46E8-93B0-7FC87299ABEF}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{E1A46D9D-66CB-46E8-93B0-7FC87299ABEF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{E1A46D9D-66CB-46E8-93B0-7FC87299ABEF}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{E1A46D9D-66CB-46E8-93B0-7FC87299ABEF}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{E1A46D9D-66CB-46E8-93B0-7FC87299ABEF}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(NestedProjects) = preSolution
+		{4CE79A54-058D-4940-875E-7F6AA9922A7D} = {47C0086D-577C-43DA-ADC7-544F27656E45}
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal
diff --git a/runtime/CSharp/runtime/CSharp/Antlr4.vs2013.sln b/runtime/CSharp/runtime/CSharp/Antlr4.vs2013.sln
new file mode 100644
index 000000000..760ea02bd
--- /dev/null
+++ b/runtime/CSharp/runtime/CSharp/Antlr4.vs2013.sln
@@ -0,0 +1,24 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2013
+VisualStudioVersion = 12.0.31101.0
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{47C0086D-577C-43DA-ADC7-544F27656E45}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Antlr4.Runtime.vs2013", "Antlr4.Runtime\Antlr4.Runtime.vs2013.csproj", "{E1A46D9D-66CB-46E8-93B0-7FC87299ABEF}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{E1A46D9D-66CB-46E8-93B0-7FC87299ABEF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{E1A46D9D-66CB-46E8-93B0-7FC87299ABEF}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{E1A46D9D-66CB-46E8-93B0-7FC87299ABEF}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{E1A46D9D-66CB-46E8-93B0-7FC87299ABEF}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal
diff --git a/runtime/Java/pom.xml b/runtime/Java/pom.xml
index a3dcc473e..9824ffdd4 100644
--- a/runtime/Java/pom.xml
+++ b/runtime/Java/pom.xml
@@ -1,77 +1,66 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <parent>
+    <groupId>org.antlr</groupId>
+    <artifactId>antlr4-master</artifactId>
+    <version>4.5.4-SNAPSHOT</version>
+    <relativePath>../../pom.xml</relativePath>
+  </parent>
+  <artifactId>antlr4-runtime</artifactId>
+  <name>ANTLR 4 Runtime</name>
+  <description>The ANTLR 4 Runtime</description>
 
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <modelVersion>4.0.0</modelVersion>
-
-    <parent>
+  <build>
+    <sourceDirectory>src</sourceDirectory>
+    <plugins>
+      <plugin>
         <groupId>org.antlr</groupId>
-        <artifactId>antlr4-master</artifactId>
-        <version>4.1.1-SNAPSHOT</version>
-        <relativePath>../..</relativePath>
-    </parent>
-
-    <artifactId>antlr4-runtime</artifactId>
-
-    <name>ANTLR 4 Runtime</name>
-    <description>The ANTLR 4 Runtime</description>
-
-    <dependencies>
-        <dependency>
-            <groupId>org.abego.treelayout</groupId>
-            <artifactId>org.abego.treelayout.core</artifactId>
-            <version>1.0.1</version>
-            <scope>compile</scope>
-        </dependency>
-    </dependencies>
-
-    <profiles>
-        <profile>
-            <id>sonatype-oss-release</id>
-            <build>
-                <plugins>
-                    <plugin>
-                        <groupId>us.bryon</groupId>
-                        <artifactId>graphviz-maven-plugin</artifactId>
-                        <version>1.0</version>
-                        <executions>
-                            <execution>
-                                <goals>
-                                    <goal>dot</goal>
-                                </goals>
-                                <configuration>
-                                    <destdir>${project.build.directory}/apidocs</destdir>
-                                    <output>svg</output>
-                                </configuration>
-                            </execution>
-                        </executions>
-                    </plugin>
-                </plugins>
-            </build>
-        </profile>
-    </profiles>
-
-    <build>
-
-        <sourceDirectory>src</sourceDirectory>
-        <resources/>
-
-        <plugins>
-            <plugin>
-                <groupId>org.antlr</groupId>
-                <artifactId>antlr4-maven-plugin</artifactId>
-                <version>4.1</version>
-                <configuration>
-                    <sourceDirectory>src</sourceDirectory>
-                </configuration>
-                <executions>
-                    <execution>
-                        <goals>
-                            <goal>antlr4</goal>
-                        </goals>
-                    </execution>
-                </executions>
-            </plugin>
-        </plugins>
-    </build>
-
+        <artifactId>antlr4-maven-plugin</artifactId>
+        <version>4.5</version>
+        <executions>
+          <execution>
+            <id>antlr</id>
+            <configuration>
+              <sourceDirectory>src</sourceDirectory>
+            </configuration>
+            <goals>
+              <goal>antlr4</goal>
+            </goals>
+          </execution>
+        </executions>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.felix</groupId>
+        <artifactId>maven-bundle-plugin</artifactId>
+        <version>2.5.4</version>
+        <executions>
+          <execution>
+            <id>bundle-manifest</id>
+            <phase>process-classes</phase>
+            <configuration>
+              <instructions>
+                <Bundle-SymbolicName>org.antlr.antlr4-runtime-osgi</Bundle-SymbolicName>
+                <Implementation-Title>ANTLR 4 Runtime</Implementation-Title>
+                <Implementation-Vendor>ANTLR</Implementation-Vendor>
+                <Implementation-Vendor-Id>org.antlr</Implementation-Vendor-Id>
+                <Implementation-Version>${project.version}</Implementation-Version>
+              </instructions>
+            </configuration>
+            <goals>
+              <goal>manifest</goal>
+            </goals>
+          </execution>
+        </executions>
+      </plugin>
+      <plugin>
+        <artifactId>maven-jar-plugin</artifactId>
+        <version>2.4</version>
+        <configuration>
+          <archive>
+            <manifestFile>${project.build.outputDirectory}/META-INF/MANIFEST.MF</manifestFile>
+          </archive>
+        </configuration>
+      </plugin>
+    </plugins>
+  </build>
 </project>
diff --git a/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/ArrayMerge_DiffTopDiffPar.dot b/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/ArrayMerge_DiffTopDiffPar.dot
index 68948fe48..86c4b699f 100644
--- a/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/ArrayMerge_DiffTopDiffPar.dot
+++ b/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/ArrayMerge_DiffTopDiffPar.dot
@@ -51,7 +51,7 @@ digraph "" {
 
         temp2a -> temp2b[style="invisible";dir="none"];
         temp2a -> temp2c[style="invisible";dir="none"];
-        temp2b -> temp2c[constraint="false";label="wwwwwww"];
+        temp2b -> temp2c[constraint="false";label="wwwwwww";fontcolor="invis"];
     }
 
     subgraph clusterC {
diff --git a/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/ArrayMerge_EqualTop.dot b/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/ArrayMerge_EqualTop.dot
index 3ae341b2c..c44454d2c 100644
--- a/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/ArrayMerge_EqualTop.dot
+++ b/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/ArrayMerge_EqualTop.dot
@@ -47,7 +47,7 @@ digraph "" {
 
         temp2a -> temp2b[style="invisible";dir="none"];
         temp2a -> temp2c[style="invisible";dir="none"];
-        temp2b -> temp2c[constraint="false";label="wwwwwww"];
+        temp2b -> temp2c[constraint="false";label="wwwwwww";fontcolor="invis"];
     }
 
     subgraph clusterC {
diff --git a/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/ArrayMerge_ShareTopDiffPar.dot b/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/ArrayMerge_ShareTopDiffPar.dot
index 87e494f1a..ca3b5e717 100644
--- a/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/ArrayMerge_ShareTopDiffPar.dot
+++ b/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/ArrayMerge_ShareTopDiffPar.dot
@@ -51,7 +51,7 @@ digraph "" {
 
         temp2a -> temp2b[style="invisible";dir="none"];
         temp2a -> temp2c[style="invisible";dir="none"];
-        temp2b -> temp2c[constraint="false";label="wwwwwww"];
+        temp2b -> temp2c[constraint="false";label="wwwwwww";fontcolor="invis"];
     }
 
     subgraph clusterC {
diff --git a/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/ArrayMerge_ShareTopSamePar.dot b/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/ArrayMerge_ShareTopSamePar.dot
index 638721aac..34d5a379b 100644
--- a/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/ArrayMerge_ShareTopSamePar.dot
+++ b/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/ArrayMerge_ShareTopSamePar.dot
@@ -51,7 +51,7 @@ digraph "" {
 
         temp2a -> temp2b[style="invisible";dir="none"];
         temp2a -> temp2c[style="invisible";dir="none"];
-        temp2b -> temp2c[constraint="false";label="wwwwwww"];
+        temp2b -> temp2c[constraint="false";label="wwwwwww";fontcolor="invis"];
     }
 
     subgraph clusterC {
diff --git a/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/ArrayMerge_ShareTopSharePar.dot b/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/ArrayMerge_ShareTopSharePar.dot
index 8eb558fac..3795de21f 100644
--- a/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/ArrayMerge_ShareTopSharePar.dot
+++ b/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/ArrayMerge_ShareTopSharePar.dot
@@ -51,7 +51,7 @@ digraph "" {
 
         temp2a -> temp2b[style="invisible";dir="none"];
         temp2a -> temp2c[style="invisible";dir="none"];
-        temp2b -> temp2c[constraint="false";label="wwwwwww"];
+        temp2b -> temp2c[constraint="false";label="wwwwwww";fontcolor="invis"];
     }
 
     subgraph clusterC {
diff --git a/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/Block.dot b/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/Block.dot
index 2875d54d2..73962b99b 100644
--- a/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/Block.dot
+++ b/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/Block.dot
@@ -1,7 +1,7 @@
 digraph "" {
-    graph[fontname="Courier New";rankdir="LR";pad="0.25"];
-    node[fontname="Courier New";target="_parent"];
-    edge[fontname="Courier New"];
+    graph[fontname="CourierNew";rankdir="LR";pad="0.25"];
+    node[fontname="CourierNew";target="_parent"];
+    edge[fontname="CourierNew"];
     subgraph clusterA {
         color="invis";
         {   node[shape="record"];
diff --git a/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/ClosureGreedy.dot b/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/ClosureGreedy.dot
index 91ec064a5..ab3fe1406 100644
--- a/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/ClosureGreedy.dot
+++ b/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/ClosureGreedy.dot
@@ -1,7 +1,7 @@
 digraph "" {
-    graph[fontname="Courier New";rankdir="LR";pad="0.25"];
-    node[fontname="Courier New";target="_parent"];
-    edge[fontname="Courier New"];
+    graph[fontname="CourierNew";rankdir="LR";pad="0.25"];
+    node[fontname="CourierNew";target="_parent"];
+    edge[fontname="CourierNew"];
     subgraph cluster0 {
         color="invis";
         {   node[shape="record"];
diff --git a/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/ClosureNonGreedy.dot b/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/ClosureNonGreedy.dot
index 2894be2e3..6f619a7c8 100644
--- a/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/ClosureNonGreedy.dot
+++ b/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/ClosureNonGreedy.dot
@@ -1,7 +1,7 @@
 digraph "" {
-    graph[fontname="Courier New";rankdir="LR";pad="0.25"];
-    node[fontname="Courier New";target="_parent"];
-    edge[fontname="Courier New"];
+    graph[fontname="CourierNew";rankdir="LR";pad="0.25"];
+    node[fontname="CourierNew";target="_parent"];
+    edge[fontname="CourierNew"];
     subgraph cluster0 {
         color="invis";
         {   node[shape="record"];
diff --git a/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/FullMerge_EmptyRoot.dot b/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/FullMerge_EmptyRoot.dot
index d740ef1a2..1ee6a0d91 100644
--- a/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/FullMerge_EmptyRoot.dot
+++ b/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/FullMerge_EmptyRoot.dot
@@ -33,7 +33,7 @@ digraph "" {
 
         temp2a -> temp2b[style="invisible";dir="none"];
         temp2a -> temp2c[style="invisible";dir="none"];
-        temp2b -> temp2c[constraint="false";label="wwwwwww"];
+        temp2b -> temp2c[constraint="false";label="wwwwwww";fontcolor="invis"];
     }
 
     subgraph Res {
diff --git a/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/FullMerge_EmptyRoots.dot b/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/FullMerge_EmptyRoots.dot
index b852f21de..42e46e0e3 100644
--- a/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/FullMerge_EmptyRoots.dot
+++ b/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/FullMerge_EmptyRoots.dot
@@ -18,7 +18,7 @@ digraph "" {
         temp2b;
         temp2c;
 
-        temp2b -> temp2c[constraint="false";label="wwwwwww"];
+        temp2b -> temp2c[constraint="false";label="wwwwwww";fontcolor="invis"];
     }
 
     subgraph Res {
diff --git a/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/FullMerge_SameRoot.dot b/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/FullMerge_SameRoot.dot
index b95ccb47d..65938603c 100644
--- a/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/FullMerge_SameRoot.dot
+++ b/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/FullMerge_SameRoot.dot
@@ -37,7 +37,7 @@ digraph "" {
 
         temp2a -> temp2b[style="invisible";dir="none"];
         temp2a -> temp2c[style="invisible";dir="none"];
-        temp2b -> temp2c[constraint="false";label="wwwwwww"];
+        temp2b -> temp2c[constraint="false";label="wwwwwww";fontcolor="invis"];
     }
 
     subgraph Res {
diff --git a/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/LocalMerge_DiffRoots.dot b/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/LocalMerge_DiffRoots.dot
index f23adef00..067fa21ca 100644
--- a/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/LocalMerge_DiffRoots.dot
+++ b/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/LocalMerge_DiffRoots.dot
@@ -25,7 +25,7 @@ digraph "" {
         temp2b;
         temp2c;
 
-        temp2b -> temp2c[constraint="false";label="wwwwwww"];
+        temp2b -> temp2c[constraint="false";label="wwwwwww";fontcolor="invis"];
     }
 
     subgraph Res {
diff --git a/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/LocalMerge_EmptyParent.dot b/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/LocalMerge_EmptyParent.dot
index 92c474955..7f5a6d86f 100644
--- a/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/LocalMerge_EmptyParent.dot
+++ b/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/LocalMerge_EmptyParent.dot
@@ -25,7 +25,7 @@ digraph "" {
         temp2b;
         temp2c;
 
-        temp2b -> temp2c[constraint="false";label="wwwwwww"];
+        temp2b -> temp2c[constraint="false";label="wwwwwww";fontcolor="invis"];
     }
 
     subgraph Res {
diff --git a/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/LocalMerge_EmptyRoot.dot b/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/LocalMerge_EmptyRoot.dot
index d4ac91caa..7527c3eb4 100644
--- a/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/LocalMerge_EmptyRoot.dot
+++ b/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/LocalMerge_EmptyRoot.dot
@@ -18,7 +18,7 @@ digraph "" {
         temp2b;
         temp2c;
 
-        temp2b -> temp2c[constraint="false";label="wwwwwww"];
+        temp2b -> temp2c[constraint="false";label="wwwwwww";fontcolor="invis"];
     }
 
     subgraph Res {
diff --git a/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/OptionalGreedy.dot b/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/OptionalGreedy.dot
index aacb4f94e..7c76df4ec 100644
--- a/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/OptionalGreedy.dot
+++ b/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/OptionalGreedy.dot
@@ -1,7 +1,7 @@
 digraph "" {
-    graph[fontname="Courier New";rankdir="LR";pad="0.25"];
-    node[fontname="Courier New";target="_parent"];
-    edge[fontname="Courier New"];
+    graph[fontname="CourierNew";rankdir="LR";pad="0.25"];
+    node[fontname="CourierNew";target="_parent"];
+    edge[fontname="CourierNew"];
     subgraph cluster0 {
         color="invis";
         {   node[shape="record"];
diff --git a/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/OptionalNonGreedy.dot b/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/OptionalNonGreedy.dot
index f5b2fa654..5d2f30d6f 100644
--- a/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/OptionalNonGreedy.dot
+++ b/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/OptionalNonGreedy.dot
@@ -1,7 +1,7 @@
 digraph "" {
-    graph[fontname="Courier New";rankdir="LR";pad="0.25"];
-    node[fontname="Courier New";target="_parent"];
-    edge[fontname="Courier New"];
+    graph[fontname="CourierNew";rankdir="LR";pad="0.25"];
+    node[fontname="CourierNew";target="_parent"];
+    edge[fontname="CourierNew"];
     subgraph cluster0 {
         color="invis";
         {   node[shape="record"];
diff --git a/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/PositiveClosureGreedy.dot b/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/PositiveClosureGreedy.dot
index 2cf3bee99..1e3336347 100644
--- a/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/PositiveClosureGreedy.dot
+++ b/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/PositiveClosureGreedy.dot
@@ -1,7 +1,7 @@
 digraph "" {
-    graph[fontname="Courier New";rankdir="LR";pad="0.25"];
-    node[fontname="Courier New";target="_parent"];
-    edge[fontname="Courier New"];
+    graph[fontname="CourierNew";rankdir="LR";pad="0.25"];
+    node[fontname="CourierNew";target="_parent"];
+    edge[fontname="CourierNew"];
     subgraph cluster0 {
         color="invis";
         {   node[shape="record"];
diff --git a/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/PositiveClosureNonGreedy.dot b/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/PositiveClosureNonGreedy.dot
index 355754708..cdbe30ec1 100644
--- a/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/PositiveClosureNonGreedy.dot
+++ b/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/PositiveClosureNonGreedy.dot
@@ -1,7 +1,7 @@
 digraph "" {
-    graph[fontname="Courier New";rankdir="LR";pad="0.25"];
-    node[fontname="Courier New";target="_parent"];
-    edge[fontname="Courier New"];
+    graph[fontname="CourierNew";rankdir="LR";pad="0.25"];
+    node[fontname="CourierNew";target="_parent"];
+    edge[fontname="CourierNew"];
     subgraph cluster0 {
         color="invis";
         {   node[shape="record"];
diff --git a/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/Rule.dot b/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/Rule.dot
index 4b0bd3364..1693f602e 100644
--- a/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/Rule.dot
+++ b/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/Rule.dot
@@ -1,7 +1,7 @@
 digraph "" {
-    graph[fontname="Courier New";rankdir="LR";pad="0.25"];
-    node[fontname="Courier New";target="_parent"];
-    edge[fontname="Courier New"];
+    graph[fontname="CourierNew";rankdir="LR";pad="0.25"];
+    node[fontname="CourierNew";target="_parent"];
+    edge[fontname="CourierNew"];
     {   node[shape="box"];
         RuleStartState[URL="../RuleStartState.html"];
         RuleStopState[URL="../RuleStopState.html"];
diff --git a/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/SingletonMerge_DiffRootDiffPar.dot b/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/SingletonMerge_DiffRootDiffPar.dot
index 19886d1d7..115f6b7f9 100644
--- a/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/SingletonMerge_DiffRootDiffPar.dot
+++ b/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/SingletonMerge_DiffRootDiffPar.dot
@@ -25,7 +25,7 @@ digraph "" {
         temp2b;
         temp2c;
 
-        temp2b -> temp2c[constraint="false";label="wwwwwww"];
+        temp2b -> temp2c[constraint="false";label="wwwwwww";fontcolor="invis"];
     }
 
     subgraph clusterRes {
diff --git a/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/SingletonMerge_DiffRootSamePar.dot b/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/SingletonMerge_DiffRootSamePar.dot
index b3f01408e..5a25216d7 100644
--- a/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/SingletonMerge_DiffRootSamePar.dot
+++ b/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/SingletonMerge_DiffRootSamePar.dot
@@ -25,7 +25,7 @@ digraph "" {
         temp2b;
         temp2c;
 
-        temp2b -> temp2c[constraint="false";label="wwwwwww"];
+        temp2b -> temp2c[constraint="false";label="wwwwwww";fontcolor="invis"];
     }
 
     subgraph clusterRes {
diff --git a/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/SingletonMerge_SameRootDiffPar.dot b/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/SingletonMerge_SameRootDiffPar.dot
index c33f461d4..39a7fce00 100644
--- a/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/SingletonMerge_SameRootDiffPar.dot
+++ b/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/SingletonMerge_SameRootDiffPar.dot
@@ -37,7 +37,7 @@ digraph "" {
 
         temp2a -> temp2b[style="invisible";dir="none"];
         temp2a -> temp2c[style="invisible";dir="none"];
-        temp2b -> temp2c[constraint="false";label="wwwwwww"];
+        temp2b -> temp2c[constraint="false";label="wwwwwww";fontcolor="invis"];
     }
 
     subgraph clusterRes {
diff --git a/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/SingletonMerge_SameRootSamePar.dot b/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/SingletonMerge_SameRootSamePar.dot
index 46d0940c8..bfb11010e 100644
--- a/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/SingletonMerge_SameRootSamePar.dot
+++ b/runtime/Java/src/main/dot/org/antlr/v4/runtime/atn/images/SingletonMerge_SameRootSamePar.dot
@@ -25,7 +25,7 @@ digraph "" {
         temp2b;
         temp2c;
 
-        temp2b -> temp2c[constraint="false";label="wwwwwww"];
+        temp2b -> temp2c[constraint="false";label="wwwwwww";fontcolor="invis"];
     }
 
     subgraph clusterRes {
diff --git a/runtime/Java/src/org/antlr/v4/runtime/ANTLRErrorListener.java b/runtime/Java/src/org/antlr/v4/runtime/ANTLRErrorListener.java
index d78d44657..83c7d869e 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/ANTLRErrorListener.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/ANTLRErrorListener.java
@@ -31,11 +31,10 @@
 package org.antlr.v4.runtime;
 
 import org.antlr.v4.runtime.atn.ATNConfigSet;
+import org.antlr.v4.runtime.atn.DecisionInfo;
 import org.antlr.v4.runtime.atn.ParserATNSimulator;
 import org.antlr.v4.runtime.atn.PredictionMode;
 import org.antlr.v4.runtime.dfa.DFA;
-import org.antlr.v4.runtime.misc.NotNull;
-import org.antlr.v4.runtime.misc.Nullable;
 
 import java.util.BitSet;
 
@@ -47,11 +46,11 @@ public interface ANTLRErrorListener {
 	 * specifies how to recover from syntax errors and how to compute error
 	 * messages. This listener's job is simply to emit a computed message,
 	 * though it has enough information to create its own message in many cases.
-	 * <p/>
-	 * The {@link RecognitionException} is non-null for all syntax errors except
+	 *
+	 * <p>The {@link RecognitionException} is non-null for all syntax errors except
 	 * when we discover mismatched token errors that we can recover from
 	 * in-line, without returning from the surrounding rule (via the single
-	 * token insertion and deletion mechanism).
+	 * token insertion and deletion mechanism).</p>
 	 *
 	 * @param recognizer
      *        What parser got the error. From this
@@ -75,58 +74,70 @@ public interface ANTLRErrorListener {
 	 *        surrounding rule.
 	 */
 	public void syntaxError(Recognizer<?, ?> recognizer,
-							@Nullable Object offendingSymbol,
+							Object offendingSymbol,
 							int line,
 							int charPositionInLine,
 							String msg,
-							@Nullable RecognitionException e);
+							RecognitionException e);
 
 	/**
 	 * This method is called by the parser when a full-context prediction
 	 * results in an ambiguity.
-	 * <p/>
-	 * When {@code exact} is {@code true}, <em>all</em> of the alternatives in
-	 * {@code ambigAlts} are viable, i.e. this is reporting an exact ambiguity.
-	 * When {@code exact} is {@code false}, <em>at least two</em> of the
-	 * alternatives in {@code ambigAlts} are viable for the current input, but
+	 *
+	 * <p>Each full-context prediction which does not result in a syntax error
+	 * will call either {@link #reportContextSensitivity} or
+	 * {@link #reportAmbiguity}.</p>
+	 *
+	 * <p>When {@code ambigAlts} is not null, it contains the set of potentially
+	 * viable alternatives identified by the prediction algorithm. When
+	 * {@code ambigAlts} is null, use {@link ATNConfigSet#getAlts} to obtain the
+	 * represented alternatives from the {@code configs} argument.</p>
+	 *
+	 * <p>When {@code exact} is {@code true}, <em>all</em> of the potentially
+	 * viable alternatives are truly viable, i.e. this is reporting an exact
+	 * ambiguity. When {@code exact} is {@code false}, <em>at least two</em> of
+	 * the potentially viable alternatives are viable for the current input, but
 	 * the prediction algorithm terminated as soon as it determined that at
-	 * least the <em>minimum</em> alternative in {@code ambigAlts} is viable.
-	 * <p/>
-	 * When the {@link PredictionMode#LL_EXACT_AMBIG_DETECTION} prediction mode
-	 * is used, the parser is required to identify exact ambiguities so
-	 * {@code exact} will always be {@code true}.
-	 * <p/>
-	 * This method is not used by lexers.
+	 * least the <em>minimum</em> potentially viable alternative is truly
+	 * viable.</p>
+	 *
+	 * <p>When the {@link PredictionMode#LL_EXACT_AMBIG_DETECTION} prediction
+	 * mode is used, the parser is required to identify exact ambiguities so
+	 * {@code exact} will always be {@code true}.</p>
+	 *
+	 * <p>This method is not used by lexers.</p>
 	 *
 	 * @param recognizer the parser instance
 	 * @param dfa the DFA for the current decision
 	 * @param startIndex the input index where the decision started
-	 * @param stopIndex the input input where the ambiguity is reported
+	 * @param stopIndex the input input where the ambiguity was identified
 	 * @param exact {@code true} if the ambiguity is exactly known, otherwise
 	 * {@code false}. This is always {@code true} when
 	 * {@link PredictionMode#LL_EXACT_AMBIG_DETECTION} is used.
-	 * @param ambigAlts the potentially ambiguous alternatives
+	 * @param ambigAlts the potentially ambiguous alternatives, or {@code null}
+	 * to indicate that the potentially ambiguous alternatives are the complete
+	 * set of represented alternatives in {@code configs}
 	 * @param configs the ATN configuration set where the ambiguity was
-	 * determined
+	 * identified
 	 */
-	void reportAmbiguity(@NotNull Parser recognizer,
-						 @NotNull DFA dfa,
+	void reportAmbiguity(Parser recognizer,
+						 DFA dfa,
 						 int startIndex,
 						 int stopIndex,
 						 boolean exact,
-						 @NotNull BitSet ambigAlts,
-						 @NotNull ATNConfigSet configs);
+						 BitSet ambigAlts,
+						 ATNConfigSet configs);
 
 	/**
 	 * This method is called when an SLL conflict occurs and the parser is about
 	 * to use the full context information to make an LL decision.
-	 * <p/>
-	 * If one or more configurations in {@code configs} contains a semantic
+	 *
+	 * <p>If one or more configurations in {@code configs} contains a semantic
 	 * predicate, the predicates are evaluated before this method is called. The
 	 * subset of alternatives which are still viable after predicates are
-	 * evaluated is reported in {@code conflictingAlts}.
-	 * <p/>
-	 * This method is not used by lexers.
+	 * evaluated is reported in {@code conflictingAlts}.</p>
+	 *
+	 * <p>This method is not used by lexers.</p>
 	 *
 	 * @param recognizer the parser instance
 	 * @param dfa the DFA for the current decision
@@ -134,35 +145,47 @@ public interface ANTLRErrorListener {
 	 * @param stopIndex the input index where the SLL conflict occurred
 	 * @param conflictingAlts The specific conflicting alternatives. If this is
 	 * {@code null}, the conflicting alternatives are all alternatives
-	 * represented in {@code configs}.
+	 * represented in {@code configs}. At the moment, conflictingAlts is non-null
+	 * (for the reference implementation, but Sam's optimized version can see this
+	 * as null).
 	 * @param configs the ATN configuration set where the SLL conflict was
 	 * detected
 	 */
-	void reportAttemptingFullContext(@NotNull Parser recognizer,
-									 @NotNull DFA dfa,
+	void reportAttemptingFullContext(Parser recognizer,
+									 DFA dfa,
 									 int startIndex,
 									 int stopIndex,
-									 @Nullable BitSet conflictingAlts,
-									 @NotNull ATNConfigSet configs);
+									 BitSet conflictingAlts,
+									 ATNConfigSet configs);
 
 	/**
 	 * This method is called by the parser when a full-context prediction has a
 	 * unique result.
-	 * <p/>
-	 * For prediction implementations that only evaluate full-context
+	 *
+	 * <p>Each full-context prediction which does not result in a syntax error
+	 * will call either {@link #reportContextSensitivity} or
+	 * {@link #reportAmbiguity}.</p>
+	 *
+	 * <p>For prediction implementations that only evaluate full-context
 	 * predictions when an SLL conflict is found (including the default
 	 * {@link ParserATNSimulator} implementation), this method reports cases
 	 * where SLL conflicts were resolved to unique full-context predictions,
 	 * i.e. the decision was context-sensitive. This report does not necessarily
 	 * indicate a problem, and it may appear even in completely unambiguous
-	 * grammars.
-	 * <p/>
-	 * {@code configs} may have more than one represented alternative if the
+	 * grammars.</p>
+	 *
+	 * <p>{@code configs} may have more than one represented alternative if the
 	 * full-context prediction algorithm does not evaluate predicates before
 	 * beginning the full-context prediction. In all cases, the final prediction
-	 * is passed as the {@code prediction} argument.
-	 * <p/>
-	 * This method is not used by lexers.
+	 * is passed as the {@code prediction} argument.</p>
+	 *
+	 * <p>Note that the definition of "context sensitivity" in this method
+	 * differs from the concept in {@link DecisionInfo#contextSensitivities}.
+	 * This method reports all instances where an SLL conflict occurred but LL
+	 * parsing produced a unique result, whether or not that unique result
+	 * matches the minimum alternative in the SLL conflicting set.</p>
+	 *
+	 * <p>This method is not used by lexers.</p>
 	 *
 	 * @param recognizer the parser instance
 	 * @param dfa the DFA for the current decision
@@ -173,10 +196,10 @@ public interface ANTLRErrorListener {
 	 * @param configs the ATN configuration set where the unambiguous prediction
 	 * was determined
 	 */
-	void reportContextSensitivity(@NotNull Parser recognizer,
-								  @NotNull DFA dfa,
+	void reportContextSensitivity(Parser recognizer,
+								  DFA dfa,
 								  int startIndex,
 								  int stopIndex,
 								  int prediction,
-								  @NotNull ATNConfigSet configs);
+								  ATNConfigSet configs);
 }
diff --git a/runtime/Java/src/org/antlr/v4/runtime/ANTLRErrorStrategy.java b/runtime/Java/src/org/antlr/v4/runtime/ANTLRErrorStrategy.java
index 5907e6632..f123778f9 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/ANTLRErrorStrategy.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/ANTLRErrorStrategy.java
@@ -30,8 +30,6 @@
 
 package org.antlr.v4.runtime;
 
-import org.antlr.v4.runtime.misc.NotNull;
-
 /**
  * The interface for defining strategies to deal with syntax errors encountered
  * during a parse by ANTLR-generated parsers. We distinguish between three
@@ -46,15 +44,15 @@ import org.antlr.v4.runtime.misc.NotNull;
  *
  * Implementations of this interface report syntax errors by calling
  * {@link Parser#notifyErrorListeners}.
- * <p/>
- * TODO: what to do about lexers
+ *
+ * <p>TODO: what to do about lexers</p>
  */
 public interface ANTLRErrorStrategy {
 	/**
 	 * Reset the error handler state for the specified {@code recognizer}.
 	 * @param recognizer the parser instance
 	 */
-	void reset(@NotNull Parser recognizer);
+	void reset(Parser recognizer);
 
 	/**
 	 * This method is called when an unexpected symbol is encountered during an
@@ -62,18 +60,19 @@ public interface ANTLRErrorStrategy {
 	 * strategy successfully recovers from the match failure, this method
 	 * returns the {@link Token} instance which should be treated as the
 	 * successful result of the match.
-	 * <p/>
-	 * Note that the calling code will not report an error if this method
+	 *
+   * <p>This method handles the consumption of any tokens - the caller should
+	 * <b>not</b> call {@link Parser#consume} after a successful recovery.</p>
+	 *
+	 * <p>Note that the calling code will not report an error if this method
 	 * returns successfully. The error strategy implementation is responsible
-	 * for calling {@link Parser#notifyErrorListeners} as appropriate.
+	 * for calling {@link Parser#notifyErrorListeners} as appropriate.</p>
 	 *
 	 * @param recognizer the parser instance
 	 * @throws RecognitionException if the error strategy was not able to
 	 * recover from the unexpected input symbol
 	 */
-	@NotNull
-	Token recoverInline(@NotNull Parser recognizer)
-		throws RecognitionException;
+	Token recoverInline(Parser recognizer) throws RecognitionException;
 
 	/**
 	 * This method is called to recover from exception {@code e}. This method is
@@ -87,21 +86,19 @@ public interface ANTLRErrorStrategy {
 	 * @throws RecognitionException if the error strategy could not recover from
 	 * the recognition exception
 	 */
-	void recover(@NotNull Parser recognizer,
-				 @NotNull RecognitionException e)
-		throws RecognitionException;
+	void recover(Parser recognizer, RecognitionException e) throws RecognitionException;
 
 	/**
 	 * This method provides the error handler with an opportunity to handle
 	 * syntactic or semantic errors in the input stream before they result in a
 	 * {@link RecognitionException}.
-	 * <p/>
-	 * The generated code currently contains calls to {@link #sync} after
+	 *
+	 * <p>The generated code currently contains calls to {@link #sync} after
 	 * entering the decision state of a closure block ({@code (...)*} or
-	 * {@code (...)+}).
-	 * <p/>
-	 * For an implementation based on Jim Idle's "magic sync" mechanism, see
-	 * {@link DefaultErrorStrategy#sync}.
+	 * {@code (...)+}).</p>
+	 *
+	 * <p>For an implementation based on Jim Idle's "magic sync" mechanism, see
+	 * {@link DefaultErrorStrategy#sync}.</p>
 	 *
 	 * @see DefaultErrorStrategy#sync
 	 *
@@ -110,8 +107,7 @@ public interface ANTLRErrorStrategy {
 	 * strategy but cannot be automatically recovered at the current state in
 	 * the parsing process
 	 */
-	void sync(@NotNull Parser recognizer)
-		throws RecognitionException;
+	void sync(Parser recognizer) throws RecognitionException;
 
 	/**
 	 * Tests whether or not {@code recognizer} is in the process of recovering
@@ -124,7 +120,7 @@ public interface ANTLRErrorStrategy {
 	 * @return {@code true} if the parser is currently recovering from a parse
 	 * error, otherwise {@code false}
 	 */
-	boolean inErrorRecoveryMode(@NotNull Parser recognizer);
+	boolean inErrorRecoveryMode(Parser recognizer);
 
 	/**
 	 * This method is called by when the parser successfully matches an input
@@ -132,7 +128,7 @@ public interface ANTLRErrorStrategy {
 	 *
 	 * @param recognizer the parser instance
 	 */
-	void reportMatch(@NotNull Parser recognizer);
+	void reportMatch(Parser recognizer);
 
 	/**
 	 * Report any kind of {@link RecognitionException}. This method is called by
@@ -141,6 +137,5 @@ public interface ANTLRErrorStrategy {
 	 * @param recognizer the parser instance
 	 * @param e the recognition exception to report
 	 */
-	void reportError(@NotNull Parser recognizer,
-					 @NotNull RecognitionException e);
+	void reportError(Parser recognizer, RecognitionException e);
 }
diff --git a/runtime/Java/src/org/antlr/v4/runtime/ANTLRFileStream.java b/runtime/Java/src/org/antlr/v4/runtime/ANTLRFileStream.java
index 340a59e93..ba4a53136 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/ANTLRFileStream.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/ANTLRFileStream.java
@@ -29,11 +29,9 @@
  */
 package org.antlr.v4.runtime;
 
-import java.io.File;
-import java.io.FileInputStream;
+import org.antlr.v4.runtime.misc.Utils;
+
 import java.io.IOException;
-import java.io.InputStreamReader;
-import java.util.Arrays;
 
 /**
  * This is an {@link ANTLRInputStream} that is loaded from a file all at once
@@ -54,29 +52,8 @@ public class ANTLRFileStream extends ANTLRInputStream {
 	public void load(String fileName, String encoding)
 		throws IOException
 	{
-		if ( fileName==null ) {
-			return;
-		}
-		File f = new File(fileName);
-		int size = (int)f.length();
-		InputStreamReader isr;
-		FileInputStream fis = new FileInputStream(fileName);
-		if ( encoding!=null ) {
-			isr = new InputStreamReader(fis, encoding);
-		}
-		else {
-			isr = new InputStreamReader(fis);
-		}
-		try {
-			data = new char[size];
-			n = isr.read(data);
-			if (n < data.length) {
-				data = Arrays.copyOf(data, n);
-			}
-		}
-		finally {
-			isr.close();
-		}
+		data = Utils.readFile(fileName, encoding);
+		this.n = data.length;
 	}
 
 	@Override
diff --git a/runtime/Java/src/org/antlr/v4/runtime/ANTLRInputStream.java b/runtime/Java/src/org/antlr/v4/runtime/ANTLRInputStream.java
index 98db38dce..62c562e3f 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/ANTLRInputStream.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/ANTLRInputStream.java
@@ -41,8 +41,8 @@ import java.util.Arrays;
  * Vacuum all input from a {@link Reader}/{@link InputStream} and then treat it
  * like a {@code char[]} buffer. Can also pass in a {@link String} or
  * {@code char[]} to use.
- * <p/>
- * If you need encoding, pass in stream/reader with correct encoding.
+ *
+ * <p>If you need encoding, pass in stream/reader with correct encoding.</p>
  */
 public class ANTLRInputStream implements CharStream {
     public static final int READ_BUFFER_SIZE = 1024;
@@ -216,8 +216,9 @@ public class ANTLRInputStream implements CharStream {
 			p = index; // just jump; don't update stream state (line, ...)
 			return;
 		}
-		// seek forward, consume until p hits index
-		while ( p<index && index<n ) {
+		// seek forward, consume until p hits index or n (whichever comes first)
+		index = Math.min(index, n);
+		while ( p<index ) {
 			consume();
 		}
 	}
@@ -237,6 +238,10 @@ public class ANTLRInputStream implements CharStream {
 
 	@Override
 	public String getSourceName() {
+		if (name == null || name.isEmpty()) {
+			return UNKNOWN_SOURCE_NAME;
+		}
+
 		return name;
 	}
 
diff --git a/runtime/Java/src/org/antlr/v4/runtime/BailErrorStrategy.java b/runtime/Java/src/org/antlr/v4/runtime/BailErrorStrategy.java
index f13bd194a..f4874dd92 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/BailErrorStrategy.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/BailErrorStrategy.java
@@ -32,9 +32,33 @@ package org.antlr.v4.runtime;
 
 import org.antlr.v4.runtime.misc.ParseCancellationException;
 
-/** Bail out of parser at first syntax error. Do this to use it:
- *  <p/>
- *  {@code myparser.setErrorHandler(new BailErrorStrategy());}
+/**
+ * This implementation of {@link ANTLRErrorStrategy} responds to syntax errors
+ * by immediately canceling the parse operation with a
+ * {@link ParseCancellationException}. The implementation ensures that the
+ * {@link ParserRuleContext#exception} field is set for all parse tree nodes
+ * that were not completed prior to encountering the error.
+ *
+ * <p>
+ * This error strategy is useful in the following scenarios.</p>
+ *
+ * <ul>
+ * <li><strong>Two-stage parsing:</strong> This error strategy allows the first
+ * stage of two-stage parsing to immediately terminate if an error is
+ * encountered, and immediately fall back to the second stage. In addition to
+ * avoiding wasted work by attempting to recover from errors here, the empty
+ * implementation of {@link BailErrorStrategy#sync} improves the performance of
+ * the first stage.</li>
+ * <li><strong>Silent validation:</strong> When syntax errors are not being
+ * reported or logged, and the parse result is simply ignored if errors occur,
+ * the {@link BailErrorStrategy} avoids wasting work on recovering from errors
+ * when the result will be ignored either way.</li>
+ * </ul>
+ *
+ * <p>
+ * {@code myparser.setErrorHandler(new BailErrorStrategy());}</p>
+ *
+ * @see Parser#setErrorHandler(ANTLRErrorStrategy)
  */
 public class BailErrorStrategy extends DefaultErrorStrategy {
     /** Instead of recovering from exception {@code e}, re-throw it wrapped
diff --git a/runtime/Java/src/org/antlr/v4/runtime/BaseErrorListener.java b/runtime/Java/src/org/antlr/v4/runtime/BaseErrorListener.java
index 9cb8a623a..3a752f2da 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/BaseErrorListener.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/BaseErrorListener.java
@@ -35,6 +35,10 @@ import org.antlr.v4.runtime.dfa.DFA;
 import java.util.BitSet;
 
 /**
+ * Provides an empty default implementation of {@link ANTLRErrorListener}. The
+ * default implementation of each method does nothing, but can be overridden as
+ * necessary.
+ *
  * @author Sam Harwell
  */
 public class BaseErrorListener implements ANTLRErrorListener {
diff --git a/runtime/Java/src/org/antlr/v4/runtime/BufferedTokenStream.java b/runtime/Java/src/org/antlr/v4/runtime/BufferedTokenStream.java
index f0848f914..ba1417c68 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/BufferedTokenStream.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/BufferedTokenStream.java
@@ -31,7 +31,6 @@
 package org.antlr.v4.runtime;
 
 import org.antlr.v4.runtime.misc.Interval;
-import org.antlr.v4.runtime.misc.NotNull;
 
 import java.util.ArrayList;
 import java.util.HashSet;
@@ -39,45 +38,55 @@ import java.util.List;
 import java.util.Set;
 
 /**
- * Buffer all input tokens but do on-demand fetching of new tokens from lexer.
- * Useful when the parser or lexer has to set context/mode info before proper
- * lexing of future tokens. The ST template parser needs this, for example,
- * because it has to constantly flip back and forth between inside/output
- * templates. E.g., {@code <names:{hi, <it>}>} has to parse names as part of an
- * expression but {@code "hi, <it>"} as a nested template.
- * <p/>
- * You can't use this stream if you pass whitespace or other off-channel tokens
- * to the parser. The stream can't ignore off-channel tokens.
- * ({@link UnbufferedTokenStream} is the same way.) Use
- * {@link CommonTokenStream}.
+ * This implementation of {@link TokenStream} loads tokens from a
+ * {@link TokenSource} on-demand, and places the tokens in a buffer to provide
+ * access to any previous token by index.
+ *
+ * <p>
+ * This token stream ignores the value of {@link Token#getChannel}. If your
+ * parser requires the token stream filter tokens to only those on a particular
+ * channel, such as {@link Token#DEFAULT_CHANNEL} or
+ * {@link Token#HIDDEN_CHANNEL}, use a filtering token stream such a
+ * {@link CommonTokenStream}.</p>
  */
 public class BufferedTokenStream implements TokenStream {
-	@NotNull
+	/**
+	 * The {@link TokenSource} from which tokens for this stream are fetched.
+	 */
     protected TokenSource tokenSource;
 
 	/**
-	 * Record every single token pulled from the source so we can reproduce
-	 * chunks of it later. This list captures everything so we can access
-	 * complete input text.
+	 * A collection of all tokens fetched from the token source. The list is
+	 * considered a complete view of the input once {@link #fetchedEOF} is set
+	 * to {@code true}.
 	 */
     protected List<Token> tokens = new ArrayList<Token>(100);
 
 	/**
 	 * The index into {@link #tokens} of the current token (next token to
-	 * consume). {@link #tokens}{@code [}{@link #p}{@code ]} should be
-	 * {@link #LT LT(1)}. {@link #p}{@code =-1} indicates need to initialize
-	 * with first token. The constructor doesn't get a token. First call to
-	 * {@link #LT LT(1)} or whatever gets the first token and sets
-	 * {@link #p}{@code =0;}.
+	 * {@link #consume}). {@link #tokens}{@code [}{@link #p}{@code ]} should be
+	 * {@link #LT LT(1)}.
+	 *
+	 * <p>This field is set to -1 when the stream is first constructed or when
+	 * {@link #setTokenSource} is called, indicating that the first token has
+	 * not yet been fetched from the token source. For additional information,
+	 * see the documentation of {@link IntStream} for a description of
+	 * Initializing Methods.</p>
 	 */
     protected int p = -1;
 
 	/**
-	 * Set to {@code true} when the EOF token is fetched. Do not continue fetching
-	 * tokens after that point, or multiple EOF tokens could end up in the
-	 * {@link #tokens} array.
+	 * Indicates whether the {@link Token#EOF} token has been fetched from
+	 * {@link #tokenSource} and added to {@link #tokens}. This field improves
+	 * performance for the following cases:
 	 *
-	 * @see #fetch
+	 * <ul>
+	 * <li>{@link #consume}: The lookahead check in {@link #consume} to prevent
+	 * consuming the EOF symbol is optimized by checking the values of
+	 * {@link #fetchedEOF} and {@link #p} instead of calling {@link #LA}.</li>
+	 * <li>{@link #fetch}: The check to prevent adding multiple EOF symbols into
+	 * {@link #tokens} is trivial with this field.</li>
+	 * <ul>
 	 */
 	protected boolean fetchedEOF;
 
@@ -119,7 +128,24 @@ public class BufferedTokenStream implements TokenStream {
 
     @Override
     public void consume() {
-		if (LA(1) == EOF) {
+		boolean skipEofCheck;
+		if (p >= 0) {
+			if (fetchedEOF) {
+				// the last token in tokens is EOF. skip check if p indexes any
+				// fetched token except the last.
+				skipEofCheck = p < tokens.size() - 1;
+			}
+			else {
+				// no EOF token in tokens. skip check if p indexes a fetched token.
+				skipEofCheck = p < tokens.size();
+			}
+		}
+		else {
+			// not yet initialized
+			skipEofCheck = false;
+		}
+
+		if (!skipEofCheck && LA(1) == EOF) {
 			throw new IllegalStateException("cannot consume EOF");
 		}
 
@@ -200,6 +226,7 @@ public class BufferedTokenStream implements TokenStream {
         return tokens.get(p-k);
     }
 
+
     @Override
     public Token LT(int k) {
         lazyInit();
@@ -222,9 +249,9 @@ public class BufferedTokenStream implements TokenStream {
 	 * operation. The default implementation simply returns {@code i}. If an
 	 * exception is thrown in this method, the current stream index should not be
 	 * changed.
-	 * <p/>
-	 * For example, {@link CommonTokenStream} overrides this method to ensure that
-	 * the seek target is always an on-channel token.
+	 *
+	 * <p>For example, {@link CommonTokenStream} overrides this method to ensure that
+	 * the seek target is always an on-channel token.</p>
 	 *
 	 * @param i The target token index.
 	 * @return The adjusted target token index.
@@ -291,31 +318,58 @@ public class BufferedTokenStream implements TokenStream {
 		return getTokens(start,stop, s);
     }
 
-	/** Given a starting index, return the index of the next token on channel.
-	 *  Return i if tokens[i] is on channel.  Return -1 if there are no tokens
-	 *  on channel between i and EOF.
+	/**
+	 * Given a starting index, return the index of the next token on channel.
+	 * Return {@code i} if {@code tokens[i]} is on channel. Return the index of
+	 * the EOF token if there are no tokens on channel between {@code i} and
+	 * EOF.
 	 */
 	protected int nextTokenOnChannel(int i, int channel) {
 		sync(i);
+		if (i >= size()) {
+			return size() - 1;
+		}
+
 		Token token = tokens.get(i);
-		if ( i>=size() ) return -1;
 		while ( token.getChannel()!=channel ) {
-			if ( token.getType()==Token.EOF ) return -1;
+			if ( token.getType()==Token.EOF ) {
+				return i;
+			}
+
 			i++;
 			sync(i);
 			token = tokens.get(i);
 		}
+
 		return i;
 	}
 
-	/** Given a starting index, return the index of the previous token on channel.
-	 *  Return i if tokens[i] is on channel. Return -1 if there are no tokens
-	 *  on channel between i and 0.
+	/**
+	 * Given a starting index, return the index of the previous token on
+	 * channel. Return {@code i} if {@code tokens[i]} is on channel. Return -1
+	 * if there are no tokens on channel between {@code i} and 0.
+	 *
+	 * <p>
+	 * If {@code i} specifies an index at or after the EOF token, the EOF token
+	 * index is returned. This is due to the fact that the EOF token is treated
+	 * as though it were on every channel.</p>
 	 */
 	protected int previousTokenOnChannel(int i, int channel) {
-		while ( i>=0 && tokens.get(i).getChannel()!=channel ) {
+		sync(i);
+		if (i >= size()) {
+			// the EOF token is on every channel
+			return size() - 1;
+		}
+
+		while (i >= 0) {
+			Token token = tokens.get(i);
+			if (token.getType() == Token.EOF || token.getChannel() == channel) {
+				return i;
+			}
+
 			i--;
 		}
+
 		return i;
 	}
 
@@ -358,6 +412,11 @@ public class BufferedTokenStream implements TokenStream {
 			throw new IndexOutOfBoundsException(tokenIndex+" not in 0.."+(tokens.size()-1));
 		}
 
+		if (tokenIndex == 0) {
+			// obviously no tokens can appear before the first token
+			return null;
+		}
+
 		int prevOnChannel =
 			previousTokenOnChannel(tokenIndex - 1, Lexer.DEFAULT_TOKEN_CHANNEL);
 		if ( prevOnChannel == tokenIndex - 1 ) return null;
@@ -394,7 +453,7 @@ public class BufferedTokenStream implements TokenStream {
     public String getSourceName() {	return tokenSource.getSourceName();	}
 
 	/** Get the text of all tokens in this buffer. */
-	@NotNull
+
 	@Override
 	public String getText() {
         lazyInit();
@@ -402,7 +461,7 @@ public class BufferedTokenStream implements TokenStream {
 		return getText(Interval.of(0,size()-1));
 	}
 
-	@NotNull
+
     @Override
     public String getText(Interval interval) {
 		int start = interval.a;
@@ -420,13 +479,13 @@ public class BufferedTokenStream implements TokenStream {
 		return buf.toString();
     }
 
-	@NotNull
+
 	@Override
 	public String getText(RuleContext ctx) {
 		return getText(ctx.getSourceInterval());
 	}
 
-	@NotNull
+
     @Override
     public String getText(Token start, Token stop) {
         if ( start!=null && stop!=null ) {
diff --git a/runtime/Java/src/org/antlr/v4/runtime/CharStream.java b/runtime/Java/src/org/antlr/v4/runtime/CharStream.java
index c7b55a80c..5814fcf94 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/CharStream.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/CharStream.java
@@ -31,7 +31,6 @@
 package org.antlr.v4.runtime;
 
 import org.antlr.v4.runtime.misc.Interval;
-import org.antlr.v4.runtime.misc.NotNull;
 
 /** A source of characters for an ANTLR lexer. */
 public interface CharStream extends IntStream {
@@ -51,6 +50,5 @@ public interface CharStream extends IntStream {
 	 * @throws UnsupportedOperationException if the stream does not support
 	 * getting the text of the specified interval
 	 */
-	@NotNull
-	public String getText(@NotNull Interval interval);
+	public String getText(Interval interval);
 }
diff --git a/runtime/Java/src/org/antlr/v4/runtime/CommonToken.java b/runtime/Java/src/org/antlr/v4/runtime/CommonToken.java
index 66460b666..d552a1ba5 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/CommonToken.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/CommonToken.java
@@ -30,42 +30,90 @@
 package org.antlr.v4.runtime;
 
 import org.antlr.v4.runtime.misc.Interval;
-import org.antlr.v4.runtime.misc.NotNull;
 import org.antlr.v4.runtime.misc.Pair;
 
 import java.io.Serializable;
 
 public class CommonToken implements WritableToken, Serializable {
+	/**
+	 * An empty {@link Pair} which is used as the default value of
+	 * {@link #source} for tokens that do not have a source.
+	 */
 	protected static final Pair<TokenSource, CharStream> EMPTY_SOURCE =
 		new Pair<TokenSource, CharStream>(null, null);
 
+	/**
+	 * This is the backing field for {@link #getType} and {@link #setType}.
+	 */
 	protected int type;
+
+	/**
+	 * This is the backing field for {@link #getLine} and {@link #setLine}.
+	 */
 	protected int line;
+
+	/**
+	 * This is the backing field for {@link #getCharPositionInLine} and
+	 * {@link #setCharPositionInLine}.
+	 */
 	protected int charPositionInLine = -1; // set to invalid position
+
+	/**
+	 * This is the backing field for {@link #getChannel} and
+	 * {@link #setChannel}.
+	 */
 	protected int channel=DEFAULT_CHANNEL;
+
+	/**
+	 * This is the backing field for {@link #getTokenSource} and
+	 * {@link #getInputStream}.
+	 *
+	 * <p>
+	 * These properties share a field to reduce the memory footprint of
+	 * {@link CommonToken}. Tokens created by a {@link CommonTokenFactory} from
+	 * the same source and input stream share a reference to the same
+	 * {@link Pair} containing these values.</p>
+	 */
+
 	protected Pair<TokenSource, CharStream> source;
 
-	/** We need to be able to change the text once in a while.  If
-	 *  this is non-null, then getText should return this.  Note that
-	 *  start/stop are not affected by changing this.
-	  */
-	// TODO: can store these in map in token stream rather than as field here
+	/**
+	 * This is the backing field for {@link #getText} when the token text is
+	 * explicitly set in the constructor or via {@link #setText}.
+	 *
+	 * @see #getText()
+	 */
 	protected String text;
 
-	/** What token number is this from 0..n-1 tokens; < 0 implies invalid index */
+	/**
+	 * This is the backing field for {@link #getTokenIndex} and
+	 * {@link #setTokenIndex}.
+	 */
 	protected int index = -1;
 
-	/** The char position into the input buffer where this token starts */
+	/**
+	 * This is the backing field for {@link #getStartIndex} and
+	 * {@link #setStartIndex}.
+	 */
 	protected int start;
 
-	/** The char position into the input buffer where this token stops */
+	/**
+	 * This is the backing field for {@link #getStopIndex} and
+	 * {@link #setStopIndex}.
+	 */
 	protected int stop;
 
+	/**
+	 * Constructs a new {@link CommonToken} with the specified token type.
+	 *
+	 * @param type The token type.
+	 */
 	public CommonToken(int type) {
 		this.type = type;
+		this.source = EMPTY_SOURCE;
 	}
 
-	public CommonToken(@NotNull Pair<TokenSource, CharStream> source, int type, int channel, int start, int stop) {
+	public CommonToken(Pair<TokenSource, CharStream> source, int type, int channel, int start, int stop) {
 		this.source = source;
 		this.type = type;
 		this.channel = channel;
@@ -77,6 +125,13 @@ public class CommonToken implements WritableToken, Serializable {
 		}
 	}
 
+	/**
+	 * Constructs a new {@link CommonToken} with the specified token type and
+	 * text.
+	 *
+	 * @param type The token type.
+	 * @param text The text of the token.
+	 */
 	public CommonToken(int type, String text) {
 		this.type = type;
 		this.channel = DEFAULT_CHANNEL;
@@ -84,8 +139,20 @@ public class CommonToken implements WritableToken, Serializable {
 		this.source = EMPTY_SOURCE;
 	}
 
+	/**
+	 * Constructs a new {@link CommonToken} as a copy of another {@link Token}.
+	 *
+	 * <p>
+	 * If {@code oldToken} is also a {@link CommonToken} instance, the newly
+	 * constructed token will share a reference to the {@link #text} field and
+	 * the {@link Pair} stored in {@link #source}. Otherwise, {@link #text} will
+	 * be assigned the result of calling {@link #getText}, and {@link #source}
+	 * will be constructed from the result of {@link Token#getTokenSource} and
+	 * {@link Token#getInputStream}.</p>
+	 *
+	 * @param oldToken The token to copy.
+	 */
 	public CommonToken(Token oldToken) {
-		text = oldToken.getText();
 		type = oldToken.getType();
 		line = oldToken.getLine();
 		index = oldToken.getTokenIndex();
@@ -95,9 +162,11 @@ public class CommonToken implements WritableToken, Serializable {
 		stop = oldToken.getStopIndex();
 
 		if (oldToken instanceof CommonToken) {
+			text = ((CommonToken)oldToken).text;
 			source = ((CommonToken)oldToken).source;
 		}
 		else {
+			text = oldToken.getText();
 			source = new Pair<TokenSource, CharStream>(oldToken.getTokenSource(), oldToken.getInputStream());
 		}
 	}
@@ -129,10 +198,14 @@ public class CommonToken implements WritableToken, Serializable {
 		}
 	}
 
-	/** Override the text for this token.  getText() will return this text
-	 *  rather than pulling from the buffer.  Note that this does not mean
-	 *  that start/stop indexes are not valid.  It means that that input
-	 *  was converted to a new string in the token object.
+	/**
+	 * Explicitly set the text for this token. If {code text} is not
+	 * {@code null}, then {@link #getText} will return this value rather than
+	 * extracting the text from the input.
+	 *
+	 * @param text The explicit text of the token, or {@code null} if the text
+	 * should be obtained from the input along with the start and stop indexes
+	 * of the token.
 	 */
 	@Override
 	public void setText(String text) {
diff --git a/runtime/Java/src/org/antlr/v4/runtime/CommonTokenFactory.java b/runtime/Java/src/org/antlr/v4/runtime/CommonTokenFactory.java
index b646a5de8..bb764d46b 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/CommonTokenFactory.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/CommonTokenFactory.java
@@ -33,20 +33,57 @@ package org.antlr.v4.runtime;
 import org.antlr.v4.runtime.misc.Interval;
 import org.antlr.v4.runtime.misc.Pair;
 
+/**
+ * This default implementation of {@link TokenFactory} creates
+ * {@link CommonToken} objects.
+ */
 public class CommonTokenFactory implements TokenFactory<CommonToken> {
+	/**
+	 * The default {@link CommonTokenFactory} instance.
+	 *
+	 * <p>
+	 * This token factory does not explicitly copy token text when constructing
+	 * tokens.</p>
+	 */
 	public static final TokenFactory<CommonToken> DEFAULT = new CommonTokenFactory();
 
-	/** Copy text for token out of input char stream. Useful when input
-	 *  stream is unbuffered.
-	 *  @see UnbufferedCharStream
- 	 */
+	/**
+	 * Indicates whether {@link CommonToken#setText} should be called after
+	 * constructing tokens to explicitly set the text. This is useful for cases
+	 * where the input stream might not be able to provide arbitrary substrings
+	 * of text from the input after the lexer creates a token (e.g. the
+	 * implementation of {@link CharStream#getText} in
+	 * {@link UnbufferedCharStream} throws an
+	 * {@link UnsupportedOperationException}). Explicitly setting the token text
+	 * allows {@link Token#getText} to be called at any time regardless of the
+	 * input stream implementation.
+	 *
+	 * <p>
+	 * The default value is {@code false} to avoid the performance and memory
+	 * overhead of copying text for every token unless explicitly requested.</p>
+	 */
 	protected final boolean copyText;
 
-	/** Create factory and indicate whether or not the factory copy
-	 *  text out of the char stream.
+	/**
+	 * Constructs a {@link CommonTokenFactory} with the specified value for
+	 * {@link #copyText}.
+	 *
+	 * <p>
+	 * When {@code copyText} is {@code false}, the {@link #DEFAULT} instance
+	 * should be used instead of constructing a new instance.</p>
+	 *
+	 * @param copyText The value for {@link #copyText}.
 	 */
 	public CommonTokenFactory(boolean copyText) { this.copyText = copyText; }
 
+	/**
+	 * Constructs a {@link CommonTokenFactory} with {@link #copyText} set to
+	 * {@code false}.
+	 *
+	 * <p>
+	 * The {@link #DEFAULT} instance should be used instead of calling this
+	 * directly.</p>
+	 */
 	public CommonTokenFactory() { this(false); }
 
 	@Override
diff --git a/runtime/Java/src/org/antlr/v4/runtime/CommonTokenStream.java b/runtime/Java/src/org/antlr/v4/runtime/CommonTokenStream.java
index b5cc25a82..ea85afcd7 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/CommonTokenStream.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/CommonTokenStream.java
@@ -30,31 +30,60 @@
 
 package org.antlr.v4.runtime;
 
-/** The most common stream of tokens where every token is buffered up
- *  and tokens are filtered for a certain channel (the parser will only
- *  see these tokens).
+/**
+ * This class extends {@link BufferedTokenStream} with functionality to filter
+ * token streams to tokens on a particular channel (tokens where
+ * {@link Token#getChannel} returns a particular value).
  *
- *  Even though it buffers all of the tokens, this token stream pulls tokens
- *  from the tokens source on demand. In other words, until you ask for a
- *  token using consume(), LT(), etc. the stream does not pull from the lexer.
+ * <p>
+ * This token stream provides access to all tokens by index or when calling
+ * methods like {@link #getText}. The channel filtering is only used for code
+ * accessing tokens via the lookahead methods {@link #LA}, {@link #LT}, and
+ * {@link #LB}.</p>
  *
- *  The only difference between this stream and {@link BufferedTokenStream} superclass
- *  is that this stream knows how to ignore off channel tokens. There may be
- *  a performance advantage to using the superclass if you don't pass
- *  whitespace and comments etc. to the parser on a hidden channel (i.e.,
- *  you set {@code $channel} instead of calling {@code skip()} in lexer rules.)
+ * <p>
+ * By default, tokens are placed on the default channel
+ * ({@link Token#DEFAULT_CHANNEL}), but may be reassigned by using the
+ * {@code ->channel(HIDDEN)} lexer command, or by using an embedded action to
+ * call {@link Lexer#setChannel}.
+ * </p>
  *
- *  @see UnbufferedTokenStream
- *  @see BufferedTokenStream
+ * <p>
+ * Note: lexer rules which use the {@code ->skip} lexer command or call
+ * {@link Lexer#skip} do not produce tokens at all, so input text matched by
+ * such a rule will not be available as part of the token stream, regardless of
+ * channel.</p>
  */
 public class CommonTokenStream extends BufferedTokenStream {
-    /** Skip tokens on any channel but this one; this is how we skip whitespace... */
+	/**
+	 * Specifies the channel to use for filtering tokens.
+	 *
+	 * <p>
+	 * The default value is {@link Token#DEFAULT_CHANNEL}, which matches the
+	 * default channel assigned to tokens created by the lexer.</p>
+	 */
     protected int channel = Token.DEFAULT_CHANNEL;
 
+	/**
+	 * Constructs a new {@link CommonTokenStream} using the specified token
+	 * source and the default token channel ({@link Token#DEFAULT_CHANNEL}).
+	 *
+	 * @param tokenSource The token source.
+	 */
     public CommonTokenStream(TokenSource tokenSource) {
         super(tokenSource);
     }
 
+	/**
+	 * Constructs a new {@link CommonTokenStream} using the specified token
+	 * source and filtering tokens to the specified channel. Only tokens whose
+	 * {@link Token#getChannel} matches {@code channel} or have the
+	 * {@link Token#getType} equal to {@link Token#EOF} will be returned by the
+	 * token stream lookahead methods.
+	 *
+	 * @param tokenSource The token source.
+	 * @param channel The channel to use for filtering tokens.
+	 */
     public CommonTokenStream(TokenSource tokenSource, int channel) {
         this(tokenSource);
         this.channel = channel;
diff --git a/runtime/Java/src/org/antlr/v4/runtime/ConsoleErrorListener.java b/runtime/Java/src/org/antlr/v4/runtime/ConsoleErrorListener.java
index 0fd3323ce..b33dc2dfc 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/ConsoleErrorListener.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/ConsoleErrorListener.java
@@ -34,8 +34,23 @@ package org.antlr.v4.runtime;
  * @author Sam Harwell
  */
 public class ConsoleErrorListener extends BaseErrorListener {
+	/**
+	 * Provides a default instance of {@link ConsoleErrorListener}.
+	 */
 	public static final ConsoleErrorListener INSTANCE = new ConsoleErrorListener();
 
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>
+	 * This implementation prints messages to {@link System#err} containing the
+	 * values of {@code line}, {@code charPositionInLine}, and {@code msg} using
+	 * the following format.</p>
+	 *
+	 * <pre>
+	 * line <em>line</em>:<em>charPositionInLine</em> <em>msg</em>
+	 * </pre>
+	 */
 	@Override
 	public void syntaxError(Recognizer<?, ?> recognizer,
 							Object offendingSymbol,
diff --git a/runtime/Java/src/org/antlr/v4/runtime/DefaultErrorStrategy.java b/runtime/Java/src/org/antlr/v4/runtime/DefaultErrorStrategy.java
index 91bb1f661..4a7e69b57 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/DefaultErrorStrategy.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/DefaultErrorStrategy.java
@@ -34,17 +34,17 @@ import org.antlr.v4.runtime.atn.ATN;
 import org.antlr.v4.runtime.atn.ATNState;
 import org.antlr.v4.runtime.atn.RuleTransition;
 import org.antlr.v4.runtime.misc.IntervalSet;
-import org.antlr.v4.runtime.misc.NotNull;
-import org.antlr.v4.runtime.misc.Nullable;
 import org.antlr.v4.runtime.misc.Pair;
 
-/** This is the default error handling mechanism for ANTLR parsers
- *  and tree parsers.
+/**
+ * This is the default implementation of {@link ANTLRErrorStrategy} used for
+ * error reporting and recovery in ANTLR parsers.
  */
 public class DefaultErrorStrategy implements ANTLRErrorStrategy {
-	/** This is true after we see an error and before having successfully
-	 *  matched a token. Prevents generation of more than one error message
-	 *  per error.
+	/**
+	 * Indicates whether the error strategy is currently "recovering from an
+	 * error". This is used to suppress reporting multiple error messages while
+	 * attempting to recover from a detected syntax error.
 	 *
 	 * @see #inErrorRecoveryMode
 	 */
@@ -62,9 +62,9 @@ public class DefaultErrorStrategy implements ANTLRErrorStrategy {
 
 	/**
 	 * {@inheritDoc}
-	 * <p/>
-	 * The default implementation simply calls {@link #endErrorCondition} to
-	 * ensure that the handler is not in error recovery mode.
+	 *
+	 * <p>The default implementation simply calls {@link #endErrorCondition} to
+	 * ensure that the handler is not in error recovery mode.</p>
 	 */
 	@Override
 	public void reset(Parser recognizer) {
@@ -77,7 +77,7 @@ public class DefaultErrorStrategy implements ANTLRErrorStrategy {
 	 *
 	 * @param recognizer the parser instance
 	 */
-	protected void beginErrorCondition(@NotNull Parser recognizer) {
+	protected void beginErrorCondition(Parser recognizer) {
 		errorRecoveryMode = true;
 	}
 
@@ -95,7 +95,7 @@ public class DefaultErrorStrategy implements ANTLRErrorStrategy {
 	 *
 	 * @param recognizer
 	 */
-	protected void endErrorCondition(@NotNull Parser recognizer) {
+	protected void endErrorCondition(Parser recognizer) {
 		errorRecoveryMode = false;
 		lastErrorStates = null;
 		lastErrorIndex = -1;
@@ -103,8 +103,8 @@ public class DefaultErrorStrategy implements ANTLRErrorStrategy {
 
 	/**
 	 * {@inheritDoc}
-	 * <p/>
-	 * The default implementation simply calls {@link #endErrorCondition}.
+	 *
+	 * <p>The default implementation simply calls {@link #endErrorCondition}.</p>
 	 */
 	@Override
 	public void reportMatch(Parser recognizer) {
@@ -113,11 +113,11 @@ public class DefaultErrorStrategy implements ANTLRErrorStrategy {
 
 	/**
 	 * {@inheritDoc}
-	 * <p/>
-	 * The default implementation returns immediately if the handler is already
+	 *
+	 * <p>The default implementation returns immediately if the handler is already
 	 * in error recovery mode. Otherwise, it calls {@link #beginErrorCondition}
 	 * and dispatches the reporting task based on the runtime type of {@code e}
-	 * according to the following table.
+	 * according to the following table.</p>
 	 *
 	 * <ul>
 	 * <li>{@link NoViableAltException}: Dispatches the call to
@@ -158,10 +158,10 @@ public class DefaultErrorStrategy implements ANTLRErrorStrategy {
 
 	/**
 	 * {@inheritDoc}
-	 * <p/>
-	 * The default implementation resynchronizes the parser by consuming tokens
+	 *
+	 * <p>The default implementation resynchronizes the parser by consuming tokens
 	 * until we find one in the resynchronization set--loosely the set of tokens
-	 * that can follow the current rule.
+	 * that can follow the current rule.</p>
 	 */
 	@Override
 	public void recover(Parser recognizer, RecognitionException e) {
@@ -194,9 +194,9 @@ public class DefaultErrorStrategy implements ANTLRErrorStrategy {
 	 * that the current lookahead symbol is consistent with what were expecting
 	 * at this point in the ATN. You can call this anytime but ANTLR only
 	 * generates code to check before subrules/loops and each iteration.
-	 * <p/>
-	 * Implements Jim Idle's magic sync mechanism in closures and optional
-	 * subrules. E.g.,
+	 *
+	 * <p>Implements Jim Idle's magic sync mechanism in closures and optional
+	 * subrules. E.g.,</p>
 	 *
 	 * <pre>
 	 * a : sync ( stuff sync )* ;
@@ -207,20 +207,20 @@ public class DefaultErrorStrategy implements ANTLRErrorStrategy {
 	 * token deletion, if possible. If it can't do that, it bails on the current
 	 * rule and uses the default error recovery, which consumes until the
 	 * resynchronization set of the current rule.
-	 * <p/>
-	 * If the sub rule is optional ({@code (...)?}, {@code (...)*}, or block
+	 *
+	 * <p>If the sub rule is optional ({@code (...)?}, {@code (...)*}, or block
 	 * with an empty alternative), then the expected set includes what follows
-	 * the subrule.
-	 * <p/>
-	 * During loop iteration, it consumes until it sees a token that can start a
+	 * the subrule.</p>
+	 *
+	 * <p>During loop iteration, it consumes until it sees a token that can start a
 	 * sub rule or what follows loop. Yes, that is pretty aggressive. We opt to
-	 * stay in the loop as long as possible.
-	 * <p/>
-	 * <strong>ORIGINS</strong>
-	 * <p/>
-	 * Previous versions of ANTLR did a poor job of their recovery within loops.
+	 * stay in the loop as long as possible.</p>
+	 *
+	 * <p><strong>ORIGINS</strong></p>
+	 *
+	 * <p>Previous versions of ANTLR did a poor job of their recovery within loops.
 	 * A single mismatch token or missing token would force the parser to bail
-	 * out of the entire rules surrounding the loop. So, for rule
+	 * out of the entire rules surrounding the loop. So, for rule</p>
 	 *
 	 * <pre>
 	 * classDef : 'class' ID '{' member* '}'
@@ -229,11 +229,11 @@ public class DefaultErrorStrategy implements ANTLRErrorStrategy {
 	 * input with an extra token between members would force the parser to
 	 * consume until it found the next class definition rather than the next
 	 * member definition of the current class.
-	 * <p/>
-	 * This functionality cost a little bit of effort because the parser has to
+	 *
+	 * <p>This functionality cost a little bit of effort because the parser has to
 	 * compare token set at the start of the loop and at each iteration. If for
 	 * some reason speed is suffering for you, you can turn off this
-	 * functionality by simply overriding this method as a blank { }.
+	 * functionality by simply overriding this method as a blank { }.</p>
 	 */
 	@Override
 	public void sync(Parser recognizer) throws RecognitionException {
@@ -292,8 +292,8 @@ public class DefaultErrorStrategy implements ANTLRErrorStrategy {
 	 * @param recognizer the parser instance
 	 * @param e the recognition exception
 	 */
-	protected void reportNoViableAlternative(@NotNull Parser recognizer,
-											 @NotNull NoViableAltException e)
+	protected void reportNoViableAlternative(Parser recognizer,
+											 NoViableAltException e)
 	{
 		TokenStream tokens = recognizer.getInputStream();
 		String input;
@@ -317,11 +317,11 @@ public class DefaultErrorStrategy implements ANTLRErrorStrategy {
 	 * @param recognizer the parser instance
 	 * @param e the recognition exception
 	 */
-	protected void reportInputMismatch(@NotNull Parser recognizer,
-									   @NotNull InputMismatchException e)
+	protected void reportInputMismatch(Parser recognizer,
+									   InputMismatchException e)
 	{
 		String msg = "mismatched input "+getTokenErrorDisplay(e.getOffendingToken())+
-		" expecting "+e.getExpectedTokens().toString(recognizer.getTokenNames());
+		" expecting "+e.getExpectedTokens().toString(recognizer.getVocabulary());
 		recognizer.notifyErrorListeners(e.getOffendingToken(), msg, e);
 	}
 
@@ -334,8 +334,8 @@ public class DefaultErrorStrategy implements ANTLRErrorStrategy {
 	 * @param recognizer the parser instance
 	 * @param e the recognition exception
 	 */
-	protected void reportFailedPredicate(@NotNull Parser recognizer,
-										 @NotNull FailedPredicateException e)
+	protected void reportFailedPredicate(Parser recognizer,
+										 FailedPredicateException e)
 	{
 		String ruleName = recognizer.getRuleNames()[recognizer._ctx.getRuleIndex()];
 		String msg = "rule "+ruleName+" "+e.getMessage();
@@ -348,19 +348,19 @@ public class DefaultErrorStrategy implements ANTLRErrorStrategy {
 	 * erroneous symbol is current {@code LT(1)} symbol and has not yet been
 	 * removed from the input stream. When this method returns,
 	 * {@code recognizer} is in error recovery mode.
-	 * <p/>
-	 * This method is called when {@link #singleTokenDeletion} identifies
+	 *
+	 * <p>This method is called when {@link #singleTokenDeletion} identifies
 	 * single-token deletion as a viable recovery strategy for a mismatched
-	 * input error.
-	 * <p/>
-	 * The default implementation simply returns if the handler is already in
+	 * input error.</p>
+	 *
+	 * <p>The default implementation simply returns if the handler is already in
 	 * error recovery mode. Otherwise, it calls {@link #beginErrorCondition} to
 	 * enter error recovery mode, followed by calling
-	 * {@link Parser#notifyErrorListeners}.
+	 * {@link Parser#notifyErrorListeners}.</p>
 	 *
 	 * @param recognizer the parser instance
 	 */
-	protected void reportUnwantedToken(@NotNull Parser recognizer) {
+	protected void reportUnwantedToken(Parser recognizer) {
 		if (inErrorRecoveryMode(recognizer)) {
 			return;
 		}
@@ -371,7 +371,7 @@ public class DefaultErrorStrategy implements ANTLRErrorStrategy {
 		String tokenName = getTokenErrorDisplay(t);
 		IntervalSet expecting = getExpectedTokens(recognizer);
 		String msg = "extraneous input "+tokenName+" expecting "+
-			expecting.toString(recognizer.getTokenNames());
+			expecting.toString(recognizer.getVocabulary());
 		recognizer.notifyErrorListeners(t, msg, null);
 	}
 
@@ -380,19 +380,19 @@ public class DefaultErrorStrategy implements ANTLRErrorStrategy {
 	 * insertion of a missing token into the input stream. At the time this
 	 * method is called, the missing token has not yet been inserted. When this
 	 * method returns, {@code recognizer} is in error recovery mode.
-	 * <p/>
-	 * This method is called when {@link #singleTokenInsertion} identifies
+	 *
+	 * <p>This method is called when {@link #singleTokenInsertion} identifies
 	 * single-token insertion as a viable recovery strategy for a mismatched
-	 * input error.
-	 * <p/>
-	 * The default implementation simply returns if the handler is already in
+	 * input error.</p>
+	 *
+	 * <p>The default implementation simply returns if the handler is already in
 	 * error recovery mode. Otherwise, it calls {@link #beginErrorCondition} to
 	 * enter error recovery mode, followed by calling
-	 * {@link Parser#notifyErrorListeners}.
+	 * {@link Parser#notifyErrorListeners}.</p>
 	 *
 	 * @param recognizer the parser instance
 	 */
-	protected void reportMissingToken(@NotNull Parser recognizer) {
+	protected void reportMissingToken(Parser recognizer) {
 		if (inErrorRecoveryMode(recognizer)) {
 			return;
 		}
@@ -401,7 +401,7 @@ public class DefaultErrorStrategy implements ANTLRErrorStrategy {
 
 		Token t = recognizer.getCurrentToken();
 		IntervalSet expecting = getExpectedTokens(recognizer);
-		String msg = "missing "+expecting.toString(recognizer.getTokenNames())+
+		String msg = "missing "+expecting.toString(recognizer.getVocabulary())+
 			" at "+getTokenErrorDisplay(t);
 
 		recognizer.notifyErrorListeners(t, msg, null);
@@ -409,46 +409,46 @@ public class DefaultErrorStrategy implements ANTLRErrorStrategy {
 
 	/**
 	 * {@inheritDoc}
-	 * <p/>
-	 * The default implementation attempts to recover from the mismatched input
+	 *
+	 * <p>The default implementation attempts to recover from the mismatched input
 	 * by using single token insertion and deletion as described below. If the
 	 * recovery attempt fails, this method throws an
-	 * {@link InputMismatchException}.
-	 * <p/>
-	 * <strong>EXTRA TOKEN</strong> (single token deletion)
-	 * <p/>
-	 * {@code LA(1)} is not what we are looking for. If {@code LA(2)} has the
+	 * {@link InputMismatchException}.</p>
+	 *
+	 * <p><strong>EXTRA TOKEN</strong> (single token deletion)</p>
+	 *
+	 * <p>{@code LA(1)} is not what we are looking for. If {@code LA(2)} has the
 	 * right token, however, then assume {@code LA(1)} is some extra spurious
 	 * token and delete it. Then consume and return the next token (which was
-	 * the {@code LA(2)} token) as the successful result of the match operation.
-	 * <p/>
-	 * This recovery strategy is implemented by {@link #singleTokenDeletion}.
-	 * <p/>
-	 * <strong>MISSING TOKEN</strong> (single token insertion)
-	 * <p/>
-	 * If current token (at {@code LA(1)}) is consistent with what could come
+	 * the {@code LA(2)} token) as the successful result of the match operation.</p>
+	 *
+	 * <p>This recovery strategy is implemented by {@link #singleTokenDeletion}.</p>
+	 *
+	 * <p><strong>MISSING TOKEN</strong> (single token insertion)</p>
+	 *
+	 * <p>If current token (at {@code LA(1)}) is consistent with what could come
 	 * after the expected {@code LA(1)} token, then assume the token is missing
 	 * and use the parser's {@link TokenFactory} to create it on the fly. The
 	 * "insertion" is performed by returning the created token as the successful
-	 * result of the match operation.
-	 * <p/>
-	 * This recovery strategy is implemented by {@link #singleTokenInsertion}.
-	 * <p/>
-	 * <strong>EXAMPLE</strong>
-	 * <p/>
-	 * For example, Input {@code i=(3;} is clearly missing the {@code ')'}. When
+	 * result of the match operation.</p>
+	 *
+	 * <p>This recovery strategy is implemented by {@link #singleTokenInsertion}.</p>
+	 *
+	 * <p><strong>EXAMPLE</strong></p>
+	 *
+	 * <p>For example, Input {@code i=(3;} is clearly missing the {@code ')'}. When
 	 * the parser returns from the nested call to {@code expr}, it will have
-	 * call chain:
+	 * call chain:</p>
 	 *
 	 * <pre>
-	 * stat -> expr -> atom
+	 * stat &rarr; expr &rarr; atom
 	 * </pre>
 	 *
 	 * and it will be trying to match the {@code ')'} at this point in the
 	 * derivation:
 	 *
 	 * <pre>
-	 * => ID '=' '(' INT ')' ('+' atom)* ';'
+	 * =&gt; ID '=' '(' INT ')' ('+' atom)* ';'
 	 *                    ^
 	 * </pre>
 	 *
@@ -485,18 +485,18 @@ public class DefaultErrorStrategy implements ANTLRErrorStrategy {
 	 * deletion strategy fails to recover from the mismatched input. If this
 	 * method returns {@code true}, {@code recognizer} will be in error recovery
 	 * mode.
-	 * <p/>
-	 * This method determines whether or not single-token insertion is viable by
+	 *
+	 * <p>This method determines whether or not single-token insertion is viable by
 	 * checking if the {@code LA(1)} input symbol could be successfully matched
 	 * if it were instead the {@code LA(2)} symbol. If this method returns
 	 * {@code true}, the caller is responsible for creating and inserting a
-	 * token with the correct type to produce this behavior.
+	 * token with the correct type to produce this behavior.</p>
 	 *
 	 * @param recognizer the parser instance
 	 * @return {@code true} if single-token insertion is a viable recovery
 	 * strategy for the current mismatched input, otherwise {@code false}
 	 */
-	protected boolean singleTokenInsertion(@NotNull Parser recognizer) {
+	protected boolean singleTokenInsertion(Parser recognizer) {
 		int currentSymbolType = recognizer.getInputStream().LA(1);
 		// if current token is consistent with what could come after current
 		// ATN state, then we know we're missing a token; error recovery
@@ -520,20 +520,19 @@ public class DefaultErrorStrategy implements ANTLRErrorStrategy {
 	 * handler state will not have changed. If this method returns non-null,
 	 * {@code recognizer} will <em>not</em> be in error recovery mode since the
 	 * returned token was a successful match.
-	 * <p/>
-	 * If the single-token deletion is successful, this method calls
+	 *
+	 * <p>If the single-token deletion is successful, this method calls
 	 * {@link #reportUnwantedToken} to report the error, followed by
 	 * {@link Parser#consume} to actually "delete" the extraneous token. Then,
 	 * before returning {@link #reportMatch} is called to signal a successful
-	 * match.
+	 * match.</p>
 	 *
 	 * @param recognizer the parser instance
 	 * @return the successfully matched {@link Token} instance if single-token
 	 * deletion successfully recovers from the mismatched input, otherwise
 	 * {@code null}
 	 */
-	@Nullable
-	protected Token singleTokenDeletion(@NotNull Parser recognizer) {
+	protected Token singleTokenDeletion(Parser recognizer) {
 		int nextTokenType = recognizer.getInputStream().LA(2);
 		IntervalSet expecting = getExpectedTokens(recognizer);
 		if ( expecting.contains(nextTokenType) ) {
@@ -572,14 +571,13 @@ public class DefaultErrorStrategy implements ANTLRErrorStrategy {
 	 *  If you change what tokens must be created by the lexer,
 	 *  override this method to create the appropriate tokens.
 	 */
-	@NotNull
-	protected Token getMissingSymbol(@NotNull Parser recognizer) {
+	protected Token getMissingSymbol(Parser recognizer) {
 		Token currentSymbol = recognizer.getCurrentToken();
 		IntervalSet expecting = getExpectedTokens(recognizer);
 		int expectedTokenType = expecting.getMinElement(); // get any element
 		String tokenText;
 		if ( expectedTokenType== Token.EOF ) tokenText = "<missing EOF>";
-		else tokenText = "<missing "+recognizer.getTokenNames()[expectedTokenType]+">";
+		else tokenText = "<missing "+recognizer.getVocabulary().getDisplayName(expectedTokenType)+">";
 		Token current = currentSymbol;
 		Token lookback = recognizer.getInputStream().LT(-1);
 		if ( current.getType() == Token.EOF && lookback!=null ) {
@@ -592,8 +590,8 @@ public class DefaultErrorStrategy implements ANTLRErrorStrategy {
 							current.getLine(), current.getCharPositionInLine());
 	}
 
-	@NotNull
-	protected IntervalSet getExpectedTokens(@NotNull Parser recognizer) {
+
+	protected IntervalSet getExpectedTokens(Parser recognizer) {
 		return recognizer.getExpectedTokens();
 	}
 
@@ -619,16 +617,16 @@ public class DefaultErrorStrategy implements ANTLRErrorStrategy {
 		return escapeWSAndQuote(s);
 	}
 
-	protected String getSymbolText(@NotNull Token symbol) {
+	protected String getSymbolText(Token symbol) {
 		return symbol.getText();
 	}
 
-	protected int getSymbolType(@NotNull Token symbol) {
+	protected int getSymbolType(Token symbol) {
 		return symbol.getType();
 	}
 
-	@NotNull
-	protected String escapeWSAndQuote(@NotNull String s) {
+
+	protected String escapeWSAndQuote(String s) {
 //		if ( s==null ) return s;
 		s = s.replace("\n","\\n");
 		s = s.replace("\r","\\r");
@@ -728,8 +726,7 @@ public class DefaultErrorStrategy implements ANTLRErrorStrategy {
 	 *  Like Grosch I implement context-sensitive FOLLOW sets that are combined
 	 *  at run-time upon error to avoid overhead during parsing.
 	 */
-	@NotNull
-	protected IntervalSet getErrorRecoverySet(@NotNull Parser recognizer) {
+	protected IntervalSet getErrorRecoverySet(Parser recognizer) {
 		ATN atn = recognizer.getInterpreter().atn;
 		RuleContext ctx = recognizer._ctx;
 		IntervalSet recoverSet = new IntervalSet();
@@ -747,7 +744,7 @@ public class DefaultErrorStrategy implements ANTLRErrorStrategy {
 	}
 
 	/** Consume tokens until one matches the given token set. */
-	protected void consumeUntil(@NotNull Parser recognizer, @NotNull IntervalSet set) {
+	protected void consumeUntil(Parser recognizer, IntervalSet set) {
 //		System.err.println("consumeUntil("+set.toString(recognizer.getTokenNames())+")");
 		int ttype = recognizer.getInputStream().LA(1);
 		while (ttype != Token.EOF && !set.contains(ttype) ) {
diff --git a/runtime/Java/src/org/antlr/v4/runtime/DiagnosticErrorListener.java b/runtime/Java/src/org/antlr/v4/runtime/DiagnosticErrorListener.java
index 79c84549f..c0d94d977 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/DiagnosticErrorListener.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/DiagnosticErrorListener.java
@@ -34,8 +34,6 @@ import org.antlr.v4.runtime.atn.ATNConfig;
 import org.antlr.v4.runtime.atn.ATNConfigSet;
 import org.antlr.v4.runtime.dfa.DFA;
 import org.antlr.v4.runtime.misc.Interval;
-import org.antlr.v4.runtime.misc.NotNull;
-import org.antlr.v4.runtime.misc.Nullable;
 
 import java.util.BitSet;
 
@@ -86,13 +84,13 @@ public class DiagnosticErrorListener extends BaseErrorListener {
 	}
 
 	@Override
-	public void reportAmbiguity(@NotNull Parser recognizer,
+	public void reportAmbiguity(Parser recognizer,
 								DFA dfa,
 								int startIndex,
 								int stopIndex,
 								boolean exact,
-								@Nullable BitSet ambigAlts,
-								@NotNull ATNConfigSet configs)
+								BitSet ambigAlts,
+								ATNConfigSet configs)
 	{
 		if (exactOnly && !exact) {
 			return;
@@ -107,12 +105,12 @@ public class DiagnosticErrorListener extends BaseErrorListener {
 	}
 
 	@Override
-	public void reportAttemptingFullContext(@NotNull Parser recognizer,
-											@NotNull DFA dfa,
+	public void reportAttemptingFullContext(Parser recognizer,
+											DFA dfa,
 											int startIndex,
 											int stopIndex,
-											@Nullable BitSet conflictingAlts,
-											@NotNull ATNConfigSet configs)
+											BitSet conflictingAlts,
+											ATNConfigSet configs)
 	{
 		String format = "reportAttemptingFullContext d=%s, input='%s'";
 		String decision = getDecisionDescription(recognizer, dfa);
@@ -122,12 +120,12 @@ public class DiagnosticErrorListener extends BaseErrorListener {
 	}
 
 	@Override
-	public void reportContextSensitivity(@NotNull Parser recognizer,
-										 @NotNull DFA dfa,
+	public void reportContextSensitivity(Parser recognizer,
+										 DFA dfa,
 										 int startIndex,
 										 int stopIndex,
 										 int prediction,
-										 @NotNull ATNConfigSet configs)
+										 ATNConfigSet configs)
 	{
 		String format = "reportContextSensitivity d=%s, input='%s'";
 		String decision = getDecisionDescription(recognizer, dfa);
@@ -136,7 +134,7 @@ public class DiagnosticErrorListener extends BaseErrorListener {
 		recognizer.notifyErrorListeners(message);
 	}
 
-	protected String getDecisionDescription(@NotNull Parser recognizer, @NotNull DFA dfa) {
+	protected String getDecisionDescription(Parser recognizer, DFA dfa) {
 		int decision = dfa.decision;
 		int ruleIndex = dfa.atnStartState.ruleIndex;
 
@@ -164,8 +162,7 @@ public class DiagnosticErrorListener extends BaseErrorListener {
 	 * @return Returns {@code reportedAlts} if it is not {@code null}, otherwise
 	 * returns the set of alternatives represented in {@code configs}.
 	 */
-	@NotNull
-	protected BitSet getConflictingAlts(@Nullable BitSet reportedAlts, @NotNull ATNConfigSet configs) {
+	protected BitSet getConflictingAlts(BitSet reportedAlts, ATNConfigSet configs) {
 		if (reportedAlts != null) {
 			return reportedAlts;
 		}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/FailedPredicateException.java b/runtime/Java/src/org/antlr/v4/runtime/FailedPredicateException.java
index 4cf42c0a7..71e03a400 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/FailedPredicateException.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/FailedPredicateException.java
@@ -32,8 +32,6 @@ package org.antlr.v4.runtime;
 import org.antlr.v4.runtime.atn.ATNState;
 import org.antlr.v4.runtime.atn.AbstractPredicateTransition;
 import org.antlr.v4.runtime.atn.PredicateTransition;
-import org.antlr.v4.runtime.misc.NotNull;
-import org.antlr.v4.runtime.misc.Nullable;
 
 import java.util.Locale;
 
@@ -47,17 +45,17 @@ public class FailedPredicateException extends RecognitionException {
 	private final int predicateIndex;
 	private final String predicate;
 
-	public FailedPredicateException(@NotNull Parser recognizer) {
+	public FailedPredicateException(Parser recognizer) {
 		this(recognizer, null);
 	}
 
-	public FailedPredicateException(@NotNull Parser recognizer, @Nullable String predicate) {
+	public FailedPredicateException(Parser recognizer, String predicate) {
 		this(recognizer, predicate, null);
 	}
 
-	public FailedPredicateException(@NotNull Parser recognizer,
-									@Nullable String predicate,
-									@Nullable String message)
+	public FailedPredicateException(Parser recognizer,
+									String predicate,
+									String message)
 	{
 		super(formatMessage(predicate, message), recognizer, recognizer.getInputStream(), recognizer._ctx);
 		ATNState s = recognizer.getInterpreter().atn.states.get(recognizer.getState());
@@ -84,13 +82,13 @@ public class FailedPredicateException extends RecognitionException {
 		return predicateIndex;
 	}
 
-	@Nullable
+
 	public String getPredicate() {
 		return predicate;
 	}
 
-	@NotNull
-	private static String formatMessage(@Nullable String predicate, @Nullable String message) {
+
+	private static String formatMessage(String predicate, String message) {
 		if (message != null) {
 			return message;
 		}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/InputMismatchException.java b/runtime/Java/src/org/antlr/v4/runtime/InputMismatchException.java
index a02b0d0db..ca2cefaff 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/InputMismatchException.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/InputMismatchException.java
@@ -29,13 +29,11 @@
  */
 package org.antlr.v4.runtime;
 
-import org.antlr.v4.runtime.misc.NotNull;
-
 /** This signifies any kind of mismatched input exceptions such as
  *  when the current input does not match the expected token.
  */
 public class InputMismatchException extends RecognitionException {
-	public InputMismatchException(@NotNull Parser recognizer) {
+	public InputMismatchException(Parser recognizer) {
 		super(recognizer, recognizer.getInputStream(), recognizer._ctx);
 		this.setOffendingToken(recognizer.getCurrentToken());
 	}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/IntStream.java b/runtime/Java/src/org/antlr/v4/runtime/IntStream.java
index cb25380d4..0108a4b78 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/IntStream.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/IntStream.java
@@ -30,17 +30,15 @@
 
 package org.antlr.v4.runtime;
 
-import org.antlr.v4.runtime.misc.NotNull;
-
 /**
  * A simple stream of symbols whose values are represented as integers. This
  * interface provides <em>marked ranges</em> with support for a minimum level
  * of buffering necessary to implement arbitrary lookahead during prediction.
  * For more information on marked ranges, see {@link #mark}.
- * <p/>
- * <strong>Initializing Methods:</strong> Some methods in this interface have
+ *
+ * <p><strong>Initializing Methods:</strong> Some methods in this interface have
  * unspecified behavior if no call to an initializing method has occurred after
- * the stream was constructed. The following is a list of initializing methods:
+ * the stream was constructed. The following is a list of initializing methods:</p>
  *
  * <ul>
  *   <li>{@link #LA}</li>
@@ -93,8 +91,8 @@ public interface IntStream {
 	 * symbol in the stream. It is not valid to call this method with
 	 * {@code i==0}, but the specific behavior is unspecified because this
 	 * method is frequently called from performance-critical code.
-	 * <p/>
-	 * This method is guaranteed to succeed if any of the following are true:
+	 *
+	 * <p>This method is guaranteed to succeed if any of the following are true:</p>
 	 *
 	 * <ul>
 	 *   <li>{@code i>0}</li>
@@ -109,12 +107,12 @@ public interface IntStream {
 	 *     that has not yet been released.</li>
 	 * </ul>
 	 *
-	 * If {@code i} represents a position at or beyond the end of the stream,
-	 * this method returns {@link #EOF}.
-	 * <p/>
-	 * The return value is unspecified if {@code i<0} and fewer than {@code -i}
+	 * <p>If {@code i} represents a position at or beyond the end of the stream,
+	 * this method returns {@link #EOF}.</p>
+	 *
+	 * <p>The return value is unspecified if {@code i<0} and fewer than {@code -i}
 	 * calls to {@link #consume consume()} have occurred from the beginning of
-	 * the stream before calling this method.
+	 * the stream before calling this method.</p>
 	 *
 	 * @throws UnsupportedOperationException if the stream does not support
 	 * retrieving the value of the specified symbol
@@ -127,8 +125,8 @@ public interface IntStream {
 	 * was called to the current {@link #index index()}. This allows the use of
 	 * streaming input sources by specifying the minimum buffering requirements
 	 * to support arbitrary lookahead during prediction.
-	 * <p/>
-	 * The returned mark is an opaque handle (type {@code int}) which is passed
+	 *
+	 * <p>The returned mark is an opaque handle (type {@code int}) which is passed
 	 * to {@link #release release()} when the guarantees provided by the marked
 	 * range are no longer necessary. When calls to
 	 * {@code mark()}/{@code release()} are nested, the marks must be released
@@ -136,19 +134,19 @@ public interface IntStream {
 	 * used during performance-critical sections of prediction, the specific
 	 * behavior of invalid usage is unspecified (i.e. a mark is not released, or
 	 * a mark is released twice, or marks are not released in reverse order from
-	 * which they were created).
-	 * <p/>
-	 * The behavior of this method is unspecified if no call to an
+	 * which they were created).</p>
+	 *
+	 * <p>The behavior of this method is unspecified if no call to an
 	 * {@link IntStream initializing method} has occurred after this stream was
-	 * constructed.
-	 * <p/>
-	 * This method does not change the current position in the input stream.
-	 * <p/>
-	 * The following example shows the use of {@link #mark mark()},
+	 * constructed.</p>
+	 *
+	 * <p>This method does not change the current position in the input stream.</p>
+	 *
+	 * <p>The following example shows the use of {@link #mark mark()},
 	 * {@link #release release(mark)}, {@link #index index()}, and
 	 * {@link #seek seek(index)} as part of an operation to safely work within a
 	 * marked region, then restore the stream position to its original value and
-	 * release the mark.
+	 * release the mark.</p>
 	 * <pre>
 	 * IntStream stream = ...;
 	 * int index = -1;
@@ -175,8 +173,8 @@ public interface IntStream {
 	 * reverse order of the corresponding calls to {@code mark()}. If a mark is
 	 * released twice, or if marks are not released in reverse order of the
 	 * corresponding calls to {@code mark()}, the behavior is unspecified.
-	 * <p/>
-	 * For more information and an example, see {@link #mark}.
+	 *
+	 * <p>For more information and an example, see {@link #mark}.</p>
 	 *
 	 * @param marker A marker returned by a call to {@code mark()}.
 	 * @see #mark
@@ -186,10 +184,10 @@ public interface IntStream {
 	/**
 	 * Return the index into the stream of the input symbol referred to by
 	 * {@code LA(1)}.
-	 * <p/>
-	 * The behavior of this method is unspecified if no call to an
+	 *
+	 * <p>The behavior of this method is unspecified if no call to an
 	 * {@link IntStream initializing method} has occurred after this stream was
-	 * constructed.
+	 * constructed.</p>
 	 */
 	int index();
 
@@ -197,7 +195,7 @@ public interface IntStream {
 	 * Set the input cursor to the position indicated by {@code index}. If the
 	 * specified index lies past the end of the stream, the operation behaves as
 	 * though {@code index} was the index of the EOF symbol. After this method
-	 * returns without throwing an exception, the at least one of the following
+	 * returns without throwing an exception, then at least one of the following
 	 * will be true.
 	 *
 	 * <ul>
@@ -237,6 +235,6 @@ public interface IntStream {
 	 * non-null, non-empty string. If such a name is not known, this method
 	 * returns {@link #UNKNOWN_SOURCE_NAME}.
 	 */
-	@NotNull
+
 	public String getSourceName();
 }
diff --git a/runtime/Java/src/org/antlr/v4/runtime/InterpreterRuleContext.java b/runtime/Java/src/org/antlr/v4/runtime/InterpreterRuleContext.java
index 231f4797c..8a7001ff2 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/InterpreterRuleContext.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/InterpreterRuleContext.java
@@ -29,16 +29,33 @@
  */
 package org.antlr.v4.runtime;
 
-import org.antlr.v4.runtime.misc.Nullable;
-
-/** This object is used by the ParserInterpreter and is the same as a regular
- *  ParserRuleContext except that we need to track the rule index of the
- *  current context so that we can build parse trees.
+/**
+ * This class extends {@link ParserRuleContext} by allowing the value of
+ * {@link #getRuleIndex} to be explicitly set for the context.
+ *
+ * <p>
+ * {@link ParserRuleContext} does not include field storage for the rule index
+ * since the context classes created by the code generator override the
+ * {@link #getRuleIndex} method to return the correct value for that context.
+ * Since the parser interpreter does not use the context classes generated for a
+ * parser, this class (with slightly more memory overhead per node) is used to
+ * provide equivalent functionality.</p>
  */
 public class InterpreterRuleContext extends ParserRuleContext {
-	private final int ruleIndex;
+	/** This is the backing field for {@link #getRuleIndex}. */
+	protected int ruleIndex = -1;
 
-	public InterpreterRuleContext(@Nullable ParserRuleContext parent,
+	public InterpreterRuleContext() { }
+
+	/**
+	 * Constructs a new {@link InterpreterRuleContext} with the specified
+	 * parent, invoking state, and rule index.
+	 *
+	 * @param parent The parent context.
+	 * @param invokingStateNumber The invoking state number.
+	 * @param ruleIndex The rule index for the current context.
+	 */
+	public InterpreterRuleContext(ParserRuleContext parent,
 								  int invokingStateNumber,
 								  int ruleIndex)
 	{
diff --git a/runtime/Java/src/org/antlr/v4/runtime/Lexer.java b/runtime/Java/src/org/antlr/v4/runtime/Lexer.java
index c50721995..3f6c4c447 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/Lexer.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/Lexer.java
@@ -274,14 +274,9 @@ public abstract class Lexer extends Recognizer<Integer, LexerATNSimulator>
 
 	public Token emitEOF() {
 		int cpos = getCharPositionInLine();
-		// The character position for EOF is one beyond the position of
-		// the previous token's last character
-		if ( _token !=null ) {
-			int n = _token.getStopIndex() - _token.getStartIndex() + 1;
-			cpos = _token.getCharPositionInLine()+n;
-		}
+		int line = getLine();
 		Token eof = _factory.create(_tokenFactorySourcePair, Token.EOF, null, Token.DEFAULT_CHANNEL, _input.index(), _input.index()-1,
-									getLine(), cpos);
+									line, cpos);
 		emit(eof);
 		return eof;
 	}
@@ -358,6 +353,7 @@ public abstract class Lexer extends Recognizer<Integer, LexerATNSimulator>
 	 *  that overrides this to point to their String[] tokenNames.
 	 */
 	@Override
+	@Deprecated
 	public String[] getTokenNames() {
 		return null;
 	}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/LexerInterpreter.java b/runtime/Java/src/org/antlr/v4/runtime/LexerInterpreter.java
index 101b2dafc..dc79aa74e 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/LexerInterpreter.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/LexerInterpreter.java
@@ -30,8 +30,6 @@
 
 package org.antlr.v4.runtime;
 
-import org.antlr.v4.runtime.CharStream;
-import org.antlr.v4.runtime.Lexer;
 import org.antlr.v4.runtime.atn.ATN;
 import org.antlr.v4.runtime.atn.ATNType;
 import org.antlr.v4.runtime.atn.LexerATNSimulator;
@@ -44,15 +42,24 @@ public class LexerInterpreter extends Lexer {
 	protected final String grammarFileName;
 	protected final ATN atn;
 
+	@Deprecated
 	protected final String[] tokenNames;
 	protected final String[] ruleNames;
 	protected final String[] modeNames;
 
+
+	private final Vocabulary vocabulary;
+
 	protected final DFA[] _decisionToDFA;
 	protected final PredictionContextCache _sharedContextCache =
 		new PredictionContextCache();
 
+	@Deprecated
 	public LexerInterpreter(String grammarFileName, Collection<String> tokenNames, Collection<String> ruleNames, Collection<String> modeNames, ATN atn, CharStream input) {
+		this(grammarFileName, VocabularyImpl.fromTokenNames(tokenNames.toArray(new String[tokenNames.size()])), ruleNames, modeNames, atn, input);
+	}
+
+	public LexerInterpreter(String grammarFileName, Vocabulary vocabulary, Collection<String> ruleNames, Collection<String> modeNames, ATN atn, CharStream input) {
 		super(input);
 
 		if (atn.grammarType != ATNType.LEXER) {
@@ -61,15 +68,20 @@ public class LexerInterpreter extends Lexer {
 
 		this.grammarFileName = grammarFileName;
 		this.atn = atn;
-		this.tokenNames = tokenNames.toArray(new String[tokenNames.size()]);
+		this.tokenNames = new String[atn.maxTokenType];
+		for (int i = 0; i < tokenNames.length; i++) {
+			tokenNames[i] = vocabulary.getDisplayName(i);
+		}
+
 		this.ruleNames = ruleNames.toArray(new String[ruleNames.size()]);
 		this.modeNames = modeNames.toArray(new String[modeNames.size()]);
+		this.vocabulary = vocabulary;
 
 		this._decisionToDFA = new DFA[atn.getNumberOfDecisions()];
 		for (int i = 0; i < _decisionToDFA.length; i++) {
 			_decisionToDFA[i] = new DFA(atn.getDecisionState(i), i);
 		}
-		this._interp = new LexerATNSimulator(atn,_decisionToDFA,_sharedContextCache);
+		this._interp = new LexerATNSimulator(this,atn,_decisionToDFA,_sharedContextCache);
 	}
 
 	@Override
@@ -83,6 +95,7 @@ public class LexerInterpreter extends Lexer {
 	}
 
 	@Override
+	@Deprecated
 	public String[] getTokenNames() {
 		return tokenNames;
 	}
@@ -96,4 +109,13 @@ public class LexerInterpreter extends Lexer {
 	public String[] getModeNames() {
 		return modeNames;
 	}
+
+	@Override
+	public Vocabulary getVocabulary() {
+		if (vocabulary != null) {
+			return vocabulary;
+		}
+
+		return super.getVocabulary();
+	}
 }
diff --git a/runtime/Java/src/org/antlr/v4/runtime/LexerNoViableAltException.java b/runtime/Java/src/org/antlr/v4/runtime/LexerNoViableAltException.java
index a6936cba2..5aae99dd7 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/LexerNoViableAltException.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/LexerNoViableAltException.java
@@ -32,8 +32,6 @@ package org.antlr.v4.runtime;
 
 import org.antlr.v4.runtime.atn.ATNConfigSet;
 import org.antlr.v4.runtime.misc.Interval;
-import org.antlr.v4.runtime.misc.NotNull;
-import org.antlr.v4.runtime.misc.Nullable;
 import org.antlr.v4.runtime.misc.Utils;
 
 import java.util.Locale;
@@ -43,13 +41,12 @@ public class LexerNoViableAltException extends RecognitionException {
 	private final int startIndex;
 
 	/** Which configurations did we try at input.index() that couldn't match input.LA(1)? */
-	@Nullable
 	private final ATNConfigSet deadEndConfigs;
 
-	public LexerNoViableAltException(@Nullable Lexer lexer,
-									 @NotNull CharStream input,
+	public LexerNoViableAltException(Lexer lexer,
+									 CharStream input,
 									 int startIndex,
-									 @Nullable ATNConfigSet deadEndConfigs) {
+									 ATNConfigSet deadEndConfigs) {
 		super(lexer, input, null);
 		this.startIndex = startIndex;
 		this.deadEndConfigs = deadEndConfigs;
@@ -59,7 +56,7 @@ public class LexerNoViableAltException extends RecognitionException {
 		return startIndex;
 	}
 
-	@Nullable
+
 	public ATNConfigSet getDeadEndConfigs() {
 		return deadEndConfigs;
 	}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/ListTokenSource.java b/runtime/Java/src/org/antlr/v4/runtime/ListTokenSource.java
index ac3be77c1..bc877b531 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/ListTokenSource.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/ListTokenSource.java
@@ -1,6 +1,5 @@
 package org.antlr.v4.runtime;
 
-import org.antlr.v4.runtime.misc.NotNull;
 import org.antlr.v4.runtime.misc.Pair;
 
 import java.util.List;
@@ -8,10 +7,10 @@ import java.util.List;
 /**
  * Provides an implementation of {@link TokenSource} as a wrapper around a list
  * of {@link Token} objects.
- * <p/>
- * If the final token in the list is an {@link Token#EOF} token, it will be used
+ *
+ * <p>If the final token in the list is an {@link Token#EOF} token, it will be used
  * as the EOF token for every call to {@link #nextToken} after the end of the
- * list is reached. Otherwise, an EOF token will be created.
+ * list is reached. Otherwise, an EOF token will be created.</p>
  */
 public class ListTokenSource implements TokenSource {
 	/**
@@ -53,7 +52,7 @@ public class ListTokenSource implements TokenSource {
 	 * {@link TokenSource}.
 	 * @exception NullPointerException if {@code tokens} is {@code null}
 	 */
-	public ListTokenSource(@NotNull List<? extends Token> tokens) {
+	public ListTokenSource(List<? extends Token> tokens) {
 		this(tokens, null);
 	}
 
@@ -70,7 +69,7 @@ public class ListTokenSource implements TokenSource {
 	 *
 	 * @exception NullPointerException if {@code tokens} is {@code null}
 	 */
-	public ListTokenSource(@NotNull List<? extends Token> tokens, String sourceName) {
+	public ListTokenSource(List<? extends Token> tokens, String sourceName) {
 		if (tokens == null) {
 			throw new NullPointerException("tokens cannot be null");
 		}
@@ -80,7 +79,7 @@ public class ListTokenSource implements TokenSource {
 	}
 
 	/**
-	 * @inheritDoc
+	 * {@inheritDoc}
 	 */
 	@Override
 	public int getCharPositionInLine() {
@@ -111,7 +110,7 @@ public class ListTokenSource implements TokenSource {
 	}
 
 	/**
-	 * @inheritDoc
+	 * {@inheritDoc}
 	 */
 	@Override
 	public Token nextToken() {
@@ -142,7 +141,7 @@ public class ListTokenSource implements TokenSource {
 	}
 
 	/**
-	 * @inheritDoc
+	 * {@inheritDoc}
 	 */
 	@Override
 	public int getLine() {
@@ -177,7 +176,7 @@ public class ListTokenSource implements TokenSource {
 	}
 
 	/**
-	 * @inheritDoc
+	 * {@inheritDoc}
 	 */
 	@Override
 	public CharStream getInputStream() {
@@ -196,7 +195,7 @@ public class ListTokenSource implements TokenSource {
 	}
 
 	/**
-	 * @inheritDoc
+	 * {@inheritDoc}
 	 */
 	@Override
 	public String getSourceName() {
@@ -213,18 +212,17 @@ public class ListTokenSource implements TokenSource {
 	}
 
 	/**
-	 * @inheritDoc
+	 * {@inheritDoc}
 	 */
 	@Override
-	public void setTokenFactory(@NotNull TokenFactory<?> factory) {
+	public void setTokenFactory(TokenFactory<?> factory) {
 		this._factory = factory;
 	}
 
 	/**
-	 * @inheritDoc
+	 * {@inheritDoc}
 	 */
 	@Override
-	@NotNull
 	public TokenFactory<?> getTokenFactory() {
 		return _factory;
 	}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/NoViableAltException.java b/runtime/Java/src/org/antlr/v4/runtime/NoViableAltException.java
index 2676e3fe1..e907d7567 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/NoViableAltException.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/NoViableAltException.java
@@ -30,8 +30,6 @@
 package org.antlr.v4.runtime;
 
 import org.antlr.v4.runtime.atn.ATNConfigSet;
-import org.antlr.v4.runtime.misc.NotNull;
-import org.antlr.v4.runtime.misc.Nullable;
 
 /** Indicates that the parser could not decide which of two or more paths
  *  to take based upon the remaining input. It tracks the starting token
@@ -40,7 +38,7 @@ import org.antlr.v4.runtime.misc.Nullable;
  */
 public class NoViableAltException extends RecognitionException {
 	/** Which configurations did we try at input.index() that couldn't match input.LT(1)? */
-	@Nullable
+
 	private final ATNConfigSet deadEndConfigs;
 
 	/** The token object at the start index; the input stream might
@@ -48,10 +46,10 @@ public class NoViableAltException extends RecognitionException {
 	 *  time the error occurred, of course the stream needs to keep a
 	 *  buffer all of the tokens but later we might not have access to those.)
 	 */
-	@NotNull
+
 	private final Token startToken;
 
-	public NoViableAltException(@NotNull Parser recognizer) { // LL(1) error
+	public NoViableAltException(Parser recognizer) { // LL(1) error
 		this(recognizer,
 			 recognizer.getInputStream(),
 			 recognizer.getCurrentToken(),
@@ -60,12 +58,12 @@ public class NoViableAltException extends RecognitionException {
 			 recognizer._ctx);
 	}
 
-	public NoViableAltException(@NotNull Parser recognizer,
-								@NotNull TokenStream input,
-								@NotNull Token startToken,
-								@NotNull Token offendingToken,
-								@Nullable ATNConfigSet deadEndConfigs,
-								@NotNull ParserRuleContext ctx)
+	public NoViableAltException(Parser recognizer,
+								TokenStream input,
+								Token startToken,
+								Token offendingToken,
+								ATNConfigSet deadEndConfigs,
+								ParserRuleContext ctx)
 	{
 		super(recognizer, input, ctx);
 		this.deadEndConfigs = deadEndConfigs;
@@ -73,12 +71,12 @@ public class NoViableAltException extends RecognitionException {
 		this.setOffendingToken(offendingToken);
 	}
 
-	@NotNull
+
 	public Token getStartToken() {
 		return startToken;
 	}
 
-	@Nullable
+
 	public ATNConfigSet getDeadEndConfigs() {
 		return deadEndConfigs;
 	}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/Parser.java b/runtime/Java/src/org/antlr/v4/runtime/Parser.java
index e2e73c4ed..eda34a13b 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/Parser.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/Parser.java
@@ -34,13 +34,14 @@ import org.antlr.v4.runtime.atn.ATNDeserializationOptions;
 import org.antlr.v4.runtime.atn.ATNDeserializer;
 import org.antlr.v4.runtime.atn.ATNSimulator;
 import org.antlr.v4.runtime.atn.ATNState;
+import org.antlr.v4.runtime.atn.ParseInfo;
 import org.antlr.v4.runtime.atn.ParserATNSimulator;
+import org.antlr.v4.runtime.atn.PredictionMode;
+import org.antlr.v4.runtime.atn.ProfilingATNSimulator;
 import org.antlr.v4.runtime.atn.RuleTransition;
 import org.antlr.v4.runtime.dfa.DFA;
 import org.antlr.v4.runtime.misc.IntegerStack;
 import org.antlr.v4.runtime.misc.IntervalSet;
-import org.antlr.v4.runtime.misc.NotNull;
-import org.antlr.v4.runtime.misc.Nullable;
 import org.antlr.v4.runtime.tree.ErrorNode;
 import org.antlr.v4.runtime.tree.ParseTreeListener;
 import org.antlr.v4.runtime.tree.ParseTreeWalker;
@@ -116,7 +117,7 @@ public abstract class Parser extends Recognizer<Token, ParserATNSimulator> {
 	 * @see #getErrorHandler
 	 * @see #setErrorHandler
 	 */
-	@NotNull
+
 	protected ANTLRErrorStrategy _errHandler = new DefaultErrorStrategy();
 
 	/**
@@ -164,7 +165,6 @@ public abstract class Parser extends Recognizer<Token, ParserATNSimulator> {
 	 *
 	 * @see #addParseListener
 	 */
-	@Nullable
 	protected List<ParseTreeListener> _parseListeners;
 
 	/**
@@ -173,6 +173,9 @@ public abstract class Parser extends Recognizer<Token, ParserATNSimulator> {
 	 */
 	protected int _syntaxErrors;
 
+	/** Indicates parser has match()ed EOF token. See {@link #exitRule()}. */
+	protected boolean matchedEOF;
+
 	public Parser(TokenStream input) {
 		setInputStream(input);
 	}
@@ -183,6 +186,7 @@ public abstract class Parser extends Recognizer<Token, ParserATNSimulator> {
 		_errHandler.reset(this);
 		_ctx = null;
 		_syntaxErrors = 0;
+		matchedEOF = false;
 		setTrace(false);
 		_precedenceStack.clear();
 		_precedenceStack.push(0);
@@ -196,13 +200,13 @@ public abstract class Parser extends Recognizer<Token, ParserATNSimulator> {
 	 * Match current input symbol against {@code ttype}. If the symbol type
 	 * matches, {@link ANTLRErrorStrategy#reportMatch} and {@link #consume} are
 	 * called to complete the match process.
-	 * <p/>
-	 * If the symbol type does not match,
+	 *
+	 * <p>If the symbol type does not match,
 	 * {@link ANTLRErrorStrategy#recoverInline} is called on the current error
 	 * strategy to attempt recovery. If {@link #getBuildParseTree} is
 	 * {@code true} and the token index of the symbol returned by
 	 * {@link ANTLRErrorStrategy#recoverInline} is -1, the symbol is added to
-	 * the parse tree by calling {@link ParserRuleContext#addErrorNode}.
+	 * the parse tree by calling {@link ParserRuleContext#addErrorNode}.</p>
 	 *
 	 * @param ttype the token type to match
 	 * @return the matched symbol
@@ -210,10 +214,12 @@ public abstract class Parser extends Recognizer<Token, ParserATNSimulator> {
 	 * {@code ttype} and the error strategy could not recover from the
 	 * mismatched symbol
 	 */
-	@NotNull
 	public Token match(int ttype) throws RecognitionException {
 		Token t = getCurrentToken();
 		if ( t.getType()==ttype ) {
+			if ( ttype==Token.EOF ) {
+				matchedEOF = true;
+			}
 			_errHandler.reportMatch(this);
 			consume();
 		}
@@ -232,20 +238,19 @@ public abstract class Parser extends Recognizer<Token, ParserATNSimulator> {
 	 * Match current input symbol as a wildcard. If the symbol type matches
 	 * (i.e. has a value greater than 0), {@link ANTLRErrorStrategy#reportMatch}
 	 * and {@link #consume} are called to complete the match process.
-	 * <p/>
-	 * If the symbol type does not match,
+	 *
+	 * <p>If the symbol type does not match,
 	 * {@link ANTLRErrorStrategy#recoverInline} is called on the current error
 	 * strategy to attempt recovery. If {@link #getBuildParseTree} is
 	 * {@code true} and the token index of the symbol returned by
 	 * {@link ANTLRErrorStrategy#recoverInline} is -1, the symbol is added to
-	 * the parse tree by calling {@link ParserRuleContext#addErrorNode}.
+	 * the parse tree by calling {@link ParserRuleContext#addErrorNode}.</p>
 	 *
 	 * @return the matched symbol
 	 * @throws RecognitionException if the current input symbol did not match
 	 * a wildcard and the error strategy could not recover from the mismatched
 	 * symbol
 	 */
-	@NotNull
 	public Token matchWildcard() throws RecognitionException {
 		Token t = getCurrentToken();
 		if (t.getType() > 0) {
@@ -269,15 +274,15 @@ public abstract class Parser extends Recognizer<Token, ParserATNSimulator> {
 	 * them up using the {@link ParserRuleContext#children} list so that it
 	 * forms a parse tree. The {@link ParserRuleContext} returned from the start
 	 * rule represents the root of the parse tree.
-	 * <p/>
-	 * Note that if we are not building parse trees, rule contexts only point
+	 *
+	 * <p>Note that if we are not building parse trees, rule contexts only point
 	 * upwards. When a rule exits, it returns the context but that gets garbage
 	 * collected if nobody holds a reference. It points upwards but nobody
-	 * points at it.
-	 * <p/>
-	 * When we build parse trees, we are adding all of these contexts to
+	 * points at it.</p>
+	 *
+	 * <p>When we build parse trees, we are adding all of these contexts to
 	 * {@link ParserRuleContext#children} list. Contexts are then not candidates
-	 * for garbage collection.
+	 * for garbage collection.</p>
 	 */
 	public void setBuildParseTree(boolean buildParseTrees) {
 		this._buildParseTrees = buildParseTrees;
@@ -319,7 +324,7 @@ public abstract class Parser extends Recognizer<Token, ParserATNSimulator> {
 		return getParseListeners().contains(TrimToSizeListener.INSTANCE);
 	}
 
-	@NotNull
+
 	public List<ParseTreeListener> getParseListeners() {
 		List<ParseTreeListener> listeners = _parseListeners;
 		if (listeners == null) {
@@ -331,19 +336,19 @@ public abstract class Parser extends Recognizer<Token, ParserATNSimulator> {
 
 	/**
 	 * Registers {@code listener} to receive events during the parsing process.
-	 * <p/>
-	 * To support output-preserving grammar transformations (including but not
+	 *
+	 * <p>To support output-preserving grammar transformations (including but not
 	 * limited to left-recursion removal, automated left-factoring, and
 	 * optimized code generation), calls to listener methods during the parse
 	 * may differ substantially from calls made by
 	 * {@link ParseTreeWalker#DEFAULT} used after the parse is complete. In
 	 * particular, rule entry and exit events may occur in a different order
 	 * during the parse than after the parser. In addition, calls to certain
-	 * rule entry methods may be omitted.
-	 * <p/>
-	 * With the following specific exceptions, calls to listener events are
+	 * rule entry methods may be omitted.</p>
+	 *
+	 * <p>With the following specific exceptions, calls to listener events are
 	 * <em>deterministic</em>, i.e. for identical input the calls to listener
-	 * methods will be the same.
+	 * methods will be the same.</p>
 	 *
 	 * <ul>
 	 * <li>Alterations to the grammar used to generate code may change the
@@ -358,7 +363,7 @@ public abstract class Parser extends Recognizer<Token, ParserATNSimulator> {
 	 *
 	 * @throws NullPointerException if {@code} listener is {@code null}
 	 */
-	public void addParseListener(@NotNull ParseTreeListener listener) {
+	public void addParseListener(ParseTreeListener listener) {
 		if (listener == null) {
 			throw new NullPointerException("listener");
 		}
@@ -372,9 +377,9 @@ public abstract class Parser extends Recognizer<Token, ParserATNSimulator> {
 
 	/**
 	 * Remove {@code listener} from the list of parse listeners.
-	 * <p/>
-	 * If {@code listener} is {@code null} or has not been added as a parse
-	 * listener, this method does nothing.
+	 *
+	 * <p>If {@code listener} is {@code null} or has not been added as a parse
+	 * listener, this method does nothing.</p>
 	 *
 	 * @see #addParseListener
 	 *
@@ -453,7 +458,7 @@ public abstract class Parser extends Recognizer<Token, ParserATNSimulator> {
 	 * @throws UnsupportedOperationException if the current parser does not
 	 * implement the {@link #getSerializedATN()} method.
 	 */
-	@NotNull
+
 	public ATN getATNWithBypassAlts() {
 		String serializedAtn = getSerializedATN();
 		if (serializedAtn == null) {
@@ -479,7 +484,7 @@ public abstract class Parser extends Recognizer<Token, ParserATNSimulator> {
 	 *
 	 * <pre>
 	 * ParseTree t = parser.expr();
-	 * ParseTreePattern p = parser.compileParseTreePattern("<ID>+0", MyParser.RULE_expr);
+	 * ParseTreePattern p = parser.compileParseTreePattern("&lt;ID&gt;+0", MyParser.RULE_expr);
 	 * ParseTreeMatch m = p.match(t);
 	 * String id = m.get("ID");
 	 * </pre>
@@ -506,12 +511,12 @@ public abstract class Parser extends Recognizer<Token, ParserATNSimulator> {
 		return m.compile(pattern, patternRuleIndex);
 	}
 
-	@NotNull
+
 	public ANTLRErrorStrategy getErrorHandler() {
 		return _errHandler;
 	}
 
-	public void setErrorHandler(@NotNull ANTLRErrorStrategy handler) {
+	public void setErrorHandler(ANTLRErrorStrategy handler) {
 		this._errHandler = handler;
 	}
 
@@ -537,6 +542,7 @@ public abstract class Parser extends Recognizer<Token, ParserATNSimulator> {
     /** Match needs to return the current input symbol, which gets put
      *  into the label for the associated token ref; e.g., x=ID.
      */
+
     public Token getCurrentToken() {
 		return _input.LT(1);
 	}
@@ -546,7 +552,7 @@ public abstract class Parser extends Recognizer<Token, ParserATNSimulator> {
 	}
 
 	public void notifyErrorListeners(Token offendingToken, String msg,
-									 @Nullable RecognitionException e)
+									 RecognitionException e)
 	{
 		_syntaxErrors++;
 		int line = -1;
@@ -560,10 +566,10 @@ public abstract class Parser extends Recognizer<Token, ParserATNSimulator> {
 
 	/**
 	 * Consume and return the {@linkplain #getCurrentToken current symbol}.
-	 * <p/>
-	 * E.g., given the following input with {@code A} being the current
+	 *
+	 * <p>E.g., given the following input with {@code A} being the current
 	 * lookahead symbol, this function moves the cursor to {@code B} and returns
-	 * {@code A}.
+	 * {@code A}.</p>
 	 *
 	 * <pre>
 	 *  A B
@@ -618,7 +624,7 @@ public abstract class Parser extends Recognizer<Token, ParserATNSimulator> {
 	 * Always called by generated parsers upon entry to a rule. Access field
 	 * {@link #_ctx} get the current context.
 	 */
-	public void enterRule(@NotNull ParserRuleContext localctx, int state, int ruleIndex) {
+	public void enterRule(ParserRuleContext localctx, int state, int ruleIndex) {
 		setState(state);
 		_ctx = localctx;
 		_ctx.start = _input.LT(1);
@@ -627,7 +633,13 @@ public abstract class Parser extends Recognizer<Token, ParserATNSimulator> {
 	}
 
     public void exitRule() {
-		_ctx.stop = _input.LT(-1);
+		if ( matchedEOF ) {
+			// if we have matched EOF, it cannot consume past EOF so we use LT(1) here
+			_ctx.stop = _input.LT(1); // LT(1) will be end of file
+		}
+		else {
+			_ctx.stop = _input.LT(-1); // stop node is what we just matched
+		}
         // trigger event on _ctx, before it reverts to parent
         if ( _parseListeners != null) triggerExitRuleEvent();
 		setState(_ctx.invokingState);
@@ -635,6 +647,7 @@ public abstract class Parser extends Recognizer<Token, ParserATNSimulator> {
     }
 
 	public void enterOuterAlt(ParserRuleContext localctx, int altNum) {
+		localctx.setAltNumber(altNum);
 		// if we have new localctx, make sure we replace existing ctx
 		// that is previous child of parse tree
 		if ( _buildParseTrees && _ctx != localctx ) {
@@ -647,6 +660,20 @@ public abstract class Parser extends Recognizer<Token, ParserATNSimulator> {
 		_ctx = localctx;
 	}
 
+	/**
+	 * Get the precedence level for the top-most precedence rule.
+	 *
+	 * @return The precedence level for the top-most precedence rule, or -1 if
+	 * the parser context is not nested within a precedence rule.
+	 */
+	public final int getPrecedence() {
+		if (_precedenceStack.isEmpty()) {
+			return -1;
+		}
+
+		return _precedenceStack.peek();
+	}
+
 	/**
 	 * @deprecated Use
 	 * {@link #enterRecursionRule(ParserRuleContext, int, int, int)} instead.
@@ -666,8 +693,8 @@ public abstract class Parser extends Recognizer<Token, ParserATNSimulator> {
 		}
 	}
 
-	/**
-	 * Like {@link #enterRule} but for recursive rules.
+	/** Like {@link #enterRule} but for recursive rules.
+	 *  Make the current context the child of the incoming localctx.
 	 */
 	public void pushNewRecursionContext(ParserRuleContext localctx, int state, int ruleIndex) {
 		ParserRuleContext previous = _ctx;
@@ -782,6 +809,10 @@ public abstract class Parser extends Recognizer<Token, ParserATNSimulator> {
         return false;
     }
 
+	public boolean isMatchedEOF() {
+		return matchedEOF;
+	}
+
 	/**
 	 * Computes the set of input symbols which could follow the current parser
 	 * state and context, as given by {@link #getState} and {@link #getContext},
@@ -789,12 +820,11 @@ public abstract class Parser extends Recognizer<Token, ParserATNSimulator> {
 	 *
 	 * @see ATN#getExpectedTokens(int, RuleContext)
 	 */
-	@NotNull
 	public IntervalSet getExpectedTokens() {
 		return getATN().getExpectedTokens(getState(), getContext());
 	}
 
-	@NotNull
+
     public IntervalSet getExpectedTokensWithinCurrentRule() {
         ATN atn = getInterpreter().atn;
         ATNState s = atn.states.get(getState());
@@ -834,13 +864,13 @@ public abstract class Parser extends Recognizer<Token, ParserATNSimulator> {
 		return stack;
 	}
 
-    /** For debugging and other purposes. */
+	/** For debugging and other purposes. */
 	public List<String> getDFAStrings() {
 		synchronized (_interp.decisionToDFA) {
 			List<String> s = new ArrayList<String>();
 			for (int d = 0; d < _interp.decisionToDFA.length; d++) {
 				DFA dfa = _interp.decisionToDFA[d];
-				s.add( dfa.toString(getTokenNames()) );
+				s.add( dfa.toString(getVocabulary()) );
 			}
 			return s;
 		}
@@ -855,7 +885,7 @@ public abstract class Parser extends Recognizer<Token, ParserATNSimulator> {
 				if ( !dfa.states.isEmpty() ) {
 					if ( seenOne ) System.out.println();
 					System.out.println("Decision " + dfa.decision + ":");
-					System.out.print(dfa.toString(getTokenNames()));
+					System.out.print(dfa.toString(getVocabulary()));
 					seenOne = true;
 				}
 			}
@@ -866,6 +896,34 @@ public abstract class Parser extends Recognizer<Token, ParserATNSimulator> {
 		return _input.getSourceName();
 	}
 
+	@Override
+	public ParseInfo getParseInfo() {
+		ParserATNSimulator interp = getInterpreter();
+		if (interp instanceof ProfilingATNSimulator) {
+			return new ParseInfo((ProfilingATNSimulator)interp);
+		}
+		return null;
+	}
+
+	/**
+	 * @since 4.3
+	 */
+	public void setProfile(boolean profile) {
+		ParserATNSimulator interp = getInterpreter();
+		PredictionMode saveMode = interp.getPredictionMode();
+		if ( profile ) {
+			if ( !(interp instanceof ProfilingATNSimulator) ) {
+				setInterpreter(new ProfilingATNSimulator(this));
+			}
+		}
+		else if ( interp instanceof ProfilingATNSimulator ) {
+			ParserATNSimulator sim =
+				new ParserATNSimulator(this, getATN(), interp.decisionToDFA, interp.getSharedContextCache());
+			setInterpreter(sim);
+		}
+		getInterpreter().setPredictionMode(saveMode);
+	}
+
 	/** During a parse is sometimes useful to listen in on the rule entry and exit
 	 *  events as well as token matches. This is for quick and dirty debugging.
 	 */
@@ -880,4 +938,14 @@ public abstract class Parser extends Recognizer<Token, ParserATNSimulator> {
 			addParseListener(_tracer);
 		}
 	}
+
+	/**
+	 * Gets whether a {@link TraceListener} is registered as a parse listener
+	 * for the parser.
+	 *
+	 * @see #setTrace(boolean)
+	 */
+	public boolean isTrace() {
+		return _tracer != null;
+	}
 }
diff --git a/runtime/Java/src/org/antlr/v4/runtime/ParserInterpreter.java b/runtime/Java/src/org/antlr/v4/runtime/ParserInterpreter.java
index f01ded747..78c9ea241 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/ParserInterpreter.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/ParserInterpreter.java
@@ -41,7 +41,6 @@ import org.antlr.v4.runtime.atn.PrecedencePredicateTransition;
 import org.antlr.v4.runtime.atn.PredicateTransition;
 import org.antlr.v4.runtime.atn.PredictionContextCache;
 import org.antlr.v4.runtime.atn.RuleStartState;
-import org.antlr.v4.runtime.atn.RuleStopState;
 import org.antlr.v4.runtime.atn.RuleTransition;
 import org.antlr.v4.runtime.atn.StarLoopEntryState;
 import org.antlr.v4.runtime.atn.Transition;
@@ -49,7 +48,6 @@ import org.antlr.v4.runtime.dfa.DFA;
 import org.antlr.v4.runtime.misc.Pair;
 
 import java.util.ArrayDeque;
-import java.util.BitSet;
 import java.util.Collection;
 import java.util.Deque;
 
@@ -69,50 +67,78 @@ import java.util.Deque;
 public class ParserInterpreter extends Parser {
 	protected final String grammarFileName;
 	protected final ATN atn;
-	protected final BitSet pushRecursionContextStates;
 
 	protected final DFA[] decisionToDFA; // not shared like it is for generated parsers
-	protected final PredictionContextCache sharedContextCache =
-		new PredictionContextCache();
+	protected final PredictionContextCache sharedContextCache = new PredictionContextCache();
 
+	@Deprecated
 	protected final String[] tokenNames;
 	protected final String[] ruleNames;
 
-	protected final Deque<Pair<ParserRuleContext, Integer>> _parentContextStack = new ArrayDeque<Pair<ParserRuleContext, Integer>>();
+	private final Vocabulary vocabulary;
 
+	/** This stack corresponds to the _parentctx, _parentState pair of locals
+	 *  that would exist on call stack frames with a recursive descent parser;
+	 *  in the generated function for a left-recursive rule you'd see:
+	 *
+	 *  private EContext e(int _p) throws RecognitionException {
+	 *      ParserRuleContext _parentctx = _ctx;    // Pair.a
+	 *      int _parentState = getState();          // Pair.b
+	 *      ...
+	 *  }
+	 *
+	 *  Those values are used to create new recursive rule invocation contexts
+	 *  associated with left operand of an alt like "expr '*' expr".
+	 */
+	protected final Deque<Pair<ParserRuleContext, Integer>> _parentContextStack =
+		new ArrayDeque<Pair<ParserRuleContext, Integer>>();
+
+	/** We need a map from (decision,inputIndex)->forced alt for computing ambiguous
+	 *  parse trees. For now, we allow exactly one override.
+	 */
+	protected int overrideDecision = -1;
+	protected int overrideDecisionInputIndex = -1;
+	protected int overrideDecisionAlt = -1;
+	protected boolean overrideDecisionReached = false; // latch and only override once; error might trigger infinite loop
+
+	/** What is the current context when we override a decisions?  This tells
+	 *  us what the root of the parse tree is when using override
+	 *  for an ambiguity/lookahead check.
+	 */
+	protected InterpreterRuleContext overrideDecisionRoot = null;
+
+
+	protected InterpreterRuleContext rootContext;
+
+	/**
+	 * @deprecated Use {@link #ParserInterpreter(String, Vocabulary, Collection, ATN, TokenStream)} instead.
+	 */
+	@Deprecated
 	public ParserInterpreter(String grammarFileName, Collection<String> tokenNames,
+							 Collection<String> ruleNames, ATN atn, TokenStream input) {
+		this(grammarFileName, VocabularyImpl.fromTokenNames(tokenNames.toArray(new String[tokenNames.size()])), ruleNames, atn, input);
+	}
+
+	public ParserInterpreter(String grammarFileName, Vocabulary vocabulary,
 							 Collection<String> ruleNames, ATN atn, TokenStream input)
 	{
 		super(input);
 		this.grammarFileName = grammarFileName;
 		this.atn = atn;
-		this.tokenNames = tokenNames.toArray(new String[tokenNames.size()]);
-		this.ruleNames = ruleNames.toArray(new String[ruleNames.size()]);
-		this.decisionToDFA = new DFA[atn.getNumberOfDecisions()];
-		for (int i = 0; i < decisionToDFA.length; i++) {
-			decisionToDFA[i] = new DFA(atn.getDecisionState(i), i);
+		this.tokenNames = new String[atn.maxTokenType];
+		for (int i = 0; i < tokenNames.length; i++) {
+			tokenNames[i] = vocabulary.getDisplayName(i);
 		}
 
-		// identify the ATN states where pushNewRecursionContext must be called
-		this.pushRecursionContextStates = new BitSet(atn.states.size());
-		for (ATNState state : atn.states) {
-			if (!(state instanceof StarLoopEntryState)) {
-				continue;
-			}
+		this.ruleNames = ruleNames.toArray(new String[ruleNames.size()]);
+		this.vocabulary = vocabulary;
 
-			RuleStartState ruleStartState = atn.ruleToStartState[state.ruleIndex];
-			if (!ruleStartState.isPrecedenceRule) {
-				continue;
-			}
-
-			ATNState maybeLoopEndState = state.transition(state.getNumberOfTransitions() - 1).target;
-			if (!(maybeLoopEndState instanceof LoopEndState)) {
-				continue;
-			}
-
-			if (maybeLoopEndState.epsilonOnlyTransitions && maybeLoopEndState.transition(0).target instanceof RuleStopState) {
-				this.pushRecursionContextStates.set(state.stateNumber);
-			}
+		// init decision DFA
+		int numberOfDecisions = atn.getNumberOfDecisions();
+		this.decisionToDFA = new DFA[numberOfDecisions];
+		for (int i = 0; i < numberOfDecisions; i++) {
+			DecisionState decisionState = atn.getDecisionState(i);
+			decisionToDFA[i] = new DFA(decisionState, i);
 		}
 
 		// get atn simulator that knows how to do predictions
@@ -121,16 +147,29 @@ public class ParserInterpreter extends Parser {
 											  sharedContextCache));
 	}
 
+	@Override
+	public void reset() {
+		super.reset();
+		overrideDecisionReached = false;
+		overrideDecisionRoot = null;
+	}
+
 	@Override
 	public ATN getATN() {
 		return atn;
 	}
 
 	@Override
+	@Deprecated
 	public String[] getTokenNames() {
 		return tokenNames;
 	}
 
+	@Override
+	public Vocabulary getVocabulary() {
+		return vocabulary;
+	}
+
 	@Override
 	public String[] getRuleNames() {
 		return ruleNames;
@@ -145,8 +184,8 @@ public class ParserInterpreter extends Parser {
 	public ParserRuleContext parse(int startRuleIndex) {
 		RuleStartState startRuleStartState = atn.ruleToStartState[startRuleIndex];
 
-		InterpreterRuleContext rootContext = new InterpreterRuleContext(null, ATNState.INVALID_STATE_NUMBER, startRuleIndex);
-		if (startRuleStartState.isPrecedenceRule) {
+		rootContext = createInterpreterRuleContext(null, ATNState.INVALID_STATE_NUMBER, startRuleIndex);
+		if (startRuleStartState.isLeftRecursiveRule) {
 			enterRecursionRule(rootContext, startRuleStartState.stateNumber, startRuleIndex, 0);
 		}
 		else {
@@ -159,15 +198,32 @@ public class ParserInterpreter extends Parser {
 			case ATNState.RULE_STOP :
 				// pop; return from rule
 				if ( _ctx.isEmpty() ) {
-					exitRule();
-					return rootContext;
+					if (startRuleStartState.isLeftRecursiveRule) {
+						ParserRuleContext result = _ctx;
+						Pair<ParserRuleContext, Integer> parentContext = _parentContextStack.pop();
+						unrollRecursionContexts(parentContext.a);
+						return result;
+					}
+					else {
+						exitRule();
+						return rootContext;
+					}
 				}
 
 				visitRuleStopState(p);
 				break;
 
 			default :
-				visitState(p);
+				try {
+					visitState(p);
+				}
+				catch (RecognitionException e) {
+					setState(atn.ruleToStopState[p.ruleIndex].stateNumber);
+					getContext().exception = e;
+					getErrorHandler().reportError(this, e);
+					recover(e);
+				}
+
 				break;
 			}
 		}
@@ -175,7 +231,8 @@ public class ParserInterpreter extends Parser {
 
 	@Override
 	public void enterRecursionRule(ParserRuleContext localctx, int state, int ruleIndex, int precedence) {
-		_parentContextStack.push(new Pair<ParserRuleContext, Integer>(_ctx, localctx.invokingState));
+		Pair<ParserRuleContext, Integer> pair = new Pair<ParserRuleContext, Integer>(_ctx, localctx.invokingState);
+		_parentContextStack.push(pair);
 		super.enterRecursionRule(localctx, state, ruleIndex, precedence);
 	}
 
@@ -184,81 +241,122 @@ public class ParserInterpreter extends Parser {
 	}
 
 	protected void visitState(ATNState p) {
-		int edge;
-		if (p.getNumberOfTransitions() > 1) {
-			edge = getInterpreter().adaptivePredict(_input, ((DecisionState)p).decision, _ctx);
-		}
-		else {
-			edge = 1;
+//		System.out.println("visitState "+p.stateNumber);
+		int predictedAlt = 1;
+		if ( p instanceof DecisionState ) {
+			predictedAlt = visitDecisionState((DecisionState) p);
 		}
 
-		Transition transition = p.transition(edge - 1);
+		Transition transition = p.transition(predictedAlt - 1);
 		switch (transition.getSerializationType()) {
-		case Transition.EPSILON:
-			if (pushRecursionContextStates.get(p.stateNumber) && !(transition.target instanceof LoopEndState)) {
-				InterpreterRuleContext ctx = new InterpreterRuleContext(_parentContextStack.peek().a, _parentContextStack.peek().b, _ctx.getRuleIndex());
-				pushNewRecursionContext(ctx, atn.ruleToStartState[p.ruleIndex].stateNumber, _ctx.getRuleIndex());
-			}
-			break;
+			case Transition.EPSILON:
+				if ( p.getStateType()==ATNState.STAR_LOOP_ENTRY &&
+					 ((StarLoopEntryState)p).isPrecedenceDecision &&
+					 !(transition.target instanceof LoopEndState))
+				{
+					// We are at the start of a left recursive rule's (...)* loop
+					// and we're not taking the exit branch of loop.
+					InterpreterRuleContext localctx =
+						createInterpreterRuleContext(_parentContextStack.peek().a,
+													 _parentContextStack.peek().b,
+													 _ctx.getRuleIndex());
+					pushNewRecursionContext(localctx,
+											atn.ruleToStartState[p.ruleIndex].stateNumber,
+											_ctx.getRuleIndex());
+				}
+				break;
 
-		case Transition.ATOM:
-			match(((AtomTransition)transition).label);
-			break;
+			case Transition.ATOM:
+				match(((AtomTransition)transition).label);
+				break;
 
-		case Transition.RANGE:
-		case Transition.SET:
-		case Transition.NOT_SET:
-			if (!transition.matches(_input.LA(1), Token.MIN_USER_TOKEN_TYPE, 65535)) {
-				_errHandler.recoverInline(this);
-			}
-			matchWildcard();
-			break;
+			case Transition.RANGE:
+			case Transition.SET:
+			case Transition.NOT_SET:
+				if (!transition.matches(_input.LA(1), Token.MIN_USER_TOKEN_TYPE, 65535)) {
+					recoverInline();
+				}
+				matchWildcard();
+				break;
 
-		case Transition.WILDCARD:
-			matchWildcard();
-			break;
+			case Transition.WILDCARD:
+				matchWildcard();
+				break;
 
-		case Transition.RULE:
-			RuleStartState ruleStartState = (RuleStartState)transition.target;
-			int ruleIndex = ruleStartState.ruleIndex;
-			InterpreterRuleContext ctx = new InterpreterRuleContext(_ctx, p.stateNumber, ruleIndex);
-			if (ruleStartState.isPrecedenceRule) {
-				enterRecursionRule(ctx, ruleStartState.stateNumber, ruleIndex, ((RuleTransition)transition).precedence);
-			}
-			else {
-				enterRule(ctx, transition.target.stateNumber, ruleIndex);
-			}
-			break;
+			case Transition.RULE:
+				RuleStartState ruleStartState = (RuleStartState)transition.target;
+				int ruleIndex = ruleStartState.ruleIndex;
+				InterpreterRuleContext newctx = createInterpreterRuleContext(_ctx, p.stateNumber, ruleIndex);
+				if (ruleStartState.isLeftRecursiveRule) {
+					enterRecursionRule(newctx, ruleStartState.stateNumber, ruleIndex, ((RuleTransition)transition).precedence);
+				}
+				else {
+					enterRule(newctx, transition.target.stateNumber, ruleIndex);
+				}
+				break;
 
-		case Transition.PREDICATE:
-			PredicateTransition predicateTransition = (PredicateTransition)transition;
-			if (!sempred(_ctx, predicateTransition.ruleIndex, predicateTransition.predIndex)) {
-				throw new FailedPredicateException(this);
-			}
+			case Transition.PREDICATE:
+				PredicateTransition predicateTransition = (PredicateTransition)transition;
+				if (!sempred(_ctx, predicateTransition.ruleIndex, predicateTransition.predIndex)) {
+					throw new FailedPredicateException(this);
+				}
 
-			break;
+				break;
 
-		case Transition.ACTION:
-			ActionTransition actionTransition = (ActionTransition)transition;
-			action(_ctx, actionTransition.ruleIndex, actionTransition.actionIndex);
-			break;
+			case Transition.ACTION:
+				ActionTransition actionTransition = (ActionTransition)transition;
+				action(_ctx, actionTransition.ruleIndex, actionTransition.actionIndex);
+				break;
 
-		case Transition.PRECEDENCE:
-			if (!precpred(_ctx, ((PrecedencePredicateTransition)transition).precedence)) {
-				throw new FailedPredicateException(this, String.format("precpred(_ctx, %d)", ((PrecedencePredicateTransition)transition).precedence));
-			}
-			break;
+			case Transition.PRECEDENCE:
+				if (!precpred(_ctx, ((PrecedencePredicateTransition)transition).precedence)) {
+					throw new FailedPredicateException(this, String.format("precpred(_ctx, %d)", ((PrecedencePredicateTransition)transition).precedence));
+				}
+				break;
 
-		default:
-			throw new UnsupportedOperationException("Unrecognized ATN transition type.");
+			default:
+				throw new UnsupportedOperationException("Unrecognized ATN transition type.");
 		}
 
 		setState(transition.target.stateNumber);
 	}
 
+	/** Method visitDecisionState() is called when the interpreter reaches
+	 *  a decision state (instance of DecisionState). It gives an opportunity
+	 *  for subclasses to track interesting things.
+	 */
+	protected int visitDecisionState(DecisionState p) {
+		int predictedAlt = 1;
+		if ( p.getNumberOfTransitions()>1 ) {
+			getErrorHandler().sync(this);
+			int decision = p.decision;
+			if ( decision == overrideDecision && _input.index() == overrideDecisionInputIndex &&
+			     !overrideDecisionReached )
+			{
+				predictedAlt = overrideDecisionAlt;
+				overrideDecisionReached = true;
+			}
+			else {
+				predictedAlt = getInterpreter().adaptivePredict(_input, decision, _ctx);
+			}
+		}
+		return predictedAlt;
+	}
+
+	/** Provide simple "factory" for InterpreterRuleContext's.
+	 *  @since 4.5.1
+	 */
+	protected InterpreterRuleContext createInterpreterRuleContext(
+		ParserRuleContext parent,
+		int invokingStateNumber,
+		int ruleIndex)
+	{
+		return new InterpreterRuleContext(parent, invokingStateNumber, ruleIndex);
+	}
+
 	protected void visitRuleStopState(ATNState p) {
 		RuleStartState ruleStartState = atn.ruleToStartState[p.ruleIndex];
-		if (ruleStartState.isPrecedenceRule) {
+		if (ruleStartState.isLeftRecursiveRule) {
 			Pair<ParserRuleContext, Integer> parentContext = _parentContextStack.pop();
 			unrollRecursionContexts(parentContext.a);
 			setState(parentContext.b);
@@ -270,4 +368,104 @@ public class ParserInterpreter extends Parser {
 		RuleTransition ruleTransition = (RuleTransition)atn.states.get(getState()).transition(0);
 		setState(ruleTransition.followState.stateNumber);
 	}
+
+	/** Override this parser interpreters normal decision-making process
+	 *  at a particular decision and input token index. Instead of
+	 *  allowing the adaptive prediction mechanism to choose the
+	 *  first alternative within a block that leads to a successful parse,
+	 *  force it to take the alternative, 1..n for n alternatives.
+	 *
+	 *  As an implementation limitation right now, you can only specify one
+	 *  override. This is sufficient to allow construction of different
+	 *  parse trees for ambiguous input. It means re-parsing the entire input
+	 *  in general because you're never sure where an ambiguous sequence would
+	 *  live in the various parse trees. For example, in one interpretation,
+	 *  an ambiguous input sequence would be matched completely in expression
+	 *  but in another it could match all the way back to the root.
+	 *
+	 *  s : e '!'? ;
+	 *  e : ID
+	 *    | ID '!'
+	 *    ;
+	 *
+	 *  Here, x! can be matched as (s (e ID) !) or (s (e ID !)). In the first
+	 *  case, the ambiguous sequence is fully contained only by the root.
+	 *  In the second case, the ambiguous sequences fully contained within just
+	 *  e, as in: (e ID !).
+	 *
+	 *  Rather than trying to optimize this and make
+	 *  some intelligent decisions for optimization purposes, I settled on
+	 *  just re-parsing the whole input and then using
+	 *  {link Trees#getRootOfSubtreeEnclosingRegion} to find the minimal
+	 *  subtree that contains the ambiguous sequence. I originally tried to
+	 *  record the call stack at the point the parser detected and ambiguity but
+	 *  left recursive rules create a parse tree stack that does not reflect
+	 *  the actual call stack. That impedance mismatch was enough to make
+	 *  it it challenging to restart the parser at a deeply nested rule
+	 *  invocation.
+	 *
+	 *  Only parser interpreters can override decisions so as to avoid inserting
+	 *  override checking code in the critical ALL(*) prediction execution path.
+	 *
+	 *  @since 4.5.1
+	 */
+	public void addDecisionOverride(int decision, int tokenIndex, int forcedAlt) {
+		overrideDecision = decision;
+		overrideDecisionInputIndex = tokenIndex;
+		overrideDecisionAlt = forcedAlt;
+	}
+
+	public InterpreterRuleContext getOverrideDecisionRoot() {
+		return overrideDecisionRoot;
+	}
+
+	/** Rely on the error handler for this parser but, if no tokens are consumed
+	 *  to recover, add an error node. Otherwise, nothing is seen in the parse
+	 *  tree.
+	 */
+	protected void recover(RecognitionException e) {
+		int i = _input.index();
+		getErrorHandler().recover(this, e);
+		if ( _input.index()==i ) {
+			// no input consumed, better add an error node
+			if ( e instanceof InputMismatchException ) {
+				InputMismatchException ime = (InputMismatchException)e;
+				Token tok = e.getOffendingToken();
+				int expectedTokenType = ime.getExpectedTokens().getMinElement(); // get any element
+				Token errToken =
+					getTokenFactory().create(new Pair<TokenSource, CharStream>(tok.getTokenSource(), tok.getTokenSource().getInputStream()),
+				                             expectedTokenType, tok.getText(),
+				                             Token.DEFAULT_CHANNEL,
+				                            -1, -1, // invalid start/stop
+				                             tok.getLine(), tok.getCharPositionInLine());
+				_ctx.addErrorNode(errToken);
+			}
+			else { // NoViableAlt
+				Token tok = e.getOffendingToken();
+				Token errToken =
+					getTokenFactory().create(new Pair<TokenSource, CharStream>(tok.getTokenSource(), tok.getTokenSource().getInputStream()),
+				                             Token.INVALID_TYPE, tok.getText(),
+				                             Token.DEFAULT_CHANNEL,
+				                            -1, -1, // invalid start/stop
+				                             tok.getLine(), tok.getCharPositionInLine());
+				_ctx.addErrorNode(errToken);
+			}
+		}
+	}
+
+	protected Token recoverInline() {
+		return _errHandler.recoverInline(this);
+	}
+
+	/** Return the root of the parse, which can be useful if the parser
+	 *  bails out. You still can access the top node. Note that,
+	 *  because of the way left recursive rules add children, it's possible
+	 *  that the root will not have any children if the start rule immediately
+	 *  called and left recursive rule that fails.
+	 *
+	 * @since 4.5.1
+	 */
+	public InterpreterRuleContext getRootContext() {
+		return rootContext;
+	}
 }
diff --git a/runtime/Java/src/org/antlr/v4/runtime/ParserRuleContext.java b/runtime/Java/src/org/antlr/v4/runtime/ParserRuleContext.java
index 56526fc95..edca61eb7 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/ParserRuleContext.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/ParserRuleContext.java
@@ -30,14 +30,12 @@
 package org.antlr.v4.runtime;
 
 import org.antlr.v4.runtime.misc.Interval;
-import org.antlr.v4.runtime.misc.Nullable;
 import org.antlr.v4.runtime.tree.ErrorNode;
 import org.antlr.v4.runtime.tree.ErrorNodeImpl;
 import org.antlr.v4.runtime.tree.ParseTree;
 import org.antlr.v4.runtime.tree.ParseTreeListener;
 import org.antlr.v4.runtime.tree.TerminalNode;
 import org.antlr.v4.runtime.tree.TerminalNodeImpl;
-import org.antlr.v4.runtime.tree.pattern.RuleTagToken;
 
 import java.util.ArrayList;
 import java.util.Collections;
@@ -47,9 +45,8 @@ import java.util.List;
  *
  *  Contains all of the information about the current rule not stored in the
  *  RuleContext. It handles parse tree children list, Any ATN state
- *  tracing, and the default values available for rule indications:
- *  start, stop, rule index, current alt number, current
- *  ATN state.
+ *  tracing, and the default values available for rule invocations:
+ *  start, stop, rule index, current alt number.
  *
  *  Subclasses made for each rule and grammar track the parameters,
  *  return values, locals, and labels specific to that rule. These
@@ -105,9 +102,10 @@ public class ParserRuleContext extends RuleContext {
 
 	public ParserRuleContext() { }
 
-	/** COPY a ctx (I'm deliberately not using copy constructor) */
+	/** COPY a ctx (I'm deliberately not using copy constructor) to avoid
+	 *  confusion with creating node with parent. Does not copy children.
+	 */
 	public void copyFrom(ParserRuleContext ctx) {
-		// from RuleContext
 		this.parent = ctx.parent;
 		this.invokingState = ctx.invokingState;
 
@@ -115,7 +113,7 @@ public class ParserRuleContext extends RuleContext {
 		this.stop = ctx.stop;
 	}
 
-	public ParserRuleContext(@Nullable ParserRuleContext parent, int invokingStateNumber) {
+	public ParserRuleContext(ParserRuleContext parent, int invokingStateNumber) {
 		super(parent, invokingStateNumber);
 	}
 
@@ -274,11 +272,26 @@ public class ParserRuleContext extends RuleContext {
 
 	@Override
 	public Interval getSourceInterval() {
-		if ( start==null || stop==null ) return Interval.INVALID;
+		if ( start == null ) {
+			return Interval.INVALID;
+		}
+		if ( stop==null || stop.getTokenIndex()<start.getTokenIndex() ) {
+			return Interval.of(start.getTokenIndex(), start.getTokenIndex()-1); // empty
+		}
 		return Interval.of(start.getTokenIndex(), stop.getTokenIndex());
 	}
 
+	/**
+	 * Get the initial token in this context.
+	 * Note that the range from start to stop is inclusive, so for rules that do not consume anything
+	 * (for example, zero length or error productions) this token may exceed stop.
+	 */
 	public Token getStart() { return start; }
+	/**
+	 * Get the final token in this context.
+	 * Note that the range from start to stop is inclusive, so for rules that do not consume anything
+	 * (for example, zero length or error productions) this token may precede start.
+	 */
 	public Token getStop() { return stop; }
 
     /** Used for rule context info debugging during parse-time, not so much for ATN debugging */
diff --git a/runtime/Java/src/org/antlr/v4/runtime/RecognitionException.java b/runtime/Java/src/org/antlr/v4/runtime/RecognitionException.java
index 14bff66dc..d80694d14 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/RecognitionException.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/RecognitionException.java
@@ -31,7 +31,6 @@ package org.antlr.v4.runtime;
 
 import org.antlr.v4.runtime.atn.DecisionState;
 import org.antlr.v4.runtime.misc.IntervalSet;
-import org.antlr.v4.runtime.misc.Nullable;
 
 /** The root of the ANTLR exception hierarchy. In general, ANTLR tracks just
  *  3 kinds of errors: prediction errors, failed predicate errors, and
@@ -41,13 +40,10 @@ import org.antlr.v4.runtime.misc.Nullable;
  */
 public class RecognitionException extends RuntimeException {
 	/** The {@link Recognizer} where this exception originated. */
-	@Nullable
 	private final Recognizer<?, ?> recognizer;
 
-	@Nullable
 	private final RuleContext ctx;
 
-	@Nullable
 	private final IntStream input;
 
 	/**
@@ -59,9 +55,9 @@ public class RecognitionException extends RuntimeException {
 
 	private int offendingState = -1;
 
-	public RecognitionException(@Nullable Recognizer<?, ?> recognizer,
-								@Nullable IntStream input,
-								@Nullable ParserRuleContext ctx)
+	public RecognitionException(Recognizer<?, ?> recognizer,
+								IntStream input,
+								ParserRuleContext ctx)
 	{
 		this.recognizer = recognizer;
 		this.input = input;
@@ -70,9 +66,9 @@ public class RecognitionException extends RuntimeException {
 	}
 
 	public RecognitionException(String message,
-								@Nullable Recognizer<?, ?> recognizer,
-								@Nullable IntStream input,
-								@Nullable ParserRuleContext ctx)
+								Recognizer<?, ?> recognizer,
+								IntStream input,
+								ParserRuleContext ctx)
 	{
 		super(message);
 		this.recognizer = recognizer;
@@ -87,8 +83,8 @@ public class RecognitionException extends RuntimeException {
 	 * {@link LexerNoViableAltException} exceptions, this is the
 	 * {@link DecisionState} number. For others, it is the state whose outgoing
 	 * edge we couldn't match.
-	 * <p/>
-	 * If the state number is not known, this method returns -1.
+	 *
+	 * <p>If the state number is not known, this method returns -1.</p>
 	 */
 	public int getOffendingState() {
 		return offendingState;
@@ -101,14 +97,13 @@ public class RecognitionException extends RuntimeException {
 	/**
 	 * Gets the set of input symbols which could potentially follow the
 	 * previously matched symbol at the time this exception was thrown.
-	 * <p/>
-	 * If the set of expected tokens is not known and could not be computed,
-	 * this method returns {@code null}.
+	 *
+	 * <p>If the set of expected tokens is not known and could not be computed,
+	 * this method returns {@code null}.</p>
 	 *
 	 * @return The set of token types that could potentially follow the current
 	 * state in the ATN, or {@code null} if the information is not available.
 	 */
-	@Nullable
 	public IntervalSet getExpectedTokens() {
 		if (recognizer != null) {
 			return recognizer.getATN().getExpectedTokens(offendingState, ctx);
@@ -119,13 +114,12 @@ public class RecognitionException extends RuntimeException {
 
 	/**
 	 * Gets the {@link RuleContext} at the time this exception was thrown.
-	 * <p/>
-	 * If the context is not available, this method returns {@code null}.
+	 *
+	 * <p>If the context is not available, this method returns {@code null}.</p>
 	 *
 	 * @return The {@link RuleContext} at the time this exception was thrown.
 	 * If the context is not available, this method returns {@code null}.
 	 */
-	@Nullable
 	public RuleContext getCtx() {
 		return ctx;
 	}
@@ -133,36 +127,34 @@ public class RecognitionException extends RuntimeException {
 	/**
 	 * Gets the input stream which is the symbol source for the recognizer where
 	 * this exception was thrown.
-	 * <p/>
-	 * If the input stream is not available, this method returns {@code null}.
+	 *
+	 * <p>If the input stream is not available, this method returns {@code null}.</p>
 	 *
 	 * @return The input stream which is the symbol source for the recognizer
 	 * where this exception was thrown, or {@code null} if the stream is not
 	 * available.
 	 */
-	@Nullable
 	public IntStream getInputStream() {
 		return input;
 	}
 
-	@Nullable
+
 	public Token getOffendingToken() {
 		return offendingToken;
 	}
 
-	protected final void setOffendingToken(@Nullable Token offendingToken) {
+	protected final void setOffendingToken(Token offendingToken) {
 		this.offendingToken = offendingToken;
 	}
 
 	/**
 	 * Gets the {@link Recognizer} where this exception occurred.
-	 * <p/>
-	 * If the recognizer is not available, this method returns {@code null}.
+	 *
+	 * <p>If the recognizer is not available, this method returns {@code null}.</p>
 	 *
 	 * @return The recognizer where this exception occurred, or {@code null} if
 	 * the recognizer is not available.
 	 */
-	@Nullable
 	public Recognizer<?, ?> getRecognizer() {
 		return recognizer;
 	}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/Recognizer.java b/runtime/Java/src/org/antlr/v4/runtime/Recognizer.java
index 1a025ad15..603a39c0f 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/Recognizer.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/Recognizer.java
@@ -32,11 +32,11 @@ package org.antlr.v4.runtime;
 
 import org.antlr.v4.runtime.atn.ATN;
 import org.antlr.v4.runtime.atn.ATNSimulator;
-import org.antlr.v4.runtime.misc.NotNull;
-import org.antlr.v4.runtime.misc.Nullable;
+import org.antlr.v4.runtime.atn.ParseInfo;
 import org.antlr.v4.runtime.misc.Utils;
 
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.WeakHashMap;
@@ -45,12 +45,12 @@ import java.util.concurrent.CopyOnWriteArrayList;
 public abstract class Recognizer<Symbol, ATNInterpreter extends ATNSimulator> {
 	public static final int EOF=-1;
 
-	private static final Map<String[], Map<String, Integer>> tokenTypeMapCache =
-		new WeakHashMap<String[], Map<String, Integer>>();
+	private static final Map<Vocabulary, Map<String, Integer>> tokenTypeMapCache =
+		new WeakHashMap<Vocabulary, Map<String, Integer>>();
 	private static final Map<String[], Map<String, Integer>> ruleIndexMapCache =
 		new WeakHashMap<String[], Map<String, Integer>>();
 
-	@NotNull
+
 	private List<ANTLRErrorListener> _listeners =
 		new CopyOnWriteArrayList<ANTLRErrorListener>() {{
 			add(ConsoleErrorListener.INSTANCE);
@@ -63,30 +63,51 @@ public abstract class Recognizer<Symbol, ATNInterpreter extends ATNSimulator> {
 	/** Used to print out token names like ID during debugging and
 	 *  error reporting.  The generated parsers implement a method
 	 *  that overrides this to point to their String[] tokenNames.
+	 *
+	 * @deprecated Use {@link #getVocabulary()} instead.
 	 */
+	@Deprecated
 	public abstract String[] getTokenNames();
 
 	public abstract String[] getRuleNames();
 
 	/**
-	 * Get a map from token names to token types.
-	 * <p/>
-	 * Used for XPath and tree pattern compilation.
+	 * Get the vocabulary used by the recognizer.
+	 *
+	 * @return A {@link Vocabulary} instance providing information about the
+	 * vocabulary used by the grammar.
 	 */
-	@NotNull
-	public Map<String, Integer> getTokenTypeMap() {
-		String[] tokenNames = getTokenNames();
-		if (tokenNames == null) {
-			throw new UnsupportedOperationException("The current recognizer does not provide a list of token names.");
-		}
+	@SuppressWarnings("deprecation")
+	public Vocabulary getVocabulary() {
+		return VocabularyImpl.fromTokenNames(getTokenNames());
+	}
 
+	/**
+	 * Get a map from token names to token types.
+	 *
+	 * <p>Used for XPath and tree pattern compilation.</p>
+	 */
+	public Map<String, Integer> getTokenTypeMap() {
+		Vocabulary vocabulary = getVocabulary();
 		synchronized (tokenTypeMapCache) {
-			Map<String, Integer> result = tokenTypeMapCache.get(tokenNames);
+			Map<String, Integer> result = tokenTypeMapCache.get(vocabulary);
 			if (result == null) {
-				result = Utils.toMap(tokenNames);
+				result = new HashMap<String, Integer>();
+				for (int i = 0; i < getATN().maxTokenType; i++) {
+					String literalName = vocabulary.getLiteralName(i);
+					if (literalName != null) {
+						result.put(literalName, i);
+					}
+
+					String symbolicName = vocabulary.getSymbolicName(i);
+					if (symbolicName != null) {
+						result.put(symbolicName, i);
+					}
+				}
+
 				result.put("EOF", Token.EOF);
 				result = Collections.unmodifiableMap(result);
-				tokenTypeMapCache.put(tokenNames, result);
+				tokenTypeMapCache.put(vocabulary, result);
 			}
 
 			return result;
@@ -95,10 +116,9 @@ public abstract class Recognizer<Symbol, ATNInterpreter extends ATNSimulator> {
 
 	/**
 	 * Get a map from rule names to rule indexes.
-	 * <p/>
-	 * Used for XPath and tree pattern compilation.
+	 *
+	 * <p>Used for XPath and tree pattern compilation.</p>
 	 */
-	@NotNull
 	public Map<String, Integer> getRuleIndexMap() {
 		String[] ruleNames = getRuleNames();
 		if (ruleNames == null) {
@@ -125,11 +145,10 @@ public abstract class Recognizer<Symbol, ATNInterpreter extends ATNSimulator> {
 	/**
 	 * If this recognizer was generated, it will have a serialized ATN
 	 * representation of the grammar.
-	 * <p/>
-	 * For interpreters, we don't know their serialized ATN despite having
-	 * created the interpreter from it.
+	 *
+	 * <p>For interpreters, we don't know their serialized ATN despite having
+	 * created the interpreter from it.</p>
 	 */
-	@NotNull
 	public String getSerializedATN() {
 		throw new UnsupportedOperationException("there is no serialized ATN");
 	}
@@ -144,7 +163,6 @@ public abstract class Recognizer<Symbol, ATNInterpreter extends ATNSimulator> {
 	 *
 	 * @return The {@link ATN} used by the recognizer for prediction.
 	 */
-	@NotNull
 	public abstract ATN getATN();
 
 	/**
@@ -152,24 +170,31 @@ public abstract class Recognizer<Symbol, ATNInterpreter extends ATNSimulator> {
 	 *
 	 * @return The ATN interpreter used by the recognizer for prediction.
 	 */
-	@NotNull
 	public ATNInterpreter getInterpreter() {
 		return _interp;
 	}
 
+	/** If profiling during the parse/lex, this will return DecisionInfo records
+	 *  for each decision in recognizer in a ParseInfo object.
+	 *
+	 * @since 4.3
+	 */
+	public ParseInfo getParseInfo() {
+		return null;
+	}
+
 	/**
 	 * Set the ATN interpreter used by the recognizer for prediction.
 	 *
 	 * @param interpreter The ATN interpreter used by the recognizer for
 	 * prediction.
 	 */
-	public void setInterpreter(@NotNull ATNInterpreter interpreter) {
+	public void setInterpreter(ATNInterpreter interpreter) {
 		_interp = interpreter;
 	}
 
 	/** What is the error header, normally line/character position information? */
-	@NotNull
-	public String getErrorHeader(@NotNull RecognitionException e) {
+	public String getErrorHeader(RecognitionException e) {
 		int line = e.getOffendingToken().getLine();
 		int charPositionInLine = e.getOffendingToken().getCharPositionInLine();
 		return "line "+line+":"+charPositionInLine;
@@ -182,7 +207,13 @@ public abstract class Recognizer<Symbol, ATNInterpreter extends ATNSimulator> {
 	 *  the token). This is better than forcing you to override a method in
 	 *  your token objects because you don't have to go modify your lexer
 	 *  so that it creates a new Java type.
+	 *
+	 * @deprecated This method is not called by the ANTLR 4 Runtime. Specific
+	 * implementations of {@link ANTLRErrorStrategy} may provide a similar
+	 * feature when necessary. For example, see
+	 * {@link DefaultErrorStrategy#getTokenErrorDisplay}.
 	 */
+	@Deprecated
 	public String getTokenErrorDisplay(Token t) {
 		if ( t==null ) return "<no token>";
 		String s = t.getText();
@@ -203,7 +234,7 @@ public abstract class Recognizer<Symbol, ATNInterpreter extends ATNSimulator> {
 	/**
 	 * @exception NullPointerException if {@code listener} is {@code null}.
 	 */
-	public void addErrorListener(@NotNull ANTLRErrorListener listener) {
+	public void addErrorListener(ANTLRErrorListener listener) {
 		if (listener == null) {
 			throw new NullPointerException("listener cannot be null.");
 		}
@@ -211,7 +242,7 @@ public abstract class Recognizer<Symbol, ATNInterpreter extends ATNSimulator> {
 		_listeners.add(listener);
 	}
 
-	public void removeErrorListener(@NotNull ANTLRErrorListener listener) {
+	public void removeErrorListener(ANTLRErrorListener listener) {
 		_listeners.remove(listener);
 	}
 
@@ -219,7 +250,7 @@ public abstract class Recognizer<Symbol, ATNInterpreter extends ATNSimulator> {
 		_listeners.clear();
 	}
 
-	@NotNull
+
 	public List<? extends ANTLRErrorListener> getErrorListeners() {
 		return _listeners;
 	}
@@ -230,15 +261,15 @@ public abstract class Recognizer<Symbol, ATNInterpreter extends ATNSimulator> {
 
 	// subclass needs to override these if there are sempreds or actions
 	// that the ATN interp needs to execute
-	public boolean sempred(@Nullable RuleContext _localctx, int ruleIndex, int actionIndex) {
+	public boolean sempred(RuleContext _localctx, int ruleIndex, int actionIndex) {
 		return true;
 	}
 
-	public boolean precpred(@Nullable RuleContext localctx, int precedence) {
+	public boolean precpred(RuleContext localctx, int precedence) {
 		return true;
 	}
 
-	public void action(@Nullable RuleContext _localctx, int ruleIndex, int actionIndex) {
+	public void action(RuleContext _localctx, int ruleIndex, int actionIndex) {
 	}
 
 	public final int getState() {
@@ -262,8 +293,8 @@ public abstract class Recognizer<Symbol, ATNInterpreter extends ATNSimulator> {
 
 	public abstract void setInputStream(IntStream input);
 
-	@NotNull
+
 	public abstract TokenFactory<?> getTokenFactory();
 
-	public abstract void setTokenFactory(@NotNull TokenFactory<?> input);
+	public abstract void setTokenFactory(TokenFactory<?> input);
 }
diff --git a/runtime/Java/src/org/antlr/v4/runtime/RuleContext.java b/runtime/Java/src/org/antlr/v4/runtime/RuleContext.java
index 4457b7d94..010396625 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/RuleContext.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/RuleContext.java
@@ -29,31 +29,56 @@
  */
 package org.antlr.v4.runtime;
 
+import org.antlr.v4.runtime.atn.ATN;
 import org.antlr.v4.runtime.misc.Interval;
-import org.antlr.v4.runtime.misc.Nullable;
 import org.antlr.v4.runtime.tree.ParseTree;
 import org.antlr.v4.runtime.tree.ParseTreeVisitor;
 import org.antlr.v4.runtime.tree.RuleNode;
 import org.antlr.v4.runtime.tree.Trees;
-import org.antlr.v4.runtime.tree.gui.TreeViewer;
 
-import javax.print.PrintException;
-import javax.swing.*;
-import java.io.IOException;
 import java.util.Arrays;
 import java.util.List;
-import java.util.concurrent.Future;
 
-/** A rule context is a record of a single rule invocation. It knows
- *  which context invoked it, if any. If there is no parent context, then
- *  naturally the invoking state is not valid.  The parent link
- *  provides a chain upwards from the current rule invocation to the root
- *  of the invocation tree, forming a stack. We actually carry no
- *  information about the rule associated with this context (except
- *  when parsing). We keep only the state number of the invoking state from
- *  the ATN submachine that invoked this. Contrast this with the s
- *  pointer inside ParserRuleContext that tracks the current state
- *  being "executed" for the current rule.
+/** A rule context is a record of a single rule invocation.
+ *
+ *  We form a stack of these context objects using the parent
+ *  pointer. A parent pointer of null indicates that the current
+ *  context is the bottom of the stack. The ParserRuleContext subclass
+ *  as a children list so that we can turn this data structure into a
+ *  tree.
+ *
+ *  The root node always has a null pointer and invokingState of -1.
+ *
+ *  Upon entry to parsing, the first invoked rule function creates a
+ *  context object (asubclass specialized for that rule such as
+ *  SContext) and makes it the root of a parse tree, recorded by field
+ *  Parser._ctx.
+ *
+ *  public final SContext s() throws RecognitionException {
+ *      SContext _localctx = new SContext(_ctx, getState()); <-- create new node
+ *      enterRule(_localctx, 0, RULE_s);                     <-- push it
+ *      ...
+ *      exitRule();                                          <-- pop back to _localctx
+ *      return _localctx;
+ *  }
+ *
+ *  A subsequent rule invocation of r from the start rule s pushes a
+ *  new context object for r whose parent points at s and use invoking
+ *  state is the state with r emanating as edge label.
+ *
+ *  The invokingState fields from a context object to the root
+ *  together form a stack of rule indication states where the root
+ *  (bottom of the stack) has a -1 sentinel value. If we invoke start
+ *  symbol s then call r1, which calls r2, the  would look like
+ *  this:
+ *
+ *     SContext[-1]   <- root node (bottom of the stack)
+ *     R1Context[p]   <- p in rule s called r1
+ *     R2Context[q]   <- q in rule r1 called r2
+ *
+ *  So the top of the stack, _ctx, represents a call to the current
+ *  rule and it holds the return address from another rule that invoke
+ *  to this rule. To invoke a rule, we must always have a current context.
  *
  *  The parent contexts are useful for computing lookahead sets and
  *  getting error information.
@@ -72,7 +97,8 @@ public class RuleContext implements RuleNode {
 
 	/** What state invoked the rule associated with this context?
 	 *  The "return address" is the followState of invokingState
-	 *  If parent is null, this should be -1.
+	 *  If parent is null, this should be -1 this context object represents
+	 *  the start rule.
 	 */
 	public int invokingState = -1;
 
@@ -94,7 +120,7 @@ public class RuleContext implements RuleNode {
 		return n;
 	}
 
-	/** A context is empty if there is no invoking state; meaning nobody call
+	/** A context is empty if there is no invoking state; meaning nobody called
 	 *  current context.
 	 */
 	public boolean isEmpty() {
@@ -140,6 +166,27 @@ public class RuleContext implements RuleNode {
 
 	public int getRuleIndex() { return -1; }
 
+	/** For rule associated with this parse tree internal node, return
+	 *  the outer alternative number used to match the input. Default
+	 *  implementation does not compute nor store this alt num. Create
+	 *  a subclass of ParserRuleContext with backing field and set
+	 *  option contextSuperClass.
+	 *  to set it.
+	 *
+	 *  @since 4.5.3
+	 */
+	public int getAltNumber() { return ATN.INVALID_ALT_NUMBER; }
+
+	/** Set the outer alternative number for this context node. Default
+	 *  implementation does nothing to avoid backing field overhead for
+	 *  trees that don't need it.  Create
+     *  a subclass of ParserRuleContext with backing field and set
+     *  option contextSuperClass.
+	 *
+	 *  @since 4.5.3
+	 */
+	public void setAltNumber(int altNumber) { }
+
 	@Override
 	public ParseTree getChild(int i) {
 		return null;
@@ -153,62 +200,19 @@ public class RuleContext implements RuleNode {
 	@Override
 	public <T> T accept(ParseTreeVisitor<? extends T> visitor) { return visitor.visitChildren(this); }
 
-	/** Call this method to view a parse tree in a dialog box visually. */
-	public Future<JDialog> inspect(@Nullable Parser parser) {
-		List<String> ruleNames = parser != null ? Arrays.asList(parser.getRuleNames()) : null;
-		return inspect(ruleNames);
-	}
-
-	public Future<JDialog> inspect(@Nullable List<String> ruleNames) {
-		TreeViewer viewer = new TreeViewer(ruleNames, this);
-		return viewer.open();
-	}
-
-	/** Save this tree in a postscript file */
-	public void save(@Nullable Parser parser, String fileName)
-		throws IOException, PrintException
-	{
-		List<String> ruleNames = parser != null ? Arrays.asList(parser.getRuleNames()) : null;
-		save(ruleNames, fileName);
-	}
-
-	/** Save this tree in a postscript file using a particular font name and size */
-	public void save(@Nullable Parser parser, String fileName,
-					 String fontName, int fontSize)
-		throws IOException
-	{
-		List<String> ruleNames = parser != null ? Arrays.asList(parser.getRuleNames()) : null;
-		save(ruleNames, fileName, fontName, fontSize);
-	}
-
-	/** Save this tree in a postscript file */
-	public void save(@Nullable List<String> ruleNames, String fileName)
-		throws IOException, PrintException
-	{
-		Trees.writePS(this, ruleNames, fileName);
-	}
-
-	/** Save this tree in a postscript file using a particular font name and size */
-	public void save(@Nullable List<String> ruleNames, String fileName,
-					 String fontName, int fontSize)
-		throws IOException
-	{
-		Trees.writePS(this, ruleNames, fileName, fontName, fontSize);
-	}
-
 	/** Print out a whole tree, not just a node, in LISP format
 	 *  (root child1 .. childN). Print just a node if this is a leaf.
 	 *  We have to know the recognizer so we can get rule names.
 	 */
 	@Override
-	public String toStringTree(@Nullable Parser recog) {
+	public String toStringTree(Parser recog) {
 		return Trees.toStringTree(this, recog);
 	}
 
 	/** Print out a whole tree, not just a node, in LISP format
 	 *  (root child1 .. childN). Print just a node if this is a leaf.
 	 */
-	public String toStringTree(@Nullable List<String> ruleNames) {
+	public String toStringTree(List<String> ruleNames) {
 		return Trees.toStringTree(this, ruleNames);
 	}
 
@@ -222,22 +226,22 @@ public class RuleContext implements RuleNode {
 		return toString((List<String>)null, (RuleContext)null);
 	}
 
-	public final String toString(@Nullable Recognizer<?,?> recog) {
+	public final String toString(Recognizer<?,?> recog) {
 		return toString(recog, ParserRuleContext.EMPTY);
 	}
 
-	public final String toString(@Nullable List<String> ruleNames) {
+	public final String toString(List<String> ruleNames) {
 		return toString(ruleNames, null);
 	}
 
 	// recog null unless ParserRuleContext, in which case we use subclass toString(...)
-	public String toString(@Nullable Recognizer<?,?> recog, @Nullable RuleContext stop) {
+	public String toString(Recognizer<?,?> recog, RuleContext stop) {
 		String[] ruleNames = recog != null ? recog.getRuleNames() : null;
 		List<String> ruleNamesList = ruleNames != null ? Arrays.asList(ruleNames) : null;
 		return toString(ruleNamesList, stop);
 	}
 
-	public String toString(@Nullable List<String> ruleNames, @Nullable RuleContext stop) {
+	public String toString(List<String> ruleNames, RuleContext stop) {
 		StringBuilder buf = new StringBuilder();
 		RuleContext p = this;
 		buf.append("[");
diff --git a/runtime/Java/src/org/antlr/v4/runtime/RuleContextWithAltNum.java b/runtime/Java/src/org/antlr/v4/runtime/RuleContextWithAltNum.java
new file mode 100644
index 000000000..63d3b22ce
--- /dev/null
+++ b/runtime/Java/src/org/antlr/v4/runtime/RuleContextWithAltNum.java
@@ -0,0 +1,24 @@
+package org.antlr.v4.runtime;
+
+import org.antlr.v4.runtime.atn.ATN;
+
+/** A handy class for use with
+ *
+ *  options {contextSuperClass=org.antlr.v4.runtime.RuleContextWithAltNum;}
+ *
+ *  that provides a backing field / impl for the outer alternative number
+ *  matched for an internal parse tree node.
+ *
+ *  I'm only putting into Java runtime as I'm certain I'm the only one that
+ *  will really every use this.
+ */
+public class RuleContextWithAltNum extends ParserRuleContext {
+	public int altNum;
+	public RuleContextWithAltNum() { altNum = ATN.INVALID_ALT_NUMBER; }
+
+	public RuleContextWithAltNum(ParserRuleContext parent, int invokingStateNumber) {
+		super(parent, invokingStateNumber);
+	}
+	@Override public int getAltNumber() { return altNum; }
+	@Override public void setAltNumber(int altNum) { this.altNum = altNum; }
+}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/RuntimeMetaData.java b/runtime/Java/src/org/antlr/v4/runtime/RuntimeMetaData.java
new file mode 100644
index 000000000..b8bf0d589
--- /dev/null
+++ b/runtime/Java/src/org/antlr/v4/runtime/RuntimeMetaData.java
@@ -0,0 +1,217 @@
+/*
+ * [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.
+ */
+
+package org.antlr.v4.runtime;
+
+/**
+ * This class provides access to the current version of the ANTLR 4 runtime
+ * library as compile-time and runtime constants, along with methods for
+ * checking for matching version numbers and notifying listeners in the case
+ * where a version mismatch is detected.
+ *
+ * <p>
+ * The runtime version information is provided by {@link #VERSION} and
+ * {@link #getRuntimeVersion()}. Detailed information about these values is
+ * provided in the documentation for each member.</p>
+ *
+ * <p>
+ * The runtime version check is implemented by {@link #checkVersion}. Detailed
+ * information about incorporating this call into user code, as well as its use
+ * in generated code, is provided in the documentation for the method.</p>
+ *
+ * <p>
+ * Version strings x.y and x.y.z are considered "compatible" and no error
+ * would be generated. Likewise, version strings x.y-SNAPSHOT and x.y.z are
+ * considered "compatible" because the major and minor components x.y
+ * are the same in each.</p>
+ *
+ * <p>
+ * To trap any error messages issued by this code, use System.setErr()
+ * in your main() startup code.
+ * </p>
+ *
+ * @since 4.3
+ */
+public class RuntimeMetaData {
+	/**
+	 * A compile-time constant containing the current version of the ANTLR 4
+	 * runtime library.
+	 *
+	 * <p>
+	 * This compile-time constant value allows generated parsers and other
+	 * libraries to include a literal reference to the version of the ANTLR 4
+	 * runtime library the code was compiled against. At each release, we
+	 * change this value.</p>
+	 *
+	 * <p>Version numbers are assumed to have the form
+	 *
+	 * <em>major</em>.<em>minor</em>.<em>patch</em>.<em>revision</em>-<em>suffix</em>,
+	 *
+	 * with the individual components defined as follows.</p>
+	 *
+	 * <ul>
+	 * <li><em>major</em> is a required non-negative integer, and is equal to
+	 * {@code 4} for ANTLR 4.</li>
+	 * <li><em>minor</em> is a required non-negative integer.</li>
+	 * <li><em>patch</em> is an optional non-negative integer. When
+	 * <em>patch</em> is omitted, the {@code .} (dot) appearing before it is
+	 * also omitted.</li>
+	 * <li><em>revision</em> is an optional non-negative integer, and may only
+	 * be included when <em>patch</em> is also included. When <em>revision</em>
+	 * is omitted, the {@code .} (dot) appearing before it is also omitted.</li>
+	 * <li><em>suffix</em> is an optional string. When <em>suffix</em> is
+	 * omitted, the {@code -} (hyphen-minus) appearing before it is also
+	 * omitted.</li>
+	 * </ul>
+	 */
+	public static final String VERSION = "4.5.3";
+
+	/**
+	 * Gets the currently executing version of the ANTLR 4 runtime library.
+	 *
+	 * <p>
+	 * This method provides runtime access to the {@link #VERSION} field, as
+	 * opposed to directly referencing the field as a compile-time constant.</p>
+	 *
+	 * @return The currently executing version of the ANTLR 4 library
+	 */
+
+	public static String getRuntimeVersion() {
+		return VERSION;
+	}
+
+	/**
+	 * This method provides the ability to detect mismatches between the version
+	 * of ANTLR 4 used to generate a parser, the version of the ANTLR runtime a
+	 * parser was compiled against, and the version of the ANTLR runtime which
+	 * is currently executing.
+	 *
+	 * <p>
+	 * The version check is designed to detect the following two specific
+	 * scenarios.</p>
+	 *
+	 * <ul>
+	 * <li>The ANTLR Tool version used for code generation does not match the
+	 * currently executing runtime version.</li>
+	 * <li>The ANTLR Runtime version referenced at the time a parser was
+	 * compiled does not match the currently executing runtime version.</li>
+	 * </ul>
+	 *
+	 * <p>
+	 * Starting with ANTLR 4.3, the code generator emits a call to this method
+	 * using two constants in each generated lexer and parser: a hard-coded
+	 * constant indicating the version of the tool used to generate the parser
+	 * and a reference to the compile-time constant {@link #VERSION}. At
+	 * runtime, this method is called during the initialization of the generated
+	 * parser to detect mismatched versions, and notify the registered listeners
+	 * prior to creating instances of the parser.</p>
+	 *
+	 * <p>
+	 * This method does not perform any detection or filtering of semantic
+	 * changes between tool and runtime versions. It simply checks for a
+	 * version match and emits an error to stderr if a difference
+	 * is detected.</p>
+	 *
+	 * <p>
+	 * Note that some breaking changes between releases could result in other
+	 * types of runtime exceptions, such as a {@link LinkageError}, prior to
+	 * calling this method. In these cases, the underlying version mismatch will
+	 * not be reported here. This method is primarily intended to
+	 * notify users of potential semantic changes between releases that do not
+	 * result in binary compatibility problems which would be detected by the
+	 * class loader. As with semantic changes, changes that break binary
+	 * compatibility between releases are mentioned in the release notes
+	 * accompanying the affected release.</p>
+	 *
+	 * <p>
+	 * <strong>Additional note for target developers:</strong> The version check
+	 * implemented by this class is designed to address specific compatibility
+	 * concerns that may arise during the execution of Java applications. Other
+	 * targets should consider the implementation of this method in the context
+	 * of that target's known execution environment, which may or may not
+	 * resemble the design provided for the Java target.</p>
+	 *
+	 * @param generatingToolVersion The version of the tool used to generate a parser.
+	 * This value may be null when called from user code that was not generated
+	 * by, and does not reference, the ANTLR 4 Tool itself.
+	 * @param compileTimeVersion The version of the runtime the parser was
+	 * compiled against. This should always be passed using a direct reference
+	 * to {@link #VERSION}.
+	 */
+	public static void checkVersion(String generatingToolVersion, String compileTimeVersion) {
+		String runtimeVersion = VERSION;
+		boolean runtimeConflictsWithGeneratingTool = false;
+		boolean runtimeConflictsWithCompileTimeTool = false;
+
+		if ( generatingToolVersion!=null ) {
+			runtimeConflictsWithGeneratingTool =
+				!runtimeVersion.equals(generatingToolVersion) &&
+				!getMajorMinorVersion(runtimeVersion).equals(getMajorMinorVersion(generatingToolVersion));
+		}
+
+		runtimeConflictsWithCompileTimeTool =
+			!runtimeVersion.equals(compileTimeVersion) &&
+			!getMajorMinorVersion(runtimeVersion).equals(getMajorMinorVersion(compileTimeVersion));
+
+		if ( runtimeConflictsWithGeneratingTool ) {
+			System.err.printf("ANTLR Tool version %s used for code generation does not match the current runtime version %s",
+							  generatingToolVersion, runtimeVersion);
+		}
+		if ( runtimeConflictsWithCompileTimeTool ) {
+			System.err.printf("ANTLR Runtime version %s used for parser compilation does not match the current runtime version %s",
+							  compileTimeVersion, runtimeVersion);
+		}
+	}
+
+	/**
+	 * Gets the major and minor version numbers from a version string. For
+	 * details about the syntax of the input {@code version}.
+	 * E.g., from x.y.z return x.y.
+	 *
+	 * @param version The complete version string.
+	 * @return A string of the form <em>major</em>.<em>minor</em> containing
+	 * only the major and minor components of the version string.
+	 */
+	public static String getMajorMinorVersion(String version) {
+		int firstDot = version.indexOf('.');
+		int secondDot = firstDot >= 0 ? version.indexOf('.', firstDot + 1) : -1;
+		int firstDash = version.indexOf('-');
+		int referenceLength = version.length();
+		if (secondDot >= 0) {
+			referenceLength = Math.min(referenceLength, secondDot);
+		}
+
+		if (firstDash >= 0) {
+			referenceLength = Math.min(referenceLength, firstDash);
+		}
+
+		return version.substring(0, referenceLength);
+	}
+}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/Token.java b/runtime/Java/src/org/antlr/v4/runtime/Token.java
index 0ea2deb63..59c694df3 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/Token.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/Token.java
@@ -57,6 +57,19 @@ public interface Token {
 	 */
 	public static final int HIDDEN_CHANNEL = 1;
 
+	/**
+	 * This is the minimum constant value which can be assigned to a
+	 * user-defined token channel.
+	 *
+	 * <p>
+	 * The non-negative numbers less than {@link #MIN_USER_CHANNEL_VALUE} are
+	 * assigned to the predefined channels {@link #DEFAULT_CHANNEL} and
+	 * {@link #HIDDEN_CHANNEL}.</p>
+	 *
+	 * @see Token#getChannel()
+	 */
+	public static final int MIN_USER_CHANNEL_VALUE = 2;
+
 	/**
 	 * Get the text of the token.
 	 */
diff --git a/runtime/Java/src/org/antlr/v4/runtime/TokenFactory.java b/runtime/Java/src/org/antlr/v4/runtime/TokenFactory.java
index ac92ccb6b..a7b95aa0f 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/TokenFactory.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/TokenFactory.java
@@ -30,7 +30,6 @@
 
 package org.antlr.v4.runtime;
 
-import org.antlr.v4.runtime.misc.NotNull;
 import org.antlr.v4.runtime.misc.Pair;
 
 /** The default mechanism for creating tokens. It's used by default in Lexer and
@@ -42,12 +41,10 @@ public interface TokenFactory<Symbol extends Token> {
 	 *  error handling strategy. If text!=null, than the start and stop positions
 	 *  are wiped to -1 in the text override is set in the CommonToken.
 	 */
-	@NotNull
-	Symbol create(@NotNull Pair<TokenSource, CharStream> source, int type, String text,
+	Symbol create(Pair<TokenSource, CharStream> source, int type, String text,
 				  int channel, int start, int stop,
 				  int line, int charPositionInLine);
 
 	/** Generically useful */
-	@NotNull
 	Symbol create(int type, String text);
 }
diff --git a/runtime/Java/src/org/antlr/v4/runtime/TokenSource.java b/runtime/Java/src/org/antlr/v4/runtime/TokenSource.java
index 4f8190b19..992b0eac6 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/TokenSource.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/TokenSource.java
@@ -29,23 +29,20 @@
  */
 package org.antlr.v4.runtime;
 
-import org.antlr.v4.runtime.misc.NotNull;
-import org.antlr.v4.runtime.misc.Nullable;
-
 /**
  * A source of tokens must provide a sequence of tokens via {@link #nextToken()}
  * and also must reveal it's source of characters; {@link CommonToken}'s text is
  * computed from a {@link CharStream}; it only store indices into the char
  * stream.
- * <p/>
- * Errors from the lexer are never passed to the parser. Either you want to keep
+ *
+ * <p>Errors from the lexer are never passed to the parser. Either you want to keep
  * going or you do not upon token recognition error. If you do not want to
  * continue lexing then you do not want to continue parsing. Just throw an
  * exception not under {@link RecognitionException} and Java will naturally toss
  * you all the way out of the recognizers. If you want to continue lexing then
  * you should not throw an exception to the parser--it has already requested a
  * token. Keep lexing until you get a valid one. Just report errors and keep
- * going, looking for a valid token.
+ * going, looking for a valid token.</p>
  */
 public interface TokenSource {
 	/**
@@ -54,7 +51,6 @@ public interface TokenSource {
 	 * on the characters until you get a good one; errors are not passed through
 	 * to the parser.
 	 */
-	@NotNull
 	public Token nextToken();
 
 	/**
@@ -83,7 +79,6 @@ public interface TokenSource {
 	 * the input, or {@code null} if no input stream is available for the token
 	 * source.
 	 */
-	@Nullable
 	public CharStream getInputStream();
 
 	/**
@@ -99,7 +94,7 @@ public interface TokenSource {
 	 *
 	 * @param factory The {@link TokenFactory} to use for creating tokens.
 	 */
-	public void setTokenFactory(@NotNull TokenFactory<?> factory);
+	public void setTokenFactory(TokenFactory<?> factory);
 
 	/**
 	 * Gets the {@link TokenFactory} this token source is currently using for
@@ -107,6 +102,5 @@ public interface TokenSource {
 	 *
 	 * @return The {@link TokenFactory} currently used by this token source.
 	 */
-	@NotNull
 	public TokenFactory<?> getTokenFactory();
 }
diff --git a/runtime/Java/src/org/antlr/v4/runtime/TokenStream.java b/runtime/Java/src/org/antlr/v4/runtime/TokenStream.java
index 64e5bee71..7bc2374b6 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/TokenStream.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/TokenStream.java
@@ -31,7 +31,6 @@
 package org.antlr.v4.runtime;
 
 import org.antlr.v4.runtime.misc.Interval;
-import org.antlr.v4.runtime.misc.NotNull;
 
 /**
  * An {@link IntStream} whose symbols are {@link Token} instances.
@@ -46,35 +45,32 @@ public interface TokenStream extends IntStream {
 	 *
 	 * @see IntStream#LA
 	 */
-	@NotNull
 	public Token LT(int k);
 
 	/**
 	 * Gets the {@link Token} at the specified {@code index} in the stream. When
 	 * the preconditions of this method are met, the return value is non-null.
-	 * <p/>
-	 * The preconditions for this method are the same as the preconditions of
+	 *
+	 * <p>The preconditions for this method are the same as the preconditions of
 	 * {@link IntStream#seek}. If the behavior of {@code seek(index)} is
 	 * unspecified for the current state and given {@code index}, then the
-	 * behavior of this method is also unspecified.
-	 * <p/>
-	 * The symbol referred to by {@code index} differs from {@code seek()} only
+	 * behavior of this method is also unspecified.</p>
+	 *
+	 * <p>The symbol referred to by {@code index} differs from {@code seek()} only
 	 * in the case of filtering streams where {@code index} lies before the end
 	 * of the stream. Unlike {@code seek()}, this method does not adjust
-	 * {@code index} to point to a non-ignored symbol.
+	 * {@code index} to point to a non-ignored symbol.</p>
 	 *
 	 * @throws IllegalArgumentException if {code index} is less than 0
 	 * @throws UnsupportedOperationException if the stream does not support
 	 * retrieving the token at the specified index
 	 */
-	@NotNull
 	public Token get(int index);
 
 	/**
 	 * Gets the underlying {@link TokenSource} which provides tokens for this
 	 * stream.
 	 */
-	@NotNull
 	public TokenSource getTokenSource();
 
 	/**
@@ -86,7 +82,7 @@ public interface TokenStream extends IntStream {
 	 * <pre>
 	 * TokenStream stream = ...;
 	 * String text = "";
-	 * for (int i = interval.a; i <= interval.b; i++) {
+	 * for (int i = interval.a; i &lt;= interval.b; i++) {
 	 *   text += stream.get(i).getText();
 	 * }
 	 * </pre>
@@ -98,8 +94,7 @@ public interface TokenStream extends IntStream {
 	 *
 	 * @throws NullPointerException if {@code interval} is {@code null}
 	 */
-	@NotNull
-	public String getText(@NotNull Interval interval);
+	public String getText(Interval interval);
 
 	/**
 	 * Return the text of all tokens in the stream. This method behaves like the
@@ -114,7 +109,6 @@ public interface TokenStream extends IntStream {
 	 *
 	 * @return The text of all tokens in the stream.
 	 */
-	@NotNull
 	public String getText();
 
 	/**
@@ -122,9 +116,9 @@ public interface TokenStream extends IntStream {
 	 * context. This method behaves like the following code, including potential
 	 * exceptions from the call to {@link #getText(Interval)}, but may be
 	 * optimized by the specific implementation.
-	 * </p>
-	 * If {@code ctx.getSourceInterval()} does not return a valid interval of
-	 * tokens provided by this stream, the behavior is unspecified.
+	 *
+	 * <p>If {@code ctx.getSourceInterval()} does not return a valid interval of
+	 * tokens provided by this stream, the behavior is unspecified.</p>
 	 *
 	 * <pre>
 	 * TokenStream stream = ...;
@@ -135,26 +129,25 @@ public interface TokenStream extends IntStream {
 	 * text for.
 	 * @return The text of all tokens within the source interval of {@code ctx}.
 	 */
-	@NotNull
-	public String getText(@NotNull RuleContext ctx);
+	public String getText(RuleContext ctx);
 
 	/**
 	 * Return the text of all tokens in this stream between {@code start} and
 	 * {@code stop} (inclusive).
-	 * <p/>
-	 * If the specified {@code start} or {@code stop} token was not provided by
+	 *
+	 * <p>If the specified {@code start} or {@code stop} token was not provided by
 	 * this stream, or if the {@code stop} occurred before the {@code start}
-	 * token, the behavior is unspecified.
-	 * <p/>
-	 * For streams which ensure that the {@link Token#getTokenIndex} method is
+	 * token, the behavior is unspecified.</p>
+	 *
+	 * <p>For streams which ensure that the {@link Token#getTokenIndex} method is
 	 * accurate for all of its provided tokens, this method behaves like the
 	 * following code. Other streams may implement this method in other ways
-	 * provided the behavior is consistent with this at a high level.
+	 * provided the behavior is consistent with this at a high level.</p>
 	 *
 	 * <pre>
 	 * TokenStream stream = ...;
 	 * String text = "";
-	 * for (int i = start.getTokenIndex(); i <= stop.getTokenIndex(); i++) {
+	 * for (int i = start.getTokenIndex(); i &lt;= stop.getTokenIndex(); i++) {
 	 *   text += stream.get(i).getText();
 	 * }
 	 * </pre>
@@ -167,6 +160,5 @@ public interface TokenStream extends IntStream {
 	 * @throws UnsupportedOperationException if this stream does not support
 	 * this method for the specified tokens
 	 */
-	@NotNull
-	public String getText(@NotNull Token start, @NotNull Token stop);
+	public String getText(Token start, Token stop);
 }
diff --git a/runtime/Java/src/org/antlr/v4/runtime/TokenStreamRewriter.java b/runtime/Java/src/org/antlr/v4/runtime/TokenStreamRewriter.java
index 9b569b20d..c9b74c18e 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/TokenStreamRewriter.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/TokenStreamRewriter.java
@@ -30,86 +30,100 @@
 package org.antlr.v4.runtime;
 
 import org.antlr.v4.runtime.misc.Interval;
-import org.antlr.v4.runtime.misc.Nullable;
 
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
-/** Useful for rewriting out a buffered input token stream after doing some
- *  augmentation or other manipulations on it.
+/**
+ * Useful for rewriting out a buffered input token stream after doing some
+ * augmentation or other manipulations on it.
  *
- *  You can insert stuff, replace, and delete chunks.  Note that the
- *  operations are done lazily--only if you convert the buffer to a
- *  String with getText(). This is very efficient because you are not moving
- *  data around all the time.  As the buffer of tokens is converted to strings,
- *  the getText() method(s) scan the input token stream and check
- *  to see if there is an operation at the current index.
- *  If so, the operation is done and then normal String
- *  rendering continues on the buffer.  This is like having multiple Turing
- *  machine instruction streams (programs) operating on a single input tape. :)
+ * <p>
+ * You can insert stuff, replace, and delete chunks. Note that the operations
+ * are done lazily--only if you convert the buffer to a {@link String} with
+ * {@link TokenStream#getText()}. This is very efficient because you are not
+ * moving data around all the time. As the buffer of tokens is converted to
+ * strings, the {@link #getText()} method(s) scan the input token stream and
+ * check to see if there is an operation at the current index. If so, the
+ * operation is done and then normal {@link String} rendering continues on the
+ * buffer. This is like having multiple Turing machine instruction streams
+ * (programs) operating on a single input tape. :)</p>
  *
- *  This rewriter makes no modifications to the token stream. It does not
- *  ask the stream to fill itself up nor does it advance the input cursor.
- *  The token stream index() will return the same value before and after
- *  any getText() call.
+ * <p>
+ * This rewriter makes no modifications to the token stream. It does not ask the
+ * stream to fill itself up nor does it advance the input cursor. The token
+ * stream {@link TokenStream#index()} will return the same value before and
+ * after any {@link #getText()} call.</p>
  *
- *  The rewriter only works on tokens that you have in the buffer and
- *  ignores the current input cursor. If you are buffering tokens on-demand,
- *  calling getText() halfway through the input will only do rewrites
- *  for those tokens in the first half of the file.
+ * <p>
+ * The rewriter only works on tokens that you have in the buffer and ignores the
+ * current input cursor. If you are buffering tokens on-demand, calling
+ * {@link #getText()} halfway through the input will only do rewrites for those
+ * tokens in the first half of the file.</p>
  *
- *  Since the operations are done lazily at getText-time, operations do not
- *  screw up the token index values.  That is, an insert operation at token
- *  index i does not change the index values for tokens i+1..n-1.
+ * <p>
+ * Since the operations are done lazily at {@link #getText}-time, operations do
+ * not screw up the token index values. That is, an insert operation at token
+ * index {@code i} does not change the index values for tokens
+ * {@code i}+1..n-1.</p>
  *
- *  Because operations never actually alter the buffer, you may always get
- *  the original token stream back without undoing anything.  Since
- *  the instructions are queued up, you can easily simulate transactions and
- *  roll back any changes if there is an error just by removing instructions.
- *  For example,
+ * <p>
+ * Because operations never actually alter the buffer, you may always get the
+ * original token stream back without undoing anything. Since the instructions
+ * are queued up, you can easily simulate transactions and roll back any changes
+ * if there is an error just by removing instructions. For example,</p>
  *
- *   CharStream input = new ANTLRFileStream("input");
- *   TLexer lex = new TLexer(input);
- *   CommonTokenStream tokens = new CommonTokenStream(lex);
- *   T parser = new T(tokens);
- *   TokenStreamRewriter rewriter = new TokenStreamRewriter(tokens);
- *   parser.startRule();
+ * <pre>
+ * CharStream input = new ANTLRFileStream("input");
+ * TLexer lex = new TLexer(input);
+ * CommonTokenStream tokens = new CommonTokenStream(lex);
+ * T parser = new T(tokens);
+ * TokenStreamRewriter rewriter = new TokenStreamRewriter(tokens);
+ * parser.startRule();
+ * </pre>
  *
- * 	 Then in the rules, you can execute (assuming rewriter is visible):
- *      Token t,u;
- *      ...
- *      rewriter.insertAfter(t, "text to put after t");}
- * 		rewriter.insertAfter(u, "text after u");}
- * 		System.out.println(tokens.toString());
+ * <p>
+ * Then in the rules, you can execute (assuming rewriter is visible):</p>
  *
- *  You can also have multiple "instruction streams" and get multiple
- *  rewrites from a single pass over the input.  Just name the instruction
- *  streams and use that name again when printing the buffer.  This could be
- *  useful for generating a C file and also its header file--all from the
- *  same buffer:
+ * <pre>
+ * Token t,u;
+ * ...
+ * rewriter.insertAfter(t, "text to put after t");}
+ * rewriter.insertAfter(u, "text after u");}
+ * System.out.println(rewriter.getText());
+ * </pre>
  *
- *      tokens.insertAfter("pass1", t, "text to put after t");}
- * 		tokens.insertAfter("pass2", u, "text after u");}
- * 		System.out.println(tokens.toString("pass1"));
- * 		System.out.println(tokens.toString("pass2"));
+ * <p>
+ * You can also have multiple "instruction streams" and get multiple rewrites
+ * from a single pass over the input. Just name the instruction streams and use
+ * that name again when printing the buffer. This could be useful for generating
+ * a C file and also its header file--all from the same buffer:</p>
  *
- *  If you don't use named rewrite streams, a "default" stream is used as
- *  the first example shows.
+ * <pre>
+ * rewriter.insertAfter("pass1", t, "text to put after t");}
+ * rewriter.insertAfter("pass2", u, "text after u");}
+ * System.out.println(rewriter.getText("pass1"));
+ * System.out.println(rewriter.getText("pass2"));
+ * </pre>
+ *
+ * <p>
+ * If you don't use named rewrite streams, a "default" stream is used as the
+ * first example shows.</p>
  */
 public class TokenStreamRewriter {
 	public static final String DEFAULT_PROGRAM_NAME = "default";
-    public static final int PROGRAM_INIT_SIZE = 100;
+	public static final int PROGRAM_INIT_SIZE = 100;
 	public static final int MIN_TOKEN_INDEX = 0;
 
 	// Define the rewrite operation hierarchy
 
 	public class RewriteOperation {
-        /** What index into rewrites List are we? */
-        protected int instructionIndex;
-        /** Token buffer index. */
-        protected int index;
+	/** What index into rewrites List are we? */
+	protected int instructionIndex;
+	/** Token buffer index. */
+	protected int index;
 		protected Object text;
 
 		protected RewriteOperation(int index) {
@@ -133,7 +147,7 @@ public class TokenStreamRewriter {
 			int $index = opName.indexOf('$');
 			opName = opName.substring($index+1, opName.length());
 			return "<"+opName+"@"+tokens.get(index)+
-				   ":\""+text+"\">";
+					":\""+text+"\">";
 		}
 	}
 
@@ -172,10 +186,10 @@ public class TokenStreamRewriter {
 		public String toString() {
 			if ( text==null ) {
 				return "<DeleteOp@"+tokens.get(index)+
-					   ".."+tokens.get(lastIndex)+">";
+						".."+tokens.get(lastIndex)+">";
 			}
 			return "<ReplaceOp@"+tokens.get(index)+
-				   ".."+tokens.get(lastIndex)+":\""+text+"\">";
+					".."+tokens.get(lastIndex)+":\""+text+"\">";
 		}
 	}
 
@@ -184,11 +198,11 @@ public class TokenStreamRewriter {
 
 	/** You may have multiple, named streams of rewrite operations.
 	 *  I'm calling these things "programs."
-	 *  Maps String (name) -> rewrite (List)
+	 *  Maps String (name) &rarr; rewrite (List)
 	 */
 	protected final Map<String, List<RewriteOperation>> programs;
 
-	/** Map String (program name) -> Integer index */
+	/** Map String (program name) &rarr; Integer index */
 	protected final Map<String, Integer> lastRewriteTokenIndexes;
 
 	public TokenStreamRewriter(TokenStream tokens) {
@@ -209,7 +223,7 @@ public class TokenStreamRewriter {
 
 	/** Rollback the instruction stream for a program so that
 	 *  the indicated instruction (via instructionIndex) is no
-	 *  longer in the stream.  UNTESTED!
+	 *  longer in the stream. UNTESTED!
 	 */
 	public void rollback(String programName, int instructionIndex) {
 		List<RewriteOperation> is = programs.get(programName);
@@ -259,8 +273,8 @@ public class TokenStreamRewriter {
 	public void insertBefore(String programName, int index, Object text) {
 		RewriteOperation op = new InsertBeforeOp(index,text);
 		List<RewriteOperation> rewrites = getProgram(programName);
-        op.instructionIndex = rewrites.size();
-        rewrites.add(op);
+		op.instructionIndex = rewrites.size();
+		rewrites.add(op);
 	}
 
 	public void replace(int index, Object text) {
@@ -279,17 +293,17 @@ public class TokenStreamRewriter {
 		replace(DEFAULT_PROGRAM_NAME, from, to, text);
 	}
 
-	public void replace(String programName, int from, int to, @Nullable Object text) {
+	public void replace(String programName, int from, int to, Object text) {
 		if ( from > to || from<0 || to<0 || to >= tokens.size() ) {
 			throw new IllegalArgumentException("replace: range invalid: "+from+".."+to+"(size="+tokens.size()+")");
 		}
 		RewriteOperation op = new ReplaceOp(from, to, text);
 		List<RewriteOperation> rewrites = getProgram(programName);
-        op.instructionIndex = rewrites.size();
-        rewrites.add(op);
+		op.instructionIndex = rewrites.size();
+		rewrites.add(op);
 	}
 
-	public void replace(String programName, Token from, Token to, @Nullable Object text) {
+	public void replace(String programName, Token from, Token to, Object text) {
 		replace(programName,
 				from.getTokenIndex(),
 				to.getTokenIndex(),
@@ -357,6 +371,13 @@ public class TokenStreamRewriter {
 		return getText(DEFAULT_PROGRAM_NAME, Interval.of(0,tokens.size()-1));
 	}
 
+	/** Return the text from the original tokens altered per the
+	 *  instructions given to this rewriter in programName.
+ 	 */
+	public String getText(String programName) {
+		return getText(programName, Interval.of(0,tokens.size()-1));
+	}
+
 	/** Return the text associated with the tokens in the interval from the
 	 *  original token stream but with the alterations given to this rewriter.
 	 *  The interval refers to the indexes in the original token stream.
@@ -375,11 +396,11 @@ public class TokenStreamRewriter {
 		int start = interval.a;
 		int stop = interval.b;
 
-        // ensure start/end are in range
-        if ( stop>tokens.size()-1 ) stop = tokens.size()-1;
-        if ( start<0 ) start = 0;
+		// ensure start/end are in range
+		if ( stop>tokens.size()-1 ) stop = tokens.size()-1;
+		if ( start<0 ) start = 0;
 
-        if ( rewrites==null || rewrites.isEmpty() ) {
+		if ( rewrites==null || rewrites.isEmpty() ) {
 			return tokens.getText(interval); // no instructions to execute
 		}
 		StringBuilder buf = new StringBuilder();
@@ -387,9 +408,9 @@ public class TokenStreamRewriter {
 		// First, optimize instruction stream
 		Map<Integer, RewriteOperation> indexToOp = reduceToSingleOperationPerIndex(rewrites);
 
-        // Walk buffer, executing instructions and emitting tokens
-        int i = start;
-        while ( i <= stop && i < tokens.size() ) {
+		// Walk buffer, executing instructions and emitting tokens
+		int i = start;
+		while ( i <= stop && i < tokens.size() ) {
 			RewriteOperation op = indexToOp.get(i);
 			indexToOp.remove(i); // remove so any left have index size-1
 			Token t = tokens.get(i);
@@ -403,22 +424,22 @@ public class TokenStreamRewriter {
 			}
 		}
 
-        // include stuff after end if it's last index in buffer
-        // So, if they did an insertAfter(lastValidIndex, "foo"), include
-        // foo if end==lastValidIndex.
-        if ( stop==tokens.size()-1 ) {
-            // Scan any remaining operations after last token
-            // should be included (they will be inserts).
+		// include stuff after end if it's last index in buffer
+		// So, if they did an insertAfter(lastValidIndex, "foo"), include
+		// foo if end==lastValidIndex.
+		if ( stop==tokens.size()-1 ) {
+			// Scan any remaining operations after last token
+			// should be included (they will be inserts).
 			for (RewriteOperation op : indexToOp.values()) {
-                if ( op.index >= tokens.size()-1 ) buf.append(op.text);
-            }
-        }
-        return buf.toString();
+				if ( op.index >= tokens.size()-1 ) buf.append(op.text);
+			}
+		}
+		return buf.toString();
 	}
 
 	/** We need to combine operations and report invalid operations (like
-	 *  overlapping replaces that are not completed nested).  Inserts to
-	 *  same index need to be combined etc...   Here are the cases:
+	 *  overlapping replaces that are not completed nested). Inserts to
+	 *  same index need to be combined etc...  Here are the cases:
 	 *
 	 *  I.i.u I.j.v								leave alone, nonoverlapping
 	 *  I.i.u I.i.v								combine: Iivu
@@ -441,25 +462,25 @@ public class TokenStreamRewriter {
 	 *  I.i.u = insert u before op @ index i
 	 *  R.x-y.u = replace x-y indexed tokens with u
 	 *
-	 *  First we need to examine replaces.  For any replace op:
+	 *  First we need to examine replaces. For any replace op:
 	 *
 	 * 		1. wipe out any insertions before op within that range.
 	 *		2. Drop any replace op before that is contained completely within
-	 *         that range.
+	 *	 that range.
 	 *		3. Throw exception upon boundary overlap with any previous replace.
 	 *
 	 *  Then we can deal with inserts:
 	 *
 	 * 		1. for any inserts to same index, combine even if not adjacent.
 	 * 		2. for any prior replace with same left boundary, combine this
-	 *         insert with replace and delete this replace.
+	 *	 insert with replace and delete this replace.
 	 * 		3. throw exception if index in same range as previous replace
 	 *
 	 *  Don't actually delete; make op null in list. Easier to walk list.
-	 *  Later we can throw as we add to index -> op map.
+	 *  Later we can throw as we add to index &rarr; op map.
 	 *
 	 *  Note that I.2 R.2-2 will wipe out I.2 even though, technically, the
-	 *  inserted stuff would be before the replace range.  But, if you
+	 *  inserted stuff would be before the replace range. But, if you
 	 *  add tokens in front of a method body '{' and then delete the method
 	 *  body, I think the stuff before the '{' you added should disappear too.
 	 *
@@ -484,16 +505,16 @@ public class TokenStreamRewriter {
 					rop.text = iop.text.toString() + (rop.text!=null?rop.text.toString():"");
 				}
 				else if ( iop.index > rop.index && iop.index <= rop.lastIndex ) {
-                    // delete insert as it's a no-op.
-                    rewrites.set(iop.instructionIndex, null);
+					// delete insert as it's a no-op.
+					rewrites.set(iop.instructionIndex, null);
 				}
 			}
 			// Drop any prior replaces contained within
 			List<? extends ReplaceOp> prevReplaces = getKindOfOps(rewrites, ReplaceOp.class, i);
 			for (ReplaceOp prevRop : prevReplaces) {
 				if ( prevRop.index>=rop.index && prevRop.lastIndex <= rop.lastIndex ) {
-                    // delete replace as it's a no-op.
-                    rewrites.set(prevRop.instructionIndex, null);
+					// delete replace as it's a no-op.
+					rewrites.set(prevRop.instructionIndex, null);
 					continue;
 				}
 				// throw exception unless disjoint or identical
@@ -511,8 +532,7 @@ public class TokenStreamRewriter {
 					System.out.println("new rop "+rop);
 				}
 				else if ( !disjoint && !same ) {
-					throw new IllegalArgumentException("replace op boundaries of "+rop+
-													   " overlap with previous "+prevRop);
+					throw new IllegalArgumentException("replace op boundaries of "+rop+" overlap with previous "+prevRop);
 				}
 			}
 		}
@@ -530,8 +550,8 @@ public class TokenStreamRewriter {
 					// convert to strings...we're in process of toString'ing
 					// whole token buffer so no lazy eval issue with any templates
 					iop.text = catOpText(iop.text,prevIop.text);
-                    // delete redundant prior insert
-                    rewrites.set(prevIop.instructionIndex, null);
+					// delete redundant prior insert
+					rewrites.set(prevIop.instructionIndex, null);
 				}
 			}
 			// look for replaces where iop.index is in range; error
@@ -539,12 +559,11 @@ public class TokenStreamRewriter {
 			for (ReplaceOp rop : prevReplaces) {
 				if ( iop.index == rop.index ) {
 					rop.text = catOpText(iop.text,rop.text);
-					rewrites.set(i, null);  // delete current insert
+					rewrites.set(i, null);	// delete current insert
 					continue;
 				}
 				if ( iop.index >= rop.index && iop.index <= rop.lastIndex ) {
-					throw new IllegalArgumentException("insert op "+iop+
-													   " within boundaries of previous "+rop);
+					throw new IllegalArgumentException("insert op "+iop+" within boundaries of previous "+rop);
 				}
 			}
 		}
@@ -570,8 +589,8 @@ public class TokenStreamRewriter {
 		return x+y;
 	}
 
-    /** Get all operations before an index of a particular kind */
-    protected <T extends RewriteOperation> List<? extends T> getKindOfOps(List<? extends RewriteOperation> rewrites, Class<T> kind, int before) {
+	/** Get all operations before an index of a particular kind */
+	protected <T extends RewriteOperation> List<? extends T> getKindOfOps(List<? extends RewriteOperation> rewrites, Class<T> kind, int before) {
 		List<T> ops = new ArrayList<T>();
 		for (int i=0; i<before && i<rewrites.size(); i++) {
 			RewriteOperation op = rewrites.get(i);
@@ -582,5 +601,4 @@ public class TokenStreamRewriter {
 		}
 		return ops;
 	}
-
 }
diff --git a/runtime/Java/src/org/antlr/v4/runtime/UnbufferedCharStream.java b/runtime/Java/src/org/antlr/v4/runtime/UnbufferedCharStream.java
index 5eee309c2..eb23ae714 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/UnbufferedCharStream.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/UnbufferedCharStream.java
@@ -53,16 +53,16 @@ public class UnbufferedCharStream implements CharStream {
 
 	/**
 	 * The number of characters currently in {@link #data data}.
-	 * <p/>
-	 * This is not the buffer capacity, that's {@code data.length}.
+	 *
+	 * <p>This is not the buffer capacity, that's {@code data.length}.</p>
 	 */
    	protected int n;
 
 	/**
 	 * 0..n-1 index into {@link #data data} of next character.
-	 * <p/>
-	 * The {@code LA(1)} character is {@code data[p]}. If {@code p == n}, we are
-	 * out of buffered characters.
+	 *
+	 * <p>The {@code LA(1)} character is {@code data[p]}. If {@code p == n}, we are
+	 * out of buffered characters.</p>
 	 */
    	protected int p=0;
 
@@ -214,10 +214,10 @@ public class UnbufferedCharStream implements CharStream {
 
 	/**
 	 * Return a marker that we can release later.
-	 * <p/>
-	 * The specific marker value used for this class allows for some level of
+	 *
+	 * <p>The specific marker value used for this class allows for some level of
 	 * protection against misuse where {@code seek()} is called on a mark or
-	 * {@code release()} is called in the wrong order.
+	 * {@code release()} is called in the wrong order.</p>
 	 */
     @Override
     public int mark() {
@@ -297,6 +297,10 @@ public class UnbufferedCharStream implements CharStream {
 
     @Override
     public String getSourceName() {
+		if (name == null || name.isEmpty()) {
+			return UNKNOWN_SOURCE_NAME;
+		}
+
 		return name;
 	}
 
diff --git a/runtime/Java/src/org/antlr/v4/runtime/UnbufferedTokenStream.java b/runtime/Java/src/org/antlr/v4/runtime/UnbufferedTokenStream.java
index a17c33f1a..fa8ba0687 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/UnbufferedTokenStream.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/UnbufferedTokenStream.java
@@ -31,7 +31,6 @@
 package org.antlr.v4.runtime;
 
 import org.antlr.v4.runtime.misc.Interval;
-import org.antlr.v4.runtime.misc.NotNull;
 
 import java.util.Arrays;
 
@@ -47,16 +46,16 @@ public class UnbufferedTokenStream<T extends Token> implements TokenStream {
 
 	/**
 	 * The number of tokens currently in {@link #tokens tokens}.
-	 * <p/>
-	 * This is not the buffer capacity, that's {@code tokens.length}.
+	 *
+	 * <p>This is not the buffer capacity, that's {@code tokens.length}.</p>
 	 */
 	protected int n;
 
 	/**
 	 * 0..n-1 index into {@link #tokens tokens} of next token.
-	 * <p/>
-	 * The {@code LT(1)} token is {@code tokens[p]}. If {@code p == n}, we are
-	 * out of buffered tokens.
+	 *
+	 * <p>The {@code LT(1)} token is {@code tokens[p]}. If {@code p == n}, we are
+	 * out of buffered tokens.</p>
 	 */
 	protected int p=0;
 
@@ -83,9 +82,9 @@ public class UnbufferedTokenStream<T extends Token> implements TokenStream {
 	 * Absolute token index. It's the index of the token about to be read via
 	 * {@code LT(1)}. Goes from 0 to the number of tokens in the entire stream,
 	 * although the stream size is unknown before the end is reached.
-	 * <p/>
-	 * This value is used to set the token indexes if the stream provides tokens
-	 * that implement {@link WritableToken}.
+	 *
+	 * <p>This value is used to set the token indexes if the stream provides tokens
+	 * that implement {@link WritableToken}.</p>
 	 */
 	protected int currentTokenIndex = 0;
 
@@ -140,19 +139,19 @@ public class UnbufferedTokenStream<T extends Token> implements TokenStream {
 		return tokenSource;
 	}
 
-	@NotNull
+
 	@Override
 	public String getText() {
 		return "";
 	}
 
-	@NotNull
+
 	@Override
 	public String getText(RuleContext ctx) {
 		return getText(ctx.getSourceInterval());
 	}
 
-	@NotNull
+
 	@Override
 	public String getText(Token start, Token stop) {
 		return getText(Interval.of(start.getTokenIndex(), stop.getTokenIndex()));
@@ -208,7 +207,7 @@ public class UnbufferedTokenStream<T extends Token> implements TokenStream {
 		return n;
 	}
 
-	protected void add(@NotNull Token t) {
+	protected void add(Token t) {
 		if ( n>=tokens.length ) {
 			tokens = Arrays.copyOf(tokens, tokens.length * 2);
 		}
@@ -222,10 +221,10 @@ public class UnbufferedTokenStream<T extends Token> implements TokenStream {
 
 	/**
 	 * Return a marker that we can release later.
-	 * <p/>
-	 * The specific marker value used for this class allows for some level of
+	 *
+	 * <p>The specific marker value used for this class allows for some level of
 	 * protection against misuse where {@code seek()} is called on a mark or
-	 * {@code release()} is called in the wrong order.
+	 * {@code release()} is called in the wrong order.</p>
 	 */
 	@Override
 	public int mark() {
@@ -305,7 +304,7 @@ public class UnbufferedTokenStream<T extends Token> implements TokenStream {
 		return tokenSource.getSourceName();
 	}
 
-	@NotNull
+
 	@Override
 	public String getText(Interval interval) {
 		int bufferStartIndex = getBufferStartIndex();
diff --git a/runtime/Java/src/org/antlr/v4/runtime/Vocabulary.java b/runtime/Java/src/org/antlr/v4/runtime/Vocabulary.java
new file mode 100644
index 000000000..2df537718
--- /dev/null
+++ b/runtime/Java/src/org/antlr/v4/runtime/Vocabulary.java
@@ -0,0 +1,151 @@
+/*
+ * [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.
+ */
+package org.antlr.v4.runtime;
+
+/**
+ * This interface provides information about the vocabulary used by a
+ * recognizer.
+ *
+ * @see Recognizer#getVocabulary()
+ * @author Sam Harwell
+ */
+public interface Vocabulary {
+	/**
+	 * Returns the highest token type value. It can be used to iterate from
+	 * zero to that number, inclusively, thus querying all stored entries.
+	 * @return the highest token type value
+	 */
+	int getMaxTokenType();
+
+	/**
+	 * Gets the string literal associated with a token type. The string returned
+	 * by this method, when not {@code null}, can be used unaltered in a parser
+	 * grammar to represent this token type.
+	 *
+	 * <p>The following table shows examples of lexer rules and the literal
+	 * names assigned to the corresponding token types.</p>
+	 *
+	 * <table>
+	 *  <tr>
+	 *   <th>Rule</th>
+	 *   <th>Literal Name</th>
+	 *   <th>Java String Literal</th>
+	 *  </tr>
+	 *  <tr>
+	 *   <td>{@code THIS : 'this';}</td>
+	 *   <td>{@code 'this'}</td>
+	 *   <td>{@code "'this'"}</td>
+	 *  </tr>
+	 *  <tr>
+	 *   <td>{@code SQUOTE : '\'';}</td>
+	 *   <td>{@code '\''}</td>
+	 *   <td>{@code "'\\''"}</td>
+	 *  </tr>
+	 *  <tr>
+	 *   <td>{@code ID : [A-Z]+;}</td>
+	 *   <td>n/a</td>
+	 *   <td>{@code null}</td>
+	 *  </tr>
+	 * </table>
+	 *
+	 * @param tokenType The token type.
+	 *
+	 * @return The string literal associated with the specified token type, or
+	 * {@code null} if no string literal is associated with the type.
+	 */
+	String getLiteralName(int tokenType);
+
+	/**
+	 * Gets the symbolic name associated with a token type. The string returned
+	 * by this method, when not {@code null}, can be used unaltered in a parser
+	 * grammar to represent this token type.
+	 *
+	 * <p>This method supports token types defined by any of the following
+	 * methods:</p>
+	 *
+	 * <ul>
+	 *  <li>Tokens created by lexer rules.</li>
+	 *  <li>Tokens defined in a <code>tokens{}</code> block in a lexer or parser
+	 *  grammar.</li>
+	 *  <li>The implicitly defined {@code EOF} token, which has the token type
+	 *  {@link Token#EOF}.</li>
+	 * </ul>
+	 *
+	 * <p>The following table shows examples of lexer rules and the literal
+	 * names assigned to the corresponding token types.</p>
+	 *
+	 * <table>
+	 *  <tr>
+	 *   <th>Rule</th>
+	 *   <th>Symbolic Name</th>
+	 *  </tr>
+	 *  <tr>
+	 *   <td>{@code THIS : 'this';}</td>
+	 *   <td>{@code THIS}</td>
+	 *  </tr>
+	 *  <tr>
+	 *   <td>{@code SQUOTE : '\'';}</td>
+	 *   <td>{@code SQUOTE}</td>
+	 *  </tr>
+	 *  <tr>
+	 *   <td>{@code ID : [A-Z]+;}</td>
+	 *   <td>{@code ID}</td>
+	 *  </tr>
+	 * </table>
+	 *
+	 * @param tokenType The token type.
+	 *
+	 * @return The symbolic name associated with the specified token type, or
+	 * {@code null} if no symbolic name is associated with the type.
+	 */
+	String getSymbolicName(int tokenType);
+
+	/**
+	 * Gets the display name of a token type.
+	 *
+	 * <p>ANTLR provides a default implementation of this method, but
+	 * applications are free to override the behavior in any manner which makes
+	 * sense for the application. The default implementation returns the first
+	 * result from the following list which produces a non-{@code null}
+	 * result.</p>
+	 *
+	 * <ol>
+	 *  <li>The result of {@link #getLiteralName}</li>
+	 *  <li>The result of {@link #getSymbolicName}</li>
+	 *  <li>The result of {@link Integer#toString}</li>
+	 * </ol>
+	 *
+	 * @param tokenType The token type.
+	 *
+	 * @return The display name of the token type, for use in error reporting or
+	 * other user-visible messages which reference specific token types.
+	 */
+	String getDisplayName(int tokenType);
+}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/VocabularyImpl.java b/runtime/Java/src/org/antlr/v4/runtime/VocabularyImpl.java
new file mode 100644
index 000000000..93566bdcb
--- /dev/null
+++ b/runtime/Java/src/org/antlr/v4/runtime/VocabularyImpl.java
@@ -0,0 +1,200 @@
+/*
+ * [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.
+ */
+package org.antlr.v4.runtime;
+
+import java.util.Arrays;
+
+/**
+ * This class provides a default implementation of the {@link Vocabulary}
+ * interface.
+ *
+ * @author Sam Harwell
+ */
+public class VocabularyImpl implements Vocabulary {
+	private static final String[] EMPTY_NAMES = new String[0];
+
+	/**
+	 * Gets an empty {@link Vocabulary} instance.
+	 *
+	 * <p>
+	 * No literal or symbol names are assigned to token types, so
+	 * {@link #getDisplayName(int)} returns the numeric value for all tokens
+	 * except {@link Token#EOF}.</p>
+	 */
+	public static final VocabularyImpl EMPTY_VOCABULARY = new VocabularyImpl(EMPTY_NAMES, EMPTY_NAMES, EMPTY_NAMES);
+
+
+	private final String[] literalNames;
+
+	private final String[] symbolicNames;
+
+	private final String[] displayNames;
+
+	private final int maxTokenType;
+
+	/**
+	 * Constructs a new instance of {@link VocabularyImpl} from the specified
+	 * literal and symbolic token names.
+	 *
+	 * @param literalNames The literal names assigned to tokens, or {@code null}
+	 * if no literal names are assigned.
+	 * @param symbolicNames The symbolic names assigned to tokens, or
+	 * {@code null} if no symbolic names are assigned.
+	 *
+	 * @see #getLiteralName(int)
+	 * @see #getSymbolicName(int)
+	 */
+	public VocabularyImpl(String[] literalNames, String[] symbolicNames) {
+		this(literalNames, symbolicNames, null);
+	}
+
+	/**
+	 * Constructs a new instance of {@link VocabularyImpl} from the specified
+	 * literal, symbolic, and display token names.
+	 *
+	 * @param literalNames The literal names assigned to tokens, or {@code null}
+	 * if no literal names are assigned.
+	 * @param symbolicNames The symbolic names assigned to tokens, or
+	 * {@code null} if no symbolic names are assigned.
+	 * @param displayNames The display names assigned to tokens, or {@code null}
+	 * to use the values in {@code literalNames} and {@code symbolicNames} as
+	 * the source of display names, as described in
+	 * {@link #getDisplayName(int)}.
+	 *
+	 * @see #getLiteralName(int)
+	 * @see #getSymbolicName(int)
+	 * @see #getDisplayName(int)
+	 */
+	public VocabularyImpl(String[] literalNames, String[] symbolicNames, String[] displayNames) {
+		this.literalNames = literalNames != null ? literalNames : EMPTY_NAMES;
+		this.symbolicNames = symbolicNames != null ? symbolicNames : EMPTY_NAMES;
+		this.displayNames = displayNames != null ? displayNames : EMPTY_NAMES;
+		// See note here on -1 part: https://github.com/antlr/antlr4/pull/1146
+		this.maxTokenType =
+			Math.max(this.displayNames.length,
+					 Math.max(this.literalNames.length, this.symbolicNames.length)) - 1;
+	}
+
+	/**
+	 * Returns a {@link VocabularyImpl} instance from the specified set of token
+	 * names. This method acts as a compatibility layer for the single
+	 * {@code tokenNames} array generated by previous releases of ANTLR.
+	 *
+	 * <p>The resulting vocabulary instance returns {@code null} for
+	 * {@link #getLiteralName(int)} and {@link #getSymbolicName(int)}, and the
+	 * value from {@code tokenNames} for the display names.</p>
+	 *
+	 * @param tokenNames The token names, or {@code null} if no token names are
+	 * available.
+	 * @return A {@link Vocabulary} instance which uses {@code tokenNames} for
+	 * the display names of tokens.
+	 */
+	public static Vocabulary fromTokenNames(String[] tokenNames) {
+		if (tokenNames == null || tokenNames.length == 0) {
+			return EMPTY_VOCABULARY;
+		}
+
+		String[] literalNames = Arrays.copyOf(tokenNames, tokenNames.length);
+		String[] symbolicNames = Arrays.copyOf(tokenNames, tokenNames.length);
+		for (int i = 0; i < tokenNames.length; i++) {
+			String tokenName = tokenNames[i];
+			if (tokenName == null) {
+				continue;
+			}
+
+			if (!tokenName.isEmpty()) {
+				char firstChar = tokenName.charAt(0);
+				if (firstChar == '\'') {
+					symbolicNames[i] = null;
+					continue;
+				}
+				else if (Character.isUpperCase(firstChar)) {
+					literalNames[i] = null;
+					continue;
+				}
+			}
+
+			// wasn't a literal or symbolic name
+			literalNames[i] = null;
+			symbolicNames[i] = null;
+		}
+
+		return new VocabularyImpl(literalNames, symbolicNames, tokenNames);
+	}
+
+	@Override
+	public int getMaxTokenType() {
+		return maxTokenType;
+	}
+
+	@Override
+	public String getLiteralName(int tokenType) {
+		if (tokenType >= 0 && tokenType < literalNames.length) {
+			return literalNames[tokenType];
+		}
+
+		return null;
+	}
+
+	@Override
+	public String getSymbolicName(int tokenType) {
+		if (tokenType >= 0 && tokenType < symbolicNames.length) {
+			return symbolicNames[tokenType];
+		}
+
+		if (tokenType == Token.EOF) {
+			return "EOF";
+		}
+
+		return null;
+	}
+
+	@Override
+	public String getDisplayName(int tokenType) {
+		if (tokenType >= 0 && tokenType < displayNames.length) {
+			String displayName = displayNames[tokenType];
+			if (displayName != null) {
+				return displayName;
+			}
+		}
+
+		String literalName = getLiteralName(tokenType);
+		if (literalName != null) {
+			return literalName;
+		}
+
+		String symbolicName = getSymbolicName(tokenType);
+		if (symbolicName != null) {
+			return symbolicName;
+		}
+
+		return Integer.toString(tokenType);
+	}
+}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/atn/ATN.java b/runtime/Java/src/org/antlr/v4/runtime/atn/ATN.java
index dd67ba086..cdaa0f088 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/atn/ATN.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/atn/ATN.java
@@ -34,8 +34,6 @@ import org.antlr.v4.runtime.ParserRuleContext;
 import org.antlr.v4.runtime.RuleContext;
 import org.antlr.v4.runtime.Token;
 import org.antlr.v4.runtime.misc.IntervalSet;
-import org.antlr.v4.runtime.misc.NotNull;
-import org.antlr.v4.runtime.misc.Nullable;
 
 import java.util.ArrayList;
 import java.util.LinkedHashMap;
@@ -46,14 +44,13 @@ import java.util.Map;
 public class ATN {
 	public static final int INVALID_ALT_NUMBER = 0;
 
-	@NotNull
+
 	public final List<ATNState> states = new ArrayList<ATNState>();
 
 	/** Each subrule/rule is a decision point and we must track them so we
 	 *  can go back later and build DFA predictors for them.  This includes
 	 *  all the rules, subrules, optional blocks, ()+, ()* etc...
 	 */
-	@NotNull
 	public final List<DecisionState> decisionToState = new ArrayList<DecisionState>();
 
 	/**
@@ -66,7 +63,7 @@ public class ATN {
 	 */
 	public RuleStopState[] ruleToStopState;
 
-	@NotNull
+
 	public final Map<String, TokensStartState> modeNameToStartState =
 		new LinkedHashMap<String, TokensStartState>();
 
@@ -90,18 +87,15 @@ public class ATN {
 	public int[] ruleToTokenType;
 
 	/**
-	 * For lexer ATNs, this maps the rule index to the action which should be
-	 * executed following a match.
-	 * <p/>
-	 * This is {@code null} for parser ATNs.
+	 * For lexer ATNs, this is an array of {@link LexerAction} objects which may
+	 * be referenced by action transitions in the ATN.
 	 */
-	public int[] ruleToActionIndex;
+	public LexerAction[] lexerActions;
 
-	@NotNull
 	public final List<TokensStartState> modeToStartState = new ArrayList<TokensStartState>();
 
 	/** Used for runtime deserialization of ATNs from strings */
-	public ATN(@NotNull ATNType grammarType, int maxTokenType) {
+	public ATN(ATNType grammarType, int maxTokenType) {
 		this.grammarType = grammarType;
 		this.maxTokenType = maxTokenType;
 	}
@@ -111,7 +105,6 @@ public class ATN {
 	 *  the rule surrounding {@code s}. In other words, the set will be
 	 *  restricted to tokens reachable staying within {@code s}'s rule.
 	 */
-	@NotNull
 	public IntervalSet nextTokens(ATNState s, RuleContext ctx) {
 		LL1Analyzer anal = new LL1Analyzer(this);
 		IntervalSet next = anal.LOOK(s, ctx);
@@ -123,15 +116,14 @@ public class ATN {
 	 * staying in same rule. {@link Token#EPSILON} is in set if we reach end of
 	 * rule.
      */
-	@NotNull
-    public IntervalSet nextTokens(@NotNull ATNState s) {
+    public IntervalSet nextTokens(ATNState s) {
         if ( s.nextTokenWithinRule != null ) return s.nextTokenWithinRule;
         s.nextTokenWithinRule = nextTokens(s, null);
         s.nextTokenWithinRule.setReadonly(true);
         return s.nextTokenWithinRule;
     }
 
-	public void addState(@Nullable ATNState state) {
+	public void addState(ATNState state) {
 		if (state != null) {
 			state.atn = this;
 			state.stateNumber = states.size();
@@ -140,11 +132,11 @@ public class ATN {
 		states.add(state);
 	}
 
-	public void removeState(@NotNull ATNState state) {
+	public void removeState(ATNState state) {
 		states.set(state.stateNumber, null); // just free mem, don't shift states in list
 	}
 
-	public int defineDecisionState(@NotNull DecisionState s) {
+	public int defineDecisionState(DecisionState s) {
 		decisionToState.add(s);
 		s.decision = decisionToState.size()-1;
 		return s.decision;
@@ -169,9 +161,9 @@ public class ATN {
 	 * assumed true). If a path in the ATN exists from the starting state to the
 	 * {@link RuleStopState} of the outermost context without matching any
 	 * symbols, {@link Token#EOF} is added to the returned set.
-	 * <p/>
-	 * If {@code context} is {@code null}, it is treated as
-	 * {@link ParserRuleContext#EMPTY}.
+	 *
+	 * <p>If {@code context} is {@code null}, it is treated as
+	 * {@link ParserRuleContext#EMPTY}.</p>
 	 *
 	 * @param stateNumber the ATN state number
 	 * @param context the full parse context
@@ -180,8 +172,7 @@ public class ATN {
 	 * @throws IllegalArgumentException if the ATN does not contain a state with
 	 * number {@code stateNumber}
 	 */
-	@NotNull
-	public IntervalSet getExpectedTokens(int stateNumber, @Nullable RuleContext context) {
+	public IntervalSet getExpectedTokens(int stateNumber, RuleContext context) {
 		if (stateNumber < 0 || stateNumber >= states.size()) {
 			throw new IllegalArgumentException("Invalid state number.");
 		}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/atn/ATNConfig.java b/runtime/Java/src/org/antlr/v4/runtime/atn/ATNConfig.java
index 95af660e5..8b57bad83 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/atn/ATNConfig.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/atn/ATNConfig.java
@@ -32,8 +32,6 @@ package org.antlr.v4.runtime.atn;
 
 import org.antlr.v4.runtime.Recognizer;
 import org.antlr.v4.runtime.misc.MurmurHash;
-import org.antlr.v4.runtime.misc.NotNull;
-import org.antlr.v4.runtime.misc.Nullable;
 
 /** A tuple: (ATN state, predicted alt, syntactic, semantic context).
  *  The syntactic context is a graph-structured stack node whose
@@ -43,8 +41,14 @@ import org.antlr.v4.runtime.misc.Nullable;
  *  an ATN state.
  */
 public class ATNConfig {
+	/**
+	 * This field stores the bit mask for implementing the
+	 * {@link #isPrecedenceFilterSuppressed} property as a bit within the
+	 * existing {@link #reachesIntoOuterContext} field.
+	 */
+	private static final int SUPPRESS_PRECEDENCE_FILTER = 0x40000000;
+
 	/** The ATN state associated with this configuration */
-	@NotNull
 	public final ATNState state;
 
 	/** What alt (or lexer rule) is predicted by this configuration */
@@ -54,7 +58,6 @@ public class ATNConfig {
 	 *  with this config.  We track only those contexts pushed during
 	 *  execution of the ATN simulator.
 	 */
-	@Nullable
 	public PredictionContext context;
 
 	/**
@@ -64,13 +67,25 @@ public class ATNConfig {
 	 * dependent predicates unless we are in the rule that initially
 	 * invokes the ATN simulator.
 	 *
-	 * closure() tracks the depth of how far we dip into the
-	 * outer context: depth > 0.  Note that it may not be totally
-	 * accurate depth since I don't ever decrement. TODO: make it a boolean then
+	 * <p>
+	 * closure() tracks the depth of how far we dip into the outer context:
+	 * depth &gt; 0.  Note that it may not be totally accurate depth since I
+	 * don't ever decrement. TODO: make it a boolean then</p>
+	 *
+	 * <p>
+	 * For memory efficiency, the {@link #isPrecedenceFilterSuppressed} method
+	 * is also backed by this field. Since the field is publicly accessible, the
+	 * highest bit which would not cause the value to become negative is used to
+	 * store this field. This choice minimizes the risk that code which only
+	 * compares this value to 0 would be affected by the new purpose of the
+	 * flag. It also ensures the performance of the existing {@link ATNConfig}
+	 * constructors as well as certain operations like
+	 * {@link ATNConfigSet#add(ATNConfig, DoubleKeyMap)} method are
+	 * <em>completely</em> unaffected by the change.</p>
 	 */
 	public int reachesIntoOuterContext;
 
-    @NotNull
+
     public final SemanticContext semanticContext;
 
 	public ATNConfig(ATNConfig old) { // dup
@@ -81,17 +96,17 @@ public class ATNConfig {
 		this.reachesIntoOuterContext = old.reachesIntoOuterContext;
 	}
 
-	public ATNConfig(@NotNull ATNState state,
+	public ATNConfig(ATNState state,
 					 int alt,
-					 @Nullable PredictionContext context)
+					 PredictionContext context)
 	{
 		this(state, alt, context, SemanticContext.NONE);
 	}
 
-	public ATNConfig(@NotNull ATNState state,
+	public ATNConfig(ATNState state,
 					 int alt,
-					 @Nullable PredictionContext context,
-					 @NotNull SemanticContext semanticContext)
+					 PredictionContext context,
+					 SemanticContext semanticContext)
 	{
 		this.state = state;
 		this.alt = alt;
@@ -99,31 +114,31 @@ public class ATNConfig {
 		this.semanticContext = semanticContext;
 	}
 
-    public ATNConfig(@NotNull ATNConfig c, @NotNull ATNState state) {
+    public ATNConfig(ATNConfig c, ATNState state) {
    		this(c, state, c.context, c.semanticContext);
    	}
 
-	public ATNConfig(@NotNull ATNConfig c, @NotNull ATNState state,
-		 @NotNull SemanticContext semanticContext)
+	public ATNConfig(ATNConfig c, ATNState state,
+		 SemanticContext semanticContext)
 {
 		this(c, state, c.context, semanticContext);
 	}
 
-	public ATNConfig(@NotNull ATNConfig c,
-					 @NotNull SemanticContext semanticContext)
+	public ATNConfig(ATNConfig c,
+					 SemanticContext semanticContext)
 	{
 		this(c, c.state, c.context, semanticContext);
 	}
 
-    public ATNConfig(@NotNull ATNConfig c, @NotNull ATNState state,
-					 @Nullable PredictionContext context)
+    public ATNConfig(ATNConfig c, ATNState state,
+					 PredictionContext context)
 	{
         this(c, state, context, c.semanticContext);
     }
 
-	public ATNConfig(@NotNull ATNConfig c, @NotNull ATNState state,
-					 @Nullable PredictionContext context,
-                     @NotNull SemanticContext semanticContext)
+	public ATNConfig(ATNConfig c, ATNState state,
+					 PredictionContext context,
+                     SemanticContext semanticContext)
     {
 		this.state = state;
 		this.alt = c.alt;
@@ -132,6 +147,28 @@ public class ATNConfig {
 		this.reachesIntoOuterContext = c.reachesIntoOuterContext;
 	}
 
+	/**
+	 * This method gets the value of the {@link #reachesIntoOuterContext} field
+	 * as it existed prior to the introduction of the
+	 * {@link #isPrecedenceFilterSuppressed} method.
+	 */
+	public final int getOuterContextDepth() {
+		return reachesIntoOuterContext & ~SUPPRESS_PRECEDENCE_FILTER;
+	}
+
+	public final boolean isPrecedenceFilterSuppressed() {
+		return (reachesIntoOuterContext & SUPPRESS_PRECEDENCE_FILTER) != 0;
+	}
+
+	public final void setPrecedenceFilterSuppressed(boolean value) {
+		if (value) {
+			this.reachesIntoOuterContext |= 0x40000000;
+		}
+		else {
+			this.reachesIntoOuterContext &= ~SUPPRESS_PRECEDENCE_FILTER;
+		}
+	}
+
 	/** An ATN configuration is equal to another if both have
      *  the same state, they predict the same alternative, and
      *  syntactic/semantic contexts are the same.
@@ -155,7 +192,8 @@ public class ATNConfig {
 		return this.state.stateNumber==other.state.stateNumber
 			&& this.alt==other.alt
 			&& (this.context==other.context || (this.context != null && this.context.equals(other.context)))
-			&& this.semanticContext.equals(other.semanticContext);
+			&& this.semanticContext.equals(other.semanticContext)
+			&& this.isPrecedenceFilterSuppressed() == other.isPrecedenceFilterSuppressed();
 	}
 
 	@Override
@@ -174,7 +212,7 @@ public class ATNConfig {
 		return toString(null, true);
 	}
 
-	public String toString(@Nullable Recognizer<?, ?> recog, boolean showAlt) {
+	public String toString(Recognizer<?, ?> recog, boolean showAlt) {
 		StringBuilder buf = new StringBuilder();
 //		if ( state.ruleIndex>=0 ) {
 //			if ( recog!=null ) buf.append(recog.getRuleNames()[state.ruleIndex]+":");
@@ -195,8 +233,8 @@ public class ATNConfig {
             buf.append(",");
             buf.append(semanticContext);
         }
-        if ( reachesIntoOuterContext>0 ) {
-            buf.append(",up=").append(reachesIntoOuterContext);
+        if ( getOuterContextDepth()>0 ) {
+            buf.append(",up=").append(getOuterContextDepth());
         }
 		buf.append(')');
 		return buf.toString();
diff --git a/runtime/Java/src/org/antlr/v4/runtime/atn/ATNConfigSet.java b/runtime/Java/src/org/antlr/v4/runtime/atn/ATNConfigSet.java
index 423c1e967..b03f7c489 100755
--- a/runtime/Java/src/org/antlr/v4/runtime/atn/ATNConfigSet.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/atn/ATNConfigSet.java
@@ -33,8 +33,6 @@ package org.antlr.v4.runtime.atn;
 import org.antlr.v4.runtime.misc.AbstractEqualityComparator;
 import org.antlr.v4.runtime.misc.Array2DHashSet;
 import org.antlr.v4.runtime.misc.DoubleKeyMap;
-import org.antlr.v4.runtime.misc.NotNull;
-import org.antlr.v4.runtime.misc.Nullable;
 
 import java.util.ArrayList;
 import java.util.BitSet;
@@ -108,6 +106,11 @@ public class ATNConfigSet implements Set<ATNConfig> {
 	// TODO: these fields make me pretty uncomfortable but nice to pack up info together, saves recomputation
 	// TODO: can we track conflicts as they are added to save scanning configs later?
 	public int uniqueAlt;
+	/** Currently this is only used when we detect SLL conflict; this does
+	 *  not necessarily represent the ambiguous alternatives. In fact,
+	 *  I should also point out that this seems to include predicated alternatives
+	 *  that have predicates that evaluate to false. Computed in computeTargetState().
+ 	 */
 	protected BitSet conflictingAlts;
 
 	// Used in parser and lexer. In lexer, it indicates we hit a pred
@@ -139,7 +142,7 @@ public class ATNConfigSet implements Set<ATNConfig> {
 	}
 
 	@Override
-	public boolean add(@NotNull ATNConfig config) {
+	public boolean add(ATNConfig config) {
 		return add(config, null);
 	}
 
@@ -149,19 +152,19 @@ public class ATNConfigSet implements Set<ATNConfig> {
 	 * {@link ATNConfig#state}, {@code i} is the {@link ATNConfig#alt}, and
 	 * {@code pi} is the {@link ATNConfig#semanticContext}. We use
 	 * {@code (s,i,pi)} as key.
-	 * <p/>
-	 * This method updates {@link #dipsIntoOuterContext} and
-	 * {@link #hasSemanticContext} when necessary.
+	 *
+	 * <p>This method updates {@link #dipsIntoOuterContext} and
+	 * {@link #hasSemanticContext} when necessary.</p>
 	 */
 	public boolean add(
-		@NotNull ATNConfig config,
-		@Nullable DoubleKeyMap<PredictionContext,PredictionContext,PredictionContext> mergeCache)
+		ATNConfig config,
+		DoubleKeyMap<PredictionContext,PredictionContext,PredictionContext> mergeCache)
 	{
 		if ( readonly ) throw new IllegalStateException("This set is readonly");
 		if ( config.semanticContext!=SemanticContext.NONE ) {
 			hasSemanticContext = true;
 		}
-		if (config.reachesIntoOuterContext > 0) {
+		if (config.getOuterContextDepth() > 0) {
 			dipsIntoOuterContext = true;
 		}
 		ATNConfig existing = configLookup.getOrAdd(config);
@@ -179,6 +182,12 @@ public class ATNConfigSet implements Set<ATNConfig> {
 		// cache at both places.
 		existing.reachesIntoOuterContext =
 			Math.max(existing.reachesIntoOuterContext, config.reachesIntoOuterContext);
+
+		// make sure to preserve the precedence filter suppression during the merge
+		if (config.isPrecedenceFilterSuppressed()) {
+			existing.setPrecedenceFilterSuppressed(true);
+		}
+
 		existing.context = merged; // replace context; no need to alt mapping
 		return true;
 	}
@@ -194,6 +203,23 @@ public class ATNConfigSet implements Set<ATNConfig> {
 		return states;
 	}
 
+	/**
+	 * Gets the complete set of represented alternatives for the configuration
+	 * set.
+	 *
+	 * @return the set of represented alternatives in this configuration set
+	 *
+	 * @since 4.3
+	 */
+
+	public BitSet getAlts() {
+		BitSet alts = new BitSet();
+		for (ATNConfig config : configs) {
+			alts.set(config.alt);
+		}
+		return alts;
+	}
+
 	public List<SemanticContext> getPredicates() {
 		List<SemanticContext> preds = new ArrayList<SemanticContext>();
 		for (ATNConfig c : configs) {
diff --git a/runtime/Java/src/org/antlr/v4/runtime/atn/ATNDeserializationOptions.java b/runtime/Java/src/org/antlr/v4/runtime/atn/ATNDeserializationOptions.java
index a1fd40d04..f1b8d1b80 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/atn/ATNDeserializationOptions.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/atn/ATNDeserializationOptions.java
@@ -30,8 +30,6 @@
 
 package org.antlr.v4.runtime.atn;
 
-import org.antlr.v4.runtime.misc.NotNull;
-
 /**
  *
  * @author Sam Harwell
@@ -57,7 +55,7 @@ public class ATNDeserializationOptions {
 		this.generateRuleBypassTransitions = options.generateRuleBypassTransitions;
 	}
 
-	@NotNull
+
 	public static ATNDeserializationOptions getDefaultOptions() {
 		return defaultOptions;
 	}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/atn/ATNDeserializer.java b/runtime/Java/src/org/antlr/v4/runtime/atn/ATNDeserializer.java
index 2554b80c2..d83c449a0 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/atn/ATNDeserializer.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/atn/ATNDeserializer.java
@@ -32,8 +32,6 @@ package org.antlr.v4.runtime.atn;
 
 import org.antlr.v4.runtime.Token;
 import org.antlr.v4.runtime.misc.IntervalSet;
-import org.antlr.v4.runtime.misc.NotNull;
-import org.antlr.v4.runtime.misc.Nullable;
 import org.antlr.v4.runtime.misc.Pair;
 
 import java.io.InvalidClassException;
@@ -64,6 +62,12 @@ public class ATNDeserializer {
 	 * addition of precedence predicates.
 	 */
 	private static final UUID ADDED_PRECEDENCE_TRANSITIONS;
+	/**
+	 * This UUID indicates an extension of {@link #ADDED_PRECEDENCE_TRANSITIONS}
+	 * for the addition of lexer actions encoded as a sequence of
+	 * {@link LexerAction} instances.
+	 */
+	private static final UUID ADDED_LEXER_ACTIONS;
 	/**
 	 * This list contains all of the currently supported UUIDs, ordered by when
 	 * the feature first appeared in this branch.
@@ -75,27 +79,29 @@ public class ATNDeserializer {
 	 */
 	public static final UUID SERIALIZED_UUID;
 	static {
-		/* WARNING: DO NOT MERGE THIS LINE. If UUIDs differ during a merge,
+		/* WARNING: DO NOT MERGE THESE LINES. If UUIDs differ during a merge,
 		 * resolve the conflict by generating a new ID!
 		 */
 		BASE_SERIALIZED_UUID = UUID.fromString("33761B2D-78BB-4A43-8B0B-4F5BEE8AACF3");
 		ADDED_PRECEDENCE_TRANSITIONS = UUID.fromString("1DA0C57D-6C06-438A-9B27-10BCB3CE0F61");
+		ADDED_LEXER_ACTIONS = UUID.fromString("AADB8D7E-AEEF-4415-AD2B-8204D6CF042E");
 
 		SUPPORTED_UUIDS = new ArrayList<UUID>();
 		SUPPORTED_UUIDS.add(BASE_SERIALIZED_UUID);
 		SUPPORTED_UUIDS.add(ADDED_PRECEDENCE_TRANSITIONS);
+		SUPPORTED_UUIDS.add(ADDED_LEXER_ACTIONS);
 
-		SERIALIZED_UUID = ADDED_PRECEDENCE_TRANSITIONS;
+		SERIALIZED_UUID = ADDED_LEXER_ACTIONS;
 	}
 
-	@NotNull
+
 	private final ATNDeserializationOptions deserializationOptions;
 
 	public ATNDeserializer() {
 		this(ATNDeserializationOptions.getDefaultOptions());
 	}
 
-	public ATNDeserializer(@Nullable ATNDeserializationOptions deserializationOptions) {
+	public ATNDeserializer(ATNDeserializationOptions deserializationOptions) {
 		if (deserializationOptions == null) {
 			deserializationOptions = ATNDeserializationOptions.getDefaultOptions();
 		}
@@ -125,7 +131,8 @@ public class ATNDeserializer {
 		return SUPPORTED_UUIDS.indexOf(actualUuid) >= featureIndex;
 	}
 
-	public ATN deserialize(@NotNull char[] data) {
+	@SuppressWarnings("deprecation")
+	public ATN deserialize(char[] data) {
 		data = data.clone();
 		// don't adjust the first value since that's the version number
 		for (int i = 1; i < data.length; i++) {
@@ -141,13 +148,13 @@ public class ATNDeserializer {
 
 		UUID uuid = toUUID(data, p);
 		p += 8;
-		if (!uuid.equals(SERIALIZED_UUID)
-			&& !uuid.equals(BASE_SERIALIZED_UUID)) {
+		if (!SUPPORTED_UUIDS.contains(uuid)) {
 			String reason = String.format(Locale.getDefault(), "Could not deserialize ATN with UUID %s (expected %s or a legacy UUID).", uuid, SERIALIZED_UUID);
 			throw new UnsupportedOperationException(new InvalidClassException(ATN.class.getName(), reason));
 		}
 
 		boolean supportsPrecedencePredicates = isFeatureSupported(ADDED_PRECEDENCE_TRANSITIONS, uuid);
+		boolean supportsLexerActions = isFeatureSupported(ADDED_LEXER_ACTIONS, uuid);
 
 		ATNType grammarType = ATNType.values()[toInt(data[p++])];
 		int maxTokenType = toInt(data[p++]);
@@ -203,7 +210,7 @@ public class ATNDeserializer {
 			int numPrecedenceStates = toInt(data[p++]);
 			for (int i = 0; i < numPrecedenceStates; i++) {
 				int stateNumber = toInt(data[p++]);
-				((RuleStartState)atn.states.get(stateNumber)).isPrecedenceRule = true;
+				((RuleStartState)atn.states.get(stateNumber)).isLeftRecursiveRule = true;
 			}
 		}
 
@@ -213,8 +220,8 @@ public class ATNDeserializer {
 		int nrules = toInt(data[p++]);
 		if ( atn.grammarType == ATNType.LEXER ) {
 			atn.ruleToTokenType = new int[nrules];
-			atn.ruleToActionIndex = new int[nrules];
 		}
+
 		atn.ruleToStartState = new RuleStartState[nrules];
 		for (int i=0; i<nrules; i++) {
 			int s = toInt(data[p++]);
@@ -227,12 +234,12 @@ public class ATNDeserializer {
 				}
 
 				atn.ruleToTokenType[i] = tokenType;
-				int actionIndex = toInt(data[p++]);
-				if (actionIndex == 0xFFFF) {
-					actionIndex = -1;
-				}
 
-				atn.ruleToActionIndex[i] = actionIndex;
+				if (!isFeatureSupported(ADDED_LEXER_ACTIONS, uuid)) {
+					// this piece of unused metadata was serialized prior to the
+					// addition of LexerAction
+					int actionIndexIgnored = toInt(data[p++]);
+				}
 			}
 		}
 
@@ -308,7 +315,15 @@ public class ATNDeserializer {
 				}
 
 				RuleTransition ruleTransition = (RuleTransition)t;
-				atn.ruleToStopState[ruleTransition.target.ruleIndex].addTransition(new EpsilonTransition(ruleTransition.followState));
+				int outermostPrecedenceReturn = -1;
+				if (atn.ruleToStartState[ruleTransition.target.ruleIndex].isLeftRecursiveRule) {
+					if (ruleTransition.precedence == 0) {
+						outermostPrecedenceReturn = ruleTransition.target.ruleIndex;
+					}
+				}
+
+				EpsilonTransition returnTransition = new EpsilonTransition(ruleTransition.followState, outermostPrecedenceReturn);
+				atn.ruleToStopState[ruleTransition.target.ruleIndex].addTransition(returnTransition);
 			}
 		}
 
@@ -358,6 +373,55 @@ public class ATNDeserializer {
 			decState.decision = i-1;
 		}
 
+		//
+		// LEXER ACTIONS
+		//
+		if (atn.grammarType == ATNType.LEXER) {
+			if (supportsLexerActions) {
+				atn.lexerActions = new LexerAction[toInt(data[p++])];
+				for (int i = 0; i < atn.lexerActions.length; i++) {
+					LexerActionType actionType = LexerActionType.values()[toInt(data[p++])];
+					int data1 = toInt(data[p++]);
+					if (data1 == 0xFFFF) {
+						data1 = -1;
+					}
+
+					int data2 = toInt(data[p++]);
+					if (data2 == 0xFFFF) {
+						data2 = -1;
+					}
+
+					LexerAction lexerAction = lexerActionFactory(actionType, data1, data2);
+
+					atn.lexerActions[i] = lexerAction;
+				}
+			}
+			else {
+				// for compatibility with older serialized ATNs, convert the old
+				// serialized action index for action transitions to the new
+				// form, which is the index of a LexerCustomAction
+				List<LexerAction> legacyLexerActions = new ArrayList<LexerAction>();
+				for (ATNState state : atn.states) {
+					for (int i = 0; i < state.getNumberOfTransitions(); i++) {
+						Transition transition = state.transition(i);
+						if (!(transition instanceof ActionTransition)) {
+							continue;
+						}
+
+						int ruleIndex = ((ActionTransition)transition).ruleIndex;
+						int actionIndex = ((ActionTransition)transition).actionIndex;
+						LexerCustomAction lexerAction = new LexerCustomAction(ruleIndex, actionIndex);
+						state.setTransition(i, new ActionTransition(transition.target, ruleIndex, legacyLexerActions.size(), false));
+						legacyLexerActions.add(lexerAction);
+					}
+				}
+
+				atn.lexerActions = legacyLexerActions.toArray(new LexerAction[legacyLexerActions.size()]);
+			}
+		}
+
+		markPrecedenceDecisions(atn);
+
 		if (deserializationOptions.isVerifyATN()) {
 			verifyATN(atn);
 		}
@@ -384,7 +448,7 @@ public class ATNDeserializer {
 
 				ATNState endState;
 				Transition excludeTransition = null;
-				if (atn.ruleToStartState[i].isPrecedenceRule) {
+				if (atn.ruleToStartState[i].isLeftRecursiveRule) {
 					// wrap from the beginning of the rule to the StarLoopEntryState
 					endState = null;
 					for (ATNState state : atn.states) {
@@ -455,6 +519,34 @@ public class ATNDeserializer {
 		return atn;
 	}
 
+	/**
+	 * Analyze the {@link StarLoopEntryState} states in the specified ATN to set
+	 * the {@link StarLoopEntryState#isPrecedenceDecision} field to the
+	 * correct value.
+	 *
+	 * @param atn The ATN.
+	 */
+	protected void markPrecedenceDecisions(ATN atn) {
+		for (ATNState state : atn.states) {
+			if (!(state instanceof StarLoopEntryState)) {
+				continue;
+			}
+
+			/* We analyze the ATN to determine if this ATN decision state is the
+			 * decision for the closure block that determines whether a
+			 * precedence rule should continue or complete.
+			 */
+			if (atn.ruleToStartState[state.ruleIndex].isLeftRecursiveRule) {
+				ATNState maybeLoopEndState = state.transition(state.getNumberOfTransitions() - 1).target;
+				if (maybeLoopEndState instanceof LoopEndState) {
+					if (maybeLoopEndState.epsilonOnlyTransitions && maybeLoopEndState.transition(0).target instanceof RuleStopState) {
+						((StarLoopEntryState)state).isPrecedenceDecision = true;
+					}
+				}
+			}
+		}
+	}
+
 	protected void verifyATN(ATN atn) {
 		// verify assumptions
 		for (ATNState state : atn.states) {
@@ -546,8 +638,8 @@ public class ATNDeserializer {
 		return new UUID(mostSigBits, leastSigBits);
 	}
 
-	@NotNull
-	protected Transition edgeFactory(@NotNull ATN atn,
+
+	protected Transition edgeFactory(ATN atn,
 										 int type, int src, int trg,
 										 int arg1, int arg2, int arg3,
 										 List<IntervalSet> sets)
@@ -613,4 +705,35 @@ public class ATNDeserializer {
 		return s;
 	}
 
+	protected LexerAction lexerActionFactory(LexerActionType type, int data1, int data2) {
+		switch (type) {
+		case CHANNEL:
+			return new LexerChannelAction(data1);
+
+		case CUSTOM:
+			return new LexerCustomAction(data1, data2);
+
+		case MODE:
+			return new LexerModeAction(data1);
+
+		case MORE:
+			return LexerMoreAction.INSTANCE;
+
+		case POP_MODE:
+			return LexerPopModeAction.INSTANCE;
+
+		case PUSH_MODE:
+			return new LexerPushModeAction(data1);
+
+		case SKIP:
+			return LexerSkipAction.INSTANCE;
+
+		case TYPE:
+			return new LexerTypeAction(data1);
+
+		default:
+			String message = String.format(Locale.getDefault(), "The specified lexer action type %d is not valid.", type);
+			throw new IllegalArgumentException(message);
+		}
+	}
 }
diff --git a/runtime/Java/src/org/antlr/v4/runtime/atn/ATNSerializer.java b/runtime/Java/src/org/antlr/v4/runtime/atn/ATNSerializer.java
index 378d43685..4c31ac92f 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/atn/ATNSerializer.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/atn/ATNSerializer.java
@@ -59,7 +59,7 @@ public class ATNSerializer {
 		this.tokenNames = tokenNames;
 	}
 
-	/** Serialize state descriptors, edge descriptors, and decision->state map
+	/** Serialize state descriptors, edge descriptors, and decision&rarr;state map
 	 *  into list of ints:
 	 *
 	 * 		grammar-type, (ANTLRParser.LEXER, ...)
@@ -108,7 +108,7 @@ public class ATNSerializer {
 				nonGreedyStates.add(s.stateNumber);
 			}
 
-			if (s instanceof RuleStartState && ((RuleStartState)s).isPrecedenceRule) {
+			if (s instanceof RuleStartState && ((RuleStartState)s).isLeftRecursiveRule) {
 				precedenceStates.add(s.stateNumber);
 			}
 
@@ -170,13 +170,6 @@ public class ATNSerializer {
 				else {
 					data.add(atn.ruleToTokenType[r]);
 				}
-
-				if (atn.ruleToActionIndex[r] == -1) {
-					data.add(Character.MAX_VALUE);
-				}
-				else {
-					data.add(atn.ruleToActionIndex[r]);
-				}
 			}
 		}
 
@@ -303,12 +296,74 @@ public class ATNSerializer {
 				data.add(arg3);
 			}
 		}
+
 		int ndecisions = atn.decisionToState.size();
 		data.add(ndecisions);
 		for (DecisionState decStartState : atn.decisionToState) {
 			data.add(decStartState.stateNumber);
 		}
 
+		//
+		// LEXER ACTIONS
+		//
+		if (atn.grammarType == ATNType.LEXER) {
+			data.add(atn.lexerActions.length);
+			for (LexerAction action : atn.lexerActions) {
+				data.add(action.getActionType().ordinal());
+				switch (action.getActionType()) {
+				case CHANNEL:
+					int channel = ((LexerChannelAction)action).getChannel();
+					data.add(channel != -1 ? channel : 0xFFFF);
+					data.add(0);
+					break;
+
+				case CUSTOM:
+					int ruleIndex = ((LexerCustomAction)action).getRuleIndex();
+					int actionIndex = ((LexerCustomAction)action).getActionIndex();
+					data.add(ruleIndex != -1 ? ruleIndex : 0xFFFF);
+					data.add(actionIndex != -1 ? actionIndex : 0xFFFF);
+					break;
+
+				case MODE:
+					int mode = ((LexerModeAction)action).getMode();
+					data.add(mode != -1 ? mode : 0xFFFF);
+					data.add(0);
+					break;
+
+				case MORE:
+					data.add(0);
+					data.add(0);
+					break;
+
+				case POP_MODE:
+					data.add(0);
+					data.add(0);
+					break;
+
+				case PUSH_MODE:
+					mode = ((LexerPushModeAction)action).getMode();
+					data.add(mode != -1 ? mode : 0xFFFF);
+					data.add(0);
+					break;
+
+				case SKIP:
+					data.add(0);
+					data.add(0);
+					break;
+
+				case TYPE:
+					int type = ((LexerTypeAction)action).getType();
+					data.add(type != -1 ? type : 0xFFFF);
+					data.add(0);
+					break;
+
+				default:
+					String message = String.format(Locale.getDefault(), "The specified lexer action type %s is not valid.", action.getActionType());
+					throw new IllegalArgumentException(message);
+				}
+			}
+		}
+
 		// don't adjust the first value since that's the version number
 		for (int i = 1; i < data.size(); i++) {
 			if (data.get(i) < Character.MIN_VALUE || data.get(i) > Character.MAX_VALUE) {
@@ -382,11 +437,7 @@ public class ATNSerializer {
 			int s = ATNDeserializer.toInt(data[p++]);
             if (atn.grammarType == ATNType.LEXER) {
                 int arg1 = ATNDeserializer.toInt(data[p++]);
-                int arg2 = ATNDeserializer.toInt(data[p++]);
-				if (arg2 == Character.MAX_VALUE) {
-					arg2 = -1;
-				}
-                buf.append("rule ").append(i).append(":").append(s).append(" ").append(arg1).append(",").append(arg2).append('\n');
+                buf.append("rule ").append(i).append(":").append(s).append(" ").append(arg1).append('\n');
             }
             else {
                 buf.append("rule ").append(i).append(":").append(s).append('\n');
@@ -435,6 +486,14 @@ public class ATNSerializer {
 			int s = ATNDeserializer.toInt(data[p++]);
 			buf.append(i).append(":").append(s).append("\n");
 		}
+		if (atn.grammarType == ATNType.LEXER) {
+				int lexerActionCount = ATNDeserializer.toInt(data[p++]);
+				for (int i = 0; i < lexerActionCount; i++) {
+					LexerActionType actionType = LexerActionType.values()[ATNDeserializer.toInt(data[p++])];
+					int data1 = ATNDeserializer.toInt(data[p++]);
+					int data2 = ATNDeserializer.toInt(data[p++]);
+				}
+		}
 		return buf.toString();
 	}
 
diff --git a/runtime/Java/src/org/antlr/v4/runtime/atn/ATNSimulator.java b/runtime/Java/src/org/antlr/v4/runtime/atn/ATNSimulator.java
index 6cb95a6e0..043144de8 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/atn/ATNSimulator.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/atn/ATNSimulator.java
@@ -32,7 +32,6 @@ package org.antlr.v4.runtime.atn;
 
 import org.antlr.v4.runtime.dfa.DFAState;
 import org.antlr.v4.runtime.misc.IntervalSet;
-import org.antlr.v4.runtime.misc.NotNull;
 
 import java.util.IdentityHashMap;
 import java.util.List;
@@ -59,9 +58,9 @@ public abstract class ATNSimulator {
 	}
 
 	/** Must distinguish between missing edge and edge we know leads nowhere */
-	@NotNull
+
 	public static final DFAState ERROR;
-	@NotNull
+
 	public final ATN atn;
 
 	/** The context cache maps all PredictionContext objects that are equals()
@@ -70,19 +69,19 @@ public abstract class ATNSimulator {
 	 *  to use only cached nodes/graphs in addDFAState(). We don't want to
 	 *  fill this during closure() since there are lots of contexts that
 	 *  pop up but are not used ever again. It also greatly slows down closure().
-	 *  <p/>
-	 *  This cache makes a huge difference in memory and a little bit in speed.
+	 *
+	 *  <p>This cache makes a huge difference in memory and a little bit in speed.
 	 *  For the Java grammar on java.*, it dropped the memory requirements
 	 *  at the end from 25M to 16M. We don't store any of the full context
 	 *  graphs in the DFA because they are limited to local context only,
 	 *  but apparently there's a lot of repetition there as well. We optimize
 	 *  the config contexts before storing the config set in the DFA states
-	 *  by literally rebuilding them with cached subgraphs only.
-	 *  <p/>
-	 *  I tried a cache for use during closure operations, that was
+	 *  by literally rebuilding them with cached subgraphs only.</p>
+	 *
+	 *  <p>I tried a cache for use during closure operations, that was
 	 *  whacked after each adaptivePredict(). It cost a little bit
 	 *  more time I think and doesn't save on the overall footprint
-	 *  so it's not worth the complexity.
+	 *  so it's not worth the complexity.</p>
  	 */
 	protected final PredictionContextCache sharedContextCache;
 
@@ -91,8 +90,8 @@ public abstract class ATNSimulator {
 		ERROR.stateNumber = Integer.MAX_VALUE;
 	}
 
-	public ATNSimulator(@NotNull ATN atn,
-						@NotNull PredictionContextCache sharedContextCache)
+	public ATNSimulator(ATN atn,
+						PredictionContextCache sharedContextCache)
 	{
 		this.atn = atn;
 		this.sharedContextCache = sharedContextCache;
@@ -100,6 +99,21 @@ public abstract class ATNSimulator {
 
 	public abstract void reset();
 
+	/**
+	 * Clear the DFA cache used by the current instance. Since the DFA cache may
+	 * be shared by multiple ATN simulators, this method may affect the
+	 * performance (but not accuracy) of other parsers which are being used
+	 * concurrently.
+	 *
+	 * @throws UnsupportedOperationException if the current instance does not
+	 * support clearing the DFA.
+	 *
+	 * @since 4.3
+	 */
+	public void clearDFA() {
+		throw new UnsupportedOperationException("This ATN simulator does not support clearing the DFA.");
+	}
+
 	public PredictionContextCache getSharedContextCache() {
 		return sharedContextCache;
 	}
@@ -120,7 +134,7 @@ public abstract class ATNSimulator {
 	 * @deprecated Use {@link ATNDeserializer#deserialize} instead.
 	 */
 	@Deprecated
-	public static ATN deserialize(@NotNull char[] data) {
+	public static ATN deserialize(char[] data) {
 		return new ATNDeserializer().deserialize(data);
 	}
 
@@ -176,8 +190,8 @@ public abstract class ATNSimulator {
 	 * @deprecated Use {@link ATNDeserializer#edgeFactory} instead.
 	 */
 	@Deprecated
-	@NotNull
-	public static Transition edgeFactory(@NotNull ATN atn,
+
+	public static Transition edgeFactory(ATN atn,
 										 int type, int src, int trg,
 										 int arg1, int arg2, int arg3,
 										 List<IntervalSet> sets)
@@ -193,15 +207,4 @@ public abstract class ATNSimulator {
 		return new ATNDeserializer().stateFactory(type, ruleIndex);
 	}
 
-/*
-	public static void dump(DFA dfa, Grammar g) {
-		DOTGenerator dot = new DOTGenerator(g);
-		String output = dot.getDOT(dfa, false);
-		System.out.println(output);
-	}
-
-	public static void dump(DFA dfa) {
-		dump(dfa, null);
-	}
-	 */
 }
diff --git a/runtime/Java/src/org/antlr/v4/runtime/atn/ActionTransition.java b/runtime/Java/src/org/antlr/v4/runtime/atn/ActionTransition.java
index f36dc1c51..1d4c32e99 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/atn/ActionTransition.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/atn/ActionTransition.java
@@ -30,18 +30,16 @@
 
 package org.antlr.v4.runtime.atn;
 
-import org.antlr.v4.runtime.misc.NotNull;
-
 public final class ActionTransition extends Transition {
 	public final int ruleIndex;
 	public final int actionIndex;
 	public final boolean isCtxDependent; // e.g., $i ref in action
 
-	public ActionTransition(@NotNull ATNState target, int ruleIndex) {
+	public ActionTransition(ATNState target, int ruleIndex) {
 		this(target, ruleIndex, -1, false);
 	}
 
-	public ActionTransition(@NotNull ATNState target, int ruleIndex, int actionIndex, boolean isCtxDependent) {
+	public ActionTransition(ATNState target, int ruleIndex, int actionIndex, boolean isCtxDependent) {
 		super(target);
 		this.ruleIndex = ruleIndex;
 		this.actionIndex = actionIndex;
diff --git a/runtime/Java/src/org/antlr/v4/runtime/atn/AmbiguityInfo.java b/runtime/Java/src/org/antlr/v4/runtime/atn/AmbiguityInfo.java
new file mode 100644
index 000000000..7ce93490c
--- /dev/null
+++ b/runtime/Java/src/org/antlr/v4/runtime/atn/AmbiguityInfo.java
@@ -0,0 +1,97 @@
+/*
+ * [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.
+ */
+
+package org.antlr.v4.runtime.atn;
+
+import org.antlr.v4.runtime.ANTLRErrorListener;
+import org.antlr.v4.runtime.TokenStream;
+
+import java.util.BitSet;
+
+/**
+ * This class represents profiling event information for an ambiguity.
+ * Ambiguities are decisions where a particular input resulted in an SLL
+ * conflict, followed by LL prediction also reaching a conflict state
+ * (indicating a true ambiguity in the grammar).
+ *
+ * <p>
+ * This event may be reported during SLL prediction in cases where the
+ * conflicting SLL configuration set provides sufficient information to
+ * determine that the SLL conflict is truly an ambiguity. For example, if none
+ * of the ATN configurations in the conflicting SLL configuration set have
+ * traversed a global follow transition (i.e.
+ * {@link ATNConfig#reachesIntoOuterContext} is 0 for all configurations), then
+ * the result of SLL prediction for that input is known to be equivalent to the
+ * result of LL prediction for that input.</p>
+ *
+ * <p>
+ * In some cases, the minimum represented alternative in the conflicting LL
+ * configuration set is not equal to the minimum represented alternative in the
+ * conflicting SLL configuration set. Grammars and inputs which result in this
+ * scenario are unable to use {@link PredictionMode#SLL}, which in turn means
+ * they cannot use the two-stage parsing strategy to improve parsing performance
+ * for that input.</p>
+ *
+ * @see ParserATNSimulator#reportAmbiguity
+ * @see ANTLRErrorListener#reportAmbiguity
+ *
+ * @since 4.3
+ */
+public class AmbiguityInfo extends DecisionEventInfo {
+	/** The set of alternative numbers for this decision event that lead to a valid parse. */
+	public BitSet ambigAlts;
+
+	/**
+	 * Constructs a new instance of the {@link AmbiguityInfo} class with the
+	 * specified detailed ambiguity information.
+	 *
+	 * @param decision The decision number
+	 * @param configs The final configuration set identifying the ambiguous
+	 * alternatives for the current input
+	 * @param ambigAlts The set of alternatives in the decision that lead to a valid parse.
+	 *                  The predicted alt is the min(ambigAlts)
+	 * @param input The input token stream
+	 * @param startIndex The start index for the current prediction
+	 * @param stopIndex The index at which the ambiguity was identified during
+	 * prediction
+	 * @param fullCtx {@code true} if the ambiguity was identified during LL
+	 * prediction; otherwise, {@code false} if the ambiguity was identified
+	 * during SLL prediction
+	 */
+	public AmbiguityInfo(int decision,
+						 ATNConfigSet configs,
+						 BitSet ambigAlts,
+						 TokenStream input, int startIndex, int stopIndex,
+						 boolean fullCtx)
+	{
+		super(decision, configs, input, startIndex, stopIndex, fullCtx);
+		this.ambigAlts = ambigAlts;
+	}
+}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/atn/AtomTransition.java b/runtime/Java/src/org/antlr/v4/runtime/atn/AtomTransition.java
index be148935e..018a4f762 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/atn/AtomTransition.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/atn/AtomTransition.java
@@ -31,14 +31,13 @@
 package org.antlr.v4.runtime.atn;
 
 import org.antlr.v4.runtime.misc.IntervalSet;
-import org.antlr.v4.runtime.misc.NotNull;
 
 /** TODO: make all transitions sets? no, should remove set edges */
 public final class AtomTransition extends Transition {
 	/** The token type or character value; or, signifies special label. */
 	public final int label;
 
-	public AtomTransition(@NotNull ATNState target, int label) {
+	public AtomTransition(ATNState target, int label) {
 		super(target);
 		this.label = label;
 	}
@@ -49,7 +48,7 @@ public final class AtomTransition extends Transition {
 	}
 
 	@Override
-	@NotNull
+
 	public IntervalSet label() { return IntervalSet.of(label); }
 
 	@Override
@@ -58,7 +57,6 @@ public final class AtomTransition extends Transition {
 	}
 
 	@Override
-	@NotNull
 	public String toString() {
 		return String.valueOf(label);
 	}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/atn/BasicBlockStartState.java b/runtime/Java/src/org/antlr/v4/runtime/atn/BasicBlockStartState.java
index d7d5aedec..ebb7f0960 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/atn/BasicBlockStartState.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/atn/BasicBlockStartState.java
@@ -35,10 +35,8 @@ package org.antlr.v4.runtime.atn;
  * @author Sam Harwell
  */
 public final class BasicBlockStartState extends BlockStartState {
-
 	@Override
 	public int getStateType() {
 		return BLOCK_START;
 	}
-
 }
diff --git a/runtime/Java/src/org/antlr/v4/runtime/atn/ContextSensitivityInfo.java b/runtime/Java/src/org/antlr/v4/runtime/atn/ContextSensitivityInfo.java
new file mode 100644
index 000000000..3f7320bea
--- /dev/null
+++ b/runtime/Java/src/org/antlr/v4/runtime/atn/ContextSensitivityInfo.java
@@ -0,0 +1,73 @@
+/*
+ * [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.
+ */
+
+package org.antlr.v4.runtime.atn;
+
+import org.antlr.v4.runtime.ANTLRErrorListener;
+import org.antlr.v4.runtime.TokenStream;
+
+/**
+ * This class represents profiling event information for a context sensitivity.
+ * Context sensitivities are decisions where a particular input resulted in an
+ * SLL conflict, but LL prediction produced a single unique alternative.
+ *
+ * <p>
+ * In some cases, the unique alternative identified by LL prediction is not
+ * equal to the minimum represented alternative in the conflicting SLL
+ * configuration set. Grammars and inputs which result in this scenario are
+ * unable to use {@link PredictionMode#SLL}, which in turn means they cannot use
+ * the two-stage parsing strategy to improve parsing performance for that
+ * input.</p>
+ *
+ * @see ParserATNSimulator#reportContextSensitivity
+ * @see ANTLRErrorListener#reportContextSensitivity
+ *
+ * @since 4.3
+ */
+public class ContextSensitivityInfo extends DecisionEventInfo {
+	/**
+	 * Constructs a new instance of the {@link ContextSensitivityInfo} class
+	 * with the specified detailed context sensitivity information.
+	 *
+	 * @param decision The decision number
+	 * @param configs The final configuration set containing the unique
+	 * alternative identified by full-context prediction
+	 * @param input The input token stream
+	 * @param startIndex The start index for the current prediction
+	 * @param stopIndex The index at which the context sensitivity was
+	 * identified during full-context prediction
+	 */
+	public ContextSensitivityInfo(int decision,
+								  ATNConfigSet configs,
+								  TokenStream input, int startIndex, int stopIndex)
+	{
+		super( decision, configs, input, startIndex, stopIndex, true);
+	}
+}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/atn/DecisionEventInfo.java b/runtime/Java/src/org/antlr/v4/runtime/atn/DecisionEventInfo.java
new file mode 100644
index 000000000..3e8e272a1
--- /dev/null
+++ b/runtime/Java/src/org/antlr/v4/runtime/atn/DecisionEventInfo.java
@@ -0,0 +1,99 @@
+/*
+ * [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.
+ */
+
+package org.antlr.v4.runtime.atn;
+
+import org.antlr.v4.runtime.TokenStream;
+
+/**
+ * This is the base class for gathering detailed information about prediction
+ * events which occur during parsing.
+ *
+ * Note that we could record the parser call stack at the time this event
+ * occurred but in the presence of left recursive rules, the stack is kind of
+ * meaningless. It's better to look at the individual configurations for their
+ * individual stacks. Of course that is a {@link PredictionContext} object
+ * not a parse tree node and so it does not have information about the extent
+ * (start...stop) of the various subtrees. Examining the stack tops of all
+ * configurations provide the return states for the rule invocations.
+ * From there you can get the enclosing rule.
+ *
+ * @since 4.3
+ */
+public class DecisionEventInfo {
+	/**
+	 * The invoked decision number which this event is related to.
+	 *
+	 * @see ATN#decisionToState
+	 */
+	public final int decision;
+
+	/**
+	 * The configuration set containing additional information relevant to the
+	 * prediction state when the current event occurred, or {@code null} if no
+	 * additional information is relevant or available.
+	 */
+	public final ATNConfigSet configs;
+
+	/**
+	 * The input token stream which is being parsed.
+	 */
+	public final TokenStream input;
+
+	/**
+	 * The token index in the input stream at which the current prediction was
+	 * originally invoked.
+	 */
+	public final int startIndex;
+
+	/**
+	 * The token index in the input stream at which the current event occurred.
+	 */
+	public final int stopIndex;
+
+	/**
+	 * {@code true} if the current event occurred during LL prediction;
+	 * otherwise, {@code false} if the input occurred during SLL prediction.
+	 */
+	public final boolean fullCtx;
+
+	public DecisionEventInfo(int decision,
+							 ATNConfigSet configs,
+							 TokenStream input, int startIndex, int stopIndex,
+							 boolean fullCtx)
+	{
+		this.decision = decision;
+		this.fullCtx = fullCtx;
+		this.stopIndex = stopIndex;
+		this.input = input;
+		this.startIndex = startIndex;
+		this.configs = configs;
+	}
+}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/atn/DecisionInfo.java b/runtime/Java/src/org/antlr/v4/runtime/atn/DecisionInfo.java
new file mode 100644
index 000000000..7780a4973
--- /dev/null
+++ b/runtime/Java/src/org/antlr/v4/runtime/atn/DecisionInfo.java
@@ -0,0 +1,268 @@
+/*
+ * [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.
+ */
+
+package org.antlr.v4.runtime.atn;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * This class contains profiling gathered for a particular decision.
+ *
+ * <p>
+ * Parsing performance in ANTLR 4 is heavily influenced by both static factors
+ * (e.g. the form of the rules in the grammar) and dynamic factors (e.g. the
+ * choice of input and the state of the DFA cache at the time profiling
+ * operations are started). For best results, gather and use aggregate
+ * statistics from a large sample of inputs representing the inputs expected in
+ * production before using the results to make changes in the grammar.</p>
+ *
+ * @since 4.3
+ */
+public class DecisionInfo {
+	/**
+	 * The decision number, which is an index into {@link ATN#decisionToState}.
+	 */
+	public final int decision;
+
+	/**
+	 * The total number of times {@link ParserATNSimulator#adaptivePredict} was
+	 * invoked for this decision.
+	 */
+	public long invocations;
+
+	/**
+	 * The total time spent in {@link ParserATNSimulator#adaptivePredict} for
+	 * this decision, in nanoseconds.
+	 *
+	 * <p>
+	 * The value of this field contains the sum of differential results obtained
+	 * by {@link System#nanoTime()}, and is not adjusted to compensate for JIT
+	 * and/or garbage collection overhead. For best accuracy, use a modern JVM
+	 * implementation that provides precise results from
+	 * {@link System#nanoTime()}, and perform profiling in a separate process
+	 * which is warmed up by parsing the input prior to profiling. If desired,
+	 * call {@link ATNSimulator#clearDFA} to reset the DFA cache to its initial
+	 * state before starting the profiling measurement pass.</p>
+	 */
+	public long timeInPrediction;
+
+	/**
+	 * The sum of the lookahead required for SLL prediction for this decision.
+	 * Note that SLL prediction is used before LL prediction for performance
+	 * reasons even when {@link PredictionMode#LL} or
+	 * {@link PredictionMode#LL_EXACT_AMBIG_DETECTION} is used.
+	 */
+	public long SLL_TotalLook;
+
+	/**
+	 * Gets the minimum lookahead required for any single SLL prediction to
+	 * complete for this decision, by reaching a unique prediction, reaching an
+	 * SLL conflict state, or encountering a syntax error.
+	 */
+	public long SLL_MinLook;
+
+	/**
+	 * Gets the maximum lookahead required for any single SLL prediction to
+	 * complete for this decision, by reaching a unique prediction, reaching an
+	 * SLL conflict state, or encountering a syntax error.
+	 */
+	public long SLL_MaxLook;
+
+	/**
+	 * Gets the {@link LookaheadEventInfo} associated with the event where the
+	 * {@link #SLL_MaxLook} value was set.
+	 */
+	public LookaheadEventInfo SLL_MaxLookEvent;
+
+	/**
+	 * The sum of the lookahead required for LL prediction for this decision.
+	 * Note that LL prediction is only used when SLL prediction reaches a
+	 * conflict state.
+	 */
+	public long LL_TotalLook;
+
+	/**
+	 * Gets the minimum lookahead required for any single LL prediction to
+	 * complete for this decision. An LL prediction completes when the algorithm
+	 * reaches a unique prediction, a conflict state (for
+	 * {@link PredictionMode#LL}, an ambiguity state (for
+	 * {@link PredictionMode#LL_EXACT_AMBIG_DETECTION}, or a syntax error.
+	 */
+	public long LL_MinLook;
+
+	/**
+	 * Gets the maximum lookahead required for any single LL prediction to
+	 * complete for this decision. An LL prediction completes when the algorithm
+	 * reaches a unique prediction, a conflict state (for
+	 * {@link PredictionMode#LL}, an ambiguity state (for
+	 * {@link PredictionMode#LL_EXACT_AMBIG_DETECTION}, or a syntax error.
+	 */
+	public long LL_MaxLook;
+
+	/**
+	 * Gets the {@link LookaheadEventInfo} associated with the event where the
+	 * {@link #LL_MaxLook} value was set.
+	 */
+	public LookaheadEventInfo LL_MaxLookEvent;
+
+	/**
+	 * A collection of {@link ContextSensitivityInfo} instances describing the
+	 * context sensitivities encountered during LL prediction for this decision.
+	 *
+	 * @see ContextSensitivityInfo
+	 */
+	public final List<ContextSensitivityInfo> contextSensitivities = new ArrayList<ContextSensitivityInfo>();
+
+	/**
+	 * A collection of {@link ErrorInfo} instances describing the parse errors
+	 * identified during calls to {@link ParserATNSimulator#adaptivePredict} for
+	 * this decision.
+	 *
+	 * @see ErrorInfo
+	 */
+	public final List<ErrorInfo> errors = new ArrayList<ErrorInfo>();
+
+	/**
+	 * A collection of {@link AmbiguityInfo} instances describing the
+	 * ambiguities encountered during LL prediction for this decision.
+	 *
+	 * @see AmbiguityInfo
+	 */
+	public final List<AmbiguityInfo> ambiguities = new ArrayList<AmbiguityInfo>();
+
+	/**
+	 * A collection of {@link PredicateEvalInfo} instances describing the
+	 * results of evaluating individual predicates during prediction for this
+	 * decision.
+	 *
+	 * @see PredicateEvalInfo
+	 */
+	public final List<PredicateEvalInfo> predicateEvals = new ArrayList<PredicateEvalInfo>();
+
+	/**
+	 * The total number of ATN transitions required during SLL prediction for
+	 * this decision. An ATN transition is determined by the number of times the
+	 * DFA does not contain an edge that is required for prediction, resulting
+	 * in on-the-fly computation of that edge.
+	 *
+	 * <p>
+	 * If DFA caching of SLL transitions is employed by the implementation, ATN
+	 * computation may cache the computed edge for efficient lookup during
+	 * future parsing of this decision. Otherwise, the SLL parsing algorithm
+	 * will use ATN transitions exclusively.</p>
+	 *
+	 * @see #SLL_ATNTransitions
+	 * @see ParserATNSimulator#computeTargetState
+	 * @see LexerATNSimulator#computeTargetState
+	 */
+	public long SLL_ATNTransitions;
+
+	/**
+	 * The total number of DFA transitions required during SLL prediction for
+	 * this decision.
+	 *
+	 * <p>If the ATN simulator implementation does not use DFA caching for SLL
+	 * transitions, this value will be 0.</p>
+	 *
+	 * @see ParserATNSimulator#getExistingTargetState
+	 * @see LexerATNSimulator#getExistingTargetState
+	 */
+	public long SLL_DFATransitions;
+
+	/**
+	 * Gets the total number of times SLL prediction completed in a conflict
+	 * state, resulting in fallback to LL prediction.
+	 *
+	 * <p>Note that this value is not related to whether or not
+	 * {@link PredictionMode#SLL} may be used successfully with a particular
+	 * grammar. If the ambiguity resolution algorithm applied to the SLL
+	 * conflicts for this decision produce the same result as LL prediction for
+	 * this decision, {@link PredictionMode#SLL} would produce the same overall
+	 * parsing result as {@link PredictionMode#LL}.</p>
+	 */
+	public long LL_Fallback;
+
+	/**
+	 * The total number of ATN transitions required during LL prediction for
+	 * this decision. An ATN transition is determined by the number of times the
+	 * DFA does not contain an edge that is required for prediction, resulting
+	 * in on-the-fly computation of that edge.
+	 *
+	 * <p>
+	 * If DFA caching of LL transitions is employed by the implementation, ATN
+	 * computation may cache the computed edge for efficient lookup during
+	 * future parsing of this decision. Otherwise, the LL parsing algorithm will
+	 * use ATN transitions exclusively.</p>
+	 *
+	 * @see #LL_DFATransitions
+	 * @see ParserATNSimulator#computeTargetState
+	 * @see LexerATNSimulator#computeTargetState
+	 */
+	public long LL_ATNTransitions;
+	
+	/**
+	 * The total number of DFA transitions required during LL prediction for
+	 * this decision.
+	 *
+	 * <p>If the ATN simulator implementation does not use DFA caching for LL
+	 * transitions, this value will be 0.</p>
+	 *
+	 * @see ParserATNSimulator#getExistingTargetState
+	 * @see LexerATNSimulator#getExistingTargetState
+	 */
+	public long LL_DFATransitions;
+
+	/**
+	 * Constructs a new instance of the {@link DecisionInfo} class to contain
+	 * statistics for a particular decision.
+	 *
+	 * @param decision The decision number
+	 */
+	public DecisionInfo(int decision) {
+		this.decision = decision;
+	}
+
+	@Override
+	public String toString() {
+		return "{" +
+			   "decision=" + decision +
+			   ", contextSensitivities=" + contextSensitivities.size() +
+			   ", errors=" + errors.size() +
+			   ", ambiguities=" + ambiguities.size() +
+			   ", SLL_lookahead=" + SLL_TotalLook +
+			   ", SLL_ATNTransitions=" + SLL_ATNTransitions +
+			   ", SLL_DFATransitions=" + SLL_DFATransitions +
+			   ", LL_Fallback=" + LL_Fallback +
+			   ", LL_lookahead=" + LL_TotalLook +
+			   ", LL_ATNTransitions=" + LL_ATNTransitions +
+			   '}';
+	}
+}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/atn/EpsilonTransition.java b/runtime/Java/src/org/antlr/v4/runtime/atn/EpsilonTransition.java
index 546286ddd..aee9ce2a0 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/atn/EpsilonTransition.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/atn/EpsilonTransition.java
@@ -30,10 +30,30 @@
 
 package org.antlr.v4.runtime.atn;
 
-import org.antlr.v4.runtime.misc.NotNull;
-
 public final class EpsilonTransition extends Transition {
-	public EpsilonTransition(@NotNull ATNState target) { super(target); }
+
+	private final int outermostPrecedenceReturn;
+
+	public EpsilonTransition(ATNState target) {
+		this(target, -1);
+	}
+
+	public EpsilonTransition(ATNState target, int outermostPrecedenceReturn) {
+		super(target);
+		this.outermostPrecedenceReturn = outermostPrecedenceReturn;
+	}
+
+	/**
+	 * @return the rule index of a precedence rule for which this transition is
+	 * returning from, where the precedence value is 0; otherwise, -1.
+	 *
+	 * @see ATNConfig#isPrecedenceFilterSuppressed()
+	 * @see ParserATNSimulator#applyPrecedenceFilter(ATNConfigSet)
+	 * @since 4.4.1
+	 */
+	public int outermostPrecedenceReturn() {
+		return outermostPrecedenceReturn;
+	}
 
 	@Override
 	public int getSerializationType() {
@@ -49,7 +69,7 @@ public final class EpsilonTransition extends Transition {
 	}
 
 	@Override
-	@NotNull
+
 	public String toString() {
 		return "epsilon";
 	}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/atn/ErrorInfo.java b/runtime/Java/src/org/antlr/v4/runtime/atn/ErrorInfo.java
new file mode 100644
index 000000000..60b9e0520
--- /dev/null
+++ b/runtime/Java/src/org/antlr/v4/runtime/atn/ErrorInfo.java
@@ -0,0 +1,72 @@
+/*
+ * [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.
+ */
+
+package org.antlr.v4.runtime.atn;
+
+import org.antlr.v4.runtime.ANTLRErrorListener;
+import org.antlr.v4.runtime.Parser;
+import org.antlr.v4.runtime.RecognitionException;
+import org.antlr.v4.runtime.Token;
+import org.antlr.v4.runtime.TokenStream;
+
+/**
+ * This class represents profiling event information for a syntax error
+ * identified during prediction. Syntax errors occur when the prediction
+ * algorithm is unable to identify an alternative which would lead to a
+ * successful parse.
+ *
+ * @see Parser#notifyErrorListeners(Token, String, RecognitionException)
+ * @see ANTLRErrorListener#syntaxError
+ *
+ * @since 4.3
+ */
+public class ErrorInfo extends DecisionEventInfo {
+	/**
+	 * Constructs a new instance of the {@link ErrorInfo} class with the
+	 * specified detailed syntax error information.
+	 *
+	 * @param decision The decision number
+	 * @param configs The final configuration set reached during prediction
+	 * prior to reaching the {@link ATNSimulator#ERROR} state
+	 * @param input The input token stream
+	 * @param startIndex The start index for the current prediction
+	 * @param stopIndex The index at which the syntax error was identified
+	 * @param fullCtx {@code true} if the syntax error was identified during LL
+	 * prediction; otherwise, {@code false} if the syntax error was identified
+	 * during SLL prediction
+	 */
+	public ErrorInfo(int decision,
+					 ATNConfigSet configs,
+					 TokenStream input, int startIndex, int stopIndex,
+					 boolean fullCtx)
+	{
+		super(decision, configs, input, startIndex, stopIndex, fullCtx);
+	}
+}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/atn/LL1Analyzer.java b/runtime/Java/src/org/antlr/v4/runtime/atn/LL1Analyzer.java
index 3467d28d0..bd88ef255 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/atn/LL1Analyzer.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/atn/LL1Analyzer.java
@@ -33,8 +33,6 @@ package org.antlr.v4.runtime.atn;
 import org.antlr.v4.runtime.RuleContext;
 import org.antlr.v4.runtime.Token;
 import org.antlr.v4.runtime.misc.IntervalSet;
-import org.antlr.v4.runtime.misc.NotNull;
-import org.antlr.v4.runtime.misc.Nullable;
 
 import java.util.BitSet;
 import java.util.HashSet;
@@ -46,10 +44,9 @@ public class LL1Analyzer {
 	 */
 	public static final int HIT_PRED = Token.INVALID_TYPE;
 
-	@NotNull
 	public final ATN atn;
 
-	public LL1Analyzer(@NotNull ATN atn) { this.atn = atn; }
+	public LL1Analyzer(ATN atn) { this.atn = atn; }
 
 	/**
 	 * Calculates the SLL(1) expected lookahead set for each outgoing transition
@@ -61,8 +58,7 @@ public class LL1Analyzer {
 	 * @param s the ATN state
 	 * @return the expected symbols for each outgoing transition of {@code s}.
 	 */
-	@Nullable
-	public IntervalSet[] getDecisionLookahead(@Nullable ATNState s) {
+	public IntervalSet[] getDecisionLookahead(ATNState s) {
 //		System.out.println("LOOK("+s.stateNumber+")");
 		if ( s==null ) {
 			return null;
@@ -87,11 +83,11 @@ public class LL1Analyzer {
 	/**
 	 * Compute set of tokens that can follow {@code s} in the ATN in the
 	 * specified {@code ctx}.
-	 * <p/>
-	 * If {@code ctx} is {@code null} and the end of the rule containing
+	 *
+	 * <p>If {@code ctx} is {@code null} and the end of the rule containing
 	 * {@code s} is reached, {@link Token#EPSILON} is added to the result set.
 	 * If {@code ctx} is not {@code null} and the end of the outermost rule is
-	 * reached, {@link Token#EOF} is added to the result set.
+	 * reached, {@link Token#EOF} is added to the result set.</p>
 	 *
 	 * @param s the ATN state
 	 * @param ctx the complete parser context, or {@code null} if the context
@@ -100,19 +96,18 @@ public class LL1Analyzer {
 	 * @return The set of tokens that can follow {@code s} in the ATN in the
 	 * specified {@code ctx}.
 	 */
-    @NotNull
-   	public IntervalSet LOOK(@NotNull ATNState s, @Nullable RuleContext ctx) {
+   	public IntervalSet LOOK(ATNState s, RuleContext ctx) {
 		return LOOK(s, null, ctx);
    	}
 
 	/**
 	 * Compute set of tokens that can follow {@code s} in the ATN in the
 	 * specified {@code ctx}.
-	 * <p/>
-	 * If {@code ctx} is {@code null} and the end of the rule containing
+	 *
+	 * <p>If {@code ctx} is {@code null} and the end of the rule containing
 	 * {@code s} is reached, {@link Token#EPSILON} is added to the result set.
 	 * If {@code ctx} is not {@code null} and the end of the outermost rule is
-	 * reached, {@link Token#EOF} is added to the result set.
+	 * reached, {@link Token#EOF} is added to the result set.</p>
 	 *
 	 * @param s the ATN state
 	 * @param stopState the ATN state to stop at. This can be a
@@ -123,8 +118,8 @@ public class LL1Analyzer {
 	 * @return The set of tokens that can follow {@code s} in the ATN in the
 	 * specified {@code ctx}.
 	 */
-    @NotNull
-   	public IntervalSet LOOK(@NotNull ATNState s, @Nullable ATNState stopState, @Nullable RuleContext ctx) {
+
+   	public IntervalSet LOOK(ATNState s, ATNState stopState, RuleContext ctx) {
    		IntervalSet r = new IntervalSet();
 		boolean seeThruPreds = true; // ignore preds; get all lookahead
 		PredictionContext lookContext = ctx != null ? PredictionContext.fromRuleContext(s.atn, ctx) : null;
@@ -136,12 +131,12 @@ public class LL1Analyzer {
 	/**
 	 * Compute set of tokens that can follow {@code s} in the ATN in the
 	 * specified {@code ctx}.
-	 * <p/>
-	 * If {@code ctx} is {@code null} and {@code stopState} or the end of the
+	 *
+	 * <p>If {@code ctx} is {@code null} and {@code stopState} or the end of the
 	 * rule containing {@code s} is reached, {@link Token#EPSILON} is added to
 	 * the result set. If {@code ctx} is not {@code null} and {@code addEOF} is
 	 * {@code true} and {@code stopState} or the end of the outermost rule is
-	 * reached, {@link Token#EOF} is added to the result set.
+	 * reached, {@link Token#EOF} is added to the result set.</p>
 	 *
 	 * @param s the ATN state.
 	 * @param stopState the ATN state to stop at. This can be a
@@ -163,12 +158,12 @@ public class LL1Analyzer {
 	 * outermost context is reached. This parameter has no effect if {@code ctx}
 	 * is {@code null}.
 	 */
-    protected void _LOOK(@NotNull ATNState s,
-						 @Nullable ATNState stopState,
-						 @Nullable PredictionContext ctx,
-						 @NotNull IntervalSet look,
-                         @NotNull Set<ATNConfig> lookBusy,
-						 @NotNull BitSet calledRuleStack,
+    protected void _LOOK(ATNState s,
+						 ATNState stopState,
+						 PredictionContext ctx,
+						 IntervalSet look,
+                         Set<ATNConfig> lookBusy,
+						 BitSet calledRuleStack,
 						 boolean seeThruPreds, boolean addEOF)
 	{
 //		System.out.println("_LOOK("+s.stateNumber+", ctx="+ctx);
diff --git a/runtime/Java/src/org/antlr/v4/runtime/atn/LexerATNConfig.java b/runtime/Java/src/org/antlr/v4/runtime/atn/LexerATNConfig.java
index 8cd79cabf..a2fc1fcd5 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/atn/LexerATNConfig.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/atn/LexerATNConfig.java
@@ -31,54 +31,64 @@
 package org.antlr.v4.runtime.atn;
 
 import org.antlr.v4.runtime.misc.MurmurHash;
-import org.antlr.v4.runtime.misc.NotNull;
-import org.antlr.v4.runtime.misc.Nullable;
+import org.antlr.v4.runtime.misc.ObjectEqualityComparator;
 
 public class LexerATNConfig extends ATNConfig {
-	/** Capture lexer action we traverse */
-	public int lexerActionIndex = -1;
+	/**
+	 * This is the backing field for {@link #getLexerActionExecutor}.
+	 */
+	private final LexerActionExecutor lexerActionExecutor;
 
 	private final boolean passedThroughNonGreedyDecision;
 
-	public LexerATNConfig(@NotNull ATNState state,
+	public LexerATNConfig(ATNState state,
 						  int alt,
-						  @Nullable PredictionContext context)
+						  PredictionContext context)
 	{
 		super(state, alt, context, SemanticContext.NONE);
 		this.passedThroughNonGreedyDecision = false;
+		this.lexerActionExecutor = null;
 	}
 
-	public LexerATNConfig(@NotNull ATNState state,
+	public LexerATNConfig(ATNState state,
 						  int alt,
-						  @Nullable PredictionContext context,
-						  int actionIndex)
+						  PredictionContext context,
+						  LexerActionExecutor lexerActionExecutor)
 	{
 		super(state, alt, context, SemanticContext.NONE);
-		this.lexerActionIndex = actionIndex;
+		this.lexerActionExecutor = lexerActionExecutor;
 		this.passedThroughNonGreedyDecision = false;
 	}
 
-	public LexerATNConfig(@NotNull LexerATNConfig c, @NotNull ATNState state) {
+	public LexerATNConfig(LexerATNConfig c, ATNState state) {
 		super(c, state, c.context, c.semanticContext);
-		this.lexerActionIndex = c.lexerActionIndex;
+		this.lexerActionExecutor = c.lexerActionExecutor;
 		this.passedThroughNonGreedyDecision = checkNonGreedyDecision(c, state);
 	}
 
-	public LexerATNConfig(@NotNull LexerATNConfig c, @NotNull ATNState state,
-						  int actionIndex)
+	public LexerATNConfig(LexerATNConfig c, ATNState state,
+						  LexerActionExecutor lexerActionExecutor)
 	{
 		super(c, state, c.context, c.semanticContext);
-		this.lexerActionIndex = actionIndex;
+		this.lexerActionExecutor = lexerActionExecutor;
 		this.passedThroughNonGreedyDecision = checkNonGreedyDecision(c, state);
 	}
 
-	public LexerATNConfig(@NotNull LexerATNConfig c, @NotNull ATNState state,
-						  @Nullable PredictionContext context) {
+	public LexerATNConfig(LexerATNConfig c, ATNState state,
+						  PredictionContext context) {
 		super(c, state, context, c.semanticContext);
-		this.lexerActionIndex = c.lexerActionIndex;
+		this.lexerActionExecutor = c.lexerActionExecutor;
 		this.passedThroughNonGreedyDecision = checkNonGreedyDecision(c, state);
 	}
 
+	/**
+	 * Gets the {@link LexerActionExecutor} capable of executing the embedded
+	 * action(s) for the current configuration.
+	 */
+	public final LexerActionExecutor getLexerActionExecutor() {
+		return lexerActionExecutor;
+	}
+
 	public final boolean hasPassedThroughNonGreedyDecision() {
 		return passedThroughNonGreedyDecision;
 	}
@@ -91,7 +101,8 @@ public class LexerATNConfig extends ATNConfig {
 		hashCode = MurmurHash.update(hashCode, context);
 		hashCode = MurmurHash.update(hashCode, semanticContext);
 		hashCode = MurmurHash.update(hashCode, passedThroughNonGreedyDecision ? 1 : 0);
-		hashCode = MurmurHash.finish(hashCode, 5);
+		hashCode = MurmurHash.update(hashCode, lexerActionExecutor);
+		hashCode = MurmurHash.finish(hashCode, 6);
 		return hashCode;
 	}
 
@@ -109,6 +120,10 @@ public class LexerATNConfig extends ATNConfig {
 			return false;
 		}
 
+		if (!ObjectEqualityComparator.INSTANCE.equals(lexerActionExecutor, lexerOther.lexerActionExecutor)) {
+			return false;
+		}
+
 		return super.equals(other);
 	}
 
diff --git a/runtime/Java/src/org/antlr/v4/runtime/atn/LexerATNSimulator.java b/runtime/Java/src/org/antlr/v4/runtime/atn/LexerATNSimulator.java
index 70f715353..6f8cd89c5 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/atn/LexerATNSimulator.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/atn/LexerATNSimulator.java
@@ -38,8 +38,6 @@ import org.antlr.v4.runtime.Token;
 import org.antlr.v4.runtime.dfa.DFA;
 import org.antlr.v4.runtime.dfa.DFAState;
 import org.antlr.v4.runtime.misc.Interval;
-import org.antlr.v4.runtime.misc.NotNull;
-import org.antlr.v4.runtime.misc.Nullable;
 
 import java.util.Locale;
 
@@ -58,13 +56,13 @@ public class LexerATNSimulator extends ATNSimulator {
 	 *  and current character position in that line. Note that the Lexer is
 	 *  tracking the starting line and characterization of the token. These
 	 *  variables track the "state" of the simulator when it hits an accept state.
-	 * <p/>
-	 *  We track these variables separately for the DFA and ATN simulation
+	 *
+	 *  <p>We track these variables separately for the DFA and ATN simulation
 	 *  because the DFA simulation often has to fail over to the ATN
 	 *  simulation. If the ATN simulation fails, we need the DFA to fall
 	 *  back to its previously accepted state, if any. If the ATN succeeds,
 	 *  then the ATN does the accept and the DFA simulator that invoked it
-	 *  can simply return the predicted token type.
+	 *  can simply return the predicted token type.</p>
 	 */
 	protected static class SimState {
 		protected int index = -1;
@@ -80,7 +78,7 @@ public class LexerATNSimulator extends ATNSimulator {
 		}
 	}
 
-	@Nullable
+
 	protected final Lexer recog;
 
 	/** The current token's starting index into the character stream.
@@ -96,39 +94,39 @@ public class LexerATNSimulator extends ATNSimulator {
 	/** The index of the character relative to the beginning of the line 0..n-1 */
 	protected int charPositionInLine = 0;
 
-	@NotNull
+
 	public final DFA[] decisionToDFA;
 	protected int mode = Lexer.DEFAULT_MODE;
 
 	/** Used during DFA/ATN exec to record the most recent accept configuration info */
-	@NotNull
+
 	protected final SimState prevAccept = new SimState();
 
 	public static int match_calls = 0;
 
-	public LexerATNSimulator(@NotNull ATN atn, @NotNull DFA[] decisionToDFA,
-							 @NotNull PredictionContextCache sharedContextCache)
+	public LexerATNSimulator(ATN atn, DFA[] decisionToDFA,
+							 PredictionContextCache sharedContextCache)
 	{
 		this(null, atn, decisionToDFA,sharedContextCache);
 	}
 
-	public LexerATNSimulator(@Nullable Lexer recog, @NotNull ATN atn,
-							 @NotNull DFA[] decisionToDFA,
-							 @NotNull PredictionContextCache sharedContextCache)
+	public LexerATNSimulator(Lexer recog, ATN atn,
+							 DFA[] decisionToDFA,
+							 PredictionContextCache sharedContextCache)
 	{
 		super(atn,sharedContextCache);
 		this.decisionToDFA = decisionToDFA;
 		this.recog = recog;
 	}
 
-	public void copyState(@NotNull LexerATNSimulator simulator) {
+	public void copyState(LexerATNSimulator simulator) {
 		this.charPositionInLine = simulator.charPositionInLine;
 		this.line = simulator.line;
 		this.mode = simulator.mode;
 		this.startIndex = simulator.startIndex;
 	}
 
-	public int match(@NotNull CharStream input, int mode) {
+	public int match(CharStream input, int mode) {
 		match_calls++;
 		this.mode = mode;
 		int mark = input.mark();
@@ -157,7 +155,14 @@ public class LexerATNSimulator extends ATNSimulator {
 		mode = Lexer.DEFAULT_MODE;
 	}
 
-	protected int matchATN(@NotNull CharStream input) {
+	@Override
+	public void clearDFA() {
+		for (int d = 0; d < decisionToDFA.length; d++) {
+			decisionToDFA[d] = new DFA(atn.getDecisionState(d), d);
+		}
+	}
+
+	protected int matchATN(CharStream input) {
 		ATNState startState = atn.modeToStartState.get(mode);
 
 		if ( debug ) {
@@ -184,14 +189,19 @@ public class LexerATNSimulator extends ATNSimulator {
 		return predict;
 	}
 
-	protected int execATN(@NotNull CharStream input, @NotNull DFAState ds0) {
+	protected int execATN(CharStream input, DFAState ds0) {
 		//System.out.println("enter exec index "+input.index()+" from "+ds0.configs);
 		if ( debug ) {
 			System.out.format(Locale.getDefault(), "start state closure=%s\n", ds0.configs);
 		}
 
+		if (ds0.isAcceptState) {
+			// allow zero-length tokens
+			captureSimState(prevAccept, input, ds0);
+		}
+
 		int t = input.LA(1);
-		@NotNull
+
 		DFAState s = ds0; // s is current/from DFA state
 
 		while ( true ) { // while more work
@@ -225,6 +235,14 @@ public class LexerATNSimulator extends ATNSimulator {
 				break;
 			}
 
+			// If this is a consumable input element, make sure to consume before
+			// capturing the accept state so the input index, line, and char
+			// position accurately reflect the state of the interpreter at the
+			// end of the token.
+			if (t != IntStream.EOF) {
+				consume(input);
+			}
+
 			if (target.isAcceptState) {
 				captureSimState(prevAccept, input, target);
 				if (t == IntStream.EOF) {
@@ -232,11 +250,7 @@ public class LexerATNSimulator extends ATNSimulator {
 				}
 			}
 
-			if (t != IntStream.EOF) {
-				consume(input);
-				t = input.LA(1);
-			}
-
+			t = input.LA(1);
 			s = target; // flip; current DFA target becomes new src/from state
 		}
 
@@ -254,8 +268,8 @@ public class LexerATNSimulator extends ATNSimulator {
 	 * {@code t}, or {@code null} if the target state for this edge is not
 	 * already cached
 	 */
-	@Nullable
-	protected DFAState getExistingTargetState(@NotNull DFAState s, int t) {
+
+	protected DFAState getExistingTargetState(DFAState s, int t) {
 		if (s.edges == null || t < MIN_DFA_EDGE || t > MAX_DFA_EDGE) {
 			return null;
 		}
@@ -281,8 +295,8 @@ public class LexerATNSimulator extends ATNSimulator {
 	 * {@code t}. If {@code t} does not lead to a valid DFA state, this method
 	 * returns {@link #ERROR}.
 	 */
-	@NotNull
-	protected DFAState computeTargetState(@NotNull CharStream input, @NotNull DFAState s, int t) {
+
+	protected DFAState computeTargetState(CharStream input, DFAState s, int t) {
 		ATNConfigSet reach = new OrderedATNConfigSet();
 
 		// if we don't find an existing DFA state
@@ -290,9 +304,12 @@ public class LexerATNSimulator extends ATNSimulator {
 		getReachableConfigSet(input, s.configs, reach, t);
 
 		if ( reach.isEmpty() ) { // we got nowhere on t from s
-			// we got nowhere on t, don't throw out this knowledge; it'd
-			// cause a failover from DFA later.
-			addDFAEdge(s, t, ERROR);
+			if (!reach.hasSemanticContext) {
+				// we got nowhere on t, don't throw out this knowledge; it'd
+				// cause a failover from DFA later.
+				addDFAEdge(s, t, ERROR);
+			}
+
 			// stop when we can't match any more char
 			return ERROR;
 		}
@@ -305,9 +322,8 @@ public class LexerATNSimulator extends ATNSimulator {
 							   ATNConfigSet reach, int t)
 	{
 		if (prevAccept.dfaState != null) {
-			int ruleIndex = prevAccept.dfaState.lexerRuleIndex;
-			int actionIndex = prevAccept.dfaState.lexerActionIndex;
-			accept(input, ruleIndex, actionIndex,
+			LexerActionExecutor lexerActionExecutor = prevAccept.dfaState.lexerActionExecutor;
+			accept(input, lexerActionExecutor, startIndex,
 				prevAccept.index, prevAccept.line, prevAccept.charPos);
 			return prevAccept.dfaState.prediction;
 		}
@@ -325,7 +341,7 @@ public class LexerATNSimulator extends ATNSimulator {
 	 *  we can reach upon input {@code t}. Parameter {@code reach} is a return
 	 *  parameter.
 	 */
-	protected void getReachableConfigSet(@NotNull CharStream input, @NotNull ATNConfigSet closure, @NotNull ATNConfigSet reach, int t) {
+	protected void getReachableConfigSet(CharStream input, ATNConfigSet closure, ATNConfigSet reach, int t) {
 		// this is used to skip processing for configs which have a lower priority
 		// than a config that already reached an accept state for the same rule
 		int skipAlt = ATN.INVALID_ALT_NUMBER;
@@ -344,7 +360,13 @@ public class LexerATNSimulator extends ATNSimulator {
 				Transition trans = c.state.transition(ti);
 				ATNState target = getReachableTarget(trans, t);
 				if ( target!=null ) {
-					if (closure(input, new LexerATNConfig((LexerATNConfig)c, target), reach, currentAltReachedAcceptState, true)) {
+					LexerActionExecutor lexerActionExecutor = ((LexerATNConfig)c).getLexerActionExecutor();
+					if (lexerActionExecutor != null) {
+						lexerActionExecutor = lexerActionExecutor.fixOffsetBeforeMatch(input.index() - startIndex);
+					}
+
+					boolean treatEofAsEpsilon = t == CharStream.EOF;
+					if (closure(input, new LexerATNConfig((LexerATNConfig)c, target, lexerActionExecutor), reach, currentAltReachedAcceptState, true, treatEofAsEpsilon)) {
 						// any remaining configs for this alt have a lower priority than
 						// the one that just reached an accept state.
 						skipAlt = c.alt;
@@ -355,25 +377,24 @@ public class LexerATNSimulator extends ATNSimulator {
 		}
 	}
 
-	protected void accept(@NotNull CharStream input, int ruleIndex, int actionIndex,
-						  int index, int line, int charPos)
+	protected void accept(CharStream input, LexerActionExecutor lexerActionExecutor,
+						  int startIndex, int index, int line, int charPos)
 	{
 		if ( debug ) {
-			System.out.format(Locale.getDefault(), "ACTION %s:%d\n", recog != null ? recog.getRuleNames()[ruleIndex] : ruleIndex, actionIndex);
+			System.out.format(Locale.getDefault(), "ACTION %s\n", lexerActionExecutor);
 		}
 
-		if ( actionIndex>=0 && recog!=null ) recog.action(null, ruleIndex, actionIndex);
-
 		// seek to after last char in token
 		input.seek(index);
 		this.line = line;
 		this.charPositionInLine = charPos;
-		if (input.LA(1) != IntStream.EOF) {
-			consume(input);
+
+		if (lexerActionExecutor != null && recog != null) {
+			lexerActionExecutor.execute(recog, input, startIndex);
 		}
 	}
 
-	@Nullable
+
 	protected ATNState getReachableTarget(Transition trans, int t) {
 		if (trans.matches(t, Character.MIN_VALUE, Character.MAX_VALUE)) {
 			return trans.target;
@@ -382,16 +403,16 @@ public class LexerATNSimulator extends ATNSimulator {
 		return null;
 	}
 
-	@NotNull
-	protected ATNConfigSet computeStartState(@NotNull CharStream input,
-											 @NotNull ATNState p)
+
+	protected ATNConfigSet computeStartState(CharStream input,
+											 ATNState p)
 	{
 		PredictionContext initialContext = PredictionContext.EMPTY;
 		ATNConfigSet configs = new OrderedATNConfigSet();
 		for (int i=0; i<p.getNumberOfTransitions(); i++) {
 			ATNState target = p.transition(i).target;
 			LexerATNConfig c = new LexerATNConfig(target, i+1, initialContext);
-			closure(input, c, configs, false, false);
+			closure(input, c, configs, false, false, false);
 		}
 		return configs;
 	}
@@ -406,7 +427,7 @@ public class LexerATNSimulator extends ATNSimulator {
 	 * @return {@code true} if an accept state is reached, otherwise
 	 * {@code false}.
 	 */
-	protected boolean closure(@NotNull CharStream input, @NotNull LexerATNConfig config, @NotNull ATNConfigSet configs, boolean currentAltReachedAcceptState, boolean speculative) {
+	protected boolean closure(CharStream input, LexerATNConfig config, ATNConfigSet configs, boolean currentAltReachedAcceptState, boolean speculative, boolean treatEofAsEpsilon) {
 		if ( debug ) {
 			System.out.println("closure("+config.toString(recog, true)+")");
 		}
@@ -437,8 +458,8 @@ public class LexerATNSimulator extends ATNSimulator {
 					if (config.context.getReturnState(i) != PredictionContext.EMPTY_RETURN_STATE) {
 						PredictionContext newContext = config.context.getParent(i); // "pop" return state
 						ATNState returnState = atn.states.get(config.context.getReturnState(i));
-						LexerATNConfig c = new LexerATNConfig(returnState, config.alt, newContext);
-						currentAltReachedAcceptState = closure(input, c, configs, currentAltReachedAcceptState, speculative);
+						LexerATNConfig c = new LexerATNConfig(config, returnState, newContext);
+						currentAltReachedAcceptState = closure(input, c, configs, currentAltReachedAcceptState, speculative, treatEofAsEpsilon);
 					}
 				}
 			}
@@ -456,9 +477,9 @@ public class LexerATNSimulator extends ATNSimulator {
 		ATNState p = config.state;
 		for (int i=0; i<p.getNumberOfTransitions(); i++) {
 			Transition t = p.transition(i);
-			LexerATNConfig c = getEpsilonTarget(input, config, t, configs, speculative);
+			LexerATNConfig c = getEpsilonTarget(input, config, t, configs, speculative, treatEofAsEpsilon);
 			if ( c!=null ) {
-				currentAltReachedAcceptState = closure(input, c, configs, currentAltReachedAcceptState, speculative);
+				currentAltReachedAcceptState = closure(input, c, configs, currentAltReachedAcceptState, speculative, treatEofAsEpsilon);
 			}
 		}
 
@@ -466,12 +487,13 @@ public class LexerATNSimulator extends ATNSimulator {
 	}
 
 	// side-effect: can alter configs.hasSemanticContext
-	@Nullable
-	protected LexerATNConfig getEpsilonTarget(@NotNull CharStream input,
-										   @NotNull LexerATNConfig config,
-										   @NotNull Transition t,
-										   @NotNull ATNConfigSet configs,
-										   boolean speculative)
+
+	protected LexerATNConfig getEpsilonTarget(CharStream input,
+										   LexerATNConfig config,
+										   Transition t,
+										   ATNConfigSet configs,
+										   boolean speculative,
+										   boolean treatEofAsEpsilon)
 	{
 		LexerATNConfig c = null;
 		switch (t.getSerializationType()) {
@@ -513,13 +535,46 @@ public class LexerATNSimulator extends ATNSimulator {
 					c = new LexerATNConfig(config, t.target);
 				}
 				break;
-			// ignore actions; just exec one per rule upon accept
+
 			case Transition.ACTION:
-				c = new LexerATNConfig(config, t.target, ((ActionTransition)t).actionIndex);
-				break;
+				if (config.context == null || config.context.hasEmptyPath()) {
+					// execute actions anywhere in the start rule for a token.
+					//
+					// TODO: if the entry rule is invoked recursively, some
+					// actions may be executed during the recursive call. The
+					// problem can appear when hasEmptyPath() is true but
+					// isEmpty() is false. In this case, the config needs to be
+					// split into two contexts - one with just the empty path
+					// and another with everything but the empty path.
+					// Unfortunately, the current algorithm does not allow
+					// getEpsilonTarget to return two configurations, so
+					// additional modifications are needed before we can support
+					// the split operation.
+					LexerActionExecutor lexerActionExecutor = LexerActionExecutor.append(config.getLexerActionExecutor(), atn.lexerActions[((ActionTransition)t).actionIndex]);
+					c = new LexerATNConfig(config, t.target, lexerActionExecutor);
+					break;
+				}
+				else {
+					// ignore actions in referenced rules
+					c = new LexerATNConfig(config, t.target);
+					break;
+				}
+
 			case Transition.EPSILON:
 				c = new LexerATNConfig(config, t.target);
 				break;
+
+			case Transition.ATOM:
+			case Transition.RANGE:
+			case Transition.SET:
+				if (treatEofAsEpsilon) {
+					if (t.matches(CharStream.EOF, Character.MIN_VALUE, Character.MAX_VALUE)) {
+						c = new LexerATNConfig(config, t.target);
+						break;
+					}
+				}
+
+				break;
 		}
 
 		return c;
@@ -527,15 +582,15 @@ public class LexerATNSimulator extends ATNSimulator {
 
 	/**
 	 * Evaluate a predicate specified in the lexer.
-	 * <p/>
-	 * If {@code speculative} is {@code true}, this method was called before
+	 *
+	 * <p>If {@code speculative} is {@code true}, this method was called before
 	 * {@link #consume} for the matched character. This method should call
 	 * {@link #consume} before evaluating the predicate to ensure position
 	 * sensitive values, including {@link Lexer#getText}, {@link Lexer#getLine},
 	 * and {@link Lexer#getCharPositionInLine}, properly reflect the current
 	 * lexer state. This method should restore {@code input} and the simulator
 	 * to the original state before returning (i.e. undo the actions made by the
-	 * call to {@link #consume}.
+	 * call to {@link #consume}.</p>
 	 *
 	 * @param input The input stream.
 	 * @param ruleIndex The rule containing the predicate.
@@ -546,7 +601,7 @@ public class LexerATNSimulator extends ATNSimulator {
 	 * @return {@code true} if the specified predicate evaluates to
 	 * {@code true}.
 	 */
-	protected boolean evaluatePredicate(@NotNull CharStream input, int ruleIndex, int predIndex, boolean speculative) {
+	protected boolean evaluatePredicate(CharStream input, int ruleIndex, int predIndex, boolean speculative) {
 		// assume true if no recognizer was provided
 		if (recog == null) {
 			return true;
@@ -572,9 +627,9 @@ public class LexerATNSimulator extends ATNSimulator {
 		}
 	}
 
-	protected void captureSimState(@NotNull SimState settings,
-								   @NotNull CharStream input,
-								   @NotNull DFAState dfaState)
+	protected void captureSimState(SimState settings,
+								   CharStream input,
+								   DFAState dfaState)
 	{
 		settings.index = input.index();
 		settings.line = line;
@@ -582,10 +637,10 @@ public class LexerATNSimulator extends ATNSimulator {
 		settings.dfaState = dfaState;
 	}
 
-	@NotNull
-	protected DFAState addDFAEdge(@NotNull DFAState from,
+
+	protected DFAState addDFAEdge(DFAState from,
 								  int t,
-								  @NotNull ATNConfigSet q)
+								  ATNConfigSet q)
 	{
 		/* leading to this call, ATNConfigSet.hasSemanticContext is used as a
 		 * marker indicating dynamic predicate evaluation makes this edge
@@ -601,7 +656,7 @@ public class LexerATNSimulator extends ATNSimulator {
 		boolean suppressEdge = q.hasSemanticContext;
 		q.hasSemanticContext = false;
 
-		@NotNull
+
 		DFAState to = addDFAState(q);
 
 		if (suppressEdge) {
@@ -612,7 +667,7 @@ public class LexerATNSimulator extends ATNSimulator {
 		return to;
 	}
 
-	protected void addDFAEdge(@NotNull DFAState p, int t, @NotNull DFAState q) {
+	protected void addDFAEdge(DFAState p, int t, DFAState q) {
 		if (t < MIN_DFA_EDGE || t > MAX_DFA_EDGE) {
 			// Only track edges within the DFA bounds
 			return;
@@ -636,8 +691,8 @@ public class LexerATNSimulator extends ATNSimulator {
 		configuration containing an ATN rule stop state. Later, when
 		traversing the DFA, we will know which rule to accept.
 	 */
-	@NotNull
-	protected DFAState addDFAState(@NotNull ATNConfigSet configs) {
+
+	protected DFAState addDFAState(ATNConfigSet configs) {
 		/* the lexer evaluates predicates on-the-fly; by this point configs
 		 * should not contain any configurations with unevaluated predicates.
 		 */
@@ -654,10 +709,8 @@ public class LexerATNSimulator extends ATNSimulator {
 
 		if ( firstConfigWithRuleStopState!=null ) {
 			proposed.isAcceptState = true;
-			proposed.lexerRuleIndex = firstConfigWithRuleStopState.state.ruleIndex;
-			proposed.lexerActionIndex =
-				((LexerATNConfig)firstConfigWithRuleStopState).lexerActionIndex;
-			proposed.prediction = atn.ruleToTokenType[proposed.lexerRuleIndex];
+			proposed.lexerActionExecutor = ((LexerATNConfig)firstConfigWithRuleStopState).getLexerActionExecutor();
+			proposed.prediction = atn.ruleToTokenType[firstConfigWithRuleStopState.state.ruleIndex];
 		}
 
 		DFA dfa = decisionToDFA[mode];
@@ -675,15 +728,15 @@ public class LexerATNSimulator extends ATNSimulator {
 		}
 	}
 
-	@NotNull
+
 	public final DFA getDFA(int mode) {
 		return decisionToDFA[mode];
 	}
 
 	/** Get the text matched so far for the current token.
 	 */
-	@NotNull
-	public String getText(@NotNull CharStream input) {
+
+	public String getText(CharStream input) {
 		// index is first lookahead char, don't include.
 		return input.getText(Interval.of(startIndex, input.index()-1));
 	}
@@ -704,7 +757,7 @@ public class LexerATNSimulator extends ATNSimulator {
 		this.charPositionInLine = charPositionInLine;
 	}
 
-	public void consume(@NotNull CharStream input) {
+	public void consume(CharStream input) {
 		int curChar = input.LA(1);
 		if ( curChar=='\n' ) {
 			line++;
@@ -715,7 +768,7 @@ public class LexerATNSimulator extends ATNSimulator {
 		input.consume();
 	}
 
-	@NotNull
+
 	public String getTokenName(int t) {
 		if ( t==-1 ) return "EOF";
 		//if ( atn.g!=null ) return atn.g.getTokenDisplayName(t);
diff --git a/runtime/Java/src/org/antlr/v4/runtime/atn/LexerAction.java b/runtime/Java/src/org/antlr/v4/runtime/atn/LexerAction.java
new file mode 100644
index 000000000..367cb2461
--- /dev/null
+++ b/runtime/Java/src/org/antlr/v4/runtime/atn/LexerAction.java
@@ -0,0 +1,77 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+
+package org.antlr.v4.runtime.atn;
+
+import org.antlr.v4.runtime.CharStream;
+import org.antlr.v4.runtime.Lexer;
+
+/**
+ * Represents a single action which can be executed following the successful
+ * match of a lexer rule. Lexer actions are used for both embedded action syntax
+ * and ANTLR 4's new lexer command syntax.
+ *
+ * @author Sam Harwell
+ * @since 4.2
+ */
+public interface LexerAction {
+	/**
+	 * Gets the serialization type of the lexer action.
+	 *
+	 * @return The serialization type of the lexer action.
+	 */
+	LexerActionType getActionType();
+
+	/**
+	 * Gets whether the lexer action is position-dependent. Position-dependent
+	 * actions may have different semantics depending on the {@link CharStream}
+	 * index at the time the action is executed.
+	 *
+	 * <p>Many lexer commands, including {@code type}, {@code skip}, and
+	 * {@code more}, do not check the input index during their execution.
+	 * Actions like this are position-independent, and may be stored more
+	 * efficiently as part of the {@link LexerATNConfig#lexerActionExecutor}.</p>
+	 *
+	 * @return {@code true} if the lexer action semantics can be affected by the
+	 * position of the input {@link CharStream} at the time it is executed;
+	 * otherwise, {@code false}.
+	 */
+	boolean isPositionDependent();
+
+	/**
+	 * Execute the lexer action in the context of the specified {@link Lexer}.
+	 *
+	 * <p>For position-dependent actions, the input stream must already be
+	 * positioned correctly prior to calling this method.</p>
+	 *
+	 * @param lexer The lexer instance.
+	 */
+	void execute(Lexer lexer);
+}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/atn/LexerActionExecutor.java b/runtime/Java/src/org/antlr/v4/runtime/atn/LexerActionExecutor.java
new file mode 100644
index 000000000..f6075fd24
--- /dev/null
+++ b/runtime/Java/src/org/antlr/v4/runtime/atn/LexerActionExecutor.java
@@ -0,0 +1,220 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+
+package org.antlr.v4.runtime.atn;
+
+import org.antlr.v4.runtime.CharStream;
+import org.antlr.v4.runtime.IntStream;
+import org.antlr.v4.runtime.Lexer;
+import org.antlr.v4.runtime.dfa.DFA;
+import org.antlr.v4.runtime.misc.MurmurHash;
+
+import java.util.Arrays;
+
+/**
+ * Represents an executor for a sequence of lexer actions which traversed during
+ * the matching operation of a lexer rule (token).
+ *
+ * <p>The executor tracks position information for position-dependent lexer actions
+ * efficiently, ensuring that actions appearing only at the end of the rule do
+ * not cause bloating of the {@link DFA} created for the lexer.</p>
+ *
+ * @author Sam Harwell
+ * @since 4.2
+ */
+public class LexerActionExecutor {
+
+	private final LexerAction[] lexerActions;
+	/**
+	 * Caches the result of {@link #hashCode} since the hash code is an element
+	 * of the performance-critical {@link LexerATNConfig#hashCode} operation.
+	 */
+	private final int hashCode;
+
+	/**
+	 * Constructs an executor for a sequence of {@link LexerAction} actions.
+	 * @param lexerActions The lexer actions to execute.
+	 */
+	public LexerActionExecutor(LexerAction[] lexerActions) {
+		this.lexerActions = lexerActions;
+
+		int hash = MurmurHash.initialize();
+		for (LexerAction lexerAction : lexerActions) {
+			hash = MurmurHash.update(hash, lexerAction);
+		}
+
+		this.hashCode = MurmurHash.finish(hash, lexerActions.length);
+	}
+
+	/**
+	 * Creates a {@link LexerActionExecutor} which executes the actions for
+	 * the input {@code lexerActionExecutor} followed by a specified
+	 * {@code lexerAction}.
+	 *
+	 * @param lexerActionExecutor The executor for actions already traversed by
+	 * the lexer while matching a token within a particular
+	 * {@link LexerATNConfig}. If this is {@code null}, the method behaves as
+	 * though it were an empty executor.
+	 * @param lexerAction The lexer action to execute after the actions
+	 * specified in {@code lexerActionExecutor}.
+	 *
+	 * @return A {@link LexerActionExecutor} for executing the combine actions
+	 * of {@code lexerActionExecutor} and {@code lexerAction}.
+	 */
+	public static LexerActionExecutor append(LexerActionExecutor lexerActionExecutor, LexerAction lexerAction) {
+		if (lexerActionExecutor == null) {
+			return new LexerActionExecutor(new LexerAction[] { lexerAction });
+		}
+
+		LexerAction[] lexerActions = Arrays.copyOf(lexerActionExecutor.lexerActions, lexerActionExecutor.lexerActions.length + 1);
+		lexerActions[lexerActions.length - 1] = lexerAction;
+		return new LexerActionExecutor(lexerActions);
+	}
+
+	/**
+	 * Creates a {@link LexerActionExecutor} which encodes the current offset
+	 * for position-dependent lexer actions.
+	 *
+	 * <p>Normally, when the executor encounters lexer actions where
+	 * {@link LexerAction#isPositionDependent} returns {@code true}, it calls
+	 * {@link IntStream#seek} on the input {@link CharStream} to set the input
+	 * position to the <em>end</em> of the current token. This behavior provides
+	 * for efficient DFA representation of lexer actions which appear at the end
+	 * of a lexer rule, even when the lexer rule matches a variable number of
+	 * characters.</p>
+	 *
+	 * <p>Prior to traversing a match transition in the ATN, the current offset
+	 * from the token start index is assigned to all position-dependent lexer
+	 * actions which have not already been assigned a fixed offset. By storing
+	 * the offsets relative to the token start index, the DFA representation of
+	 * lexer actions which appear in the middle of tokens remains efficient due
+	 * to sharing among tokens of the same length, regardless of their absolute
+	 * position in the input stream.</p>
+	 *
+	 * <p>If the current executor already has offsets assigned to all
+	 * position-dependent lexer actions, the method returns {@code this}.</p>
+	 *
+	 * @param offset The current offset to assign to all position-dependent
+	 * lexer actions which do not already have offsets assigned.
+	 *
+	 * @return A {@link LexerActionExecutor} which stores input stream offsets
+	 * for all position-dependent lexer actions.
+	 */
+	public LexerActionExecutor fixOffsetBeforeMatch(int offset) {
+		LexerAction[] updatedLexerActions = null;
+		for (int i = 0; i < lexerActions.length; i++) {
+			if (lexerActions[i].isPositionDependent() && !(lexerActions[i] instanceof LexerIndexedCustomAction)) {
+				if (updatedLexerActions == null) {
+					updatedLexerActions = lexerActions.clone();
+				}
+
+				updatedLexerActions[i] = new LexerIndexedCustomAction(offset, lexerActions[i]);
+			}
+		}
+
+		if (updatedLexerActions == null) {
+			return this;
+		}
+
+		return new LexerActionExecutor(updatedLexerActions);
+	}
+
+	/**
+	 * Gets the lexer actions to be executed by this executor.
+	 * @return The lexer actions to be executed by this executor.
+	 */
+	public LexerAction[] getLexerActions() {
+		return lexerActions;
+	}
+
+	/**
+	 * Execute the actions encapsulated by this executor within the context of a
+	 * particular {@link Lexer}.
+	 *
+	 * <p>This method calls {@link IntStream#seek} to set the position of the
+	 * {@code input} {@link CharStream} prior to calling
+	 * {@link LexerAction#execute} on a position-dependent action. Before the
+	 * method returns, the input position will be restored to the same position
+	 * it was in when the method was invoked.</p>
+	 *
+	 * @param lexer The lexer instance.
+	 * @param input The input stream which is the source for the current token.
+	 * When this method is called, the current {@link IntStream#index} for
+	 * {@code input} should be the start of the following token, i.e. 1
+	 * character past the end of the current token.
+	 * @param startIndex The token start index. This value may be passed to
+	 * {@link IntStream#seek} to set the {@code input} position to the beginning
+	 * of the token.
+	 */
+	public void execute(Lexer lexer, CharStream input, int startIndex) {
+		boolean requiresSeek = false;
+		int stopIndex = input.index();
+		try {
+			for (LexerAction lexerAction : lexerActions) {
+				if (lexerAction instanceof LexerIndexedCustomAction) {
+					int offset = ((LexerIndexedCustomAction)lexerAction).getOffset();
+					input.seek(startIndex + offset);
+					lexerAction = ((LexerIndexedCustomAction)lexerAction).getAction();
+					requiresSeek = (startIndex + offset) != stopIndex;
+				}
+				else if (lexerAction.isPositionDependent()) {
+					input.seek(stopIndex);
+					requiresSeek = false;
+				}
+
+				lexerAction.execute(lexer);
+			}
+		}
+		finally {
+			if (requiresSeek) {
+				input.seek(stopIndex);
+			}
+		}
+	}
+
+	@Override
+	public int hashCode() {
+		return this.hashCode;
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (obj == this) {
+			return true;
+		}
+		else if (!(obj instanceof LexerActionExecutor)) {
+			return false;
+		}
+
+		LexerActionExecutor other = (LexerActionExecutor)obj;
+		return hashCode == other.hashCode
+			&& Arrays.equals(lexerActions, other.lexerActions);
+	}
+}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/atn/LexerActionType.java b/runtime/Java/src/org/antlr/v4/runtime/atn/LexerActionType.java
new file mode 100644
index 000000000..1d9b9f5dd
--- /dev/null
+++ b/runtime/Java/src/org/antlr/v4/runtime/atn/LexerActionType.java
@@ -0,0 +1,72 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+
+package org.antlr.v4.runtime.atn;
+
+/**
+ * Represents the serialization type of a {@link LexerAction}.
+ *
+ * @author Sam Harwell
+ * @since 4.2
+ */
+public enum LexerActionType {
+	/**
+	 * The type of a {@link LexerChannelAction} action.
+	 */
+	CHANNEL,
+	/**
+	 * The type of a {@link LexerCustomAction} action.
+	 */
+	CUSTOM,
+	/**
+	 * The type of a {@link LexerModeAction} action.
+	 */
+	MODE,
+	/**
+	 * The type of a {@link LexerMoreAction} action.
+	 */
+	MORE,
+	/**
+	 * The type of a {@link LexerPopModeAction} action.
+	 */
+	POP_MODE,
+	/**
+	 * The type of a {@link LexerPushModeAction} action.
+	 */
+	PUSH_MODE,
+	/**
+	 * The type of a {@link LexerSkipAction} action.
+	 */
+	SKIP,
+	/**
+	 * The type of a {@link LexerTypeAction} action.
+	 */
+	TYPE,
+}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/atn/LexerChannelAction.java b/runtime/Java/src/org/antlr/v4/runtime/atn/LexerChannelAction.java
new file mode 100644
index 000000000..5737c7958
--- /dev/null
+++ b/runtime/Java/src/org/antlr/v4/runtime/atn/LexerChannelAction.java
@@ -0,0 +1,117 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+
+package org.antlr.v4.runtime.atn;
+
+import org.antlr.v4.runtime.Lexer;
+import org.antlr.v4.runtime.Token;
+import org.antlr.v4.runtime.misc.MurmurHash;
+
+/**
+ * Implements the {@code channel} lexer action by calling
+ * {@link Lexer#setChannel} with the assigned channel.
+ *
+ * @author Sam Harwell
+ * @since 4.2
+ */
+public final class LexerChannelAction implements LexerAction {
+	private final int channel;
+
+	/**
+	 * Constructs a new {@code channel} action with the specified channel value.
+	 * @param channel The channel value to pass to {@link Lexer#setChannel}.
+	 */
+	public LexerChannelAction(int channel) {
+		this.channel = channel;
+	}
+
+	/**
+	 * Gets the channel to use for the {@link Token} created by the lexer.
+	 *
+	 * @return The channel to use for the {@link Token} created by the lexer.
+	 */
+	public int getChannel() {
+		return channel;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 * @return This method returns {@link LexerActionType#CHANNEL}.
+	 */
+	@Override
+	public LexerActionType getActionType() {
+		return LexerActionType.CHANNEL;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 * @return This method returns {@code false}.
+	 */
+	@Override
+	public boolean isPositionDependent() {
+		return false;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>This action is implemented by calling {@link Lexer#setChannel} with the
+	 * value provided by {@link #getChannel}.</p>
+	 */
+	@Override
+	public void execute(Lexer lexer) {
+		lexer.setChannel(channel);
+	}
+
+	@Override
+	public int hashCode() {
+		int hash = MurmurHash.initialize();
+		hash = MurmurHash.update(hash, getActionType().ordinal());
+		hash = MurmurHash.update(hash, channel);
+		return MurmurHash.finish(hash, 2);
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (obj == this) {
+			return true;
+		}
+		else if (!(obj instanceof LexerChannelAction)) {
+			return false;
+		}
+
+		return channel == ((LexerChannelAction)obj).channel;
+	}
+
+	@Override
+	public String toString() {
+		return String.format("channel(%d)", channel);
+	}
+}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/atn/LexerCustomAction.java b/runtime/Java/src/org/antlr/v4/runtime/atn/LexerCustomAction.java
new file mode 100644
index 000000000..78040e4fc
--- /dev/null
+++ b/runtime/Java/src/org/antlr/v4/runtime/atn/LexerCustomAction.java
@@ -0,0 +1,146 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+
+package org.antlr.v4.runtime.atn;
+
+import org.antlr.v4.runtime.CharStream;
+import org.antlr.v4.runtime.Lexer;
+import org.antlr.v4.runtime.Recognizer;
+import org.antlr.v4.runtime.misc.MurmurHash;
+
+/**
+ * Executes a custom lexer action by calling {@link Recognizer#action} with the
+ * rule and action indexes assigned to the custom action. The implementation of
+ * a custom action is added to the generated code for the lexer in an override
+ * of {@link Recognizer#action} when the grammar is compiled.
+ *
+ * <p>This class may represent embedded actions created with the <code>{...}</code>
+ * syntax in ANTLR 4, as well as actions created for lexer commands where the
+ * command argument could not be evaluated when the grammar was compiled.</p>
+ *
+ * @author Sam Harwell
+ * @since 4.2
+ */
+public final class LexerCustomAction implements LexerAction {
+	private final int ruleIndex;
+	private final int actionIndex;
+
+	/**
+	 * Constructs a custom lexer action with the specified rule and action
+	 * indexes.
+	 *
+	 * @param ruleIndex The rule index to use for calls to
+	 * {@link Recognizer#action}.
+	 * @param actionIndex The action index to use for calls to
+	 * {@link Recognizer#action}.
+	 */
+	public LexerCustomAction(int ruleIndex, int actionIndex) {
+		this.ruleIndex = ruleIndex;
+		this.actionIndex = actionIndex;
+	}
+
+	/**
+	 * Gets the rule index to use for calls to {@link Recognizer#action}.
+	 *
+	 * @return The rule index for the custom action.
+	 */
+	public int getRuleIndex() {
+		return ruleIndex;
+	}
+
+	/**
+	 * Gets the action index to use for calls to {@link Recognizer#action}.
+	 *
+	 * @return The action index for the custom action.
+	 */
+	public int getActionIndex() {
+		return actionIndex;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 *
+	 * @return This method returns {@link LexerActionType#CUSTOM}.
+	 */
+	@Override
+	public LexerActionType getActionType() {
+		return LexerActionType.CUSTOM;
+	}
+
+	/**
+	 * Gets whether the lexer action is position-dependent. Position-dependent
+	 * actions may have different semantics depending on the {@link CharStream}
+	 * index at the time the action is executed.
+	 *
+	 * <p>Custom actions are position-dependent since they may represent a
+	 * user-defined embedded action which makes calls to methods like
+	 * {@link Lexer#getText}.</p>
+	 *
+	 * @return This method returns {@code true}.
+	 */
+	@Override
+	public boolean isPositionDependent() {
+		return true;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>Custom actions are implemented by calling {@link Lexer#action} with the
+	 * appropriate rule and action indexes.</p>
+	 */
+	@Override
+	public void execute(Lexer lexer) {
+		lexer.action(null, ruleIndex, actionIndex);
+	}
+
+	@Override
+	public int hashCode() {
+		int hash = MurmurHash.initialize();
+		hash = MurmurHash.update(hash, getActionType().ordinal());
+		hash = MurmurHash.update(hash, ruleIndex);
+		hash = MurmurHash.update(hash, actionIndex);
+		return MurmurHash.finish(hash, 3);
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (obj == this) {
+			return true;
+		}
+		else if (!(obj instanceof LexerCustomAction)) {
+			return false;
+		}
+
+		LexerCustomAction other = (LexerCustomAction)obj;
+		return ruleIndex == other.ruleIndex
+			&& actionIndex == other.actionIndex;
+	}
+}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/atn/LexerIndexedCustomAction.java b/runtime/Java/src/org/antlr/v4/runtime/atn/LexerIndexedCustomAction.java
new file mode 100644
index 000000000..b4566fa7b
--- /dev/null
+++ b/runtime/Java/src/org/antlr/v4/runtime/atn/LexerIndexedCustomAction.java
@@ -0,0 +1,147 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+
+package org.antlr.v4.runtime.atn;
+
+import org.antlr.v4.runtime.CharStream;
+import org.antlr.v4.runtime.Lexer;
+import org.antlr.v4.runtime.misc.MurmurHash;
+
+/**
+ * This implementation of {@link LexerAction} is used for tracking input offsets
+ * for position-dependent actions within a {@link LexerActionExecutor}.
+ *
+ * <p>This action is not serialized as part of the ATN, and is only required for
+ * position-dependent lexer actions which appear at a location other than the
+ * end of a rule. For more information about DFA optimizations employed for
+ * lexer actions, see {@link LexerActionExecutor#append} and
+ * {@link LexerActionExecutor#fixOffsetBeforeMatch}.</p>
+ *
+ * @author Sam Harwell
+ * @since 4.2
+ */
+public final class LexerIndexedCustomAction implements LexerAction {
+	private final int offset;
+	private final LexerAction action;
+
+	/**
+	 * Constructs a new indexed custom action by associating a character offset
+	 * with a {@link LexerAction}.
+	 *
+	 * <p>Note: This class is only required for lexer actions for which
+	 * {@link LexerAction#isPositionDependent} returns {@code true}.</p>
+	 *
+	 * @param offset The offset into the input {@link CharStream}, relative to
+	 * the token start index, at which the specified lexer action should be
+	 * executed.
+	 * @param action The lexer action to execute at a particular offset in the
+	 * input {@link CharStream}.
+	 */
+	public LexerIndexedCustomAction(int offset, LexerAction action) {
+		this.offset = offset;
+		this.action = action;
+	}
+
+	/**
+	 * Gets the location in the input {@link CharStream} at which the lexer
+	 * action should be executed. The value is interpreted as an offset relative
+	 * to the token start index.
+	 *
+	 * @return The location in the input {@link CharStream} at which the lexer
+	 * action should be executed.
+	 */
+	public int getOffset() {
+		return offset;
+	}
+
+	/**
+	 * Gets the lexer action to execute.
+	 *
+	 * @return A {@link LexerAction} object which executes the lexer action.
+	 */
+	public LexerAction getAction() {
+		return action;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 *
+	 * @return This method returns the result of calling {@link #getActionType}
+	 * on the {@link LexerAction} returned by {@link #getAction}.
+	 */
+	@Override
+	public LexerActionType getActionType() {
+		return action.getActionType();
+	}
+
+	/**
+	 * {@inheritDoc}
+	 * @return This method returns {@code true}.
+	 */
+	@Override
+	public boolean isPositionDependent() {
+		return true;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>This method calls {@link #execute} on the result of {@link #getAction}
+	 * using the provided {@code lexer}.</p>
+	 */
+	@Override
+	public void execute(Lexer lexer) {
+		// assume the input stream position was properly set by the calling code
+		action.execute(lexer);
+	}
+
+	@Override
+	public int hashCode() {
+		int hash = MurmurHash.initialize();
+		hash = MurmurHash.update(hash, offset);
+		hash = MurmurHash.update(hash, action);
+		return MurmurHash.finish(hash, 2);
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (obj == this) {
+			return true;
+		}
+		else if (!(obj instanceof LexerIndexedCustomAction)) {
+			return false;
+		}
+
+		LexerIndexedCustomAction other = (LexerIndexedCustomAction)obj;
+		return offset == other.offset
+			&& action.equals(other.action);
+	}
+
+}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/atn/LexerModeAction.java b/runtime/Java/src/org/antlr/v4/runtime/atn/LexerModeAction.java
new file mode 100644
index 000000000..9b3a43d16
--- /dev/null
+++ b/runtime/Java/src/org/antlr/v4/runtime/atn/LexerModeAction.java
@@ -0,0 +1,116 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+
+package org.antlr.v4.runtime.atn;
+
+import org.antlr.v4.runtime.Lexer;
+import org.antlr.v4.runtime.misc.MurmurHash;
+
+/**
+ * Implements the {@code mode} lexer action by calling {@link Lexer#mode} with
+ * the assigned mode.
+ *
+ * @author Sam Harwell
+ * @since 4.2
+ */
+public final class LexerModeAction implements LexerAction {
+	private final int mode;
+
+	/**
+	 * Constructs a new {@code mode} action with the specified mode value.
+	 * @param mode The mode value to pass to {@link Lexer#mode}.
+	 */
+	public LexerModeAction(int mode) {
+		this.mode = mode;
+	}
+
+	/**
+	 * Get the lexer mode this action should transition the lexer to.
+	 *
+	 * @return The lexer mode for this {@code mode} command.
+	 */
+	public int getMode() {
+		return mode;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 * @return This method returns {@link LexerActionType#MODE}.
+	 */
+	@Override
+	public LexerActionType getActionType() {
+		return LexerActionType.MODE;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 * @return This method returns {@code false}.
+	 */
+	@Override
+	public boolean isPositionDependent() {
+		return false;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>This action is implemented by calling {@link Lexer#mode} with the
+	 * value provided by {@link #getMode}.</p>
+	 */
+	@Override
+	public void execute(Lexer lexer) {
+		lexer.mode(mode);
+	}
+
+	@Override
+	public int hashCode() {
+		int hash = MurmurHash.initialize();
+		hash = MurmurHash.update(hash, getActionType().ordinal());
+		hash = MurmurHash.update(hash, mode);
+		return MurmurHash.finish(hash, 2);
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (obj == this) {
+			return true;
+		}
+		else if (!(obj instanceof LexerModeAction)) {
+			return false;
+		}
+
+		return mode == ((LexerModeAction)obj).mode;
+	}
+
+	@Override
+	public String toString() {
+		return String.format("mode(%d)", mode);
+	}
+}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/atn/LexerMoreAction.java b/runtime/Java/src/org/antlr/v4/runtime/atn/LexerMoreAction.java
new file mode 100644
index 000000000..ed98044fa
--- /dev/null
+++ b/runtime/Java/src/org/antlr/v4/runtime/atn/LexerMoreAction.java
@@ -0,0 +1,102 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+
+package org.antlr.v4.runtime.atn;
+
+import org.antlr.v4.runtime.Lexer;
+import org.antlr.v4.runtime.misc.MurmurHash;
+
+/**
+ * Implements the {@code more} lexer action by calling {@link Lexer#more}.
+ *
+ * <p>The {@code more} command does not have any parameters, so this action is
+ * implemented as a singleton instance exposed by {@link #INSTANCE}.</p>
+ *
+ * @author Sam Harwell
+ * @since 4.2
+ */
+public final class LexerMoreAction implements LexerAction {
+	/**
+	 * Provides a singleton instance of this parameterless lexer action.
+	 */
+	public static final LexerMoreAction INSTANCE = new LexerMoreAction();
+
+	/**
+	 * Constructs the singleton instance of the lexer {@code more} command.
+	 */
+	private LexerMoreAction() {
+	}
+
+	/**
+	 * {@inheritDoc}
+	 * @return This method returns {@link LexerActionType#MORE}.
+	 */
+	@Override
+	public LexerActionType getActionType() {
+		return LexerActionType.MORE;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 * @return This method returns {@code false}.
+	 */
+	@Override
+	public boolean isPositionDependent() {
+		return false;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>This action is implemented by calling {@link Lexer#more}.</p>
+	 */
+	@Override
+	public void execute(Lexer lexer) {
+		lexer.more();
+	}
+
+	@Override
+	public int hashCode() {
+		int hash = MurmurHash.initialize();
+		hash = MurmurHash.update(hash, getActionType().ordinal());
+		return MurmurHash.finish(hash, 1);
+	}
+
+	@Override
+	@SuppressWarnings("EqualsWhichDoesntCheckParameterClass")
+	public boolean equals(Object obj) {
+		return obj == this;
+	}
+
+	@Override
+	public String toString() {
+		return "more";
+	}
+}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/atn/LexerPopModeAction.java b/runtime/Java/src/org/antlr/v4/runtime/atn/LexerPopModeAction.java
new file mode 100644
index 000000000..27c29c546
--- /dev/null
+++ b/runtime/Java/src/org/antlr/v4/runtime/atn/LexerPopModeAction.java
@@ -0,0 +1,102 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+
+package org.antlr.v4.runtime.atn;
+
+import org.antlr.v4.runtime.Lexer;
+import org.antlr.v4.runtime.misc.MurmurHash;
+
+/**
+ * Implements the {@code popMode} lexer action by calling {@link Lexer#popMode}.
+ *
+ * <p>The {@code popMode} command does not have any parameters, so this action is
+ * implemented as a singleton instance exposed by {@link #INSTANCE}.</p>
+ *
+ * @author Sam Harwell
+ * @since 4.2
+ */
+public final class LexerPopModeAction implements LexerAction {
+	/**
+	 * Provides a singleton instance of this parameterless lexer action.
+	 */
+	public static final LexerPopModeAction INSTANCE = new LexerPopModeAction();
+
+	/**
+	 * Constructs the singleton instance of the lexer {@code popMode} command.
+	 */
+	private LexerPopModeAction() {
+	}
+
+	/**
+	 * {@inheritDoc}
+	 * @return This method returns {@link LexerActionType#POP_MODE}.
+	 */
+	@Override
+	public LexerActionType getActionType() {
+		return LexerActionType.POP_MODE;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 * @return This method returns {@code false}.
+	 */
+	@Override
+	public boolean isPositionDependent() {
+		return false;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>This action is implemented by calling {@link Lexer#popMode}.</p>
+	 */
+	@Override
+	public void execute(Lexer lexer) {
+		lexer.popMode();
+	}
+
+	@Override
+	public int hashCode() {
+		int hash = MurmurHash.initialize();
+		hash = MurmurHash.update(hash, getActionType().ordinal());
+		return MurmurHash.finish(hash, 1);
+	}
+
+	@Override
+	@SuppressWarnings("EqualsWhichDoesntCheckParameterClass")
+	public boolean equals(Object obj) {
+		return obj == this;
+	}
+
+	@Override
+	public String toString() {
+		return "popMode";
+	}
+}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/atn/LexerPushModeAction.java b/runtime/Java/src/org/antlr/v4/runtime/atn/LexerPushModeAction.java
new file mode 100644
index 000000000..70ebc9b8d
--- /dev/null
+++ b/runtime/Java/src/org/antlr/v4/runtime/atn/LexerPushModeAction.java
@@ -0,0 +1,116 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+
+package org.antlr.v4.runtime.atn;
+
+import org.antlr.v4.runtime.Lexer;
+import org.antlr.v4.runtime.misc.MurmurHash;
+
+/**
+ * Implements the {@code pushMode} lexer action by calling
+ * {@link Lexer#pushMode} with the assigned mode.
+ *
+ * @author Sam Harwell
+ * @since 4.2
+ */
+public final class LexerPushModeAction implements LexerAction {
+	private final int mode;
+
+	/**
+	 * Constructs a new {@code pushMode} action with the specified mode value.
+	 * @param mode The mode value to pass to {@link Lexer#pushMode}.
+	 */
+	public LexerPushModeAction(int mode) {
+		this.mode = mode;
+	}
+
+	/**
+	 * Get the lexer mode this action should transition the lexer to.
+	 *
+	 * @return The lexer mode for this {@code pushMode} command.
+	 */
+	public int getMode() {
+		return mode;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 * @return This method returns {@link LexerActionType#PUSH_MODE}.
+	 */
+	@Override
+	public LexerActionType getActionType() {
+		return LexerActionType.PUSH_MODE;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 * @return This method returns {@code false}.
+	 */
+	@Override
+	public boolean isPositionDependent() {
+		return false;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>This action is implemented by calling {@link Lexer#pushMode} with the
+	 * value provided by {@link #getMode}.</p>
+	 */
+	@Override
+	public void execute(Lexer lexer) {
+		lexer.pushMode(mode);
+	}
+
+	@Override
+	public int hashCode() {
+		int hash = MurmurHash.initialize();
+		hash = MurmurHash.update(hash, getActionType().ordinal());
+		hash = MurmurHash.update(hash, mode);
+		return MurmurHash.finish(hash, 2);
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (obj == this) {
+			return true;
+		}
+		else if (!(obj instanceof LexerPushModeAction)) {
+			return false;
+		}
+
+		return mode == ((LexerPushModeAction)obj).mode;
+	}
+
+	@Override
+	public String toString() {
+		return String.format("pushMode(%d)", mode);
+	}
+}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/atn/LexerSkipAction.java b/runtime/Java/src/org/antlr/v4/runtime/atn/LexerSkipAction.java
new file mode 100644
index 000000000..d0a166256
--- /dev/null
+++ b/runtime/Java/src/org/antlr/v4/runtime/atn/LexerSkipAction.java
@@ -0,0 +1,102 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+
+package org.antlr.v4.runtime.atn;
+
+import org.antlr.v4.runtime.Lexer;
+import org.antlr.v4.runtime.misc.MurmurHash;
+
+/**
+ * Implements the {@code skip} lexer action by calling {@link Lexer#skip}.
+ *
+ * <p>The {@code skip} command does not have any parameters, so this action is
+ * implemented as a singleton instance exposed by {@link #INSTANCE}.</p>
+ *
+ * @author Sam Harwell
+ * @since 4.2
+ */
+public final class LexerSkipAction implements LexerAction {
+	/**
+	 * Provides a singleton instance of this parameterless lexer action.
+	 */
+	public static final LexerSkipAction INSTANCE = new LexerSkipAction();
+
+	/**
+	 * Constructs the singleton instance of the lexer {@code skip} command.
+	 */
+	private LexerSkipAction() {
+	}
+
+	/**
+	 * {@inheritDoc}
+	 * @return This method returns {@link LexerActionType#SKIP}.
+	 */
+	@Override
+	public LexerActionType getActionType() {
+		return LexerActionType.SKIP;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 * @return This method returns {@code false}.
+	 */
+	@Override
+	public boolean isPositionDependent() {
+		return false;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>This action is implemented by calling {@link Lexer#skip}.</p>
+	 */
+	@Override
+	public void execute(Lexer lexer) {
+		lexer.skip();
+	}
+
+	@Override
+	public int hashCode() {
+		int hash = MurmurHash.initialize();
+		hash = MurmurHash.update(hash, getActionType().ordinal());
+		return MurmurHash.finish(hash, 1);
+	}
+
+	@Override
+	@SuppressWarnings("EqualsWhichDoesntCheckParameterClass")
+	public boolean equals(Object obj) {
+		return obj == this;
+	}
+
+	@Override
+	public String toString() {
+		return "skip";
+	}
+}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/atn/LexerTypeAction.java b/runtime/Java/src/org/antlr/v4/runtime/atn/LexerTypeAction.java
new file mode 100644
index 000000000..e5fcf07c1
--- /dev/null
+++ b/runtime/Java/src/org/antlr/v4/runtime/atn/LexerTypeAction.java
@@ -0,0 +1,115 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+
+package org.antlr.v4.runtime.atn;
+
+import org.antlr.v4.runtime.Lexer;
+import org.antlr.v4.runtime.misc.MurmurHash;
+
+/**
+ * Implements the {@code type} lexer action by calling {@link Lexer#setType}
+ * with the assigned type.
+ *
+ * @author Sam Harwell
+ * @since 4.2
+ */
+public class LexerTypeAction implements LexerAction {
+	private final int type;
+
+	/**
+	 * Constructs a new {@code type} action with the specified token type value.
+	 * @param type The type to assign to the token using {@link Lexer#setType}.
+	 */
+	public LexerTypeAction(int type) {
+		this.type = type;
+	}
+
+	/**
+	 * Gets the type to assign to a token created by the lexer.
+	 * @return The type to assign to a token created by the lexer.
+	 */
+	public int getType() {
+		return type;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 * @return This method returns {@link LexerActionType#TYPE}.
+	 */
+	@Override
+	public LexerActionType getActionType() {
+		return LexerActionType.TYPE;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 * @return This method returns {@code false}.
+	 */
+	@Override
+	public boolean isPositionDependent() {
+		return false;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>This action is implemented by calling {@link Lexer#setType} with the
+	 * value provided by {@link #getType}.</p>
+	 */
+	@Override
+	public void execute(Lexer lexer) {
+		lexer.setType(type);
+	}
+
+	@Override
+	public int hashCode() {
+		int hash = MurmurHash.initialize();
+		hash = MurmurHash.update(hash, getActionType().ordinal());
+		hash = MurmurHash.update(hash, type);
+		return MurmurHash.finish(hash, 2);
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (obj == this) {
+			return true;
+		}
+		else if (!(obj instanceof LexerTypeAction)) {
+			return false;
+		}
+
+		return type == ((LexerTypeAction)obj).type;
+	}
+
+	@Override
+	public String toString() {
+		return String.format("type(%d)", type);
+	}
+}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/atn/LookaheadEventInfo.java b/runtime/Java/src/org/antlr/v4/runtime/atn/LookaheadEventInfo.java
new file mode 100644
index 000000000..19a4059d0
--- /dev/null
+++ b/runtime/Java/src/org/antlr/v4/runtime/atn/LookaheadEventInfo.java
@@ -0,0 +1,73 @@
+/*
+ * [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.
+ */
+
+package org.antlr.v4.runtime.atn;
+
+import org.antlr.v4.runtime.TokenStream;
+
+/**
+ * This class represents profiling event information for tracking the lookahead
+ * depth required in order to make a prediction.
+ *
+ * @since 4.3
+ */
+public class LookaheadEventInfo extends DecisionEventInfo {
+	/** The alternative chosen by adaptivePredict(), not necessarily
+	 *  the outermost alt shown for a rule; left-recursive rules have
+	 *  user-level alts that differ from the rewritten rule with a (...) block
+	 *  and a (..)* loop.
+	 */
+	public int predictedAlt;
+
+	/**
+	 * Constructs a new instance of the {@link LookaheadEventInfo} class with
+	 * the specified detailed lookahead information.
+	 *
+	 * @param decision The decision number
+	 * @param configs The final configuration set containing the necessary
+	 * information to determine the result of a prediction, or {@code null} if
+	 * the final configuration set is not available
+	 * @param input The input token stream
+	 * @param startIndex The start index for the current prediction
+	 * @param stopIndex The index at which the prediction was finally made
+	 * @param fullCtx {@code true} if the current lookahead is part of an LL
+	 * prediction; otherwise, {@code false} if the current lookahead is part of
+	 * an SLL prediction
+	 */
+	public LookaheadEventInfo(int decision,
+							  ATNConfigSet configs,
+							  int predictedAlt,
+							  TokenStream input, int startIndex, int stopIndex,
+							  boolean fullCtx)
+	{
+		super(decision, configs, input, startIndex, stopIndex, fullCtx);
+		this.predictedAlt = predictedAlt;
+	}
+}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/atn/NotSetTransition.java b/runtime/Java/src/org/antlr/v4/runtime/atn/NotSetTransition.java
index b50c6d909..07b82174b 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/atn/NotSetTransition.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/atn/NotSetTransition.java
@@ -31,11 +31,9 @@
 package org.antlr.v4.runtime.atn;
 
 import org.antlr.v4.runtime.misc.IntervalSet;
-import org.antlr.v4.runtime.misc.NotNull;
-import org.antlr.v4.runtime.misc.Nullable;
 
 public final class NotSetTransition extends SetTransition {
-	public NotSetTransition(@NotNull ATNState target, @Nullable IntervalSet set) {
+	public NotSetTransition(ATNState target, IntervalSet set) {
 		super(target, set);
 	}
 
diff --git a/runtime/Java/src/org/antlr/v4/runtime/atn/ParseInfo.java b/runtime/Java/src/org/antlr/v4/runtime/atn/ParseInfo.java
new file mode 100644
index 000000000..55457496c
--- /dev/null
+++ b/runtime/Java/src/org/antlr/v4/runtime/atn/ParseInfo.java
@@ -0,0 +1,187 @@
+/*
+ * [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.
+ */
+
+package org.antlr.v4.runtime.atn;
+
+import org.antlr.v4.runtime.dfa.DFA;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * This class provides access to specific and aggregate statistics gathered
+ * during profiling of a parser.
+ *
+ * @since 4.3
+ */
+public class ParseInfo {
+	protected final ProfilingATNSimulator atnSimulator;
+
+	public ParseInfo(ProfilingATNSimulator atnSimulator) {
+		this.atnSimulator = atnSimulator;
+	}
+
+	/**
+	 * Gets an array of {@link DecisionInfo} instances containing the profiling
+	 * information gathered for each decision in the ATN.
+	 *
+	 * @return An array of {@link DecisionInfo} instances, indexed by decision
+	 * number.
+	 */
+	public DecisionInfo[] getDecisionInfo() {
+		return atnSimulator.getDecisionInfo();
+	}
+
+	/**
+	 * Gets the decision numbers for decisions that required one or more
+	 * full-context predictions during parsing. These are decisions for which
+	 * {@link DecisionInfo#LL_Fallback} is non-zero.
+	 *
+	 * @return A list of decision numbers which required one or more
+	 * full-context predictions during parsing.
+	 */
+	public List<Integer> getLLDecisions() {
+		DecisionInfo[] decisions = atnSimulator.getDecisionInfo();
+		List<Integer> LL = new ArrayList<Integer>();
+		for (int i=0; i<decisions.length; i++) {
+			long fallBack = decisions[i].LL_Fallback;
+			if ( fallBack>0 ) LL.add(i);
+		}
+		return LL;
+	}
+
+	/**
+	 * Gets the total time spent during prediction across all decisions made
+	 * during parsing. This value is the sum of
+	 * {@link DecisionInfo#timeInPrediction} for all decisions.
+	 */
+	public long getTotalTimeInPrediction() {
+		DecisionInfo[] decisions = atnSimulator.getDecisionInfo();
+		long t = 0;
+		for (int i=0; i<decisions.length; i++) {
+			t += decisions[i].timeInPrediction;
+		}
+		return t;
+	}
+
+	/**
+	 * Gets the total number of SLL lookahead operations across all decisions
+	 * made during parsing. This value is the sum of
+	 * {@link DecisionInfo#SLL_TotalLook} for all decisions.
+	 */
+	public long getTotalSLLLookaheadOps() {
+		DecisionInfo[] decisions = atnSimulator.getDecisionInfo();
+		long k = 0;
+		for (int i = 0; i < decisions.length; i++) {
+			k += decisions[i].SLL_TotalLook;
+		}
+		return k;
+	}
+
+	/**
+	 * Gets the total number of LL lookahead operations across all decisions
+	 * made during parsing. This value is the sum of
+	 * {@link DecisionInfo#LL_TotalLook} for all decisions.
+	 */
+	public long getTotalLLLookaheadOps() {
+		DecisionInfo[] decisions = atnSimulator.getDecisionInfo();
+		long k = 0;
+		for (int i = 0; i < decisions.length; i++) {
+			k += decisions[i].LL_TotalLook;
+		}
+		return k;
+	}
+
+	/**
+	 * Gets the total number of ATN lookahead operations for SLL prediction
+	 * across all decisions made during parsing.
+	 */
+	public long getTotalSLLATNLookaheadOps() {
+		DecisionInfo[] decisions = atnSimulator.getDecisionInfo();
+		long k = 0;
+		for (int i = 0; i < decisions.length; i++) {
+			k += decisions[i].SLL_ATNTransitions;
+		}
+		return k;
+	}
+
+	/**
+	 * Gets the total number of ATN lookahead operations for LL prediction
+	 * across all decisions made during parsing.
+	 */
+	public long getTotalLLATNLookaheadOps() {
+		DecisionInfo[] decisions = atnSimulator.getDecisionInfo();
+		long k = 0;
+		for (int i = 0; i < decisions.length; i++) {
+			k += decisions[i].LL_ATNTransitions;
+		}
+		return k;
+	}
+
+	/**
+	 * Gets the total number of ATN lookahead operations for SLL and LL
+	 * prediction across all decisions made during parsing.
+	 *
+	 * <p>
+	 * This value is the sum of {@link #getTotalSLLATNLookaheadOps} and
+	 * {@link #getTotalLLATNLookaheadOps}.</p>
+	 */
+	public long getTotalATNLookaheadOps() {
+		DecisionInfo[] decisions = atnSimulator.getDecisionInfo();
+		long k = 0;
+		for (int i = 0; i < decisions.length; i++) {
+			k += decisions[i].SLL_ATNTransitions;
+			k += decisions[i].LL_ATNTransitions;
+		}
+		return k;
+	}
+
+	/**
+	 * Gets the total number of DFA states stored in the DFA cache for all
+	 * decisions in the ATN.
+	 */
+	public int getDFASize() {
+		int n = 0;
+		DFA[] decisionToDFA = atnSimulator.decisionToDFA;
+		for (int i = 0; i < decisionToDFA.length; i++) {
+			n += getDFASize(i);
+		}
+		return n;
+	}
+
+	/**
+	 * Gets the total number of DFA states stored in the DFA cache for a
+	 * particular decision.
+	 */
+	public int getDFASize(int decision) {
+		DFA decisionToDFA = atnSimulator.decisionToDFA[decision];
+		return decisionToDFA.states.size();
+	}
+}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/atn/ParserATNSimulator.java b/runtime/Java/src/org/antlr/v4/runtime/atn/ParserATNSimulator.java
index 1ef4b4143..15f71ec58 100755
--- a/runtime/Java/src/org/antlr/v4/runtime/atn/ParserATNSimulator.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/atn/ParserATNSimulator.java
@@ -30,7 +30,8 @@
 
 package org.antlr.v4.runtime.atn;
 
-import org.antlr.v4.runtime.CommonTokenStream;
+import org.antlr.v4.runtime.BailErrorStrategy;
+import org.antlr.v4.runtime.FailedPredicateException;
 import org.antlr.v4.runtime.IntStream;
 import org.antlr.v4.runtime.NoViableAltException;
 import org.antlr.v4.runtime.Parser;
@@ -38,241 +39,272 @@ import org.antlr.v4.runtime.ParserRuleContext;
 import org.antlr.v4.runtime.RuleContext;
 import org.antlr.v4.runtime.Token;
 import org.antlr.v4.runtime.TokenStream;
+import org.antlr.v4.runtime.Vocabulary;
+import org.antlr.v4.runtime.VocabularyImpl;
 import org.antlr.v4.runtime.dfa.DFA;
 import org.antlr.v4.runtime.dfa.DFAState;
 import org.antlr.v4.runtime.misc.DoubleKeyMap;
 import org.antlr.v4.runtime.misc.Interval;
 import org.antlr.v4.runtime.misc.IntervalSet;
-import org.antlr.v4.runtime.misc.NotNull;
-import org.antlr.v4.runtime.misc.Nullable;
+import org.antlr.v4.runtime.misc.Pair;
 
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.BitSet;
 import java.util.Collection;
+import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 
 /**
- The embodiment of the adaptive LL(*), ALL(*), parsing strategy.
-
- The basic complexity of the adaptive strategy makes it harder to
- understand. We begin with ATN simulation to build paths in a
- DFA. Subsequent prediction requests go through the DFA first. If
- they reach a state without an edge for the current symbol, the
- algorithm fails over to the ATN simulation to complete the DFA
- path for the current input (until it finds a conflict state or
- uniquely predicting state).
-
- All of that is done without using the outer context because we
- want to create a DFA that is not dependent upon the rule
- invocation stack when we do a prediction.  One DFA works in all
- contexts. We avoid using context not necessarily because it's
- slower, although it can be, but because of the DFA caching
- problem.  The closure routine only considers the rule invocation
- stack created during prediction beginning in the decision rule.  For
- example, if prediction occurs without invoking another rule's
- ATN, there are no context stacks in the configurations.
- When lack of context leads to a conflict, we don't know if it's
- an ambiguity or a weakness in the strong LL(*) parsing strategy
- (versus full LL(*)).
-
- When SLL yields a configuration set with conflict, we rewind the
- input and retry the ATN simulation, this time using
- full outer context without adding to the DFA. Configuration context
- stacks will be the full invocation stacks from the start rule. If
- we get a conflict using full context, then we can definitively
- say we have a true ambiguity for that input sequence. If we don't
- get a conflict, it implies that the decision is sensitive to the
- outer context. (It is not context-sensitive in the sense of
- context-sensitive grammars.)
-
- The next time we reach this DFA state with an SLL conflict, through
- DFA simulation, we will again retry the ATN simulation using full
- context mode. This is slow because we can't save the results and have
- to "interpret" the ATN each time we get that input.
-
- CACHING FULL CONTEXT PREDICTIONS
-
- We could cache results from full context to predicted
- alternative easily and that saves a lot of time but doesn't work
- in presence of predicates. The set of visible predicates from
- the ATN start state changes depending on the context, because
- closure can fall off the end of a rule. I tried to cache
- tuples (stack context, semantic context, predicted alt) but it
- was slower than interpreting and much more complicated. Also
- required a huge amount of memory. The goal is not to create the
- world's fastest parser anyway. I'd like to keep this algorithm
- simple. By launching multiple threads, we can improve the speed
- of parsing across a large number of files.
-
- There is no strict ordering between the amount of input used by
- SLL vs LL, which makes it really hard to build a cache for full
- context. Let's say that we have input A B C that leads to an SLL
- conflict with full context X.  That implies that using X we
- might only use A B but we could also use A B C D to resolve
- conflict.  Input A B C D could predict alternative 1 in one
- position in the input and A B C E could predict alternative 2 in
- another position in input.  The conflicting SLL configurations
- could still be non-unique in the full context prediction, which
- would lead us to requiring more input than the original A B C.	To
- make a	prediction cache work, we have to track	the exact input	used
- during the previous prediction. That amounts to a cache that maps X
- to a specific DFA for that context.
-
- Something should be done for left-recursive expression predictions.
- They are likely LL(1) + pred eval. Easier to do the whole SLL unless
- error and retry with full LL thing Sam does.
-
- AVOIDING FULL CONTEXT PREDICTION
-
- We avoid doing full context retry when the outer context is empty,
- we did not dip into the outer context by falling off the end of the
- decision state rule, or when we force SLL mode.
-
- As an example of the not dip into outer context case, consider
- as super constructor calls versus function calls. One grammar
- might look like this:
-
- ctorBody : '{' superCall? stat* '}' ;
-
- Or, you might see something like
-
- stat : superCall ';' | expression ';' | ... ;
-
- In both cases I believe that no closure operations will dip into the
- outer context. In the first case ctorBody in the worst case will stop
- at the '}'. In the 2nd case it should stop at the ';'. Both cases
- should stay within the entry rule and not dip into the outer context.
-
- PREDICATES
-
- Predicates are always evaluated if present in either SLL or LL both.
- SLL and LL simulation deals with predicates differently. SLL collects
- predicates as it performs closure operations like ANTLR v3 did. It
- delays predicate evaluation until it reaches and accept state. This
- allows us to cache the SLL ATN simulation whereas, if we had evaluated
- predicates on-the-fly during closure, the DFA state configuration sets
- would be different and we couldn't build up a suitable DFA.
-
- When building a DFA accept state during ATN simulation, we evaluate
- any predicates and return the sole semantically valid alternative. If
- there is more than 1 alternative, we report an ambiguity. If there are
- 0 alternatives, we throw an exception. Alternatives without predicates
- act like they have true predicates. The simple way to think about it
- is to strip away all alternatives with false predicates and choose the
- minimum alternative that remains.
-
- When we start in the DFA and reach an accept state that's predicated,
- we test those and return the minimum semantically viable
- alternative. If no alternatives are viable, we throw an exception.
-
- During full LL ATN simulation, closure always evaluates predicates and
- on-the-fly. This is crucial to reducing the configuration set size
- during closure. It hits a landmine when parsing with the Java grammar,
- for example, without this on-the-fly evaluation.
-
- SHARING DFA
-
- All instances of the same parser share the same decision DFAs through
- a static field. Each instance gets its own ATN simulator but they
- share the same decisionToDFA field. They also share a
- PredictionContextCache object that makes sure that all
- PredictionContext objects are shared among the DFA states. This makes
- a big size difference.
-
- THREAD SAFETY
-
- The parser ATN simulator locks on the decisionDFA field when it adds a
- new DFA object to that array. addDFAEdge locks on the DFA for the
- current decision when setting the edges[] field.  addDFAState locks on
- the DFA for the current decision when looking up a DFA state to see if
- it already exists.  We must make sure that all requests to add DFA
- states that are equivalent result in the same shared DFA object. This
- is because lots of threads will be trying to update the DFA at
- once. The addDFAState method also locks inside the DFA lock but this
- time on the shared context cache when it rebuilds the configurations'
- PredictionContext objects using cached subgraphs/nodes. No other
- locking occurs, even during DFA simulation. This is safe as long as we
- can guarantee that all threads referencing s.edge[t] get the same
- physical target DFA state, or none.  Once into the DFA, the DFA
- simulation does not reference the dfa.state map. It follows the
- edges[] field to new targets.  The DFA simulator will either find
- dfa.edges to be null, to be non-null and dfa.edges[t] null, or
- dfa.edges[t] to be non-null. The addDFAEdge method could be racing to
- set the field but in either case the DFA simulator works; if null, and
- requests ATN simulation.  It could also race trying to get
- dfa.edges[t], but either way it will work because it's not doing a
- test and set operation.
-
- Starting with SLL then failing to combined SLL/LL
-
- Sam pointed out that if SLL does not give a syntax error, then there
- is no point in doing full LL, which is slower. We only have to try LL
- if we get a syntax error.  For maximum speed, Sam starts the parser
- with pure SLL mode:
-
-     parser.getInterpreter().setSLL(true);
-
- and with the bail error strategy:
-
-     parser.setErrorHandler(new BailErrorStrategy());
-
- If it does not get a syntax error, then we're done. If it does get a
- syntax error, we need to retry with the combined SLL/LL strategy.
-
- The reason this works is as follows.  If there are no SLL
- conflicts then the grammar is SLL for sure, at least for that
- input set. If there is an SLL conflict, the full LL analysis
- must yield a set of ambiguous alternatives that is no larger
- than the SLL set. If the LL set is a singleton, then the grammar
- is LL but not SLL. If the LL set is the same size as the SLL
- set, the decision is SLL. If the LL set has size > 1, then that
- decision is truly ambiguous on the current input. If the LL set
- is smaller, then the SLL conflict resolution might choose an
- alternative that the full LL would rule out as a possibility
- based upon better context information. If that's the case, then
- the SLL parse will definitely get an error because the full LL
- analysis says it's not viable. If SLL conflict resolution
- chooses an alternative within the LL set, them both SLL and LL
- would choose the same alternative because they both choose the
- minimum of multiple conflicting alternatives.
-
- Let's say we have a set of SLL conflicting alternatives {1, 2, 3} and
- a smaller LL set called s. If s is {2, 3}, then SLL parsing will get
- an error because SLL will pursue alternative 1. If s is {1, 2} or {1,
- 3} then both SLL and LL will choose the same alternative because
- alternative one is the minimum of either set. If s is {2} or {3} then
- SLL will get a syntax error. If s is {1} then SLL will succeed.
-
- Of course, if the input is invalid, then we will get an error for sure
- in both SLL and LL parsing. Erroneous input will therefore require 2
- passes over the input.
-
-*/
+ * The embodiment of the adaptive LL(*), ALL(*), parsing strategy.
+ *
+ * <p>
+ * The basic complexity of the adaptive strategy makes it harder to understand.
+ * We begin with ATN simulation to build paths in a DFA. Subsequent prediction
+ * requests go through the DFA first. If they reach a state without an edge for
+ * the current symbol, the algorithm fails over to the ATN simulation to
+ * complete the DFA path for the current input (until it finds a conflict state
+ * or uniquely predicting state).</p>
+ *
+ * <p>
+ * All of that is done without using the outer context because we want to create
+ * a DFA that is not dependent upon the rule invocation stack when we do a
+ * prediction. One DFA works in all contexts. We avoid using context not
+ * necessarily because it's slower, although it can be, but because of the DFA
+ * caching problem. The closure routine only considers the rule invocation stack
+ * created during prediction beginning in the decision rule. For example, if
+ * prediction occurs without invoking another rule's ATN, there are no context
+ * stacks in the configurations. When lack of context leads to a conflict, we
+ * don't know if it's an ambiguity or a weakness in the strong LL(*) parsing
+ * strategy (versus full LL(*)).</p>
+ *
+ * <p>
+ * When SLL yields a configuration set with conflict, we rewind the input and
+ * retry the ATN simulation, this time using full outer context without adding
+ * to the DFA. Configuration context stacks will be the full invocation stacks
+ * from the start rule. If we get a conflict using full context, then we can
+ * definitively say we have a true ambiguity for that input sequence. If we
+ * don't get a conflict, it implies that the decision is sensitive to the outer
+ * context. (It is not context-sensitive in the sense of context-sensitive
+ * grammars.)</p>
+ *
+ * <p>
+ * The next time we reach this DFA state with an SLL conflict, through DFA
+ * simulation, we will again retry the ATN simulation using full context mode.
+ * This is slow because we can't save the results and have to "interpret" the
+ * ATN each time we get that input.</p>
+ *
+ * <p>
+ * <strong>CACHING FULL CONTEXT PREDICTIONS</strong></p>
+ *
+ * <p>
+ * We could cache results from full context to predicted alternative easily and
+ * that saves a lot of time but doesn't work in presence of predicates. The set
+ * of visible predicates from the ATN start state changes depending on the
+ * context, because closure can fall off the end of a rule. I tried to cache
+ * tuples (stack context, semantic context, predicted alt) but it was slower
+ * than interpreting and much more complicated. Also required a huge amount of
+ * memory. The goal is not to create the world's fastest parser anyway. I'd like
+ * to keep this algorithm simple. By launching multiple threads, we can improve
+ * the speed of parsing across a large number of files.</p>
+ *
+ * <p>
+ * There is no strict ordering between the amount of input used by SLL vs LL,
+ * which makes it really hard to build a cache for full context. Let's say that
+ * we have input A B C that leads to an SLL conflict with full context X. That
+ * implies that using X we might only use A B but we could also use A B C D to
+ * resolve conflict. Input A B C D could predict alternative 1 in one position
+ * in the input and A B C E could predict alternative 2 in another position in
+ * input. The conflicting SLL configurations could still be non-unique in the
+ * full context prediction, which would lead us to requiring more input than the
+ * original A B C.	To make a	prediction cache work, we have to track	the exact
+ * input	used during the previous prediction. That amounts to a cache that maps
+ * X to a specific DFA for that context.</p>
+ *
+ * <p>
+ * Something should be done for left-recursive expression predictions. They are
+ * likely LL(1) + pred eval. Easier to do the whole SLL unless error and retry
+ * with full LL thing Sam does.</p>
+ *
+ * <p>
+ * <strong>AVOIDING FULL CONTEXT PREDICTION</strong></p>
+ *
+ * <p>
+ * We avoid doing full context retry when the outer context is empty, we did not
+ * dip into the outer context by falling off the end of the decision state rule,
+ * or when we force SLL mode.</p>
+ *
+ * <p>
+ * As an example of the not dip into outer context case, consider as super
+ * constructor calls versus function calls. One grammar might look like
+ * this:</p>
+ *
+ * <pre>
+ * ctorBody
+ *   : '{' superCall? stat* '}'
+ *   ;
+ * </pre>
+ *
+ * <p>
+ * Or, you might see something like</p>
+ *
+ * <pre>
+ * stat
+ *   : superCall ';'
+ *   | expression ';'
+ *   | ...
+ *   ;
+ * </pre>
+ *
+ * <p>
+ * In both cases I believe that no closure operations will dip into the outer
+ * context. In the first case ctorBody in the worst case will stop at the '}'.
+ * In the 2nd case it should stop at the ';'. Both cases should stay within the
+ * entry rule and not dip into the outer context.</p>
+ *
+ * <p>
+ * <strong>PREDICATES</strong></p>
+ *
+ * <p>
+ * Predicates are always evaluated if present in either SLL or LL both. SLL and
+ * LL simulation deals with predicates differently. SLL collects predicates as
+ * it performs closure operations like ANTLR v3 did. It delays predicate
+ * evaluation until it reaches and accept state. This allows us to cache the SLL
+ * ATN simulation whereas, if we had evaluated predicates on-the-fly during
+ * closure, the DFA state configuration sets would be different and we couldn't
+ * build up a suitable DFA.</p>
+ *
+ * <p>
+ * When building a DFA accept state during ATN simulation, we evaluate any
+ * predicates and return the sole semantically valid alternative. If there is
+ * more than 1 alternative, we report an ambiguity. If there are 0 alternatives,
+ * we throw an exception. Alternatives without predicates act like they have
+ * true predicates. The simple way to think about it is to strip away all
+ * alternatives with false predicates and choose the minimum alternative that
+ * remains.</p>
+ *
+ * <p>
+ * When we start in the DFA and reach an accept state that's predicated, we test
+ * those and return the minimum semantically viable alternative. If no
+ * alternatives are viable, we throw an exception.</p>
+ *
+ * <p>
+ * During full LL ATN simulation, closure always evaluates predicates and
+ * on-the-fly. This is crucial to reducing the configuration set size during
+ * closure. It hits a landmine when parsing with the Java grammar, for example,
+ * without this on-the-fly evaluation.</p>
+ *
+ * <p>
+ * <strong>SHARING DFA</strong></p>
+ *
+ * <p>
+ * All instances of the same parser share the same decision DFAs through a
+ * static field. Each instance gets its own ATN simulator but they share the
+ * same {@link #decisionToDFA} field. They also share a
+ * {@link PredictionContextCache} object that makes sure that all
+ * {@link PredictionContext} objects are shared among the DFA states. This makes
+ * a big size difference.</p>
+ *
+ * <p>
+ * <strong>THREAD SAFETY</strong></p>
+ *
+ * <p>
+ * The {@link ParserATNSimulator} locks on the {@link #decisionToDFA} field when
+ * it adds a new DFA object to that array. {@link #addDFAEdge}
+ * locks on the DFA for the current decision when setting the
+ * {@link DFAState#edges} field. {@link #addDFAState} locks on
+ * the DFA for the current decision when looking up a DFA state to see if it
+ * already exists. We must make sure that all requests to add DFA states that
+ * are equivalent result in the same shared DFA object. This is because lots of
+ * threads will be trying to update the DFA at once. The
+ * {@link #addDFAState} method also locks inside the DFA lock
+ * but this time on the shared context cache when it rebuilds the
+ * configurations' {@link PredictionContext} objects using cached
+ * subgraphs/nodes. No other locking occurs, even during DFA simulation. This is
+ * safe as long as we can guarantee that all threads referencing
+ * {@code s.edge[t]} get the same physical target {@link DFAState}, or
+ * {@code null}. Once into the DFA, the DFA simulation does not reference the
+ * {@link DFA#states} map. It follows the {@link DFAState#edges} field to new
+ * targets. The DFA simulator will either find {@link DFAState#edges} to be
+ * {@code null}, to be non-{@code null} and {@code dfa.edges[t]} null, or
+ * {@code dfa.edges[t]} to be non-null. The
+ * {@link #addDFAEdge} method could be racing to set the field
+ * but in either case the DFA simulator works; if {@code null}, and requests ATN
+ * simulation. It could also race trying to get {@code dfa.edges[t]}, but either
+ * way it will work because it's not doing a test and set operation.</p>
+ *
+ * <p>
+ * <strong>Starting with SLL then failing to combined SLL/LL (Two-Stage
+ * Parsing)</strong></p>
+ *
+ * <p>
+ * Sam pointed out that if SLL does not give a syntax error, then there is no
+ * point in doing full LL, which is slower. We only have to try LL if we get a
+ * syntax error. For maximum speed, Sam starts the parser set to pure SLL
+ * mode with the {@link BailErrorStrategy}:</p>
+ *
+ * <pre>
+ * parser.{@link Parser#getInterpreter() getInterpreter()}.{@link #setPredictionMode setPredictionMode}{@code (}{@link PredictionMode#SLL}{@code )};
+ * parser.{@link Parser#setErrorHandler setErrorHandler}(new {@link BailErrorStrategy}());
+ * </pre>
+ *
+ * <p>
+ * If it does not get a syntax error, then we're done. If it does get a syntax
+ * error, we need to retry with the combined SLL/LL strategy.</p>
+ *
+ * <p>
+ * The reason this works is as follows. If there are no SLL conflicts, then the
+ * grammar is SLL (at least for that input set). If there is an SLL conflict,
+ * the full LL analysis must yield a set of viable alternatives which is a
+ * subset of the alternatives reported by SLL. If the LL set is a singleton,
+ * then the grammar is LL but not SLL. If the LL set is the same size as the SLL
+ * set, the decision is SLL. If the LL set has size &gt; 1, then that decision
+ * is truly ambiguous on the current input. If the LL set is smaller, then the
+ * SLL conflict resolution might choose an alternative that the full LL would
+ * rule out as a possibility based upon better context information. If that's
+ * the case, then the SLL parse will definitely get an error because the full LL
+ * analysis says it's not viable. If SLL conflict resolution chooses an
+ * alternative within the LL set, them both SLL and LL would choose the same
+ * alternative because they both choose the minimum of multiple conflicting
+ * alternatives.</p>
+ *
+ * <p>
+ * Let's say we have a set of SLL conflicting alternatives {@code {1, 2, 3}} and
+ * a smaller LL set called <em>s</em>. If <em>s</em> is {@code {2, 3}}, then SLL
+ * parsing will get an error because SLL will pursue alternative 1. If
+ * <em>s</em> is {@code {1, 2}} or {@code {1, 3}} then both SLL and LL will
+ * choose the same alternative because alternative one is the minimum of either
+ * set. If <em>s</em> is {@code {2}} or {@code {3}} then SLL will get a syntax
+ * error. If <em>s</em> is {@code {1}} then SLL will succeed.</p>
+ *
+ * <p>
+ * Of course, if the input is invalid, then we will get an error for sure in
+ * both SLL and LL parsing. Erroneous input will therefore require 2 passes over
+ * the input.</p>
+ */
 public class ParserATNSimulator extends ATNSimulator {
 	public static final boolean debug = false;
 	public static final boolean debug_list_atn_decisions = false;
 	public static final boolean dfa_debug = false;
 	public static final boolean retry_debug = false;
 
-	@Nullable
 	protected final Parser parser;
 
-	@NotNull
 	public final DFA[] decisionToDFA;
 
 	/** SLL, LL, or LL + exact ambig detection? */
-	@NotNull
+
 	private PredictionMode mode = PredictionMode.LL;
 
 	/** Each prediction operation uses a cache for merge of prediction contexts.
 	 *  Don't keep around as it wastes huge amounts of memory. DoubleKeyMap
 	 *  isn't synchronized but we're ok since two threads shouldn't reuse same
 	 *  parser/atnsim object because it can only handle one input at a time.
-	 *  This maps graphs a and b to merged result c. (a,b)->c. We can avoid
-	 *  the merge if we ever see a and b again.  Note that (b,a)->c should
+	 *  This maps graphs a and b to merged result c. (a,b)&rarr;c. We can avoid
+	 *  the merge if we ever see a and b again.  Note that (b,a)&rarr;c should
 	 *  also be examined during cache lookup.
 	 */
 	protected DoubleKeyMap<PredictionContext,PredictionContext,PredictionContext> mergeCache;
@@ -281,19 +313,20 @@ public class ParserATNSimulator extends ATNSimulator {
 	protected TokenStream _input;
 	protected int _startIndex;
 	protected ParserRuleContext _outerContext;
+	protected DFA _dfa;
 
 	/** Testing only! */
-	public ParserATNSimulator(@NotNull ATN atn, @NotNull DFA[] decisionToDFA,
-							  @NotNull PredictionContextCache sharedContextCache)
+	public ParserATNSimulator(ATN atn, DFA[] decisionToDFA,
+							  PredictionContextCache sharedContextCache)
 	{
 		this(null, atn, decisionToDFA, sharedContextCache);
 	}
 
-	public ParserATNSimulator(@Nullable Parser parser, @NotNull ATN atn,
-							  @NotNull DFA[] decisionToDFA,
-							  @NotNull PredictionContextCache sharedContextCache)
+	public ParserATNSimulator(Parser parser, ATN atn,
+							  DFA[] decisionToDFA,
+							  PredictionContextCache sharedContextCache)
 	{
-		super(atn,sharedContextCache);
+		super(atn, sharedContextCache);
 		this.parser = parser;
 		this.decisionToDFA = decisionToDFA;
 		//		DOTGenerator dot = new DOTGenerator(null);
@@ -305,8 +338,15 @@ public class ParserATNSimulator extends ATNSimulator {
 	public void reset() {
 	}
 
-	public int adaptivePredict(@NotNull TokenStream input, int decision,
-							   @Nullable ParserRuleContext outerContext)
+	@Override
+	public void clearDFA() {
+		for (int d = 0; d < decisionToDFA.length; d++) {
+			decisionToDFA[d] = new DFA(atn.getDecisionState(d), d);
+		}
+	}
+
+	public int adaptivePredict(TokenStream input, int decision,
+							   ParserRuleContext outerContext)
 	{
 		if ( debug || debug_list_atn_decisions )  {
 			System.out.println("adaptivePredict decision "+decision+
@@ -318,35 +358,64 @@ public class ParserATNSimulator extends ATNSimulator {
 		_startIndex = input.index();
 		_outerContext = outerContext;
 		DFA dfa = decisionToDFA[decision];
+		_dfa = dfa;
 
 		int m = input.mark();
-		int index = input.index();
+		int index = _startIndex;
 
 		// Now we are certain to have a specific decision's DFA
 		// But, do we still need an initial state?
 		try {
-			if ( dfa.s0==null ) {
+			DFAState s0;
+			if (dfa.isPrecedenceDfa()) {
+				// the start state for a precedence DFA depends on the current
+				// parser precedence, and is provided by a DFA method.
+				s0 = dfa.getPrecedenceStartState(parser.getPrecedence());
+			}
+			else {
+				// the start state for a "regular" DFA is just s0
+				s0 = dfa.s0;
+			}
+
+			if (s0 == null) {
 				if ( outerContext ==null ) outerContext = ParserRuleContext.EMPTY;
 				if ( debug || debug_list_atn_decisions )  {
 					System.out.println("predictATN decision "+ dfa.decision+
 									   " exec LA(1)=="+ getLookaheadName(input) +
 									   ", outerContext="+ outerContext.toString(parser));
 				}
+
 				boolean fullCtx = false;
 				ATNConfigSet s0_closure =
 					computeStartState(dfa.atnStartState,
 									  ParserRuleContext.EMPTY,
 									  fullCtx);
-				dfa.s0 = addDFAState(dfa, new DFAState(s0_closure));
+
+				if (dfa.isPrecedenceDfa()) {
+					/* If this is a precedence DFA, we use applyPrecedenceFilter
+					 * to convert the computed start state to a precedence start
+					 * state. We then use DFA.setPrecedenceStartState to set the
+					 * appropriate start state for the precedence level rather
+					 * than simply setting DFA.s0.
+					 */
+					dfa.s0.configs = s0_closure; // not used for prediction but useful to know start configs anyway
+					s0_closure = applyPrecedenceFilter(s0_closure);
+					s0 = addDFAState(dfa, new DFAState(s0_closure));
+					dfa.setPrecedenceStartState(parser.getPrecedence(), s0);
+				}
+				else {
+					s0 = addDFAState(dfa, new DFAState(s0_closure));
+					dfa.s0 = s0;
+				}
 			}
 
-			// We can start with an existing DFA
-			int alt = execATN(dfa, dfa.s0, input, index, outerContext);
-			if ( debug ) System.out.println("DFA after predictATN: "+ dfa.toString(parser.getTokenNames()));
+			int alt = execATN(dfa, s0, input, index, outerContext);
+			if ( debug ) System.out.println("DFA after predictATN: "+ dfa.toString(parser.getVocabulary()));
 			return alt;
 		}
 		finally {
 			mergeCache = null; // wack cache after each prediction
+			_dfa = null;
 			input.seek(index);
 			input.release(m);
 		}
@@ -382,8 +451,8 @@ public class ParserATNSimulator extends ATNSimulator {
 	    conflict
 	    conflict + preds
 	 */
-	protected int execATN(@NotNull DFA dfa, @NotNull DFAState s0,
-					   @NotNull TokenStream input, int startIndex,
+	protected int execATN(DFA dfa, DFAState s0,
+					   TokenStream input, int startIndex,
 					   ParserRuleContext outerContext)
 	{
 		if ( debug || debug_list_atn_decisions) {
@@ -414,18 +483,18 @@ public class ParserATNSimulator extends ATNSimulator {
 				// ATN states in SLL implies LL will also get nowhere.
 				// If conflict in states that dip out, choose min since we
 				// will get error no matter what.
-				int alt = getAltThatFinishedDecisionEntryRule(previousD.configs);
+				NoViableAltException e = noViableAlt(input, outerContext, previousD.configs, startIndex);
+				input.seek(startIndex);
+				int alt = getSynValidOrSemInvalidAltThatFinishedDecisionEntryRule(previousD.configs, outerContext);
 				if ( alt!=ATN.INVALID_ALT_NUMBER ) {
-					// return w/o altering DFA
 					return alt;
 				}
-
-				throw noViableAlt(input, outerContext, previousD.configs, startIndex);
+				throw e;
 			}
 
 			if ( D.requiresFullContext && mode != PredictionMode.SLL ) {
 				// IF PREDS, MIGHT RESOLVE TO SINGLE ALT => SLL (or syntax error)
-				BitSet conflictingAlts = null;
+				BitSet conflictingAlts = D.configs.conflictingAlts;
 				if ( D.predicates!=null ) {
 					if ( debug ) System.out.println("DFA state has preds in DFA sim LL failover");
 					int conflictIndex = input.index();
@@ -501,8 +570,7 @@ public class ParserATNSimulator extends ATNSimulator {
 	 * {@code t}, or {@code null} if the target state for this edge is not
 	 * already cached
 	 */
-	@Nullable
-	protected DFAState getExistingTargetState(@NotNull DFAState previousD, int t) {
+	protected DFAState getExistingTargetState(DFAState previousD, int t) {
 		DFAState[] edges = previousD.edges;
 		if (edges == null || t + 1 < 0 || t + 1 >= edges.length) {
 			return null;
@@ -523,8 +591,7 @@ public class ParserATNSimulator extends ATNSimulator {
 	 * {@code t}. If {@code t} does not lead to a valid DFA state, this method
 	 * returns {@link #ERROR}.
 	 */
-	@NotNull
-	protected DFAState computeTargetState(@NotNull DFA dfa, @NotNull DFAState previousD, int t) {
+	protected DFAState computeTargetState(DFA dfa, DFAState previousD, int t) {
 		ATNConfigSet reach = computeReachSet(previousD.configs, t, false);
 		if ( reach==null ) {
 			addDFAEdge(dfa, previousD, t, ERROR);
@@ -594,9 +661,9 @@ public class ParserATNSimulator extends ATNSimulator {
 
 	// comes back with reach.uniqueAlt set to a valid alt
 	protected int execATNWithFullContext(DFA dfa,
-										 DFAState D, // how far we got before failing over
-										 @NotNull ATNConfigSet s0,
-										 @NotNull TokenStream input, int startIndex,
+										 DFAState D, // how far we got in SLL DFA before failing over
+										 ATNConfigSet s0,
+										 TokenStream input, int startIndex,
 										 ParserRuleContext outerContext)
 	{
 		if ( debug || debug_list_atn_decisions ) {
@@ -624,11 +691,13 @@ public class ParserATNSimulator extends ATNSimulator {
 				// ATN states in SLL implies LL will also get nowhere.
 				// If conflict in states that dip out, choose min since we
 				// will get error no matter what.
-				int alt = getAltThatFinishedDecisionEntryRule(previous);
+				NoViableAltException e = noViableAlt(input, outerContext, previous, startIndex);
+				input.seek(startIndex);
+				int alt = getSynValidOrSemInvalidAltThatFinishedDecisionEntryRule(previous, outerContext);
 				if ( alt!=ATN.INVALID_ALT_NUMBER ) {
 					return alt;
 				}
-				throw noViableAlt(input, outerContext, previous, startIndex);
+				throw e;
 			}
 
 			Collection<BitSet> altSubSets = PredictionMode.getConflictingAltSubsets(reach);
@@ -640,6 +709,7 @@ public class ParserATNSimulator extends ATNSimulator {
 			}
 
 //			System.out.println("altSubSets: "+altSubSets);
+//			System.err.println("reach="+reach+", "+reach.conflictingAlts);
 			reach.uniqueAlt = getUniqueAlt(reach);
 			// unique prediction?
 			if ( reach.uniqueAlt!=ATN.INVALID_ALT_NUMBER ) {
@@ -709,7 +779,8 @@ public class ParserATNSimulator extends ATNSimulator {
 		the fact that we should predict alternative 1.  We just can't say for
 		sure that there is an ambiguity without looking further.
 		*/
-		reportAmbiguity(dfa, D, startIndex, input.index(), foundExactAmbig, null, reach);
+		reportAmbiguity(dfa, D, startIndex, input.index(), foundExactAmbig,
+						reach.getAlts(), reach);
 
 		return predictedAlt;
 	}
@@ -775,9 +846,9 @@ public class ParserATNSimulator extends ATNSimulator {
 		 * The conditions assume that intermediate
 		 * contains all configurations relevant to the reach set, but this
 		 * condition is not true when one or more configurations have been
-		 * withheld in skippedStopStates.
+		 * withheld in skippedStopStates, or when the current symbol is EOF.
 		 */
-		if (skippedStopStates == null) {
+		if (skippedStopStates == null && t != Token.EOF) {
 			if ( intermediate.size()==1 ) {
 				// Don't pursue the closure if there is just one state.
 				// It can only have one alternative; just add to result
@@ -798,8 +869,9 @@ public class ParserATNSimulator extends ATNSimulator {
 		if (reach == null) {
 			reach = new ATNConfigSet(fullCtx);
 			Set<ATNConfig> closureBusy = new HashSet<ATNConfig>();
+			boolean treatEofAsEpsilon = t == Token.EOF;
 			for (ATNConfig c : intermediate) {
-				closure(c, reach, closureBusy, false, fullCtx);
+				closure(c, reach, closureBusy, false, fullCtx, treatEofAsEpsilon);
 			}
 		}
 
@@ -848,11 +920,11 @@ public class ParserATNSimulator extends ATNSimulator {
 	 * {@code configs} which are in a {@link RuleStopState}. If all
 	 * configurations in {@code configs} are already in a rule stop state, this
 	 * method simply returns {@code configs}.
-	 * <p/>
-	 * When {@code lookToEndOfRule} is true, this method uses
+	 *
+	 * <p>When {@code lookToEndOfRule} is true, this method uses
 	 * {@link ATN#nextTokens} for each configuration in {@code configs} which is
 	 * not already in a rule stop state to see if a rule stop state is reachable
-	 * from the configuration via epsilon-only transitions.
+	 * from the configuration via epsilon-only transitions.</p>
 	 *
 	 * @param configs the configuration set to update
 	 * @param lookToEndOfRule when true, this method checks for rule stop states
@@ -863,8 +935,7 @@ public class ParserATNSimulator extends ATNSimulator {
 	 * rule stop state, otherwise return a new configuration set containing only
 	 * the configurations from {@code configs} which are in a rule stop state
 	 */
-	@NotNull
-	protected ATNConfigSet removeAllConfigsNotInRuleStopState(@NotNull ATNConfigSet configs, boolean lookToEndOfRule) {
+	protected ATNConfigSet removeAllConfigsNotInRuleStopState(ATNConfigSet configs, boolean lookToEndOfRule) {
 		if (PredictionMode.allConfigsInRuleStopStates(configs)) {
 			return configs;
 		}
@@ -888,9 +959,9 @@ public class ParserATNSimulator extends ATNSimulator {
 		return result;
 	}
 
-	@NotNull
-	protected ATNConfigSet computeStartState(@NotNull ATNState p,
-										  @Nullable RuleContext ctx,
+
+	protected ATNConfigSet computeStartState(ATNState p,
+										  RuleContext ctx,
 										  boolean fullCtx)
 	{
 		// always at least the implicit call to start rule
@@ -901,14 +972,228 @@ public class ParserATNSimulator extends ATNSimulator {
 			ATNState target = p.transition(i).target;
 			ATNConfig c = new ATNConfig(target, i+1, initialContext);
 			Set<ATNConfig> closureBusy = new HashSet<ATNConfig>();
-			closure(c, configs, closureBusy, true, fullCtx);
+			closure(c, configs, closureBusy, true, fullCtx, false);
 		}
 
 		return configs;
 	}
 
-	@Nullable
-	protected ATNState getReachableTarget(@NotNull Transition trans, int ttype) {
+	/* parrt internal source braindump that doesn't mess up
+	 * external API spec.
+
+		applyPrecedenceFilter is an optimization to avoid highly
+		nonlinear prediction of expressions and other left recursive
+		rules. The precedence predicates such as {3>=prec}? Are highly
+		context-sensitive in that they can only be properly evaluated
+		in the context of the proper prec argument. Without pruning,
+		these predicates are normal predicates evaluated when we reach
+		conflict state (or unique prediction). As we cannot evaluate
+		these predicates out of context, the resulting conflict leads
+		to full LL evaluation and nonlinear prediction which shows up
+		very clearly with fairly large expressions.
+
+		Example grammar:
+
+		e : e '*' e
+		  | e '+' e
+		  | INT
+		  ;
+
+		We convert that to the following:
+
+		e[int prec]
+			:   INT
+				( {3>=prec}? '*' e[4]
+				| {2>=prec}? '+' e[3]
+				)*
+			;
+
+		The (..)* loop has a decision for the inner block as well as
+		an enter or exit decision, which is what concerns us here. At
+		the 1st + of input 1+2+3, the loop entry sees both predicates
+		and the loop exit also sees both predicates by falling off the
+		edge of e.  This is because we have no stack information with
+		SLL and find the follow of e, which will hit the return states
+		inside the loop after e[4] and e[3], which brings it back to
+		the enter or exit decision. In this case, we know that we
+		cannot evaluate those predicates because we have fallen off
+		the edge of the stack and will in general not know which prec
+		parameter is the right one to use in the predicate.
+
+		Because we have special information, that these are precedence
+		predicates, we can resolve them without failing over to full
+		LL despite their context sensitive nature. We make an
+		assumption that prec[-1] <= prec[0], meaning that the current
+		precedence level is greater than or equal to the precedence
+		level of recursive invocations above us in the stack. For
+		example, if predicate {3>=prec}? is true of the current prec,
+		then one option is to enter the loop to match it now. The
+		other option is to exit the loop and the left recursive rule
+		to match the current operator in rule invocation further up
+		the stack. But, we know that all of those prec are lower or
+		the same value and so we can decide to enter the loop instead
+		of matching it later. That means we can strip out the other
+		configuration for the exit branch.
+
+		So imagine we have (14,1,$,{2>=prec}?) and then
+		(14,2,$-dipsIntoOuterContext,{2>=prec}?). The optimization
+		allows us to collapse these two configurations. We know that
+		if {2>=prec}? is true for the current prec parameter, it will
+		also be true for any prec from an invoking e call, indicated
+		by dipsIntoOuterContext. As the predicates are both true, we
+		have the option to evaluate them early in the decision start
+		state. We do this by stripping both predicates and choosing to
+		enter the loop as it is consistent with the notion of operator
+		precedence. It's also how the full LL conflict resolution
+		would work.
+
+		The solution requires a different DFA start state for each
+		precedence level.
+
+		The basic filter mechanism is to remove configurations of the
+		form (p, 2, pi) if (p, 1, pi) exists for the same p and pi. In
+		other words, for the same ATN state and predicate context,
+		remove any configuration associated with an exit branch if
+		there is a configuration associated with the enter branch.
+
+		It's also the case that the filter evaluates precedence
+		predicates and resolves conflicts according to precedence
+		levels. For example, for input 1+2+3 at the first +, we see
+		prediction filtering
+
+		[(11,1,[$],{3>=prec}?), (14,1,[$],{2>=prec}?), (5,2,[$],up=1),
+		 (11,2,[$],up=1), (14,2,[$],up=1)],hasSemanticContext=true,dipsIntoOuterContext
+
+		to
+
+		[(11,1,[$]), (14,1,[$]), (5,2,[$],up=1)],dipsIntoOuterContext
+
+		This filters because {3>=prec}? evals to true and collapses
+		(11,1,[$],{3>=prec}?) and (11,2,[$],up=1) since early conflict
+		resolution based upon rules of operator precedence fits with
+		our usual match first alt upon conflict.
+
+		We noticed a problem where a recursive call resets precedence
+		to 0. Sam's fix: each config has flag indicating if it has
+		returned from an expr[0] call. then just don't filter any
+		config with that flag set. flag is carried along in
+		closure(). so to avoid adding field, set bit just under sign
+		bit of dipsIntoOuterContext (SUPPRESS_PRECEDENCE_FILTER).
+		With the change you filter "unless (p, 2, pi) was reached
+		after leaving the rule stop state of the LR rule containing
+		state p, corresponding to a rule invocation with precedence
+		level 0"
+	 */
+
+	/**
+	 * This method transforms the start state computed by
+	 * {@link #computeStartState} to the special start state used by a
+	 * precedence DFA for a particular precedence value. The transformation
+	 * process applies the following changes to the start state's configuration
+	 * set.
+	 *
+	 * <ol>
+	 * <li>Evaluate the precedence predicates for each configuration using
+	 * {@link SemanticContext#evalPrecedence}.</li>
+	 * <li>When {@link ATNConfig#isPrecedenceFilterSuppressed} is {@code false},
+	 * remove all configurations which predict an alternative greater than 1,
+	 * for which another configuration that predicts alternative 1 is in the
+	 * same ATN state with the same prediction context. This transformation is
+	 * valid for the following reasons:
+	 * <ul>
+	 * <li>The closure block cannot contain any epsilon transitions which bypass
+	 * the body of the closure, so all states reachable via alternative 1 are
+	 * part of the precedence alternatives of the transformed left-recursive
+	 * rule.</li>
+	 * <li>The "primary" portion of a left recursive rule cannot contain an
+	 * epsilon transition, so the only way an alternative other than 1 can exist
+	 * in a state that is also reachable via alternative 1 is by nesting calls
+	 * to the left-recursive rule, with the outer calls not being at the
+	 * preferred precedence level. The
+	 * {@link ATNConfig#isPrecedenceFilterSuppressed} property marks ATN
+	 * configurations which do not meet this condition, and therefore are not
+	 * eligible for elimination during the filtering process.</li>
+	 * </ul>
+	 * </li>
+	 * </ol>
+	 *
+	 * <p>
+	 * The prediction context must be considered by this filter to address
+	 * situations like the following.
+	 * </p>
+	 * <code>
+	 * <pre>
+	 * grammar TA;
+	 * prog: statement* EOF;
+	 * statement: letterA | statement letterA 'b' ;
+	 * letterA: 'a';
+	 * </pre>
+	 * </code>
+	 * <p>
+	 * If the above grammar, the ATN state immediately before the token
+	 * reference {@code 'a'} in {@code letterA} is reachable from the left edge
+	 * of both the primary and closure blocks of the left-recursive rule
+	 * {@code statement}. The prediction context associated with each of these
+	 * configurations distinguishes between them, and prevents the alternative
+	 * which stepped out to {@code prog} (and then back in to {@code statement}
+	 * from being eliminated by the filter.
+	 * </p>
+	 *
+	 * @param configs The configuration set computed by
+	 * {@link #computeStartState} as the start state for the DFA.
+	 * @return The transformed configuration set representing the start state
+	 * for a precedence DFA at a particular precedence level (determined by
+	 * calling {@link Parser#getPrecedence}).
+	 */
+	protected ATNConfigSet applyPrecedenceFilter(ATNConfigSet configs) {
+		Map<Integer, PredictionContext> statesFromAlt1 = new HashMap<Integer, PredictionContext>();
+		ATNConfigSet configSet = new ATNConfigSet(configs.fullCtx);
+		for (ATNConfig config : configs) {
+			// handle alt 1 first
+			if (config.alt != 1) {
+				continue;
+			}
+
+			SemanticContext updatedContext = config.semanticContext.evalPrecedence(parser, _outerContext);
+			if (updatedContext == null) {
+				// the configuration was eliminated
+				continue;
+			}
+
+			statesFromAlt1.put(config.state.stateNumber, config.context);
+			if (updatedContext != config.semanticContext) {
+				configSet.add(new ATNConfig(config, updatedContext), mergeCache);
+			}
+			else {
+				configSet.add(config, mergeCache);
+			}
+		}
+
+		for (ATNConfig config : configs) {
+			if (config.alt == 1) {
+				// already handled
+				continue;
+			}
+
+			if (!config.isPrecedenceFilterSuppressed()) {
+				/* In the future, this elimination step could be updated to also
+				 * filter the prediction context for alternatives predicting alt>1
+				 * (basically a graph subtraction algorithm).
+				 */
+				PredictionContext context = statesFromAlt1.get(config.state.stateNumber);
+				if (context != null && context.equals(config.context)) {
+					// eliminated
+					continue;
+				}
+			}
+
+			configSet.add(config, mergeCache);
+		}
+
+		return configSet;
+	}
+
+	protected ATNState getReachableTarget(Transition trans, int ttype) {
 		if (trans.matches(ttype, 0, atn.maxTokenType)) {
 			return trans.target;
 		}
@@ -916,8 +1201,8 @@ public class ParserATNSimulator extends ATNSimulator {
 		return null;
 	}
 
-	protected SemanticContext[] getPredsForAmbigAlts(@NotNull BitSet ambigAlts,
-												  @NotNull ATNConfigSet configs,
+	protected SemanticContext[] getPredsForAmbigAlts(BitSet ambigAlts,
+												  ATNConfigSet configs,
 												  int nalts)
 	{
 		// REACH=[1|1|[]|0:0, 1|2|[]|0:1]
@@ -985,10 +1270,77 @@ public class ParserATNSimulator extends ATNSimulator {
 		return pairs.toArray(new DFAState.PredPrediction[pairs.size()]);
 	}
 
+	/**
+	 * This method is used to improve the localization of error messages by
+	 * choosing an alternative rather than throwing a
+	 * {@link NoViableAltException} in particular prediction scenarios where the
+	 * {@link #ERROR} state was reached during ATN simulation.
+	 *
+	 * <p>
+	 * The default implementation of this method uses the following
+	 * algorithm to identify an ATN configuration which successfully parsed the
+	 * decision entry rule. Choosing such an alternative ensures that the
+	 * {@link ParserRuleContext} returned by the calling rule will be complete
+	 * and valid, and the syntax error will be reported later at a more
+	 * localized location.</p>
+	 *
+	 * <ul>
+	 * <li>If a syntactically valid path or paths reach the end of the decision rule and
+	 * they are semantically valid if predicated, return the min associated alt.</li>
+	 * <li>Else, if a semantically invalid but syntactically valid path exist
+	 * or paths exist, return the minimum associated alt.
+	 * </li>
+	 * <li>Otherwise, return {@link ATN#INVALID_ALT_NUMBER}.</li>
+	 * </ul>
+	 *
+	 * <p>
+	 * In some scenarios, the algorithm described above could predict an
+	 * alternative which will result in a {@link FailedPredicateException} in
+	 * the parser. Specifically, this could occur if the <em>only</em> configuration
+	 * capable of successfully parsing to the end of the decision rule is
+	 * blocked by a semantic predicate. By choosing this alternative within
+	 * {@link #adaptivePredict} instead of throwing a
+	 * {@link NoViableAltException}, the resulting
+	 * {@link FailedPredicateException} in the parser will identify the specific
+	 * predicate which is preventing the parser from successfully parsing the
+	 * decision rule, which helps developers identify and correct logic errors
+	 * in semantic predicates.
+	 * </p>
+	 *
+	 * @param configs The ATN configurations which were valid immediately before
+	 * the {@link #ERROR} state was reached
+	 * @param outerContext The is the \gamma_0 initial parser context from the paper
+	 * or the parser stack at the instant before prediction commences.
+	 *
+	 * @return The value to return from {@link #adaptivePredict}, or
+	 * {@link ATN#INVALID_ALT_NUMBER} if a suitable alternative was not
+	 * identified and {@link #adaptivePredict} should report an error instead.
+	 */
+	protected int getSynValidOrSemInvalidAltThatFinishedDecisionEntryRule(ATNConfigSet configs,
+																		  ParserRuleContext outerContext)
+	{
+		Pair<ATNConfigSet,ATNConfigSet> sets =
+			splitAccordingToSemanticValidity(configs, outerContext);
+		ATNConfigSet semValidConfigs = sets.a;
+		ATNConfigSet semInvalidConfigs = sets.b;
+		int alt = getAltThatFinishedDecisionEntryRule(semValidConfigs);
+		if ( alt!=ATN.INVALID_ALT_NUMBER ) { // semantically/syntactically viable path exists
+			return alt;
+		}
+		// Is there a syntactically valid path with a failed pred?
+		if ( semInvalidConfigs.size()>0 ) {
+			alt = getAltThatFinishedDecisionEntryRule(semInvalidConfigs);
+			if ( alt!=ATN.INVALID_ALT_NUMBER ) { // syntactically viable path exists
+				return alt;
+			}
+		}
+		return ATN.INVALID_ALT_NUMBER;
+	}
+
 	protected int getAltThatFinishedDecisionEntryRule(ATNConfigSet configs) {
 		IntervalSet alts = new IntervalSet();
 		for (ATNConfig c : configs) {
-			if ( c.reachesIntoOuterContext>0 || (c.state instanceof RuleStopState && c.context.hasEmptyPath()) ) {
+			if ( c.getOuterContextDepth()>0 || (c.state instanceof RuleStopState && c.context.hasEmptyPath()) ) {
 				alts.add(c.alt);
 			}
 		}
@@ -996,13 +1348,45 @@ public class ParserATNSimulator extends ATNSimulator {
 		return alts.getMinElement();
 	}
 
+	/** Walk the list of configurations and split them according to
+	 *  those that have preds evaluating to true/false.  If no pred, assume
+	 *  true pred and include in succeeded set.  Returns Pair of sets.
+	 *
+	 *  Create a new set so as not to alter the incoming parameter.
+	 *
+	 *  Assumption: the input stream has been restored to the starting point
+	 *  prediction, which is where predicates need to evaluate.
+ 	 */
+	protected Pair<ATNConfigSet,ATNConfigSet> splitAccordingToSemanticValidity(
+		ATNConfigSet configs,
+		ParserRuleContext outerContext)
+	{
+		ATNConfigSet succeeded = new ATNConfigSet(configs.fullCtx);
+		ATNConfigSet failed = new ATNConfigSet(configs.fullCtx);
+		for (ATNConfig c : configs) {
+			if ( c.semanticContext!=SemanticContext.NONE ) {
+				boolean predicateEvaluationResult = evalSemanticContext(c.semanticContext, outerContext, c.alt, configs.fullCtx);
+				if ( predicateEvaluationResult ) {
+					succeeded.add(c);
+				}
+				else {
+					failed.add(c);
+				}
+			}
+			else {
+				succeeded.add(c);
+			}
+		}
+		return new Pair<ATNConfigSet, ATNConfigSet>(succeeded,failed);
+	}
+
 	/** Look through a list of predicate/alt pairs, returning alts for the
 	 *  pairs that win. A {@code NONE} predicate indicates an alt containing an
 	 *  unpredicated config which behaves as "always true." If !complete
 	 *  then we stop at the first predicate that evaluates to true. This
 	 *  includes pairs with null predicates.
 	 */
-	protected BitSet evalSemanticContext(@NotNull DFAState.PredPrediction[] predPredictions,
+	protected BitSet evalSemanticContext(DFAState.PredPrediction[] predPredictions,
 									  ParserRuleContext outerContext,
 									  boolean complete)
 	{
@@ -1016,7 +1400,8 @@ public class ParserATNSimulator extends ATNSimulator {
 				continue;
 			}
 
-			boolean predicateEvaluationResult = pair.pred.eval(parser, outerContext);
+			boolean fullCtx = false; // in dfa
+			boolean predicateEvaluationResult = evalSemanticContext(pair.pred, outerContext, pair.alt, fullCtx);
 			if ( debug || dfa_debug ) {
 				System.out.println("eval pred "+pair+"="+predicateEvaluationResult);
 			}
@@ -1033,6 +1418,39 @@ public class ParserATNSimulator extends ATNSimulator {
 		return predictions;
 	}
 
+	/**
+	 * Evaluate a semantic context within a specific parser context.
+	 *
+	 * <p>
+	 * This method might not be called for every semantic context evaluated
+	 * during the prediction process. In particular, we currently do not
+	 * evaluate the following but it may change in the future:</p>
+	 *
+	 * <ul>
+	 * <li>Precedence predicates (represented by
+	 * {@link SemanticContext.PrecedencePredicate}) are not currently evaluated
+	 * through this method.</li>
+	 * <li>Operator predicates (represented by {@link SemanticContext.AND} and
+	 * {@link SemanticContext.OR}) are evaluated as a single semantic
+	 * context, rather than evaluating the operands individually.
+	 * Implementations which require evaluation results from individual
+	 * predicates should override this method to explicitly handle evaluation of
+	 * the operands within operator predicates.</li>
+	 * </ul>
+	 *
+	 * @param pred The semantic context to evaluate
+	 * @param parserCallStack The parser context in which to evaluate the
+	 * semantic context
+	 * @param alt The alternative which is guarded by {@code pred}
+	 * @param fullCtx {@code true} if the evaluation is occurring during LL
+	 * prediction; otherwise, {@code false} if the evaluation is occurring
+	 * during SLL prediction
+	 *
+	 * @since 4.3
+	 */
+	protected boolean evalSemanticContext(SemanticContext pred, ParserRuleContext parserCallStack, int alt, boolean fullCtx) {
+		return pred.eval(parser, parserCallStack);
+	}
 
 	/* TODO: If we are doing predicates, there is no point in pursuing
 		 closure operations if we reach a DFA state that uniquely predicts
@@ -1041,25 +1459,27 @@ public class ParserATNSimulator extends ATNSimulator {
 		 ambig detection thought :(
 		  */
 
-	protected void closure(@NotNull ATNConfig config,
-						   @NotNull ATNConfigSet configs,
-						   @NotNull Set<ATNConfig> closureBusy,
+	protected void closure(ATNConfig config,
+						   ATNConfigSet configs,
+						   Set<ATNConfig> closureBusy,
 						   boolean collectPredicates,
-						   boolean fullCtx)
+						   boolean fullCtx,
+						   boolean treatEofAsEpsilon)
 	{
 		final int initialDepth = 0;
 		closureCheckingStopState(config, configs, closureBusy, collectPredicates,
 								 fullCtx,
-								 initialDepth);
+								 initialDepth, treatEofAsEpsilon);
 		assert !fullCtx || !configs.dipsIntoOuterContext;
 	}
 
-	protected void closureCheckingStopState(@NotNull ATNConfig config,
-											@NotNull ATNConfigSet configs,
-											@NotNull Set<ATNConfig> closureBusy,
+	protected void closureCheckingStopState(ATNConfig config,
+											ATNConfigSet configs,
+											Set<ATNConfig> closureBusy,
 											boolean collectPredicates,
 											boolean fullCtx,
-											int depth)
+											int depth,
+											boolean treatEofAsEpsilon)
 	{
 		if ( debug ) System.out.println("closure("+config.toString(parser,true)+")");
 
@@ -1078,7 +1498,7 @@ public class ParserATNSimulator extends ATNSimulator {
 							if ( debug ) System.out.println("FALLING off rule "+
 															getRuleName(config.state.ruleIndex));
 							closure_(config, configs, closureBusy, collectPredicates,
-									 fullCtx, depth);
+									 fullCtx, depth, treatEofAsEpsilon);
 						}
 						continue;
 					}
@@ -1089,10 +1509,14 @@ public class ParserATNSimulator extends ATNSimulator {
 					// While we have context to pop back from, we may have
 					// gotten that context AFTER having falling off a rule.
 					// Make sure we track that we are now out of context.
+					//
+					// This assignment also propagates the
+					// isPrecedenceFilterSuppressed() value to the new
+					// configuration.
 					c.reachesIntoOuterContext = config.reachesIntoOuterContext;
 					assert depth > Integer.MIN_VALUE;
 					closureCheckingStopState(c, configs, closureBusy, collectPredicates,
-											 fullCtx, depth - 1);
+											 fullCtx, depth - 1, treatEofAsEpsilon);
 				}
 				return;
 			}
@@ -1109,21 +1533,24 @@ public class ParserATNSimulator extends ATNSimulator {
 		}
 
 		closure_(config, configs, closureBusy, collectPredicates,
-				 fullCtx, depth);
+				 fullCtx, depth, treatEofAsEpsilon);
 	}
 
 	/** Do the actual work of walking epsilon edges */
-	protected void closure_(@NotNull ATNConfig config,
-							@NotNull ATNConfigSet configs,
-							@NotNull Set<ATNConfig> closureBusy,
+	protected void closure_(ATNConfig config,
+							ATNConfigSet configs,
+							Set<ATNConfig> closureBusy,
 							boolean collectPredicates,
 							boolean fullCtx,
-							int depth)
+							int depth,
+							boolean treatEofAsEpsilon)
 	{
 		ATNState p = config.state;
 		// optimization
 		if ( !p.onlyHasEpsilonTransitions() ) {
             configs.add(config, mergeCache);
+			// make sure to not return here, because EOF transitions can act as
+			// both epsilon transitions and non-epsilon transitions.
 //            if ( debug ) System.out.println("added config "+configs);
         }
 
@@ -1132,8 +1559,13 @@ public class ParserATNSimulator extends ATNSimulator {
 			boolean continueCollecting =
 				!(t instanceof ActionTransition) && collectPredicates;
 			ATNConfig c = getEpsilonTarget(config, t, continueCollecting,
-										   depth == 0, fullCtx);
+										   depth == 0, fullCtx, treatEofAsEpsilon);
 			if ( c!=null ) {
+				if (!t.isEpsilon() && !closureBusy.add(c)) {
+					// avoid infinite recursion for EOF* and EOF+
+					continue;
+				}
+
 				int newDepth = depth;
 				if ( config.state instanceof RuleStopState) {
 					assert !fullCtx;
@@ -1148,6 +1580,13 @@ public class ParserATNSimulator extends ATNSimulator {
 						continue;
 					}
 
+					if (_dfa != null && _dfa.isPrecedenceDfa()) {
+						int outermostPrecedenceReturn = ((EpsilonTransition)t).outermostPrecedenceReturn();
+						if (outermostPrecedenceReturn == _dfa.atnStartState.ruleIndex) {
+							c.setPrecedenceFilterSuppressed(true);
+						}
+					}
+
 					c.reachesIntoOuterContext++;
 					configs.dipsIntoOuterContext = true; // TODO: can remove? only care when we add to set per middle of this method
 					assert newDepth > Integer.MIN_VALUE;
@@ -1162,23 +1601,24 @@ public class ParserATNSimulator extends ATNSimulator {
 				}
 
 				closureCheckingStopState(c, configs, closureBusy, continueCollecting,
-										 fullCtx, newDepth);
+										 fullCtx, newDepth, treatEofAsEpsilon);
 			}
 		}
 	}
 
-	@NotNull
+
 	public String getRuleName(int index) {
 		if ( parser!=null && index>=0 ) return parser.getRuleNames()[index];
 		return "<rule "+index+">";
 	}
 
-	@Nullable
-	protected ATNConfig getEpsilonTarget(@NotNull ATNConfig config,
-									  @NotNull Transition t,
+
+	protected ATNConfig getEpsilonTarget(ATNConfig config,
+									  Transition t,
 									  boolean collectPredicates,
 									  boolean inContext,
-									  boolean fullCtx)
+									  boolean fullCtx,
+									  boolean treatEofAsEpsilon)
 	{
 		switch (t.getSerializationType()) {
 		case Transition.RULE:
@@ -1199,20 +1639,33 @@ public class ParserATNSimulator extends ATNSimulator {
 		case Transition.EPSILON:
 			return new ATNConfig(config, t.target);
 
+		case Transition.ATOM:
+		case Transition.RANGE:
+		case Transition.SET:
+			// EOF transitions act like epsilon transitions after the first EOF
+			// transition is traversed
+			if (treatEofAsEpsilon) {
+				if (t.matches(Token.EOF, 0, 1)) {
+					return new ATNConfig(config, t.target);
+				}
+			}
+
+			return null;
+
 		default:
 			return null;
 		}
 	}
 
-	@NotNull
-	protected ATNConfig actionTransition(@NotNull ATNConfig config, @NotNull ActionTransition t) {
+
+	protected ATNConfig actionTransition(ATNConfig config, ActionTransition t) {
 		if ( debug ) System.out.println("ACTION edge "+t.ruleIndex+":"+t.actionIndex);
 		return new ATNConfig(config, t.target);
 	}
 
-	@Nullable
-	public ATNConfig precedenceTransition(@NotNull ATNConfig config,
-									@NotNull PrecedencePredicateTransition pt,
+
+	public ATNConfig precedenceTransition(ATNConfig config,
+									PrecedencePredicateTransition pt,
 									boolean collectPredicates,
 									boolean inContext,
 									boolean fullCtx)
@@ -1236,7 +1689,7 @@ public class ParserATNSimulator extends ATNSimulator {
 				// later during conflict resolution.
 				int currentPosition = _input.index();
 				_input.seek(_startIndex);
-				boolean predSucceeds = pt.getPredicate().eval(parser, _outerContext);
+				boolean predSucceeds = evalSemanticContext(pt.getPredicate(), _outerContext, config.alt, fullCtx);
 				_input.seek(currentPosition);
 				if ( predSucceeds ) {
 					c = new ATNConfig(config, pt.target); // no pred context
@@ -1256,9 +1709,9 @@ public class ParserATNSimulator extends ATNSimulator {
         return c;
 	}
 
-	@Nullable
-	protected ATNConfig predTransition(@NotNull ATNConfig config,
-									@NotNull PredicateTransition pt,
+
+	protected ATNConfig predTransition(ATNConfig config,
+									PredicateTransition pt,
 									boolean collectPredicates,
 									boolean inContext,
 									boolean fullCtx)
@@ -1284,7 +1737,7 @@ public class ParserATNSimulator extends ATNSimulator {
 				// later during conflict resolution.
 				int currentPosition = _input.index();
 				_input.seek(_startIndex);
-				boolean predSucceeds = pt.getPredicate().eval(parser, _outerContext);
+				boolean predSucceeds = evalSemanticContext(pt.getPredicate(), _outerContext, config.alt, fullCtx);
 				_input.seek(currentPosition);
 				if ( predSucceeds ) {
 					c = new ATNConfig(config, pt.target); // no pred context
@@ -1304,8 +1757,8 @@ public class ParserATNSimulator extends ATNSimulator {
         return c;
 	}
 
-	@NotNull
-	protected ATNConfig ruleTransition(@NotNull ATNConfig config, @NotNull RuleTransition t) {
+
+	protected ATNConfig ruleTransition(ATNConfig config, RuleTransition t) {
 		if ( debug ) {
 			System.out.println("CALL rule "+getRuleName(t.target.ruleIndex)+
 							   ", ctx="+config.context);
@@ -1317,6 +1770,15 @@ public class ParserATNSimulator extends ATNSimulator {
 		return new ATNConfig(config, t.target, newContext);
 	}
 
+	/**
+	 * Gets a {@link BitSet} containing the alternatives in {@code configs}
+	 * which are part of one or more conflicting alternative subsets.
+	 *
+	 * @param configs The {@link ATNConfigSet} to analyze.
+	 * @return The alternatives in {@code configs} which are part of one or more
+	 * conflicting alternative subsets. If {@code configs} does not contain any
+	 * conflicting subsets, this method returns an empty {@link BitSet}.
+	 */
 	protected BitSet getConflictingAlts(ATNConfigSet configs) {
 		Collection<BitSet> altsets = PredictionMode.getConflictingAltSubsets(configs);
 		return PredictionMode.getAlts(altsets);
@@ -1339,7 +1801,7 @@ public class ParserATNSimulator extends ATNSimulator {
 	 we don't consider any conflicts that include alternative 2. So, we
 	 ignore the conflict between alts 1 and 2. We ignore a set of
 	 conflicting alts when there is an intersection with an alternative
-	 associated with a single alt state in the state->config-list map.
+	 associated with a single alt state in the state&rarr;config-list map.
 
 	 It's also the case that we might have two conflicting configurations but
 	 also a 3rd nonconflicting configuration for a different alternative:
@@ -1358,7 +1820,6 @@ public class ParserATNSimulator extends ATNSimulator {
 	 ignore a set of conflicting alts when we have an alternative
 	 that we still need to pursue.
 	 */
-
 	protected BitSet getConflictingAltsOrUniqueAlt(ATNConfigSet configs) {
 		BitSet conflictingAlts;
 		if ( configs.uniqueAlt!= ATN.INVALID_ALT_NUMBER ) {
@@ -1371,20 +1832,19 @@ public class ParserATNSimulator extends ATNSimulator {
 		return conflictingAlts;
 	}
 
-	@NotNull
+
 	public String getTokenName(int t) {
-		if ( t==Token.EOF ) return "EOF";
-		if ( parser!=null && parser.getTokenNames()!=null ) {
-			String[] tokensNames = parser.getTokenNames();
-			if ( t>=tokensNames.length ) {
-				System.err.println(t+" ttype out of range: "+ Arrays.toString(tokensNames));
-				System.err.println(((CommonTokenStream)parser.getInputStream()).getTokens());
-			}
-			else {
-				return tokensNames[t]+"<"+t+">";
-			}
+		if (t == Token.EOF) {
+			return "EOF";
 		}
-		return String.valueOf(t);
+
+		Vocabulary vocabulary = parser != null ? parser.getVocabulary() : VocabularyImpl.EMPTY_VOCABULARY;
+		String displayName = vocabulary.getDisplayName(t);
+		if (displayName.equals(Integer.toString(t))) {
+			return displayName;
+		}
+
+		return displayName + "<" + t + ">";
 	}
 
 	public String getLookaheadName(TokenStream input) {
@@ -1395,7 +1855,7 @@ public class ParserATNSimulator extends ATNSimulator {
 	 *  it out for clarity now that alg. works well. We can leave this
 	 *  "dead" code for a bit.
 	 */
-	public void dumpDeadEndConfigs(@NotNull NoViableAltException nvae) {
+	public void dumpDeadEndConfigs(NoViableAltException nvae) {
 		System.err.println("dead end configs: ");
 		for (ATNConfig c : nvae.getDeadEndConfigs()) {
 			String trans = "no edges";
@@ -1415,10 +1875,10 @@ public class ParserATNSimulator extends ATNSimulator {
 		}
 	}
 
-	@NotNull
-	protected NoViableAltException noViableAlt(@NotNull TokenStream input,
-											@NotNull ParserRuleContext outerContext,
-											@NotNull ATNConfigSet configs,
+
+	protected NoViableAltException noViableAlt(TokenStream input,
+											ParserRuleContext outerContext,
+											ATNConfigSet configs,
 											int startIndex)
 	{
 		return new NoViableAltException(parser, input,
@@ -1427,7 +1887,7 @@ public class ParserATNSimulator extends ATNSimulator {
 											configs, outerContext);
 	}
 
-	protected static int getUniqueAlt(@NotNull ATNConfigSet configs) {
+	protected static int getUniqueAlt(ATNConfigSet configs) {
 		int alt = ATN.INVALID_ALT_NUMBER;
 		for (ATNConfig c : configs) {
 			if ( alt == ATN.INVALID_ALT_NUMBER ) {
@@ -1446,10 +1906,10 @@ public class ParserATNSimulator extends ATNSimulator {
 	 * DFA. If {@code from} is {@code null}, or if {@code t} is outside the
 	 * range of edges that can be represented in the DFA tables, this method
 	 * returns without adding the edge to the DFA.
-	 * <p/>
-	 * If {@code to} is {@code null}, this method returns {@code null}.
+	 *
+	 * <p>If {@code to} is {@code null}, this method returns {@code null}.
 	 * Otherwise, this method returns the {@link DFAState} returned by calling
-	 * {@link #addDFAState} for the {@code to} state.
+	 * {@link #addDFAState} for the {@code to} state.</p>
 	 *
 	 * @param dfa The DFA
 	 * @param from The source state for the edge
@@ -1460,10 +1920,10 @@ public class ParserATNSimulator extends ATNSimulator {
 	 * otherwise this method returns the result of calling {@link #addDFAState}
 	 * on {@code to}
 	 */
-	protected DFAState addDFAEdge(@NotNull DFA dfa,
-								  @Nullable DFAState from,
+	protected DFAState addDFAEdge(DFA dfa,
+								  DFAState from,
 								  int t,
-								  @Nullable DFAState to)
+								  DFAState to)
 	{
 		if ( debug ) {
 			System.out.println("EDGE "+from+" -> "+to+" upon "+getTokenName(t));
@@ -1487,7 +1947,7 @@ public class ParserATNSimulator extends ATNSimulator {
 		}
 
 		if ( debug ) {
-			System.out.println("DFA=\n"+dfa.toString(parser!=null?parser.getTokenNames():null));
+			System.out.println("DFA=\n"+dfa.toString(parser!=null?parser.getVocabulary():VocabularyImpl.EMPTY_VOCABULARY));
 		}
 
 		return to;
@@ -1498,9 +1958,9 @@ public class ParserATNSimulator extends ATNSimulator {
 	 * the actual instance stored in the DFA. If a state equivalent to {@code D}
 	 * is already in the DFA, the existing state is returned. Otherwise this
 	 * method returns {@code D} after adding it to the DFA.
-	 * <p/>
-	 * If {@code D} is {@link #ERROR}, this method returns {@link #ERROR} and
-	 * does not change the DFA.
+	 *
+	 * <p>If {@code D} is {@link #ERROR}, this method returns {@link #ERROR} and
+	 * does not change the DFA.</p>
 	 *
 	 * @param dfa The dfa
 	 * @param D The DFA state to add
@@ -1508,8 +1968,7 @@ public class ParserATNSimulator extends ATNSimulator {
 	 * state if {@code D} is already in the DFA, or {@code D} itself if the
 	 * state was not already present.
 	 */
-	@NotNull
-	protected DFAState addDFAState(@NotNull DFA dfa, @NotNull DFAState D) {
+	protected DFAState addDFAState(DFA dfa, DFAState D) {
 		if (D == ERROR) {
 			return D;
 		}
@@ -1529,7 +1988,7 @@ public class ParserATNSimulator extends ATNSimulator {
 		}
 	}
 
-	protected void reportAttemptingFullContext(DFA dfa, @Nullable BitSet conflictingAlts, @NotNull ATNConfigSet configs, int startIndex, int stopIndex) {
+	protected void reportAttemptingFullContext(DFA dfa, BitSet conflictingAlts, ATNConfigSet configs, int startIndex, int stopIndex) {
         if ( debug || retry_debug ) {
 			Interval interval = Interval.of(startIndex, stopIndex);
 			System.out.println("reportAttemptingFullContext decision="+dfa.decision+":"+configs+
@@ -1538,7 +1997,7 @@ public class ParserATNSimulator extends ATNSimulator {
         if ( parser!=null ) parser.getErrorListenerDispatch().reportAttemptingFullContext(parser, dfa, startIndex, stopIndex, conflictingAlts, configs);
     }
 
-	protected void reportContextSensitivity(DFA dfa, int prediction, @NotNull ATNConfigSet configs, int startIndex, int stopIndex) {
+	protected void reportContextSensitivity(DFA dfa, int prediction, ATNConfigSet configs, int startIndex, int stopIndex) {
         if ( debug || retry_debug ) {
 			Interval interval = Interval.of(startIndex, stopIndex);
             System.out.println("reportContextSensitivity decision="+dfa.decision+":"+configs+
@@ -1548,28 +2007,14 @@ public class ParserATNSimulator extends ATNSimulator {
     }
 
     /** If context sensitive parsing, we know it's ambiguity not conflict */
-    protected void reportAmbiguity(@NotNull DFA dfa, DFAState D, int startIndex, int stopIndex,
+    protected void reportAmbiguity(DFA dfa,
+								   DFAState D, // the DFA state from execATN() that had SLL conflicts
+								   int startIndex, int stopIndex,
 								   boolean exact,
-								   @Nullable BitSet ambigAlts,
-								   @NotNull ATNConfigSet configs)
+								   BitSet ambigAlts,
+								   ATNConfigSet configs) // configs that LL not SLL considered conflicting
 	{
 		if ( debug || retry_debug ) {
-//			ParserATNPathFinder finder = new ParserATNPathFinder(parser, atn);
-//			int i = 1;
-//			for (Transition t : dfa.atnStartState.transitions) {
-//				System.out.println("ALT "+i+"=");
-//				System.out.println(startIndex+".."+stopIndex+", len(input)="+parser.getInputStream().size());
-//				TraceTree path = finder.trace(t.target, parser.getContext(), (TokenStream)parser.getInputStream(),
-//											  startIndex, stopIndex);
-//				if ( path!=null ) {
-//					System.out.println("path = "+path.toStringTree());
-//					for (TraceTree leaf : path.leaves) {
-//						List<ATNState> states = path.getPathToNode(leaf);
-//						System.out.println("states="+states);
-//					}
-//				}
-//				i++;
-//			}
 			Interval interval = Interval.of(startIndex, stopIndex);
 			System.out.println("reportAmbiguity "+
 							   ambigAlts+":"+configs+
@@ -1579,12 +2024,19 @@ public class ParserATNSimulator extends ATNSimulator {
 																			  exact, ambigAlts, configs);
     }
 
-	public final void setPredictionMode(@NotNull PredictionMode mode) {
+	public final void setPredictionMode(PredictionMode mode) {
 		this.mode = mode;
 	}
 
-	@NotNull
+
 	public final PredictionMode getPredictionMode() {
 		return mode;
 	}
+
+	/**
+	 * @since 4.3
+	 */
+	public Parser getParser() {
+		return parser;
+	}
 }
diff --git a/runtime/Java/src/org/antlr/v4/runtime/atn/PrecedencePredicateTransition.java b/runtime/Java/src/org/antlr/v4/runtime/atn/PrecedencePredicateTransition.java
index 659014a56..ad96a027b 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/atn/PrecedencePredicateTransition.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/atn/PrecedencePredicateTransition.java
@@ -30,8 +30,6 @@
 
 package org.antlr.v4.runtime.atn;
 
-import org.antlr.v4.runtime.misc.NotNull;
-
 /**
  *
  * @author Sam Harwell
@@ -39,7 +37,7 @@ import org.antlr.v4.runtime.misc.NotNull;
 public final class PrecedencePredicateTransition extends AbstractPredicateTransition {
 	public final int precedence;
 
-	public PrecedencePredicateTransition(@NotNull ATNState target, int precedence) {
+	public PrecedencePredicateTransition(ATNState target, int precedence) {
 		super(target);
 		this.precedence = precedence;
 	}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/atn/PredicateEvalInfo.java b/runtime/Java/src/org/antlr/v4/runtime/atn/PredicateEvalInfo.java
new file mode 100644
index 000000000..59241e264
--- /dev/null
+++ b/runtime/Java/src/org/antlr/v4/runtime/atn/PredicateEvalInfo.java
@@ -0,0 +1,97 @@
+/*
+ * [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.
+ */
+
+package org.antlr.v4.runtime.atn;
+
+import org.antlr.v4.runtime.ParserRuleContext;
+import org.antlr.v4.runtime.Recognizer;
+import org.antlr.v4.runtime.RuleContext;
+import org.antlr.v4.runtime.TokenStream;
+
+/**
+ * This class represents profiling event information for semantic predicate
+ * evaluations which occur during prediction.
+ *
+ * @see ParserATNSimulator#evalSemanticContext
+ *
+ * @since 4.3
+ */
+public class PredicateEvalInfo extends DecisionEventInfo {
+	/**
+	 * The semantic context which was evaluated.
+	 */
+	public final SemanticContext semctx;
+	/**
+	 * The alternative number for the decision which is guarded by the semantic
+	 * context {@link #semctx}. Note that other ATN
+	 * configurations may predict the same alternative which are guarded by
+	 * other semantic contexts and/or {@link SemanticContext#NONE}.
+	 */
+	public final int predictedAlt;
+	/**
+	 * The result of evaluating the semantic context {@link #semctx}.
+	 */
+	public final boolean evalResult;
+
+	/**
+	 * Constructs a new instance of the {@link PredicateEvalInfo} class with the
+	 * specified detailed predicate evaluation information.
+	 *
+	 * @param decision The decision number
+	 * @param input The input token stream
+	 * @param startIndex The start index for the current prediction
+	 * @param stopIndex The index at which the predicate evaluation was
+	 * triggered. Note that the input stream may be reset to other positions for
+	 * the actual evaluation of individual predicates.
+	 * @param semctx The semantic context which was evaluated
+	 * @param evalResult The results of evaluating the semantic context
+	 * @param predictedAlt The alternative number for the decision which is
+	 * guarded by the semantic context {@code semctx}. See {@link #predictedAlt}
+	 * for more information.
+	 * @param fullCtx {@code true} if the semantic context was
+	 * evaluated during LL prediction; otherwise, {@code false} if the semantic
+	 * context was evaluated during SLL prediction
+	 *
+	 * @see ParserATNSimulator#evalSemanticContext(SemanticContext, ParserRuleContext, int, boolean)
+	 * @see SemanticContext#eval(Recognizer, RuleContext)
+	 */
+	public PredicateEvalInfo(int decision,
+							 TokenStream input, int startIndex, int stopIndex,
+							 SemanticContext semctx,
+							 boolean evalResult,
+							 int predictedAlt,
+							 boolean fullCtx)
+	{
+		super(decision, new ATNConfigSet(), input, startIndex, stopIndex, fullCtx);
+		this.semctx = semctx;
+		this.evalResult = evalResult;
+		this.predictedAlt = predictedAlt;
+	}
+}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/atn/PredicateTransition.java b/runtime/Java/src/org/antlr/v4/runtime/atn/PredicateTransition.java
index f2e579278..574d32911 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/atn/PredicateTransition.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/atn/PredicateTransition.java
@@ -30,8 +30,6 @@
 
 package org.antlr.v4.runtime.atn;
 
-import org.antlr.v4.runtime.misc.NotNull;
-
 /** TODO: this is old comment:
  *  A tree of semantic predicates from the grammar AST if label==SEMPRED.
  *  In the ATN, labels will always be exactly one predicate, but the DFA
@@ -43,7 +41,7 @@ public final class PredicateTransition extends AbstractPredicateTransition {
 	public final int predIndex;
 	public final boolean isCtxDependent;  // e.g., $i ref in pred
 
-	public PredicateTransition(@NotNull ATNState target, int ruleIndex, int predIndex, boolean isCtxDependent) {
+	public PredicateTransition(ATNState target, int ruleIndex, int predIndex, boolean isCtxDependent) {
 		super(target);
 		this.ruleIndex = ruleIndex;
 		this.predIndex = predIndex;
@@ -68,7 +66,6 @@ public final class PredicateTransition extends AbstractPredicateTransition {
    	}
 
 	@Override
-	@NotNull
 	public String toString() {
 		return "pred_"+ruleIndex+":"+predIndex;
 	}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/atn/PredictionContext.java b/runtime/Java/src/org/antlr/v4/runtime/atn/PredictionContext.java
index 0e58cf4a0..20fb17193 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/atn/PredictionContext.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/atn/PredictionContext.java
@@ -34,8 +34,6 @@ import org.antlr.v4.runtime.Recognizer;
 import org.antlr.v4.runtime.RuleContext;
 import org.antlr.v4.runtime.misc.DoubleKeyMap;
 import org.antlr.v4.runtime.misc.MurmurHash;
-import org.antlr.v4.runtime.misc.NotNull;
-import org.antlr.v4.runtime.misc.Nullable;
 
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -71,17 +69,17 @@ public abstract class PredictionContext {
 	 *
 	 * <pre>
 	 *  private int referenceHashCode() {
-	 *      int hash = {@link MurmurHash#initialize}({@link #INITIAL_HASH});
+	 *      int hash = {@link MurmurHash#initialize MurmurHash.initialize}({@link #INITIAL_HASH});
 	 *
-	 *      for (int i = 0; i < {@link #size()}; i++) {
-	 *          hash = {@link MurmurHash#update}(hash, {@link #getParent}(i));
+	 *      for (int i = 0; i &lt; {@link #size()}; i++) {
+	 *          hash = {@link MurmurHash#update MurmurHash.update}(hash, {@link #getParent getParent}(i));
 	 *      }
 	 *
-	 *      for (int i = 0; i < {@link #size()}; i++) {
-	 *          hash = {@link MurmurHash#update}(hash, {@link #getReturnState}(i));
+	 *      for (int i = 0; i &lt; {@link #size()}; i++) {
+	 *          hash = {@link MurmurHash#update MurmurHash.update}(hash, {@link #getReturnState getReturnState}(i));
 	 *      }
 	 *
-	 *      hash = {@link MurmurHash#finish}(hash, 2 * {@link #size()});
+	 *      hash = {@link MurmurHash#finish MurmurHash.finish}(hash, 2 * {@link #size()});
 	 *      return hash;
 	 *  }
 	 * </pre>
@@ -95,7 +93,7 @@ public abstract class PredictionContext {
 	/** Convert a {@link RuleContext} tree to a {@link PredictionContext} graph.
 	 *  Return {@link #EMPTY} if {@code outerContext} is empty or null.
 	 */
-	public static PredictionContext fromRuleContext(@NotNull ATN atn, RuleContext outerContext) {
+	public static PredictionContext fromRuleContext(ATN atn, RuleContext outerContext) {
 		if ( outerContext==null ) outerContext = RuleContext.EMPTY;
 
 		// if we are in RuleContext of start rule, s, then PredictionContext
@@ -203,31 +201,23 @@ public abstract class PredictionContext {
 	/**
 	 * Merge two {@link SingletonPredictionContext} instances.
 	 *
-	 * <p/>
+	 * <p>Stack tops equal, parents merge is same; return left graph.<br>
+	 * <embed src="images/SingletonMerge_SameRootSamePar.svg" type="image/svg+xml"/></p>
 	 *
-	 * Stack tops equal, parents merge is same; return left graph.<br/>
-	 * <embed src="images/SingletonMerge_SameRootSamePar.svg" type="image/svg+xml"/>
-	 *
-	 * <p/>
-	 *
-	 * Same stack top, parents differ; merge parents giving array node, then
+	 * <p>Same stack top, parents differ; merge parents giving array node, then
 	 * remainders of those graphs. A new root node is created to point to the
-	 * merged parents.<br/>
-	 * <embed src="images/SingletonMerge_SameRootDiffPar.svg" type="image/svg+xml"/>
+	 * merged parents.<br>
+	 * <embed src="images/SingletonMerge_SameRootDiffPar.svg" type="image/svg+xml"/></p>
 	 *
-	 * <p/>
-	 *
-	 * Different stack tops pointing to same parent. Make array node for the
+	 * <p>Different stack tops pointing to same parent. Make array node for the
 	 * root where both element in the root point to the same (original)
-	 * parent.<br/>
-	 * <embed src="images/SingletonMerge_DiffRootSamePar.svg" type="image/svg+xml"/>
+	 * parent.<br>
+	 * <embed src="images/SingletonMerge_DiffRootSamePar.svg" type="image/svg+xml"/></p>
 	 *
-	 * <p/>
-	 *
-	 * Different stack tops pointing to different parents. Make array node for
+	 * <p>Different stack tops pointing to different parents. Make array node for
 	 * the root where each element points to the corresponding original
-	 * parent.<br/>
-	 * <embed src="images/SingletonMerge_DiffRootDiffPar.svg" type="image/svg+xml"/>
+	 * parent.<br>
+	 * <embed src="images/SingletonMerge_DiffRootDiffPar.svg" type="image/svg+xml"/></p>
 	 *
 	 * @param a the first {@link SingletonPredictionContext}
 	 * @param b the second {@link SingletonPredictionContext}
@@ -308,43 +298,31 @@ public abstract class PredictionContext {
 	 *
 	 * <h2>Local-Context Merges</h2>
 	 *
-	 * These local-context merge operations are used when {@code rootIsWildcard}
-	 * is true.
+	 * <p>These local-context merge operations are used when {@code rootIsWildcard}
+	 * is true.</p>
 	 *
-	 * <p/>
+	 * <p>{@link #EMPTY} is superset of any graph; return {@link #EMPTY}.<br>
+	 * <embed src="images/LocalMerge_EmptyRoot.svg" type="image/svg+xml"/></p>
 	 *
-	 * {@link #EMPTY} is superset of any graph; return {@link #EMPTY}.<br/>
-	 * <embed src="images/LocalMerge_EmptyRoot.svg" type="image/svg+xml"/>
+	 * <p>{@link #EMPTY} and anything is {@code #EMPTY}, so merged parent is
+	 * {@code #EMPTY}; return left graph.<br>
+	 * <embed src="images/LocalMerge_EmptyParent.svg" type="image/svg+xml"/></p>
 	 *
-	 * <p/>
-	 *
-	 * {@link #EMPTY} and anything is {@code #EMPTY}, so merged parent is
-	 * {@code #EMPTY}; return left graph.<br/>
-	 * <embed src="images/LocalMerge_EmptyParent.svg" type="image/svg+xml"/>
-	 *
-	 * <p/>
-	 *
-	 * Special case of last merge if local context.<br/>
-	 * <embed src="images/LocalMerge_DiffRoots.svg" type="image/svg+xml"/>
+	 * <p>Special case of last merge if local context.<br>
+	 * <embed src="images/LocalMerge_DiffRoots.svg" type="image/svg+xml"/></p>
 	 *
 	 * <h2>Full-Context Merges</h2>
 	 *
-	 * These full-context merge operations are used when {@code rootIsWildcard}
-	 * is false.
+	 * <p>These full-context merge operations are used when {@code rootIsWildcard}
+	 * is false.</p>
 	 *
-	 * <p/>
+	 * <p><embed src="images/FullMerge_EmptyRoots.svg" type="image/svg+xml"/></p>
 	 *
-	 * <embed src="images/FullMerge_EmptyRoots.svg" type="image/svg+xml"/>
+	 * <p>Must keep all contexts; {@link #EMPTY} in array is a special value (and
+	 * null parent).<br>
+	 * <embed src="images/FullMerge_EmptyRoot.svg" type="image/svg+xml"/></p>
 	 *
-	 * <p/>
-	 *
-	 * Must keep all contexts; {@link #EMPTY} in array is a special value (and
-	 * null parent).<br/>
-	 * <embed src="images/FullMerge_EmptyRoot.svg" type="image/svg+xml"/>
-	 *
-	 * <p/>
-	 *
-	 * <embed src="images/FullMerge_SameRoot.svg" type="image/svg+xml"/>
+	 * <p><embed src="images/FullMerge_SameRoot.svg" type="image/svg+xml"/></p>
 	 *
 	 * @param a the first {@link SingletonPredictionContext}
 	 * @param b the second {@link SingletonPredictionContext}
@@ -382,31 +360,21 @@ public abstract class PredictionContext {
 	/**
 	 * Merge two {@link ArrayPredictionContext} instances.
 	 *
-	 * <p/>
+	 * <p>Different tops, different parents.<br>
+	 * <embed src="images/ArrayMerge_DiffTopDiffPar.svg" type="image/svg+xml"/></p>
 	 *
-	 * Different tops, different parents.<br/>
-	 * <embed src="images/ArrayMerge_DiffTopDiffPar.svg" type="image/svg+xml"/>
+	 * <p>Shared top, same parents.<br>
+	 * <embed src="images/ArrayMerge_ShareTopSamePar.svg" type="image/svg+xml"/></p>
 	 *
-	 * <p/>
+	 * <p>Shared top, different parents.<br>
+	 * <embed src="images/ArrayMerge_ShareTopDiffPar.svg" type="image/svg+xml"/></p>
 	 *
-	 * Shared top, same parents.<br/>
-	 * <embed src="images/ArrayMerge_ShareTopSamePar.svg" type="image/svg+xml"/>
+	 * <p>Shared top, all shared parents.<br>
+	 * <embed src="images/ArrayMerge_ShareTopSharePar.svg" type="image/svg+xml"/></p>
 	 *
-	 * <p/>
-	 *
-	 * Shared top, different parents.<br/>
-	 * <embed src="images/ArrayMerge_ShareTopDiffPar.svg" type="image/svg+xml"/>
-	 *
-	 * <p/>
-	 *
-	 * Shared top, all shared parents.<br/>
-	 * <embed src="images/ArrayMerge_ShareTopSharePar.svg" type="image/svg+xml"/>
-	 *
-	 * <p/>
-	 *
-	 * Equal tops, merge parents and reduce top to
-	 * {@link SingletonPredictionContext}.<br/>
-	 * <embed src="images/ArrayMerge_EqualTop.svg" type="image/svg+xml"/>
+	 * <p>Equal tops, merge parents and reduce top to
+	 * {@link SingletonPredictionContext}.<br>
+	 * <embed src="images/ArrayMerge_EqualTop.svg" type="image/svg+xml"/></p>
 	 */
 	public static PredictionContext mergeArrays(
 		ArrayPredictionContext a,
@@ -595,9 +563,9 @@ public abstract class PredictionContext {
 
 	// From Sam
 	public static PredictionContext getCachedContext(
-		@NotNull PredictionContext context,
-		@NotNull PredictionContextCache contextCache,
-		@NotNull IdentityHashMap<PredictionContext, PredictionContext> visited)
+		PredictionContext context,
+		PredictionContextCache contextCache,
+		IdentityHashMap<PredictionContext, PredictionContext> visited)
 	{
 		if (context.isEmpty()) {
 			return context;
@@ -700,7 +668,7 @@ public abstract class PredictionContext {
 		}
 	}
 
-	public String toString(@Nullable Recognizer<?,?> recog) {
+	public String toString(Recognizer<?,?> recog) {
 		return toString();
 //		return toString(recog, ParserRuleContext.EMPTY);
 	}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/atn/PredictionContextCache.java b/runtime/Java/src/org/antlr/v4/runtime/atn/PredictionContextCache.java
index 55af6c8ce..b9d12e4fc 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/atn/PredictionContextCache.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/atn/PredictionContextCache.java
@@ -38,7 +38,7 @@ import java.util.Map;
  *  can be used for both lexers and parsers.
  */
 public class PredictionContextCache {
-	protected Map<PredictionContext, PredictionContext> cache =
+	protected final Map<PredictionContext, PredictionContext> cache =
 		new HashMap<PredictionContext, PredictionContext>();
 
 	/** Add a context to the cache and return it. If the context already exists,
diff --git a/runtime/Java/src/org/antlr/v4/runtime/atn/PredictionMode.java b/runtime/Java/src/org/antlr/v4/runtime/atn/PredictionMode.java
index 246f55d11..e2e0f8ff7 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/atn/PredictionMode.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/atn/PredictionMode.java
@@ -33,7 +33,6 @@ package org.antlr.v4.runtime.atn;
 import org.antlr.v4.runtime.misc.AbstractEqualityComparator;
 import org.antlr.v4.runtime.misc.FlexibleHashMap;
 import org.antlr.v4.runtime.misc.MurmurHash;
-import org.antlr.v4.runtime.misc.NotNull;
 
 import java.util.BitSet;
 import java.util.Collection;
@@ -41,26 +40,69 @@ import java.util.HashMap;
 import java.util.Iterator;
 import java.util.Map;
 
+/**
+ * This enumeration defines the prediction modes available in ANTLR 4 along with
+ * utility methods for analyzing configuration sets for conflicts and/or
+ * ambiguities.
+ */
 public enum PredictionMode {
-	/** Do only local context prediction (SLL style) and using
-	 *  heuristic which almost always works but is much faster
-	 *  than precise answer.
+	/**
+	 * The SLL(*) prediction mode. This prediction mode ignores the current
+	 * parser context when making predictions. This is the fastest prediction
+	 * mode, and provides correct results for many grammars. This prediction
+	 * mode is more powerful than the prediction mode provided by ANTLR 3, but
+	 * may result in syntax errors for grammar and input combinations which are
+	 * not SLL.
+	 *
+	 * <p>
+	 * When using this prediction mode, the parser will either return a correct
+	 * parse tree (i.e. the same parse tree that would be returned with the
+	 * {@link #LL} prediction mode), or it will report a syntax error. If a
+	 * syntax error is encountered when using the {@link #SLL} prediction mode,
+	 * it may be due to either an actual syntax error in the input or indicate
+	 * that the particular combination of grammar and input requires the more
+	 * powerful {@link #LL} prediction abilities to complete successfully.</p>
+	 *
+	 * <p>
+	 * This prediction mode does not provide any guarantees for prediction
+	 * behavior for syntactically-incorrect inputs.</p>
 	 */
 	SLL,
-
-	/** Full LL(*) that always gets right answer. For speed
-	 *  reasons, we terminate the prediction process when we know for
-	 *  sure which alt to predict. We don't always know what
-	 *  the ambiguity is in this mode.
+	/**
+	 * The LL(*) prediction mode. This prediction mode allows the current parser
+	 * context to be used for resolving SLL conflicts that occur during
+	 * prediction. This is the fastest prediction mode that guarantees correct
+	 * parse results for all combinations of grammars with syntactically correct
+	 * inputs.
+	 *
+	 * <p>
+	 * When using this prediction mode, the parser will make correct decisions
+	 * for all syntactically-correct grammar and input combinations. However, in
+	 * cases where the grammar is truly ambiguous this prediction mode might not
+	 * report a precise answer for <em>exactly which</em> alternatives are
+	 * ambiguous.</p>
+	 *
+	 * <p>
+	 * This prediction mode does not provide any guarantees for prediction
+	 * behavior for syntactically-incorrect inputs.</p>
 	 */
 	LL,
-
-	/** Tell the full LL prediction algorithm to pursue lookahead until
-	 *  it has uniquely predicted an alternative without conflict or it's
-	 *  certain that it's found an ambiguous input sequence.  when this
-	 *  variable is false. When true, the prediction process will
-	 *  continue looking for the exact ambiguous sequence even if
-	 *  it has already figured out which alternative to predict.
+	/**
+	 * The LL(*) prediction mode with exact ambiguity detection. In addition to
+	 * the correctness guarantees provided by the {@link #LL} prediction mode,
+	 * this prediction mode instructs the prediction algorithm to determine the
+	 * complete and exact set of ambiguous alternatives for every ambiguous
+	 * decision encountered while parsing.
+	 *
+	 * <p>
+	 * This prediction mode may be used for diagnosing ambiguities during
+	 * grammar development. Due to the performance overhead of calculating sets
+	 * of ambiguous alternatives, this prediction mode should be avoided when
+	 * the exact results are not necessary.</p>
+	 *
+	 * <p>
+	 * This prediction mode does not provide any guarantees for prediction
+	 * behavior for syntactically-incorrect inputs.</p>
 	 */
 	LL_EXACT_AMBIG_DETECTION;
 
@@ -77,7 +119,10 @@ public enum PredictionMode {
 		private AltAndContextConfigEqualityComparator() {
 		}
 
-		/** Code is function of (s, _, ctx, _) */
+		/**
+		 * The hash code is only a function of the {@link ATNState#stateNumber}
+		 * and {@link ATNConfig#context}.
+		 */
 		@Override
 		public int hashCode(ATNConfig o) {
 			int hashCode = MurmurHash.initialize(7);
@@ -99,137 +144,96 @@ public enum PredictionMode {
 	/**
 	 * Computes the SLL prediction termination condition.
 	 *
-	 * <p/>
-	 *
+	 * <p>
 	 * This method computes the SLL prediction termination condition for both of
-	 * the following cases.
+	 * the following cases.</p>
 	 *
 	 * <ul>
 	 * <li>The usual SLL+LL fallback upon SLL conflict</li>
 	 * <li>Pure SLL without LL fallback</li>
 	 * </ul>
 	 *
-	 * <p/>
+	 * <p><strong>COMBINED SLL+LL PARSING</strong></p>
 	 *
-	 * <strong>COMBINED SLL+LL PARSING</strong>
-	 *
-	 * <p/>
-	 *
-	 * When LL-fallback is enabled upon SLL conflict, correct predictions are
+	 * <p>When LL-fallback is enabled upon SLL conflict, correct predictions are
 	 * ensured regardless of how the termination condition is computed by this
 	 * method. Due to the substantially higher cost of LL prediction, the
 	 * prediction should only fall back to LL when the additional lookahead
-	 * cannot lead to a unique SLL prediction.
+	 * cannot lead to a unique SLL prediction.</p>
 	 *
-	 * <p/>
-	 *
-	 * Assuming combined SLL+LL parsing, an SLL configuration set with only
+	 * <p>Assuming combined SLL+LL parsing, an SLL configuration set with only
 	 * conflicting subsets should fall back to full LL, even if the
 	 * configuration sets don't resolve to the same alternative (e.g.
 	 * {@code {1,2}} and {@code {3,4}}. If there is at least one non-conflicting
 	 * configuration, SLL could continue with the hopes that more lookahead will
-	 * resolve via one of those non-conflicting configurations.
+	 * resolve via one of those non-conflicting configurations.</p>
 	 *
-	 * <p/>
-	 *
-	 * Here's the prediction termination rule them: SLL (for SLL+LL parsing)
+	 * <p>Here's the prediction termination rule them: SLL (for SLL+LL parsing)
 	 * stops when it sees only conflicting configuration subsets. In contrast,
-	 * full LL keeps going when there is uncertainty.
+	 * full LL keeps going when there is uncertainty.</p>
 	 *
-	 * <p/>
+	 * <p><strong>HEURISTIC</strong></p>
 	 *
-	 * <strong>HEURISTIC</strong>
-	 *
-	 * <p/>
-	 *
-	 * As a heuristic, we stop prediction when we see any conflicting subset
+	 * <p>As a heuristic, we stop prediction when we see any conflicting subset
 	 * unless we see a state that only has one alternative associated with it.
 	 * The single-alt-state thing lets prediction continue upon rules like
-	 * (otherwise, it would admit defeat too soon):
+	 * (otherwise, it would admit defeat too soon):</p>
 	 *
-	 * <p/>
+	 * <p>{@code [12|1|[], 6|2|[], 12|2|[]]. s : (ID | ID ID?) ';' ;}</p>
 	 *
-	 * {@code [12|1|[], 6|2|[], 12|2|[]]. s : (ID | ID ID?) ';' ;}
-	 *
-	 * <p/>
-	 *
-	 * When the ATN simulation reaches the state before {@code ';'}, it has a
+	 * <p>When the ATN simulation reaches the state before {@code ';'}, it has a
 	 * DFA state that looks like: {@code [12|1|[], 6|2|[], 12|2|[]]}. Naturally
 	 * {@code 12|1|[]} and {@code 12|2|[]} conflict, but we cannot stop
 	 * processing this node because alternative to has another way to continue,
-	 * via {@code [6|2|[]]}.
+	 * via {@code [6|2|[]]}.</p>
 	 *
-	 * <p/>
+	 * <p>It also let's us continue for this rule:</p>
 	 *
-	 * It also let's us continue for this rule:
+	 * <p>{@code [1|1|[], 1|2|[], 8|3|[]] a : A | A | A B ;}</p>
 	 *
-	 * <p/>
-	 *
-	 * {@code [1|1|[], 1|2|[], 8|3|[]] a : A | A | A B ;}
-	 *
-	 * <p/>
-	 *
-	 * After matching input A, we reach the stop state for rule A, state 1.
+	 * <p>After matching input A, we reach the stop state for rule A, state 1.
 	 * State 8 is the state right before B. Clearly alternatives 1 and 2
 	 * conflict and no amount of further lookahead will separate the two.
 	 * However, alternative 3 will be able to continue and so we do not stop
 	 * working on this state. In the previous example, we're concerned with
 	 * states associated with the conflicting alternatives. Here alt 3 is not
 	 * associated with the conflicting configs, but since we can continue
-	 * looking for input reasonably, don't declare the state done.
+	 * looking for input reasonably, don't declare the state done.</p>
 	 *
-	 * <p/>
+	 * <p><strong>PURE SLL PARSING</strong></p>
 	 *
-	 * <strong>PURE SLL PARSING</strong>
-	 *
-	 * <p/>
-	 *
-	 * To handle pure SLL parsing, all we have to do is make sure that we
+	 * <p>To handle pure SLL parsing, all we have to do is make sure that we
 	 * combine stack contexts for configurations that differ only by semantic
-	 * predicate. From there, we can do the usual SLL termination heuristic.
+	 * predicate. From there, we can do the usual SLL termination heuristic.</p>
 	 *
-	 * <p/>
+	 * <p><strong>PREDICATES IN SLL+LL PARSING</strong></p>
 	 *
-	 * <strong>PREDICATES IN SLL+LL PARSING</strong>
-	 *
-	 * <p/>
-	 *
-	 * SLL decisions don't evaluate predicates until after they reach DFA stop
+	 * <p>SLL decisions don't evaluate predicates until after they reach DFA stop
 	 * states because they need to create the DFA cache that works in all
 	 * semantic situations. In contrast, full LL evaluates predicates collected
 	 * during start state computation so it can ignore predicates thereafter.
 	 * This means that SLL termination detection can totally ignore semantic
-	 * predicates.
+	 * predicates.</p>
 	 *
-	 * <p/>
-	 *
-	 * Implementation-wise, {@link ATNConfigSet} combines stack contexts but not
+	 * <p>Implementation-wise, {@link ATNConfigSet} combines stack contexts but not
 	 * semantic predicate contexts so we might see two configurations like the
-	 * following.
+	 * following.</p>
 	 *
-	 * <p/>
+	 * <p>{@code (s, 1, x, {}), (s, 1, x', {p})}</p>
 	 *
-	 * {@code (s, 1, x, {}), (s, 1, x', {p})}
-	 *
-	 * <p/>
-	 *
-	 * Before testing these configurations against others, we have to merge
+	 * <p>Before testing these configurations against others, we have to merge
 	 * {@code x} and {@code x'} (without modifying the existing configurations).
 	 * For example, we test {@code (x+x')==x''} when looking for conflicts in
-	 * the following configurations.
+	 * the following configurations.</p>
 	 *
-	 * <p/>
+	 * <p>{@code (s, 1, x, {}), (s, 1, x', {p}), (s, 2, x'', {})}</p>
 	 *
-	 * {@code (s, 1, x, {}), (s, 1, x', {p}), (s, 2, x'', {})}
-	 *
-	 * <p/>
-	 *
-	 * If the configuration set has predicates (as indicated by
+	 * <p>If the configuration set has predicates (as indicated by
 	 * {@link ATNConfigSet#hasSemanticContext}), this algorithm makes a copy of
 	 * the configurations to strip out all of the predicates so that a standard
-	 * {@link ATNConfigSet} will merge everything ignoring predicates.
+	 * {@link ATNConfigSet} will merge everything ignoring predicates.</p>
 	 */
-	public static boolean hasSLLConflictTerminatingPrediction(PredictionMode mode, @NotNull ATNConfigSet configs) {
+	public static boolean hasSLLConflictTerminatingPrediction(PredictionMode mode, ATNConfigSet configs) {
 		/* Configs in rule stop states indicate reaching the end of the decision
 		 * rule (local context) or end of start rule (full context). If all
 		 * configs meet this condition, then none of the configurations is able
@@ -294,7 +298,7 @@ public enum PredictionMode {
 	 * @return {@code true} if all configurations in {@code configs} are in a
 	 * {@link RuleStopState}, otherwise {@code false}
 	 */
-	public static boolean allConfigsInRuleStopStates(@NotNull ATNConfigSet configs) {
+	public static boolean allConfigsInRuleStopStates(ATNConfigSet configs) {
 		for (ATNConfig config : configs) {
 			if (!(config.state instanceof RuleStopState)) {
 				return false;
@@ -307,86 +311,62 @@ public enum PredictionMode {
 	/**
 	 * Full LL prediction termination.
 	 *
-	 * <p/>
-	 *
-	 * Can we stop looking ahead during ATN simulation or is there some
+	 * <p>Can we stop looking ahead during ATN simulation or is there some
 	 * uncertainty as to which alternative we will ultimately pick, after
 	 * consuming more input? Even if there are partial conflicts, we might know
 	 * that everything is going to resolve to the same minimum alternative. That
 	 * means we can stop since no more lookahead will change that fact. On the
 	 * other hand, there might be multiple conflicts that resolve to different
 	 * minimums. That means we need more look ahead to decide which of those
-	 * alternatives we should predict.
+	 * alternatives we should predict.</p>
 	 *
-	 * <p/>
-	 *
-	 * The basic idea is to split the set of configurations {@code C}, into
+	 * <p>The basic idea is to split the set of configurations {@code C}, into
 	 * conflicting subsets {@code (s, _, ctx, _)} and singleton subsets with
 	 * non-conflicting configurations. Two configurations conflict if they have
 	 * identical {@link ATNConfig#state} and {@link ATNConfig#context} values
 	 * but different {@link ATNConfig#alt} value, e.g. {@code (s, i, ctx, _)}
-	 * and {@code (s, j, ctx, _)} for {@code i!=j}.
+	 * and {@code (s, j, ctx, _)} for {@code i!=j}.</p>
 	 *
-	 * <p/>
+	 * <p>Reduce these configuration subsets to the set of possible alternatives.
+	 * You can compute the alternative subsets in one pass as follows:</p>
 	 *
-	 * Reduce these configuration subsets to the set of possible alternatives.
-	 * You can compute the alternative subsets in one pass as follows:
+	 * <p>{@code A_s,ctx = {i | (s, i, ctx, _)}} for each configuration in
+	 * {@code C} holding {@code s} and {@code ctx} fixed.</p>
 	 *
-	 * <p/>
-	 *
-	 * {@code A_s,ctx = {i | (s, i, ctx, _)}} for each configuration in
-	 * {@code C} holding {@code s} and {@code ctx} fixed.
-	 *
-	 * <p/>
-	 *
-	 * Or in pseudo-code, for each configuration {@code c} in {@code C}:
+	 * <p>Or in pseudo-code, for each configuration {@code c} in {@code C}:</p>
 	 *
 	 * <pre>
 	 * map[c] U= c.{@link ATNConfig#alt alt} # map hash/equals uses s and x, not
 	 * alt and not pred
 	 * </pre>
 	 *
-	 * <p/>
+	 * <p>The values in {@code map} are the set of {@code A_s,ctx} sets.</p>
 	 *
-	 * The values in {@code map} are the set of {@code A_s,ctx} sets.
+	 * <p>If {@code |A_s,ctx|=1} then there is no conflict associated with
+	 * {@code s} and {@code ctx}.</p>
 	 *
-	 * <p/>
-	 *
-	 * If {@code |A_s,ctx|=1} then there is no conflict associated with
-	 * {@code s} and {@code ctx}.
-	 *
-	 * <p/>
-	 *
-	 * Reduce the subsets to singletons by choosing a minimum of each subset. If
+	 * <p>Reduce the subsets to singletons by choosing a minimum of each subset. If
 	 * the union of these alternative subsets is a singleton, then no amount of
 	 * more lookahead will help us. We will always pick that alternative. If,
 	 * however, there is more than one alternative, then we are uncertain which
 	 * alternative to predict and must continue looking for resolution. We may
 	 * or may not discover an ambiguity in the future, even if there are no
-	 * conflicting subsets this round.
+	 * conflicting subsets this round.</p>
 	 *
-	 * <p/>
-	 *
-	 * The biggest sin is to terminate early because it means we've made a
+	 * <p>The biggest sin is to terminate early because it means we've made a
 	 * decision but were uncertain as to the eventual outcome. We haven't used
 	 * enough lookahead. On the other hand, announcing a conflict too late is no
 	 * big deal; you will still have the conflict. It's just inefficient. It
-	 * might even look until the end of file.
+	 * might even look until the end of file.</p>
 	 *
-	 * <p/>
-	 *
-	 * No special consideration for semantic predicates is required because
+	 * <p>No special consideration for semantic predicates is required because
 	 * predicates are evaluated on-the-fly for full LL prediction, ensuring that
 	 * no configuration contains a semantic context during the termination
-	 * check.
+	 * check.</p>
 	 *
-	 * <p/>
+	 * <p><strong>CONFLICTING CONFIGS</strong></p>
 	 *
-	 * <strong>CONFLICTING CONFIGS</strong>
-	 *
-	 * <p/>
-	 *
-	 * Two configurations {@code (s, i, x)} and {@code (s, j, x')}, conflict
+	 * <p>Two configurations {@code (s, i, x)} and {@code (s, j, x')}, conflict
 	 * when {@code i!=j} but {@code x=x'}. Because we merge all
 	 * {@code (s, i, _)} configurations together, that means that there are at
 	 * most {@code n} configurations associated with state {@code s} for
@@ -399,38 +379,28 @@ public enum PredictionMode {
 	 * others resolve to {@code min(i)} as well. However, if {@code x} is
 	 * associated with {@code j>i} then at least one stack configuration for
 	 * {@code j} is not in conflict with alternative {@code i}. The algorithm
-	 * should keep going, looking for more lookahead due to the uncertainty.
+	 * should keep going, looking for more lookahead due to the uncertainty.</p>
 	 *
-	 * <p/>
-	 *
-	 * For simplicity, I'm doing a equality check between {@code x} and
+	 * <p>For simplicity, I'm doing a equality check between {@code x} and
 	 * {@code x'} that lets the algorithm continue to consume lookahead longer
 	 * than necessary. The reason I like the equality is of course the
 	 * simplicity but also because that is the test you need to detect the
-	 * alternatives that are actually in conflict.
+	 * alternatives that are actually in conflict.</p>
 	 *
-	 * <p/>
+	 * <p><strong>CONTINUE/STOP RULE</strong></p>
 	 *
-	 * <strong>CONTINUE/STOP RULE</strong>
-	 *
-	 * <p/>
-	 *
-	 * Continue if union of resolved alternative sets from non-conflicting and
+	 * <p>Continue if union of resolved alternative sets from non-conflicting and
 	 * conflicting alternative subsets has more than one alternative. We are
-	 * uncertain about which alternative to predict.
+	 * uncertain about which alternative to predict.</p>
 	 *
-	 * <p/>
-	 *
-	 * The complete set of alternatives, {@code [i for (_,i,_)]}, tells us which
+	 * <p>The complete set of alternatives, {@code [i for (_,i,_)]}, tells us which
 	 * alternatives are still in the running for the amount of input we've
 	 * consumed at this point. The conflicting sets let us to strip away
 	 * configurations that won't lead to more states because we resolve
 	 * conflicts to the configuration with a minimum alternate for the
-	 * conflicting set.
+	 * conflicting set.</p>
 	 *
-	 * <p/>
-	 *
-	 * <strong>CASES</strong>
+	 * <p><strong>CASES</strong></p>
 	 *
 	 * <ul>
 	 *
@@ -462,30 +432,24 @@ public enum PredictionMode {
 	 *
 	 * </ul>
 	 *
-	 * <strong>EXACT AMBIGUITY DETECTION</strong>
+	 * <p><strong>EXACT AMBIGUITY DETECTION</strong></p>
 	 *
-	 * <p/>
+	 * <p>If all states report the same conflicting set of alternatives, then we
+	 * know we have the exact ambiguity set.</p>
 	 *
-	 * If all states report the same conflicting set of alternatives, then we
-	 * know we have the exact ambiguity set.
+	 * <p><code>|A_<em>i</em>|&gt;1</code> and
+	 * <code>A_<em>i</em> = A_<em>j</em></code> for all <em>i</em>, <em>j</em>.</p>
 	 *
-	 * <p/>
-	 *
-	 * <code>|A_<em>i</em>|&gt;1</code> and
-	 * <code>A_<em>i</em> = A_<em>j</em></code> for all <em>i</em>, <em>j</em>.
-	 *
-	 * <p/>
-	 *
-	 * In other words, we continue examining lookahead until all {@code A_i}
+	 * <p>In other words, we continue examining lookahead until all {@code A_i}
 	 * have more than one alternative and all {@code A_i} are the same. If
 	 * {@code A={{1,2}, {1,3}}}, then regular LL prediction would terminate
 	 * because the resolved set is {@code {1}}. To determine what the real
 	 * ambiguity is, we have to know whether the ambiguity is between one and
 	 * two or one and three so we keep going. We can only stop prediction when
 	 * we need exact ambiguity detection when the sets look like
-	 * {@code A={{1,2}}} or {@code {{1,2},{1,2}}}, etc...
+	 * {@code A={{1,2}}} or {@code {{1,2},{1,2}}}, etc...</p>
 	 */
-	public static int resolvesToJustOneViableAlt(@NotNull Collection<BitSet> altsets) {
+	public static int resolvesToJustOneViableAlt(Collection<BitSet> altsets) {
 		return getSingleViableAlt(altsets);
 	}
 
@@ -497,7 +461,7 @@ public enum PredictionMode {
 	 * @return {@code true} if every {@link BitSet} in {@code altsets} has
 	 * {@link BitSet#cardinality cardinality} &gt; 1, otherwise {@code false}
 	 */
-	public static boolean allSubsetsConflict(@NotNull Collection<BitSet> altsets) {
+	public static boolean allSubsetsConflict(Collection<BitSet> altsets) {
 		return !hasNonConflictingAltSet(altsets);
 	}
 
@@ -509,7 +473,7 @@ public enum PredictionMode {
 	 * @return {@code true} if {@code altsets} contains a {@link BitSet} with
 	 * {@link BitSet#cardinality cardinality} 1, otherwise {@code false}
 	 */
-	public static boolean hasNonConflictingAltSet(@NotNull Collection<BitSet> altsets) {
+	public static boolean hasNonConflictingAltSet(Collection<BitSet> altsets) {
 		for (BitSet alts : altsets) {
 			if ( alts.cardinality()==1 ) {
 				return true;
@@ -526,7 +490,7 @@ public enum PredictionMode {
 	 * @return {@code true} if {@code altsets} contains a {@link BitSet} with
 	 * {@link BitSet#cardinality cardinality} &gt; 1, otherwise {@code false}
 	 */
-	public static boolean hasConflictingAltSet(@NotNull Collection<BitSet> altsets) {
+	public static boolean hasConflictingAltSet(Collection<BitSet> altsets) {
 		for (BitSet alts : altsets) {
 			if ( alts.cardinality()>1 ) {
 				return true;
@@ -542,7 +506,7 @@ public enum PredictionMode {
 	 * @return {@code true} if every member of {@code altsets} is equal to the
 	 * others, otherwise {@code false}
 	 */
-	public static boolean allSubsetsEqual(@NotNull Collection<BitSet> altsets) {
+	public static boolean allSubsetsEqual(Collection<BitSet> altsets) {
 		Iterator<BitSet> it = altsets.iterator();
 		BitSet first = it.next();
 		while ( it.hasNext() ) {
@@ -559,7 +523,7 @@ public enum PredictionMode {
 	 *
 	 * @param altsets a collection of alternative subsets
 	 */
-	public static int getUniqueAlt(@NotNull Collection<BitSet> altsets) {
+	public static int getUniqueAlt(Collection<BitSet> altsets) {
 		BitSet all = getAlts(altsets);
 		if ( all.cardinality()==1 ) return all.nextSetBit(0);
 		return ATN.INVALID_ALT_NUMBER;
@@ -573,7 +537,7 @@ public enum PredictionMode {
 	 * @param altsets a collection of alternative subsets
 	 * @return the set of represented alternatives in {@code altsets}
 	 */
-	public static BitSet getAlts(@NotNull Collection<BitSet> altsets) {
+	public static BitSet getAlts(Collection<BitSet> altsets) {
 		BitSet all = new BitSet();
 		for (BitSet alts : altsets) {
 			all.or(alts);
@@ -581,6 +545,15 @@ public enum PredictionMode {
 		return all;
 	}
 
+	/** Get union of all alts from configs. @since 4.5.1 */
+	public static BitSet getAlts(ATNConfigSet configs) {
+		BitSet alts = new BitSet();
+		for (ATNConfig config : configs) {
+			alts.set(config.alt);
+		}
+		return alts;
+	}
+
 	/**
 	 * This function gets the conflicting alt subsets from a configuration set.
 	 * For each configuration {@code c} in {@code configs}:
@@ -590,7 +563,6 @@ public enum PredictionMode {
 	 * alt and not pred
 	 * </pre>
 	 */
-	@NotNull
 	public static Collection<BitSet> getConflictingAltSubsets(ATNConfigSet configs) {
 		AltAndContextMap configToAlts = new AltAndContextMap();
 		for (ATNConfig c : configs) {
@@ -612,8 +584,7 @@ public enum PredictionMode {
 	 * map[c.{@link ATNConfig#state state}] U= c.{@link ATNConfig#alt alt}
 	 * </pre>
 	 */
-	@NotNull
-	public static Map<ATNState, BitSet> getStateToAltMap(@NotNull ATNConfigSet configs) {
+	public static Map<ATNState, BitSet> getStateToAltMap(ATNConfigSet configs) {
 		Map<ATNState, BitSet> m = new HashMap<ATNState, BitSet>();
 		for (ATNConfig c : configs) {
 			BitSet alts = m.get(c.state);
@@ -626,7 +597,7 @@ public enum PredictionMode {
 		return m;
 	}
 
-	public static boolean hasStateAssociatedWithOneAlt(@NotNull ATNConfigSet configs) {
+	public static boolean hasStateAssociatedWithOneAlt(ATNConfigSet configs) {
 		Map<ATNState, BitSet> x = getStateToAltMap(configs);
 		for (BitSet alts : x.values()) {
 			if ( alts.cardinality()==1 ) return true;
@@ -634,7 +605,7 @@ public enum PredictionMode {
 		return false;
 	}
 
-	public static int getSingleViableAlt(@NotNull Collection<BitSet> altsets) {
+	public static int getSingleViableAlt(Collection<BitSet> altsets) {
 		BitSet viableAlts = new BitSet();
 		for (BitSet alts : altsets) {
 			int minAlt = alts.nextSetBit(0);
diff --git a/runtime/Java/src/org/antlr/v4/runtime/atn/ProfilingATNSimulator.java b/runtime/Java/src/org/antlr/v4/runtime/atn/ProfilingATNSimulator.java
new file mode 100644
index 000000000..20ffbd297
--- /dev/null
+++ b/runtime/Java/src/org/antlr/v4/runtime/atn/ProfilingATNSimulator.java
@@ -0,0 +1,251 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+
+package org.antlr.v4.runtime.atn;
+
+import org.antlr.v4.runtime.Parser;
+import org.antlr.v4.runtime.ParserRuleContext;
+import org.antlr.v4.runtime.TokenStream;
+import org.antlr.v4.runtime.dfa.DFA;
+import org.antlr.v4.runtime.dfa.DFAState;
+
+import java.util.BitSet;
+
+/**
+ * @since 4.3
+ */
+public class ProfilingATNSimulator extends ParserATNSimulator {
+	protected final DecisionInfo[] decisions;
+	protected int numDecisions;
+
+	protected int _sllStopIndex;
+	protected int _llStopIndex;
+
+	protected int currentDecision;
+	protected DFAState currentState;
+
+ 	/** At the point of LL failover, we record how SLL would resolve the conflict so that
+	 *  we can determine whether or not a decision / input pair is context-sensitive.
+	 *  If LL gives a different result than SLL's predicted alternative, we have a
+	 *  context sensitivity for sure. The converse is not necessarily true, however.
+	 *  It's possible that after conflict resolution chooses minimum alternatives,
+	 *  SLL could get the same answer as LL. Regardless of whether or not the result indicates
+	 *  an ambiguity, it is not treated as a context sensitivity because LL prediction
+	 *  was not required in order to produce a correct prediction for this decision and input sequence.
+	 *  It may in fact still be a context sensitivity but we don't know by looking at the
+	 *  minimum alternatives for the current input.
+ 	 */
+	protected int conflictingAltResolvedBySLL;
+
+	public ProfilingATNSimulator(Parser parser) {
+		super(parser,
+				parser.getInterpreter().atn,
+				parser.getInterpreter().decisionToDFA,
+				parser.getInterpreter().sharedContextCache);
+		numDecisions = atn.decisionToState.size();
+		decisions = new DecisionInfo[numDecisions];
+		for (int i=0; i<numDecisions; i++) {
+			decisions[i] = new DecisionInfo(i);
+		}
+	}
+
+	@Override
+	public int adaptivePredict(TokenStream input, int decision, ParserRuleContext outerContext) {
+		try {
+			this._sllStopIndex = -1;
+			this._llStopIndex = -1;
+			this.currentDecision = decision;
+			long start = System.nanoTime(); // expensive but useful info
+			int alt = super.adaptivePredict(input, decision, outerContext);
+			long stop = System.nanoTime();
+			decisions[decision].timeInPrediction += (stop-start);
+			decisions[decision].invocations++;
+
+			int SLL_k = _sllStopIndex - _startIndex + 1;
+			decisions[decision].SLL_TotalLook += SLL_k;
+			decisions[decision].SLL_MinLook = decisions[decision].SLL_MinLook==0 ? SLL_k : Math.min(decisions[decision].SLL_MinLook, SLL_k);
+			if ( SLL_k > decisions[decision].SLL_MaxLook ) {
+				decisions[decision].SLL_MaxLook = SLL_k;
+				decisions[decision].SLL_MaxLookEvent =
+						new LookaheadEventInfo(decision, null, alt, input, _startIndex, _sllStopIndex, false);
+			}
+
+			if (_llStopIndex >= 0) {
+				int LL_k = _llStopIndex - _startIndex + 1;
+				decisions[decision].LL_TotalLook += LL_k;
+				decisions[decision].LL_MinLook = decisions[decision].LL_MinLook==0 ? LL_k : Math.min(decisions[decision].LL_MinLook, LL_k);
+				if ( LL_k > decisions[decision].LL_MaxLook ) {
+					decisions[decision].LL_MaxLook = LL_k;
+					decisions[decision].LL_MaxLookEvent =
+							new LookaheadEventInfo(decision, null, alt, input, _startIndex, _llStopIndex, true);
+				}
+			}
+
+			return alt;
+		}
+		finally {
+			this.currentDecision = -1;
+		}
+	}
+
+	@Override
+	protected DFAState getExistingTargetState(DFAState previousD, int t) {
+		// this method is called after each time the input position advances
+		// during SLL prediction
+		_sllStopIndex = _input.index();
+
+		DFAState existingTargetState = super.getExistingTargetState(previousD, t);
+		if ( existingTargetState!=null ) {
+			decisions[currentDecision].SLL_DFATransitions++; // count only if we transition over a DFA state
+			if ( existingTargetState==ERROR ) {
+				decisions[currentDecision].errors.add(
+						new ErrorInfo(currentDecision, previousD.configs, _input, _startIndex, _sllStopIndex, false)
+				);
+			}
+		}
+
+		currentState = existingTargetState;
+		return existingTargetState;
+	}
+
+	@Override
+	protected DFAState computeTargetState(DFA dfa, DFAState previousD, int t) {
+		DFAState state = super.computeTargetState(dfa, previousD, t);
+		currentState = state;
+		return state;
+	}
+
+	@Override
+	protected ATNConfigSet computeReachSet(ATNConfigSet closure, int t, boolean fullCtx) {
+		if (fullCtx) {
+			// this method is called after each time the input position advances
+			// during full context prediction
+			_llStopIndex = _input.index();
+		}
+
+		ATNConfigSet reachConfigs = super.computeReachSet(closure, t, fullCtx);
+		if (fullCtx) {
+			decisions[currentDecision].LL_ATNTransitions++; // count computation even if error
+			if ( reachConfigs!=null ) {
+			}
+			else { // no reach on current lookahead symbol. ERROR.
+				// TODO: does not handle delayed errors per getSynValidOrSemInvalidAltThatFinishedDecisionEntryRule()
+				decisions[currentDecision].errors.add(
+					new ErrorInfo(currentDecision, closure, _input, _startIndex, _llStopIndex, true)
+				);
+			}
+		}
+		else {
+			decisions[currentDecision].SLL_ATNTransitions++;
+			if ( reachConfigs!=null ) {
+			}
+			else { // no reach on current lookahead symbol. ERROR.
+				decisions[currentDecision].errors.add(
+					new ErrorInfo(currentDecision, closure, _input, _startIndex, _sllStopIndex, false)
+				);
+			}
+		}
+		return reachConfigs;
+	}
+
+	@Override
+	protected boolean evalSemanticContext(SemanticContext pred, ParserRuleContext parserCallStack, int alt, boolean fullCtx) {
+		boolean result = super.evalSemanticContext(pred, parserCallStack, alt, fullCtx);
+		if (!(pred instanceof SemanticContext.PrecedencePredicate)) {
+			boolean fullContext = _llStopIndex >= 0;
+			int stopIndex = fullContext ? _llStopIndex : _sllStopIndex;
+			decisions[currentDecision].predicateEvals.add(
+				new PredicateEvalInfo(currentDecision, _input, _startIndex, stopIndex, pred, result, alt, fullCtx)
+			);
+		}
+
+		return result;
+	}
+
+	@Override
+	protected void reportAttemptingFullContext(DFA dfa, BitSet conflictingAlts, ATNConfigSet configs, int startIndex, int stopIndex) {
+		if ( conflictingAlts!=null ) {
+			conflictingAltResolvedBySLL = conflictingAlts.nextSetBit(0);
+		}
+		else {
+			conflictingAltResolvedBySLL = configs.getAlts().nextSetBit(0);
+		}
+		decisions[currentDecision].LL_Fallback++;
+		super.reportAttemptingFullContext(dfa, conflictingAlts, configs, startIndex, stopIndex);
+	}
+
+	@Override
+	protected void reportContextSensitivity(DFA dfa, int prediction, ATNConfigSet configs, int startIndex, int stopIndex) {
+		if ( prediction != conflictingAltResolvedBySLL ) {
+			decisions[currentDecision].contextSensitivities.add(
+					new ContextSensitivityInfo(currentDecision, configs, _input, startIndex, stopIndex)
+			);
+		}
+		super.reportContextSensitivity(dfa, prediction, configs, startIndex, stopIndex);
+	}
+
+	@Override
+	protected void reportAmbiguity(DFA dfa, DFAState D, int startIndex, int stopIndex, boolean exact,
+								   BitSet ambigAlts, ATNConfigSet configs)
+	{
+		int prediction;
+		if ( ambigAlts!=null ) {
+			prediction = ambigAlts.nextSetBit(0);
+		}
+		else {
+			prediction = configs.getAlts().nextSetBit(0);
+		}
+		if ( configs.fullCtx && prediction != conflictingAltResolvedBySLL ) {
+			// Even though this is an ambiguity we are reporting, we can
+			// still detect some context sensitivities.  Both SLL and LL
+			// are showing a conflict, hence an ambiguity, but if they resolve
+			// to different minimum alternatives we have also identified a
+			// context sensitivity.
+			decisions[currentDecision].contextSensitivities.add(
+					new ContextSensitivityInfo(currentDecision, configs, _input, startIndex, stopIndex)
+			);
+		}
+		decisions[currentDecision].ambiguities.add(
+			new AmbiguityInfo(currentDecision, configs, ambigAlts,
+							  _input, startIndex, stopIndex, configs.fullCtx)
+		);
+		super.reportAmbiguity(dfa, D, startIndex, stopIndex, exact, ambigAlts, configs);
+	}
+
+	// ---------------------------------------------------------------------
+
+	public DecisionInfo[] getDecisionInfo() {
+		return decisions;
+	}
+
+	public DFAState getCurrentState() {
+		return currentState;
+	}
+}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/atn/RangeTransition.java b/runtime/Java/src/org/antlr/v4/runtime/atn/RangeTransition.java
index 6351b477c..9dbb0b192 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/atn/RangeTransition.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/atn/RangeTransition.java
@@ -31,13 +31,12 @@
 package org.antlr.v4.runtime.atn;
 
 import org.antlr.v4.runtime.misc.IntervalSet;
-import org.antlr.v4.runtime.misc.NotNull;
 
 public final class RangeTransition extends Transition {
 	public final int from;
 	public final int to;
 
-	public RangeTransition(@NotNull ATNState target, int from, int to) {
+	public RangeTransition(ATNState target, int from, int to) {
 		super(target);
 		this.from = from;
 		this.to = to;
@@ -49,7 +48,7 @@ public final class RangeTransition extends Transition {
 	}
 
 	@Override
-	@NotNull
+
 	public IntervalSet label() { return IntervalSet.of(from, to); }
 
 	@Override
@@ -58,7 +57,6 @@ public final class RangeTransition extends Transition {
 	}
 
 	@Override
-	@NotNull
 	public String toString() {
 		return "'"+(char)from+"'..'"+(char)to+"'";
 	}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/atn/RuleStartState.java b/runtime/Java/src/org/antlr/v4/runtime/atn/RuleStartState.java
index 652a0e7cb..b2105d679 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/atn/RuleStartState.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/atn/RuleStartState.java
@@ -32,7 +32,7 @@ package org.antlr.v4.runtime.atn;
 
 public final class RuleStartState extends ATNState {
 	public RuleStopState stopState;
-	public boolean isPrecedenceRule;
+	public boolean isLeftRecursiveRule;
 
 	@Override
 	public int getStateType() {
diff --git a/runtime/Java/src/org/antlr/v4/runtime/atn/RuleTransition.java b/runtime/Java/src/org/antlr/v4/runtime/atn/RuleTransition.java
index fb12ab39e..0b6da672e 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/atn/RuleTransition.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/atn/RuleTransition.java
@@ -30,8 +30,6 @@
 
 package org.antlr.v4.runtime.atn;
 
-import org.antlr.v4.runtime.misc.NotNull;
-
 /** */
 public final class RuleTransition extends Transition {
 	/** Ptr to the rule definition object for this rule ref */
@@ -40,7 +38,6 @@ public final class RuleTransition extends Transition {
 	public final int precedence;
 
 	/** What node to begin computations following ref to rule */
-	@NotNull
 	public ATNState followState;
 
 	/**
@@ -48,17 +45,17 @@ public final class RuleTransition extends Transition {
 	 * {@link #RuleTransition(RuleStartState, int, int, ATNState)} instead.
 	 */
 	@Deprecated
-	public RuleTransition(@NotNull RuleStartState ruleStart,
+	public RuleTransition(RuleStartState ruleStart,
 						  int ruleIndex,
-						  @NotNull ATNState followState)
+						  ATNState followState)
 	{
 		this(ruleStart, ruleIndex, 0, followState);
 	}
 
-	public RuleTransition(@NotNull RuleStartState ruleStart,
+	public RuleTransition(RuleStartState ruleStart,
 						  int ruleIndex,
 						  int precedence,
-						  @NotNull ATNState followState)
+						  ATNState followState)
 	{
 		super(ruleStart);
 		this.ruleIndex = ruleIndex;
diff --git a/runtime/Java/src/org/antlr/v4/runtime/atn/SemanticContext.java b/runtime/Java/src/org/antlr/v4/runtime/atn/SemanticContext.java
index 66ca13256..64dd21e1b 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/atn/SemanticContext.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/atn/SemanticContext.java
@@ -33,7 +33,6 @@ package org.antlr.v4.runtime.atn;
 import org.antlr.v4.runtime.Recognizer;
 import org.antlr.v4.runtime.RuleContext;
 import org.antlr.v4.runtime.misc.MurmurHash;
-import org.antlr.v4.runtime.misc.NotNull;
 import org.antlr.v4.runtime.misc.Utils;
 
 import java.util.ArrayList;
@@ -48,29 +47,53 @@ import java.util.Set;
 /** A tree structure used to record the semantic context in which
  *  an ATN configuration is valid.  It's either a single predicate,
  *  a conjunction {@code p1&&p2}, or a sum of products {@code p1||p2}.
- * <p/>
- *  I have scoped the {@link AND}, {@link OR}, and {@link Predicate} subclasses of
- *  {@link SemanticContext} within the scope of this outer class.
+ *
+ *  <p>I have scoped the {@link AND}, {@link OR}, and {@link Predicate} subclasses of
+ *  {@link SemanticContext} within the scope of this outer class.</p>
  */
 public abstract class SemanticContext {
+	/**
+	 * The default {@link SemanticContext}, which is semantically equivalent to
+	 * a predicate of the form {@code {true}?}.
+	 */
     public static final SemanticContext NONE = new Predicate();
 
-	public SemanticContext parent;
-
 	/**
 	 * For context independent predicates, we evaluate them without a local
 	 * context (i.e., null context). That way, we can evaluate them without
 	 * having to create proper rule-specific context during prediction (as
 	 * opposed to the parser, which creates them naturally). In a practical
 	 * sense, this avoids a cast exception from RuleContext to myruleContext.
-	 * <p/>
-	 * For context dependent predicates, we must pass in a local context so that
+	 *
+	 * <p>For context dependent predicates, we must pass in a local context so that
 	 * references such as $arg evaluate properly as _localctx.arg. We only
 	 * capture context dependent predicates in the context in which we begin
 	 * prediction, so we passed in the outer context here in case of context
-	 * dependent predicate evaluation.
+	 * dependent predicate evaluation.</p>
 	 */
-    public abstract boolean eval(Recognizer<?,?> parser, RuleContext outerContext);
+    public abstract boolean eval(Recognizer<?,?> parser, RuleContext parserCallStack);
+
+	/**
+	 * Evaluate the precedence predicates for the context and reduce the result.
+	 *
+	 * @param parser The parser instance.
+	 * @param parserCallStack
+	 * @return The simplified semantic context after precedence predicates are
+	 * evaluated, which will be one of the following values.
+	 * <ul>
+	 * <li>{@link #NONE}: if the predicate simplifies to {@code true} after
+	 * precedence predicates are evaluated.</li>
+	 * <li>{@code null}: if the predicate simplifies to {@code false} after
+	 * precedence predicates are evaluated.</li>
+	 * <li>{@code this}: if the semantic context is not changed as a result of
+	 * precedence predicate evaluation.</li>
+	 * <li>A non-{@code null} {@link SemanticContext}: the new simplified
+	 * semantic context after precedence predicates are evaluated.</li>
+	 * </ul>
+	 */
+	public SemanticContext evalPrecedence(Recognizer<?,?> parser, RuleContext parserCallStack) {
+		return this;
+	}
 
     public static class Predicate extends SemanticContext {
         public final int ruleIndex;
@@ -90,8 +113,8 @@ public abstract class SemanticContext {
         }
 
         @Override
-        public boolean eval(Recognizer<?,?> parser, RuleContext outerContext) {
-            RuleContext localctx = isCtxDependent ? outerContext : null;
+        public boolean eval(Recognizer<?,?> parser, RuleContext parserCallStack) {
+            RuleContext localctx = isCtxDependent ? parserCallStack : null;
             return parser.sempred(localctx, ruleIndex, predIndex);
         }
 
@@ -133,8 +156,18 @@ public abstract class SemanticContext {
 		}
 
 		@Override
-		public boolean eval(Recognizer<?, ?> parser, RuleContext outerContext) {
-			return parser.precpred(outerContext, precedence);
+		public boolean eval(Recognizer<?, ?> parser, RuleContext parserCallStack) {
+			return parser.precpred(parserCallStack, precedence);
+		}
+
+		@Override
+		public SemanticContext evalPrecedence(Recognizer<?, ?> parser, RuleContext parserCallStack) {
+			if (parser.precpred(parserCallStack, precedence)) {
+				return SemanticContext.NONE;
+			}
+			else {
+				return null;
+			}
 		}
 
 		@Override
@@ -164,15 +197,39 @@ public abstract class SemanticContext {
 		}
 
 		@Override
+		// precedence >= _precedenceStack.peek()
 		public String toString() {
-			return super.toString();
+			return "{"+precedence+">=prec}?";
 		}
 	}
 
-    public static class AND extends SemanticContext {
-		@NotNull public final SemanticContext[] opnds;
+	/**
+	 * This is the base class for semantic context "operators", which operate on
+	 * a collection of semantic context "operands".
+	 *
+	 * @since 4.3
+	 */
+	public static abstract class Operator extends SemanticContext {
+		/**
+		 * Gets the operands for the semantic context operator.
+		 *
+		 * @return a collection of {@link SemanticContext} operands for the
+		 * operator.
+		 *
+		 * @since 4.3
+		 */
 
-		public AND(@NotNull SemanticContext a, @NotNull SemanticContext b) {
+		public abstract Collection<SemanticContext> getOperands();
+	}
+
+	/**
+	 * A semantic context which is true whenever none of the contained contexts
+	 * is false.
+	 */
+    public static class AND extends Operator {
+		public final SemanticContext[] opnds;
+
+		public AND(SemanticContext a, SemanticContext b) {
 			Set<SemanticContext> operands = new HashSet<SemanticContext>();
 			if ( a instanceof AND ) operands.addAll(Arrays.asList(((AND)a).opnds));
 			else operands.add(a);
@@ -189,6 +246,11 @@ public abstract class SemanticContext {
 			opnds = operands.toArray(new SemanticContext[operands.size()]);
         }
 
+		@Override
+		public Collection<SemanticContext> getOperands() {
+			return Arrays.asList(opnds);
+		}
+
 		@Override
 		public boolean equals(Object obj) {
 			if ( this==obj ) return true;
@@ -202,24 +264,69 @@ public abstract class SemanticContext {
 			return MurmurHash.hashCode(opnds, AND.class.hashCode());
 		}
 
+		/**
+		 * {@inheritDoc}
+		 *
+		 * <p>
+		 * The evaluation of predicates by this context is short-circuiting, but
+		 * unordered.</p>
+		 */
 		@Override
-		public boolean eval(Recognizer<?,?> parser, RuleContext outerContext) {
+		public boolean eval(Recognizer<?,?> parser, RuleContext parserCallStack) {
 			for (SemanticContext opnd : opnds) {
-				if ( !opnd.eval(parser, outerContext) ) return false;
+				if ( !opnd.eval(parser, parserCallStack) ) return false;
 			}
 			return true;
         }
 
+		@Override
+		public SemanticContext evalPrecedence(Recognizer<?, ?> parser, RuleContext parserCallStack) {
+			boolean differs = false;
+			List<SemanticContext> operands = new ArrayList<SemanticContext>();
+			for (SemanticContext context : opnds) {
+				SemanticContext evaluated = context.evalPrecedence(parser, parserCallStack);
+				differs |= (evaluated != context);
+				if (evaluated == null) {
+					// The AND context is false if any element is false
+					return null;
+				}
+				else if (evaluated != NONE) {
+					// Reduce the result by skipping true elements
+					operands.add(evaluated);
+				}
+			}
+
+			if (!differs) {
+				return this;
+			}
+
+			if (operands.isEmpty()) {
+				// all elements were true, so the AND context is true
+				return NONE;
+			}
+
+			SemanticContext result = operands.get(0);
+			for (int i = 1; i < operands.size(); i++) {
+				result = SemanticContext.and(result, operands.get(i));
+			}
+
+			return result;
+		}
+
 		@Override
 		public String toString() {
 			return Utils.join(Arrays.asList(opnds).iterator(), "&&");
         }
     }
 
-    public static class OR extends SemanticContext {
-		@NotNull public final SemanticContext[] opnds;
+	/**
+	 * A semantic context which is true whenever at least one of the contained
+	 * contexts is true.
+	 */
+    public static class OR extends Operator {
+		public final SemanticContext[] opnds;
 
-		public OR(@NotNull SemanticContext a, @NotNull SemanticContext b) {
+		public OR(SemanticContext a, SemanticContext b) {
 			Set<SemanticContext> operands = new HashSet<SemanticContext>();
 			if ( a instanceof OR ) operands.addAll(Arrays.asList(((OR)a).opnds));
 			else operands.add(a);
@@ -236,6 +343,11 @@ public abstract class SemanticContext {
 			this.opnds = operands.toArray(new SemanticContext[operands.size()]);
         }
 
+		@Override
+		public Collection<SemanticContext> getOperands() {
+			return Arrays.asList(opnds);
+		}
+
 		@Override
 		public boolean equals(Object obj) {
 			if ( this==obj ) return true;
@@ -249,14 +361,55 @@ public abstract class SemanticContext {
 			return MurmurHash.hashCode(opnds, OR.class.hashCode());
 		}
 
+		/**
+		 * {@inheritDoc}
+		 *
+		 * <p>
+		 * The evaluation of predicates by this context is short-circuiting, but
+		 * unordered.</p>
+		 */
 		@Override
-        public boolean eval(Recognizer<?,?> parser, RuleContext outerContext) {
+        public boolean eval(Recognizer<?,?> parser, RuleContext parserCallStack) {
 			for (SemanticContext opnd : opnds) {
-				if ( opnd.eval(parser, outerContext) ) return true;
+				if ( opnd.eval(parser, parserCallStack) ) return true;
 			}
 			return false;
         }
 
+		@Override
+		public SemanticContext evalPrecedence(Recognizer<?, ?> parser, RuleContext parserCallStack) {
+			boolean differs = false;
+			List<SemanticContext> operands = new ArrayList<SemanticContext>();
+			for (SemanticContext context : opnds) {
+				SemanticContext evaluated = context.evalPrecedence(parser, parserCallStack);
+				differs |= (evaluated != context);
+				if (evaluated == NONE) {
+					// The OR context is true if any element is true
+					return NONE;
+				}
+				else if (evaluated != null) {
+					// Reduce the result by skipping false elements
+					operands.add(evaluated);
+				}
+			}
+
+			if (!differs) {
+				return this;
+			}
+
+			if (operands.isEmpty()) {
+				// all elements were false, so the OR context is false
+				return null;
+			}
+
+			SemanticContext result = operands.get(0);
+			for (int i = 1; i < operands.size(); i++) {
+				result = SemanticContext.or(result, operands.get(i));
+			}
+
+			return result;
+		}
+
         @Override
         public String toString() {
 			return Utils.join(Arrays.asList(opnds).iterator(), "||");
diff --git a/runtime/Java/src/org/antlr/v4/runtime/atn/SetTransition.java b/runtime/Java/src/org/antlr/v4/runtime/atn/SetTransition.java
index e2c4bf5bf..5b4dfafe2 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/atn/SetTransition.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/atn/SetTransition.java
@@ -32,16 +32,13 @@ package org.antlr.v4.runtime.atn;
 
 import org.antlr.v4.runtime.Token;
 import org.antlr.v4.runtime.misc.IntervalSet;
-import org.antlr.v4.runtime.misc.NotNull;
-import org.antlr.v4.runtime.misc.Nullable;
 
 /** A transition containing a set of values. */
 public class SetTransition extends Transition {
-	@NotNull
 	public final IntervalSet set;
 
 	// TODO (sam): should we really allow null here?
-	public SetTransition(@NotNull ATNState target, @Nullable IntervalSet set) {
+	public SetTransition(ATNState target, IntervalSet set) {
 		super(target);
 		if ( set == null ) set = IntervalSet.of(Token.INVALID_TYPE);
 		this.set = set;
@@ -53,7 +50,7 @@ public class SetTransition extends Transition {
 	}
 
 	@Override
-	@NotNull
+
 	public IntervalSet label() { return set; }
 
 	@Override
@@ -62,7 +59,7 @@ public class SetTransition extends Transition {
 	}
 
 	@Override
-	@NotNull
+
 	public String toString() {
 		return set.toString();
 	}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/atn/StarLoopEntryState.java b/runtime/Java/src/org/antlr/v4/runtime/atn/StarLoopEntryState.java
index 3fe24cdc9..621f1ec45 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/atn/StarLoopEntryState.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/atn/StarLoopEntryState.java
@@ -30,9 +30,24 @@
 
 package org.antlr.v4.runtime.atn;
 
+import org.antlr.v4.runtime.ParserInterpreter;
+import org.antlr.v4.runtime.dfa.DFA;
+
 public final class StarLoopEntryState extends DecisionState {
 	public StarLoopbackState loopBackState;
 
+	/**
+	 * Indicates whether this state can benefit from a precedence DFA during SLL
+	 * decision making.
+	 *
+	 * <p>This is a computed property that is calculated during ATN deserialization
+	 * and stored for use in {@link ParserATNSimulator} and
+	 * {@link ParserInterpreter}.</p>
+	 *
+	 * @see DFA#isPrecedenceDfa()
+	 */
+	public boolean isPrecedenceDecision;
+
 	@Override
 	public int getStateType() {
 		return STAR_LOOP_ENTRY;
diff --git a/runtime/Java/src/org/antlr/v4/runtime/atn/Transition.java b/runtime/Java/src/org/antlr/v4/runtime/atn/Transition.java
index 872046d2b..55681925b 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/atn/Transition.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/atn/Transition.java
@@ -31,8 +31,6 @@
 package org.antlr.v4.runtime.atn;
 
 import org.antlr.v4.runtime.misc.IntervalSet;
-import org.antlr.v4.runtime.misc.NotNull;
-import org.antlr.v4.runtime.misc.Nullable;
 
 import java.util.Arrays;
 import java.util.Collections;
@@ -42,15 +40,15 @@ import java.util.Map;
 
 /** An ATN transition between any two ATN states.  Subclasses define
  *  atom, set, epsilon, action, predicate, rule transitions.
- * <p/>
- *  This is a one way link.  It emanates from a state (usually via a list of
- *  transitions) and has a target state.
- * <p/>
- *  Since we never have to change the ATN transitions once we construct it,
+ *
+ *  <p>This is a one way link.  It emanates from a state (usually via a list of
+ *  transitions) and has a target state.</p>
+ *
+ *  <p>Since we never have to change the ATN transitions once we construct it,
  *  we can fix these transitions as specific classes. The DFA transitions
  *  on the other hand need to update the labels as it adds transitions to
  *  the states. We'll use the term Edge for the DFA to distinguish them from
- *  ATN transitions.
+ *  ATN transitions.</p>
  */
 public abstract class Transition {
 	// constants for serialization
@@ -96,10 +94,10 @@ public abstract class Transition {
 		}});
 
 	/** The target of this transition. */
-	@NotNull
+
 	public ATNState target;
 
-	protected Transition(@NotNull ATNState target) {
+	protected Transition(ATNState target) {
 		if (target == null) {
 			throw new NullPointerException("target cannot be null.");
 		}
@@ -109,10 +107,20 @@ public abstract class Transition {
 
 	public abstract int getSerializationType();
 
-	/** Are we epsilon, action, sempred? */
-	public boolean isEpsilon() { return false; }
+	/**
+	 * Determines if the transition is an "epsilon" transition.
+	 *
+	 * <p>The default implementation returns {@code false}.</p>
+	 *
+	 * @return {@code true} if traversing this transition in the ATN does not
+	 * consume an input symbol; otherwise, {@code false} if traversing this
+	 * transition consumes (matches) an input symbol.
+	 */
+	public boolean isEpsilon() {
+		return false;
+	}
+
 
-	@Nullable
 	public IntervalSet label() { return null; }
 
 	public abstract boolean matches(int symbol, int minVocabSymbol, int maxVocabSymbol);
diff --git a/runtime/Java/src/org/antlr/v4/runtime/atn/WildcardTransition.java b/runtime/Java/src/org/antlr/v4/runtime/atn/WildcardTransition.java
index f7f001e01..6cca73d09 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/atn/WildcardTransition.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/atn/WildcardTransition.java
@@ -30,10 +30,8 @@
 
 package org.antlr.v4.runtime.atn;
 
-import org.antlr.v4.runtime.misc.NotNull;
-
 public final class WildcardTransition extends Transition {
-	public WildcardTransition(@NotNull ATNState target) { super(target); }
+	public WildcardTransition(ATNState target) { super(target); }
 
 	@Override
 	public int getSerializationType() {
@@ -46,7 +44,6 @@ public final class WildcardTransition extends Transition {
 	}
 
 	@Override
-	@NotNull
 	public String toString() {
 		return ".";
 	}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/dfa/DFA.java b/runtime/Java/src/org/antlr/v4/runtime/dfa/DFA.java
index 091a07161..1f6890de7 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/dfa/DFA.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/dfa/DFA.java
@@ -29,11 +29,15 @@
  */
 package org.antlr.v4.runtime.dfa;
 
+import org.antlr.v4.runtime.Parser;
+import org.antlr.v4.runtime.Vocabulary;
+import org.antlr.v4.runtime.VocabularyImpl;
+import org.antlr.v4.runtime.atn.ATNConfigSet;
 import org.antlr.v4.runtime.atn.DecisionState;
-import org.antlr.v4.runtime.misc.NotNull;
-import org.antlr.v4.runtime.misc.Nullable;
+import org.antlr.v4.runtime.atn.StarLoopEntryState;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashMap;
@@ -45,30 +49,139 @@ public class DFA {
 	/** A set of all DFA states. Use {@link Map} so we can get old state back
 	 *  ({@link Set} only allows you to see if it's there).
      */
-    @NotNull
+
 	public final Map<DFAState, DFAState> states = new HashMap<DFAState, DFAState>();
-	@Nullable
-	public DFAState s0;
+
+	public volatile DFAState s0;
 
 	public final int decision;
 
 	/** From which ATN state did we create this DFA? */
-	@NotNull
+
 	public final DecisionState atnStartState;
 
-	public DFA(@NotNull DecisionState atnStartState) {
+	/**
+	 * {@code true} if this DFA is for a precedence decision; otherwise,
+	 * {@code false}. This is the backing field for {@link #isPrecedenceDfa}.
+	 */
+	private final boolean precedenceDfa;
+
+	public DFA(DecisionState atnStartState) {
 		this(atnStartState, 0);
 	}
 
-	public DFA(@NotNull DecisionState atnStartState, int decision) {
+	public DFA(DecisionState atnStartState, int decision) {
 		this.atnStartState = atnStartState;
 		this.decision = decision;
+
+		boolean precedenceDfa = false;
+		if (atnStartState instanceof StarLoopEntryState) {
+			if (((StarLoopEntryState)atnStartState).isPrecedenceDecision) {
+				precedenceDfa = true;
+				DFAState precedenceState = new DFAState(new ATNConfigSet());
+				precedenceState.edges = new DFAState[0];
+				precedenceState.isAcceptState = false;
+				precedenceState.requiresFullContext = false;
+				this.s0 = precedenceState;
+			}
+		}
+
+		this.precedenceDfa = precedenceDfa;
+	}
+
+	/**
+	 * Gets whether this DFA is a precedence DFA. Precedence DFAs use a special
+	 * start state {@link #s0} which is not stored in {@link #states}. The
+	 * {@link DFAState#edges} array for this start state contains outgoing edges
+	 * supplying individual start states corresponding to specific precedence
+	 * values.
+	 *
+	 * @return {@code true} if this is a precedence DFA; otherwise,
+	 * {@code false}.
+	 * @see Parser#getPrecedence()
+	 */
+	public final boolean isPrecedenceDfa() {
+		return precedenceDfa;
+	}
+
+	/**
+	 * Get the start state for a specific precedence value.
+	 *
+	 * @param precedence The current precedence.
+	 * @return The start state corresponding to the specified precedence, or
+	 * {@code null} if no start state exists for the specified precedence.
+	 *
+	 * @throws IllegalStateException if this is not a precedence DFA.
+	 * @see #isPrecedenceDfa()
+	 */
+	@SuppressWarnings("null")
+	public final DFAState getPrecedenceStartState(int precedence) {
+		if (!isPrecedenceDfa()) {
+			throw new IllegalStateException("Only precedence DFAs may contain a precedence start state.");
+		}
+
+		// s0.edges is never null for a precedence DFA
+		if (precedence < 0 || precedence >= s0.edges.length) {
+			return null;
+		}
+
+		return s0.edges[precedence];
+	}
+
+	/**
+	 * Set the start state for a specific precedence value.
+	 *
+	 * @param precedence The current precedence.
+	 * @param startState The start state corresponding to the specified
+	 * precedence.
+	 *
+	 * @throws IllegalStateException if this is not a precedence DFA.
+	 * @see #isPrecedenceDfa()
+	 */
+	@SuppressWarnings({"SynchronizeOnNonFinalField", "null"})
+	public final void setPrecedenceStartState(int precedence, DFAState startState) {
+		if (!isPrecedenceDfa()) {
+			throw new IllegalStateException("Only precedence DFAs may contain a precedence start state.");
+		}
+
+		if (precedence < 0) {
+			return;
+		}
+
+		// synchronization on s0 here is ok. when the DFA is turned into a
+		// precedence DFA, s0 will be initialized once and not updated again
+		synchronized (s0) {
+			// s0.edges is never null for a precedence DFA
+			if (precedence >= s0.edges.length) {
+				s0.edges = Arrays.copyOf(s0.edges, precedence + 1);
+			}
+
+			s0.edges[precedence] = startState;
+		}
+	}
+
+	/**
+	 * Sets whether this is a precedence DFA.
+	 *
+	 * @param precedenceDfa {@code true} if this is a precedence DFA; otherwise,
+	 * {@code false}
+	 *
+	 * @throws UnsupportedOperationException if {@code precedenceDfa} does not
+	 * match the value of {@link #isPrecedenceDfa} for the current DFA.
+	 *
+	 * @deprecated This method no longer performs any action.
+	 */
+	@Deprecated
+	public final void setPrecedenceDfa(boolean precedenceDfa) {
+		if (precedenceDfa != isPrecedenceDfa()) {
+			throw new UnsupportedOperationException("The precedenceDfa field cannot change after a DFA is constructed.");
+		}
 	}
 
 	/**
 	 * Return a list of all states in this DFA, ordered by state number.
 	 */
-	@NotNull
+
 	public List<DFAState> getStates() {
 		List<DFAState> result = new ArrayList<DFAState>(states.keySet());
 		Collections.sort(result, new Comparator<DFAState>() {
@@ -82,14 +195,27 @@ public class DFA {
 	}
 
 	@Override
-	public String toString() { return toString(null); }
+	public String toString() { return toString(VocabularyImpl.EMPTY_VOCABULARY); }
 
-	public String toString(@Nullable String[] tokenNames) {
+	/**
+	 * @deprecated Use {@link #toString(Vocabulary)} instead.
+	 */
+	@Deprecated
+	public String toString(String[] tokenNames) {
 		if ( s0==null ) return "";
 		DFASerializer serializer = new DFASerializer(this,tokenNames);
 		return serializer.toString();
 	}
 
+	public String toString(Vocabulary vocabulary) {
+		if (s0 == null) {
+			return "";
+		}
+
+		DFASerializer serializer = new DFASerializer(this, vocabulary);
+		return serializer.toString();
+	}
+
 	public String toLexerString() {
 		if ( s0==null ) return "";
 		DFASerializer serializer = new LexerDFASerializer(this);
diff --git a/runtime/Java/src/org/antlr/v4/runtime/dfa/DFASerializer.java b/runtime/Java/src/org/antlr/v4/runtime/dfa/DFASerializer.java
index e17a1f9c9..7f4c4e5e8 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/dfa/DFASerializer.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/dfa/DFASerializer.java
@@ -30,22 +30,30 @@
 
 package org.antlr.v4.runtime.dfa;
 
-import org.antlr.v4.runtime.misc.NotNull;
-import org.antlr.v4.runtime.misc.Nullable;
+import org.antlr.v4.runtime.Vocabulary;
+import org.antlr.v4.runtime.VocabularyImpl;
 
 import java.util.Arrays;
 import java.util.List;
 
 /** A DFA walker that knows how to dump them to serialized strings. */
 public class DFASerializer {
-	@NotNull
-	final DFA dfa;
-	@Nullable
-	final String[] tokenNames;
 
-	public DFASerializer(@NotNull DFA dfa, @Nullable String[] tokenNames) {
+	private final DFA dfa;
+
+	private final Vocabulary vocabulary;
+
+	/**
+	 * @deprecated Use {@link #DFASerializer(DFA, Vocabulary)} instead.
+	 */
+	@Deprecated
+	public DFASerializer(DFA dfa, String[] tokenNames) {
+		this(dfa, VocabularyImpl.fromTokenNames(tokenNames));
+	}
+
+	public DFASerializer(DFA dfa, Vocabulary vocabulary) {
 		this.dfa = dfa;
-		this.tokenNames = tokenNames;
+		this.vocabulary = vocabulary;
 	}
 
 	@Override
@@ -73,15 +81,11 @@ public class DFASerializer {
 	}
 
 	protected String getEdgeLabel(int i) {
-		String label;
-		if ( i==0 ) return "EOF";
-		if ( tokenNames!=null ) label = tokenNames[i-1];
-		else label = String.valueOf(i-1);
-		return label;
+		return vocabulary.getDisplayName(i - 1);
 	}
 
-	@NotNull
-	protected String getStateString(@NotNull DFAState s) {
+
+	protected String getStateString(DFAState s) {
 		int n = s.stateNumber;
 		final String baseStateStr = (s.isAcceptState ? ":" : "") + "s" + n + (s.requiresFullContext ? "^" : "");
 		if ( s.isAcceptState ) {
diff --git a/runtime/Java/src/org/antlr/v4/runtime/dfa/DFAState.java b/runtime/Java/src/org/antlr/v4/runtime/dfa/DFAState.java
index 49005a6a6..fe5b3ea9e 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/dfa/DFAState.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/dfa/DFAState.java
@@ -34,11 +34,10 @@ import org.antlr.v4.runtime.Token;
 import org.antlr.v4.runtime.atn.ATN;
 import org.antlr.v4.runtime.atn.ATNConfig;
 import org.antlr.v4.runtime.atn.ATNConfigSet;
+import org.antlr.v4.runtime.atn.LexerActionExecutor;
 import org.antlr.v4.runtime.atn.ParserATNSimulator;
 import org.antlr.v4.runtime.atn.SemanticContext;
 import org.antlr.v4.runtime.misc.MurmurHash;
-import org.antlr.v4.runtime.misc.NotNull;
-import org.antlr.v4.runtime.misc.Nullable;
 
 import java.util.Arrays;
 import java.util.HashSet;
@@ -51,7 +50,7 @@ import java.util.Set;
  *  input a1a2..an, the DFA is in a state that represents the
  *  subset T of the states of the ATN that are reachable from the
  *  ATN's start state along some path labeled a1a2..an."
- *  In conventional NFA->DFA conversion, therefore, the subset T
+ *  In conventional NFA&rarr;DFA conversion, therefore, the subset T
  *  would be a bitset representing the set of states the
  *  ATN could be in.  We need to track the alt predicted by each
  *  state as well, however.  More importantly, we need to maintain
@@ -59,25 +58,25 @@ import java.util.Set;
  *  jump from rule to rule, emulating rule invocations (method calls).
  *  I have to add a stack to simulate the proper lookahead sequences for
  *  the underlying LL grammar from which the ATN was derived.
- * <p/>
- *  I use a set of ATNConfig objects not simple states.  An ATNConfig
+ *
+ *  <p>I use a set of ATNConfig objects not simple states.  An ATNConfig
  *  is both a state (ala normal conversion) and a RuleContext describing
- *  the chain of rules (if any) followed to arrive at that state.
- * <p/>
- *  A DFA state may have multiple references to a particular state,
+ *  the chain of rules (if any) followed to arrive at that state.</p>
+ *
+ *  <p>A DFA state may have multiple references to a particular state,
  *  but with different ATN contexts (with same or different alts)
- *  meaning that state was reached via a different set of rule invocations.
+ *  meaning that state was reached via a different set of rule invocations.</p>
  */
 public class DFAState {
 	public int stateNumber = -1;
 
-	@NotNull
+
 	public ATNConfigSet configs = new ATNConfigSet();
 
 	/** {@code edges[symbol]} points to target of symbol. Shift up by 1 so (-1)
 	 *  {@link Token#EOF} maps to {@code edges[0]}.
 	 */
-	@Nullable
+
 	public DFAState[] edges;
 
 	public boolean isAcceptState = false;
@@ -88,8 +87,7 @@ public class DFAState {
 	 */
 	public int prediction;
 
-	public int lexerRuleIndex = -1;		// if accept, exec action in what rule?
-	public int lexerActionIndex = -1;	// if accept, exec what action?
+	public LexerActionExecutor lexerActionExecutor;
 
 	/**
 	 * Indicates that this state was created during SLL prediction that
@@ -104,19 +102,19 @@ public class DFAState {
 	 *  {@link #requiresFullContext} is {@code false} since full context prediction evaluates predicates
 	 *  on-the-fly. If this is not null, then {@link #prediction} is
 	 *  {@link ATN#INVALID_ALT_NUMBER}.
-	 * <p/>
-	 *  We only use these for non-{@link #requiresFullContext} but conflicting states. That
+	 *
+	 *  <p>We only use these for non-{@link #requiresFullContext} but conflicting states. That
 	 *  means we know from the context (it's $ or we don't dip into outer
-	 *  context) that it's an ambiguity not a conflict.
-	 * <p/>
-	 *  This list is computed by {@link ParserATNSimulator#predicateDFAState}.
+	 *  context) that it's an ambiguity not a conflict.</p>
+	 *
+	 *  <p>This list is computed by {@link ParserATNSimulator#predicateDFAState}.</p>
 	 */
-	@Nullable
+
 	public PredPrediction[] predicates;
 
 	/** Map a predicate to a predicted alternative. */
 	public static class PredPrediction {
-		@NotNull
+
 		public SemanticContext pred; // never null; at least SemanticContext.NONE
 		public int alt;
 		public PredPrediction(SemanticContext pred, int alt) {
@@ -133,7 +131,7 @@ public class DFAState {
 
 	public DFAState(int stateNumber) { this.stateNumber = stateNumber; }
 
-	public DFAState(@NotNull ATNConfigSet configs) { this.configs = configs; }
+	public DFAState(ATNConfigSet configs) { this.configs = configs; }
 
 	/** Get the set of all alts mentioned by all ATN configurations in this
 	 *  DFA state.
@@ -160,15 +158,15 @@ public class DFAState {
 	/**
 	 * Two {@link DFAState} instances are equal if their ATN configuration sets
 	 * are the same. This method is used to see if a state already exists.
-	 * <p/>
-	 * Because the number of alternatives and number of ATN configurations are
+	 *
+	 * <p>Because the number of alternatives and number of ATN configurations are
 	 * finite, there is a finite number of DFA states that can be processed.
-	 * This is necessary to show that the algorithm terminates.
-	 * <p/>
-	 * Cannot test the DFA state numbers here because in
+	 * This is necessary to show that the algorithm terminates.</p>
+	 *
+	 * <p>Cannot test the DFA state numbers here because in
 	 * {@link ParserATNSimulator#addDFAState} we need to know if any other state
 	 * exists that has this exact set of ATN configurations. The
-	 * {@link #stateNumber} is irrelevant.
+	 * {@link #stateNumber} is irrelevant.</p>
 	 */
 	@Override
 	public boolean equals(Object o) {
diff --git a/runtime/Java/src/org/antlr/v4/runtime/dfa/LexerDFASerializer.java b/runtime/Java/src/org/antlr/v4/runtime/dfa/LexerDFASerializer.java
index 5e22df6e0..8bacc7af1 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/dfa/LexerDFASerializer.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/dfa/LexerDFASerializer.java
@@ -30,15 +30,15 @@
 
 package org.antlr.v4.runtime.dfa;
 
-import org.antlr.v4.runtime.misc.NotNull;
+import org.antlr.v4.runtime.VocabularyImpl;
 
 public class LexerDFASerializer extends DFASerializer {
-	public LexerDFASerializer(@NotNull DFA dfa) {
-		super(dfa, null);
+	public LexerDFASerializer(DFA dfa) {
+		super(dfa, VocabularyImpl.EMPTY_VOCABULARY);
 	}
 
 	@Override
-	@NotNull
+
 	protected String getEdgeLabel(int i) {
 		return "'"+(char)i+"'";
 	}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/misc/Array2DHashSet.java b/runtime/Java/src/org/antlr/v4/runtime/misc/Array2DHashSet.java
index 49ebd1ced..4f25420a3 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/misc/Array2DHashSet.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/misc/Array2DHashSet.java
@@ -42,7 +42,7 @@ public class Array2DHashSet<T> implements Set<T> {
 	public static final int INITAL_BUCKET_CAPACITY = 8;
 	public static final double LOAD_FACTOR = 0.75;
 
-	@NotNull
+
 	protected final AbstractEqualityComparator<? super T> comparator;
 
 	protected T[][] buckets;
@@ -59,11 +59,11 @@ public class Array2DHashSet<T> implements Set<T> {
 		this(null, INITAL_CAPACITY, INITAL_BUCKET_CAPACITY);
 	}
 
-	public Array2DHashSet(@Nullable AbstractEqualityComparator<? super T> comparator) {
+	public Array2DHashSet(AbstractEqualityComparator<? super T> comparator) {
 		this(comparator, INITAL_CAPACITY, INITAL_BUCKET_CAPACITY);
 	}
 
-	public Array2DHashSet(@Nullable AbstractEqualityComparator<? super T> comparator, int initialCapacity, int initialBucketCapacity) {
+	public Array2DHashSet(AbstractEqualityComparator<? super T> comparator, int initialCapacity, int initialBucketCapacity) {
 		if (comparator == null) {
 			comparator = ObjectEqualityComparator.INSTANCE;
 		}
@@ -226,7 +226,7 @@ public class Array2DHashSet<T> implements Set<T> {
 		return containsFast(asElementType(o));
 	}
 
-	public boolean containsFast(@Nullable T obj) {
+	public boolean containsFast(T obj) {
 		if (obj == null) {
 			return false;
 		}
@@ -290,7 +290,7 @@ public class Array2DHashSet<T> implements Set<T> {
 		return removeFast(asElementType(o));
 	}
 
-	public boolean removeFast(@Nullable T obj) {
+	public boolean removeFast(T obj) {
 		if (obj == null) {
 			return false;
 		}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/misc/FlexibleHashMap.java b/runtime/Java/src/org/antlr/v4/runtime/misc/FlexibleHashMap.java
index 7f9e86898..3e5582ab4 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/misc/FlexibleHashMap.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/misc/FlexibleHashMap.java
@@ -57,7 +57,7 @@ public class FlexibleHashMap<K,V> implements Map<K, V> {
 		}
 	}
 
-	@NotNull
+
 	protected final AbstractEqualityComparator<? super K> comparator;
 
 	protected LinkedList<Entry<K, V>>[] buckets;
@@ -74,11 +74,11 @@ public class FlexibleHashMap<K,V> implements Map<K, V> {
 		this(null, INITAL_CAPACITY, INITAL_BUCKET_CAPACITY);
 	}
 
-	public FlexibleHashMap(@Nullable AbstractEqualityComparator<? super K> comparator) {
+	public FlexibleHashMap(AbstractEqualityComparator<? super K> comparator) {
 		this(comparator, INITAL_CAPACITY, INITAL_BUCKET_CAPACITY);
 	}
 
-	public FlexibleHashMap(@Nullable AbstractEqualityComparator<? super K> comparator, int initialCapacity, int initialBucketCapacity) {
+	public FlexibleHashMap(AbstractEqualityComparator<? super K> comparator, int initialCapacity, int initialBucketCapacity) {
 		if (comparator == null) {
 			comparator = ObjectEqualityComparator.INSTANCE;
 		}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/misc/IntSet.java b/runtime/Java/src/org/antlr/v4/runtime/misc/IntSet.java
index 7bc07c5a2..606efbb4c 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/misc/IntSet.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/misc/IntSet.java
@@ -30,51 +30,170 @@
 package org.antlr.v4.runtime.misc;
 
 
+import org.antlr.v4.runtime.Token;
+
 import java.util.List;
 
-/** A generic set of ints.
+/**
+ * A generic set of integers.
  *
- *  @see IntervalSet
+ * @see IntervalSet
  */
 public interface IntSet {
-    /** Add an element to the set */
-    void add(int el);
+	/**
+	 * Adds the specified value to the current set.
+	 *
+	 * @param el the value to add
+	 *
+	 * @exception IllegalStateException if the current set is read-only
+	 */
+	void add(int el);
 
-    /** Add all elements from incoming set to this set.  Can limit
-     *  to set of its own type. Return "this" so we can chain calls.
-     */
-    IntSet addAll(IntSet set);
+	/**
+	 * Modify the current {@link IntSet} object to contain all elements that are
+	 * present in itself, the specified {@code set}, or both.
+	 *
+	 * @param set The set to add to the current set. A {@code null} argument is
+	 * treated as though it were an empty set.
+	 * @return {@code this} (to support chained calls)
+	 *
+	 * @exception IllegalStateException if the current set is read-only
+	 */
 
-    /** Return the intersection of this set with the argument, creating
-     *  a new set.
-     */
-    IntSet and(IntSet a);
+	IntSet addAll(IntSet set);
 
-    IntSet complement(IntSet elements);
+	/**
+	 * Return a new {@link IntSet} object containing all elements that are
+	 * present in both the current set and the specified set {@code a}.
+	 *
+	 * @param a The set to intersect with the current set. A {@code null}
+	 * argument is treated as though it were an empty set.
+	 * @return A new {@link IntSet} instance containing the intersection of the
+	 * current set and {@code a}. The value {@code null} may be returned in
+	 * place of an empty result set.
+	 */
 
-    IntSet or(IntSet a);
+	IntSet and(IntSet a);
 
-    IntSet subtract(IntSet a);
+	/**
+	 * Return a new {@link IntSet} object containing all elements that are
+	 * present in {@code elements} but not present in the current set. The
+	 * following expressions are equivalent for input non-null {@link IntSet}
+	 * instances {@code x} and {@code y}.
+	 *
+	 * <ul>
+	 * <li>{@code x.complement(y)}</li>
+	 * <li>{@code y.subtract(x)}</li>
+	 * </ul>
+	 *
+	 * @param elements The set to compare with the current set. A {@code null}
+	 * argument is treated as though it were an empty set.
+	 * @return A new {@link IntSet} instance containing the elements present in
+	 * {@code elements} but not present in the current set. The value
+	 * {@code null} may be returned in place of an empty result set.
+	 */
 
-    /** Return the size of this set (not the underlying implementation's
-     *  allocated memory size, for example).
-     */
-    int size();
+	IntSet complement(IntSet elements);
 
-    boolean isNil();
+	/**
+	 * Return a new {@link IntSet} object containing all elements that are
+	 * present in the current set, the specified set {@code a}, or both.
+	 *
+	 * <p>
+	 * This method is similar to {@link #addAll(IntSet)}, but returns a new
+	 * {@link IntSet} instance instead of modifying the current set.</p>
+	 *
+	 * @param a The set to union with the current set. A {@code null} argument
+	 * is treated as though it were an empty set.
+	 * @return A new {@link IntSet} instance containing the union of the current
+	 * set and {@code a}. The value {@code null} may be returned in place of an
+	 * empty result set.
+	 */
 
-    @Override
-    boolean equals(Object obj);
+	IntSet or(IntSet a);
 
-    int getSingleElement();
+	/**
+	 * Return a new {@link IntSet} object containing all elements that are
+	 * present in the current set but not present in the input set {@code a}.
+	 * The following expressions are equivalent for input non-null
+	 * {@link IntSet} instances {@code x} and {@code y}.
+	 *
+	 * <ul>
+	 * <li>{@code y.subtract(x)}</li>
+	 * <li>{@code x.complement(y)}</li>
+	 * </ul>
+	 *
+	 * @param a The set to compare with the current set. A {@code null}
+	 * argument is treated as though it were an empty set.
+	 * @return A new {@link IntSet} instance containing the elements present in
+	 * {@code elements} but not present in the current set. The value
+	 * {@code null} may be returned in place of an empty result set.
+	 */
 
-    boolean contains(int el);
+	IntSet subtract(IntSet a);
 
-    /** remove this element from this set */
-    void remove(int el);
+	/**
+	 * Return the total number of elements represented by the current set.
+	 *
+	 * @return the total number of elements represented by the current set,
+	 * regardless of the manner in which the elements are stored.
+	 */
+	int size();
 
-    List<Integer> toList();
+	/**
+	 * Returns {@code true} if this set contains no elements.
+	 *
+	 * @return {@code true} if the current set contains no elements; otherwise,
+	 * {@code false}.
+	 */
+	boolean isNil();
 
-    @Override
-    String toString();
+	/**
+	 * {@inheritDoc}
+	 */
+	@Override
+	boolean equals(Object obj);
+
+	/**
+	 * Returns the single value contained in the set, if {@link #size} is 1;
+	 * otherwise, returns {@link Token#INVALID_TYPE}.
+	 *
+	 * @return the single value contained in the set, if {@link #size} is 1;
+	 * otherwise, returns {@link Token#INVALID_TYPE}.
+	 */
+	int getSingleElement();
+
+	/**
+	 * Returns {@code true} if the set contains the specified element.
+	 *
+	 * @param el The element to check for.
+	 * @return {@code true} if the set contains {@code el}; otherwise {@code false}.
+	 */
+	boolean contains(int el);
+
+	/**
+	 * Removes the specified value from the current set. If the current set does
+	 * not contain the element, no changes are made.
+	 *
+	 * @param el the value to remove
+	 *
+	 * @exception IllegalStateException if the current set is read-only
+	 */
+	void remove(int el);
+
+	/**
+	 * Return a list containing the elements represented by the current set. The
+	 * list is returned in ascending numerical order.
+	 *
+	 * @return A list containing all element present in the current set, sorted
+	 * in ascending numerical order.
+	 */
+
+	List<Integer> toList();
+
+	/**
+	 * {@inheritDoc}
+	 */
+	@Override
+	String toString();
 }
diff --git a/runtime/Java/src/org/antlr/v4/runtime/misc/IntegerList.java b/runtime/Java/src/org/antlr/v4/runtime/misc/IntegerList.java
index 48e054dce..18860fe19 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/misc/IntegerList.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/misc/IntegerList.java
@@ -29,6 +29,7 @@
  */
 package org.antlr.v4.runtime.misc;
 
+import java.lang.IllegalArgumentException;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;
@@ -44,7 +45,7 @@ public class IntegerList {
 	private static final int INITIAL_SIZE = 4;
 	private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
 
-	@NotNull
+
 	private int[] _data;
 
 	private int _size;
@@ -65,12 +66,12 @@ public class IntegerList {
 		}
 	}
 
-	public IntegerList(@NotNull IntegerList list) {
+	public IntegerList(IntegerList list) {
 		_data = list._data.clone();
 		_size = list._size;
 	}
 
-	public IntegerList(@NotNull Collection<Integer> list) {
+	public IntegerList(Collection<Integer> list) {
 		this(list.size());
 		for (Integer value : list) {
 			add(value);
@@ -101,11 +102,11 @@ public class IntegerList {
 	public final void addAll(Collection<Integer> list) {
 		ensureCapacity(_size + list.size());
 		int current = 0;
-		for (int x : list) {
-			_data[_size + current] = x;
-		}
-
-		_size += list.size();
+    		for (int x : list) {
+      			_data[_size + current] = x;
+      			current++;
+    		}
+    		_size += list.size();
 	}
 
 	public final int get(int index) {
@@ -234,10 +235,10 @@ public class IntegerList {
 
 	/**
 	 * Returns the hash code value for this list.
-	 * <p/>
-	 * This implementation uses exactly the code that is used to define the
+	 *
+	 * <p>This implementation uses exactly the code that is used to define the
 	 * list hash function in the documentation for the {@link List#hashCode}
-	 * method.
+	 * method.</p>
 	 *
 	 * @return the hash code value for this list
 	 */
@@ -267,6 +268,9 @@ public class IntegerList {
 		if (fromIndex < 0 || toIndex < 0 || fromIndex > _size || toIndex > _size) {
 			throw new IndexOutOfBoundsException();
 		}
+		if (fromIndex > toIndex) {
+        		throw new IllegalArgumentException();
+		}
 
 		return Arrays.binarySearch(_data, fromIndex, toIndex, key);
 	}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/misc/IntegerStack.java b/runtime/Java/src/org/antlr/v4/runtime/misc/IntegerStack.java
index 401f25988..d5806e871 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/misc/IntegerStack.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/misc/IntegerStack.java
@@ -42,7 +42,7 @@ public class IntegerStack extends IntegerList {
 		super(capacity);
 	}
 
-	public IntegerStack(@NotNull IntegerStack list) {
+	public IntegerStack(IntegerStack list) {
 		super(list);
 	}
 
diff --git a/runtime/Java/src/org/antlr/v4/runtime/misc/Interval.java b/runtime/Java/src/org/antlr/v4/runtime/misc/Interval.java
index d2bd435d1..c2b3f81ca 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/misc/Interval.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/misc/Interval.java
@@ -65,7 +65,7 @@ public class Interval {
 	}
 
 	/** return number of elements between a and b inclusively. x..x is length 1.
-	 *  if b < a, then length is 0.  9..10 has length 2.
+	 *  if b &lt; a, then length is 0.  9..10 has length 2.
 	 */
 	public int length() {
 		if ( b<a ) return 0;
diff --git a/runtime/Java/src/org/antlr/v4/runtime/misc/IntervalSet.java b/runtime/Java/src/org/antlr/v4/runtime/misc/IntervalSet.java
index 007680fe1..9f274be15 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/misc/IntervalSet.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/misc/IntervalSet.java
@@ -31,6 +31,8 @@ package org.antlr.v4.runtime.misc;
 
 import org.antlr.v4.runtime.Lexer;
 import org.antlr.v4.runtime.Token;
+import org.antlr.v4.runtime.Vocabulary;
+import org.antlr.v4.runtime.VocabularyImpl;
 
 import java.util.ArrayList;
 import java.util.HashSet;
@@ -39,23 +41,28 @@ import java.util.List;
 import java.util.ListIterator;
 import java.util.Set;
 
-/** A set of integers that relies on ranges being common to do
- *  "run-length-encoded" like compression (if you view an IntSet like
- *  a BitSet with runs of 0s and 1s).  Only ranges are recorded so that
- *  a few ints up near value 1000 don't cause massive bitsets, just two
- *  integer intervals.
+/**
+ * This class implements the {@link IntSet} backed by a sorted array of
+ * non-overlapping intervals. It is particularly efficient for representing
+ * large collections of numbers, where the majority of elements appear as part
+ * of a sequential range of numbers that are all part of the set. For example,
+ * the set { 1, 2, 3, 4, 7, 8 } may be represented as { [1, 4], [7, 8] }.
  *
- *  element values may be negative.  Useful for sets of EPSILON and EOF.
- *
- *  0..9 char range is index pair ['\u0030','\u0039'].
- *  Multiple ranges are encoded with multiple index pairs.  Isolated
- *  elements are encoded with an index pair where both intervals are the same.
- *
- *  The ranges are ordered and disjoint so that 2..6 appears before 101..103.
+ * <p>
+ * This class is able to represent sets containing any combination of values in
+ * the range {@link Integer#MIN_VALUE} to {@link Integer#MAX_VALUE}
+ * (inclusive).</p>
  */
 public class IntervalSet implements IntSet {
-	public static final IntervalSet COMPLETE_CHAR_SET = IntervalSet.of(0, Lexer.MAX_CHAR_VALUE);
+	public static final IntervalSet COMPLETE_CHAR_SET = IntervalSet.of(Lexer.MIN_CHAR_VALUE, Lexer.MAX_CHAR_VALUE);
+	static {
+		COMPLETE_CHAR_SET.setReadonly(true);
+	}
+
 	public static final IntervalSet EMPTY_SET = new IntervalSet();
+	static {
+		EMPTY_SET.setReadonly(true);
+	}
 
 	/** The list of sorted, disjoint intervals. */
     protected List<Interval> intervals;
@@ -82,7 +89,7 @@ public class IntervalSet implements IntSet {
 	}
 
 	/** Create a set with a single element, el. */
-    @NotNull
+
     public static IntervalSet of(int a) {
 		IntervalSet s = new IntervalSet();
         s.add(a);
@@ -111,7 +118,7 @@ public class IntervalSet implements IntSet {
     }
 
     /** Add interval; i.e., add all integers from a to b to set.
-     *  If b<a, do nothing.
+     *  If b&lt;a, do nothing.
      *  Keep list in sorted order (by left range value).
      *  If overlap, combine ranges.  For example,
      *  If this is {1..5, 10..20}, adding 6..7 yields
@@ -180,18 +187,22 @@ public class IntervalSet implements IntSet {
 		if ( set==null ) {
 			return this;
 		}
-        if ( !(set instanceof IntervalSet) ) {
-            throw new IllegalArgumentException("can't add non IntSet ("+
-											   set.getClass().getName()+
-											   ") to IntervalSet");
-        }
-        IntervalSet other = (IntervalSet)set;
-        // walk set and add each interval
-		int n = other.intervals.size();
-		for (int i = 0; i < n; i++) {
-			Interval I = other.intervals.get(i);
-			this.add(I.a,I.b);
+
+		if (set instanceof IntervalSet) {
+			IntervalSet other = (IntervalSet)set;
+			// walk set and add each interval
+			int n = other.intervals.size();
+			for (int i = 0; i < n; i++) {
+				Interval I = other.intervals.get(i);
+				this.add(I.a,I.b);
+			}
 		}
+		else {
+			for (int value : set.toList()) {
+				add(value);
+			}
+		}
+
 		return this;
     }
 
@@ -199,67 +210,120 @@ public class IntervalSet implements IntSet {
         return this.complement(IntervalSet.of(minElement,maxElement));
     }
 
-    /** Given the set of possible values (rather than, say UNICODE or MAXINT),
-     *  return a new set containing all elements in vocabulary, but not in
-     *  this.  The computation is (vocabulary - this).
-     *
-     *  'this' is assumed to be either a subset or equal to vocabulary.
-     */
+    /** {@inheritDoc} */
     @Override
     public IntervalSet complement(IntSet vocabulary) {
-        if ( vocabulary==null ) {
-            return null; // nothing in common with null set
-        }
-		if ( !(vocabulary instanceof IntervalSet ) ) {
-			throw new IllegalArgumentException("can't complement with non IntervalSet ("+
-											   vocabulary.getClass().getName()+")");
+		if ( vocabulary==null || vocabulary.isNil() ) {
+			return null; // nothing in common with null set
 		}
-		IntervalSet vocabularyIS = ((IntervalSet)vocabulary);
-		int maxElement = vocabularyIS.getMaxElement();
 
-		IntervalSet compl = new IntervalSet();
-		int n = intervals.size();
-		if ( n ==0 ) {
-			return compl;
+		IntervalSet vocabularyIS;
+		if (vocabulary instanceof IntervalSet) {
+			vocabularyIS = (IntervalSet)vocabulary;
 		}
-		Interval first = intervals.get(0);
-		// add a range from 0 to first.a constrained to vocab
-		if ( first.a > 0 ) {
-			IntervalSet s = IntervalSet.of(0, first.a-1);
-			IntervalSet a = s.and(vocabularyIS);
-			compl.addAll(a);
+		else {
+			vocabularyIS = new IntervalSet();
+			vocabularyIS.addAll(vocabulary);
 		}
-		for (int i=1; i<n; i++) { // from 2nd interval .. nth
-			Interval previous = intervals.get(i-1);
-			Interval current = intervals.get(i);
-			IntervalSet s = IntervalSet.of(previous.b+1, current.a-1);
-			IntervalSet a = s.and(vocabularyIS);
-			compl.addAll(a);
-		}
-		Interval last = intervals.get(n -1);
-		// add a range from last.b to maxElement constrained to vocab
-		if ( last.b < maxElement ) {
-			IntervalSet s = IntervalSet.of(last.b+1, maxElement);
-			IntervalSet a = s.and(vocabularyIS);
-			compl.addAll(a);
-		}
-		return compl;
+
+		return vocabularyIS.subtract(this);
     }
 
-	/** Compute this-other via this&~other.
-	 *  Return a new set containing all elements in this but not in other.
-	 *  other is assumed to be a subset of this;
-     *  anything that is in other but not in this will be ignored.
-	 */
 	@Override
-	public IntervalSet subtract(IntSet other) {
-		// assume the whole unicode range here for the complement
-		// because it doesn't matter.  Anything beyond the max of this' set
-		// will be ignored since we are doing this & ~other.  The intersection
-		// will be empty.  The only problem would be when this' set max value
-		// goes beyond MAX_CHAR_VALUE, but hopefully the constant MAX_CHAR_VALUE
-		// will prevent this.
-		return this.and(((IntervalSet)other).complement(COMPLETE_CHAR_SET));
+	public IntervalSet subtract(IntSet a) {
+		if (a == null || a.isNil()) {
+			return new IntervalSet(this);
+		}
+
+		if (a instanceof IntervalSet) {
+			return subtract(this, (IntervalSet)a);
+		}
+
+		IntervalSet other = new IntervalSet();
+		other.addAll(a);
+		return subtract(this, other);
+	}
+
+	/**
+	 * Compute the set difference between two interval sets. The specific
+	 * operation is {@code left - right}. If either of the input sets is
+	 * {@code null}, it is treated as though it was an empty set.
+	 */
+
+	public static IntervalSet subtract(IntervalSet left, IntervalSet right) {
+		if (left == null || left.isNil()) {
+			return new IntervalSet();
+		}
+
+		IntervalSet result = new IntervalSet(left);
+		if (right == null || right.isNil()) {
+			// right set has no elements; just return the copy of the current set
+			return result;
+		}
+
+		int resultI = 0;
+		int rightI = 0;
+		while (resultI < result.intervals.size() && rightI < right.intervals.size()) {
+			Interval resultInterval = result.intervals.get(resultI);
+			Interval rightInterval = right.intervals.get(rightI);
+
+			// operation: (resultInterval - rightInterval) and update indexes
+
+			if (rightInterval.b < resultInterval.a) {
+				rightI++;
+				continue;
+			}
+
+			if (rightInterval.a > resultInterval.b) {
+				resultI++;
+				continue;
+			}
+
+			Interval beforeCurrent = null;
+			Interval afterCurrent = null;
+			if (rightInterval.a > resultInterval.a) {
+				beforeCurrent = new Interval(resultInterval.a, rightInterval.a - 1);
+			}
+
+			if (rightInterval.b < resultInterval.b) {
+				afterCurrent = new Interval(rightInterval.b + 1, resultInterval.b);
+			}
+
+			if (beforeCurrent != null) {
+				if (afterCurrent != null) {
+					// split the current interval into two
+					result.intervals.set(resultI, beforeCurrent);
+					result.intervals.add(resultI + 1, afterCurrent);
+					resultI++;
+					rightI++;
+					continue;
+				}
+				else {
+					// replace the current interval
+					result.intervals.set(resultI, beforeCurrent);
+					resultI++;
+					continue;
+				}
+			}
+			else {
+				if (afterCurrent != null) {
+					// replace the current interval
+					result.intervals.set(resultI, afterCurrent);
+					rightI++;
+					continue;
+				}
+				else {
+					// remove the current interval (thus no need to increment resultI)
+					result.intervals.remove(resultI);
+					continue;
+				}
+			}
+		}
+
+		// If rightI reached right.intervals.size(), no more intervals to subtract from result.
+		// If resultI reached result.intervals.size(), we would be subtracting from an empty set.
+		// Either way, we are done.
+		return result;
 	}
 
 	@Override
@@ -270,11 +334,7 @@ public class IntervalSet implements IntSet {
 		return o;
 	}
 
-    /** Return a new set with the intersection of this set with other.  Because
-     *  the intervals are sorted, we can use an iterator for each list and
-     *  just walk them together.  This is roughly O(min(n,m)) for interval
-     *  list lengths n and m.
-     */
+    /** {@inheritDoc} */
 	@Override
 	public IntervalSet and(IntSet other) {
 		if ( other==null ) { //|| !(other instanceof IntervalSet) ) {
@@ -344,7 +404,7 @@ public class IntervalSet implements IntSet {
 		return intersection;
 	}
 
-    /** Is el in any range of this set? */
+    /** {@inheritDoc} */
     @Override
     public boolean contains(int el) {
 		int n = intervals.size();
@@ -374,13 +434,13 @@ public class IntervalSet implements IntSet {
         */
     }
 
-    /** return true if this set has no members */
+    /** {@inheritDoc} */
     @Override
     public boolean isNil() {
         return intervals==null || intervals.isEmpty();
     }
 
-    /** If this set is a single integer, return it otherwise Token.INVALID_TYPE */
+    /** {@inheritDoc} */
     @Override
     public int getSingleElement() {
         if ( intervals!=null && intervals.size()==1 ) {
@@ -392,6 +452,12 @@ public class IntervalSet implements IntSet {
         return Token.INVALID_TYPE;
     }
 
+	/**
+	 * Returns the maximum value contained in the set.
+	 *
+	 * @return the maximum value contained in the set. If the set is empty, this
+	 * method returns {@link Token#INVALID_TYPE}.
+	 */
 	public int getMaxElement() {
 		if ( isNil() ) {
 			return Token.INVALID_TYPE;
@@ -400,21 +466,18 @@ public class IntervalSet implements IntSet {
 		return last.b;
 	}
 
-	/** Return minimum element >= 0 */
+	/**
+	 * Returns the minimum value contained in the set.
+	 *
+	 * @return the minimum value contained in the set. If the set is empty, this
+	 * method returns {@link Token#INVALID_TYPE}.
+	 */
 	public int getMinElement() {
 		if ( isNil() ) {
 			return Token.INVALID_TYPE;
 		}
-		int n = intervals.size();
-		for (int i = 0; i < n; i++) {
-			Interval I = intervals.get(i);
-			int a = I.a;
-			int b = I.b;
-			for (int v=a; v<=b; v++) {
-				if ( v>=0 ) return v;
-			}
-		}
-		return Token.INVALID_TYPE;
+
+		return intervals.get(0).a;
 	}
 
     /** Return a list of Interval objects. */
@@ -465,7 +528,7 @@ public class IntervalSet implements IntSet {
 			int a = I.a;
 			int b = I.b;
 			if ( a==b ) {
-				if ( a==-1 ) buf.append("<EOF>");
+				if ( a==Token.EOF ) buf.append("<EOF>");
 				else if ( elemAreChar ) buf.append("'").append((char)a).append("'");
 				else buf.append(a);
 			}
@@ -483,7 +546,15 @@ public class IntervalSet implements IntSet {
 		return buf.toString();
 	}
 
+	/**
+	 * @deprecated Use {@link #toString(Vocabulary)} instead.
+	 */
+	@Deprecated
 	public String toString(String[] tokenNames) {
+		return toString(VocabularyImpl.fromTokenNames(tokenNames));
+	}
+
+	public String toString(Vocabulary vocabulary) {
 		StringBuilder buf = new StringBuilder();
 		if ( this.intervals==null || this.intervals.isEmpty() ) {
 			return "{}";
@@ -497,12 +568,12 @@ public class IntervalSet implements IntSet {
 			int a = I.a;
 			int b = I.b;
 			if ( a==b ) {
-				buf.append(elementName(tokenNames, a));
+				buf.append(elementName(vocabulary, a));
 			}
 			else {
 				for (int i=a; i<=b; i++) {
 					if ( i>a ) buf.append(", ");
-                    buf.append(elementName(tokenNames, i));
+                    buf.append(elementName(vocabulary, i));
 				}
 			}
 			if ( iter.hasNext() ) {
@@ -515,12 +586,26 @@ public class IntervalSet implements IntSet {
         return buf.toString();
     }
 
-    protected String elementName(String[] tokenNames, int a) {
-        if ( a==Token.EOF ) return "<EOF>";
-        else if ( a==Token.EPSILON ) return "<EPSILON>";
-        else return tokenNames[a];
+	/**
+	 * @deprecated Use {@link #elementName(Vocabulary, int)} instead.
+	 */
+	@Deprecated
+	protected String elementName(String[] tokenNames, int a) {
+		return elementName(VocabularyImpl.fromTokenNames(tokenNames), a);
+	}
 
-    }
+
+	protected String elementName(Vocabulary vocabulary, int a) {
+		if (a == Token.EOF) {
+			return "<EOF>";
+		}
+		else if (a == Token.EPSILON) {
+			return "<EPSILON>";
+		}
+		else {
+			return vocabulary.getDisplayName(a);
+		}
+	}
 
     @Override
     public int size() {
@@ -643,6 +728,7 @@ public class IntervalSet implements IntSet {
     }
 
     public void setReadonly(boolean readonly) {
+        if ( this.readonly && !readonly ) throw new IllegalStateException("can't alter readonly IntervalSet");
         this.readonly = readonly;
     }
 }
diff --git a/runtime/Java/src/org/antlr/v4/runtime/misc/LogManager.java b/runtime/Java/src/org/antlr/v4/runtime/misc/LogManager.java
index b3ea4f92a..e3e998516 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/misc/LogManager.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/misc/LogManager.java
@@ -67,7 +67,7 @@ public class LogManager {
 
 	protected List<Record> records;
 
-	public void log(@Nullable String component, String msg) {
+	public void log(String component, String msg) {
 		Record r = new Record();
 		r.component = component;
 		r.msg = msg;
diff --git a/runtime/Java/src/org/antlr/v4/runtime/misc/NotNull.java b/runtime/Java/src/org/antlr/v4/runtime/misc/NotNull.java
index 8beacf2ee..1277d8da0 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/misc/NotNull.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/misc/NotNull.java
@@ -27,11 +27,19 @@
  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-
 package org.antlr.v4.runtime.misc;
 
-@java.lang.annotation.Documented
-@java.lang.annotation.Retention(java.lang.annotation.RetentionPolicy.CLASS)
-@java.lang.annotation.Target({java.lang.annotation.ElementType.FIELD, java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.PARAMETER, java.lang.annotation.ElementType.LOCAL_VARIABLE})
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/** @deprecated THIS IS HERE FOR BACKWARD COMPATIBILITY WITH 4.5 ONLY.  It will
+ *  disappear in 4.6+
+ */
+@Documented
+@Retention(RetentionPolicy.CLASS)
+@Target({ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.LOCAL_VARIABLE})
 public @interface NotNull {
 }
diff --git a/runtime/Java/src/org/antlr/v4/runtime/misc/ObjectEqualityComparator.java b/runtime/Java/src/org/antlr/v4/runtime/misc/ObjectEqualityComparator.java
index d4560c2f3..576e06fb6 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/misc/ObjectEqualityComparator.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/misc/ObjectEqualityComparator.java
@@ -40,9 +40,9 @@ public final class ObjectEqualityComparator extends AbstractEqualityComparator<O
 
 	/**
 	 * {@inheritDoc}
-	 * <p/>
-	 * This implementation returns
-	 * {@code obj.}{@link Object#hashCode hashCode()}.
+	 *
+	 * <p>This implementation returns
+	 * {@code obj.}{@link Object#hashCode hashCode()}.</p>
 	 */
 	@Override
 	public int hashCode(Object obj) {
@@ -55,12 +55,12 @@ public final class ObjectEqualityComparator extends AbstractEqualityComparator<O
 
 	/**
 	 * {@inheritDoc}
-	 * <p/>
-	 * This implementation relies on object equality. If both objects are
+	 *
+	 * <p>This implementation relies on object equality. If both objects are
 	 * {@code null}, this method returns {@code true}. Otherwise if only
 	 * {@code a} is {@code null}, this method returns {@code false}. Otherwise,
 	 * this method returns the result of
-	 * {@code a.}{@link Object#equals equals}{@code (b)}.
+	 * {@code a.}{@link Object#equals equals}{@code (b)}.</p>
 	 */
 	@Override
 	public boolean equals(Object a, Object b) {
diff --git a/runtime/Java/src/org/antlr/v4/runtime/misc/Pair.java b/runtime/Java/src/org/antlr/v4/runtime/misc/Pair.java
index 4ff0c7ef6..2b11efd06 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/misc/Pair.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/misc/Pair.java
@@ -30,7 +30,9 @@
 
 package org.antlr.v4.runtime.misc;
 
-public class Pair<A,B> {
+import java.io.Serializable;
+
+public class Pair<A,B> implements Serializable {
 	public final A a;
 	public final B b;
 
@@ -38,4 +40,31 @@ public class Pair<A,B> {
 		this.a = a;
 		this.b = b;
 	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (obj == this) {
+			return true;
+		}
+		else if (!(obj instanceof Pair<?, ?>)) {
+			return false;
+		}
+
+		Pair<?, ?> other = (Pair<?, ?>)obj;
+		return ObjectEqualityComparator.INSTANCE.equals(a, other.a)
+			&& ObjectEqualityComparator.INSTANCE.equals(b, other.b);
+	}
+
+	@Override
+	public int hashCode() {
+		int hash = MurmurHash.initialize();
+		hash = MurmurHash.update(hash, a);
+		hash = MurmurHash.update(hash, b);
+		return MurmurHash.finish(hash, 2);
+	}
+
+	@Override
+	public String toString() {
+		return String.format("(%s, %s)", a, b);
+	}
 }
diff --git a/runtime/Java/src/org/antlr/v4/runtime/misc/Predicate.java b/runtime/Java/src/org/antlr/v4/runtime/misc/Predicate.java
new file mode 100644
index 000000000..41c9af058
--- /dev/null
+++ b/runtime/Java/src/org/antlr/v4/runtime/misc/Predicate.java
@@ -0,0 +1,5 @@
+package org.antlr.v4.runtime.misc;
+
+public interface Predicate<T> {
+	boolean test(T t);
+}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/misc/TestRig.java b/runtime/Java/src/org/antlr/v4/runtime/misc/TestRig.java
index 6c35a9028..9f656fea5 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/misc/TestRig.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/misc/TestRig.java
@@ -1,270 +1,29 @@
-/*
- * [The "BSD license"]
- *  Copyright (c) 2012 Terence Parr
- *  Copyright (c) 2012 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.
- */
-
 package org.antlr.v4.runtime.misc;
 
-import org.antlr.v4.runtime.ANTLRInputStream;
-import org.antlr.v4.runtime.CharStream;
-import org.antlr.v4.runtime.CommonTokenStream;
-import org.antlr.v4.runtime.DiagnosticErrorListener;
-import org.antlr.v4.runtime.Lexer;
-import org.antlr.v4.runtime.Parser;
-import org.antlr.v4.runtime.ParserRuleContext;
-import org.antlr.v4.runtime.TokenStream;
-import org.antlr.v4.runtime.atn.PredictionMode;
-
-import javax.print.PrintException;
-import java.io.FileInputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.io.Reader;
-import java.lang.reflect.Constructor;
-import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
-import java.util.ArrayList;
-import java.util.List;
 
-/** Run a lexer/parser combo, optionally printing tree string or generating
- *  postscript file. Optionally taking input file.
+/** A proxy for the real org.antlr.v4.gui.TestRig that we moved to tool
+ *  artifact from runtime.
  *
- *  $ java org.antlr.v4.runtime.misc.TestRig GrammarName startRuleName
- *        [-tree]
- *        [-tokens] [-gui] [-ps file.ps]
- *        [-trace]
- *        [-diagnostics]
- *        [-SLL]
- *        [input-filename(s)]
+ *  @deprecated
+ *  @since 4.5.1
  */
 public class TestRig {
-	public static final String LEXER_START_RULE_NAME = "tokens";
-
-	protected String grammarName;
-	protected String startRuleName;
-	protected final List<String> inputFiles = new ArrayList<String>();
-	protected boolean printTree = false;
-	protected boolean gui = false;
-	protected String psFile = null;
-	protected boolean showTokens = false;
-	protected boolean trace = false;
-	protected boolean diagnostics = false;
-	protected String encoding = null;
-	protected boolean SLL = false;
-
-	public TestRig(String[] args) throws Exception {
-		if ( args.length < 2 ) {
-			System.err.println("java org.antlr.v4.runtime.misc.TestRig GrammarName startRuleName\n" +
-							   "  [-tokens] [-tree] [-gui] [-ps file.ps] [-encoding encodingname]\n" +
-							   "  [-trace] [-diagnostics] [-SLL]\n"+
-							   "  [input-filename(s)]");
-			System.err.println("Use startRuleName='tokens' if GrammarName is a lexer grammar.");
-			System.err.println("Omitting input-filename makes rig read from stdin.");
-			return;
-		}
-		int i=0;
-		grammarName = args[i];
-		i++;
-		startRuleName = args[i];
-		i++;
-		while ( i<args.length ) {
-			String arg = args[i];
-			i++;
-			if ( arg.charAt(0)!='-' ) { // input file name
-				inputFiles.add(arg);
-				continue;
-			}
-			if ( arg.equals("-tree") ) {
-				printTree = true;
-			}
-			if ( arg.equals("-gui") ) {
-				gui = true;
-			}
-			if ( arg.equals("-tokens") ) {
-				showTokens = true;
-			}
-			else if ( arg.equals("-trace") ) {
-				trace = true;
-			}
-			else if ( arg.equals("-SLL") ) {
-				SLL = true;
-			}
-			else if ( arg.equals("-diagnostics") ) {
-				diagnostics = true;
-			}
-			else if ( arg.equals("-encoding") ) {
-				if ( i>=args.length ) {
-					System.err.println("missing encoding on -encoding");
-					return;
-				}
-				encoding = args[i];
-				i++;
-			}
-			else if ( arg.equals("-ps") ) {
-				if ( i>=args.length ) {
-					System.err.println("missing filename on -ps");
-					return;
-				}
-				psFile = args[i];
-				i++;
-			}
-		}
-	}
-
-	public static void main(String[] args) throws Exception {
-		TestRig testRig = new TestRig(args);
- 		if(args.length >= 2) {
-			testRig.process();
-		}
-	}
-
-	public void process() throws Exception {
-//		System.out.println("exec "+grammarName+"."+startRuleName);
-		String lexerName = grammarName+"Lexer";
-		ClassLoader cl = Thread.currentThread().getContextClassLoader();
-		Class<? extends Lexer> lexerClass = null;
+	public static void main(String[] args) {
 		try {
-			lexerClass = cl.loadClass(lexerName).asSubclass(Lexer.class);
-		}
-		catch (java.lang.ClassNotFoundException cnfe) {
-			// might be pure lexer grammar; no Lexer suffix then
-			lexerName = grammarName;
+			Class<?> testRigClass = Class.forName("org.antlr.v4.gui.TestRig");
+			System.err.println("Warning: TestRig moved to org.antlr.v4.gui.TestRig; calling automatically");
 			try {
-				lexerClass = cl.loadClass(lexerName).asSubclass(Lexer.class);
+				Method mainMethod = testRigClass.getMethod("main", String[].class);
+				mainMethod.invoke(null, (Object)args);
 			}
-			catch (ClassNotFoundException cnfe2) {
-				System.err.println("Can't load "+lexerName+" as lexer or parser");
-				return;
+			catch (Exception nsme) {
+				System.err.println("Problems calling org.antlr.v4.gui.TestRig.main(args)");
 			}
 		}
-
-		Constructor<? extends Lexer> lexerCtor = lexerClass.getConstructor(CharStream.class);
-		Lexer lexer = lexerCtor.newInstance((CharStream)null);
-
-		Class<? extends Parser> parserClass = null;
-		Parser parser = null;
-		if ( !startRuleName.equals(LEXER_START_RULE_NAME) ) {
-			String parserName = grammarName+"Parser";
-			parserClass = cl.loadClass(parserName).asSubclass(Parser.class);
-			if ( parserClass==null ) {
-				System.err.println("Can't load "+parserName);
-			}
-			Constructor<? extends Parser> parserCtor = parserClass.getConstructor(TokenStream.class);
-			parser = parserCtor.newInstance((TokenStream)null);
-		}
-
-		if ( inputFiles.size()==0 ) {
-			InputStream is = System.in;
-			Reader r;
-			if ( encoding!=null ) {
-				r = new InputStreamReader(is, encoding);
-			}
-			else {
-				r = new InputStreamReader(is);
-			}
-
-			process(lexer, parserClass, parser, is, r);
-			return;
-		}
-		for (String inputFile : inputFiles) {
-			InputStream is = System.in;
-			if ( inputFile!=null ) {
-				is = new FileInputStream(inputFile);
-			}
-			Reader r;
-			if ( encoding!=null ) {
-				r = new InputStreamReader(is, encoding);
-			}
-			else {
-				r = new InputStreamReader(is);
-			}
-
-			if ( inputFiles.size()>1 ) {
-				System.err.println(inputFile);
-			}
-			process(lexer, parserClass, parser, is, r);
-		}
-	}
-
-	protected void process(Lexer lexer, Class<? extends Parser> parserClass, Parser parser, InputStream is, Reader r) throws IOException, IllegalAccessException, InvocationTargetException, PrintException {
-		try {
-			ANTLRInputStream input = new ANTLRInputStream(r);
-			lexer.setInputStream(input);
-			CommonTokenStream tokens = new CommonTokenStream(lexer);
-
-			tokens.fill();
-
-			if ( showTokens ) {
-				for (Object tok : tokens.getTokens()) {
-					System.out.println(tok);
-				}
-			}
-
-			if ( startRuleName.equals(LEXER_START_RULE_NAME) ) return;
-
-			if ( diagnostics ) {
-				parser.addErrorListener(new DiagnosticErrorListener());
-				parser.getInterpreter().setPredictionMode(PredictionMode.LL_EXACT_AMBIG_DETECTION);
-			}
-
-			if ( printTree || gui || psFile!=null ) {
-				parser.setBuildParseTree(true);
-			}
-
-			if ( SLL ) { // overrides diagnostics
-				parser.getInterpreter().setPredictionMode(PredictionMode.SLL);
-			}
-
-			parser.setTokenStream(tokens);
-			parser.setTrace(trace);
-
-			try {
-				Method startRule = parserClass.getMethod(startRuleName);
-				ParserRuleContext tree = (ParserRuleContext)startRule.invoke(parser, (Object[])null);
-
-				if ( printTree ) {
-					System.out.println(tree.toStringTree(parser));
-				}
-				if ( gui ) {
-					tree.inspect(parser);
-				}
-				if ( psFile!=null ) {
-					tree.save(parser, psFile); // Generate postscript
-				}
-			}
-			catch (NoSuchMethodException nsme) {
-				System.err.println("No method for rule "+startRuleName+" or it has arguments");
-			}
-		}
-		finally {
-			if ( r!=null ) r.close();
-			if ( is!=null ) is.close();
+		catch (ClassNotFoundException cnfe) {
+			System.err.println("Use of TestRig now requires the use of the tool jar, antlr-4.X-complete.jar");
+			System.err.println("Maven users need group ID org.antlr and artifact ID antlr4");
 		}
 	}
 }
diff --git a/runtime/Java/src/org/antlr/v4/runtime/misc/Triple.java b/runtime/Java/src/org/antlr/v4/runtime/misc/Triple.java
index f4ff63955..ad8c216df 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/misc/Triple.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/misc/Triple.java
@@ -41,4 +41,32 @@ public class Triple<A,B,C> {
 		this.c = c;
 	}
 
+	@Override
+	public boolean equals(Object obj) {
+		if (obj == this) {
+			return true;
+		}
+		else if (!(obj instanceof Triple<?, ?, ?>)) {
+			return false;
+		}
+
+		Triple<?, ?, ?> other = (Triple<?, ?, ?>)obj;
+		return ObjectEqualityComparator.INSTANCE.equals(a, other.a)
+			&& ObjectEqualityComparator.INSTANCE.equals(b, other.b)
+			&& ObjectEqualityComparator.INSTANCE.equals(c, other.c);
+	}
+
+	@Override
+	public int hashCode() {
+		int hash = MurmurHash.initialize();
+		hash = MurmurHash.update(hash, a);
+		hash = MurmurHash.update(hash, b);
+		hash = MurmurHash.update(hash, c);
+		return MurmurHash.finish(hash, 3);
+	}
+
+	@Override
+	public String toString() {
+		return String.format("(%s, %s, %s)", a, b, c);
+	}
 }
diff --git a/runtime/Java/src/org/antlr/v4/runtime/misc/Utils.java b/runtime/Java/src/org/antlr/v4/runtime/misc/Utils.java
index 7cda40152..991ee2b35 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/misc/Utils.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/misc/Utils.java
@@ -30,13 +30,14 @@
 
 package org.antlr.v4.runtime.misc;
 
-import java.awt.*;
-import java.awt.event.WindowAdapter;
-import java.awt.event.WindowEvent;
-import java.io.BufferedWriter;
-import java.io.FileWriter;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
 import java.io.IOException;
-import java.io.Writer;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.util.Arrays;
+import java.util.BitSet;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.Iterator;
@@ -94,50 +95,61 @@ public class Utils {
 	}
 
 	public static void writeFile(String fileName, String content) throws IOException {
-		FileWriter fw = new FileWriter(fileName);
-		Writer w = new BufferedWriter(fw);
+		writeFile(fileName, content, null);
+	}
+
+	public static void writeFile(String fileName, String content, String encoding) throws IOException {
+		File f = new File(fileName);
+		FileOutputStream fos = new FileOutputStream(f);
+		OutputStreamWriter osw;
+		if (encoding != null) {
+			osw = new OutputStreamWriter(fos, encoding);
+		}
+		else {
+			osw = new OutputStreamWriter(fos);
+		}
+
 		try {
-			w.write(content);
+			osw.write(content);
 		}
 		finally {
-			w.close();
+			osw.close();
 		}
 	}
 
-	public static void waitForClose(final Window window) throws InterruptedException {
-		final Object lock = new Object();
 
-		Thread t = new Thread() {
-			@Override
-			public void run() {
-				synchronized (lock) {
-					while (window.isVisible()) {
-						try {
-							lock.wait(500);
-						} catch (InterruptedException e) {
-						}
-					}
-				}
-			}
-		};
-
-		t.start();
-
-		window.addWindowListener(new WindowAdapter() {
-			@Override
-			public void windowClosing(WindowEvent arg0) {
-				synchronized (lock) {
-					window.setVisible(false);
-					lock.notify();
-				}
-			}
-		});
-
-		t.join();
+	public static char[] readFile(String fileName) throws IOException {
+		return readFile(fileName, null);
 	}
 
-	/** Convert array of strings to string->index map. Useful for
-	 *  converting rulenames to name->ruleindex map.
+
+	public static char[] readFile(String fileName, String encoding) throws IOException {
+		File f = new File(fileName);
+		int size = (int)f.length();
+		InputStreamReader isr;
+		FileInputStream fis = new FileInputStream(fileName);
+		if ( encoding!=null ) {
+			isr = new InputStreamReader(fis, encoding);
+		}
+		else {
+			isr = new InputStreamReader(fis);
+		}
+		char[] data = null;
+		try {
+			data = new char[size];
+			int n = isr.read(data);
+			if (n < data.length) {
+				data = Arrays.copyOf(data, n);
+			}
+		}
+		finally {
+			isr.close();
+		}
+		return data;
+	}
+
+	/** Convert array of strings to string&rarr;index map. Useful for
+	 *  converting rulenames to name&rarr;ruleindex map.
 	 */
 	public static Map<String, Integer> toMap(String[] keys) {
 		Map<String, Integer> m = new HashMap<String, Integer>();
@@ -155,4 +167,14 @@ public class Utils {
 		}
 		return cdata;
 	}
+
+	public static IntervalSet toSet(BitSet bits) {
+		IntervalSet s = new IntervalSet();
+		int i = bits.nextSetBit(0);
+		while ( i >= 0 ) {
+			s.add(i);
+			i = bits.nextSetBit(i+1);
+		}
+		return s;
+	}
 }
diff --git a/runtime/Java/src/org/antlr/v4/runtime/tree/AbstractParseTreeVisitor.java b/runtime/Java/src/org/antlr/v4/runtime/tree/AbstractParseTreeVisitor.java
index 2bbf3a4af..9477d96fb 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/tree/AbstractParseTreeVisitor.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/tree/AbstractParseTreeVisitor.java
@@ -30,33 +30,35 @@
 
 package org.antlr.v4.runtime.tree;
 
-import org.antlr.v4.runtime.misc.NotNull;
-
 public abstract class AbstractParseTreeVisitor<T> implements ParseTreeVisitor<T> {
 	/**
 	 * {@inheritDoc}
-	 * <p/>
-	 * The default implementation calls {@link ParseTree#accept} on the
-	 * specified tree.
+	 *
+	 * <p>The default implementation calls {@link ParseTree#accept} on the
+	 * specified tree.</p>
 	 */
 	@Override
-	public T visit(@NotNull ParseTree tree) {
+	public T visit(ParseTree tree) {
 		return tree.accept(this);
 	}
 
 	/**
 	 * {@inheritDoc}
-	 * <p/>
-	 * The default implementation initializes the aggregate result to
+	 *
+	 * <p>The default implementation initializes the aggregate result to
 	 * {@link #defaultResult defaultResult()}. Before visiting each child, it
 	 * calls {@link #shouldVisitNextChild shouldVisitNextChild}; if the result
 	 * is {@code false} no more children are visited and the current aggregate
 	 * result is returned. After visiting a child, the aggregate result is
 	 * updated by calling {@link #aggregateResult aggregateResult} with the
-	 * previous aggregate result and the result of visiting the child.
+	 * previous aggregate result and the result of visiting the child.</p>
+	 *
+	 * <p>The default implementation is not safe for use in visitors that modify
+	 * the tree structure. Visitors that modify the tree should override this
+	 * method to behave properly in respect to the specific algorithm in use.</p>
 	 */
 	@Override
-	public T visitChildren(@NotNull RuleNode node) {
+	public T visitChildren(RuleNode node) {
 		T result = defaultResult();
 		int n = node.getChildCount();
 		for (int i=0; i<n; i++) {
@@ -74,23 +76,23 @@ public abstract class AbstractParseTreeVisitor<T> implements ParseTreeVisitor<T>
 
 	/**
 	 * {@inheritDoc}
-	 * <p/>
-	 * The default implementation returns the result of
-	 * {@link #defaultResult defaultResult}.
+	 *
+	 * <p>The default implementation returns the result of
+	 * {@link #defaultResult defaultResult}.</p>
 	 */
 	@Override
-	public T visitTerminal(@NotNull TerminalNode node) {
+	public T visitTerminal(TerminalNode node) {
 		return defaultResult();
 	}
 
 	/**
 	 * {@inheritDoc}
-	 * <p/>
-	 * The default implementation returns the result of
-	 * {@link #defaultResult defaultResult}.
+	 *
+	 * <p>The default implementation returns the result of
+	 * {@link #defaultResult defaultResult}.</p>
 	 */
 	@Override
-	public T visitErrorNode(@NotNull ErrorNode node) {
+	public T visitErrorNode(ErrorNode node) {
 		return defaultResult();
 	}
 
@@ -100,8 +102,8 @@ public abstract class AbstractParseTreeVisitor<T> implements ParseTreeVisitor<T>
 	 * {@link #visitTerminal visitTerminal}, {@link #visitErrorNode visitErrorNode}.
 	 * The default implementation of {@link #visitChildren visitChildren}
 	 * initializes its aggregate result to this value.
-	 * <p/>
-	 * The base implementation returns {@code null}.
+	 *
+	 * <p>The base implementation returns {@code null}.</p>
 	 *
 	 * @return The default value returned by visitor methods.
 	 */
@@ -114,10 +116,10 @@ public abstract class AbstractParseTreeVisitor<T> implements ParseTreeVisitor<T>
 	 * either all children are visited or {@link #shouldVisitNextChild} returns
 	 * {@code false}, the aggregate value is returned as the result of
 	 * {@link #visitChildren}.
-	 * <p/>
-	 * The default implementation returns {@code nextResult}, meaning
+	 *
+	 * <p>The default implementation returns {@code nextResult}, meaning
 	 * {@link #visitChildren} will return the result of the last child visited
-	 * (or return the initial value if the node has no children).
+	 * (or return the initial value if the node has no children).</p>
 	 *
 	 * @param aggregate The previous aggregate value. In the default
 	 * implementation, the aggregate value is initialized to
@@ -139,13 +141,13 @@ public abstract class AbstractParseTreeVisitor<T> implements ParseTreeVisitor<T>
 	 * value (in the default implementation, the initial value is returned by a
 	 * call to {@link #defaultResult}. This method is not called after the last
 	 * child is visited.
-	 * <p/>
-	 * The default implementation always returns {@code true}, indicating that
+	 *
+	 * <p>The default implementation always returns {@code true}, indicating that
 	 * {@code visitChildren} should only return after all children are visited.
 	 * One reason to override this method is to provide a "short circuit"
 	 * evaluation option for situations where the result of visiting a single
 	 * child has the potential to determine the result of the visit operation as
-	 * a whole.
+	 * a whole.</p>
 	 *
 	 * @param node The {@link RuleNode} whose children are currently being
 	 * visited.
@@ -156,7 +158,7 @@ public abstract class AbstractParseTreeVisitor<T> implements ParseTreeVisitor<T>
 	 * {@code false} to stop visiting children and immediately return the
 	 * current aggregate result from {@link #visitChildren}.
 	 */
-	protected boolean shouldVisitNextChild(@NotNull RuleNode node, T currentResult) {
+	protected boolean shouldVisitNextChild(RuleNode node, T currentResult) {
 		return true;
 	}
 
diff --git a/runtime/Java/src/org/antlr/v4/runtime/tree/ParseTree.java b/runtime/Java/src/org/antlr/v4/runtime/tree/ParseTree.java
index ccdeab8ad..7b490402b 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/tree/ParseTree.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/tree/ParseTree.java
@@ -38,8 +38,8 @@ import org.antlr.v4.runtime.Token;
  *  during a parse that makes the data structure look like a simple parse tree.
  *  This node represents both internal nodes, rule invocations,
  *  and leaf nodes, token matches.
- * <p/>
- *  The payload is either a {@link Token} or a {@link RuleContext} object.
+ *
+ *  <p>The payload is either a {@link Token} or a {@link RuleContext} object.</p>
  */
 public interface ParseTree extends SyntaxTree {
 	// the following methods narrow the return type; they are not additional methods
diff --git a/runtime/Java/src/org/antlr/v4/runtime/tree/ParseTreeListener.java b/runtime/Java/src/org/antlr/v4/runtime/tree/ParseTreeListener.java
index f90420bca..913e0bdd0 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/tree/ParseTreeListener.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/tree/ParseTreeListener.java
@@ -31,11 +31,21 @@
 package org.antlr.v4.runtime.tree;
 
 import org.antlr.v4.runtime.ParserRuleContext;
-import org.antlr.v4.runtime.misc.NotNull;
 
+/** This interface describes the minimal core of methods triggered
+ *  by {@link ParseTreeWalker}. E.g.,
+ *
+ *  	ParseTreeWalker walker = new ParseTreeWalker();
+ *		walker.walk(myParseTreeListener, myParseTree); <-- triggers events in your listener
+ *
+ *  If you want to trigger events in multiple listeners during a single
+ *  tree walk, you can use the ParseTreeDispatcher object available at
+ *
+ * 		https://github.com/antlr/antlr4/issues/841
+ */
 public interface ParseTreeListener {
-	void visitTerminal(@NotNull TerminalNode node);
-	void visitErrorNode(@NotNull ErrorNode node);
-    void enterEveryRule(@NotNull ParserRuleContext ctx);
-    void exitEveryRule(@NotNull ParserRuleContext ctx);
+	void visitTerminal(TerminalNode node);
+	void visitErrorNode(ErrorNode node);
+    void enterEveryRule(ParserRuleContext ctx);
+    void exitEveryRule(ParserRuleContext ctx);
 }
diff --git a/runtime/Java/src/org/antlr/v4/runtime/tree/ParseTreeVisitor.java b/runtime/Java/src/org/antlr/v4/runtime/tree/ParseTreeVisitor.java
index 0bff07989..48522db94 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/tree/ParseTreeVisitor.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/tree/ParseTreeVisitor.java
@@ -30,8 +30,6 @@
 
 package org.antlr.v4.runtime.tree;
 
-import org.antlr.v4.runtime.misc.NotNull;
-
 /**
  * This interface defines the basic notion of a parse tree visitor. Generated
  * visitors implement this interface and the {@code XVisitor} interface for
@@ -48,7 +46,7 @@ public interface ParseTreeVisitor<T> {
 	 * @param tree The {@link ParseTree} to visit.
 	 * @return The result of visiting the parse tree.
 	 */
-	T visit(@NotNull ParseTree tree);
+	T visit(ParseTree tree);
 
 	/**
 	 * Visit the children of a node, and return a user-defined result of the
@@ -57,7 +55,7 @@ public interface ParseTreeVisitor<T> {
 	 * @param node The {@link RuleNode} whose children should be visited.
 	 * @return The result of visiting the children of the node.
 	 */
-	T visitChildren(@NotNull RuleNode node);
+	T visitChildren(RuleNode node);
 
 	/**
 	 * Visit a terminal node, and return a user-defined result of the operation.
@@ -65,7 +63,7 @@ public interface ParseTreeVisitor<T> {
 	 * @param node The {@link TerminalNode} to visit.
 	 * @return The result of visiting the node.
 	 */
-	T visitTerminal(@NotNull TerminalNode node);
+	T visitTerminal(TerminalNode node);
 
 	/**
 	 * Visit an error node, and return a user-defined result of the operation.
@@ -73,6 +71,6 @@ public interface ParseTreeVisitor<T> {
 	 * @param node The {@link ErrorNode} to visit.
 	 * @return The result of visiting the node.
 	 */
-	T visitErrorNode(@NotNull ErrorNode node);
+	T visitErrorNode(ErrorNode node);
 
 }
diff --git a/runtime/Java/src/org/antlr/v4/runtime/tree/SyntaxTree.java b/runtime/Java/src/org/antlr/v4/runtime/tree/SyntaxTree.java
index 76dbbc0f0..8a465905d 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/tree/SyntaxTree.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/tree/SyntaxTree.java
@@ -32,7 +32,6 @@ package org.antlr.v4.runtime.tree;
 
 import org.antlr.v4.runtime.TokenStream;
 import org.antlr.v4.runtime.misc.Interval;
-import org.antlr.v4.runtime.misc.NotNull;
 
 /** A tree that knows about an interval in a token stream
  *  is some kind of syntax tree. Subinterfaces distinguish
@@ -43,10 +42,17 @@ public interface SyntaxTree extends Tree {
 	 * Return an {@link Interval} indicating the index in the
 	 * {@link TokenStream} of the first and last token associated with this
 	 * subtree. If this node is a leaf, then the interval represents a single
-	 * token.
-	 * <p/>
-	 * If source interval is unknown, this returns {@link Interval#INVALID}.
+	 * token and has interval i..i for token index i.
+	 *
+	 * <p>An interval of i..i-1 indicates an empty interval at position
+	 * i in the input stream, where 0 &lt;= i &lt;= the size of the input
+	 * token stream.  Currently, the code base can only have i=0..n-1 but
+	 * in concept one could have an empty interval after EOF. </p>
+	 *
+	 * <p>If source interval is unknown, this returns {@link Interval#INVALID}.</p>
+	 *
+	 * <p>As a weird special case, the source interval for rules matched after
+	 * EOF is unspecified.</p>
 	 */
-	@NotNull
 	Interval getSourceInterval();
 }
diff --git a/runtime/Java/src/org/antlr/v4/runtime/tree/TerminalNodeImpl.java b/runtime/Java/src/org/antlr/v4/runtime/tree/TerminalNodeImpl.java
index 676375121..05e26306e 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/tree/TerminalNodeImpl.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/tree/TerminalNodeImpl.java
@@ -34,8 +34,6 @@ import org.antlr.v4.runtime.Parser;
 import org.antlr.v4.runtime.Token;
 import org.antlr.v4.runtime.misc.Interval;
 
-import java.util.List;
-
 public class TerminalNodeImpl implements TerminalNode {
 	public Token symbol;
 	public ParseTree parent;
diff --git a/runtime/Java/src/org/antlr/v4/runtime/tree/Tree.java b/runtime/Java/src/org/antlr/v4/runtime/tree/Tree.java
index b396962b3..119dbee7c 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/tree/Tree.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/tree/Tree.java
@@ -33,9 +33,6 @@ package org.antlr.v4.runtime.tree;
 import org.antlr.v4.runtime.RuleContext;
 import org.antlr.v4.runtime.Token;
 
-import java.util.Collection;
-import java.util.List;
-
 /** The basic notion of a tree has a parent, a payload, and a list of children.
  *  It is the most abstract interface for all the trees used by ANTLR.
  */
diff --git a/runtime/Java/src/org/antlr/v4/runtime/tree/Trees.java b/runtime/Java/src/org/antlr/v4/runtime/tree/Trees.java
index 9cd675f2e..3cb86683b 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/tree/Trees.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/tree/Trees.java
@@ -30,17 +30,16 @@
 
 package org.antlr.v4.runtime.tree;
 
+import org.antlr.v4.runtime.CommonToken;
 import org.antlr.v4.runtime.Parser;
 import org.antlr.v4.runtime.ParserRuleContext;
+import org.antlr.v4.runtime.RuleContext;
 import org.antlr.v4.runtime.Token;
-import org.antlr.v4.runtime.misc.NotNull;
-import org.antlr.v4.runtime.misc.Nullable;
+import org.antlr.v4.runtime.atn.ATN;
+import org.antlr.v4.runtime.misc.Interval;
+import org.antlr.v4.runtime.misc.Predicate;
 import org.antlr.v4.runtime.misc.Utils;
-import org.antlr.v4.runtime.tree.gui.TreePostScriptGenerator;
 
-import java.io.BufferedWriter;
-import java.io.FileWriter;
-import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
@@ -49,46 +48,11 @@ import java.util.List;
 
 /** A set of utility routines useful for all kinds of ANTLR trees. */
 public class Trees {
-
-	public static String getPS(Tree t, @Nullable List<String> ruleNames,
-							   String fontName, int fontSize)
-	{
-		TreePostScriptGenerator psgen =
-			new TreePostScriptGenerator(ruleNames, t, fontName, fontSize);
-		return psgen.getPS();
-	}
-
-	public static String getPS(Tree t, @Nullable List<String> ruleNames) {
-		return getPS(t, ruleNames, "Helvetica", 11);
-	}
-
-	public static void writePS(Tree t, @Nullable List<String> ruleNames,
-							   String fileName,
-							   String fontName, int fontSize)
-		throws IOException
-	{
-		String ps = getPS(t, ruleNames, fontName, fontSize);
-		FileWriter f = new FileWriter(fileName);
-		BufferedWriter bw = new BufferedWriter(f);
-		try {
-			bw.write(ps);
-		}
-		finally {
-			bw.close();
-		}
-	}
-
-	public static void writePS(Tree t, @Nullable List<String> ruleNames, String fileName)
-		throws IOException
-	{
-		writePS(t, ruleNames, fileName, "Helvetica", 11);
-	}
-
 	/** Print out a whole tree in LISP form. {@link #getNodeText} is used on the
 	 *  node payloads to get the text for the nodes.  Detect
 	 *  parse trees and extract data appropriately.
 	 */
-	public static String toStringTree(@NotNull Tree t) {
+	public static String toStringTree(Tree t) {
 		return toStringTree(t, (List<String>)null);
 	}
 
@@ -96,17 +60,16 @@ public class Trees {
 	 *  node payloads to get the text for the nodes.  Detect
 	 *  parse trees and extract data appropriately.
 	 */
-	public static String toStringTree(@NotNull Tree t, @Nullable Parser recog) {
+	public static String toStringTree(Tree t, Parser recog) {
 		String[] ruleNames = recog != null ? recog.getRuleNames() : null;
 		List<String> ruleNamesList = ruleNames != null ? Arrays.asList(ruleNames) : null;
 		return toStringTree(t, ruleNamesList);
 	}
 
 	/** Print out a whole tree in LISP form. {@link #getNodeText} is used on the
-	 *  node payloads to get the text for the nodes.  Detect
-	 *  parse trees and extract data appropriately.
+	 *  node payloads to get the text for the nodes.
 	 */
-	public static String toStringTree(@NotNull Tree t, @Nullable List<String> ruleNames) {
+	public static String toStringTree(final Tree t, final List<String> ruleNames) {
 		String s = Utils.escapeWhitespace(getNodeText(t, ruleNames), false);
 		if ( t.getChildCount()==0 ) return s;
 		StringBuilder buf = new StringBuilder();
@@ -122,17 +85,21 @@ public class Trees {
 		return buf.toString();
 	}
 
-	public static String getNodeText(@NotNull Tree t, @Nullable Parser recog) {
+	public static String getNodeText(Tree t, Parser recog) {
 		String[] ruleNames = recog != null ? recog.getRuleNames() : null;
 		List<String> ruleNamesList = ruleNames != null ? Arrays.asList(ruleNames) : null;
 		return getNodeText(t, ruleNamesList);
 	}
 
-	public static String getNodeText(@NotNull Tree t, @Nullable List<String> ruleNames) {
+	public static String getNodeText(Tree t, List<String> ruleNames) {
 		if ( ruleNames!=null ) {
-			if ( t instanceof RuleNode ) {
-				int ruleIndex = ((RuleNode)t).getRuleContext().getRuleIndex();
+			if ( t instanceof RuleContext ) {
+				int ruleIndex = ((RuleContext)t).getRuleContext().getRuleIndex();
 				String ruleName = ruleNames.get(ruleIndex);
+				int altNumber = ((RuleContext) t).getAltNumber();
+				if ( altNumber!=ATN.INVALID_ALT_NUMBER ) {
+					return ruleName+":"+altNumber;
+				}
 				return ruleName;
 			}
 			else if ( t instanceof ErrorNode) {
@@ -154,7 +121,6 @@ public class Trees {
 		return t.getPayload().toString();
 	}
 
-
 	/** Return ordered list of all children of this node */
 	public static List<Tree> getChildren(Tree t) {
 		List<Tree> kids = new ArrayList<Tree>();
@@ -166,9 +132,10 @@ public class Trees {
 
 	/** Return a list of all ancestors of this node.  The first node of
 	 *  list is the root and the last is the parent of this node.
+	 *
+	 *  @since 4.5.1
 	 */
-	@NotNull
-	public static List<? extends Tree> getAncestors(@NotNull Tree t) {
+	public static List<? extends Tree> getAncestors(Tree t) {
 		if ( t.getParent()==null ) return Collections.emptyList();
 		List<Tree> ancestors = new ArrayList<Tree>();
 		t = t.getParent();
@@ -179,6 +146,21 @@ public class Trees {
 		return ancestors;
 	}
 
+	/** Return true if t is u's parent or a node on path to root from u.
+	 *  Use == not equals().
+	 *
+	 *  @since 4.5.1
+	 */
+	public static boolean isAncestorOf(Tree t, Tree u) {
+		if ( t==null || u==null || t.getParent()==null ) return false;
+		Tree p = u.getParent();
+		while ( p!=null ) {
+			if ( t==p ) return true;
+			p = p.getParent();
+		}
+		return false;
+	}
+
 	public static Collection<ParseTree> findAllTokenNodes(ParseTree t, int ttype) {
 		return findAllNodes(t, ttype, true);
 	}
@@ -211,17 +193,94 @@ public class Trees {
 		}
 	}
 
-	public static List<ParseTree> descendants(ParseTree t){
+	/** Get all descendents; includes t itself.
+	 *
+	 * @since 4.5.1
+ 	 */
+	public static List<ParseTree> getDescendants(ParseTree t) {
 		List<ParseTree> nodes = new ArrayList<ParseTree>();
 		nodes.add(t);
 
 		int n = t.getChildCount();
 		for (int i = 0 ; i < n ; i++){
-			nodes.addAll(descendants(t.getChild(i)));
+			nodes.addAll(getDescendants(t.getChild(i)));
 		}
 		return nodes;
 	}
 
+	/** @deprecated */
+	public static List<ParseTree> descendants(ParseTree t) {
+		return getDescendants(t);
+	}
+
+	/** Find smallest subtree of t enclosing range startTokenIndex..stopTokenIndex
+	 *  inclusively using postorder traversal.  Recursive depth-first-search.
+	 *
+	 *  @since 4.5.1
+	 */
+	public static ParserRuleContext getRootOfSubtreeEnclosingRegion(ParseTree t,
+																	int startTokenIndex, // inclusive
+																	int stopTokenIndex)  // inclusive
+	{
+		int n = t.getChildCount();
+		for (int i = 0; i<n; i++) {
+			ParseTree child = t.getChild(i);
+			ParserRuleContext r = getRootOfSubtreeEnclosingRegion(child, startTokenIndex, stopTokenIndex);
+			if ( r!=null ) return r;
+		}
+		if ( t instanceof ParserRuleContext ) {
+			ParserRuleContext r = (ParserRuleContext) t;
+			if ( startTokenIndex>=r.getStart().getTokenIndex() && // is range fully contained in t?
+				 (r.getStop()==null || stopTokenIndex<=r.getStop().getTokenIndex()) )
+			{
+				// note: r.getStop()==null likely implies that we bailed out of parser and there's nothing to the right
+				return r;
+			}
+		}
+		return null;
+	}
+
+	/** Replace any subtree siblings of root that are completely to left
+	 *  or right of lookahead range with a CommonToken(Token.INVALID_TYPE,"...")
+	 *  node. The source interval for t is not altered to suit smaller range!
+	 *
+	 *  WARNING: destructive to t.
+	 *
+	 *  @since 4.5.1
+	 */
+	public static void stripChildrenOutOfRange(ParserRuleContext t,
+											   ParserRuleContext root,
+											   int startIndex,
+											   int stopIndex)
+	{
+		if ( t==null ) return;
+		for (int i = 0; i < t.getChildCount(); i++) {
+			ParseTree child = t.getChild(i);
+			Interval range = child.getSourceInterval();
+			if ( child instanceof ParserRuleContext && (range.b < startIndex || range.a > stopIndex) ) {
+				if ( isAncestorOf(child, root) ) { // replace only if subtree doesn't have displayed root
+					CommonToken abbrev = new CommonToken(Token.INVALID_TYPE, "...");
+					t.children.set(i, new TerminalNodeImpl(abbrev));
+				}
+			}
+		}
+	}
+
+	/** Return first node satisfying the pred
+	 *
+ 	 *  @since 4.5.1
+	 */
+	public static Tree findNodeSuchThat(Tree t, Predicate<Tree> pred) {
+		if ( pred.test(t) ) return t;
+
+		int n = t.getChildCount();
+		for (int i = 0 ; i < n ; i++){
+			Tree u = findNodeSuchThat(t.getChild(i), pred);
+			if ( u!=null ) return u;
+		}
+		return null;
+	}
+
 	private Trees() {
 	}
 }
diff --git a/runtime/Java/src/org/antlr/v4/runtime/tree/pattern/Chunk.java b/runtime/Java/src/org/antlr/v4/runtime/tree/pattern/Chunk.java
index d4d8d16e8..6947bebc3 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/tree/pattern/Chunk.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/tree/pattern/Chunk.java
@@ -33,13 +33,13 @@ package org.antlr.v4.runtime.tree.pattern;
 /**
  * A chunk is either a token tag, a rule tag, or a span of literal text within a
  * tree pattern.
- * <p/>
- * The method {@link ParseTreePatternMatcher#split(String)} returns a list of
+ *
+ * <p>The method {@link ParseTreePatternMatcher#split(String)} returns a list of
  * chunks in preparation for creating a token stream by
  * {@link ParseTreePatternMatcher#tokenize(String)}. From there, we get a parse
  * tree from with {@link ParseTreePatternMatcher#compile(String, int)}. These
  * chunks are converted to {@link RuleTagToken}, {@link TokenTagToken}, or the
- * regular tokens of the text surrounding the tags.
+ * regular tokens of the text surrounding the tags.</p>
  */
 abstract class Chunk {
 }
diff --git a/runtime/Java/src/org/antlr/v4/runtime/tree/pattern/ParseTreeMatch.java b/runtime/Java/src/org/antlr/v4/runtime/tree/pattern/ParseTreeMatch.java
index a4aea6e85..62917cfbf 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/tree/pattern/ParseTreeMatch.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/tree/pattern/ParseTreeMatch.java
@@ -31,8 +31,6 @@
 package org.antlr.v4.runtime.tree.pattern;
 
 import org.antlr.v4.runtime.misc.MultiMap;
-import org.antlr.v4.runtime.misc.NotNull;
-import org.antlr.v4.runtime.misc.Nullable;
 import org.antlr.v4.runtime.tree.ParseTree;
 
 import java.util.Collections;
@@ -77,7 +75,7 @@ public class ParseTreeMatch {
 	 * @exception IllegalArgumentException if {@code pattern} is {@code null}
 	 * @exception IllegalArgumentException if {@code labels} is {@code null}
 	 */
-	public ParseTreeMatch(@NotNull ParseTree tree, @NotNull ParseTreePattern pattern, @NotNull MultiMap<String, ParseTree> labels, @Nullable ParseTree mismatchedNode) {
+	public ParseTreeMatch(ParseTree tree, ParseTreePattern pattern, MultiMap<String, ParseTree> labels, ParseTree mismatchedNode) {
 		if (tree == null) {
 			throw new IllegalArgumentException("tree cannot be null");
 		}
@@ -98,24 +96,24 @@ public class ParseTreeMatch {
 
 	/**
 	 * Get the last node associated with a specific {@code label}.
-	 * <p/>
-	 * For example, for pattern {@code <id:ID>}, {@code get("id")} returns the
+	 *
+	 * <p>For example, for pattern {@code <id:ID>}, {@code get("id")} returns the
 	 * node matched for that {@code ID}. If more than one node
 	 * matched the specified label, only the last is returned. If there is
-	 * no node associated with the label, this returns {@code null}.
-	 * <p/>
-	 * Pattern tags like {@code <ID>} and {@code <expr>} without labels are
-	 * considered to be labeled with {@code ID} and {@code expr}, respectively.
+	 * no node associated with the label, this returns {@code null}.</p>
+	 *
+	 * <p>Pattern tags like {@code <ID>} and {@code <expr>} without labels are
+	 * considered to be labeled with {@code ID} and {@code expr}, respectively.</p>
 	 *
 	 * @param label The label to check.
 	 *
 	 * @return The last {@link ParseTree} to match a tag with the specified
 	 * label, or {@code null} if no parse tree matched a tag with the label.
 	 */
-	@Nullable
+
 	public ParseTree get(String label) {
 		List<ParseTree> parseTrees = labels.get(label);
-		if ( parseTrees==null ) {
+		if ( parseTrees==null || parseTrees.size()==0 ) {
 			return null;
 		}
 
@@ -124,13 +122,13 @@ public class ParseTreeMatch {
 
 	/**
 	 * Return all nodes matching a rule or token tag with the specified label.
-	 * <p/>
-	 * If the {@code label} is the name of a parser rule or token in the
+	 *
+	 * <p>If the {@code label} is the name of a parser rule or token in the
 	 * grammar, the resulting list will contain both the parse trees matching
 	 * rule or tags explicitly labeled with the label and the complete set of
 	 * parse trees matching the labeled and unlabeled tags in the pattern for
 	 * the parser rule or token. For example, if {@code label} is {@code "foo"},
-	 * the result will contain <em>all</em> of the following.
+	 * the result will contain <em>all</em> of the following.</p>
 	 *
 	 * <ul>
 	 * <li>Parse tree nodes matching tags of the form {@code <foo:anyRuleName>} and
@@ -145,8 +143,8 @@ public class ParseTreeMatch {
 	 * the specified {@code label}. If no nodes matched the label, an empty list
 	 * is returned.
 	 */
-	@NotNull
-	public List<ParseTree> getAll(@NotNull String label) {
+
+	public List<ParseTree> getAll(String label) {
 		List<ParseTree> nodes = labels.get(label);
 		if ( nodes==null ) {
 			return Collections.emptyList();
@@ -157,15 +155,15 @@ public class ParseTreeMatch {
 
 	/**
 	 * Return a mapping from label &rarr; [list of nodes].
-	 * <p/>
-	 * The map includes special entries corresponding to the names of rules and
+	 *
+	 * <p>The map includes special entries corresponding to the names of rules and
 	 * tokens referenced in tags in the original pattern. For additional
-	 * information, see the description of {@link #getAll(String)}.
+	 * information, see the description of {@link #getAll(String)}.</p>
 	 *
 	 * @return A mapping from labels to parse tree nodes. If the parse tree
 	 * pattern did not contain any rule or token tags, this map will be empty.
 	 */
-	@NotNull
+
 	public MultiMap<String, ParseTree> getLabels() {
 		return labels;
 	}
@@ -176,7 +174,7 @@ public class ParseTreeMatch {
 	 * @return the node at which we first detected a mismatch, or {@code null}
 	 * if the match was successful.
 	 */
-	@Nullable
+
 	public ParseTree getMismatchedNode() {
 		return mismatchedNode;
 	}
@@ -196,7 +194,7 @@ public class ParseTreeMatch {
 	 *
 	 * @return The tree pattern we are matching against.
 	 */
-	@NotNull
+
 	public ParseTreePattern getPattern() {
 		return pattern;
 	}
@@ -206,7 +204,7 @@ public class ParseTreeMatch {
 	 *
 	 * @return The {@link ParseTree} we are trying to match to a pattern.
 	 */
-	@NotNull
+
 	public ParseTree getTree() {
 		return tree;
 	}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/tree/pattern/ParseTreePattern.java b/runtime/Java/src/org/antlr/v4/runtime/tree/pattern/ParseTreePattern.java
index 78351536f..69651b41b 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/tree/pattern/ParseTreePattern.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/tree/pattern/ParseTreePattern.java
@@ -30,7 +30,6 @@
 
 package org.antlr.v4.runtime.tree.pattern;
 
-import org.antlr.v4.runtime.misc.NotNull;
 import org.antlr.v4.runtime.tree.ParseTree;
 import org.antlr.v4.runtime.tree.xpath.XPath;
 
@@ -51,19 +50,19 @@ public class ParseTreePattern {
 	/**
 	 * This is the backing field for {@link #getPattern()}.
 	 */
-	@NotNull
+
 	private final String pattern;
 
 	/**
 	 * This is the backing field for {@link #getPatternTree()}.
 	 */
-	@NotNull
+
 	private final ParseTree patternTree;
 
 	/**
 	 * This is the backing field for {@link #getMatcher()}.
 	 */
-	@NotNull
+
 	private final ParseTreePatternMatcher matcher;
 
 	/**
@@ -76,8 +75,8 @@ public class ParseTreePattern {
 	 * tree pattern.
 	 * @param patternTree The tree pattern in {@link ParseTree} form.
 	 */
-	public ParseTreePattern(@NotNull ParseTreePatternMatcher matcher,
-							@NotNull String pattern, int patternRuleIndex, @NotNull ParseTree patternTree)
+	public ParseTreePattern(ParseTreePatternMatcher matcher,
+							String pattern, int patternRuleIndex, ParseTree patternTree)
 	{
 		this.matcher = matcher;
 		this.patternRuleIndex = patternRuleIndex;
@@ -93,8 +92,8 @@ public class ParseTreePattern {
 	 * match operation. The {@link ParseTreeMatch#succeeded()} method can be
 	 * used to determine whether or not the match was successful.
 	 */
-	@NotNull
-	public ParseTreeMatch match(@NotNull ParseTree tree) {
+
+	public ParseTreeMatch match(ParseTree tree) {
 		return matcher.match(tree, this);
 	}
 
@@ -105,7 +104,7 @@ public class ParseTreePattern {
 	 * @return {@code true} if {@code tree} is a match for the current tree
 	 * pattern; otherwise, {@code false}.
 	 */
-	public boolean matches(@NotNull ParseTree tree) {
+	public boolean matches(ParseTree tree) {
 		return matcher.match(tree, this).succeeded();
 	}
 
@@ -120,8 +119,8 @@ public class ParseTreePattern {
 	 * successful matches. Unsuccessful matches are omitted from the result,
 	 * regardless of the reason for the failure.
 	 */
-	@NotNull
-	public List<ParseTreeMatch> findAll(@NotNull ParseTree tree, @NotNull String xpath) {
+
+	public List<ParseTreeMatch> findAll(ParseTree tree, String xpath) {
 		Collection<ParseTree> subtrees = XPath.findAll(tree, xpath, matcher.getParser());
 		List<ParseTreeMatch> matches = new ArrayList<ParseTreeMatch>();
 		for (ParseTree t : subtrees) {
@@ -139,7 +138,7 @@ public class ParseTreePattern {
 	 * @return The {@link ParseTreePatternMatcher} which created this tree
 	 * pattern.
 	 */
-	@NotNull
+
 	public ParseTreePatternMatcher getMatcher() {
 		return matcher;
 	}
@@ -149,7 +148,7 @@ public class ParseTreePattern {
 	 *
 	 * @return The tree pattern in concrete syntax form.
 	 */
-	@NotNull
+
 	public String getPattern() {
 		return pattern;
 	}
@@ -172,7 +171,7 @@ public class ParseTreePattern {
 	 *
 	 * @return The tree pattern as a {@link ParseTree}.
 	 */
-	@NotNull
+
 	public ParseTree getPatternTree() {
 		return patternTree;
 	}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/tree/pattern/ParseTreePatternMatcher.java b/runtime/Java/src/org/antlr/v4/runtime/tree/pattern/ParseTreePatternMatcher.java
index 5fc2a4c85..9ee5beeac 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/tree/pattern/ParseTreePatternMatcher.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/tree/pattern/ParseTreePatternMatcher.java
@@ -31,17 +31,18 @@
 package org.antlr.v4.runtime.tree.pattern;
 
 import org.antlr.v4.runtime.ANTLRInputStream;
+import org.antlr.v4.runtime.BailErrorStrategy;
 import org.antlr.v4.runtime.CommonTokenStream;
 import org.antlr.v4.runtime.Lexer;
 import org.antlr.v4.runtime.ListTokenSource;
 import org.antlr.v4.runtime.Parser;
 import org.antlr.v4.runtime.ParserInterpreter;
 import org.antlr.v4.runtime.ParserRuleContext;
+import org.antlr.v4.runtime.RecognitionException;
 import org.antlr.v4.runtime.Token;
 import org.antlr.v4.runtime.atn.ATN;
 import org.antlr.v4.runtime.misc.MultiMap;
-import org.antlr.v4.runtime.misc.NotNull;
-import org.antlr.v4.runtime.misc.Nullable;
+import org.antlr.v4.runtime.misc.ParseCancellationException;
 import org.antlr.v4.runtime.tree.ParseTree;
 import org.antlr.v4.runtime.tree.RuleNode;
 import org.antlr.v4.runtime.tree.TerminalNode;
@@ -52,60 +53,60 @@ import java.util.List;
 
 /**
  * A tree pattern matching mechanism for ANTLR {@link ParseTree}s.
- * <p/>
- * Patterns are strings of source input text with special tags representing
- * token or rule references such as:
- * <p/>
- * {@code <ID> = <expr>;}
- * <p/>
- * Given a pattern start rule such as {@code statement}, this object constructs
+ *
+ * <p>Patterns are strings of source input text with special tags representing
+ * token or rule references such as:</p>
+ *
+ * <p>{@code <ID> = <expr>;}</p>
+ *
+ * <p>Given a pattern start rule such as {@code statement}, this object constructs
  * a {@link ParseTree} with placeholders for the {@code ID} and {@code expr}
  * subtree. Then the {@link #match} routines can compare an actual
  * {@link ParseTree} from a parse with this pattern. Tag {@code <ID>} matches
  * any {@code ID} token and tag {@code <expr>} references the result of the
- * {@code expr} rule (generally an instance of {@code ExprContext}.
- * <p/>
- * Pattern {@code x = 0;} is a similar pattern that matches the same pattern
+ * {@code expr} rule (generally an instance of {@code ExprContext}.</p>
+ *
+ * <p>Pattern {@code x = 0;} is a similar pattern that matches the same pattern
  * except that it requires the identifier to be {@code x} and the expression to
- * be {@code 0}.
- * <p/>
- * The {@link #matches} routines return {@code true} or {@code false} based
+ * be {@code 0}.</p>
+ *
+ * <p>The {@link #matches} routines return {@code true} or {@code false} based
  * upon a match for the tree rooted at the parameter sent in. The
  * {@link #match} routines return a {@link ParseTreeMatch} object that
  * contains the parse tree, the parse tree pattern, and a map from tag name to
  * matched nodes (more below). A subtree that fails to match, returns with
  * {@link ParseTreeMatch#mismatchedNode} set to the first tree node that did not
- * match.
- * <p/>
- * For efficiency, you can compile a tree pattern in string form to a
- * {@link ParseTreePattern} object.
- * <p/>
- * See {@code TestParseTreeMatcher} for lots of examples.
+ * match.</p>
+ *
+ * <p>For efficiency, you can compile a tree pattern in string form to a
+ * {@link ParseTreePattern} object.</p>
+ *
+ * <p>See {@code TestParseTreeMatcher} for lots of examples.
  * {@link ParseTreePattern} has two static helper methods:
  * {@link ParseTreePattern#findAll} and {@link ParseTreePattern#match} that
  * are easy to use but not super efficient because they create new
  * {@link ParseTreePatternMatcher} objects each time and have to compile the
- * pattern in string form before using it.
- * <p/>
- * The lexer and parser that you pass into the {@link ParseTreePatternMatcher}
+ * pattern in string form before using it.</p>
+ *
+ * <p>The lexer and parser that you pass into the {@link ParseTreePatternMatcher}
  * constructor are used to parse the pattern in string form. The lexer converts
  * the {@code <ID> = <expr>;} into a sequence of four tokens (assuming lexer
  * throws out whitespace or puts it on a hidden channel). Be aware that the
  * input stream is reset for the lexer (but not the parser; a
  * {@link ParserInterpreter} is created to parse the input.). Any user-defined
  * fields you have put into the lexer might get changed when this mechanism asks
- * it to scan the pattern string.
- * <p/>
- * Normally a parser does not accept token {@code <expr>} as a valid
+ * it to scan the pattern string.</p>
+ *
+ * <p>Normally a parser does not accept token {@code <expr>} as a valid
  * {@code expr} but, from the parser passed in, we create a special version of
  * the underlying grammar representation (an {@link ATN}) that allows imaginary
  * tokens representing rules ({@code <expr>}) to match entire rules. We call
- * these <em>bypass alternatives</em>.
- * <p/>
- * Delimiters are {@code <} and {@code >}, with {@code \} as the escape string
+ * these <em>bypass alternatives</em>.</p>
+ *
+ * <p>Delimiters are {@code <} and {@code >}, with {@code \} as the escape string
  * by default, but you can set them to whatever you want using
  * {@link #setDelimiters}. You must escape both start and stop strings
- * {@code \<} and {@code \>}.
+ * {@code \<} and {@code \>}.</p>
  */
 public class ParseTreePatternMatcher {
 	public static class CannotInvokeStartRule extends RuntimeException {
@@ -114,6 +115,11 @@ public class ParseTreePatternMatcher {
 		}
 	}
 
+	// Fixes https://github.com/antlr/antlr4/issues/413
+	// "Tree pattern compilation doesn't check for a complete parse"
+	public static class StartRuleDoesNotConsumeFullPattern extends RuntimeException {
+	}
+
 	/**
 	 * This is the backing field for {@link #getLexer()}.
 	 */
@@ -195,8 +201,8 @@ public class ParseTreePatternMatcher {
 	 * node at which the match failed. Pass in a compiled pattern instead of a
 	 * string representation of a tree pattern.
 	 */
-	@NotNull
-	public ParseTreeMatch match(@NotNull ParseTree tree, @NotNull ParseTreePattern pattern) {
+
+	public ParseTreeMatch match(ParseTree tree, ParseTreePattern pattern) {
 		MultiMap<String, ParseTree> labels = new MultiMap<String, ParseTree>();
 		ParseTree mismatchedNode = matchImpl(tree, pattern.getPatternTree(), labels);
 		return new ParseTreeMatch(tree, pattern, labels, mismatchedNode);
@@ -212,20 +218,32 @@ public class ParseTreePatternMatcher {
 		CommonTokenStream tokens = new CommonTokenStream(tokenSrc);
 
 		ParserInterpreter parserInterp = new ParserInterpreter(parser.getGrammarFileName(),
-															   Arrays.asList(parser.getTokenNames()),
+															   parser.getVocabulary(),
 															   Arrays.asList(parser.getRuleNames()),
 															   parser.getATNWithBypassAlts(),
 															   tokens);
 
 		ParseTree tree = null;
 		try {
+			parserInterp.setErrorHandler(new BailErrorStrategy());
 			tree = parserInterp.parse(patternRuleIndex);
 //			System.out.println("pattern tree = "+tree.toStringTree(parserInterp));
 		}
+		catch (ParseCancellationException e) {
+			throw (RecognitionException)e.getCause();
+		}
+		catch (RecognitionException re) {
+			throw re;
+		}
 		catch (Exception e) {
 			throw new CannotInvokeStartRule(e);
 		}
 
+		// Make sure tree pattern compilation checks for a complete parse
+		if ( tokens.LA(1)!=Token.EOF ) {
+			throw new StartRuleDoesNotConsumeFullPattern();
+		}
+
 		return new ParseTreePattern(this, pattern, patternRuleIndex, tree);
 	}
 
@@ -233,7 +251,7 @@ public class ParseTreePatternMatcher {
 	 * Used to convert the tree pattern string into a series of tokens. The
 	 * input stream is reset.
 	 */
-	@NotNull
+
 	public Lexer getLexer() {
 		return lexer;
 	}
@@ -242,7 +260,7 @@ public class ParseTreePatternMatcher {
 	 * Used to collect to the grammar file name, token names, rule names for
 	 * used to parse the pattern into a parse tree.
 	 */
-	@NotNull
+
 	public Parser getParser() {
 		return parser;
 	}
@@ -258,10 +276,10 @@ public class ParseTreePatternMatcher {
 	 * was successful. The specific node returned depends on the matching
 	 * algorithm used by the implementation, and may be overridden.
 	 */
-	@Nullable
-	protected ParseTree matchImpl(@NotNull ParseTree tree,
-								  @NotNull ParseTree patternTree,
-								  @NotNull MultiMap<String, ParseTree> labels)
+
+	protected ParseTree matchImpl(ParseTree tree,
+								  ParseTree patternTree,
+								  MultiMap<String, ParseTree> labels)
 	{
 		if (tree == null) {
 			throw new IllegalArgumentException("tree cannot be null");
diff --git a/runtime/Java/src/org/antlr/v4/runtime/tree/pattern/RuleTagToken.java b/runtime/Java/src/org/antlr/v4/runtime/tree/pattern/RuleTagToken.java
index 6fc3a0332..5b3313c76 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/tree/pattern/RuleTagToken.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/tree/pattern/RuleTagToken.java
@@ -33,8 +33,6 @@ package org.antlr.v4.runtime.tree.pattern;
 import org.antlr.v4.runtime.CharStream;
 import org.antlr.v4.runtime.Token;
 import org.antlr.v4.runtime.TokenSource;
-import org.antlr.v4.runtime.misc.NotNull;
-import org.antlr.v4.runtime.misc.Nullable;
 
 /**
  * A {@link Token} object representing an entire subtree matched by a parser
@@ -66,7 +64,7 @@ public class RuleTagToken implements Token {
 	 * @exception IllegalArgumentException if {@code ruleName} is {@code null}
 	 * or empty.
 	 */
-	public RuleTagToken(@NotNull String ruleName, int bypassTokenType) {
+	public RuleTagToken(String ruleName, int bypassTokenType) {
 		this(ruleName, bypassTokenType, null);
 	}
 
@@ -82,7 +80,7 @@ public class RuleTagToken implements Token {
 	 * @exception IllegalArgumentException if {@code ruleName} is {@code null}
 	 * or empty.
 	 */
-	public RuleTagToken(@NotNull String ruleName, int bypassTokenType, @Nullable String label) {
+	public RuleTagToken(String ruleName, int bypassTokenType, String label) {
 		if (ruleName == null || ruleName.isEmpty()) {
 			throw new IllegalArgumentException("ruleName cannot be null or empty.");
 		}
@@ -97,7 +95,7 @@ public class RuleTagToken implements Token {
 	 *
 	 * @return The name of the parser rule associated with this rule tag.
 	 */
-	@NotNull
+
 	public final String getRuleName() {
 		return ruleName;
 	}
@@ -108,15 +106,15 @@ public class RuleTagToken implements Token {
 	 * @return The name of the label associated with the rule tag, or
 	 * {@code null} if this is an unlabeled rule tag.
 	 */
-	@Nullable
+
 	public final String getLabel() {
 		return label;
 	}
 
 	/**
 	 * {@inheritDoc}
-	 * <p/>
-	 * Rule tag tokens are always placed on the {@link #DEFAULT_CHANNEL}.
+	 *
+	 * <p>Rule tag tokens are always placed on the {@link #DEFAULT_CHANNEL}.</p>
 	 */
 	@Override
 	public int getChannel() {
@@ -125,9 +123,9 @@ public class RuleTagToken implements Token {
 
 	/**
 	 * {@inheritDoc}
-	 * <p/>
-	 * This method returns the rule tag formatted with {@code <} and {@code >}
-	 * delimiters.
+	 *
+	 * <p>This method returns the rule tag formatted with {@code <} and {@code >}
+	 * delimiters.</p>
 	 */
 	@Override
 	public String getText() {
@@ -140,9 +138,9 @@ public class RuleTagToken implements Token {
 
 	/**
 	 * {@inheritDoc}
-	 * <p/>
-	 * Rule tag tokens have types assigned according to the rule bypass
-	 * transitions created during ATN deserialization.
+	 *
+	 * <p>Rule tag tokens have types assigned according to the rule bypass
+	 * transitions created during ATN deserialization.</p>
 	 */
 	@Override
 	public int getType() {
@@ -151,8 +149,8 @@ public class RuleTagToken implements Token {
 
 	/**
 	 * {@inheritDoc}
-	 * <p/>
-	 * The implementation for {@link RuleTagToken} always returns 0.
+	 *
+	 * <p>The implementation for {@link RuleTagToken} always returns 0.</p>
 	 */
 	@Override
 	public int getLine() {
@@ -161,8 +159,8 @@ public class RuleTagToken implements Token {
 
 	/**
 	 * {@inheritDoc}
-	 * <p/>
-	 * The implementation for {@link RuleTagToken} always returns -1.
+	 *
+	 * <p>The implementation for {@link RuleTagToken} always returns -1.</p>
 	 */
 	@Override
 	public int getCharPositionInLine() {
@@ -171,8 +169,8 @@ public class RuleTagToken implements Token {
 
 	/**
 	 * {@inheritDoc}
-	 * <p/>
-	 * The implementation for {@link RuleTagToken} always returns -1.
+	 *
+	 * <p>The implementation for {@link RuleTagToken} always returns -1.</p>
 	 */
 	@Override
 	public int getTokenIndex() {
@@ -181,8 +179,8 @@ public class RuleTagToken implements Token {
 
 	/**
 	 * {@inheritDoc}
-	 * <p/>
-	 * The implementation for {@link RuleTagToken} always returns -1.
+	 *
+	 * <p>The implementation for {@link RuleTagToken} always returns -1.</p>
 	 */
 	@Override
 	public int getStartIndex() {
@@ -191,8 +189,8 @@ public class RuleTagToken implements Token {
 
 	/**
 	 * {@inheritDoc}
-	 * <p/>
-	 * The implementation for {@link RuleTagToken} always returns -1.
+	 *
+	 * <p>The implementation for {@link RuleTagToken} always returns -1.</p>
 	 */
 	@Override
 	public int getStopIndex() {
@@ -201,8 +199,8 @@ public class RuleTagToken implements Token {
 
 	/**
 	 * {@inheritDoc}
-	 * <p/>
-	 * The implementation for {@link RuleTagToken} always returns {@code null}.
+	 *
+	 * <p>The implementation for {@link RuleTagToken} always returns {@code null}.</p>
 	 */
 	@Override
 	public TokenSource getTokenSource() {
@@ -211,8 +209,8 @@ public class RuleTagToken implements Token {
 
 	/**
 	 * {@inheritDoc}
-	 * <p/>
-	 * The implementation for {@link RuleTagToken} always returns {@code null}.
+	 *
+	 * <p>The implementation for {@link RuleTagToken} always returns {@code null}.</p>
 	 */
 	@Override
 	public CharStream getInputStream() {
@@ -221,9 +219,9 @@ public class RuleTagToken implements Token {
 
 	/**
 	 * {@inheritDoc}
-	 * <p/>
-	 * The implementation for {@link RuleTagToken} returns a string of the form
-	 * {@code ruleName:bypassTokenType}.
+	 *
+	 * <p>The implementation for {@link RuleTagToken} returns a string of the form
+	 * {@code ruleName:bypassTokenType}.</p>
 	 */
 	@Override
 	public String toString() {
diff --git a/runtime/Java/src/org/antlr/v4/runtime/tree/pattern/TagChunk.java b/runtime/Java/src/org/antlr/v4/runtime/tree/pattern/TagChunk.java
index fbda1a44a..8b5394a6d 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/tree/pattern/TagChunk.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/tree/pattern/TagChunk.java
@@ -30,9 +30,6 @@
 
 package org.antlr.v4.runtime.tree.pattern;
 
-import org.antlr.v4.runtime.misc.NotNull;
-import org.antlr.v4.runtime.misc.Nullable;
-
 /**
  * Represents a placeholder tag in a tree pattern. A tag can have any of the
  * following forms.
@@ -97,7 +94,7 @@ class TagChunk extends Chunk {
 	 *
 	 * @return The tag for the chunk.
 	 */
-	@NotNull
+
 	public final String getTag() {
 		return tag;
 	}
@@ -108,7 +105,7 @@ class TagChunk extends Chunk {
 	 * @return The label assigned to this chunk, or {@code null} if no label is
 	 * assigned to the chunk.
 	 */
-	@Nullable
+
 	public final String getLabel() {
 		return label;
 	}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/tree/pattern/TextChunk.java b/runtime/Java/src/org/antlr/v4/runtime/tree/pattern/TextChunk.java
index 4ec29e327..82e224c70 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/tree/pattern/TextChunk.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/tree/pattern/TextChunk.java
@@ -30,8 +30,6 @@
 
 package org.antlr.v4.runtime.tree.pattern;
 
-import org.antlr.v4.runtime.misc.NotNull;
-
 /**
  * Represents a span of raw text (concrete syntax) between tags in a tree
  * pattern string.
@@ -40,7 +38,7 @@ class TextChunk extends Chunk {
 	/**
 	 * This is the backing field for {@link #getText}.
 	 */
-	@NotNull
+
 	private final String text;
 
 	/**
@@ -49,7 +47,7 @@ class TextChunk extends Chunk {
 	 * @param text The text of this chunk.
 	 * @exception IllegalArgumentException if {@code text} is {@code null}.
 	 */
-	public TextChunk(@NotNull String text) {
+	public TextChunk(String text) {
 		if (text == null) {
 			throw new IllegalArgumentException("text cannot be null");
 		}
@@ -62,16 +60,16 @@ class TextChunk extends Chunk {
 	 *
 	 * @return The text of the chunk.
 	 */
-	@NotNull
+
 	public final String getText() {
 		return text;
 	}
 
 	/**
 	 * {@inheritDoc}
-	 * <p/>
-	 * The implementation for {@link TextChunk} returns the result of
-	 * {@link #getText()} in single quotes.
+	 *
+	 * <p>The implementation for {@link TextChunk} returns the result of
+	 * {@link #getText()} in single quotes.</p>
 	 */
 	@Override
 	public String toString() {
diff --git a/runtime/Java/src/org/antlr/v4/runtime/tree/pattern/TokenTagToken.java b/runtime/Java/src/org/antlr/v4/runtime/tree/pattern/TokenTagToken.java
index 4a620cb2a..2ce2e2de5 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/tree/pattern/TokenTagToken.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/tree/pattern/TokenTagToken.java
@@ -32,8 +32,6 @@ package org.antlr.v4.runtime.tree.pattern;
 
 import org.antlr.v4.runtime.CommonToken;
 import org.antlr.v4.runtime.Token;
-import org.antlr.v4.runtime.misc.NotNull;
-import org.antlr.v4.runtime.misc.Nullable;
 
 /**
  * A {@link Token} object representing a token of a particular type; e.g.,
@@ -44,12 +42,12 @@ public class TokenTagToken extends CommonToken {
 	/**
 	 * This is the backing field for {@link #getTokenName}.
 	 */
-	@NotNull
+
 	private final String tokenName;
 	/**
 	 * This is the backing field for {@link #getLabel}.
 	 */
-	@Nullable
+
 	private final String label;
 
 	/**
@@ -59,7 +57,7 @@ public class TokenTagToken extends CommonToken {
 	 * @param tokenName The token name.
 	 * @param type The token type.
 	 */
-	public TokenTagToken(@NotNull String tokenName, int type) {
+	public TokenTagToken(String tokenName, int type) {
 		this(tokenName, type, null);
 	}
 
@@ -72,7 +70,7 @@ public class TokenTagToken extends CommonToken {
 	 * @param label The label associated with the token tag, or {@code null} if
 	 * the token tag is unlabeled.
 	 */
-	public TokenTagToken(@NotNull String tokenName, int type, @Nullable String label) {
+	public TokenTagToken(String tokenName, int type, String label) {
 		super(type);
 		this.tokenName = tokenName;
 		this.label = label;
@@ -82,7 +80,7 @@ public class TokenTagToken extends CommonToken {
 	 * Gets the token name.
 	 * @return The token name.
 	 */
-	@NotNull
+
 	public final String getTokenName() {
 		return tokenName;
 	}
@@ -93,16 +91,16 @@ public class TokenTagToken extends CommonToken {
 	 * @return The name of the label associated with the rule tag, or
 	 * {@code null} if this is an unlabeled rule tag.
 	 */
-	@Nullable
+
 	public final String getLabel() {
 		return label;
 	}
 
 	/**
 	 * {@inheritDoc}
-	 * <p/>
-	 * The implementation for {@link TokenTagToken} returns the token tag
-	 * formatted with {@code <} and {@code >} delimiters.
+	 *
+	 * <p>The implementation for {@link TokenTagToken} returns the token tag
+	 * formatted with {@code <} and {@code >} delimiters.</p>
 	 */
 	@Override
 	public String getText() {
@@ -115,9 +113,9 @@ public class TokenTagToken extends CommonToken {
 
 	/**
 	 * {@inheritDoc}
-	 * <p/>
-	 * The implementation for {@link TokenTagToken} returns a string of the form
-	 * {@code tokenName:type}.
+	 *
+	 * <p>The implementation for {@link TokenTagToken} returns a string of the form
+	 * {@code tokenName:type}.</p>
 	 */
 	@Override
 	public String toString() {
diff --git a/runtime/Java/src/org/antlr/v4/runtime/tree/xpath/XPath.java b/runtime/Java/src/org/antlr/v4/runtime/tree/xpath/XPath.java
index b04c6a857..7bd249f6b 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/tree/xpath/XPath.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/tree/xpath/XPath.java
@@ -12,36 +12,52 @@ import java.io.IOException;
 import java.io.StringReader;
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.Collections;
+import java.util.LinkedHashSet;
 import java.util.List;
 
-/** Represent a subset of XPath XML path syntax for use in identifying nodes in
- *  parse trees.
+/**
+ * Represent a subset of XPath XML path syntax for use in identifying nodes in
+ * parse trees.
  *
- *  Split path into words and separators / and // via ANTLR itself then walk
- *  path elements from left to right.  At each separator-word pair, find set
- *  of nodes. Next stage uses those as work list.
+ * <p>
+ * Split path into words and separators {@code /} and {@code //} via ANTLR
+ * itself then walk path elements from left to right. At each separator-word
+ * pair, find set of nodes. Next stage uses those as work list.</p>
  *
- *  The basic interface is ParseTree.findAll(parser, pathString). But that is
- *  just shorthand for:
+ * <p>
+ * The basic interface is
+ * {@link XPath#findAll ParseTree.findAll}{@code (tree, pathString, parser)}.
+ * But that is just shorthand for:</p>
  *
- *  XPath p = new XPath(parser, xpath);
- *  return p.evaluate(this);
+ * <pre>
+ * {@link XPath} p = new {@link XPath#XPath XPath}(parser, pathString);
+ * return p.{@link #evaluate evaluate}(tree);
+ * </pre>
  *
- *  See {@code org.antlr.v4.test.TestXPath} for descriptions. In short, this allows
- *  operators:
+ * <p>
+ * See {@code org.antlr.v4.test.TestXPath} for descriptions. In short, this
+ * allows operators:</p>
  *
- *      /         root
- *      //        anywhere
- *      !         invert; this must appear directly after root or anywhere operator
+ * <dl>
+ * <dt>/</dt> <dd>root</dd>
+ * <dt>//</dt> <dd>anywhere</dd>
+ * <dt>!</dt> <dd>invert; this must appear directly after root or anywhere
+ * operator</dd>
+ * </dl>
  *
- *  and path elements:
+ * <p>
+ * and path elements:</p>
  *
- *      ID        token name
- *      'string'  any string literal token from the grammar
- *      expr      rule name
- *      *         wildcard matching any node
+ * <dl>
+ * <dt>ID</dt> <dd>token name</dd>
+ * <dt>'string'</dt> <dd>any string literal token from the grammar</dd>
+ * <dt>expr</dt> <dd>rule name</dd>
+ * <dt>*</dt> <dd>wildcard matching any node</dd>
+ * </dl>
  *
- *  Whitespace is not allowed.
+ * <p>
+ * Whitespace is not allowed.</p>
  */
 public class XPath {
 	public static final String WILDCARD = "*"; // word not operator/separator
@@ -126,8 +142,10 @@ loop:
 		return elements.toArray(new XPathElement[0]);
 	}
 
-	/** Convert word like * or ID or expr to a path element. anywhere is true
-	 *  if // precedes the word.
+	/**
+	 * Convert word like {@code *} or {@code ID} or {@code expr} to a path
+	 * element. {@code anywhere} is {@code true} if {@code //} precedes the
+	 * word.
 	 */
 	protected XPathElement getXPathElement(Token wordToken, boolean anywhere) {
 		if ( wordToken.getType()==Token.EOF ) {
@@ -171,19 +189,20 @@ loop:
 		return p.evaluate(tree);
 	}
 
-	/** Return a list of all nodes starting at t as root that satisfy the path.
-	 *  The root / is relative to the node passed to evaluate().
+	/**
+	 * Return a list of all nodes starting at {@code t} as root that satisfy the
+	 * path. The root {@code /} is relative to the node passed to
+	 * {@link #evaluate}.
 	 */
 	public Collection<ParseTree> evaluate(final ParseTree t) {
 		ParserRuleContext dummyRoot = new ParserRuleContext();
-		dummyRoot.children = new ArrayList<ParseTree>() {{add(t);}}; // don't set t's parent.
+		dummyRoot.children = Collections.singletonList(t); // don't set t's parent.
 
-		Collection<ParseTree> work = new ArrayList<ParseTree>();
-		work.add(dummyRoot);
+		Collection<ParseTree> work = Collections.<ParseTree>singleton(dummyRoot);
 
 		int i = 0;
 		while ( i < elements.length ) {
-			Collection<ParseTree> next = new ArrayList<ParseTree>();
+			Collection<ParseTree> next = new LinkedHashSet<ParseTree>();
 			for (ParseTree node : work) {
 				if ( node.getChildCount()>0 ) {
 					// only try to match next element if it has children
diff --git a/runtime/Java/src/org/antlr/v4/runtime/tree/xpath/XPathElement.java b/runtime/Java/src/org/antlr/v4/runtime/tree/xpath/XPathElement.java
index 083bfe548..1385cf9b1 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/tree/xpath/XPathElement.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/tree/xpath/XPathElement.java
@@ -8,14 +8,17 @@ public abstract class XPathElement {
 	protected String nodeName;
 	protected boolean invert;
 
-	/** Construct element like /ID or or ID or "/*" etc...
+	/** Construct element like {@code /ID} or {@code ID} or {@code /*} etc...
 	 *  op is null if just node
 	 */
 	public XPathElement(String nodeName) {
 		this.nodeName = nodeName;
 	}
 
-	/** Given tree rooted at t return all nodes matched by this path element */
+	/**
+	 * Given tree rooted at {@code t} return all nodes matched by this path
+	 * element.
+	 */
 	public abstract Collection<ParseTree> evaluate(ParseTree t);
 
 	@Override
diff --git a/runtime/Java/src/org/antlr/v4/runtime/tree/xpath/XPathRuleAnywhereElement.java b/runtime/Java/src/org/antlr/v4/runtime/tree/xpath/XPathRuleAnywhereElement.java
index e303989c0..216b1bade 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/tree/xpath/XPathRuleAnywhereElement.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/tree/xpath/XPathRuleAnywhereElement.java
@@ -5,7 +5,9 @@ import org.antlr.v4.runtime.tree.Trees;
 
 import java.util.Collection;
 
-/** Either ID at start of path or ...//ID in middle of path */
+/**
+ * Either {@code ID} at start of path or {@code ...//ID} in middle of path.
+ */
 public class XPathRuleAnywhereElement extends XPathElement {
 	protected int ruleIndex;
 	public XPathRuleAnywhereElement(String ruleName, int ruleIndex) {
diff --git a/runtime/Java/src/org/antlr/v4/runtime/tree/xpath/XPathWildcardAnywhereElement.java b/runtime/Java/src/org/antlr/v4/runtime/tree/xpath/XPathWildcardAnywhereElement.java
index 4a2af465a..b4f7c8a0d 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/tree/xpath/XPathWildcardAnywhereElement.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/tree/xpath/XPathWildcardAnywhereElement.java
@@ -14,6 +14,6 @@ public class XPathWildcardAnywhereElement extends XPathElement {
 	@Override
 	public Collection<ParseTree> evaluate(ParseTree t) {
 		if ( invert ) return new ArrayList<ParseTree>(); // !* is weird but valid (empty)
-		return Trees.descendants(t);
+		return Trees.getDescendants(t);
 	}
 }
diff --git a/runtime/Java/src/org/antlr/v4/runtime/tree/xpath/XPathWildcardElement.java b/runtime/Java/src/org/antlr/v4/runtime/tree/xpath/XPathWildcardElement.java
index 8d9a2e247..c38e30d41 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/tree/xpath/XPathWildcardElement.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/tree/xpath/XPathWildcardElement.java
@@ -6,7 +6,6 @@ import org.antlr.v4.runtime.tree.Trees;
 
 import java.util.ArrayList;
 import java.util.Collection;
-import java.util.Collections;
 import java.util.List;
 
 public class XPathWildcardElement extends XPathElement {
diff --git a/runtime/JavaScript/.project b/runtime/JavaScript/.project
new file mode 100644
index 000000000..99687285f
--- /dev/null
+++ b/runtime/JavaScript/.project
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>antlr4-javascript-runtime</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.xtext.ui.shared.xtextBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.python.pydev.PyDevBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>com.eclipsesource.jshint.ui.builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.nodeclipse.ui.NodeNature</nature>
+		<nature>org.eclipse.wst.jsdt.core.jsNature</nature>
+		<nature>org.eclipse.xtext.ui.shared.xtextNature</nature>
+	</natures>
+</projectDescription>
diff --git a/runtime/JavaScript/LICENSE.txt b/runtime/JavaScript/LICENSE.txt
new file mode 100644
index 000000000..dff211c19
--- /dev/null
+++ b/runtime/JavaScript/LICENSE.txt
@@ -0,0 +1,26 @@
+[The "BSD license"]
+Copyright (c) 2015 Terence Parr, Sam Harwell, Eric Vergnaud
+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.
diff --git a/runtime/JavaScript/README.md b/runtime/JavaScript/README.md
new file mode 100644
index 000000000..f35326d6d
--- /dev/null
+++ b/runtime/JavaScript/README.md
@@ -0,0 +1,13 @@
+# JavaScript target for ANTLR 4
+
+JavaScript runtime libraries for ANTLR 4
+
+This runtime is available through npm. The package name is 'antlr4'.
+
+This runtime has been tested in Node.js, Safari, Firefox, Chrome and IE.
+
+See www.antlr.org for more information on ANTLR
+
+See https://raw.githubusercontent.com/antlr/antlr4/master/doc/javascript-target.md for more information on using ANTLR in JavaScript
+
+
diff --git a/runtime/JavaScript/src/antlr4/BufferedTokenStream.js b/runtime/JavaScript/src/antlr4/BufferedTokenStream.js
new file mode 100644
index 000000000..812321086
--- /dev/null
+++ b/runtime/JavaScript/src/antlr4/BufferedTokenStream.js
@@ -0,0 +1,400 @@
+//
+// [The "BSD license"]
+//  Copyright (c) 2012 Terence Parr
+//  Copyright (c) 2012 Sam Harwell
+//  Copyright (c) 2014 Eric Vergnaud
+//  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.
+
+// This implementation of {@link TokenStream} loads tokens from a
+// {@link TokenSource} on-demand, and places the tokens in a buffer to provide
+// access to any previous token by index.
+//
+// <p>
+// This token stream ignores the value of {@link Token//getChannel}. If your
+// parser requires the token stream filter tokens to only those on a particular
+// channel, such as {@link Token//DEFAULT_CHANNEL} or
+// {@link Token//HIDDEN_CHANNEL}, use a filtering token stream such a
+// {@link CommonTokenStream}.</p>
+
+var Token = require('./Token').Token;
+var Lexer = require('./Lexer').Lexer;
+var Interval = require('./IntervalSet').Interval;
+
+// this is just to keep meaningful parameter types to Parser
+function TokenStream() {
+	return this;
+}
+
+function BufferedTokenStream(tokenSource) {
+
+	TokenStream.call(this);
+	// The {@link TokenSource} from which tokens for this stream are fetched.
+	this.tokenSource = tokenSource;
+
+	// A collection of all tokens fetched from the token source. The list is
+	// considered a complete view of the input once {@link //fetchedEOF} is set
+	// to {@code true}.
+	this.tokens = [];
+
+	// The index into {@link //tokens} of the current token (next token to
+	// {@link //consume}). {@link //tokens}{@code [}{@link //p}{@code ]} should
+	// be
+	// {@link //LT LT(1)}.
+	//
+	// <p>This field is set to -1 when the stream is first constructed or when
+	// {@link //setTokenSource} is called, indicating that the first token has
+	// not yet been fetched from the token source. For additional information,
+	// see the documentation of {@link IntStream} for a description of
+	// Initializing Methods.</p>
+	this.index = -1;
+
+	// Indicates whether the {@link Token//EOF} token has been fetched from
+	// {@link //tokenSource} and added to {@link //tokens}. This field improves
+	// performance for the following cases:
+	//
+	// <ul>
+	// <li>{@link //consume}: The lookahead check in {@link //consume} to
+	// prevent
+	// consuming the EOF symbol is optimized by checking the values of
+	// {@link //fetchedEOF} and {@link //p} instead of calling {@link
+	// //LA}.</li>
+	// <li>{@link //fetch}: The check to prevent adding multiple EOF symbols
+	// into
+	// {@link //tokens} is trivial with this field.</li>
+	// <ul>
+	this.fetchedEOF = false;
+	return this;
+}
+
+BufferedTokenStream.prototype = Object.create(TokenStream.prototype);
+BufferedTokenStream.prototype.constructor = BufferedTokenStream;
+
+BufferedTokenStream.prototype.mark = function() {
+	return 0;
+};
+
+BufferedTokenStream.prototype.release = function(marker) {
+	// no resources to release
+};
+
+BufferedTokenStream.prototype.reset = function() {
+	this.seek(0);
+};
+
+BufferedTokenStream.prototype.seek = function(index) {
+	this.lazyInit();
+	this.index = this.adjustSeekIndex(index);
+};
+
+BufferedTokenStream.prototype.get = function(index) {
+	this.lazyInit();
+	return this.tokens[index];
+};
+
+BufferedTokenStream.prototype.consume = function() {
+	var skipEofCheck = false;
+	if (this.index >= 0) {
+		if (this.fetchedEOF) {
+			// the last token in tokens is EOF. skip check if p indexes any
+			// fetched token except the last.
+			skipEofCheck = this.index < this.tokens.length - 1;
+		} else {
+			// no EOF token in tokens. skip check if p indexes a fetched token.
+			skipEofCheck = this.index < this.tokens.length;
+		}
+	} else {
+		// not yet initialized
+		skipEofCheck = false;
+	}
+	if (!skipEofCheck && this.LA(1) === Token.EOF) {
+		throw "cannot consume EOF";
+	}
+	if (this.sync(this.index + 1)) {
+		this.index = this.adjustSeekIndex(this.index + 1);
+	}
+};
+
+// Make sure index {@code i} in tokens has a token.
+//
+// @return {@code true} if a token is located at index {@code i}, otherwise
+// {@code false}.
+// @see //get(int i)
+// /
+BufferedTokenStream.prototype.sync = function(i) {
+	var n = i - this.tokens.length + 1; // how many more elements we need?
+	if (n > 0) {
+		var fetched = this.fetch(n);
+		return fetched >= n;
+	}
+	return true;
+};
+
+// Add {@code n} elements to buffer.
+//
+// @return The actual number of elements added to the buffer.
+// /
+BufferedTokenStream.prototype.fetch = function(n) {
+	if (this.fetchedEOF) {
+		return 0;
+	}
+	for (var i = 0; i < n; i++) {
+		var t = this.tokenSource.nextToken();
+		t.tokenIndex = this.tokens.length;
+		this.tokens.push(t);
+		if (t.type === Token.EOF) {
+			this.fetchedEOF = true;
+			return i + 1;
+		}
+	}
+	return n;
+};
+
+// Get all tokens from start..stop inclusively///
+BufferedTokenStream.prototype.getTokens = function(start, stop, types) {
+	if (types === undefined) {
+		types = null;
+	}
+	if (start < 0 || stop < 0) {
+		return null;
+	}
+	this.lazyInit();
+	var subset = [];
+	if (stop >= this.tokens.length) {
+		stop = this.tokens.length - 1;
+	}
+	for (var i = start; i < stop; i++) {
+		var t = this.tokens[i];
+		if (t.type === Token.EOF) {
+			break;
+		}
+		if (types === null || types.contains(t.type)) {
+			subset.push(t);
+		}
+	}
+	return subset;
+};
+
+BufferedTokenStream.prototype.LA = function(i) {
+	return this.LT(i).type;
+};
+
+BufferedTokenStream.prototype.LB = function(k) {
+	if (this.index - k < 0) {
+		return null;
+	}
+	return this.tokens[this.index - k];
+};
+
+BufferedTokenStream.prototype.LT = function(k) {
+	this.lazyInit();
+	if (k === 0) {
+		return null;
+	}
+	if (k < 0) {
+		return this.LB(-k);
+	}
+	var i = this.index + k - 1;
+	this.sync(i);
+	if (i >= this.tokens.length) { // return EOF token
+		// EOF must be last token
+		return this.tokens[this.tokens.length - 1];
+	}
+	return this.tokens[i];
+};
+
+// Allowed derived classes to modify the behavior of operations which change
+// the current stream position by adjusting the target token index of a seek
+// operation. The default implementation simply returns {@code i}. If an
+// exception is thrown in this method, the current stream index should not be
+// changed.
+//
+// <p>For example, {@link CommonTokenStream} overrides this method to ensure
+// that
+// the seek target is always an on-channel token.</p>
+//
+// @param i The target token index.
+// @return The adjusted target token index.
+
+BufferedTokenStream.prototype.adjustSeekIndex = function(i) {
+	return i;
+};
+
+BufferedTokenStream.prototype.lazyInit = function() {
+	if (this.index === -1) {
+		this.setup();
+	}
+};
+
+BufferedTokenStream.prototype.setup = function() {
+	this.sync(0);
+	this.index = this.adjustSeekIndex(0);
+};
+
+// Reset this token stream by setting its token source.///
+BufferedTokenStream.prototype.setTokenSource = function(tokenSource) {
+	this.tokenSource = tokenSource;
+	this.tokens = [];
+	this.index = -1;
+};
+
+
+// Given a starting index, return the index of the next token on channel.
+// Return i if tokens[i] is on channel. Return -1 if there are no tokens
+// on channel between i and EOF.
+// /
+BufferedTokenStream.prototype.nextTokenOnChannel = function(i, channel) {
+	this.sync(i);
+	if (i >= this.tokens.length) {
+		return -1;
+	}
+	var token = this.tokens[i];
+	while (token.channel !== this.channel) {
+		if (token.type === Token.EOF) {
+			return -1;
+		}
+		i += 1;
+		this.sync(i);
+		token = this.tokens[i];
+	}
+	return i;
+};
+
+// Given a starting index, return the index of the previous token on channel.
+// Return i if tokens[i] is on channel. Return -1 if there are no tokens
+// on channel between i and 0.
+BufferedTokenStream.prototype.previousTokenOnChannel = function(i, channel) {
+	while (i >= 0 && this.tokens[i].channel !== channel) {
+		i -= 1;
+	}
+	return i;
+};
+
+// Collect all tokens on specified channel to the right of
+// the current token up until we see a token on DEFAULT_TOKEN_CHANNEL or
+// EOF. If channel is -1, find any non default channel token.
+BufferedTokenStream.prototype.getHiddenTokensToRight = function(tokenIndex,
+		channel) {
+	if (channel === undefined) {
+		channel = -1;
+	}
+	this.lazyInit();
+	if (tokenIndex < 0 || tokenIndex >= this.tokens.length) {
+		throw "" + tokenIndex + " not in 0.." + this.tokens.length - 1;
+	}
+	var nextOnChannel = this.nextTokenOnChannel(tokenIndex + 1,
+			Lexer.DEFAULT_TOKEN_CHANNEL);
+	var from_ = tokenIndex + 1;
+	// if none onchannel to right, nextOnChannel=-1 so set to = last token
+	var to = nextOnChannel === -1 ? this.tokens.length - 1 : nextOnChannel;
+	return this.filterForChannel(from_, to, channel);
+};
+
+// Collect all tokens on specified channel to the left of
+// the current token up until we see a token on DEFAULT_TOKEN_CHANNEL.
+// If channel is -1, find any non default channel token.
+BufferedTokenStream.prototype.getHiddenTokensToLeft = function(tokenIndex,
+		channel) {
+	if (channel === undefined) {
+		channel = -1;
+	}
+	this.lazyInit();
+	if (tokenIndex < 0 || tokenIndex >= this.tokens.length) {
+		throw "" + tokenIndex + " not in 0.." + this.tokens.length - 1;
+	}
+	var prevOnChannel = this.previousTokenOnChannel(tokenIndex - 1,
+			Lexer.DEFAULT_TOKEN_CHANNEL);
+	if (prevOnChannel === tokenIndex - 1) {
+		return null;
+	}
+	// if none on channel to left, prevOnChannel=-1 then from=0
+	var from_ = prevOnChannel + 1;
+	var to = tokenIndex - 1;
+	return this.filterForChannel(from_, to, channel);
+};
+
+BufferedTokenStream.prototype.filterForChannel = function(left, right, channel) {
+	var hidden = [];
+	for (var i = left; i < right + 1; i++) {
+		var t = this.tokens[i];
+		if (channel === -1) {
+			if (t.channel !== Lexer.DEFAULT_TOKEN_CHANNEL) {
+				hidden.push(t);
+			}
+		} else if (t.channel === channel) {
+			hidden.push(t);
+		}
+	}
+	if (hidden.length === 0) {
+		return null;
+	}
+	return hidden;
+};
+
+BufferedTokenStream.prototype.getSourceName = function() {
+	return this.tokenSource.getSourceName();
+};
+
+// Get the text of all tokens in this buffer.///
+BufferedTokenStream.prototype.getText = function(interval) {
+	this.lazyInit();
+	this.fill();
+	if (interval === undefined || interval === null) {
+		interval = new Interval(0, this.tokens.length - 1);
+	}
+	var start = interval.start;
+	if (start instanceof Token) {
+		start = start.tokenIndex;
+	}
+	var stop = interval.stop;
+	if (stop instanceof Token) {
+		stop = stop.tokenIndex;
+	}
+	if (start === null || stop === null || start < 0 || stop < 0) {
+		return "";
+	}
+	if (stop >= this.tokens.length) {
+		stop = this.tokens.length - 1;
+	}
+	var s = "";
+	for (var i = start; i < stop + 1; i++) {
+		var t = this.tokens[i];
+		if (t.type === Token.EOF) {
+			break;
+		}
+		s = s + t.text;
+	}
+	return s;
+};
+
+// Get all tokens from lexer until EOF///
+BufferedTokenStream.prototype.fill = function() {
+	this.lazyInit();
+	while (this.fetch(1000) === 1000) {
+		continue;
+	}
+};
+
+exports.BufferedTokenStream = BufferedTokenStream;
diff --git a/runtime/JavaScript/src/antlr4/CommonTokenFactory.js b/runtime/JavaScript/src/antlr4/CommonTokenFactory.js
new file mode 100644
index 000000000..49971190b
--- /dev/null
+++ b/runtime/JavaScript/src/antlr4/CommonTokenFactory.js
@@ -0,0 +1,93 @@
+//
+// [The "BSD license"]
+//  Copyright (c) 2012 Terence Parr
+//  Copyright (c) 2012 Sam Harwell
+//  Copyright (c) 2014 Eric Vergnaud
+//  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.
+//
+
+//
+// This default implementation of {@link TokenFactory} creates
+// {@link CommonToken} objects.
+//
+
+var CommonToken = require('./Token').CommonToken;
+
+function TokenFactory() {
+	return this;
+}
+
+function CommonTokenFactory(copyText) {
+	TokenFactory.call(this);
+    // Indicates whether {@link CommonToken//setText} should be called after
+    // constructing tokens to explicitly set the text. This is useful for cases
+    // where the input stream might not be able to provide arbitrary substrings
+    // of text from the input after the lexer creates a token (e.g. the
+    // implementation of {@link CharStream//getText} in
+    // {@link UnbufferedCharStream} throws an
+    // {@link UnsupportedOperationException}). Explicitly setting the token text
+    // allows {@link Token//getText} to be called at any time regardless of the
+    // input stream implementation.
+    //
+    // <p>
+    // The default value is {@code false} to avoid the performance and memory
+    // overhead of copying text for every token unless explicitly requested.</p>
+    //
+    this.copyText = copyText===undefined ? false : copyText;
+	return this;
+}
+
+CommonTokenFactory.prototype = Object.create(TokenFactory.prototype);
+CommonTokenFactory.prototype.constructor = CommonTokenFactory;
+
+//
+// The default {@link CommonTokenFactory} instance.
+//
+// <p>
+// This token factory does not explicitly copy token text when constructing
+// tokens.</p>
+//
+CommonTokenFactory.DEFAULT = new CommonTokenFactory();
+
+CommonTokenFactory.prototype.create = function(source, type, text, channel, start, stop, line, column) {
+    var t = new CommonToken(source, type, channel, start, stop);
+    t.line = line;
+    t.column = column;
+    if (text !==null) {
+        t.text = text;
+    } else if (this.copyText && source[1] !==null) {
+        t.text = source[1].getText(start,stop);
+    }
+    return t;
+};
+
+CommonTokenFactory.prototype.createThin = function(type, text) {
+    var t = new CommonToken(null, type);
+    t.text = text;
+    return t;
+};
+
+exports.CommonTokenFactory = CommonTokenFactory;
diff --git a/runtime/JavaScript/src/antlr4/CommonTokenStream.js b/runtime/JavaScript/src/antlr4/CommonTokenStream.js
new file mode 100644
index 000000000..2c07360d7
--- /dev/null
+++ b/runtime/JavaScript/src/antlr4/CommonTokenStream.js
@@ -0,0 +1,128 @@
+//
+// [The "BSD license"]
+//  Copyright (c) 2012 Terence Parr
+//  Copyright (c) 2012 Sam Harwell
+//  Copyright (c) 2014 Eric Vergnaud
+//  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.
+///
+
+//
+// This class extends {@link BufferedTokenStream} with functionality to filter
+// token streams to tokens on a particular channel (tokens where
+// {@link Token//getChannel} returns a particular value).
+//
+// <p>
+// This token stream provides access to all tokens by index or when calling
+// methods like {@link //getText}. The channel filtering is only used for code
+// accessing tokens via the lookahead methods {@link //LA}, {@link //LT}, and
+// {@link //LB}.</p>
+//
+// <p>
+// By default, tokens are placed on the default channel
+// ({@link Token//DEFAULT_CHANNEL}), but may be reassigned by using the
+// {@code ->channel(HIDDEN)} lexer command, or by using an embedded action to
+// call {@link Lexer//setChannel}.
+// </p>
+//
+// <p>
+// Note: lexer rules which use the {@code ->skip} lexer command or call
+// {@link Lexer//skip} do not produce tokens at all, so input text matched by
+// such a rule will not be available as part of the token stream, regardless of
+// channel.</p>
+///
+
+var Token = require('./Token').Token;
+var BufferedTokenStream = require('./BufferedTokenStream').BufferedTokenStream;
+
+function CommonTokenStream(lexer, channel) {
+	BufferedTokenStream.call(this, lexer);
+    this.channel = channel===undefined ? Token.DEFAULT_CHANNEL : channel;
+    return this;
+}
+
+CommonTokenStream.prototype = Object.create(BufferedTokenStream.prototype);
+CommonTokenStream.prototype.constructor = CommonTokenStream;
+
+CommonTokenStream.prototype.adjustSeekIndex = function(i) {
+    return this.nextTokenOnChannel(i, this.channel);
+};
+
+CommonTokenStream.prototype.LB = function(k) {
+    if (k===0 || this.index-k<0) {
+        return null;
+    }
+    var i = this.index;
+    var n = 1;
+    // find k good tokens looking backwards
+    while (n <= k) {
+        // skip off-channel tokens
+        i = this.previousTokenOnChannel(i - 1, this.channel);
+        n += 1;
+    }
+    if (i < 0) {
+        return null;
+    }
+    return this.tokens[i];
+};
+
+CommonTokenStream.prototype.LT = function(k) {
+    this.lazyInit();
+    if (k === 0) {
+        return null;
+    }
+    if (k < 0) {
+        return this.LB(-k);
+    }
+    var i = this.index;
+    var n = 1; // we know tokens[pos] is a good one
+    // find k good tokens
+    while (n < k) {
+        // skip off-channel tokens, but make sure to not look past EOF
+        if (this.sync(i + 1)) {
+            i = this.nextTokenOnChannel(i + 1, this.channel);
+        }
+        n += 1;
+    }
+    return this.tokens[i];
+};
+
+// Count EOF just once.///
+CommonTokenStream.prototype.getNumberOfOnChannelTokens = function() {
+    var n = 0;
+    this.fill();
+    for (var i =0; i< this.tokens.length;i++) {
+        var t = this.tokens[i];
+        if( t.channel===this.channel) {
+            n += 1;
+        }
+        if( t.type===Token.EOF) {
+            break;
+        }
+    }
+    return n;
+};
+
+exports.CommonTokenStream = CommonTokenStream;
\ No newline at end of file
diff --git a/runtime/JavaScript/src/antlr4/FileStream.js b/runtime/JavaScript/src/antlr4/FileStream.js
new file mode 100644
index 000000000..664056155
--- /dev/null
+++ b/runtime/JavaScript/src/antlr4/FileStream.js
@@ -0,0 +1,50 @@
+//
+//  [The "BSD license"]
+//   Copyright (c) 2012 Terence Parr
+//   Copyright (c) 2012 Sam Harwell
+//   Copyright (c) 2014 Eric Vergnaud
+//   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.
+// 
+
+//
+//  This is an InputStream that is loaded from a file all at once
+//  when you construct the object.
+// 
+var InputStream = require('./InputStream').InputStream;
+var isNodeJs = typeof window === 'undefined' && typeof importScripts === 'undefined';
+var fs = isNodeJs ? require("fs") : null;
+
+function FileStream(fileName) {
+	var data = fs.readFileSync(fileName, "utf8");
+	InputStream.call(this, data);
+	this.fileName = fileName;
+	return this;
+}
+
+FileStream.prototype = Object.create(InputStream.prototype);
+FileStream.prototype.constructor = FileStream;
+
+exports.FileStream = FileStream;
diff --git a/runtime/JavaScript/src/antlr4/InputStream.js b/runtime/JavaScript/src/antlr4/InputStream.js
new file mode 100644
index 000000000..b72b33a76
--- /dev/null
+++ b/runtime/JavaScript/src/antlr4/InputStream.js
@@ -0,0 +1,134 @@
+// 
+//  [The "BSD license"]
+//   Copyright (c) 2012 Terence Parr
+//   Copyright (c) 2012 Sam Harwell
+//   Copyright (c) 2014 Eric Vergnaud
+//   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.
+// 
+
+var Token = require('./Token').Token;
+
+// Vacuum all input from a string and then treat it like a buffer.
+
+function _loadString(stream) {
+	stream._index = 0;
+	stream.data = [];
+	for (var i = 0; i < stream.strdata.length; i++) {
+		stream.data.push(stream.strdata.charCodeAt(i));
+	}
+	stream._size = stream.data.length;
+}
+
+function InputStream(data) {
+	this.name = "<empty>";
+	this.strdata = data;
+	_loadString(this);
+	return this;
+}
+
+Object.defineProperty(InputStream.prototype, "index", {
+	get : function() {
+		return this._index;
+	}
+});
+
+Object.defineProperty(InputStream.prototype, "size", {
+	get : function() {
+		return this._size;
+	}
+});
+
+// Reset the stream so that it's in the same state it was
+// when the object was created *except* the data array is not
+// touched.
+//
+InputStream.prototype.reset = function() {
+	this._index = 0;
+};
+
+InputStream.prototype.consume = function() {
+	if (this._index >= this._size) {
+		// assert this.LA(1) == Token.EOF
+		throw ("cannot consume EOF");
+	}
+	this._index += 1;
+};
+
+InputStream.prototype.LA = function(offset) {
+	if (offset === 0) {
+		return 0; // undefined
+	}
+	if (offset < 0) {
+		offset += 1; // e.g., translate LA(-1) to use offset=0
+	}
+	var pos = this._index + offset - 1;
+	if (pos < 0 || pos >= this._size) { // invalid
+		return Token.EOF;
+	}
+	return this.data[pos];
+};
+
+InputStream.prototype.LT = function(offset) {
+	return this.LA(offset);
+};
+
+// mark/release do nothing; we have entire buffer
+InputStream.prototype.mark = function() {
+	return -1;
+};
+
+InputStream.prototype.release = function(marker) {
+};
+
+// consume() ahead until p==_index; can't just set p=_index as we must
+// update line and column. If we seek backwards, just set p
+//
+InputStream.prototype.seek = function(_index) {
+	if (_index <= this._index) {
+		this._index = _index; // just jump; don't update stream state (line,
+								// ...)
+		return;
+	}
+	// seek forward
+	this._index = Math.min(_index, this._size);
+};
+
+InputStream.prototype.getText = function(start, stop) {
+	if (stop >= this._size) {
+		stop = this._size - 1;
+	}
+	if (start >= this._size) {
+		return "";
+	} else {
+		return this.strdata.slice(start, stop + 1);
+	}
+};
+
+InputStream.prototype.toString = function() {
+	return this.strdata;
+};
+
+exports.InputStream = InputStream;
diff --git a/runtime/JavaScript/src/antlr4/IntervalSet.js b/runtime/JavaScript/src/antlr4/IntervalSet.js
new file mode 100644
index 000000000..9e58f2f06
--- /dev/null
+++ b/runtime/JavaScript/src/antlr4/IntervalSet.js
@@ -0,0 +1,293 @@
+/*jslint smarttabs:true */
+
+var Token = require('./Token').Token;
+
+/* stop is not included! */
+function Interval(start, stop) {
+	this.start = start;
+	this.stop = stop;
+	return this;
+}
+
+Interval.prototype.contains = function(item) {
+	return item >= this.start && item < this.stop;
+};
+
+Interval.prototype.toString = function() {
+	if(this.start===this.stop-1) {
+		return this.start.toString();
+	} else {
+		return this.start.toString() + ".." + (this.stop-1).toString();
+	}
+};
+
+
+Object.defineProperty(Interval.prototype, "length", {
+	get : function() {
+		return this.stop - this.start;
+	}
+});
+
+function IntervalSet() {
+	this.intervals = null;
+	this.readOnly = false;
+}
+
+IntervalSet.prototype.first = function(v) {
+	if (this.intervals === null || this.intervals.length===0) {
+		return Token.INVALID_TYPE;
+	} else {
+		return this.intervals[0].start;
+	}
+};
+
+IntervalSet.prototype.addOne = function(v) {
+	this.addInterval(new Interval(v, v + 1));
+};
+
+IntervalSet.prototype.addRange = function(l, h) {
+	this.addInterval(new Interval(l, h + 1));
+};
+
+IntervalSet.prototype.addInterval = function(v) {
+	if (this.intervals === null) {
+		this.intervals = [];
+		this.intervals.push(v);
+	} else {
+		// find insert pos
+		for (var k = 0; k < this.intervals.length; k++) {
+			var i = this.intervals[k];
+			// distinct range -> insert
+			if (v.stop < i.start) {
+				this.intervals.splice(k, 0, v);
+				return;
+			}
+			// contiguous range -> adjust
+			else if (v.stop === i.start) {
+				this.intervals[k].start = v.start;
+				return;
+			}
+			// overlapping range -> adjust and reduce
+			else if (v.start <= i.stop) {
+				this.intervals[k] = new Interval(Math.min(i.start, v.start), Math.max(i.stop, v.stop));
+				this.reduce(k);
+				return;
+			}
+		}
+		// greater than any existing
+		this.intervals.push(v);
+	}
+};
+
+IntervalSet.prototype.addSet = function(other) {
+	if (other.intervals !== null) {
+		for (var k = 0; k < other.intervals.length; k++) {
+			var i = other.intervals[k];
+			this.addInterval(new Interval(i.start, i.stop));
+		}
+	}
+	return this;
+};
+
+IntervalSet.prototype.reduce = function(k) {
+	// only need to reduce if k is not the last
+	if (k < this.intervalslength - 1) {
+		var l = this.intervals[k];
+		var r = this.intervals[k + 1];
+		// if r contained in l
+		if (l.stop >= r.stop) {
+			this.intervals.pop(k + 1);
+			this.reduce(k);
+		} else if (l.stop >= r.start) {
+			this.intervals[k] = new Interval(l.start, r.stop);
+			this.intervals.pop(k + 1);
+		}
+	}
+};
+
+IntervalSet.prototype.complement = function(start, stop) {
+    var result = new IntervalSet();
+    result.addInterval(new Interval(start,stop+1));
+    for(var i=0; i<this.intervals.length; i++) {
+        result.removeRange(this.intervals[i]);
+    }
+    return result;
+};
+
+IntervalSet.prototype.contains = function(item) {
+	if (this.intervals === null) {
+		return false;
+	} else {
+		for (var k = 0; k < this.intervals.length; k++) {
+			if(this.intervals[k].contains(item)) {
+				return true;
+			}
+		}
+		return false;
+	}
+};
+
+Object.defineProperty(IntervalSet.prototype, "length", {
+	get : function() {
+		var len = 0;
+		this.intervals.map(function(i) {len += i.length;});
+		return len;
+	}
+});
+
+IntervalSet.prototype.removeRange = function(v) {
+    if(v.start===v.stop-1) {
+        this.removeOne(v.start);
+    } else if (this.intervals!==null) {
+        var k = 0;
+        for(var n=0; n<this.intervals.length; n++) {
+            var i = this.intervals[k];
+            // intervals are ordered
+            if (v.stop<=i.start) {
+                return;
+            }
+            // check for including range, split it
+            else if(v.start>i.start && v.stop<i.stop) {
+                this.intervals[k] = new Interval(i.start, v.start);
+                var x = new Interval(v.stop, i.stop);
+                this.intervals.splice(k, 0, x);
+                return;
+            }
+            // check for included range, remove it
+            else if(v.start<=i.start && v.stop>=i.stop) {
+                this.intervals.splice(k, 1);
+                k = k - 1; // need another pass
+            }
+            // check for lower boundary
+            else if(v.start<i.stop) {
+                this.intervals[k] = new Interval(i.start, v.start);
+            }
+            // check for upper boundary
+            else if(v.stop<i.stop) {
+                this.intervals[k] = new Interval(v.stop, i.stop);
+            }
+            k += 1;
+        }
+    }
+};
+
+IntervalSet.prototype.removeOne = function(v) {
+	if (this.intervals !== null) {
+		for (var k = 0; k < this.intervals.length; k++) {
+			var i = this.intervals[k];
+			// intervals is ordered
+			if (v < i.start) {
+				return;
+			}
+			// check for single value range
+			else if (v === i.start && v === i.stop - 1) {
+				this.intervals.splice(k, 1);
+				return;
+			}
+			// check for lower boundary
+			else if (v === i.start) {
+				this.intervals[k] = new Interval(i.start + 1, i.stop);
+				return;
+			}
+			// check for upper boundary
+			else if (v === i.stop - 1) {
+				this.intervals[k] = new Interval(i.start, i.stop - 1);
+				return;
+			}
+			// split existing range
+			else if (v < i.stop - 1) {
+				var x = new Interval(i.start, v);
+				i.start = v + 1;
+				this.intervals.splice(k, 0, x);
+				return;
+			}
+		}
+	}
+};
+
+IntervalSet.prototype.toString = function(literalNames, symbolicNames, elemsAreChar) {
+	literalNames = literalNames || null;
+	symbolicNames = symbolicNames || null;
+	elemsAreChar = elemsAreChar || false;
+	if (this.intervals === null) {
+		return "{}";
+	} else if(literalNames!==null || symbolicNames!==null) {
+		return this.toTokenString(literalNames, symbolicNames);
+	} else if(elemsAreChar) {
+		return this.toCharString();
+	} else {
+		return this.toIndexString();
+	}
+};
+
+IntervalSet.prototype.toCharString = function() {
+	var names = [];
+	for (var i = 0; i < this.intervals.length; i++) {
+		var v = this.intervals[i];
+		if(v.stop===v.start+1) {
+			if ( v.start===Token.EOF ) {
+				names.push("<EOF>");
+			} else {
+				names.push("'" + String.fromCharCode(v.start) + "'");
+			}
+		} else {
+			names.push("'" + String.fromCharCode(v.start) + "'..'" + String.fromCharCode(v.stop-1) + "'");
+		}
+	}
+	if (names.length > 1) {
+		return "{" + names.join(", ") + "}";
+	} else {
+		return names[0];
+	}
+};
+
+
+IntervalSet.prototype.toIndexString = function() {
+	var names = [];
+	for (var i = 0; i < this.intervals.length; i++) {
+		var v = this.intervals[i];
+		if(v.stop===v.start+1) {
+			if ( v.start===Token.EOF ) {
+				names.push("<EOF>");
+			} else {
+				names.push(v.start.toString());
+			}
+		} else {
+			names.push(v.start.toString() + ".." + (v.stop-1).toString());
+		}
+	}
+	if (names.length > 1) {
+		return "{" + names.join(", ") + "}";
+	} else {
+		return names[0];
+	}
+};
+
+
+IntervalSet.prototype.toTokenString = function(literalNames, symbolicNames) {
+	var names = [];
+	for (var i = 0; i < this.intervals.length; i++) {
+		var v = this.intervals[i];
+		for (var j = v.start; j < v.stop; j++) {
+			names.push(this.elementName(literalNames, symbolicNames, j));
+		}
+	}
+	if (names.length > 1) {
+		return "{" + names.join(", ") + "}";
+	} else {
+		return names[0];
+	}
+};
+
+IntervalSet.prototype.elementName = function(literalNames, symbolicNames, a) {
+	if (a === Token.EOF) {
+		return "<EOF>";
+	} else if (a === Token.EPSILON) {
+		return "<EPSILON>";
+	} else {
+		return literalNames[a] || symbolicNames[a];
+	}
+};
+
+exports.Interval = Interval;
+exports.IntervalSet = IntervalSet;
diff --git a/runtime/JavaScript/src/antlr4/LL1Analyzer.js b/runtime/JavaScript/src/antlr4/LL1Analyzer.js
new file mode 100644
index 000000000..42d521268
--- /dev/null
+++ b/runtime/JavaScript/src/antlr4/LL1Analyzer.js
@@ -0,0 +1,223 @@
+//
+// [The "BSD license"]
+//  Copyright (c) 2012 Terence Parr
+//  Copyright (c) 2012 Sam Harwell
+//  Copyright (c) 2014 Eric Vergnaud
+//  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.
+///
+
+var Set = require('./Utils').Set;
+var BitSet = require('./Utils').BitSet;
+var Token = require('./Token').Token;
+var ATNConfig = require('./atn/ATNConfig').ATNConfig;
+var Interval = require('./IntervalSet').Interval;
+var IntervalSet = require('./IntervalSet').IntervalSet;
+var RuleStopState = require('./atn/ATNState').RuleStopState;
+var RuleTransition = require('./atn/Transition').RuleTransition;
+var NotSetTransition = require('./atn/Transition').NotSetTransition;
+var WildcardTransition = require('./atn/Transition').WildcardTransition;
+var AbstractPredicateTransition = require('./atn/Transition').AbstractPredicateTransition;
+
+var pc = require('./PredictionContext');
+var predictionContextFromRuleContext = pc.predictionContextFromRuleContext;
+var PredictionContext = pc.PredictionContext;
+var SingletonPredictionContext = pc.SingletonPredictionContext;
+
+function LL1Analyzer (atn) {
+    this.atn = atn;
+}
+
+//* Special value added to the lookahead sets to indicate that we hit
+//  a predicate during analysis if {@code seeThruPreds==false}.
+///
+LL1Analyzer.HIT_PRED = Token.INVALID_TYPE;
+
+
+//*
+// Calculates the SLL(1) expected lookahead set for each outgoing transition
+// of an {@link ATNState}. The returned array has one element for each
+// outgoing transition in {@code s}. If the closure from transition
+// <em>i</em> leads to a semantic predicate before matching a symbol, the
+// element at index <em>i</em> of the result will be {@code null}.
+//
+// @param s the ATN state
+// @return the expected symbols for each outgoing transition of {@code s}.
+///
+LL1Analyzer.prototype.getDecisionLookahead = function(s) {
+    if (s === null) {
+        return null;
+    }
+    var count = s.transitions.length;
+    var look = [];
+    for(var alt=0; alt< count; alt++) {
+        look[alt] = new IntervalSet();
+        var lookBusy = new Set();
+        var seeThruPreds = false; // fail to get lookahead upon pred
+        this._LOOK(s.transition(alt).target, null, PredictionContext.EMPTY,
+              look[alt], lookBusy, new BitSet(), seeThruPreds, false);
+        // Wipe out lookahead for this alternative if we found nothing
+        // or we had a predicate when we !seeThruPreds
+        if (look[alt].length===0 || look[alt].contains(LL1Analyzer.HIT_PRED)) {
+            look[alt] = null;
+        }
+    }
+    return look;
+};
+
+//*
+// Compute set of tokens that can follow {@code s} in the ATN in the
+// specified {@code ctx}.
+//
+// <p>If {@code ctx} is {@code null} and the end of the rule containing
+// {@code s} is reached, {@link Token//EPSILON} is added to the result set.
+// If {@code ctx} is not {@code null} and the end of the outermost rule is
+// reached, {@link Token//EOF} is added to the result set.</p>
+//
+// @param s the ATN state
+// @param stopState the ATN state to stop at. This can be a
+// {@link BlockEndState} to detect epsilon paths through a closure.
+// @param ctx the complete parser context, or {@code null} if the context
+// should be ignored
+//
+// @return The set of tokens that can follow {@code s} in the ATN in the
+// specified {@code ctx}.
+///
+LL1Analyzer.prototype.LOOK = function(s, stopState, ctx) {
+    var r = new IntervalSet();
+    var seeThruPreds = true; // ignore preds; get all lookahead
+	ctx = ctx || null;
+    var lookContext = ctx!==null ? predictionContextFromRuleContext(s.atn, ctx) : null;
+    this._LOOK(s, stopState, lookContext, r, new Set(), new BitSet(), seeThruPreds, true);
+    return r;
+};
+    
+//*
+// Compute set of tokens that can follow {@code s} in the ATN in the
+// specified {@code ctx}.
+//
+// <p>If {@code ctx} is {@code null} and {@code stopState} or the end of the
+// rule containing {@code s} is reached, {@link Token//EPSILON} is added to
+// the result set. If {@code ctx} is not {@code null} and {@code addEOF} is
+// {@code true} and {@code stopState} or the end of the outermost rule is
+// reached, {@link Token//EOF} is added to the result set.</p>
+//
+// @param s the ATN state.
+// @param stopState the ATN state to stop at. This can be a
+// {@link BlockEndState} to detect epsilon paths through a closure.
+// @param ctx The outer context, or {@code null} if the outer context should
+// not be used.
+// @param look The result lookahead set.
+// @param lookBusy A set used for preventing epsilon closures in the ATN
+// from causing a stack overflow. Outside code should pass
+// {@code new Set<ATNConfig>} for this argument.
+// @param calledRuleStack A set used for preventing left recursion in the
+// ATN from causing a stack overflow. Outside code should pass
+// {@code new BitSet()} for this argument.
+// @param seeThruPreds {@code true} to true semantic predicates as
+// implicitly {@code true} and "see through them", otherwise {@code false}
+// to treat semantic predicates as opaque and add {@link //HIT_PRED} to the
+// result if one is encountered.
+// @param addEOF Add {@link Token//EOF} to the result if the end of the
+// outermost context is reached. This parameter has no effect if {@code ctx}
+// is {@code null}.
+///
+LL1Analyzer.prototype._LOOK = function(s, stopState , ctx, look, lookBusy, calledRuleStack, seeThruPreds, addEOF) {
+    var c = new ATNConfig({state:s, alt:0, context: ctx}, null);
+    if (lookBusy.contains(c)) {
+        return;
+    }
+    lookBusy.add(c);
+    if (s === stopState) {
+        if (ctx ===null) {
+            look.addOne(Token.EPSILON);
+            return;
+        } else if (ctx.isEmpty() && addEOF) {
+            look.addOne(Token.EOF);
+            return;
+        }
+    }
+    if (s instanceof RuleStopState ) {
+        if (ctx ===null) {
+            look.addOne(Token.EPSILON);
+            return;
+        } else if (ctx.isEmpty() && addEOF) {
+            look.addOne(Token.EOF);
+            return;
+        }
+        if (ctx !== PredictionContext.EMPTY) {
+            // run thru all possible stack tops in ctx
+            for(var i=0; i<ctx.length; i++) {
+                var returnState = this.atn.states[ctx.getReturnState(i)];
+                var removed = calledRuleStack.contains(returnState.ruleIndex);
+                try {
+                    calledRuleStack.remove(returnState.ruleIndex);
+                    this._LOOK(returnState, stopState, ctx.getParent(i), look, lookBusy, calledRuleStack, seeThruPreds, addEOF);
+                } finally {
+                    if (removed) {
+                        calledRuleStack.add(returnState.ruleIndex);
+                    }
+                }
+            }
+            return;
+        }
+    }
+    for(var j=0; j<s.transitions.length; j++) {
+        var t = s.transitions[j];
+        if (t.constructor === RuleTransition) {
+            if (calledRuleStack.contains(t.target.ruleIndex)) {
+                continue;
+            }
+            var newContext = SingletonPredictionContext.create(ctx, t.followState.stateNumber);
+            try {
+                calledRuleStack.add(t.target.ruleIndex);
+                this._LOOK(t.target, stopState, newContext, look, lookBusy, calledRuleStack, seeThruPreds, addEOF);
+            } finally {
+                calledRuleStack.remove(t.target.ruleIndex);
+            }
+        } else if (t instanceof AbstractPredicateTransition ) {
+            if (seeThruPreds) {
+                this._LOOK(t.target, stopState, ctx, look, lookBusy, calledRuleStack, seeThruPreds, addEOF);
+            } else {
+                look.addOne(LL1Analyzer.HIT_PRED);
+            }
+        } else if( t.isEpsilon) {
+            this._LOOK(t.target, stopState, ctx, look, lookBusy, calledRuleStack, seeThruPreds, addEOF);
+        } else if (t.constructor === WildcardTransition) {
+            look.addRange( Token.MIN_USER_TOKEN_TYPE, this.atn.maxTokenType );
+        } else {
+            var set = t.label;
+            if (set !== null) {
+                if (t instanceof NotSetTransition) {
+                    set = set.complement(Token.MIN_USER_TOKEN_TYPE, this.atn.maxTokenType);
+                }
+                look.addSet(set);
+            }
+        }
+    }
+};
+
+exports.LL1Analyzer = LL1Analyzer;
+
diff --git a/runtime/JavaScript/src/antlr4/Lexer.js b/runtime/JavaScript/src/antlr4/Lexer.js
new file mode 100644
index 000000000..cc4b9c0ea
--- /dev/null
+++ b/runtime/JavaScript/src/antlr4/Lexer.js
@@ -0,0 +1,391 @@
+// [The "BSD license"]
+//  Copyright (c) 2012 Terence Parr
+//  Copyright (c) 2012 Sam Harwell
+//  Copyright (c) 2014 Eric Vergnaud
+//  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 lexer is recognizer that draws input symbols from a character stream.
+//  lexer grammars result in a subclass of this object. A Lexer object
+//  uses simplified match() and error recovery mechanisms in the interest
+//  of speed.
+///
+
+var Token = require('./Token').Token;
+var Recognizer = require('./Recognizer').Recognizer;
+var CommonTokenFactory = require('./CommonTokenFactory').CommonTokenFactory;
+var LexerNoViableAltException = require('./error/Errors').LexerNoViableAltException;
+
+function TokenSource() {
+	return this;
+}
+
+function Lexer(input) {
+	Recognizer.call(this);
+	this._input = input;
+	this._factory = CommonTokenFactory.DEFAULT;
+	this._tokenFactorySourcePair = [ this, input ];
+
+	this._interp = null; // child classes must populate this
+
+	// The goal of all lexer rules/methods is to create a token object.
+	// this is an instance variable as multiple rules may collaborate to
+	// create a single token. nextToken will return this object after
+	// matching lexer rule(s). If you subclass to allow multiple token
+	// emissions, then set this to the last token to be matched or
+	// something nonnull so that the auto token emit mechanism will not
+	// emit another token.
+	this._token = null;
+
+	// What character index in the stream did the current token start at?
+	// Needed, for example, to get the text for current token. Set at
+	// the start of nextToken.
+	this._tokenStartCharIndex = -1;
+
+	// The line on which the first character of the token resides///
+	this._tokenStartLine = -1;
+
+	// The character position of first character within the line///
+	this._tokenStartColumn = -1;
+
+	// Once we see EOF on char stream, next token will be EOF.
+	// If you have DONE : EOF ; then you see DONE EOF.
+	this._hitEOF = false;
+
+	// The channel number for the current token///
+	this._channel = Token.DEFAULT_CHANNEL;
+
+	// The token type for the current token///
+	this._type = Token.INVALID_TYPE;
+
+	this._modeStack = [];
+	this._mode = Lexer.DEFAULT_MODE;
+
+	// You can set the text for the current token to override what is in
+	// the input char buffer. Use setText() or can set this instance var.
+	// /
+	this._text = null;
+
+	return this;
+}
+
+Lexer.prototype = Object.create(Recognizer.prototype);
+Lexer.prototype.constructor = Lexer;
+
+Lexer.DEFAULT_MODE = 0;
+Lexer.MORE = -2;
+Lexer.SKIP = -3;
+
+Lexer.DEFAULT_TOKEN_CHANNEL = Token.DEFAULT_CHANNEL;
+Lexer.HIDDEN = Token.HIDDEN_CHANNEL;
+Lexer.MIN_CHAR_VALUE = '\u0000';
+Lexer.MAX_CHAR_VALUE = '\uFFFE';
+
+Lexer.prototype.reset = function() {
+	// wack Lexer state variables
+	if (this._input !== null) {
+		this._input.seek(0); // rewind the input
+	}
+	this._token = null;
+	this._type = Token.INVALID_TYPE;
+	this._channel = Token.DEFAULT_CHANNEL;
+	this._tokenStartCharIndex = -1;
+	this._tokenStartColumn = -1;
+	this._tokenStartLine = -1;
+	this._text = null;
+
+	this._hitEOF = false;
+	this._mode = Lexer.DEFAULT_MODE;
+	this._modeStack = [];
+
+	this._interp.reset();
+};
+
+// Return a token from this source; i.e., match a token on the char stream.
+Lexer.prototype.nextToken = function() {
+	if (this._input === null) {
+		throw "nextToken requires a non-null input stream.";
+	}
+
+	// Mark start location in char stream so unbuffered streams are
+	// guaranteed at least have text of current token
+	var tokenStartMarker = this._input.mark();
+	try {
+		while (true) {
+			if (this._hitEOF) {
+				this.emitEOF();
+				return this._token;
+			}
+			this._token = null;
+			this._channel = Token.DEFAULT_CHANNEL;
+			this._tokenStartCharIndex = this._input.index;
+			this._tokenStartColumn = this._interp.column;
+			this._tokenStartLine = this._interp.line;
+			this._text = null;
+			var continueOuter = false;
+			while (true) {
+				this._type = Token.INVALID_TYPE;
+				var ttype = Lexer.SKIP;
+				try {
+					ttype = this._interp.match(this._input, this._mode);
+				} catch (e) {
+					this.notifyListeners(e); // report error
+					this.recover(e);
+				}
+				if (this._input.LA(1) === Token.EOF) {
+					this._hitEOF = true;
+				}
+				if (this._type === Token.INVALID_TYPE) {
+					this._type = ttype;
+				}
+				if (this._type === Lexer.SKIP) {
+					continueOuter = true;
+					break;
+				}
+				if (this._type !== Lexer.MORE) {
+					break;
+				}
+			}
+			if (continueOuter) {
+				continue;
+			}
+			if (this._token === null) {
+				this.emit();
+			}
+			return this._token;
+		}
+	} finally {
+		// make sure we release marker after match or
+		// unbuffered char stream will keep buffering
+		this._input.release(tokenStartMarker);
+	}
+};
+
+// Instruct the lexer to skip creating a token for current lexer rule
+// and look for another token. nextToken() knows to keep looking when
+// a lexer rule finishes with token set to SKIP_TOKEN. Recall that
+// if token==null at end of any token rule, it creates one for you
+// and emits it.
+// /
+Lexer.prototype.skip = function() {
+	this._type = Lexer.SKIP;
+};
+
+Lexer.prototype.more = function() {
+	this._type = Lexer.MORE;
+};
+
+Lexer.prototype.mode = function(m) {
+	this._mode = m;
+};
+
+Lexer.prototype.pushMode = function(m) {
+	if (this._interp.debug) {
+		console.log("pushMode " + m);
+	}
+	this._modeStack.push(this._mode);
+	this.mode(m);
+};
+
+Lexer.prototype.popMode = function() {
+	if (this._modeStack.length === 0) {
+		throw "Empty Stack";
+	}
+	if (this._interp.debug) {
+		console.log("popMode back to " + this._modeStack.slice(0, -1));
+	}
+	this.mode(this._modeStack.pop());
+	return this._mode;
+};
+
+// Set the char stream and reset the lexer
+Object.defineProperty(Lexer.prototype, "inputStream", {
+	get : function() {
+		return this._input;
+	},
+	set : function(input) {
+		this._input = null;
+		this._tokenFactorySourcePair = [ this, this._input ];
+		this.reset();
+		this._input = input;
+		this._tokenFactorySourcePair = [ this, this._input ];
+	}
+});
+
+Object.defineProperty(Lexer.prototype, "sourceName", {
+	get : function sourceName() {
+		return this._input.sourceName;
+	}
+});
+
+// By default does not support multiple emits per nextToken invocation
+// for efficiency reasons. Subclass and override this method, nextToken,
+// and getToken (to push tokens into a list and pull from that list
+// rather than a single variable as this implementation does).
+// /
+Lexer.prototype.emitToken = function(token) {
+	this._token = token;
+};
+
+// The standard method called to automatically emit a token at the
+// outermost lexical rule. The token object should point into the
+// char buffer start..stop. If there is a text override in 'text',
+// use that to set the token's text. Override this method to emit
+// custom Token objects or provide a new factory.
+// /
+Lexer.prototype.emit = function() {
+	var t = this._factory.create(this._tokenFactorySourcePair, this._type,
+			this._text, this._channel, this._tokenStartCharIndex, this
+					.getCharIndex() - 1, this._tokenStartLine,
+			this._tokenStartColumn);
+	this.emitToken(t);
+	return t;
+};
+
+Lexer.prototype.emitEOF = function() {
+	var cpos = this.column;
+	var lpos = this.line;
+	var eof = this._factory.create(this._tokenFactorySourcePair, Token.EOF,
+			null, Token.DEFAULT_CHANNEL, this._input.index,
+			this._input.index - 1, lpos, cpos);
+	this.emitToken(eof);
+	return eof;
+};
+
+Object.defineProperty(Lexer.prototype, "type", {
+	get : function() {
+		return this.type;
+	},
+	set : function(type) {
+		this._type = type;
+	}
+});
+
+Object.defineProperty(Lexer.prototype, "line", {
+	get : function() {
+		return this._interp.line;
+	},
+	set : function(line) {
+		this._interp.line = line;
+	}
+});
+
+Object.defineProperty(Lexer.prototype, "column", {
+	get : function() {
+		return this._interp.column;
+	},
+	set : function(column) {
+		this._interp.column = column;
+	}
+});
+
+
+// What is the index of the current character of lookahead?///
+Lexer.prototype.getCharIndex = function() {
+	return this._input.index;
+};
+
+// Return the text matched so far for the current token or any text override.
+//Set the complete text of this token; it wipes any previous changes to the text.
+Object.defineProperty(Lexer.prototype, "text", {
+	get : function() {
+		if (this._text !== null) {
+			return this._text;
+		} else {
+			return this._interp.getText(this._input);
+		}
+	},
+	set : function(text) {
+		this._text = text;
+	}
+});
+// Return a list of all Token objects in input char stream.
+// Forces load of all tokens. Does not include EOF token.
+// /
+Lexer.prototype.getAllTokens = function() {
+	var tokens = [];
+	var t = this.nextToken();
+	while (t.type !== Token.EOF) {
+		tokens.push(t);
+		t = this.nextToken();
+	}
+	return tokens;
+};
+
+Lexer.prototype.notifyListeners = function(e) {
+	var start = this._tokenStartCharIndex;
+	var stop = this._input.index;
+	var text = this._input.getText(start, stop);
+	var msg = "token recognition error at: '" + this.getErrorDisplay(text) + "'";
+	var listener = this.getErrorListenerDispatch();
+	listener.syntaxError(this, null, this._tokenStartLine,
+			this._tokenStartColumn, msg, e);
+};
+
+Lexer.prototype.getErrorDisplay = function(s) {
+	var d = [];
+	for (var i = 0; i < s.length; i++) {
+		d.push(s[i]);
+	}
+	return d.join('');
+};
+
+Lexer.prototype.getErrorDisplayForChar = function(c) {
+	if (c.charCodeAt(0) === Token.EOF) {
+		return "<EOF>";
+	} else if (c === '\n') {
+		return "\\n";
+	} else if (c === '\t') {
+		return "\\t";
+	} else if (c === '\r') {
+		return "\\r";
+	} else {
+		return c;
+	}
+};
+
+Lexer.prototype.getCharErrorDisplay = function(c) {
+	return "'" + this.getErrorDisplayForChar(c) + "'";
+};
+
+// Lexers can normally match any char in it's vocabulary after matching
+// a token, so do the easy thing and just kill a character and hope
+// it all works out. You can instead use the rule invocation stack
+// to do sophisticated error recovery if you are in a fragment rule.
+// /
+Lexer.prototype.recover = function(re) {
+	if (this._input.LA(1) !== Token.EOF) {
+		if (re instanceof LexerNoViableAltException) {
+			// skip a char and try again
+			this._interp.consume(this._input);
+		} else {
+			// TODO: Do we lose character or line position information?
+			this._input.consume();
+		}
+	}
+};
+
+exports.Lexer = Lexer;
diff --git a/runtime/JavaScript/src/antlr4/Parser.js b/runtime/JavaScript/src/antlr4/Parser.js
new file mode 100644
index 000000000..1ec5cc014
--- /dev/null
+++ b/runtime/JavaScript/src/antlr4/Parser.js
@@ -0,0 +1,692 @@
+// [The "BSD license"]
+//  Copyright (c) 2012 Terence Parr
+//  Copyright (c) 2012 Sam Harwell
+//  Copyright (c) 2014 Eric Vergnaud
+//  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.
+
+var Token = require('./Token').Token;
+var ParseTreeListener = require('./tree/Tree').ParseTreeListener;
+var Recognizer = require('./Recognizer').Recognizer;
+var DefaultErrorStrategy = require('./error/ErrorStrategy').DefaultErrorStrategy;
+var ATNDeserializer = require('./atn/ATNDeserializer').ATNDeserializer;
+var ATNDeserializationOptions = require('./atn/ATNDeserializationOptions').ATNDeserializationOptions;
+
+function TraceListener(parser) {
+	ParseTreeListener.call(this);
+    this.parser = parser;
+	return this;
+}
+
+TraceListener.prototype = Object.create(ParseTreeListener);
+TraceListener.prototype.constructor = TraceListener;
+
+TraceListener.prototype.enterEveryRule = function(ctx) {
+	console.log("enter   " + this.parser.ruleNames[ctx.ruleIndex] + ", LT(1)=" + this.parser._input.LT(1).text);
+};
+
+TraceListener.prototype.visitTerminal = function( node) {
+	console.log("consume " + node.symbol + " rule " + this.parser.ruleNames[this.parser._ctx.ruleIndex]);
+};
+
+TraceListener.prototype.exitEveryRule = function(ctx) {
+	console.log("exit    " + this.parser.ruleNames[ctx.ruleIndex] + ", LT(1)=" + this.parser._input.LT(1).text);
+};
+
+// this is all the parsing support code essentially; most of it is error
+// recovery stuff.//
+function Parser(input) {
+	Recognizer.call(this);
+	// The input stream.
+	this._input = null;
+	// The error handling strategy for the parser. The default value is a new
+	// instance of {@link DefaultErrorStrategy}.
+	this._errHandler = new DefaultErrorStrategy();
+	this._precedenceStack = [];
+	this._precedenceStack.push(0);
+	// The {@link ParserRuleContext} object for the currently executing rule.
+	// this is always non-null during the parsing process.
+	this._ctx = null;
+	// Specifies whether or not the parser should construct a parse tree during
+	// the parsing process. The default value is {@code true}.
+	this.buildParseTrees = true;
+	// When {@link //setTrace}{@code (true)} is called, a reference to the
+	// {@link TraceListener} is stored here so it can be easily removed in a
+	// later call to {@link //setTrace}{@code (false)}. The listener itself is
+	// implemented as a parser listener so this field is not directly used by
+	// other parser methods.
+	this._tracer = null;
+	// The list of {@link ParseTreeListener} listeners registered to receive
+	// events during the parse.
+	this._parseListeners = null;
+	// The number of syntax errors reported during parsing. this value is
+	// incremented each time {@link //notifyErrorListeners} is called.
+	this._syntaxErrors = 0;
+	this.setInputStream(input);
+	return this;
+}
+
+Parser.prototype = Object.create(Recognizer.prototype);
+Parser.prototype.contructor = Parser;
+
+// this field maps from the serialized ATN string to the deserialized {@link
+// ATN} with
+// bypass alternatives.
+//
+// @see ATNDeserializationOptions//isGenerateRuleBypassTransitions()
+//
+Parser.bypassAltsAtnCache = {};
+
+// reset the parser's state//
+Parser.prototype.reset = function() {
+	if (this._input !== null) {
+		this._input.seek(0);
+	}
+	this._errHandler.reset(this);
+	this._ctx = null;
+	this._syntaxErrors = 0;
+	this.setTrace(false);
+	this._precedenceStack = [];
+	this._precedenceStack.push(0);
+	if (this._interp !== null) {
+		this._interp.reset();
+	}
+};
+
+// Match current input symbol against {@code ttype}. If the symbol type
+// matches, {@link ANTLRErrorStrategy//reportMatch} and {@link //consume} are
+// called to complete the match process.
+//
+// <p>If the symbol type does not match,
+// {@link ANTLRErrorStrategy//recoverInline} is called on the current error
+// strategy to attempt recovery. If {@link //getBuildParseTree} is
+// {@code true} and the token index of the symbol returned by
+// {@link ANTLRErrorStrategy//recoverInline} is -1, the symbol is added to
+// the parse tree by calling {@link ParserRuleContext//addErrorNode}.</p>
+//
+// @param ttype the token type to match
+// @return the matched symbol
+// @throws RecognitionException if the current input symbol did not match
+// {@code ttype} and the error strategy could not recover from the
+// mismatched symbol
+
+Parser.prototype.match = function(ttype) {
+	var t = this.getCurrentToken();
+	if (t.type === ttype) {
+		this._errHandler.reportMatch(this);
+		this.consume();
+	} else {
+		t = this._errHandler.recoverInline(this);
+		if (this.buildParseTrees && t.tokenIndex === -1) {
+			// we must have conjured up a new token during single token
+			// insertion
+			// if it's not the current symbol
+			this._ctx.addErrorNode(t);
+		}
+	}
+	return t;
+};
+// Match current input symbol as a wildcard. If the symbol type matches
+// (i.e. has a value greater than 0), {@link ANTLRErrorStrategy//reportMatch}
+// and {@link //consume} are called to complete the match process.
+//
+// <p>If the symbol type does not match,
+// {@link ANTLRErrorStrategy//recoverInline} is called on the current error
+// strategy to attempt recovery. If {@link //getBuildParseTree} is
+// {@code true} and the token index of the symbol returned by
+// {@link ANTLRErrorStrategy//recoverInline} is -1, the symbol is added to
+// the parse tree by calling {@link ParserRuleContext//addErrorNode}.</p>
+//
+// @return the matched symbol
+// @throws RecognitionException if the current input symbol did not match
+// a wildcard and the error strategy could not recover from the mismatched
+// symbol
+
+Parser.prototype.matchWildcard = function() {
+	var t = this.getCurrentToken();
+	if (t.type > 0) {
+		this._errHandler.reportMatch(this);
+		this.consume();
+	} else {
+		t = this._errHandler.recoverInline(this);
+		if (this._buildParseTrees && t.tokenIndex === -1) {
+			// we must have conjured up a new token during single token
+			// insertion
+			// if it's not the current symbol
+			this._ctx.addErrorNode(t);
+		}
+	}
+	return t;
+};
+
+Parser.prototype.getParseListeners = function() {
+	return this._parseListeners || [];
+};
+
+// Registers {@code listener} to receive events during the parsing process.
+//
+// <p>To support output-preserving grammar transformations (including but not
+// limited to left-recursion removal, automated left-factoring, and
+// optimized code generation), calls to listener methods during the parse
+// may differ substantially from calls made by
+// {@link ParseTreeWalker//DEFAULT} used after the parse is complete. In
+// particular, rule entry and exit events may occur in a different order
+// during the parse than after the parser. In addition, calls to certain
+// rule entry methods may be omitted.</p>
+//
+// <p>With the following specific exceptions, calls to listener events are
+// <em>deterministic</em>, i.e. for identical input the calls to listener
+// methods will be the same.</p>
+//
+// <ul>
+// <li>Alterations to the grammar used to generate code may change the
+// behavior of the listener calls.</li>
+// <li>Alterations to the command line options passed to ANTLR 4 when
+// generating the parser may change the behavior of the listener calls.</li>
+// <li>Changing the version of the ANTLR Tool used to generate the parser
+// may change the behavior of the listener calls.</li>
+// </ul>
+//
+// @param listener the listener to add
+//
+// @throws NullPointerException if {@code} listener is {@code null}
+//
+Parser.prototype.addParseListener = function(listener) {
+	if (listener === null) {
+		throw "listener";
+	}
+	if (this._parseListeners === null) {
+		this._parseListeners = [];
+	}
+	this._parseListeners.push(listener);
+};
+
+//
+// Remove {@code listener} from the list of parse listeners.
+//
+// <p>If {@code listener} is {@code null} or has not been added as a parse
+// listener, this method does nothing.</p>
+// @param listener the listener to remove
+//
+Parser.prototype.removeParseListener = function(listener) {
+	if (this._parseListeners !== null) {
+		var idx = this._parseListeners.indexOf(listener);
+		if (idx >= 0) {
+			this._parseListeners.splice(idx, 1);
+		}
+		if (this._parseListeners.length === 0) {
+			this._parseListeners = null;
+		}
+	}
+};
+
+// Remove all parse listeners.
+Parser.prototype.removeParseListeners = function() {
+	this._parseListeners = null;
+};
+
+// Notify any parse listeners of an enter rule event.
+Parser.prototype.triggerEnterRuleEvent = function() {
+	if (this._parseListeners !== null) {
+        var ctx = this._ctx;
+		this._parseListeners.map(function(listener) {
+			listener.enterEveryRule(ctx);
+			ctx.enterRule(listener);
+		});
+	}
+};
+
+//
+// Notify any parse listeners of an exit rule event.
+//
+// @see //addParseListener
+//
+Parser.prototype.triggerExitRuleEvent = function() {
+	if (this._parseListeners !== null) {
+		// reverse order walk of listeners
+        var ctx = this._ctx;
+		this._parseListeners.slice(0).reverse().map(function(listener) {
+			ctx.exitRule(listener);
+			listener.exitEveryRule(ctx);
+		});
+	}
+};
+
+Parser.prototype.getTokenFactory = function() {
+	return this._input.tokenSource._factory;
+};
+
+// Tell our token source and error strategy about a new way to create tokens.//
+Parser.prototype.setTokenFactory = function(factory) {
+	this._input.tokenSource._factory = factory;
+};
+
+// The ATN with bypass alternatives is expensive to create so we create it
+// lazily.
+//
+// @throws UnsupportedOperationException if the current parser does not
+// implement the {@link //getSerializedATN()} method.
+//
+Parser.prototype.getATNWithBypassAlts = function() {
+	var serializedAtn = this.getSerializedATN();
+	if (serializedAtn === null) {
+		throw "The current parser does not support an ATN with bypass alternatives.";
+	}
+	var result = this.bypassAltsAtnCache[serializedAtn];
+	if (result === null) {
+		var deserializationOptions = new ATNDeserializationOptions();
+		deserializationOptions.generateRuleBypassTransitions = true;
+		result = new ATNDeserializer(deserializationOptions)
+				.deserialize(serializedAtn);
+		this.bypassAltsAtnCache[serializedAtn] = result;
+	}
+	return result;
+};
+
+// The preferred method of getting a tree pattern. For example, here's a
+// sample use:
+//
+// <pre>
+// ParseTree t = parser.expr();
+// ParseTreePattern p = parser.compileParseTreePattern("&lt;ID&gt;+0",
+// MyParser.RULE_expr);
+// ParseTreeMatch m = p.match(t);
+// String id = m.get("ID");
+// </pre>
+
+var Lexer = require('./Lexer').Lexer;
+
+Parser.prototype.compileParseTreePattern = function(pattern, patternRuleIndex, lexer) {
+	lexer = lexer || null;
+	if (lexer === null) {
+		if (this.getTokenStream() !== null) {
+			var tokenSource = this.getTokenStream().tokenSource;
+			if (tokenSource instanceof Lexer) {
+				lexer = tokenSource;
+			}
+		}
+	}
+	if (lexer === null) {
+		throw "Parser can't discover a lexer to use";
+	}
+	var m = new ParseTreePatternMatcher(lexer, this);
+	return m.compile(pattern, patternRuleIndex);
+};
+
+Parser.prototype.getInputStream = function() {
+	return this.getTokenStream();
+};
+
+Parser.prototype.setInputStream = function(input) {
+	this.setTokenStream(input);
+};
+
+Parser.prototype.getTokenStream = function() {
+	return this._input;
+};
+
+// Set the token stream and reset the parser.//
+Parser.prototype.setTokenStream = function(input) {
+	this._input = null;
+	this.reset();
+	this._input = input;
+};
+
+// Match needs to return the current input symbol, which gets put
+// into the label for the associated token ref; e.g., x=ID.
+//
+Parser.prototype.getCurrentToken = function() {
+	return this._input.LT(1);
+};
+
+Parser.prototype.notifyErrorListeners = function(msg, offendingToken, err) {
+	offendingToken = offendingToken || null;
+	err = err || null;
+	if (offendingToken === null) {
+		offendingToken = this.getCurrentToken();
+	}
+	this._syntaxErrors += 1;
+	var line = offendingToken.line;
+	var column = offendingToken.column;
+	var listener = this.getErrorListenerDispatch();
+	listener.syntaxError(this, offendingToken, line, column, msg, err);
+};
+
+//
+// Consume and return the {@linkplain //getCurrentToken current symbol}.
+//
+// <p>E.g., given the following input with {@code A} being the current
+// lookahead symbol, this function moves the cursor to {@code B} and returns
+// {@code A}.</p>
+//
+// <pre>
+// A B
+// ^
+// </pre>
+//
+// If the parser is not in error recovery mode, the consumed symbol is added
+// to the parse tree using {@link ParserRuleContext//addChild(Token)}, and
+// {@link ParseTreeListener//visitTerminal} is called on any parse listeners.
+// If the parser <em>is</em> in error recovery mode, the consumed symbol is
+// added to the parse tree using
+// {@link ParserRuleContext//addErrorNode(Token)}, and
+// {@link ParseTreeListener//visitErrorNode} is called on any parse
+// listeners.
+//
+Parser.prototype.consume = function() {
+	var o = this.getCurrentToken();
+	if (o.type !== Token.EOF) {
+		this.getInputStream().consume();
+	}
+	var hasListener = this._parseListeners !== null && this._parseListeners.length > 0;
+	if (this.buildParseTrees || hasListener) {
+		var node;
+		if (this._errHandler.inErrorRecoveryMode(this)) {
+			node = this._ctx.addErrorNode(o);
+		} else {
+			node = this._ctx.addTokenNode(o);
+		}
+        node.invokingState = this.state;
+		if (hasListener) {
+			this._parseListeners.map(function(listener) {
+				listener.visitTerminal(node);
+			});
+		}
+	}
+	return o;
+};
+
+Parser.prototype.addContextToParseTree = function() {
+	// add current context to parent if we have a parent
+	if (this._ctx.parentCtx !== null) {
+		this._ctx.parentCtx.addChild(this._ctx);
+	}
+};
+
+// Always called by generated parsers upon entry to a rule. Access field
+// {@link //_ctx} get the current context.
+
+Parser.prototype.enterRule = function(localctx, state, ruleIndex) {
+	this.state = state;
+	this._ctx = localctx;
+	this._ctx.start = this._input.LT(1);
+	if (this.buildParseTrees) {
+		this.addContextToParseTree();
+	}
+	if (this._parseListeners !== null) {
+		this.triggerEnterRuleEvent();
+	}
+};
+
+Parser.prototype.exitRule = function() {
+	this._ctx.stop = this._input.LT(-1);
+	// trigger event on _ctx, before it reverts to parent
+	if (this._parseListeners !== null) {
+		this.triggerExitRuleEvent();
+	}
+	this.state = this._ctx.invokingState;
+	this._ctx = this._ctx.parentCtx;
+};
+
+Parser.prototype.enterOuterAlt = function(localctx, altNum) {
+   	localctx.setAltNumber(altNum);
+	// if we have new localctx, make sure we replace existing ctx
+	// that is previous child of parse tree
+	if (this.buildParseTrees && this._ctx !== localctx) {
+		if (this._ctx.parentCtx !== null) {
+			this._ctx.parentCtx.removeLastChild();
+			this._ctx.parentCtx.addChild(localctx);
+		}
+	}
+	this._ctx = localctx;
+};
+
+// Get the precedence level for the top-most precedence rule.
+//
+// @return The precedence level for the top-most precedence rule, or -1 if
+// the parser context is not nested within a precedence rule.
+
+Parser.prototype.getPrecedence = function() {
+	if (this._precedenceStack.length === 0) {
+		return -1;
+	} else {
+		return this._precedenceStack[this._precedenceStack.length-1];
+	}
+};
+
+Parser.prototype.enterRecursionRule = function(localctx, state, ruleIndex,
+		precedence) {
+	this.state = state;
+	this._precedenceStack.push(precedence);
+	this._ctx = localctx;
+	this._ctx.start = this._input.LT(1);
+	if (this._parseListeners !== null) {
+		this.triggerEnterRuleEvent(); // simulates rule entry for
+										// left-recursive rules
+	}
+};
+
+//
+// Like {@link //enterRule} but for recursive rules.
+
+Parser.prototype.pushNewRecursionContext = function(localctx, state, ruleIndex) {
+	var previous = this._ctx;
+	previous.parentCtx = localctx;
+	previous.invokingState = state;
+	previous.stop = this._input.LT(-1);
+
+	this._ctx = localctx;
+	this._ctx.start = previous.start;
+	if (this.buildParseTrees) {
+		this._ctx.addChild(previous);
+	}
+	if (this._parseListeners !== null) {
+		this.triggerEnterRuleEvent(); // simulates rule entry for
+										// left-recursive rules
+	}
+};
+
+Parser.prototype.unrollRecursionContexts = function(parentCtx) {
+	this._precedenceStack.pop();
+	this._ctx.stop = this._input.LT(-1);
+	var retCtx = this._ctx; // save current ctx (return value)
+	// unroll so _ctx is as it was before call to recursive method
+	if (this._parseListeners !== null) {
+		while (this._ctx !== parentCtx) {
+			this.triggerExitRuleEvent();
+			this._ctx = this._ctx.parentCtx;
+		}
+	} else {
+		this._ctx = parentCtx;
+	}
+	// hook into tree
+	retCtx.parentCtx = parentCtx;
+	if (this.buildParseTrees && parentCtx !== null) {
+		// add return ctx into invoking rule's tree
+		parentCtx.addChild(retCtx);
+	}
+};
+
+Parser.prototype.getInvokingContext = function(ruleIndex) {
+	var ctx = this._ctx;
+	while (ctx !== null) {
+		if (ctx.ruleIndex === ruleIndex) {
+			return ctx;
+		}
+		ctx = ctx.parentCtx;
+	}
+	return null;
+};
+
+Parser.prototype.precpred = function(localctx, precedence) {
+	return precedence >= this._precedenceStack[this._precedenceStack.length-1];
+};
+
+Parser.prototype.inContext = function(context) {
+	// TODO: useful in parser?
+	return false;
+};
+
+//
+// Checks whether or not {@code symbol} can follow the current state in the
+// ATN. The behavior of this method is equivalent to the following, but is
+// implemented such that the complete context-sensitive follow set does not
+// need to be explicitly constructed.
+//
+// <pre>
+// return getExpectedTokens().contains(symbol);
+// </pre>
+//
+// @param symbol the symbol type to check
+// @return {@code true} if {@code symbol} can follow the current state in
+// the ATN, otherwise {@code false}.
+
+Parser.prototype.isExpectedToken = function(symbol) {
+	var atn = this._interp.atn;
+	var ctx = this._ctx;
+	var s = atn.states[this.state];
+	var following = atn.nextTokens(s);
+	if (following.contains(symbol)) {
+		return true;
+	}
+	if (!following.contains(Token.EPSILON)) {
+		return false;
+	}
+	while (ctx !== null && ctx.invokingState >= 0 && following.contains(Token.EPSILON)) {
+		var invokingState = atn.states[ctx.invokingState];
+		var rt = invokingState.transitions[0];
+		following = atn.nextTokens(rt.followState);
+		if (following.contains(symbol)) {
+			return true;
+		}
+		ctx = ctx.parentCtx;
+	}
+	if (following.contains(Token.EPSILON) && symbol === Token.EOF) {
+		return true;
+	} else {
+		return false;
+	}
+};
+
+// Computes the set of input symbols which could follow the current parser
+// state and context, as given by {@link //getState} and {@link //getContext},
+// respectively.
+//
+// @see ATN//getExpectedTokens(int, RuleContext)
+//
+Parser.prototype.getExpectedTokens = function() {
+	return this._interp.atn.getExpectedTokens(this.state, this._ctx);
+};
+
+Parser.prototype.getExpectedTokensWithinCurrentRule = function() {
+	var atn = this._interp.atn;
+	var s = atn.states[this.state];
+	return atn.nextTokens(s);
+};
+
+// Get a rule's index (i.e., {@code RULE_ruleName} field) or -1 if not found.//
+Parser.prototype.getRuleIndex = function(ruleName) {
+	var ruleIndex = this.getRuleIndexMap()[ruleName];
+	if (ruleIndex !== null) {
+		return ruleIndex;
+	} else {
+		return -1;
+	}
+};
+
+// Return List&lt;String&gt; of the rule names in your parser instance
+// leading up to a call to the current rule. You could override if
+// you want more details such as the file/line info of where
+// in the ATN a rule is invoked.
+//
+// this is very useful for error messages.
+//
+Parser.prototype.getRuleInvocationStack = function(p) {
+	p = p || null;
+	if (p === null) {
+		p = this._ctx;
+	}
+	var stack = [];
+	while (p !== null) {
+		// compute what follows who invoked us
+		var ruleIndex = p.ruleIndex;
+		if (ruleIndex < 0) {
+			stack.push("n/a");
+		} else {
+			stack.push(this.ruleNames[ruleIndex]);
+		}
+		p = p.parentCtx;
+	}
+	return stack;
+};
+
+// For debugging and other purposes.//
+Parser.prototype.getDFAStrings = function() {
+	return this._interp.decisionToDFA.toString();
+};
+// For debugging and other purposes.//
+Parser.prototype.dumpDFA = function() {
+	var seenOne = false;
+	for (var i = 0; i < this._interp.decisionToDFA.length; i++) {
+		var dfa = this._interp.decisionToDFA[i];
+		if (dfa.states.length > 0) {
+			if (seenOne) {
+				console.log();
+			}
+			this.printer.println("Decision " + dfa.decision + ":");
+			this.printer.print(dfa.toString(this.literalNames, this.symbolicNames));
+			seenOne = true;
+		}
+	}
+};
+
+/*
+"			printer = function() {\r\n" +
+"				this.println = function(s) { document.getElementById('output') += s + '\\n'; }\r\n" +
+"				this.print = function(s) { document.getElementById('output') += s; }\r\n" +
+"			};\r\n" +
+*/
+
+Parser.prototype.getSourceName = function() {
+	return this._input.sourceName;
+};
+
+// During a parse is sometimes useful to listen in on the rule entry and exit
+// events as well as token matches. this is for quick and dirty debugging.
+//
+Parser.prototype.setTrace = function(trace) {
+	if (!trace) {
+		this.removeParseListener(this._tracer);
+		this._tracer = null;
+	} else {
+		if (this._tracer !== null) {
+			this.removeParseListener(this._tracer);
+		}
+		this._tracer = new TraceListener(this);
+		this.addParseListener(this._tracer);
+	}
+};
+
+exports.Parser = Parser;
\ No newline at end of file
diff --git a/runtime/JavaScript/src/antlr4/ParserRuleContext.js b/runtime/JavaScript/src/antlr4/ParserRuleContext.js
new file mode 100644
index 000000000..800ed7af0
--- /dev/null
+++ b/runtime/JavaScript/src/antlr4/ParserRuleContext.js
@@ -0,0 +1,232 @@
+// [The "BSD license"]
+//  Copyright (c) 2012 Terence Parr
+//  Copyright (c) 2012 Sam Harwell
+//  Copyright (c) 2014 Eric Vergnaud
+//  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 rule invocation record for parsing.
+//
+//  Contains all of the information about the current rule not stored in the
+//  RuleContext. It handles parse tree children list, Any ATN state
+//  tracing, and the default values available for rule indications:
+//  start, stop, rule index, current alt number, current
+//  ATN state.
+//
+//  Subclasses made for each rule and grammar track the parameters,
+//  return values, locals, and labels specific to that rule. These
+//  are the objects that are returned from rules.
+//
+//  Note text is not an actual field of a rule return value; it is computed
+//  from start and stop using the input stream's toString() method.  I
+//  could add a ctor to this so that we can pass in and store the input
+//  stream, but I'm not sure we want to do that.  It would seem to be undefined
+//  to get the .text property anyway if the rule matches tokens from multiple
+//  input streams.
+//
+//  I do not use getters for fields of objects that are used simply to
+//  group values such as this aggregate.  The getters/setters are there to
+//  satisfy the superclass interface.
+
+var RuleContext = require('./RuleContext').RuleContext;
+var Tree = require('./tree/Tree');
+var INVALID_INTERVAL = Tree.INVALID_INTERVAL;
+var TerminalNode = Tree.TerminalNode;
+var TerminalNodeImpl = Tree.TerminalNodeImpl;
+var ErrorNodeImpl = Tree.ErrorNodeImpl;
+var Interval = require("./IntervalSet").Interval;
+
+function ParserRuleContext(parent, invokingStateNumber) {
+	parent = parent || null;
+	invokingStateNumber = invokingStateNumber || null;
+	RuleContext.call(this, parent, invokingStateNumber);
+	this.ruleIndex = -1;
+    // * If we are debugging or building a parse tree for a visitor,
+    // we need to track all of the tokens and rule invocations associated
+    // with this rule's context. This is empty for parsing w/o tree constr.
+    // operation because we don't the need to track the details about
+    // how we parse this rule.
+    // /
+    this.children = null;
+    this.start = null;
+    this.stop = null;
+    // The exception that forced this rule to return. If the rule successfully
+    // completed, this is {@code null}.
+    this.exception = null;
+}
+
+ParserRuleContext.prototype = Object.create(RuleContext.prototype);
+ParserRuleContext.prototype.constructor = ParserRuleContext;
+
+// * COPY a ctx (I'm deliberately not using copy constructor)///
+ParserRuleContext.prototype.copyFrom = function(ctx) {
+    // from RuleContext
+    this.parentCtx = ctx.parentCtx;
+    this.invokingState = ctx.invokingState;
+    this.children = null;
+    this.start = ctx.start;
+    this.stop = ctx.stop;
+};
+
+// Double dispatch methods for listeners
+ParserRuleContext.prototype.enterRule = function(listener) {
+};
+
+ParserRuleContext.prototype.exitRule = function(listener) {
+};
+
+// * Does not set parent link; other add methods do that///
+ParserRuleContext.prototype.addChild = function(child) {
+    if (this.children === null) {
+        this.children = [];
+    }
+    this.children.push(child);
+    return child;
+};
+
+// * Used by enterOuterAlt to toss out a RuleContext previously added as
+// we entered a rule. If we have // label, we will need to remove
+// generic ruleContext object.
+// /
+ParserRuleContext.prototype.removeLastChild = function() {
+    if (this.children !== null) {
+        this.children.pop();
+    }
+};
+
+ParserRuleContext.prototype.addTokenNode = function(token) {
+    var node = new TerminalNodeImpl(token);
+    this.addChild(node);
+    node.parentCtx = this;
+    return node;
+};
+
+ParserRuleContext.prototype.addErrorNode = function(badToken) {
+    var node = new ErrorNodeImpl(badToken);
+    this.addChild(node);
+    node.parentCtx = this;
+    return node;
+};
+
+ParserRuleContext.prototype.getChild = function(i, type) {
+	type = type || null;
+	if (type === null) {
+		return this.children.length>=i ? this.children[i] : null;
+	} else {
+		for(var j=0; j<this.children.length; j++) {
+			var child = this.children[j];
+			if(child instanceof type) {
+				if(i===0) {
+					return child;
+				} else {
+					i -= 1;
+				}
+			}
+		}
+		return null;
+    }
+};
+
+
+ParserRuleContext.prototype.getToken = function(ttype, i) {
+	for(var j=0; j<this.children.length; j++) {
+		var child = this.children[j];
+		if (child instanceof TerminalNode) {
+			if (child.symbol.type === ttype) {
+				if(i===0) {
+					return child;
+				} else {
+					i -= 1;
+				}
+			}
+        }
+	}
+    return null;
+};
+
+ParserRuleContext.prototype.getTokens = function(ttype ) {
+    if (this.children=== null) {
+        return [];
+    } else {
+		var tokens = [];
+		for(var j=0; j<this.children.length; j++) {
+			var child = this.children[j];
+			if (child instanceof TerminalNode) {
+				if (child.symbol.type === ttype) {
+					tokens.push(child);
+				}
+			}
+		}
+		return tokens;
+    }
+};
+
+ParserRuleContext.prototype.getTypedRuleContext = function(ctxType, i) {
+    return this.getChild(i, ctxType);
+};
+
+ParserRuleContext.prototype.getTypedRuleContexts = function(ctxType) {
+    if (this.children=== null) {
+        return [];
+    } else {
+		var contexts = [];
+		for(var j=0; j<this.children.length; j++) {
+			var child = this.children[j];
+			if (child instanceof ctxType) {
+				contexts.push(child);
+			}
+		}
+		return contexts;
+	}
+};
+
+ParserRuleContext.prototype.getChildCount = function() {
+	if (this.children=== null) {
+		return 0;
+	} else {
+		return this.children.length;
+	}
+};
+
+ParserRuleContext.prototype.getSourceInterval = function() {
+    if( this.start === null || this.stop === null) {
+        return INVALID_INTERVAL;
+    } else {
+        return new Interval(this.start.tokenIndex, this.stop.tokenIndex);
+    }
+};
+
+RuleContext.EMPTY = new ParserRuleContext();
+
+function InterpreterRuleContext(parent, invokingStateNumber, ruleIndex) {
+	ParserRuleContext.call(parent, invokingStateNumber);
+    this.ruleIndex = ruleIndex;
+    return this;
+}
+
+InterpreterRuleContext.prototype = Object.create(ParserRuleContext.prototype);
+InterpreterRuleContext.prototype.constructor = InterpreterRuleContext;
+
+exports.ParserRuleContext = ParserRuleContext;
\ No newline at end of file
diff --git a/runtime/JavaScript/src/antlr4/PredictionContext.js b/runtime/JavaScript/src/antlr4/PredictionContext.js
new file mode 100644
index 000000000..5114c12c4
--- /dev/null
+++ b/runtime/JavaScript/src/antlr4/PredictionContext.js
@@ -0,0 +1,750 @@
+//
+// [The "BSD license"]
+//  Copyright (c) 2012 Terence Parr
+//  Copyright (c) 2012 Sam Harwell
+//  Copyright (c) 2014 Eric Vergnaud
+//  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.
+///
+
+var RuleContext = require('./RuleContext').RuleContext;
+
+function PredictionContext(cachedHashString) {
+	this.cachedHashString = cachedHashString;
+}
+
+// Represents {@code $} in local context prediction, which means wildcard.
+// {@code//+x =//}.
+// /
+PredictionContext.EMPTY = null;
+
+// Represents {@code $} in an array in full context mode, when {@code $}
+// doesn't mean wildcard: {@code $ + x = [$,x]}. Here,
+// {@code $} = {@link //EMPTY_RETURN_STATE}.
+// /
+PredictionContext.EMPTY_RETURN_STATE = 0x7FFFFFFF;
+
+PredictionContext.globalNodeCount = 1;
+PredictionContext.id = PredictionContext.globalNodeCount;
+
+// Stores the computed hash code of this {@link PredictionContext}. The hash
+// code is computed in parts to match the following reference algorithm.
+//
+// <pre>
+// private int referenceHashCode() {
+// int hash = {@link MurmurHash//initialize MurmurHash.initialize}({@link
+// //INITIAL_HASH});
+//
+// for (int i = 0; i &lt; {@link //size()}; i++) {
+// hash = {@link MurmurHash//update MurmurHash.update}(hash, {@link //getParent
+// getParent}(i));
+// }
+//
+// for (int i = 0; i &lt; {@link //size()}; i++) {
+// hash = {@link MurmurHash//update MurmurHash.update}(hash, {@link
+// //getReturnState getReturnState}(i));
+// }
+//
+// hash = {@link MurmurHash//finish MurmurHash.finish}(hash, 2// {@link
+// //size()});
+// return hash;
+// }
+// </pre>
+// /
+
+// This means only the {@link //EMPTY} context is in set.
+PredictionContext.prototype.isEmpty = function() {
+	return this === PredictionContext.EMPTY;
+};
+
+PredictionContext.prototype.hasEmptyPath = function() {
+	return this.getReturnState(this.length - 1) === PredictionContext.EMPTY_RETURN_STATE;
+};
+
+PredictionContext.prototype.hashString = function() {
+	return this.cachedHashString;
+};
+
+function calculateHashString(parent, returnState) {
+	return "" + parent + returnState;
+}
+
+function calculateEmptyHashString() {
+	return "";
+}
+
+// Used to cache {@link PredictionContext} objects. Its used for the shared
+// context cash associated with contexts in DFA states. This cache
+// can be used for both lexers and parsers.
+
+function PredictionContextCache() {
+	this.cache = {};
+	return this;
+}
+
+// Add a context to the cache and return it. If the context already exists,
+// return that one instead and do not add a new context to the cache.
+// Protect shared cache from unsafe thread access.
+//
+PredictionContextCache.prototype.add = function(ctx) {
+	if (ctx === PredictionContext.EMPTY) {
+		return PredictionContext.EMPTY;
+	}
+	var existing = this.cache[ctx] || null;
+	if (existing !== null) {
+		return existing;
+	}
+	this.cache[ctx] = ctx;
+	return ctx;
+};
+
+PredictionContextCache.prototype.get = function(ctx) {
+	return this.cache[ctx] || null;
+};
+
+Object.defineProperty(PredictionContextCache.prototype, "length", {
+	get : function() {
+		return this.cache.length;
+	}
+});
+
+function SingletonPredictionContext(parent, returnState) {
+	var hashString = parent !== null ? calculateHashString(parent, returnState)
+			: calculateEmptyHashString();
+	PredictionContext.call(this, hashString);
+	this.parentCtx = parent;
+	this.returnState = returnState;
+}
+
+SingletonPredictionContext.prototype = Object.create(PredictionContext.prototype);
+SingletonPredictionContext.prototype.contructor = SingletonPredictionContext;
+
+SingletonPredictionContext.create = function(parent, returnState) {
+	if (returnState === PredictionContext.EMPTY_RETURN_STATE && parent === null) {
+		// someone can pass in the bits of an array ctx that mean $
+		return PredictionContext.EMPTY;
+	} else {
+		return new SingletonPredictionContext(parent, returnState);
+	}
+};
+
+Object.defineProperty(SingletonPredictionContext.prototype, "length", {
+	get : function() {
+		return 1;
+	}
+});
+
+SingletonPredictionContext.prototype.getParent = function(index) {
+	return this.parentCtx;
+};
+
+SingletonPredictionContext.prototype.getReturnState = function(index) {
+	return this.returnState;
+};
+
+SingletonPredictionContext.prototype.equals = function(other) {
+	if (this === other) {
+		return true;
+	} else if (!(other instanceof SingletonPredictionContext)) {
+		return false;
+	} else if (this.hashString() !== other.hashString()) {
+		return false; // can't be same if hash is different
+	} else {
+		if(this.returnState !== other.returnState)
+            return false;
+        else if(this.parentCtx==null)
+            return other.parentCtx==null
+		else
+            return this.parentCtx.equals(other.parentCtx);
+	}
+};
+
+SingletonPredictionContext.prototype.hashString = function() {
+	return this.cachedHashString;
+};
+
+SingletonPredictionContext.prototype.toString = function() {
+	var up = this.parentCtx === null ? "" : this.parentCtx.toString();
+	if (up.length === 0) {
+		if (this.returnState === this.EMPTY_RETURN_STATE) {
+			return "$";
+		} else {
+			return "" + this.returnState;
+		}
+	} else {
+		return "" + this.returnState + " " + up;
+	}
+};
+
+function EmptyPredictionContext() {
+	SingletonPredictionContext.call(this, null, PredictionContext.EMPTY_RETURN_STATE);
+	return this;
+}
+
+EmptyPredictionContext.prototype = Object.create(SingletonPredictionContext.prototype);
+EmptyPredictionContext.prototype.constructor = EmptyPredictionContext;
+
+EmptyPredictionContext.prototype.isEmpty = function() {
+	return true;
+};
+
+EmptyPredictionContext.prototype.getParent = function(index) {
+	return null;
+};
+
+EmptyPredictionContext.prototype.getReturnState = function(index) {
+	return this.returnState;
+};
+
+EmptyPredictionContext.prototype.equals = function(other) {
+	return this === other;
+};
+
+EmptyPredictionContext.prototype.toString = function() {
+	return "$";
+};
+
+PredictionContext.EMPTY = new EmptyPredictionContext();
+
+function ArrayPredictionContext(parents, returnStates) {
+	// Parent can be null only if full ctx mode and we make an array
+	// from {@link //EMPTY} and non-empty. We merge {@link //EMPTY} by using
+	// null parent and
+	// returnState == {@link //EMPTY_RETURN_STATE}.
+	var hash = calculateHashString(parents, returnStates);
+	PredictionContext.call(this, hash);
+	this.parents = parents;
+	this.returnStates = returnStates;
+	return this;
+}
+
+ArrayPredictionContext.prototype = Object.create(PredictionContext.prototype);
+ArrayPredictionContext.prototype.constructor = ArrayPredictionContext;
+
+ArrayPredictionContext.prototype.isEmpty = function() {
+	// since EMPTY_RETURN_STATE can only appear in the last position, we
+	// don't need to verify that size==1
+	return this.returnStates[0] === PredictionContext.EMPTY_RETURN_STATE;
+};
+
+Object.defineProperty(ArrayPredictionContext.prototype, "length", {
+	get : function() {
+		return this.returnStates.length;
+	}
+});
+
+ArrayPredictionContext.prototype.getParent = function(index) {
+	return this.parents[index];
+};
+
+ArrayPredictionContext.prototype.getReturnState = function(index) {
+	return this.returnStates[index];
+};
+
+ArrayPredictionContext.prototype.equals = function(other) {
+	if (this === other) {
+		return true;
+	} else if (!(other instanceof ArrayPredictionContext)) {
+		return false;
+	} else if (this.hashString !== other.hashString()) {
+		return false; // can't be same if hash is different
+	} else {
+		return this.returnStates === other.returnStates &&
+				this.parents === other.parents;
+	}
+};
+
+ArrayPredictionContext.prototype.toString = function() {
+	if (this.isEmpty()) {
+		return "[]";
+	} else {
+		var s = "[";
+		for (var i = 0; i < this.returnStates.length; i++) {
+			if (i > 0) {
+				s = s + ", ";
+			}
+			if (this.returnStates[i] === PredictionContext.EMPTY_RETURN_STATE) {
+				s = s + "$";
+				continue;
+			}
+			s = s + this.returnStates[i];
+			if (this.parents[i] !== null) {
+				s = s + " " + this.parents[i];
+			} else {
+				s = s + "null";
+			}
+		}
+		return s + "]";
+	}
+};
+
+// Convert a {@link RuleContext} tree to a {@link PredictionContext} graph.
+// Return {@link //EMPTY} if {@code outerContext} is empty or null.
+// /
+function predictionContextFromRuleContext(atn, outerContext) {
+	if (outerContext === undefined || outerContext === null) {
+		outerContext = RuleContext.EMPTY;
+	}
+	// if we are in RuleContext of start rule, s, then PredictionContext
+	// is EMPTY. Nobody called us. (if we are empty, return empty)
+	if (outerContext.parentCtx === null || outerContext === RuleContext.EMPTY) {
+		return PredictionContext.EMPTY;
+	}
+	// If we have a parent, convert it to a PredictionContext graph
+	var parent = predictionContextFromRuleContext(atn, outerContext.parentCtx);
+	var state = atn.states[outerContext.invokingState];
+	var transition = state.transitions[0];
+	return SingletonPredictionContext.create(parent, transition.followState.stateNumber);
+}
+
+function calculateListsHashString(parents, returnStates) {
+	var s = "";
+	parents.map(function(p) {
+		s = s + p;
+	});
+	returnStates.map(function(r) {
+		s = s + r;
+	});
+	return s;
+}
+
+function merge(a, b, rootIsWildcard, mergeCache) {
+	// share same graph if both same
+	if (a === b) {
+		return a;
+	}
+	if (a instanceof SingletonPredictionContext && b instanceof SingletonPredictionContext) {
+		return mergeSingletons(a, b, rootIsWildcard, mergeCache);
+	}
+	// At least one of a or b is array
+	// If one is $ and rootIsWildcard, return $ as// wildcard
+	if (rootIsWildcard) {
+		if (a instanceof EmptyPredictionContext) {
+			return a;
+		}
+		if (b instanceof EmptyPredictionContext) {
+			return b;
+		}
+	}
+	// convert singleton so both are arrays to normalize
+	if (a instanceof SingletonPredictionContext) {
+		a = new ArrayPredictionContext([a.getParent()], [a.returnState]);
+	}
+	if (b instanceof SingletonPredictionContext) {
+		b = new ArrayPredictionContext([b.getParent()], [b.returnState]);
+	}
+	return mergeArrays(a, b, rootIsWildcard, mergeCache);
+}
+
+//
+// Merge two {@link SingletonPredictionContext} instances.
+//
+// <p>Stack tops equal, parents merge is same; return left graph.<br>
+// <embed src="images/SingletonMerge_SameRootSamePar.svg"
+// type="image/svg+xml"/></p>
+//
+// <p>Same stack top, parents differ; merge parents giving array node, then
+// remainders of those graphs. A new root node is created to point to the
+// merged parents.<br>
+// <embed src="images/SingletonMerge_SameRootDiffPar.svg"
+// type="image/svg+xml"/></p>
+//
+// <p>Different stack tops pointing to same parent. Make array node for the
+// root where both element in the root point to the same (original)
+// parent.<br>
+// <embed src="images/SingletonMerge_DiffRootSamePar.svg"
+// type="image/svg+xml"/></p>
+//
+// <p>Different stack tops pointing to different parents. Make array node for
+// the root where each element points to the corresponding original
+// parent.<br>
+// <embed src="images/SingletonMerge_DiffRootDiffPar.svg"
+// type="image/svg+xml"/></p>
+//
+// @param a the first {@link SingletonPredictionContext}
+// @param b the second {@link SingletonPredictionContext}
+// @param rootIsWildcard {@code true} if this is a local-context merge,
+// otherwise false to indicate a full-context merge
+// @param mergeCache
+// /
+function mergeSingletons(a, b, rootIsWildcard, mergeCache) {
+	if (mergeCache !== null) {
+		var previous = mergeCache.get(a, b);
+		if (previous !== null) {
+			return previous;
+		}
+		previous = mergeCache.get(b, a);
+		if (previous !== null) {
+			return previous;
+		}
+	}
+
+	var rootMerge = mergeRoot(a, b, rootIsWildcard);
+	if (rootMerge !== null) {
+		if (mergeCache !== null) {
+			mergeCache.set(a, b, rootMerge);
+		}
+		return rootMerge;
+	}
+	if (a.returnState === b.returnState) {
+		var parent = merge(a.parentCtx, b.parentCtx, rootIsWildcard, mergeCache);
+		// if parent is same as existing a or b parent or reduced to a parent,
+		// return it
+		if (parent === a.parentCtx) {
+			return a; // ax + bx = ax, if a=b
+		}
+		if (parent === b.parentCtx) {
+			return b; // ax + bx = bx, if a=b
+		}
+		// else: ax + ay = a'[x,y]
+		// merge parents x and y, giving array node with x,y then remainders
+		// of those graphs. dup a, a' points at merged array
+		// new joined parent so create new singleton pointing to it, a'
+		var spc = SingletonPredictionContext.create(parent, a.returnState);
+		if (mergeCache !== null) {
+			mergeCache.set(a, b, spc);
+		}
+		return spc;
+	} else { // a != b payloads differ
+		// see if we can collapse parents due to $+x parents if local ctx
+		var singleParent = null;
+		if (a === b || (a.parentCtx !== null && a.parentCtx === b.parentCtx)) { // ax +
+																				// bx =
+																				// [a,b]x
+			singleParent = a.parentCtx;
+		}
+		if (singleParent !== null) { // parents are same
+			// sort payloads and use same parent
+			var payloads = [ a.returnState, b.returnState ];
+			if (a.returnState > b.returnState) {
+				payloads[0] = b.returnState;
+				payloads[1] = a.returnState;
+			}
+			var parents = [ singleParent, singleParent ];
+			var apc = new ArrayPredictionContext(parents, payloads);
+			if (mergeCache !== null) {
+				mergeCache.set(a, b, apc);
+			}
+			return apc;
+		}
+		// parents differ and can't merge them. Just pack together
+		// into array; can't merge.
+		// ax + by = [ax,by]
+		var payloads = [ a.returnState, b.returnState ];
+		var parents = [ a.parentCtx, b.parentCtx ];
+		if (a.returnState > b.returnState) { // sort by payload
+			payloads[0] = b.returnState;
+			payloads[1] = a.returnState;
+			parents = [ b.parentCtx, a.parentCtx ];
+		}
+		var a_ = new ArrayPredictionContext(parents, payloads);
+		if (mergeCache !== null) {
+			mergeCache.set(a, b, a_);
+		}
+		return a_;
+	}
+}
+
+//
+// Handle case where at least one of {@code a} or {@code b} is
+// {@link //EMPTY}. In the following diagrams, the symbol {@code $} is used
+// to represent {@link //EMPTY}.
+//
+// <h2>Local-Context Merges</h2>
+//
+// <p>These local-context merge operations are used when {@code rootIsWildcard}
+// is true.</p>
+//
+// <p>{@link //EMPTY} is superset of any graph; return {@link //EMPTY}.<br>
+// <embed src="images/LocalMerge_EmptyRoot.svg" type="image/svg+xml"/></p>
+//
+// <p>{@link //EMPTY} and anything is {@code //EMPTY}, so merged parent is
+// {@code //EMPTY}; return left graph.<br>
+// <embed src="images/LocalMerge_EmptyParent.svg" type="image/svg+xml"/></p>
+//
+// <p>Special case of last merge if local context.<br>
+// <embed src="images/LocalMerge_DiffRoots.svg" type="image/svg+xml"/></p>
+//
+// <h2>Full-Context Merges</h2>
+//
+// <p>These full-context merge operations are used when {@code rootIsWildcard}
+// is false.</p>
+//
+// <p><embed src="images/FullMerge_EmptyRoots.svg" type="image/svg+xml"/></p>
+//
+// <p>Must keep all contexts; {@link //EMPTY} in array is a special value (and
+// null parent).<br>
+// <embed src="images/FullMerge_EmptyRoot.svg" type="image/svg+xml"/></p>
+//
+// <p><embed src="images/FullMerge_SameRoot.svg" type="image/svg+xml"/></p>
+//
+// @param a the first {@link SingletonPredictionContext}
+// @param b the second {@link SingletonPredictionContext}
+// @param rootIsWildcard {@code true} if this is a local-context merge,
+// otherwise false to indicate a full-context merge
+// /
+function mergeRoot(a, b, rootIsWildcard) {
+	if (rootIsWildcard) {
+		if (a === PredictionContext.EMPTY) {
+			return PredictionContext.EMPTY; // // + b =//
+		}
+		if (b === PredictionContext.EMPTY) {
+			return PredictionContext.EMPTY; // a +// =//
+		}
+	} else {
+		if (a === PredictionContext.EMPTY && b === PredictionContext.EMPTY) {
+			return PredictionContext.EMPTY; // $ + $ = $
+		} else if (a === PredictionContext.EMPTY) { // $ + x = [$,x]
+			var payloads = [ b.returnState,
+					PredictionContext.EMPTY_RETURN_STATE ];
+			var parents = [ b.parentCtx, null ];
+			return new ArrayPredictionContext(parents, payloads);
+		} else if (b === PredictionContext.EMPTY) { // x + $ = [$,x] ($ is always first if present)
+			var payloads = [ a.returnState, PredictionContext.EMPTY_RETURN_STATE ];
+			var parents = [ a.parentCtx, null ];
+			return new ArrayPredictionContext(parents, payloads);
+		}
+	}
+	return null;
+}
+
+//
+// Merge two {@link ArrayPredictionContext} instances.
+//
+// <p>Different tops, different parents.<br>
+// <embed src="images/ArrayMerge_DiffTopDiffPar.svg" type="image/svg+xml"/></p>
+//
+// <p>Shared top, same parents.<br>
+// <embed src="images/ArrayMerge_ShareTopSamePar.svg" type="image/svg+xml"/></p>
+//
+// <p>Shared top, different parents.<br>
+// <embed src="images/ArrayMerge_ShareTopDiffPar.svg" type="image/svg+xml"/></p>
+//
+// <p>Shared top, all shared parents.<br>
+// <embed src="images/ArrayMerge_ShareTopSharePar.svg"
+// type="image/svg+xml"/></p>
+//
+// <p>Equal tops, merge parents and reduce top to
+// {@link SingletonPredictionContext}.<br>
+// <embed src="images/ArrayMerge_EqualTop.svg" type="image/svg+xml"/></p>
+// /
+function mergeArrays(a, b, rootIsWildcard, mergeCache) {
+	if (mergeCache !== null) {
+		var previous = mergeCache.get(a, b);
+		if (previous !== null) {
+			return previous;
+		}
+		previous = mergeCache.get(b, a);
+		if (previous !== null) {
+			return previous;
+		}
+	}
+	// merge sorted payloads a + b => M
+	var i = 0; // walks a
+	var j = 0; // walks b
+	var k = 0; // walks target M array
+
+	var mergedReturnStates = [];
+	var mergedParents = [];
+	// walk and merge to yield mergedParents, mergedReturnStates
+	while (i < a.returnStates.length && j < b.returnStates.length) {
+		var a_parent = a.parents[i];
+		var b_parent = b.parents[j];
+		if (a.returnStates[i] === b.returnStates[j]) {
+			// same payload (stack tops are equal), must yield merged singleton
+			var payload = a.returnStates[i];
+			// $+$ = $
+			var bothDollars = payload === PredictionContext.EMPTY_RETURN_STATE &&
+					a_parent === null && b_parent === null;
+			var ax_ax = (a_parent !== null && b_parent !== null && a_parent === b_parent); // ax+ax
+																							// ->
+																							// ax
+			if (bothDollars || ax_ax) {
+				mergedParents[k] = a_parent; // choose left
+				mergedReturnStates[k] = payload;
+			} else { // ax+ay -> a'[x,y]
+				var mergedParent = merge(a_parent, b_parent, rootIsWildcard, mergeCache);
+				mergedParents[k] = mergedParent;
+				mergedReturnStates[k] = payload;
+			}
+			i += 1; // hop over left one as usual
+			j += 1; // but also skip one in right side since we merge
+		} else if (a.returnStates[i] < b.returnStates[j]) { // copy a[i] to M
+			mergedParents[k] = a_parent;
+			mergedReturnStates[k] = a.returnStates[i];
+			i += 1;
+		} else { // b > a, copy b[j] to M
+			mergedParents[k] = b_parent;
+			mergedReturnStates[k] = b.returnStates[j];
+			j += 1;
+		}
+		k += 1;
+	}
+	// copy over any payloads remaining in either array
+	if (i < a.returnStates.length) {
+		for (var p = i; p < a.returnStates.length; p++) {
+			mergedParents[k] = a.parents[p];
+			mergedReturnStates[k] = a.returnStates[p];
+			k += 1;
+		}
+	} else {
+		for (var p = j; p < b.returnStates.length; p++) {
+			mergedParents[k] = b.parents[p];
+			mergedReturnStates[k] = b.returnStates[p];
+			k += 1;
+		}
+	}
+	// trim merged if we combined a few that had same stack tops
+	if (k < mergedParents.length) { // write index < last position; trim
+		if (k === 1) { // for just one merged element, return singleton top
+			var a_ = SingletonPredictionContext.create(mergedParents[0],
+					mergedReturnStates[0]);
+			if (mergeCache !== null) {
+				mergeCache.set(a, b, a_);
+			}
+			return a_;
+		}
+		mergedParents = mergedParents.slice(0, k);
+		mergedReturnStates = mergedReturnStates.slice(0, k);
+	}
+
+	var M = new ArrayPredictionContext(mergedParents, mergedReturnStates);
+
+	// if we created same array as a or b, return that instead
+	// TODO: track whether this is possible above during merge sort for speed
+	if (M === a) {
+		if (mergeCache !== null) {
+			mergeCache.set(a, b, a);
+		}
+		return a;
+	}
+	if (M === b) {
+		if (mergeCache !== null) {
+			mergeCache.set(a, b, b);
+		}
+		return b;
+	}
+	combineCommonParents(mergedParents);
+
+	if (mergeCache !== null) {
+		mergeCache.set(a, b, M);
+	}
+	return M;
+}
+
+//
+// Make pass over all <em>M</em> {@code parents}; merge any {@code equals()}
+// ones.
+// /
+function combineCommonParents(parents) {
+	var uniqueParents = {};
+
+	for (var p = 0; p < parents.length; p++) {
+		var parent = parents[p];
+		if (!(parent in uniqueParents)) {
+			uniqueParents[parent] = parent;
+		}
+	}
+	for (var q = 0; q < parents.length; q++) {
+		parents[q] = uniqueParents[parents[q]];
+	}
+}
+
+function getCachedPredictionContext(context, contextCache, visited) {
+	if (context.isEmpty()) {
+		return context;
+	}
+	var existing = visited[context] || null;
+	if (existing !== null) {
+		return existing;
+	}
+	existing = contextCache.get(context);
+	if (existing !== null) {
+		visited[context] = existing;
+		return existing;
+	}
+	var changed = false;
+	var parents = [];
+	for (var i = 0; i < parents.length; i++) {
+		var parent = getCachedPredictionContext(context.getParent(i), contextCache, visited);
+		if (changed || parent !== context.getParent(i)) {
+			if (!changed) {
+				parents = [];
+				for (var j = 0; j < context.length; j++) {
+					parents[j] = context.getParent(j);
+				}
+				changed = true;
+			}
+			parents[i] = parent;
+		}
+	}
+	if (!changed) {
+		contextCache.add(context);
+		visited[context] = context;
+		return context;
+	}
+	var updated = null;
+	if (parents.length === 0) {
+		updated = PredictionContext.EMPTY;
+	} else if (parents.length === 1) {
+		updated = SingletonPredictionContext.create(parents[0], context
+				.getReturnState(0));
+	} else {
+		updated = new ArrayPredictionContext(parents, context.returnStates);
+	}
+	contextCache.add(updated);
+	visited[updated] = updated;
+	visited[context] = updated;
+
+	return updated;
+}
+
+// ter's recursive version of Sam's getAllNodes()
+function getAllContextNodes(context, nodes, visited) {
+	if (nodes === null) {
+		nodes = [];
+		return getAllContextNodes(context, nodes, visited);
+	} else if (visited === null) {
+		visited = {};
+		return getAllContextNodes(context, nodes, visited);
+	} else {
+		if (context === null || visited[context] !== null) {
+			return nodes;
+		}
+		visited[context] = context;
+		nodes.push(context);
+		for (var i = 0; i < context.length; i++) {
+			getAllContextNodes(context.getParent(i), nodes, visited);
+		}
+		return nodes;
+	}
+}
+
+exports.merge = merge;
+exports.PredictionContext = PredictionContext;
+exports.PredictionContextCache = PredictionContextCache;
+exports.SingletonPredictionContext = SingletonPredictionContext;
+exports.predictionContextFromRuleContext = predictionContextFromRuleContext;
+exports.getCachedPredictionContext = getCachedPredictionContext;
diff --git a/runtime/JavaScript/src/antlr4/README.md b/runtime/JavaScript/src/antlr4/README.md
new file mode 100644
index 000000000..9ff7e5cfc
--- /dev/null
+++ b/runtime/JavaScript/src/antlr4/README.md
@@ -0,0 +1,13 @@
+# JavaScript target for ANTLR 4
+
+JavaScript runtime libraries for ANTLR 4
+
+This runtime is available through npm. The package name is 'antlr4'.
+
+This runtime has been tested in Node.js, Safari, Firefox, Chrome and IE.
+
+See www.antlr.org for more information on ANTLR
+
+See https://theantlrguy.atlassian.net/wiki/display/ANTLR4/JavaScript+Target for more information on using ANTLR in JavaScript
+
+
diff --git a/runtime/JavaScript/src/antlr4/Recognizer.js b/runtime/JavaScript/src/antlr4/Recognizer.js
new file mode 100644
index 000000000..96a8e0729
--- /dev/null
+++ b/runtime/JavaScript/src/antlr4/Recognizer.js
@@ -0,0 +1,171 @@
+//
+// [The "BSD license"]
+//  Copyright (c) 2012 Terence Parr
+//  Copyright (c) 2012 Sam Harwell
+//  Copyright (c) 2014 Eric Vergnaud
+//  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.
+//
+
+var Token = require('./Token').Token;
+var ConsoleErrorListener = require('./error/ErrorListener').ConsoleErrorListener;
+var ProxyErrorListener = require('./error/ErrorListener').ProxyErrorListener;
+
+function Recognizer() {
+    this._listeners = [ ConsoleErrorListener.INSTANCE ];
+    this._interp = null;
+    this._stateNumber = -1;
+    return this;
+}
+
+Recognizer.tokenTypeMapCache = {};
+Recognizer.ruleIndexMapCache = {};
+
+
+Recognizer.prototype.checkVersion = function(toolVersion) {
+    var runtimeVersion = "4.5.3";
+    if (runtimeVersion!==toolVersion) {
+        console.log("ANTLR runtime and generated code versions disagree: "+runtimeVersion+"!="+toolVersion);
+    }
+};
+
+Recognizer.prototype.addErrorListener = function(listener) {
+    this._listeners.push(listener);
+};
+
+Recognizer.prototype.removeErrorListeners = function() {
+    this._listeners = [];
+};
+
+Recognizer.prototype.getTokenTypeMap = function() {
+    var tokenNames = this.getTokenNames();
+    if (tokenNames===null) {
+        throw("The current recognizer does not provide a list of token names.");
+    }
+    var result = this.tokenTypeMapCache[tokenNames];
+    if(result===undefined) {
+        result = tokenNames.reduce(function(o, k, i) { o[k] = i; });
+        result.EOF = Token.EOF;
+        this.tokenTypeMapCache[tokenNames] = result;
+    }
+    return result;
+};
+
+// Get a map from rule names to rule indexes.
+//
+// <p>Used for XPath and tree pattern compilation.</p>
+//
+Recognizer.prototype.getRuleIndexMap = function() {
+    var ruleNames = this.getRuleNames();
+    if (ruleNames===null) {
+        throw("The current recognizer does not provide a list of rule names.");
+    }
+    var result = this.ruleIndexMapCache[ruleNames];
+    if(result===undefined) {
+        result = ruleNames.reduce(function(o, k, i) { o[k] = i; });
+        this.ruleIndexMapCache[ruleNames] = result;
+    }
+    return result;
+};
+
+Recognizer.prototype.getTokenType = function(tokenName) {
+    var ttype = this.getTokenTypeMap()[tokenName];
+    if (ttype !==undefined) {
+        return ttype;
+    } else {
+        return Token.INVALID_TYPE;
+    }
+};
+
+
+// What is the error header, normally line/character position information?//
+Recognizer.prototype.getErrorHeader = function(e) {
+    var line = e.getOffendingToken().line;
+    var column = e.getOffendingToken().column;
+    return "line " + line + ":" + column;
+};
+
+
+// How should a token be displayed in an error message? The default
+//  is to display just the text, but during development you might
+//  want to have a lot of information spit out.  Override in that case
+//  to use t.toString() (which, for CommonToken, dumps everything about
+//  the token). This is better than forcing you to override a method in
+//  your token objects because you don't have to go modify your lexer
+//  so that it creates a new Java type.
+//
+// @deprecated This method is not called by the ANTLR 4 Runtime. Specific
+// implementations of {@link ANTLRErrorStrategy} may provide a similar
+// feature when necessary. For example, see
+// {@link DefaultErrorStrategy//getTokenErrorDisplay}.
+//
+Recognizer.prototype.getTokenErrorDisplay = function(t) {
+    if (t===null) {
+        return "<no token>";
+    }
+    var s = t.text;
+    if (s===null) {
+        if (t.type===Token.EOF) {
+            s = "<EOF>";
+        } else {
+            s = "<" + t.type + ">";
+        }
+    }
+    s = s.replace("\n","\\n").replace("\r","\\r").replace("\t","\\t");
+    return "'" + s + "'";
+};
+
+Recognizer.prototype.getErrorListenerDispatch = function() {
+    return new ProxyErrorListener(this._listeners);
+};
+
+// subclass needs to override these if there are sempreds or actions
+// that the ATN interp needs to execute
+Recognizer.prototype.sempred = function(localctx, ruleIndex, actionIndex) {
+    return true;
+};
+
+Recognizer.prototype.precpred = function(localctx , precedence) {
+    return true;
+};
+
+//Indicate that the recognizer has changed internal state that is
+//consistent with the ATN state passed in.  This way we always know
+//where we are in the ATN as the parser goes along. The rule
+//context objects form a stack that lets us see the stack of
+//invoking rules. Combine this and we have complete ATN
+//configuration information.
+
+Object.defineProperty(Recognizer.prototype, "state", {
+	get : function() {
+		return this._stateNumber;
+	},
+	set : function(state) {
+		this._stateNumber = state;
+	}
+});
+
+
+exports.Recognizer = Recognizer;
diff --git a/runtime/JavaScript/src/antlr4/RuleContext.js b/runtime/JavaScript/src/antlr4/RuleContext.js
new file mode 100644
index 000000000..c3631bab6
--- /dev/null
+++ b/runtime/JavaScript/src/antlr4/RuleContext.js
@@ -0,0 +1,181 @@
+// [The "BSD license"]
+//  Copyright (c) 2013 Terence Parr
+//  Copyright (c) 2013 Sam Harwell
+//  Copyright (c) 2014 Eric Vergnaud
+//  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 rule context is a record of a single rule invocation. It knows
+//  which context invoked it, if any. If there is no parent context, then
+//  naturally the invoking state is not valid.  The parent link
+//  provides a chain upwards from the current rule invocation to the root
+//  of the invocation tree, forming a stack. We actually carry no
+//  information about the rule associated with this context (except
+//  when parsing). We keep only the state number of the invoking state from
+//  the ATN submachine that invoked this. Contrast this with the s
+//  pointer inside ParserRuleContext that tracks the current state
+//  being "executed" for the current rule.
+//
+//  The parent contexts are useful for computing lookahead sets and
+//  getting error information.
+//
+//  These objects are used during parsing and prediction.
+//  For the special case of parsers, we use the subclass
+//  ParserRuleContext.
+//
+//  @see ParserRuleContext
+///
+
+var RuleNode = require('./tree/Tree').RuleNode;
+var INVALID_INTERVAL = require('./tree/Tree').INVALID_INTERVAL;
+var INVALID_ALT_NUMBER = require('./atn/ATN').INVALID_ALT_NUMBER;
+
+function RuleContext(parent, invokingState) {
+	RuleNode.call(this);
+	// What context invoked this rule?
+	this.parentCtx = parent || null;
+	// What state invoked the rule associated with this context?
+	// The "return address" is the followState of invokingState
+	// If parent is null, this should be -1.
+	this.invokingState = invokingState || -1;
+	return this;
+}
+
+RuleContext.prototype = Object.create(RuleNode.prototype);
+RuleContext.prototype.constructor = RuleContext;
+
+RuleContext.prototype.depth = function() {
+	var n = 0;
+	var p = this;
+	while (p !== null) {
+		p = p.parentCtx;
+		n += 1;
+	}
+	return n;
+};
+
+// A context is empty if there is no invoking state; meaning nobody call
+// current context.
+RuleContext.prototype.isEmpty = function() {
+	return this.invokingState === -1;
+};
+
+// satisfy the ParseTree / SyntaxTree interface
+
+RuleContext.prototype.getSourceInterval = function() {
+	return INVALID_INTERVAL;
+};
+
+RuleContext.prototype.getRuleContext = function() {
+	return this;
+};
+
+RuleContext.prototype.getPayload = function() {
+	return this;
+};
+
+// Return the combined text of all child nodes. This method only considers
+// tokens which have been added to the parse tree.
+// <p>
+// Since tokens on hidden channels (e.g. whitespace or comments) are not
+// added to the parse trees, they will not appear in the output of this
+// method.
+// /
+RuleContext.prototype.getText = function() {
+	if (this.getChildCount() === 0) {
+		return "";
+	} else {
+		return this.children.map(function(child) {
+			return child.getText();
+		}).join("");
+	}
+};
+
+// For rule associated with this parse tree internal node, return
+// the outer alternative number used to match the input. Default
+// implementation does not compute nor store this alt num. Create
+// a subclass of ParserRuleContext with backing field and set
+// option contextSuperClass.
+// to set it.
+RuleContext.prototype.getAltNumber = function() { return INVALID_ALT_NUMBER; }
+
+// Set the outer alternative number for this context node. Default
+// implementation does nothing to avoid backing field overhead for
+// trees that don't need it.  Create
+// a subclass of ParserRuleContext with backing field and set
+// option contextSuperClass.
+RuleContext.prototype.setAltNumber = function(altNumber) { }
+
+RuleContext.prototype.getChild = function(i) {
+	return null;
+};
+
+RuleContext.prototype.getChildCount = function() {
+	return 0;
+};
+
+RuleContext.prototype.accept = function(visitor) {
+	return visitor.visitChildren(this);
+};
+
+//need to manage circular dependencies, so export now
+exports.RuleContext = RuleContext;
+var Trees = require('./tree/Trees').Trees;
+
+
+// Print out a whole tree, not just a node, in LISP format
+// (root child1 .. childN). Print just a node if this is a leaf.
+//
+
+RuleContext.prototype.toStringTree = function(ruleNames, recog) {
+	return Trees.toStringTree(this, ruleNames, recog);
+};
+
+RuleContext.prototype.toString = function(ruleNames, stop) {
+	ruleNames = ruleNames || null;
+	stop = stop || null;
+	var p = this;
+	var s = "[";
+	while (p !== null && p !== stop) {
+		if (ruleNames === null) {
+			if (!p.isEmpty()) {
+				s += p.invokingState;
+			}
+		} else {
+			var ri = p.ruleIndex;
+			var ruleName = (ri >= 0 && ri < ruleNames.length) ? ruleNames[ri]
+					: "" + ri;
+			s += ruleName;
+		}
+		if (p.parentCtx !== null && (ruleNames !== null || !p.parentCtx.isEmpty())) {
+			s += " ";
+		}
+		p = p.parentCtx;
+	}
+	s += "]";
+	return s;
+};
+
diff --git a/runtime/JavaScript/src/antlr4/Token.js b/runtime/JavaScript/src/antlr4/Token.js
new file mode 100644
index 000000000..c2c554551
--- /dev/null
+++ b/runtime/JavaScript/src/antlr4/Token.js
@@ -0,0 +1,175 @@
+//[The "BSD license"]
+// Copyright (c) 2012 Terence Parr
+// Copyright (c) 2012 Sam Harwell
+// Copyright (c) 2014 Eric Vergnaud
+// 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 token has properties: text, type, line, character position in the line
+// (so we can ignore tabs), token channel, index, and source from which
+// we obtained this token.
+
+function Token() {
+	this.source = null;
+	this.type = null; // token type of the token
+	this.channel = null; // The parser ignores everything not on DEFAULT_CHANNEL
+	this.start = null; // optional; return -1 if not implemented.
+	this.stop = null; // optional; return -1 if not implemented.
+	this.tokenIndex = null; // from 0..n-1 of the token object in the input stream
+	this.line = null; // line=1..n of the 1st character
+	this.column = null; // beginning of the line at which it occurs, 0..n-1
+	this._text = null; // text of the token.
+	return this;
+}
+
+Token.INVALID_TYPE = 0;
+
+// During lookahead operations, this "token" signifies we hit rule end ATN state
+// and did not follow it despite needing to.
+Token.EPSILON = -2;
+
+Token.MIN_USER_TOKEN_TYPE = 1;
+
+Token.EOF = -1;
+
+// All tokens go to the parser (unless skip() is called in that rule)
+// on a particular "channel". The parser tunes to a particular channel
+// so that whitespace etc... can go to the parser on a "hidden" channel.
+
+Token.DEFAULT_CHANNEL = 0;
+
+// Anything on different channel than DEFAULT_CHANNEL is not parsed
+// by parser.
+
+Token.HIDDEN_CHANNEL = 1;
+
+// Explicitly set the text for this token. If {code text} is not
+// {@code null}, then {@link //getText} will return this value rather than
+// extracting the text from the input.
+//
+// @param text The explicit text of the token, or {@code null} if the text
+// should be obtained from the input along with the start and stop indexes
+// of the token.
+
+Object.defineProperty(Token.prototype, "text", {
+	get : function() {
+		return this._text;
+	},
+	set : function(text) {
+		this._text = text;
+	}
+});
+
+Token.prototype.getTokenSource = function() {
+	return this.source[0];
+};
+
+Token.prototype.getInputStream = function() {
+	return this.source[1];
+};
+
+function CommonToken(source, type, channel, start, stop) {
+	Token.call(this);
+	this.source = source !== undefined ? source : CommonToken.EMPTY_SOURCE;
+	this.type = type !== undefined ? type : null;
+	this.channel = channel !== undefined ? channel : Token.DEFAULT_CHANNEL;
+	this.start = start !== undefined ? start : -1;
+	this.stop = stop !== undefined ? stop : -1;
+	this.tokenIndex = -1;
+	if (this.source[0] !== null) {
+		this.line = source[0].line;
+		this.column = source[0].column;
+	} else {
+		this.column = -1;
+	}
+	return this;
+}
+
+CommonToken.prototype = Object.create(Token.prototype);
+CommonToken.prototype.constructor = CommonToken;
+
+// An empty {@link Pair} which is used as the default value of
+// {@link //source} for tokens that do not have a source.
+CommonToken.EMPTY_SOURCE = [ null, null ];
+
+// Constructs a new {@link CommonToken} as a copy of another {@link Token}.
+//
+// <p>
+// If {@code oldToken} is also a {@link CommonToken} instance, the newly
+// constructed token will share a reference to the {@link //text} field and
+// the {@link Pair} stored in {@link //source}. Otherwise, {@link //text} will
+// be assigned the result of calling {@link //getText}, and {@link //source}
+// will be constructed from the result of {@link Token//getTokenSource} and
+// {@link Token//getInputStream}.</p>
+//
+// @param oldToken The token to copy.
+//
+CommonToken.prototype.clone = function() {
+	var t = new CommonToken(this.source, this.type, this.channel, this.start,
+			this.stop);
+	t.tokenIndex = this.tokenIndex;
+	t.line = this.line;
+	t.column = this.column;
+	t.text = this.text;
+	return t;
+};
+
+Object.defineProperty(CommonToken.prototype, "text", {
+	get : function() {
+		if (this._text !== null) {
+			return this._text;
+		}
+		var input = this.getInputStream();
+		if (input === null) {
+			return null;
+		}
+		var n = input.size;
+		if (this.start < n && this.stop < n) {
+			return input.getText(this.start, this.stop);
+		} else {
+			return "<EOF>";
+		}
+	},
+	set : function(text) {
+		this._text = text;
+	}
+});
+
+CommonToken.prototype.toString = function() {
+	var txt = this.text;
+	if (txt !== null) {
+		txt = txt.replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+	} else {
+		txt = "<no text>";
+	}
+	return "[@" + this.tokenIndex + "," + this.start + ":" + this.stop + "='" +
+			txt + "',<" + this.type + ">" +
+			(this.channel > 0 ? ",channel=" + this.channel : "") + "," +
+			this.line + ":" + this.column + "]";
+};
+
+exports.Token = Token;
+exports.CommonToken = CommonToken;
diff --git a/runtime/JavaScript/src/antlr4/Utils.js b/runtime/JavaScript/src/antlr4/Utils.js
new file mode 100644
index 000000000..b47e75872
--- /dev/null
+++ b/runtime/JavaScript/src/antlr4/Utils.js
@@ -0,0 +1,207 @@
+function arrayToString(a) {
+	return "[" + a.join(", ") + "]";
+}
+
+String.prototype.hashCode = function(s) {
+	var hash = 0;
+	if (this.length === 0) {
+		return hash;
+	}
+	for (var i = 0; i < this.length; i++) {
+		var character = this.charCodeAt(i);
+		hash = ((hash << 5) - hash) + character;
+		hash = hash & hash; // Convert to 32bit integer
+	}
+	return hash;
+};
+
+function standardEqualsFunction(a,b) {
+	return a.equals(b);
+}
+
+function standardHashFunction(a) {
+	return a.hashString();
+}
+
+function Set(hashFunction, equalsFunction) {
+	this.data = {};
+	this.hashFunction = hashFunction || standardHashFunction;
+	this.equalsFunction = equalsFunction || standardEqualsFunction;
+	return this;
+}
+
+Object.defineProperty(Set.prototype, "length", {
+	get : function() {
+		return this.values().length;
+	}
+});
+
+Set.prototype.add = function(value) {
+	var hash = this.hashFunction(value);
+	var key = "hash_" + hash.hashCode();
+	if(key in this.data) {
+		var i;
+		var values = this.data[key];
+		for(i=0;i<values.length; i++) {
+			if(this.equalsFunction(value, values[i])) {
+				return values[i];
+			}
+		}
+		values.push(value);
+		return value;
+	} else {
+		this.data[key] = [ value ];
+		return value;
+	}
+};
+
+Set.prototype.contains = function(value) {
+	var hash = this.hashFunction(value);
+	var key = hash.hashCode();
+	if(key in this.data) {
+		var i;
+		var values = this.data[key];
+		for(i=0;i<values.length; i++) {
+			if(this.equalsFunction(value, values[i])) {
+				return true;
+			}
+		}
+	}
+	return false;
+};
+
+Set.prototype.values = function() {
+	var l = [];
+	for(var key in this.data) {
+		if(key.indexOf("hash_")===0) {
+			l = l.concat(this.data[key]);
+		}
+	}
+	return l;
+};
+
+Set.prototype.toString = function() {
+	return arrayToString(this.values());
+};
+
+function BitSet() {
+	this.data = [];
+	return this;
+}
+
+BitSet.prototype.add = function(value) {
+	this.data[value] = true;
+};
+
+BitSet.prototype.or = function(set) {
+	var bits = this;
+	Object.keys(set.data).map( function(alt) { bits.add(alt); });
+};
+
+BitSet.prototype.remove = function(value) {
+	delete this.data[value];
+};
+
+BitSet.prototype.contains = function(value) {
+	return this.data[value] === true;
+};
+
+BitSet.prototype.values = function() {
+	return Object.keys(this.data);
+};
+
+BitSet.prototype.minValue = function() {
+	return Math.min.apply(null, this.values());
+};
+
+BitSet.prototype.hashString = function() {
+	return this.values().toString();
+};
+
+BitSet.prototype.equals = function(other) {
+	if(!(other instanceof BitSet)) {
+		return false;
+	}
+	return this.hashString()===other.hashString();
+};
+
+Object.defineProperty(BitSet.prototype, "length", {
+	get : function() {
+		return this.values().length;
+	}
+});
+
+BitSet.prototype.toString = function() {
+	return "{" + this.values().join(", ") + "}";
+};
+
+function AltDict() {
+	this.data = {};
+	return this;
+}
+
+AltDict.prototype.get = function(key) {
+	key = "k-" + key;
+	if(key in this.data){
+		return this.data[key];
+	} else {
+		return null;
+	}
+};
+
+AltDict.prototype.put = function(key, value) {
+	key = "k-" + key;
+	this.data[key] = value;
+};
+
+AltDict.prototype.values = function() {
+	var data = this.data;
+	var keys = Object.keys(this.data);
+	return keys.map(function(key) {
+		return data[key];
+	});
+};
+
+function DoubleDict() {
+	return this;
+}
+
+DoubleDict.prototype.get = function(a, b) {
+	var d = this[a] || null;
+	return d===null ? null : (d[b] || null);
+};
+
+DoubleDict.prototype.set = function(a, b, o) {
+	var d = this[a] || null;
+	if(d===null) {
+		d = {};
+		this[a] = d;
+	}
+	d[b] = o;
+};
+
+
+function escapeWhitespace(s, escapeSpaces) {
+	s = s.replace("\t","\\t");
+	s = s.replace("\n","\\n");
+	s = s.replace("\r","\\r");
+	if(escapeSpaces) {
+		s = s.replace(" ","\u00B7");
+	}
+	return s;
+}
+
+exports.isArray = function (entity) {
+	return Object.prototype.toString.call( entity ) === '[object Array]'
+};
+
+exports.titleCase = function(str) {
+	return str.replace(/\w\S*/g, function(txt){return txt.charAt(0).toUpperCase() + txt.substr(1);});
+};
+
+exports.Set = Set;
+exports.BitSet = BitSet;
+exports.AltDict = AltDict;
+exports.DoubleDict = DoubleDict;
+exports.escapeWhitespace = escapeWhitespace;
+exports.arrayToString = arrayToString;
diff --git a/runtime/JavaScript/src/antlr4/atn/ATN.js b/runtime/JavaScript/src/antlr4/atn/ATN.js
new file mode 100644
index 000000000..899ae869a
--- /dev/null
+++ b/runtime/JavaScript/src/antlr4/atn/ATN.js
@@ -0,0 +1,166 @@
+// [The "BSD license"]
+//  Copyright (c) 2013 Terence Parr
+//  Copyright (c) 2013 Sam Harwell
+//  Copyright (c) 2014 Eric Vergnaud
+//  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.
+
+var LL1Analyzer = require('./../LL1Analyzer').LL1Analyzer;
+var IntervalSet = require('./../IntervalSet').IntervalSet;
+
+function ATN(grammarType , maxTokenType) {
+
+    // Used for runtime deserialization of ATNs from strings///
+    // The type of the ATN.
+    this.grammarType = grammarType;
+    // The maximum value for any symbol recognized by a transition in the ATN.
+    this.maxTokenType = maxTokenType;
+    this.states = [];
+    // Each subrule/rule is a decision point and we must track them so we
+    //  can go back later and build DFA predictors for them.  This includes
+    //  all the rules, subrules, optional blocks, ()+, ()* etc...
+    this.decisionToState = [];
+    // Maps from rule index to starting state number.
+    this.ruleToStartState = [];
+    // Maps from rule index to stop state number.
+    this.ruleToStopState = null;
+    this.modeNameToStartState = {};
+    // For lexer ATNs, this maps the rule index to the resulting token type.
+    // For parser ATNs, this maps the rule index to the generated bypass token
+    // type if the
+    // {@link ATNDeserializationOptions//isGenerateRuleBypassTransitions}
+    // deserialization option was specified; otherwise, this is {@code null}.
+    this.ruleToTokenType = null;
+    // For lexer ATNs, this is an array of {@link LexerAction} objects which may
+    // be referenced by action transitions in the ATN.
+    this.lexerActions = null;
+    this.modeToStartState = [];
+
+    return this;
+}
+	
+// Compute the set of valid tokens that can occur starting in state {@code s}.
+//  If {@code ctx} is null, the set of tokens will not include what can follow
+//  the rule surrounding {@code s}. In other words, the set will be
+//  restricted to tokens reachable staying within {@code s}'s rule.
+ATN.prototype.nextTokensInContext = function(s, ctx) {
+    var anal = new LL1Analyzer(this);
+    return anal.LOOK(s, null, ctx);
+};
+
+// Compute the set of valid tokens that can occur starting in {@code s} and
+// staying in same rule. {@link Token//EPSILON} is in set if we reach end of
+// rule.
+ATN.prototype.nextTokensNoContext = function(s) {
+    if (s.nextTokenWithinRule !== null ) {
+        return s.nextTokenWithinRule;
+    }
+    s.nextTokenWithinRule = this.nextTokensInContext(s, null);
+    s.nextTokenWithinRule.readOnly = true;
+    return s.nextTokenWithinRule;
+};
+
+ATN.prototype.nextTokens = function(s, ctx) {
+    if ( ctx===undefined ) {
+        return this.nextTokensNoContext(s);
+    } else {
+        return this.nextTokensInContext(s, ctx);
+    }
+};
+
+ATN.prototype.addState = function( state) {
+    if ( state !== null ) {
+        state.atn = this;
+        state.stateNumber = this.states.length;
+    }
+    this.states.push(state);
+};
+
+ATN.prototype.removeState = function( state) {
+    this.states[state.stateNumber] = null; // just free mem, don't shift states in list
+};
+
+ATN.prototype.defineDecisionState = function( s) {
+    this.decisionToState.push(s);
+    s.decision = this.decisionToState.length-1;
+    return s.decision;
+};
+
+ATN.prototype.getDecisionState = function( decision) {
+    if (this.decisionToState.length===0) {
+        return null;
+    } else {
+        return this.decisionToState[decision];
+    }
+};
+
+// Computes the set of input symbols which could follow ATN state number
+// {@code stateNumber} in the specified full {@code context}. This method
+// considers the complete parser context, but does not evaluate semantic
+// predicates (i.e. all predicates encountered during the calculation are
+// assumed true). If a path in the ATN exists from the starting state to the
+// {@link RuleStopState} of the outermost context without matching any
+// symbols, {@link Token//EOF} is added to the returned set.
+//
+// <p>If {@code context} is {@code null}, it is treated as
+// {@link ParserRuleContext//EMPTY}.</p>
+//
+// @param stateNumber the ATN state number
+// @param context the full parse context
+// @return The set of potentially valid input symbols which could follow the
+// specified state in the specified context.
+// @throws IllegalArgumentException if the ATN does not contain a state with
+// number {@code stateNumber}
+var Token = require('./../Token').Token;
+
+ATN.prototype.getExpectedTokens = function( stateNumber, ctx ) {
+    if ( stateNumber < 0 || stateNumber >= this.states.length ) {
+        throw("Invalid state number.");
+    }
+    var s = this.states[stateNumber];
+    var following = this.nextTokens(s);
+    if (!following.contains(Token.EPSILON)) {
+        return following;
+    }
+    var expected = new IntervalSet();
+    expected.addSet(following);
+    expected.removeOne(Token.EPSILON);
+    while (ctx !== null && ctx.invokingState >= 0 && following.contains(Token.EPSILON)) {
+        var invokingState = this.states[ctx.invokingState];
+        var rt = invokingState.transitions[0];
+        following = this.nextTokens(rt.followState);
+        expected.addSet(following);
+        expected.removeOne(Token.EPSILON);
+        ctx = ctx.parentCtx;
+    }
+    if (following.contains(Token.EPSILON)) {
+        expected.addOne(Token.EOF);
+    }
+    return expected;
+};
+
+ATN.INVALID_ALT_NUMBER = 0;
+
+exports.ATN = ATN;
\ No newline at end of file
diff --git a/runtime/JavaScript/src/antlr4/atn/ATNConfig.js b/runtime/JavaScript/src/antlr4/atn/ATNConfig.js
new file mode 100644
index 000000000..988729dc7
--- /dev/null
+++ b/runtime/JavaScript/src/antlr4/atn/ATNConfig.js
@@ -0,0 +1,180 @@
+//
+// [The "BSD license"]
+//  Copyright (c) 2012 Terence Parr
+//  Copyright (c) 2012 Sam Harwell
+//  Copyright (c) 2014 Eric Vergnaud
+//  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 tuple: (ATN state, predicted alt, syntactic, semantic context).
+//  The syntactic context is a graph-structured stack node whose
+//  path(s) to the root is the rule invocation(s)
+//  chain used to arrive at the state.  The semantic context is
+//  the tree of semantic predicates encountered before reaching
+//  an ATN state.
+///
+
+var DecisionState = require('./ATNState').DecisionState;
+var SemanticContext = require('./SemanticContext').SemanticContext;
+
+function checkParams(params, isCfg) {
+	if(params===null) {
+		var result = { state:null, alt:null, context:null, semanticContext:null };
+		if(isCfg) {
+			result.reachesIntoOuterContext = 0;
+		}
+		return result;
+	} else {
+		var props = {};
+		props.state = params.state || null;
+		props.alt = (params.alt === undefined) ? null : params.alt;
+		props.context = params.context || null;
+		props.semanticContext = params.semanticContext || null;
+		if(isCfg) {
+			props.reachesIntoOuterContext = params.reachesIntoOuterContext || 0;
+			props.precedenceFilterSuppressed = params.precedenceFilterSuppressed || false;
+		}
+		return props;
+	}
+}
+
+function ATNConfig(params, config) {
+	this.checkContext(params, config);
+	params = checkParams(params);
+	config = checkParams(config, true);
+    // The ATN state associated with this configuration///
+    this.state = params.state!==null ? params.state : config.state;
+    // What alt (or lexer rule) is predicted by this configuration///
+    this.alt = params.alt!==null ? params.alt : config.alt;
+    // The stack of invoking states leading to the rule/states associated
+    //  with this config.  We track only those contexts pushed during
+    //  execution of the ATN simulator.
+    this.context = params.context!==null ? params.context : config.context;
+    this.semanticContext = params.semanticContext!==null ? params.semanticContext :
+        (config.semanticContext!==null ? config.semanticContext : SemanticContext.NONE);
+    // We cannot execute predicates dependent upon local context unless
+    // we know for sure we are in the correct context. Because there is
+    // no way to do this efficiently, we simply cannot evaluate
+    // dependent predicates unless we are in the rule that initially
+    // invokes the ATN simulator.
+    //
+    // closure() tracks the depth of how far we dip into the
+    // outer context: depth &gt; 0.  Note that it may not be totally
+    // accurate depth since I don't ever decrement. TODO: make it a boolean then
+    this.reachesIntoOuterContext = config.reachesIntoOuterContext;
+    this.precedenceFilterSuppressed = config.precedenceFilterSuppressed;
+    return this;
+}
+
+ATNConfig.prototype.checkContext = function(params, config) {
+	if((params.context===null || params.context===undefined) &&
+			(config===null || config.context===null || config.context===undefined)) {
+		this.context = null;
+	}
+};
+
+// An ATN configuration is equal to another if both have
+//  the same state, they predict the same alternative, and
+//  syntactic/semantic contexts are the same.
+///
+ATNConfig.prototype.equals = function(other) {
+    if (this === other) {
+        return true;
+    } else if (! (other instanceof ATNConfig)) {
+        return false;
+    } else {
+        return this.state.stateNumber===other.state.stateNumber &&
+            this.alt===other.alt &&
+            (this.context===null ? other.context===null : this.context.equals(other.context)) &&
+            this.semanticContext.equals(other.semanticContext) &&
+            this.precedenceFilterSuppressed===other.precedenceFilterSuppressed;
+    }
+};
+
+ATNConfig.prototype.shortHashString = function() {
+    return "" + this.state.stateNumber + "/" + this.alt + "/" + this.semanticContext;
+};
+
+ATNConfig.prototype.hashString = function() {
+    return "" + this.state.stateNumber + "/" + this.alt + "/" +
+             (this.context===null ? "" : this.context.hashString()) +
+             "/" + this.semanticContext.hashString();
+};
+
+ATNConfig.prototype.toString = function() {
+    return "(" + this.state + "," + this.alt +
+        (this.context!==null ? ",[" + this.context.toString() + "]" : "") +
+        (this.semanticContext !== SemanticContext.NONE ?
+                ("," + this.semanticContext.toString())
+                : "") +
+        (this.reachesIntoOuterContext>0 ?
+                (",up=" + this.reachesIntoOuterContext)
+                : "") + ")";
+};
+
+
+function LexerATNConfig(params, config) {
+	ATNConfig.call(this, params, config);
+    
+    // This is the backing field for {@link //getLexerActionExecutor}.
+	var lexerActionExecutor = params.lexerActionExecutor || null;
+    this.lexerActionExecutor = lexerActionExecutor || (config!==null ? config.lexerActionExecutor : null);
+    this.passedThroughNonGreedyDecision = config!==null ? this.checkNonGreedyDecision(config, this.state) : false;
+    return this;
+}
+
+LexerATNConfig.prototype = Object.create(ATNConfig.prototype);
+LexerATNConfig.prototype.constructor = LexerATNConfig;
+
+LexerATNConfig.prototype.hashString = function() {
+    return "" + this.state.stateNumber + this.alt + this.context +
+            this.semanticContext + (this.passedThroughNonGreedyDecision ? 1 : 0) +
+            this.lexerActionExecutor;
+};
+
+LexerATNConfig.prototype.equals = function(other) {
+    if (this === other) {
+        return true;
+    } else if (!(other instanceof LexerATNConfig)) {
+        return false;
+    } else if (this.passedThroughNonGreedyDecision !== other.passedThroughNonGreedyDecision) {
+        return false;
+    } else if (this.lexerActionExecutor ?
+            !this.lexerActionExecutor.equals(other.lexerActionExecutor)
+            : !other.lexerActionExecutor) {
+        return false;
+    } else {
+        return ATNConfig.prototype.equals.call(this, other);
+    }
+};
+
+LexerATNConfig.prototype.checkNonGreedyDecision = function(source, target) {
+    return source.passedThroughNonGreedyDecision ||
+        (target instanceof DecisionState) && target.nonGreedy;
+};
+
+exports.ATNConfig = ATNConfig;
+exports.LexerATNConfig = LexerATNConfig;
\ No newline at end of file
diff --git a/runtime/JavaScript/src/antlr4/atn/ATNConfigSet.js b/runtime/JavaScript/src/antlr4/atn/ATNConfigSet.js
new file mode 100644
index 000000000..723eeceb6
--- /dev/null
+++ b/runtime/JavaScript/src/antlr4/atn/ATNConfigSet.js
@@ -0,0 +1,281 @@
+//
+// [The "BSD license"]
+//  Copyright (c) 2012 Terence Parr
+//  Copyright (c) 2012 Sam Harwell
+//  Copyright (c) 2014 Eric Vergnaud
+//  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.
+
+//
+// Specialized {@link Set}{@code <}{@link ATNConfig}{@code >} that can track
+// info about the set, with support for combining similar configurations using a
+// graph-structured stack.
+///
+
+var ATN = require('./ATN').ATN;
+var Utils = require('./../Utils');
+var Set = Utils.Set;
+var SemanticContext = require('./SemanticContext').SemanticContext;
+var merge = require('./../PredictionContext').merge;
+
+function hashATNConfig(c) {
+	return c.shortHashString();
+}
+
+function equalATNConfigs(a, b) {
+	if ( a===b ) {
+		return true;
+	}
+	if ( a===null || b===null ) {
+		return false;
+	}
+	return a.state.stateNumber===b.state.stateNumber &&
+		a.alt===b.alt && a.semanticContext.equals(b.semanticContext);
+}
+
+
+function ATNConfigSet(fullCtx) {
+	//
+	// The reason that we need this is because we don't want the hash map to use
+	// the standard hash code and equals. We need all configurations with the
+	// same
+	// {@code (s,i,_,semctx)} to be equal. Unfortunately, this key effectively
+	// doubles
+	// the number of objects associated with ATNConfigs. The other solution is
+	// to
+	// use a hash table that lets us specify the equals/hashcode operation.
+	// All configs but hashed by (s, i, _, pi) not including context. Wiped out
+	// when we go readonly as this set becomes a DFA state.
+	this.configLookup = new Set(hashATNConfig, equalATNConfigs);
+	// Indicates that this configuration set is part of a full context
+	// LL prediction. It will be used to determine how to merge $. With SLL
+	// it's a wildcard whereas it is not for LL context merge.
+	this.fullCtx = fullCtx === undefined ? true : fullCtx;
+	// Indicates that the set of configurations is read-only. Do not
+	// allow any code to manipulate the set; DFA states will point at
+	// the sets and they must not change. This does not protect the other
+	// fields; in particular, conflictingAlts is set after
+	// we've made this readonly.
+	this.readOnly = false;
+	// Track the elements as they are added to the set; supports get(i)///
+	this.configs = [];
+
+	// TODO: these fields make me pretty uncomfortable but nice to pack up info
+	// together, saves recomputation
+	// TODO: can we track conflicts as they are added to save scanning configs
+	// later?
+	this.uniqueAlt = 0;
+	this.conflictingAlts = null;
+
+	// Used in parser and lexer. In lexer, it indicates we hit a pred
+	// while computing a closure operation. Don't make a DFA state from this.
+	this.hasSemanticContext = false;
+	this.dipsIntoOuterContext = false;
+
+	this.cachedHashString = "-1";
+
+	return this;
+}
+
+// Adding a new config means merging contexts with existing configs for
+// {@code (s, i, pi, _)}, where {@code s} is the
+// {@link ATNConfig//state}, {@code i} is the {@link ATNConfig//alt}, and
+// {@code pi} is the {@link ATNConfig//semanticContext}. We use
+// {@code (s,i,pi)} as key.
+//
+// <p>This method updates {@link //dipsIntoOuterContext} and
+// {@link //hasSemanticContext} when necessary.</p>
+// /
+ATNConfigSet.prototype.add = function(config, mergeCache) {
+	if (mergeCache === undefined) {
+		mergeCache = null;
+	}
+	if (this.readOnly) {
+		throw "This set is readonly";
+	}
+	if (config.semanticContext !== SemanticContext.NONE) {
+		this.hasSemanticContext = true;
+	}
+	if (config.reachesIntoOuterContext > 0) {
+		this.dipsIntoOuterContext = true;
+	}
+	var existing = this.configLookup.add(config);
+	if (existing === config) {
+		this.cachedHashString = "-1";
+		this.configs.push(config); // track order here
+		return true;
+	}
+	// a previous (s,i,pi,_), merge with it and save result
+	var rootIsWildcard = !this.fullCtx;
+	var merged = merge(existing.context, config.context, rootIsWildcard, mergeCache);
+	// no need to check for existing.context, config.context in cache
+	// since only way to create new graphs is "call rule" and here. We
+	// cache at both places.
+	existing.reachesIntoOuterContext = Math.max( existing.reachesIntoOuterContext, config.reachesIntoOuterContext);
+	// make sure to preserve the precedence filter suppression during the merge
+	if (config.precedenceFilterSuppressed) {
+		existing.precedenceFilterSuppressed = true;
+	}
+	existing.context = merged; // replace context; no need to alt mapping
+	return true;
+};
+
+ATNConfigSet.prototype.getStates = function() {
+	var states = new Set();
+	for (var i = 0; i < this.configs.length; i++) {
+		states.add(this.configs[i].state);
+	}
+	return states;
+};
+
+ATNConfigSet.prototype.getPredicates = function() {
+	var preds = [];
+	for (var i = 0; i < this.configs.length; i++) {
+		var c = this.configs[i].semanticContext;
+		if (c !== SemanticContext.NONE) {
+			preds.push(c.semanticContext);
+		}
+	}
+	return preds;
+};
+
+Object.defineProperty(ATNConfigSet.prototype, "items", {
+	get : function() {
+		return this.configs;
+	}
+});
+
+ATNConfigSet.prototype.optimizeConfigs = function(interpreter) {
+	if (this.readOnly) {
+		throw "This set is readonly";
+	}
+	if (this.configLookup.length === 0) {
+		return;
+	}
+	for (var i = 0; i < this.configs.length; i++) {
+		var config = this.configs[i];
+		config.context = interpreter.getCachedContext(config.context);
+	}
+};
+
+ATNConfigSet.prototype.addAll = function(coll) {
+	for (var i = 0; i < coll.length; i++) {
+		this.add(coll[i]);
+	}
+	return false;
+};
+
+ATNConfigSet.prototype.equals = function(other) {
+	if (this === other) {
+		return true;
+	} else if (!(other instanceof ATNConfigSet)) {
+		return false;
+	}
+	return this.configs !== null && this.configs.equals(other.configs) &&
+			this.fullCtx === other.fullCtx &&
+			this.uniqueAlt === other.uniqueAlt &&
+			this.conflictingAlts === other.conflictingAlts &&
+			this.hasSemanticContext === other.hasSemanticContext &&
+			this.dipsIntoOuterContext === other.dipsIntoOuterContext;
+};
+
+ATNConfigSet.prototype.hashString = function() {
+	if (this.readOnly) {
+		if (this.cachedHashString === "-1") {
+			this.cachedHashString = this.hashConfigs();
+		}
+		return this.cachedHashString;
+	} else {
+		return this.hashConfigs();
+	}
+};
+
+ATNConfigSet.prototype.hashConfigs = function() {
+	var s = "";
+	this.configs.map(function(c) {
+		s += c.toString();
+	});
+	return s;
+};
+
+Object.defineProperty(ATNConfigSet.prototype, "length", {
+	get : function() {
+		return this.configs.length;
+	}
+});
+
+ATNConfigSet.prototype.isEmpty = function() {
+	return this.configs.length === 0;
+};
+
+ATNConfigSet.prototype.contains = function(item) {
+	if (this.configLookup === null) {
+		throw "This method is not implemented for readonly sets.";
+	}
+	return this.configLookup.contains(item);
+};
+
+ATNConfigSet.prototype.containsFast = function(item) {
+	if (this.configLookup === null) {
+		throw "This method is not implemented for readonly sets.";
+	}
+	return this.configLookup.containsFast(item);
+};
+
+ATNConfigSet.prototype.clear = function() {
+	if (this.readOnly) {
+		throw "This set is readonly";
+	}
+	this.configs = [];
+	this.cachedHashString = "-1";
+	this.configLookup = new Set();
+};
+
+ATNConfigSet.prototype.setReadonly = function(readOnly) {
+	this.readOnly = readOnly;
+	if (readOnly) {
+		this.configLookup = null; // can't mod, no need for lookup cache
+	}
+};
+
+ATNConfigSet.prototype.toString = function() {
+	return Utils.arrayToString(this.configs) +
+		(this.hasSemanticContext ? ",hasSemanticContext=" + this.hasSemanticContext : "") +
+		(this.uniqueAlt !== ATN.INVALID_ALT_NUMBER ? ",uniqueAlt=" + this.uniqueAlt : "") +
+		(this.conflictingAlts !== null ? ",conflictingAlts=" + this.conflictingAlts : "") +
+		(this.dipsIntoOuterContext ? ",dipsIntoOuterContext" : "");
+};
+
+function OrderedATNConfigSet() {
+	ATNConfigSet.call(this);
+	this.configLookup = new Set();
+	return this;
+}
+
+OrderedATNConfigSet.prototype = Object.create(ATNConfigSet.prototype);
+OrderedATNConfigSet.prototype.constructor = OrderedATNConfigSet;
+
+exports.ATNConfigSet = ATNConfigSet;
+exports.OrderedATNConfigSet = OrderedATNConfigSet;
diff --git a/runtime/JavaScript/src/antlr4/atn/ATNDeserializationOptions.js b/runtime/JavaScript/src/antlr4/atn/ATNDeserializationOptions.js
new file mode 100644
index 000000000..5b89253b3
--- /dev/null
+++ b/runtime/JavaScript/src/antlr4/atn/ATNDeserializationOptions.js
@@ -0,0 +1,49 @@
+//[The "BSD license"]
+// Copyright (c) 2013 Terence Parr
+// Copyright (c) 2013 Sam Harwell
+// Copyright (c) 2014 Eric Vergnaud
+// 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.
+
+function ATNDeserializationOptions(copyFrom) {
+	if(copyFrom===undefined) {
+		copyFrom = null;
+	}
+	this.readOnly = false;
+    this.verifyATN = copyFrom===null ? true : copyFrom.verifyATN;
+    this.generateRuleBypassTransitions = copyFrom===null ? false : copyFrom.generateRuleBypassTransitions;
+
+    return this;
+}
+
+ATNDeserializationOptions.defaultOptions = new ATNDeserializationOptions();
+ATNDeserializationOptions.defaultOptions.readOnly = true;
+
+//    def __setattr__(self, key, value):
+//        if key!="readOnly" and self.readOnly:
+//            raise Exception("The object is read only.")
+//        super(type(self), self).__setattr__(key,value)
+
+exports.ATNDeserializationOptions = ATNDeserializationOptions;
diff --git a/runtime/JavaScript/src/antlr4/atn/ATNDeserializer.js b/runtime/JavaScript/src/antlr4/atn/ATNDeserializer.js
new file mode 100644
index 000000000..548549826
--- /dev/null
+++ b/runtime/JavaScript/src/antlr4/atn/ATNDeserializer.js
@@ -0,0 +1,690 @@
+// [The "BSD license"]
+//  Copyright (c) 2013 Terence Parr
+//  Copyright (c) 2013 Sam Harwell
+//  Copyright (c) 2014 Eric Vergnaud
+//  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.
+
+var Token = require('./../Token').Token;
+var ATN = require('./ATN').ATN;
+var ATNType = require('./ATNType').ATNType;
+var ATNStates = require('./ATNState');
+var ATNState = ATNStates.ATNState;
+var BasicState = ATNStates.BasicState;
+var DecisionState = ATNStates.DecisionState;
+var BlockStartState = ATNStates.BlockStartState;
+var BlockEndState = ATNStates.BlockEndState;
+var LoopEndState = ATNStates.LoopEndState;
+var RuleStartState = ATNStates.RuleStartState;
+var RuleStopState = ATNStates.RuleStopState;
+var TokensStartState = ATNStates.TokensStartState;
+var PlusLoopbackState = ATNStates.PlusLoopbackState;
+var StarLoopbackState = ATNStates.StarLoopbackState;
+var StarLoopEntryState = ATNStates.StarLoopEntryState;
+var PlusBlockStartState = ATNStates.PlusBlockStartState;
+var StarBlockStartState = ATNStates.StarBlockStartState;
+var BasicBlockStartState = ATNStates.BasicBlockStartState;
+var Transitions = require('./Transition');
+var Transition = Transitions.Transition;
+var AtomTransition = Transitions.AtomTransition;
+var SetTransition = Transitions.SetTransition;
+var NotSetTransition = Transitions.NotSetTransition;
+var RuleTransition = Transitions.RuleTransition;
+var RangeTransition = Transitions.RangeTransition;
+var ActionTransition = Transitions.ActionTransition;
+var EpsilonTransition = Transitions.EpsilonTransition;
+var WildcardTransition = Transitions.WildcardTransition;
+var PredicateTransition = Transitions.PredicateTransition;
+var PrecedencePredicateTransition = Transitions.PrecedencePredicateTransition;
+var IntervalSet = require('./../IntervalSet').IntervalSet;
+var Interval = require('./../IntervalSet').Interval;
+var ATNDeserializationOptions = require('./ATNDeserializationOptions').ATNDeserializationOptions;
+var LexerActions = require('./LexerAction');
+var LexerActionType = LexerActions.LexerActionType;
+var LexerSkipAction = LexerActions.LexerSkipAction;
+var LexerChannelAction = LexerActions.LexerChannelAction;
+var LexerCustomAction = LexerActions.LexerCustomAction;
+var LexerMoreAction = LexerActions.LexerMoreAction;
+var LexerTypeAction = LexerActions.LexerTypeAction;
+var LexerPushModeAction = LexerActions.LexerPushModeAction;
+var LexerPopModeAction = LexerActions.LexerPopModeAction;
+var LexerModeAction = LexerActions.LexerModeAction;
+// This is the earliest supported serialized UUID.
+// stick to serialized version for now, we don't need a UUID instance
+var BASE_SERIALIZED_UUID = "AADB8D7E-AEEF-4415-AD2B-8204D6CF042E";
+
+// This list contains all of the currently supported UUIDs, ordered by when
+// the feature first appeared in this branch.
+var SUPPORTED_UUIDS = [ BASE_SERIALIZED_UUID ];
+
+var SERIALIZED_VERSION = 3;
+
+// This is the current serialized UUID.
+var SERIALIZED_UUID = BASE_SERIALIZED_UUID;
+
+function initArray( length, value) {
+	var tmp = [];
+	tmp[length-1] = value;
+	return tmp.map(function(i) {return value;});
+}
+
+function ATNDeserializer (options) {
+	
+    if ( options=== undefined || options === null ) {
+        options = ATNDeserializationOptions.defaultOptions;
+    }
+    this.deserializationOptions = options;
+    this.stateFactories = null;
+    this.actionFactories = null;
+    
+    return this;
+}
+
+// Determines if a particular serialized representation of an ATN supports
+// a particular feature, identified by the {@link UUID} used for serializing
+// the ATN at the time the feature was first introduced.
+//
+// @param feature The {@link UUID} marking the first time the feature was
+// supported in the serialized ATN.
+// @param actualUuid The {@link UUID} of the actual serialized ATN which is
+// currently being deserialized.
+// @return {@code true} if the {@code actualUuid} value represents a
+// serialized ATN at or after the feature identified by {@code feature} was
+// introduced; otherwise, {@code false}.
+
+ATNDeserializer.prototype.isFeatureSupported = function(feature, actualUuid) {
+    var idx1 = SUPPORTED_UUIDS.index(feature);
+    if (idx1<0) {
+        return false;
+    }
+    var idx2 = SUPPORTED_UUIDS.index(actualUuid);
+    return idx2 >= idx1;
+};
+
+ATNDeserializer.prototype.deserialize = function(data) {
+    this.reset(data);
+    this.checkVersion();
+    this.checkUUID();
+    var atn = this.readATN();
+    this.readStates(atn);
+    this.readRules(atn);
+    this.readModes(atn);
+    var sets = this.readSets(atn);
+    this.readEdges(atn, sets);
+    this.readDecisions(atn);
+    this.readLexerActions(atn);
+    this.markPrecedenceDecisions(atn);
+    this.verifyATN(atn);
+    if (this.deserializationOptions.generateRuleBypassTransitions && atn.grammarType === ATNType.PARSER ) {
+        this.generateRuleBypassTransitions(atn);
+        // re-verify after modification
+        this.verifyATN(atn);
+    }
+    return atn;
+};
+
+ATNDeserializer.prototype.reset = function(data) {
+	var adjust = function(c) {
+        var v = c.charCodeAt(0);
+        return v>1  ? v-2 : -1;
+	};
+    var temp = data.split("").map(adjust);
+    // don't adjust the first value since that's the version number
+    temp[0] = data.charCodeAt(0);
+    this.data = temp;
+    this.pos = 0;
+};
+
+ATNDeserializer.prototype.checkVersion = function() {
+    var version = this.readInt();
+    if ( version !== SERIALIZED_VERSION ) {
+        throw ("Could not deserialize ATN with version " + version + " (expected " + SERIALIZED_VERSION + ").");
+    }
+};
+
+ATNDeserializer.prototype.checkUUID = function() {
+    var uuid = this.readUUID();
+    if (SUPPORTED_UUIDS.indexOf(uuid)<0) {
+        throw ("Could not deserialize ATN with UUID: " + uuid +
+                        " (expected " + SERIALIZED_UUID + " or a legacy UUID).", uuid, SERIALIZED_UUID);
+    }
+    this.uuid = uuid;
+};
+
+ATNDeserializer.prototype.readATN = function() {
+    var grammarType = this.readInt();
+    var maxTokenType = this.readInt();
+    return new ATN(grammarType, maxTokenType);
+};
+
+ATNDeserializer.prototype.readStates = function(atn) {
+	var j, pair, stateNumber;
+    var loopBackStateNumbers = [];
+    var endStateNumbers = [];
+    var nstates = this.readInt();
+    for(var i=0; i<nstates; i++) {
+        var stype = this.readInt();
+        // ignore bad type of states
+        if (stype===ATNState.INVALID_TYPE) {
+            atn.addState(null);
+            continue;
+        }
+        var ruleIndex = this.readInt();
+        if (ruleIndex === 0xFFFF) {
+            ruleIndex = -1;
+        }
+        var s = this.stateFactory(stype, ruleIndex);
+        if (stype === ATNState.LOOP_END) { // special case
+            var loopBackStateNumber = this.readInt();
+            loopBackStateNumbers.push([s, loopBackStateNumber]);
+        } else if(s instanceof BlockStartState) {
+            var endStateNumber = this.readInt();
+            endStateNumbers.push([s, endStateNumber]);
+        }
+        atn.addState(s);
+    }
+    // delay the assignment of loop back and end states until we know all the
+	// state instances have been initialized
+    for (j=0; j<loopBackStateNumbers.length; j++) {
+        pair = loopBackStateNumbers[j];
+        pair[0].loopBackState = atn.states[pair[1]];
+    }
+
+    for (j=0; j<endStateNumbers.length; j++) {
+        pair = endStateNumbers[j];
+        pair[0].endState = atn.states[pair[1]];
+    }
+    
+    var numNonGreedyStates = this.readInt();
+    for (j=0; j<numNonGreedyStates; j++) {
+        stateNumber = this.readInt();
+        atn.states[stateNumber].nonGreedy = true;
+    }
+
+    var numPrecedenceStates = this.readInt();
+    for (j=0; j<numPrecedenceStates; j++) {
+        stateNumber = this.readInt();
+        atn.states[stateNumber].isPrecedenceRule = true;
+    }
+};
+
+ATNDeserializer.prototype.readRules = function(atn) {
+    var i;
+    var nrules = this.readInt();
+    if (atn.grammarType === ATNType.LEXER ) {
+        atn.ruleToTokenType = initArray(nrules, 0);
+    }
+    atn.ruleToStartState = initArray(nrules, 0);
+    for (i=0; i<nrules; i++) {
+        var s = this.readInt();
+        var startState = atn.states[s];
+        atn.ruleToStartState[i] = startState;
+        if ( atn.grammarType === ATNType.LEXER ) {
+            var tokenType = this.readInt();
+            if (tokenType === 0xFFFF) {
+                tokenType = Token.EOF;
+            }
+            atn.ruleToTokenType[i] = tokenType;
+        }
+    }
+    atn.ruleToStopState = initArray(nrules, 0);
+    for (i=0; i<atn.states.length; i++) {
+        var state = atn.states[i];
+        if (!(state instanceof RuleStopState)) {
+            continue;
+        }
+        atn.ruleToStopState[state.ruleIndex] = state;
+        atn.ruleToStartState[state.ruleIndex].stopState = state;
+    }
+};
+
+ATNDeserializer.prototype.readModes = function(atn) {
+    var nmodes = this.readInt();
+    for (var i=0; i<nmodes; i++) {
+        var s = this.readInt();
+        atn.modeToStartState.push(atn.states[s]);
+    }
+};
+
+ATNDeserializer.prototype.readSets = function(atn) {
+    var sets = [];
+    var m = this.readInt();
+    for (var i=0; i<m; i++) {
+        var iset = new IntervalSet();
+        sets.push(iset);
+        var n = this.readInt();
+        var containsEof = this.readInt();
+        if (containsEof!==0) {
+            iset.addOne(-1);
+        }
+        for (var j=0; j<n; j++) {
+            var i1 = this.readInt();
+            var i2 = this.readInt();
+            iset.addRange(i1, i2);
+        }
+    }
+    return sets;
+};
+
+ATNDeserializer.prototype.readEdges = function(atn, sets) {
+	var i, j, state, trans, target;
+    var nedges = this.readInt();
+    for (i=0; i<nedges; i++) {
+        var src = this.readInt();
+        var trg = this.readInt();
+        var ttype = this.readInt();
+        var arg1 = this.readInt();
+        var arg2 = this.readInt();
+        var arg3 = this.readInt();
+        trans = this.edgeFactory(atn, ttype, src, trg, arg1, arg2, arg3, sets);
+        var srcState = atn.states[src];
+        srcState.addTransition(trans);
+    }
+    // edges for rule stop states can be derived, so they aren't serialized
+    for (i=0; i<atn.states.length; i++) {
+        state = atn.states[i];
+        for (j=0; j<state.transitions.length; j++) {
+            var t = state.transitions[j];
+            if (!(t instanceof RuleTransition)) {
+                continue;
+            }
+			var outermostPrecedenceReturn = -1;
+			if (atn.ruleToStartState[t.target.ruleIndex].isPrecedenceRule) {
+				if (t.precedence === 0) {
+					outermostPrecedenceReturn = t.target.ruleIndex;
+				}
+			}
+
+			trans = new EpsilonTransition(t.followState, outermostPrecedenceReturn);
+            atn.ruleToStopState[t.target.ruleIndex].addTransition(trans);
+        }
+    }
+
+    for (i=0; i<atn.states.length; i++) {
+        state = atn.states[i];
+        if (state instanceof BlockStartState) {
+            // we need to know the end state to set its start state
+            if (state.endState === null) {
+                throw ("IllegalState");
+            }
+            // block end states can only be associated to a single block start
+			// state
+            if ( state.endState.startState !== null) {
+                throw ("IllegalState");
+            }
+            state.endState.startState = state;
+        }
+        if (state instanceof PlusLoopbackState) {
+            for (j=0; j<state.transitions.length; j++) {
+                target = state.transitions[j].target;
+                if (target instanceof PlusBlockStartState) {
+                    target.loopBackState = state;
+                }
+            }
+        } else if (state instanceof StarLoopbackState) {
+            for (j=0; j<state.transitions.length; j++) {
+                target = state.transitions[j].target;
+                if (target instanceof StarLoopEntryState) {
+                    target.loopBackState = state;
+                }
+            }
+        }
+    }
+};
+
+ATNDeserializer.prototype.readDecisions = function(atn) {
+    var ndecisions = this.readInt();
+    for (var i=0; i<ndecisions; i++) {
+        var s = this.readInt();
+        var decState = atn.states[s];
+        atn.decisionToState.push(decState);
+        decState.decision = i;
+    }
+};
+
+ATNDeserializer.prototype.readLexerActions = function(atn) {
+    if (atn.grammarType === ATNType.LEXER) {
+        var count = this.readInt();
+        atn.lexerActions = initArray(count, null);
+        for (var i=0; i<count; i++) {
+            var actionType = this.readInt();
+            var data1 = this.readInt();
+            if (data1 === 0xFFFF) {
+                data1 = -1;
+            }
+            var data2 = this.readInt();
+            if (data2 === 0xFFFF) {
+                data2 = -1;
+            }
+            var lexerAction = this.lexerActionFactory(actionType, data1, data2);
+            atn.lexerActions[i] = lexerAction;
+        }
+    }
+};
+
+ATNDeserializer.prototype.generateRuleBypassTransitions = function(atn) {
+	var i;
+    var count = atn.ruleToStartState.length;
+    for(i=0; i<count; i++) {
+        atn.ruleToTokenType[i] = atn.maxTokenType + i + 1;
+    }
+    for(i=0; i<count; i++) {
+        this.generateRuleBypassTransition(atn, i);
+    }
+};
+
+ATNDeserializer.prototype.generateRuleBypassTransition = function(atn, idx) {
+	var i, state;
+    var bypassStart = new BasicBlockStartState();
+    bypassStart.ruleIndex = idx;
+    atn.addState(bypassStart);
+
+    var bypassStop = new BlockEndState();
+    bypassStop.ruleIndex = idx;
+    atn.addState(bypassStop);
+
+    bypassStart.endState = bypassStop;
+    atn.defineDecisionState(bypassStart);
+
+    bypassStop.startState = bypassStart;
+
+    var excludeTransition = null;
+    var endState = null;
+    
+    if (atn.ruleToStartState[idx].isPrecedenceRule) {
+        // wrap from the beginning of the rule to the StarLoopEntryState
+        endState = null;
+        for(i=0; i<atn.states.length; i++) {
+            state = atn.states[i];
+            if (this.stateIsEndStateFor(state, idx)) {
+                endState = state;
+                excludeTransition = state.loopBackState.transitions[0];
+                break;
+            }
+        }
+        if (excludeTransition === null) {
+            throw ("Couldn't identify final state of the precedence rule prefix section.");
+        }
+    } else {
+        endState = atn.ruleToStopState[idx];
+    }
+    
+    // all non-excluded transitions that currently target end state need to
+	// target blockEnd instead
+    for(i=0; i<atn.states.length; i++) {
+        state = atn.states[i];
+        for(var j=0; j<state.transitions.length; j++) {
+            var transition = state.transitions[j];
+            if (transition === excludeTransition) {
+                continue;
+            }
+            if (transition.target === endState) {
+                transition.target = bypassStop;
+            }
+        }
+    }
+
+    // all transitions leaving the rule start state need to leave blockStart
+	// instead
+    var ruleToStartState = atn.ruleToStartState[idx];
+    var count = ruleToStartState.transitions.length;
+    while ( count > 0) {
+        bypassStart.addTransition(ruleToStartState.transitions[count-1]);
+        ruleToStartState.transitions = ruleToStartState.transitions.slice(-1);
+    }
+    // link the new states
+    atn.ruleToStartState[idx].addTransition(new EpsilonTransition(bypassStart));
+    bypassStop.addTransition(new EpsilonTransition(endState));
+
+    var matchState = new BasicState();
+    atn.addState(matchState);
+    matchState.addTransition(new AtomTransition(bypassStop, atn.ruleToTokenType[idx]));
+    bypassStart.addTransition(new EpsilonTransition(matchState));
+};
+
+ATNDeserializer.prototype.stateIsEndStateFor = function(state, idx) {
+    if ( state.ruleIndex !== idx) {
+        return null;
+    }
+    if (!( state instanceof StarLoopEntryState)) {
+        return null;
+    }
+    var maybeLoopEndState = state.transitions[state.transitions.length - 1].target;
+    if (!( maybeLoopEndState instanceof LoopEndState)) {
+        return null;
+    }
+    if (maybeLoopEndState.epsilonOnlyTransitions &&
+        (maybeLoopEndState.transitions[0].target instanceof RuleStopState)) {
+        return state;
+    } else {
+        return null;
+    }
+};
+
+//
+// Analyze the {@link StarLoopEntryState} states in the specified ATN to set
+// the {@link StarLoopEntryState//precedenceRuleDecision} field to the
+// correct value.
+//
+// @param atn The ATN.
+//
+ATNDeserializer.prototype.markPrecedenceDecisions = function(atn) {
+	for(var i=0; i<atn.states.length; i++) {
+		var state = atn.states[i];
+		if (!( state instanceof StarLoopEntryState)) {
+            continue;
+        }
+        // We analyze the ATN to determine if this ATN decision state is the
+        // decision for the closure block that determines whether a
+        // precedence rule should continue or complete.
+        //
+        if ( atn.ruleToStartState[state.ruleIndex].isPrecedenceRule) {
+            var maybeLoopEndState = state.transitions[state.transitions.length - 1].target;
+            if (maybeLoopEndState instanceof LoopEndState) {
+                if ( maybeLoopEndState.epsilonOnlyTransitions &&
+                        (maybeLoopEndState.transitions[0].target instanceof RuleStopState)) {
+                    state.precedenceRuleDecision = true;
+                }
+            }
+        }
+	}
+};
+
+ATNDeserializer.prototype.verifyATN = function(atn) {
+    if (!this.deserializationOptions.verifyATN) {
+        return;
+    }
+    // verify assumptions
+	for(var i=0; i<atn.states.length; i++) {
+        var state = atn.states[i];
+        if (state === null) {
+            continue;
+        }
+        this.checkCondition(state.epsilonOnlyTransitions || state.transitions.length <= 1);
+        if (state instanceof PlusBlockStartState) {
+            this.checkCondition(state.loopBackState !== null);
+        } else  if (state instanceof StarLoopEntryState) {
+            this.checkCondition(state.loopBackState !== null);
+            this.checkCondition(state.transitions.length === 2);
+            if (state.transitions[0].target instanceof StarBlockStartState) {
+                this.checkCondition(state.transitions[1].target instanceof LoopEndState);
+                this.checkCondition(!state.nonGreedy);
+            } else if (state.transitions[0].target instanceof LoopEndState) {
+                this.checkCondition(state.transitions[1].target instanceof StarBlockStartState);
+                this.checkCondition(state.nonGreedy);
+            } else {
+                throw("IllegalState");
+            }
+        } else if (state instanceof StarLoopbackState) {
+            this.checkCondition(state.transitions.length === 1);
+            this.checkCondition(state.transitions[0].target instanceof StarLoopEntryState);
+        } else if (state instanceof LoopEndState) {
+            this.checkCondition(state.loopBackState !== null);
+        } else if (state instanceof RuleStartState) {
+            this.checkCondition(state.stopState !== null);
+        } else if (state instanceof BlockStartState) {
+            this.checkCondition(state.endState !== null);
+        } else if (state instanceof BlockEndState) {
+            this.checkCondition(state.startState !== null);
+        } else if (state instanceof DecisionState) {
+            this.checkCondition(state.transitions.length <= 1 || state.decision >= 0);
+        } else {
+            this.checkCondition(state.transitions.length <= 1 || (state instanceof RuleStopState));
+        }
+	}
+};
+
+ATNDeserializer.prototype.checkCondition = function(condition, message) {
+    if (!condition) {
+        if (message === undefined || message===null) {
+            message = "IllegalState";
+        }
+        throw (message);
+    }
+};
+
+ATNDeserializer.prototype.readInt = function() {
+    return this.data[this.pos++];
+};
+
+ATNDeserializer.prototype.readInt32 = function() {
+    var low = this.readInt();
+    var high = this.readInt();
+    return low | (high << 16);
+};
+
+ATNDeserializer.prototype.readLong = function() {
+    var low = this.readInt32();
+    var high = this.readInt32();
+    return (low & 0x00000000FFFFFFFF) | (high << 32);
+};
+
+function createByteToHex() {
+	var bth = [];
+	for (var i = 0; i < 256; i++) {
+		bth[i] = (i + 0x100).toString(16).substr(1).toUpperCase();
+	}
+	return bth;
+}
+
+var byteToHex = createByteToHex();
+	
+ATNDeserializer.prototype.readUUID = function() {
+	var bb = [];
+	for(var i=7;i>=0;i--) {
+		var int = this.readInt();
+		/* jshint bitwise: false */
+		bb[(2*i)+1] = int & 0xFF;
+		bb[2*i] = (int >> 8) & 0xFF;
+	}
+    return byteToHex[bb[0]] + byteToHex[bb[1]] +
+    byteToHex[bb[2]] + byteToHex[bb[3]] + '-' +
+    byteToHex[bb[4]] + byteToHex[bb[5]] + '-' +
+    byteToHex[bb[6]] + byteToHex[bb[7]] + '-' +
+    byteToHex[bb[8]] + byteToHex[bb[9]] + '-' +
+    byteToHex[bb[10]] + byteToHex[bb[11]] +
+    byteToHex[bb[12]] + byteToHex[bb[13]] +
+    byteToHex[bb[14]] + byteToHex[bb[15]];
+};
+
+ATNDeserializer.prototype.edgeFactory = function(atn, type, src, trg, arg1, arg2, arg3, sets) {
+    var target = atn.states[trg];
+    switch(type) {
+    case Transition.EPSILON:
+        return new EpsilonTransition(target);
+    case Transition.RANGE:
+        return arg3 !== 0 ? new RangeTransition(target, Token.EOF, arg2) : new RangeTransition(target, arg1, arg2);
+    case Transition.RULE:
+        return new RuleTransition(atn.states[arg1], arg2, arg3, target);
+    case Transition.PREDICATE:
+        return new PredicateTransition(target, arg1, arg2, arg3 !== 0);
+    case Transition.PRECEDENCE:
+        return new PrecedencePredicateTransition(target, arg1);
+    case Transition.ATOM:
+        return arg3 !== 0 ? new AtomTransition(target, Token.EOF) : new AtomTransition(target, arg1);
+    case Transition.ACTION:
+        return new ActionTransition(target, arg1, arg2, arg3 !== 0);
+    case Transition.SET:
+        return new SetTransition(target, sets[arg1]);
+    case Transition.NOT_SET:
+        return new NotSetTransition(target, sets[arg1]);
+    case Transition.WILDCARD:
+        return new WildcardTransition(target);
+    default:
+        throw "The specified transition type: " + type + " is not valid.";
+    }
+};
+
+ATNDeserializer.prototype.stateFactory = function(type, ruleIndex) {
+    if (this.stateFactories === null) {
+        var sf = [];
+        sf[ATNState.INVALID_TYPE] = null;
+        sf[ATNState.BASIC] = function() { return new BasicState(); };
+        sf[ATNState.RULE_START] = function() { return new RuleStartState(); };
+        sf[ATNState.BLOCK_START] = function() { return new BasicBlockStartState(); };
+        sf[ATNState.PLUS_BLOCK_START] = function() { return new PlusBlockStartState(); };
+        sf[ATNState.STAR_BLOCK_START] = function() { return new StarBlockStartState(); };
+        sf[ATNState.TOKEN_START] = function() { return new TokensStartState(); };
+        sf[ATNState.RULE_STOP] = function() { return new RuleStopState(); };
+        sf[ATNState.BLOCK_END] = function() { return new BlockEndState(); };
+        sf[ATNState.STAR_LOOP_BACK] = function() { return new StarLoopbackState(); };
+        sf[ATNState.STAR_LOOP_ENTRY] = function() { return new StarLoopEntryState(); };
+        sf[ATNState.PLUS_LOOP_BACK] = function() { return new PlusLoopbackState(); };
+        sf[ATNState.LOOP_END] = function() { return new LoopEndState(); };
+        this.stateFactories = sf;
+    }
+    if (type>this.stateFactories.length || this.stateFactories[type] === null) {
+        throw("The specified state type " + type + " is not valid.");
+    } else {
+        var s = this.stateFactories[type]();
+        if (s!==null) {
+            s.ruleIndex = ruleIndex;
+            return s;
+        }
+    }
+};
+
+ATNDeserializer.prototype.lexerActionFactory = function(type, data1, data2) {
+    if (this.actionFactories === null) {
+        var af = [];
+        af[LexerActionType.CHANNEL] = function(data1, data2) { return new LexerChannelAction(data1); };
+        af[LexerActionType.CUSTOM] = function(data1, data2) { return new LexerCustomAction(data1, data2); };
+        af[LexerActionType.MODE] = function(data1, data2) { return new LexerModeAction(data1); };
+        af[LexerActionType.MORE] = function(data1, data2) { return LexerMoreAction.INSTANCE; };
+        af[LexerActionType.POP_MODE] = function(data1, data2) { return LexerPopModeAction.INSTANCE; };
+        af[LexerActionType.PUSH_MODE] = function(data1, data2) { return new LexerPushModeAction(data1); };
+        af[LexerActionType.SKIP] = function(data1, data2) { return LexerSkipAction.INSTANCE; };
+        af[LexerActionType.TYPE] = function(data1, data2) { return new LexerTypeAction(data1); };
+        this.actionFactories = af;
+    }
+    if (type>this.actionFactories.length || this.actionFactories[type] === null) {
+        throw("The specified lexer action type " + type + " is not valid.");
+    } else {
+        return this.actionFactories[type](data1, data2);
+    }
+};
+   
+
+exports.ATNDeserializer = ATNDeserializer;
\ No newline at end of file
diff --git a/runtime/JavaScript/src/antlr4/atn/ATNSimulator.js b/runtime/JavaScript/src/antlr4/atn/ATNSimulator.js
new file mode 100644
index 000000000..8608743fb
--- /dev/null
+++ b/runtime/JavaScript/src/antlr4/atn/ATNSimulator.js
@@ -0,0 +1,75 @@
+//
+// [The "BSD license"]
+//  Copyright (c) 2013 Terence Parr
+//  Copyright (c) 2013 Sam Harwell
+//  Copyright (c) 2014 Eric Vergnaud
+//  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.
+///
+
+var DFAState = require('./../dfa/DFAState').DFAState;
+var ATNConfigSet = require('./ATNConfigSet').ATNConfigSet;
+var getCachedPredictionContext = require('./../PredictionContext').getCachedPredictionContext;
+
+function ATNSimulator(atn, sharedContextCache) {
+	
+    // The context cache maps all PredictionContext objects that are ==
+    //  to a single cached copy. This cache is shared across all contexts
+    //  in all ATNConfigs in all DFA states.  We rebuild each ATNConfigSet
+    //  to use only cached nodes/graphs in addDFAState(). We don't want to
+    //  fill this during closure() since there are lots of contexts that
+    //  pop up but are not used ever again. It also greatly slows down closure().
+    //
+    //  <p>This cache makes a huge difference in memory and a little bit in speed.
+    //  For the Java grammar on java.*, it dropped the memory requirements
+    //  at the end from 25M to 16M. We don't store any of the full context
+    //  graphs in the DFA because they are limited to local context only,
+    //  but apparently there's a lot of repetition there as well. We optimize
+    //  the config contexts before storing the config set in the DFA states
+    //  by literally rebuilding them with cached subgraphs only.</p>
+    //
+    //  <p>I tried a cache for use during closure operations, that was
+    //  whacked after each adaptivePredict(). It cost a little bit
+    //  more time I think and doesn't save on the overall footprint
+    //  so it's not worth the complexity.</p>
+    ///
+    this.atn = atn;
+    this.sharedContextCache = sharedContextCache;
+    return this;
+}
+
+// Must distinguish between missing edge and edge we know leads nowhere///
+ATNSimulator.ERROR = new DFAState(0x7FFFFFFF, new ATNConfigSet());
+
+
+ATNSimulator.prototype.getCachedContext = function(context) {
+    if (this.sharedContextCache ===null) {
+        return context;
+    }
+    var visited = {};
+    return getCachedPredictionContext(context, this.sharedContextCache, visited);
+};
+
+exports.ATNSimulator = ATNSimulator;
diff --git a/runtime/JavaScript/src/antlr4/atn/ATNState.js b/runtime/JavaScript/src/antlr4/atn/ATNState.js
new file mode 100644
index 000000000..e311b120c
--- /dev/null
+++ b/runtime/JavaScript/src/antlr4/atn/ATNState.js
@@ -0,0 +1,350 @@
+//
+// [The "BSD license"]
+//  Copyright (c) 2012 Terence Parr
+//  Copyright (c) 2012 Sam Harwell
+//  Copyright (c) 2014 Eric Vergnaud
+//  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.
+//
+
+// The following images show the relation of states and
+// {@link ATNState//transitions} for various grammar constructs.
+//
+// <ul>
+//
+// <li>Solid edges marked with an &//0949; indicate a required
+// {@link EpsilonTransition}.</li>
+//
+// <li>Dashed edges indicate locations where any transition derived from
+// {@link Transition} might appear.</li>
+//
+// <li>Dashed nodes are place holders for either a sequence of linked
+// {@link BasicState} states or the inclusion of a block representing a nested
+// construct in one of the forms below.</li>
+//
+// <li>Nodes showing multiple outgoing alternatives with a {@code ...} support
+// any number of alternatives (one or more). Nodes without the {@code ...} only
+// support the exact number of alternatives shown in the diagram.</li>
+//
+// </ul>
+//
+// <h2>Basic Blocks</h2>
+//
+// <h3>Rule</h3>
+//
+// <embed src="images/Rule.svg" type="image/svg+xml"/>
+//
+// <h3>Block of 1 or more alternatives</h3>
+//
+// <embed src="images/Block.svg" type="image/svg+xml"/>
+//
+// <h2>Greedy Loops</h2>
+//
+// <h3>Greedy Closure: {@code (...)*}</h3>
+//
+// <embed src="images/ClosureGreedy.svg" type="image/svg+xml"/>
+//
+// <h3>Greedy Positive Closure: {@code (...)+}</h3>
+//
+// <embed src="images/PositiveClosureGreedy.svg" type="image/svg+xml"/>
+//
+// <h3>Greedy Optional: {@code (...)?}</h3>
+//
+// <embed src="images/OptionalGreedy.svg" type="image/svg+xml"/>
+//
+// <h2>Non-Greedy Loops</h2>
+//
+// <h3>Non-Greedy Closure: {@code (...)*?}</h3>
+//
+// <embed src="images/ClosureNonGreedy.svg" type="image/svg+xml"/>
+//
+// <h3>Non-Greedy Positive Closure: {@code (...)+?}</h3>
+//
+// <embed src="images/PositiveClosureNonGreedy.svg" type="image/svg+xml"/>
+//
+// <h3>Non-Greedy Optional: {@code (...)??}</h3>
+//
+// <embed src="images/OptionalNonGreedy.svg" type="image/svg+xml"/>
+//
+
+var INITIAL_NUM_TRANSITIONS = 4;
+
+function ATNState() {
+    // Which ATN are we in?
+    this.atn = null;
+    this.stateNumber = ATNState.INVALID_STATE_NUMBER;
+    this.stateType = null;
+    this.ruleIndex = 0; // at runtime, we don't have Rule objects
+    this.epsilonOnlyTransitions = false;
+    // Track the transitions emanating from this ATN state.
+    this.transitions = [];
+    // Used to cache lookahead during parsing, not used during construction
+    this.nextTokenWithinRule = null;
+    return this;
+}
+
+// constants for serialization
+ATNState.INVALID_TYPE = 0;
+ATNState.BASIC = 1;
+ATNState.RULE_START = 2;
+ATNState.BLOCK_START = 3;
+ATNState.PLUS_BLOCK_START = 4;
+ATNState.STAR_BLOCK_START = 5;
+ATNState.TOKEN_START = 6;
+ATNState.RULE_STOP = 7;
+ATNState.BLOCK_END = 8;
+ATNState.STAR_LOOP_BACK = 9;
+ATNState.STAR_LOOP_ENTRY = 10;
+ATNState.PLUS_LOOP_BACK = 11;
+ATNState.LOOP_END = 12;
+
+ATNState.serializationNames = [
+            "INVALID",
+            "BASIC",
+            "RULE_START",
+            "BLOCK_START",
+            "PLUS_BLOCK_START",
+            "STAR_BLOCK_START",
+            "TOKEN_START",
+            "RULE_STOP",
+            "BLOCK_END",
+            "STAR_LOOP_BACK",
+            "STAR_LOOP_ENTRY",
+            "PLUS_LOOP_BACK",
+            "LOOP_END" ];
+
+ATNState.INVALID_STATE_NUMBER = -1;
+
+ATNState.prototype.toString = function() {
+	return this.stateNumber;
+};
+
+ATNState.prototype.equals = function(other) {
+    if (other instanceof ATNState) {
+        return this.stateNumber===other.stateNumber;
+    } else {
+        return false;
+    }
+};
+
+ATNState.prototype.isNonGreedyExitState = function() {
+    return false;
+};
+
+
+ATNState.prototype.addTransition = function(trans, index) {
+	if(index===undefined) {
+		index = -1;
+	}
+    if (this.transitions.length===0) {
+        this.epsilonOnlyTransitions = trans.isEpsilon;
+    } else if(this.epsilonOnlyTransitions !== trans.isEpsilon) {
+        this.epsilonOnlyTransitions = false;
+    }
+    if (index===-1) {
+        this.transitions.push(trans);
+    } else {
+        this.transitions.splice(index, 1, trans);
+    }
+};
+
+function BasicState() {
+	ATNState.call(this);
+    this.stateType = ATNState.BASIC;
+    return this;
+}
+
+BasicState.prototype = Object.create(ATNState.prototype);
+BasicState.prototype.constructor = BasicState;
+
+
+function DecisionState() {
+	ATNState.call(this);
+    this.decision = -1;
+    this.nonGreedy = false;
+    return this;
+}
+
+DecisionState.prototype = Object.create(ATNState.prototype);
+DecisionState.prototype.constructor = DecisionState;
+
+
+//  The start of a regular {@code (...)} block.
+function BlockStartState() {
+	DecisionState.call(this);
+	this.endState = null;
+	return this;
+}
+
+BlockStartState.prototype = Object.create(DecisionState.prototype);
+BlockStartState.prototype.constructor = BlockStartState;
+
+
+function BasicBlockStartState() {
+	BlockStartState.call(this);
+	this.stateType = ATNState.BLOCK_START;
+	return this;
+}
+
+BasicBlockStartState.prototype = Object.create(BlockStartState.prototype);
+BasicBlockStartState.prototype.constructor = BasicBlockStartState;
+
+
+// Terminal node of a simple {@code (a|b|c)} block.
+function BlockEndState() {
+	ATNState.call(this);
+	this.stateType = ATNState.BLOCK_END;
+    this.startState = null;
+    return this;
+}
+
+BlockEndState.prototype = Object.create(ATNState.prototype);
+BlockEndState.prototype.constructor = BlockEndState;
+
+
+// The last node in the ATN for a rule, unless that rule is the start symbol.
+//  In that case, there is one transition to EOF. Later, we might encode
+//  references to all calls to this rule to compute FOLLOW sets for
+//  error handling.
+//
+function RuleStopState() {
+	ATNState.call(this);
+    this.stateType = ATNState.RULE_STOP;
+    return this;
+}
+
+RuleStopState.prototype = Object.create(ATNState.prototype);
+RuleStopState.prototype.constructor = RuleStopState;
+
+function RuleStartState() {
+	ATNState.call(this);
+	this.stateType = ATNState.RULE_START;
+	this.stopState = null;
+	this.isPrecedenceRule = false;
+	return this;
+}
+
+RuleStartState.prototype = Object.create(ATNState.prototype);
+RuleStartState.prototype.constructor = RuleStartState;
+
+// Decision state for {@code A+} and {@code (A|B)+}.  It has two transitions:
+//  one to the loop back to start of the block and one to exit.
+//
+function PlusLoopbackState() {
+	DecisionState.call(this);
+	this.stateType = ATNState.PLUS_LOOP_BACK;
+	return this;
+}
+
+PlusLoopbackState.prototype = Object.create(DecisionState.prototype);
+PlusLoopbackState.prototype.constructor = PlusLoopbackState;
+        
+
+// Start of {@code (A|B|...)+} loop. Technically a decision state, but
+//  we don't use for code generation; somebody might need it, so I'm defining
+//  it for completeness. In reality, the {@link PlusLoopbackState} node is the
+//  real decision-making note for {@code A+}.
+//
+function PlusBlockStartState() {
+	BlockStartState.call(this);
+	this.stateType = ATNState.PLUS_BLOCK_START;
+    this.loopBackState = null;
+    return this;
+}
+
+PlusBlockStartState.prototype = Object.create(BlockStartState.prototype);
+PlusBlockStartState.prototype.constructor = PlusBlockStartState;
+
+// The block that begins a closure loop.
+function StarBlockStartState() {
+	BlockStartState.call(this);
+	this.stateType = ATNState.STAR_BLOCK_START;
+	return this;
+}
+
+StarBlockStartState.prototype = Object.create(BlockStartState.prototype);
+StarBlockStartState.prototype.constructor = StarBlockStartState;
+
+
+function StarLoopbackState() {
+	ATNState.call(this);
+	this.stateType = ATNState.STAR_LOOP_BACK;
+	return this;
+}
+
+StarLoopbackState.prototype = Object.create(ATNState.prototype);
+StarLoopbackState.prototype.constructor = StarLoopbackState;
+
+
+function StarLoopEntryState() {
+	DecisionState.call(this);
+	this.stateType = ATNState.STAR_LOOP_ENTRY;
+    this.loopBackState = null;
+    // Indicates whether this state can benefit from a precedence DFA during SLL decision making.
+    this.precedenceRuleDecision = null;
+    return this;
+}
+
+StarLoopEntryState.prototype = Object.create(DecisionState.prototype);
+StarLoopEntryState.prototype.constructor = StarLoopEntryState;
+
+
+// Mark the end of a * or + loop.
+function LoopEndState() {
+	ATNState.call(this);
+	this.stateType = ATNState.LOOP_END;
+	this.loopBackState = null;
+	return this;
+}
+
+LoopEndState.prototype = Object.create(ATNState.prototype);
+LoopEndState.prototype.constructor = LoopEndState;
+
+
+// The Tokens rule start state linking to each lexer rule start state */
+function TokensStartState() {
+	DecisionState.call(this);
+	this.stateType = ATNState.TOKEN_START;
+	return this;
+}
+
+TokensStartState.prototype = Object.create(DecisionState.prototype);
+TokensStartState.prototype.constructor = TokensStartState;
+
+exports.ATNState = ATNState;
+exports.BasicState = BasicState;
+exports.DecisionState = DecisionState;
+exports.BlockStartState = BlockStartState;
+exports.BlockEndState = BlockEndState;
+exports.LoopEndState = LoopEndState;
+exports.RuleStartState = RuleStartState;
+exports.RuleStopState = RuleStopState;
+exports.TokensStartState = TokensStartState;
+exports.PlusLoopbackState = PlusLoopbackState;
+exports.StarLoopbackState = StarLoopbackState;
+exports.StarLoopEntryState = StarLoopEntryState;
+exports.PlusBlockStartState = PlusBlockStartState;
+exports.StarBlockStartState = StarBlockStartState;
+exports.BasicBlockStartState = BasicBlockStartState;
diff --git a/runtime/JavaScript/src/antlr4/atn/ATNType.js b/runtime/JavaScript/src/antlr4/atn/ATNType.js
new file mode 100644
index 000000000..011245a0e
--- /dev/null
+++ b/runtime/JavaScript/src/antlr4/atn/ATNType.js
@@ -0,0 +1,41 @@
+// [The "BSD license"]
+//  Copyright (c) 2013 Terence Parr
+//  Copyright (c) 2013 Sam Harwell
+//  Copyright (c) 2014 Eric Vergnaud
+//  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.
+///
+
+// Represents the type of recognizer an ATN applies to.
+
+function ATNType() {
+	
+}
+
+ATNType.LEXER = 0;
+ATNType.PARSER = 1;
+
+exports.ATNType = ATNType;
+
diff --git a/runtime/JavaScript/src/antlr4/atn/LexerATNSimulator.js b/runtime/JavaScript/src/antlr4/atn/LexerATNSimulator.js
new file mode 100644
index 000000000..4e27c29cd
--- /dev/null
+++ b/runtime/JavaScript/src/antlr4/atn/LexerATNSimulator.js
@@ -0,0 +1,661 @@
+//
+// [The "BSD license"]
+//  Copyright (c) 2012 Terence Parr
+//  Copyright (c) 2012 Sam Harwell
+//  Copyright (c) 2014 Eric Vergnaud
+//  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.
+///
+
+// When we hit an accept state in either the DFA or the ATN, we
+//  have to notify the character stream to start buffering characters
+//  via {@link IntStream//mark} and record the current state. The current sim state
+//  includes the current index into the input, the current line,
+//  and current character position in that line. Note that the Lexer is
+//  tracking the starting line and characterization of the token. These
+//  variables track the "state" of the simulator when it hits an accept state.
+//
+//  <p>We track these variables separately for the DFA and ATN simulation
+//  because the DFA simulation often has to fail over to the ATN
+//  simulation. If the ATN simulation fails, we need the DFA to fall
+//  back to its previously accepted state, if any. If the ATN succeeds,
+//  then the ATN does the accept and the DFA simulator that invoked it
+//  can simply return the predicted token type.</p>
+///
+
+var Token = require('./../Token').Token;
+var Lexer = require('./../Lexer').Lexer;
+var ATN = require('./ATN').ATN;
+var ATNSimulator = require('./ATNSimulator').ATNSimulator;
+var DFAState = require('./../dfa/DFAState').DFAState;
+var ATNConfigSet = require('./ATNConfigSet').ATNConfigSet;
+var OrderedATNConfigSet = require('./ATNConfigSet').OrderedATNConfigSet;
+var PredictionContext = require('./../PredictionContext').PredictionContext;
+var SingletonPredictionContext = require('./../PredictionContext').SingletonPredictionContext;
+var RuleStopState = require('./ATNState').RuleStopState;
+var LexerATNConfig = require('./ATNConfig').LexerATNConfig;
+var Transition = require('./Transition').Transition;
+var LexerActionExecutor = require('./LexerActionExecutor').LexerActionExecutor;
+var LexerNoViableAltException = require('./../error/Errors').LexerNoViableAltException;
+
+function resetSimState(sim) {
+	sim.index = -1;
+	sim.line = 0;
+	sim.column = -1;
+	sim.dfaState = null;
+}
+
+function SimState() {
+	resetSimState(this);
+	return this;
+}
+
+SimState.prototype.reset = function() {
+	resetSimState(this);
+};
+
+function LexerATNSimulator(recog, atn, decisionToDFA, sharedContextCache) {
+	ATNSimulator.call(this, atn, sharedContextCache);
+	this.decisionToDFA = decisionToDFA;
+	this.recog = recog;
+	// The current token's starting index into the character stream.
+	// Shared across DFA to ATN simulation in case the ATN fails and the
+	// DFA did not have a previous accept state. In this case, we use the
+	// ATN-generated exception object.
+	this.startIndex = -1;
+	// line number 1..n within the input///
+	this.line = 1;
+	// The index of the character relative to the beginning of the line
+	// 0..n-1///
+	this.column = 0;
+	this.mode = Lexer.DEFAULT_MODE;
+	// Used during DFA/ATN exec to record the most recent accept configuration
+	// info
+	this.prevAccept = new SimState();
+	// done
+	return this;
+}
+
+LexerATNSimulator.prototype = Object.create(ATNSimulator.prototype);
+LexerATNSimulator.prototype.constructor = LexerATNSimulator;
+
+LexerATNSimulator.debug = false;
+LexerATNSimulator.dfa_debug = false;
+
+LexerATNSimulator.MIN_DFA_EDGE = 0;
+LexerATNSimulator.MAX_DFA_EDGE = 127; // forces unicode to stay in ATN
+
+LexerATNSimulator.match_calls = 0;
+
+LexerATNSimulator.prototype.copyState = function(simulator) {
+	this.column = simulator.column;
+	this.line = simulator.line;
+	this.mode = simulator.mode;
+	this.startIndex = simulator.startIndex;
+};
+
+LexerATNSimulator.prototype.match = function(input, mode) {
+	this.match_calls += 1;
+	this.mode = mode;
+	var mark = input.mark();
+	try {
+		this.startIndex = input.index;
+		this.prevAccept.reset();
+		var dfa = this.decisionToDFA[mode];
+		if (dfa.s0 === null) {
+			return this.matchATN(input);
+		} else {
+			return this.execATN(input, dfa.s0);
+		}
+	} finally {
+		input.release(mark);
+	}
+};
+
+LexerATNSimulator.prototype.reset = function() {
+	this.prevAccept.reset();
+	this.startIndex = -1;
+	this.line = 1;
+	this.column = 0;
+	this.mode = Lexer.DEFAULT_MODE;
+};
+
+LexerATNSimulator.prototype.matchATN = function(input) {
+	var startState = this.atn.modeToStartState[this.mode];
+
+	if (this.debug) {
+		console.log("matchATN mode " + this.mode + " start: " + startState);
+	}
+	var old_mode = this.mode;
+	var s0_closure = this.computeStartState(input, startState);
+	var suppressEdge = s0_closure.hasSemanticContext;
+	s0_closure.hasSemanticContext = false;
+
+	var next = this.addDFAState(s0_closure);
+	if (!suppressEdge) {
+		this.decisionToDFA[this.mode].s0 = next;
+	}
+
+	var predict = this.execATN(input, next);
+
+	if (this.debug) {
+		console.log("DFA after matchATN: " + this.decisionToDFA[old_mode].toLexerString());
+	}
+	return predict;
+};
+
+LexerATNSimulator.prototype.execATN = function(input, ds0) {
+	if (this.debug) {
+		console.log("start state closure=" + ds0.configs);
+	}
+	if (ds0.isAcceptState) {
+		// allow zero-length tokens
+		this.captureSimState(this.prevAccept, input, ds0);
+	}
+	var t = input.LA(1);
+	var s = ds0; // s is current/from DFA state
+
+	while (true) { // while more work
+		if (this.debug) {
+			console.log("execATN loop starting closure: " + s.configs);
+		}
+
+		// As we move src->trg, src->trg, we keep track of the previous trg to
+		// avoid looking up the DFA state again, which is expensive.
+		// If the previous target was already part of the DFA, we might
+		// be able to avoid doing a reach operation upon t. If s!=null,
+		// it means that semantic predicates didn't prevent us from
+		// creating a DFA state. Once we know s!=null, we check to see if
+		// the DFA state has an edge already for t. If so, we can just reuse
+		// it's configuration set; there's no point in re-computing it.
+		// This is kind of like doing DFA simulation within the ATN
+		// simulation because DFA simulation is really just a way to avoid
+		// computing reach/closure sets. Technically, once we know that
+		// we have a previously added DFA state, we could jump over to
+		// the DFA simulator. But, that would mean popping back and forth
+		// a lot and making things more complicated algorithmically.
+		// This optimization makes a lot of sense for loops within DFA.
+		// A character will take us back to an existing DFA state
+		// that already has lots of edges out of it. e.g., .* in comments.
+		// print("Target for:" + str(s) + " and:" + str(t))
+		var target = this.getExistingTargetState(s, t);
+		// print("Existing:" + str(target))
+		if (target === null) {
+			target = this.computeTargetState(input, s, t);
+			// print("Computed:" + str(target))
+		}
+		if (target === ATNSimulator.ERROR) {
+			break;
+		}
+		// If this is a consumable input element, make sure to consume before
+		// capturing the accept state so the input index, line, and char
+		// position accurately reflect the state of the interpreter at the
+		// end of the token.
+		if (t !== Token.EOF) {
+			this.consume(input);
+		}
+		if (target.isAcceptState) {
+			this.captureSimState(this.prevAccept, input, target);
+			if (t === Token.EOF) {
+				break;
+			}
+		}
+		t = input.LA(1);
+		s = target; // flip; current DFA target becomes new src/from state
+	}
+	return this.failOrAccept(this.prevAccept, input, s.configs, t);
+};
+
+// Get an existing target state for an edge in the DFA. If the target state
+// for the edge has not yet been computed or is otherwise not available,
+// this method returns {@code null}.
+//
+// @param s The current DFA state
+// @param t The next input symbol
+// @return The existing target DFA state for the given input symbol
+// {@code t}, or {@code null} if the target state for this edge is not
+// already cached
+LexerATNSimulator.prototype.getExistingTargetState = function(s, t) {
+	if (s.edges === null || t < LexerATNSimulator.MIN_DFA_EDGE || t > LexerATNSimulator.MAX_DFA_EDGE) {
+		return null;
+	}
+
+	var target = s.edges[t - LexerATNSimulator.MIN_DFA_EDGE];
+	if(target===undefined) {
+		target = null;
+	}
+	if (this.debug && target !== null) {
+		console.log("reuse state " + s.stateNumber + " edge to " + target.stateNumber);
+	}
+	return target;
+};
+
+// Compute a target state for an edge in the DFA, and attempt to add the
+// computed state and corresponding edge to the DFA.
+//
+// @param input The input stream
+// @param s The current DFA state
+// @param t The next input symbol
+//
+// @return The computed target DFA state for the given input symbol
+// {@code t}. If {@code t} does not lead to a valid DFA state, this method
+// returns {@link //ERROR}.
+LexerATNSimulator.prototype.computeTargetState = function(input, s, t) {
+	var reach = new OrderedATNConfigSet();
+	// if we don't find an existing DFA state
+	// Fill reach starting from closure, following t transitions
+	this.getReachableConfigSet(input, s.configs, reach, t);
+
+	if (reach.items.length === 0) { // we got nowhere on t from s
+		if (!reach.hasSemanticContext) {
+			// we got nowhere on t, don't throw out this knowledge; it'd
+			// cause a failover from DFA later.
+			this.addDFAEdge(s, t, ATNSimulator.ERROR);
+		}
+		// stop when we can't match any more char
+		return ATNSimulator.ERROR;
+	}
+	// Add an edge from s to target DFA found/created for reach
+	return this.addDFAEdge(s, t, null, reach);
+};
+
+LexerATNSimulator.prototype.failOrAccept = function(prevAccept, input, reach, t) {
+	if (this.prevAccept.dfaState !== null) {
+		var lexerActionExecutor = prevAccept.dfaState.lexerActionExecutor;
+		this.accept(input, lexerActionExecutor, this.startIndex,
+				prevAccept.index, prevAccept.line, prevAccept.column);
+		return prevAccept.dfaState.prediction;
+	} else {
+		// if no accept and EOF is first char, return EOF
+		if (t === Token.EOF && input.index === this.startIndex) {
+			return Token.EOF;
+		}
+		throw new LexerNoViableAltException(this.recog, input, this.startIndex, reach);
+	}
+};
+
+// Given a starting configuration set, figure out all ATN configurations
+// we can reach upon input {@code t}. Parameter {@code reach} is a return
+// parameter.
+LexerATNSimulator.prototype.getReachableConfigSet = function(input, closure,
+		reach, t) {
+	// this is used to skip processing for configs which have a lower priority
+	// than a config that already reached an accept state for the same rule
+	var skipAlt = ATN.INVALID_ALT_NUMBER;
+	for (var i = 0; i < closure.items.length; i++) {
+		var cfg = closure.items[i];
+		var currentAltReachedAcceptState = (cfg.alt === skipAlt);
+		if (currentAltReachedAcceptState && cfg.passedThroughNonGreedyDecision) {
+			continue;
+		}
+		if (this.debug) {
+			console.log("testing %s at %s\n", this.getTokenName(t), cfg
+					.toString(this.recog, true));
+		}
+		for (var j = 0; j < cfg.state.transitions.length; j++) {
+			var trans = cfg.state.transitions[j]; // for each transition
+			var target = this.getReachableTarget(trans, t);
+			if (target !== null) {
+				var lexerActionExecutor = cfg.lexerActionExecutor;
+				if (lexerActionExecutor !== null) {
+					lexerActionExecutor = lexerActionExecutor.fixOffsetBeforeMatch(input.index - this.startIndex);
+				}
+				var treatEofAsEpsilon = (t === Token.EOF);
+				var config = new LexerATNConfig({state:target, lexerActionExecutor:lexerActionExecutor}, cfg);
+				if (this.closure(input, config, reach,
+						currentAltReachedAcceptState, true, treatEofAsEpsilon)) {
+					// any remaining configs for this alt have a lower priority
+					// than the one that just reached an accept state.
+					skipAlt = cfg.alt;
+				}
+			}
+		}
+	}
+};
+
+LexerATNSimulator.prototype.accept = function(input, lexerActionExecutor,
+		startIndex, index, line, charPos) {
+	if (this.debug) {
+		console.log("ACTION %s\n", lexerActionExecutor);
+	}
+	// seek to after last char in token
+	input.seek(index);
+	this.line = line;
+	this.column = charPos;
+	if (lexerActionExecutor !== null && this.recog !== null) {
+		lexerActionExecutor.execute(this.recog, input, startIndex);
+	}
+};
+
+LexerATNSimulator.prototype.getReachableTarget = function(trans, t) {
+	if (trans.matches(t, 0, 0xFFFE)) {
+		return trans.target;
+	} else {
+		return null;
+	}
+};
+
+LexerATNSimulator.prototype.computeStartState = function(input, p) {
+	var initialContext = PredictionContext.EMPTY;
+	var configs = new OrderedATNConfigSet();
+	for (var i = 0; i < p.transitions.length; i++) {
+		var target = p.transitions[i].target;
+        var cfg = new LexerATNConfig({state:target, alt:i+1, context:initialContext}, null);
+		this.closure(input, cfg, configs, false, false, false);
+	}
+	return configs;
+};
+
+// Since the alternatives within any lexer decision are ordered by
+// preference, this method stops pursuing the closure as soon as an accept
+// state is reached. After the first accept state is reached by depth-first
+// search from {@code config}, all other (potentially reachable) states for
+// this rule would have a lower priority.
+//
+// @return {@code true} if an accept state is reached, otherwise
+// {@code false}.
+LexerATNSimulator.prototype.closure = function(input, config, configs,
+		currentAltReachedAcceptState, speculative, treatEofAsEpsilon) {
+	var cfg = null;
+	if (this.debug) {
+		console.log("closure(" + config.toString(this.recog, true) + ")");
+	}
+	if (config.state instanceof RuleStopState) {
+		if (this.debug) {
+			if (this.recog !== null) {
+				console.log("closure at %s rule stop %s\n", this.recog.getRuleNames()[config.state.ruleIndex], config);
+			} else {
+				console.log("closure at rule stop %s\n", config);
+			}
+		}
+		if (config.context === null || config.context.hasEmptyPath()) {
+			if (config.context === null || config.context.isEmpty()) {
+				configs.add(config);
+				return true;
+			} else {
+				configs.add(new LexerATNConfig({ state:config.state, context:PredictionContext.EMPTY}, config));
+				currentAltReachedAcceptState = true;
+			}
+		}
+		if (config.context !== null && !config.context.isEmpty()) {
+			for (var i = 0; i < config.context.length; i++) {
+				if (config.context.getReturnState(i) !== PredictionContext.EMPTY_RETURN_STATE) {
+					var newContext = config.context.getParent(i); // "pop" return state
+					var returnState = this.atn.states[config.context.getReturnState(i)];
+					cfg = new LexerATNConfig({ state:returnState, context:newContext }, config);
+					currentAltReachedAcceptState = this.closure(input, cfg,
+							configs, currentAltReachedAcceptState, speculative,
+							treatEofAsEpsilon);
+				}
+			}
+		}
+		return currentAltReachedAcceptState;
+	}
+	// optimization
+	if (!config.state.epsilonOnlyTransitions) {
+		if (!currentAltReachedAcceptState || !config.passedThroughNonGreedyDecision) {
+			configs.add(config);
+		}
+	}
+	for (var j = 0; j < config.state.transitions.length; j++) {
+		var trans = config.state.transitions[j];
+		cfg = this.getEpsilonTarget(input, config, trans, configs, speculative, treatEofAsEpsilon);
+		if (cfg !== null) {
+			currentAltReachedAcceptState = this.closure(input, cfg, configs,
+					currentAltReachedAcceptState, speculative, treatEofAsEpsilon);
+		}
+	}
+	return currentAltReachedAcceptState;
+};
+
+// side-effect: can alter configs.hasSemanticContext
+LexerATNSimulator.prototype.getEpsilonTarget = function(input, config, trans,
+		configs, speculative, treatEofAsEpsilon) {
+	var cfg = null;
+	if (trans.serializationType === Transition.RULE) {
+		var newContext = SingletonPredictionContext.create(config.context, trans.followState.stateNumber);
+		cfg = new LexerATNConfig( { state:trans.target, context:newContext}, config);
+	} else if (trans.serializationType === Transition.PRECEDENCE) {
+		throw "Precedence predicates are not supported in lexers.";
+	} else if (trans.serializationType === Transition.PREDICATE) {
+		// Track traversing semantic predicates. If we traverse,
+		// we cannot add a DFA state for this "reach" computation
+		// because the DFA would not test the predicate again in the
+		// future. Rather than creating collections of semantic predicates
+		// like v3 and testing them on prediction, v4 will test them on the
+		// fly all the time using the ATN not the DFA. This is slower but
+		// semantically it's not used that often. One of the key elements to
+		// this predicate mechanism is not adding DFA states that see
+		// predicates immediately afterwards in the ATN. For example,
+
+		// a : ID {p1}? | ID {p2}? ;
+
+		// should create the start state for rule 'a' (to save start state
+		// competition), but should not create target of ID state. The
+		// collection of ATN states the following ID references includes
+		// states reached by traversing predicates. Since this is when we
+		// test them, we cannot cash the DFA state target of ID.
+
+		if (this.debug) {
+			console.log("EVAL rule " + trans.ruleIndex + ":" + trans.predIndex);
+		}
+		configs.hasSemanticContext = true;
+		if (this.evaluatePredicate(input, trans.ruleIndex, trans.predIndex, speculative)) {
+			cfg = new LexerATNConfig({ state:trans.target}, config);
+		}
+	} else if (trans.serializationType === Transition.ACTION) {
+		if (config.context === null || config.context.hasEmptyPath()) {
+			// execute actions anywhere in the start rule for a token.
+			//
+			// TODO: if the entry rule is invoked recursively, some
+			// actions may be executed during the recursive call. The
+			// problem can appear when hasEmptyPath() is true but
+			// isEmpty() is false. In this case, the config needs to be
+			// split into two contexts - one with just the empty path
+			// and another with everything but the empty path.
+			// Unfortunately, the current algorithm does not allow
+			// getEpsilonTarget to return two configurations, so
+			// additional modifications are needed before we can support
+			// the split operation.
+			var lexerActionExecutor = LexerActionExecutor.append(config.lexerActionExecutor,
+					this.atn.lexerActions[trans.actionIndex]);
+			cfg = new LexerATNConfig({ state:trans.target, lexerActionExecutor:lexerActionExecutor }, config);
+		} else {
+			// ignore actions in referenced rules
+			cfg = new LexerATNConfig( { state:trans.target}, config);
+		}
+	} else if (trans.serializationType === Transition.EPSILON) {
+		cfg = new LexerATNConfig({ state:trans.target}, config);
+	} else if (trans.serializationType === Transition.ATOM ||
+				trans.serializationType === Transition.RANGE ||
+				trans.serializationType === Transition.SET) {
+		if (treatEofAsEpsilon) {
+			if (trans.matches(Token.EOF, 0, 0xFFFF)) {
+				cfg = new LexerATNConfig( { state:trans.target }, config);
+			}
+		}
+	}
+	return cfg;
+};
+
+// Evaluate a predicate specified in the lexer.
+//
+// <p>If {@code speculative} is {@code true}, this method was called before
+// {@link //consume} for the matched character. This method should call
+// {@link //consume} before evaluating the predicate to ensure position
+// sensitive values, including {@link Lexer//getText}, {@link Lexer//getLine},
+// and {@link Lexer//getcolumn}, properly reflect the current
+// lexer state. This method should restore {@code input} and the simulator
+// to the original state before returning (i.e. undo the actions made by the
+// call to {@link //consume}.</p>
+//
+// @param input The input stream.
+// @param ruleIndex The rule containing the predicate.
+// @param predIndex The index of the predicate within the rule.
+// @param speculative {@code true} if the current index in {@code input} is
+// one character before the predicate's location.
+//
+// @return {@code true} if the specified predicate evaluates to
+// {@code true}.
+// /
+LexerATNSimulator.prototype.evaluatePredicate = function(input, ruleIndex,
+		predIndex, speculative) {
+	// assume true if no recognizer was provided
+	if (this.recog === null) {
+		return true;
+	}
+	if (!speculative) {
+		return this.recog.sempred(null, ruleIndex, predIndex);
+	}
+	var savedcolumn = this.column;
+	var savedLine = this.line;
+	var index = input.index;
+	var marker = input.mark();
+	try {
+		this.consume(input);
+		return this.recog.sempred(null, ruleIndex, predIndex);
+	} finally {
+		this.column = savedcolumn;
+		this.line = savedLine;
+		input.seek(index);
+		input.release(marker);
+	}
+};
+
+LexerATNSimulator.prototype.captureSimState = function(settings, input, dfaState) {
+	settings.index = input.index;
+	settings.line = this.line;
+	settings.column = this.column;
+	settings.dfaState = dfaState;
+};
+
+LexerATNSimulator.prototype.addDFAEdge = function(from_, tk, to, cfgs) {
+	if (to === undefined) {
+		to = null;
+	}
+	if (cfgs === undefined) {
+		cfgs = null;
+	}
+	if (to === null && cfgs !== null) {
+		// leading to this call, ATNConfigSet.hasSemanticContext is used as a
+		// marker indicating dynamic predicate evaluation makes this edge
+		// dependent on the specific input sequence, so the static edge in the
+		// DFA should be omitted. The target DFAState is still created since
+		// execATN has the ability to resynchronize with the DFA state cache
+		// following the predicate evaluation step.
+		//
+		// TJP notes: next time through the DFA, we see a pred again and eval.
+		// If that gets us to a previously created (but dangling) DFA
+		// state, we can continue in pure DFA mode from there.
+		// /
+		var suppressEdge = cfgs.hasSemanticContext;
+		cfgs.hasSemanticContext = false;
+
+		to = this.addDFAState(cfgs);
+
+		if (suppressEdge) {
+			return to;
+		}
+	}
+	// add the edge
+	if (tk < LexerATNSimulator.MIN_DFA_EDGE || tk > LexerATNSimulator.MAX_DFA_EDGE) {
+		// Only track edges within the DFA bounds
+		return to;
+	}
+	if (this.debug) {
+		console.log("EDGE " + from_ + " -> " + to + " upon " + tk);
+	}
+	if (from_.edges === null) {
+		// make room for tokens 1..n and -1 masquerading as index 0
+		from_.edges = [];
+	}
+	from_.edges[tk - LexerATNSimulator.MIN_DFA_EDGE] = to; // connect
+
+	return to;
+};
+
+// Add a new DFA state if there isn't one with this set of
+// configurations already. This method also detects the first
+// configuration containing an ATN rule stop state. Later, when
+// traversing the DFA, we will know which rule to accept.
+LexerATNSimulator.prototype.addDFAState = function(configs) {
+	var proposed = new DFAState(null, configs);
+	var firstConfigWithRuleStopState = null;
+	for (var i = 0; i < configs.items.length; i++) {
+		var cfg = configs.items[i];
+		if (cfg.state instanceof RuleStopState) {
+			firstConfigWithRuleStopState = cfg;
+			break;
+		}
+	}
+	if (firstConfigWithRuleStopState !== null) {
+		proposed.isAcceptState = true;
+		proposed.lexerActionExecutor = firstConfigWithRuleStopState.lexerActionExecutor;
+		proposed.prediction = this.atn.ruleToTokenType[firstConfigWithRuleStopState.state.ruleIndex];
+	}
+	var hash = proposed.hashString();
+	var dfa = this.decisionToDFA[this.mode];
+	var existing = dfa.states[hash] || null;
+	if (existing!==null) {
+		return existing;
+	}
+	var newState = proposed;
+	newState.stateNumber = dfa.states.length;
+	configs.setReadonly(true);
+	newState.configs = configs;
+	dfa.states[hash] = newState;
+	return newState;
+};
+
+LexerATNSimulator.prototype.getDFA = function(mode) {
+	return this.decisionToDFA[mode];
+};
+
+// Get the text matched so far for the current token.
+LexerATNSimulator.prototype.getText = function(input) {
+	// index is first lookahead char, don't include.
+	return input.getText(this.startIndex, input.index - 1);
+};
+
+LexerATNSimulator.prototype.consume = function(input) {
+	var curChar = input.LA(1);
+	if (curChar === "\n".charCodeAt(0)) {
+		this.line += 1;
+		this.column = 0;
+	} else {
+		this.column += 1;
+	}
+	input.consume();
+};
+
+LexerATNSimulator.prototype.getTokenName = function(tt) {
+	if (tt === -1) {
+		return "EOF";
+	} else {
+		return "'" + String.fromCharCode(tt) + "'";
+	}
+};
+
+exports.LexerATNSimulator = LexerATNSimulator;
diff --git a/runtime/JavaScript/src/antlr4/atn/LexerAction.js b/runtime/JavaScript/src/antlr4/atn/LexerAction.js
new file mode 100644
index 000000000..e4a070fd0
--- /dev/null
+++ b/runtime/JavaScript/src/antlr4/atn/LexerAction.js
@@ -0,0 +1,384 @@
+//
+ //[The "BSD license"]
+ // Copyright (c) 2013 Terence Parr
+ // Copyright (c) 2013 Sam Harwell
+ // Copyright (c) 2014 Eric Vergnaud
+ // 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.
+ //
+
+function LexerActionType() {
+}
+
+LexerActionType.CHANNEL = 0;     //The type of a {@link LexerChannelAction} action.
+LexerActionType.CUSTOM = 1;      //The type of a {@link LexerCustomAction} action.
+LexerActionType.MODE = 2;        //The type of a {@link LexerModeAction} action.
+LexerActionType.MORE = 3;        //The type of a {@link LexerMoreAction} action.
+LexerActionType.POP_MODE = 4;    //The type of a {@link LexerPopModeAction} action.
+LexerActionType.PUSH_MODE = 5;   //The type of a {@link LexerPushModeAction} action.
+LexerActionType.SKIP = 6;        //The type of a {@link LexerSkipAction} action.
+LexerActionType.TYPE = 7;        //The type of a {@link LexerTypeAction} action.
+
+function LexerAction(action) {
+    this.actionType = action;
+    this.isPositionDependent = false;
+    return this;
+}
+
+LexerAction.prototype.hashString = function() {
+    return "" + this.actionType;
+};
+
+LexerAction.prototype.equals = function(other) {
+    return this === other;
+};
+
+
+
+//
+// Implements the {@code skip} lexer action by calling {@link Lexer//skip}.
+//
+// <p>The {@code skip} command does not have any parameters, so this action is
+// implemented as a singleton instance exposed by {@link //INSTANCE}.</p>
+function LexerSkipAction() {
+	LexerAction.call(this, LexerActionType.SKIP);
+	return this;
+}
+
+LexerSkipAction.prototype = Object.create(LexerAction.prototype);
+LexerSkipAction.prototype.constructor = LexerSkipAction;
+
+// Provides a singleton instance of this parameterless lexer action.
+LexerSkipAction.INSTANCE = new LexerSkipAction();
+
+LexerSkipAction.prototype.execute = function(lexer) {
+    lexer.skip();
+};
+
+LexerSkipAction.prototype.toString = function() {
+	return "skip";
+};
+
+//  Implements the {@code type} lexer action by calling {@link Lexer//setType}
+// with the assigned type.
+function LexerTypeAction(type) {
+	LexerAction.call(this, LexerActionType.TYPE);
+	this.type = type;
+	return this;
+}
+
+LexerTypeAction.prototype = Object.create(LexerAction.prototype);
+LexerTypeAction.prototype.constructor = LexerTypeAction;
+
+LexerTypeAction.prototype.execute = function(lexer) {
+    lexer.type = this.type;
+};
+
+LexerTypeAction.prototype.hashString = function() {
+	return "" + this.actionType + this.type;
+};
+
+
+LexerTypeAction.prototype.equals = function(other) {
+    if(this === other) {
+        return true;
+    } else if (! (other instanceof LexerTypeAction)) {
+        return false;
+    } else {
+        return this.type === other.type;
+    }
+};
+
+LexerTypeAction.prototype.toString = function() {
+    return "type(" + this.type + ")";
+};
+
+// Implements the {@code pushMode} lexer action by calling
+// {@link Lexer//pushMode} with the assigned mode.
+function LexerPushModeAction(mode) {
+	LexerAction.call(this, LexerActionType.PUSH_MODE);
+    this.mode = mode;
+    return this;
+}
+
+LexerPushModeAction.prototype = Object.create(LexerAction.prototype);
+LexerPushModeAction.prototype.constructor = LexerPushModeAction;
+
+// <p>This action is implemented by calling {@link Lexer//pushMode} with the
+// value provided by {@link //getMode}.</p>
+LexerPushModeAction.prototype.execute = function(lexer) {
+    lexer.pushMode(this.mode);
+};
+
+LexerPushModeAction.prototype.hashString = function() {
+    return "" + this.actionType + this.mode;
+};
+
+LexerPushModeAction.prototype.equals = function(other) {
+    if (this === other) {
+        return true;
+    } else if (! (other instanceof LexerPushModeAction)) {
+        return false;
+    } else {
+        return this.mode === other.mode;
+    }
+};
+
+LexerPushModeAction.prototype.toString = function() {
+	return "pushMode(" + this.mode + ")";
+};
+
+
+// Implements the {@code popMode} lexer action by calling {@link Lexer//popMode}.
+//
+// <p>The {@code popMode} command does not have any parameters, so this action is
+// implemented as a singleton instance exposed by {@link //INSTANCE}.</p>
+function LexerPopModeAction() {
+	LexerAction.call(this,LexerActionType.POP_MODE);
+	return this;
+}
+
+LexerPopModeAction.prototype = Object.create(LexerAction.prototype);
+LexerPopModeAction.prototype.constructor = LexerPopModeAction;
+
+LexerPopModeAction.INSTANCE = new LexerPopModeAction();
+
+// <p>This action is implemented by calling {@link Lexer//popMode}.</p>
+LexerPopModeAction.prototype.execute = function(lexer) {
+    lexer.popMode();
+};
+
+LexerPopModeAction.prototype.toString = function() {
+	return "popMode";
+};
+
+// Implements the {@code more} lexer action by calling {@link Lexer//more}.
+//
+// <p>The {@code more} command does not have any parameters, so this action is
+// implemented as a singleton instance exposed by {@link //INSTANCE}.</p>
+function LexerMoreAction() {
+	LexerAction.call(this, LexerActionType.MORE);
+	return this;
+}
+
+LexerMoreAction.prototype = Object.create(LexerAction.prototype);
+LexerMoreAction.prototype.constructor = LexerMoreAction;
+
+LexerMoreAction.INSTANCE = new LexerMoreAction();
+
+// <p>This action is implemented by calling {@link Lexer//popMode}.</p>
+LexerMoreAction.prototype.execute = function(lexer) {
+    lexer.more();
+};
+
+LexerMoreAction.prototype.toString = function() {
+    return "more";
+};
+
+
+// Implements the {@code mode} lexer action by calling {@link Lexer//mode} with
+// the assigned mode.
+function LexerModeAction(mode) {
+	LexerAction.call(this, LexerActionType.MODE);
+    this.mode = mode;
+    return this;
+}
+
+LexerModeAction.prototype = Object.create(LexerAction.prototype);
+LexerModeAction.prototype.constructor = LexerModeAction;
+
+// <p>This action is implemented by calling {@link Lexer//mode} with the
+// value provided by {@link //getMode}.</p>
+LexerModeAction.prototype.execute = function(lexer) {
+    lexer.mode(this.mode);
+};
+
+LexerModeAction.prototype.hashString = function() {
+	return "" + this.actionType + this.mode;
+};
+
+LexerModeAction.prototype.equals = function(other) {
+    if (this === other) {
+        return true;
+    } else if (! (other instanceof LexerModeAction)) {
+        return false;
+    } else {
+        return this.mode === other.mode;
+    }
+};
+
+LexerModeAction.prototype.toString = function() {
+    return "mode(" + this.mode + ")";
+};
+
+// Executes a custom lexer action by calling {@link Recognizer//action} with the
+// rule and action indexes assigned to the custom action. The implementation of
+// a custom action is added to the generated code for the lexer in an override
+// of {@link Recognizer//action} when the grammar is compiled.
+//
+// <p>This class may represent embedded actions created with the <code>{...}</code>
+// syntax in ANTLR 4, as well as actions created for lexer commands where the
+// command argument could not be evaluated when the grammar was compiled.</p>
+
+
+    // Constructs a custom lexer action with the specified rule and action
+    // indexes.
+    //
+    // @param ruleIndex The rule index to use for calls to
+    // {@link Recognizer//action}.
+    // @param actionIndex The action index to use for calls to
+    // {@link Recognizer//action}.
+
+function LexerCustomAction(ruleIndex, actionIndex) {
+	LexerAction.call(this, LexerActionType.CUSTOM);
+    this.ruleIndex = ruleIndex;
+    this.actionIndex = actionIndex;
+    this.isPositionDependent = true;
+    return this;
+}
+
+LexerCustomAction.prototype = Object.create(LexerAction.prototype);
+LexerCustomAction.prototype.constructor = LexerCustomAction;
+
+// <p>Custom actions are implemented by calling {@link Lexer//action} with the
+// appropriate rule and action indexes.</p>
+LexerCustomAction.prototype.execute = function(lexer) {
+    lexer.action(null, this.ruleIndex, this.actionIndex);
+};
+
+LexerCustomAction.prototype.hashString = function() {
+    return "" + this.actionType + this.ruleIndex + this.actionIndex;
+};
+
+LexerCustomAction.prototype.equals = function(other) {
+    if (this === other) {
+        return true;
+    } else if (! (other instanceof LexerCustomAction)) {
+        return false;
+    } else {
+        return this.ruleIndex === other.ruleIndex && this.actionIndex === other.actionIndex;
+    }
+};
+
+// Implements the {@code channel} lexer action by calling
+// {@link Lexer//setChannel} with the assigned channel.
+// Constructs a new {@code channel} action with the specified channel value.
+// @param channel The channel value to pass to {@link Lexer//setChannel}.
+function LexerChannelAction(channel) {
+	LexerAction.call(this, LexerActionType.CHANNEL);
+    this.channel = channel;
+    return this;
+}
+
+LexerChannelAction.prototype = Object.create(LexerAction.prototype);
+LexerChannelAction.prototype.constructor = LexerChannelAction;
+
+// <p>This action is implemented by calling {@link Lexer//setChannel} with the
+// value provided by {@link //getChannel}.</p>
+LexerChannelAction.prototype.execute = function(lexer) {
+    lexer._channel = this.channel;
+};
+
+LexerChannelAction.prototype.hashString = function() {
+    return "" + this.actionType + this.channel;
+};
+
+LexerChannelAction.prototype.equals = function(other) {
+    if (this === other) {
+        return true;
+    } else if (! (other instanceof LexerChannelAction)) {
+        return false;
+    } else {
+        return this.channel === other.channel;
+    }
+};
+
+LexerChannelAction.prototype.toString = function() {
+    return "channel(" + this.channel + ")";
+};
+
+// This implementation of {@link LexerAction} is used for tracking input offsets
+// for position-dependent actions within a {@link LexerActionExecutor}.
+//
+// <p>This action is not serialized as part of the ATN, and is only required for
+// position-dependent lexer actions which appear at a location other than the
+// end of a rule. For more information about DFA optimizations employed for
+// lexer actions, see {@link LexerActionExecutor//append} and
+// {@link LexerActionExecutor//fixOffsetBeforeMatch}.</p>
+
+// Constructs a new indexed custom action by associating a character offset
+// with a {@link LexerAction}.
+//
+// <p>Note: This class is only required for lexer actions for which
+// {@link LexerAction//isPositionDependent} returns {@code true}.</p>
+//
+// @param offset The offset into the input {@link CharStream}, relative to
+// the token start index, at which the specified lexer action should be
+// executed.
+// @param action The lexer action to execute at a particular offset in the
+// input {@link CharStream}.
+function LexerIndexedCustomAction(offset, action) {
+	LexerAction.call(this, action.actionType);
+    this.offset = offset;
+    this.action = action;
+    this.isPositionDependent = true;
+    return this;
+}
+
+LexerIndexedCustomAction.prototype = Object.create(LexerAction.prototype);
+LexerIndexedCustomAction.prototype.constructor = LexerIndexedCustomAction;
+
+// <p>This method calls {@link //execute} on the result of {@link //getAction}
+// using the provided {@code lexer}.</p>
+LexerIndexedCustomAction.prototype.execute = function(lexer) {
+    // assume the input stream position was properly set by the calling code
+    this.action.execute(lexer);
+};
+
+LexerIndexedCustomAction.prototype.hashString = function() {
+    return "" + this.actionType + this.offset + this.action;
+};
+
+LexerIndexedCustomAction.prototype.equals = function(other) {
+    if (this === other) {
+        return true;
+    } else if (! (other instanceof LexerIndexedCustomAction)) {
+        return false;
+    } else {
+        return this.offset === other.offset && this.action === other.action;
+    }
+};
+
+
+exports.LexerActionType = LexerActionType;
+exports.LexerSkipAction = LexerSkipAction;
+exports.LexerChannelAction = LexerChannelAction;
+exports.LexerCustomAction = LexerCustomAction;
+exports.LexerIndexedCustomAction = LexerIndexedCustomAction;
+exports.LexerMoreAction = LexerMoreAction;
+exports.LexerTypeAction = LexerTypeAction;
+exports.LexerPushModeAction = LexerPushModeAction;
+exports.LexerPopModeAction = LexerPopModeAction;
+exports.LexerModeAction = LexerModeAction;
\ No newline at end of file
diff --git a/runtime/JavaScript/src/antlr4/atn/LexerActionExecutor.js b/runtime/JavaScript/src/antlr4/atn/LexerActionExecutor.js
new file mode 100644
index 000000000..0ccea5815
--- /dev/null
+++ b/runtime/JavaScript/src/antlr4/atn/LexerActionExecutor.js
@@ -0,0 +1,184 @@
+//
+// [The "BSD license"]
+//  Copyright (c) 2013 Terence Parr
+//  Copyright (c) 2013 Sam Harwell
+//  Copyright (c) 2014 Eric Vergnaud
+//  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.
+///
+
+// Represents an executor for a sequence of lexer actions which traversed during
+// the matching operation of a lexer rule (token).
+//
+// <p>The executor tracks position information for position-dependent lexer actions
+// efficiently, ensuring that actions appearing only at the end of the rule do
+// not cause bloating of the {@link DFA} created for the lexer.</p>
+
+var LexerIndexedCustomAction = require('./LexerAction').LexerIndexedCustomAction;
+
+function LexerActionExecutor(lexerActions) {
+	this.lexerActions = lexerActions === null ? [] : lexerActions;
+	// Caches the result of {@link //hashCode} since the hash code is an element
+	// of the performance-critical {@link LexerATNConfig//hashCode} operation.
+	this._hashString = lexerActions.toString(); // "".join([str(la) for la in
+	// lexerActions]))
+	return this;
+}
+
+// Creates a {@link LexerActionExecutor} which executes the actions for
+// the input {@code lexerActionExecutor} followed by a specified
+// {@code lexerAction}.
+//
+// @param lexerActionExecutor The executor for actions already traversed by
+// the lexer while matching a token within a particular
+// {@link LexerATNConfig}. If this is {@code null}, the method behaves as
+// though it were an empty executor.
+// @param lexerAction The lexer action to execute after the actions
+// specified in {@code lexerActionExecutor}.
+//
+// @return A {@link LexerActionExecutor} for executing the combine actions
+// of {@code lexerActionExecutor} and {@code lexerAction}.
+LexerActionExecutor.append = function(lexerActionExecutor, lexerAction) {
+	if (lexerActionExecutor === null) {
+		return new LexerActionExecutor([ lexerAction ]);
+	}
+	var lexerActions = lexerActionExecutor.lexerActions.concat([ lexerAction ]);
+	return new LexerActionExecutor(lexerActions);
+};
+
+// Creates a {@link LexerActionExecutor} which encodes the current offset
+// for position-dependent lexer actions.
+//
+// <p>Normally, when the executor encounters lexer actions where
+// {@link LexerAction//isPositionDependent} returns {@code true}, it calls
+// {@link IntStream//seek} on the input {@link CharStream} to set the input
+// position to the <em>end</em> of the current token. This behavior provides
+// for efficient DFA representation of lexer actions which appear at the end
+// of a lexer rule, even when the lexer rule matches a variable number of
+// characters.</p>
+//
+// <p>Prior to traversing a match transition in the ATN, the current offset
+// from the token start index is assigned to all position-dependent lexer
+// actions which have not already been assigned a fixed offset. By storing
+// the offsets relative to the token start index, the DFA representation of
+// lexer actions which appear in the middle of tokens remains efficient due
+// to sharing among tokens of the same length, regardless of their absolute
+// position in the input stream.</p>
+//
+// <p>If the current executor already has offsets assigned to all
+// position-dependent lexer actions, the method returns {@code this}.</p>
+//
+// @param offset The current offset to assign to all position-dependent
+// lexer actions which do not already have offsets assigned.
+//
+// @return A {@link LexerActionExecutor} which stores input stream offsets
+// for all position-dependent lexer actions.
+// /
+LexerActionExecutor.prototype.fixOffsetBeforeMatch = function(offset) {
+	var updatedLexerActions = null;
+	for (var i = 0; i < this.lexerActions.length; i++) {
+		if (this.lexerActions[i].isPositionDependent &&
+				!(this.lexerActions[i] instanceof LexerIndexedCustomAction)) {
+			if (updatedLexerActions === null) {
+				updatedLexerActions = this.lexerActions.concat([]);
+			}
+			updatedLexerActions[i] = new LexerIndexedCustomAction(offset,
+					this.lexerActions[i]);
+		}
+	}
+	if (updatedLexerActions === null) {
+		return this;
+	} else {
+		return new LexerActionExecutor(updatedLexerActions);
+	}
+};
+
+// Execute the actions encapsulated by this executor within the context of a
+// particular {@link Lexer}.
+//
+// <p>This method calls {@link IntStream//seek} to set the position of the
+// {@code input} {@link CharStream} prior to calling
+// {@link LexerAction//execute} on a position-dependent action. Before the
+// method returns, the input position will be restored to the same position
+// it was in when the method was invoked.</p>
+//
+// @param lexer The lexer instance.
+// @param input The input stream which is the source for the current token.
+// When this method is called, the current {@link IntStream//index} for
+// {@code input} should be the start of the following token, i.e. 1
+// character past the end of the current token.
+// @param startIndex The token start index. This value may be passed to
+// {@link IntStream//seek} to set the {@code input} position to the beginning
+// of the token.
+// /
+LexerActionExecutor.prototype.execute = function(lexer, input, startIndex) {
+	var requiresSeek = false;
+	var stopIndex = input.index;
+	try {
+		for (var i = 0; i < this.lexerActions.length; i++) {
+			var lexerAction = this.lexerActions[i];
+			if (lexerAction instanceof LexerIndexedCustomAction) {
+				var offset = lexerAction.offset;
+				input.seek(startIndex + offset);
+				lexerAction = lexerAction.action;
+				requiresSeek = (startIndex + offset) !== stopIndex;
+			} else if (lexerAction.isPositionDependent) {
+				input.seek(stopIndex);
+				requiresSeek = false;
+			}
+			lexerAction.execute(lexer);
+		}
+	} finally {
+		if (requiresSeek) {
+			input.seek(stopIndex);
+		}
+	}
+};
+
+LexerActionExecutor.prototype.hashString = function() {
+	return this._hashString;
+};
+
+LexerActionExecutor.prototype.equals = function(other) {
+	if (this === other) {
+		return true;
+	} else if (!(other instanceof LexerActionExecutor)) {
+		return false;
+	} else if (this._hashString != other._hashString) {
+		return false;
+	} else if (this.lexerActions.length != other.lexerActions.length) {
+		return false;
+	} else {
+		var numActions = this.lexerActions.length
+		for (var idx = 0; idx < numActions; ++idx) {
+			if (!this.lexerActions[idx].equals(other.lexerActions[idx])) {
+				return false;
+			}
+		}
+		return true;
+	}
+};
+
+exports.LexerActionExecutor = LexerActionExecutor;
diff --git a/runtime/JavaScript/src/antlr4/atn/ParserATNSimulator.js b/runtime/JavaScript/src/antlr4/atn/ParserATNSimulator.js
new file mode 100644
index 000000000..b740ed92a
--- /dev/null
+++ b/runtime/JavaScript/src/antlr4/atn/ParserATNSimulator.js
@@ -0,0 +1,1686 @@
+//
+// [The "BSD license"]
+//  Copyright (c) 2012 Terence Parr
+//  Copyright (c) 2012 Sam Harwell
+//  Copyright (c) 2014 Eric Vergnaud
+//  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.
+//
+
+//
+// The embodiment of the adaptive LL(*), ALL(*), parsing strategy.
+//
+// <p>
+// The basic complexity of the adaptive strategy makes it harder to understand.
+// We begin with ATN simulation to build paths in a DFA. Subsequent prediction
+// requests go through the DFA first. If they reach a state without an edge for
+// the current symbol, the algorithm fails over to the ATN simulation to
+// complete the DFA path for the current input (until it finds a conflict state
+// or uniquely predicting state).</p>
+//
+// <p>
+// All of that is done without using the outer context because we want to create
+// a DFA that is not dependent upon the rule invocation stack when we do a
+// prediction. One DFA works in all contexts. We avoid using context not
+// necessarily because it's slower, although it can be, but because of the DFA
+// caching problem. The closure routine only considers the rule invocation stack
+// created during prediction beginning in the decision rule. For example, if
+// prediction occurs without invoking another rule's ATN, there are no context
+// stacks in the configurations. When lack of context leads to a conflict, we
+// don't know if it's an ambiguity or a weakness in the strong LL(*) parsing
+// strategy (versus full LL(*)).</p>
+//
+// <p>
+// When SLL yields a configuration set with conflict, we rewind the input and
+// retry the ATN simulation, this time using full outer context without adding
+// to the DFA. Configuration context stacks will be the full invocation stacks
+// from the start rule. If we get a conflict using full context, then we can
+// definitively say we have a true ambiguity for that input sequence. If we
+// don't get a conflict, it implies that the decision is sensitive to the outer
+// context. (It is not context-sensitive in the sense of context-sensitive
+// grammars.)</p>
+//
+// <p>
+// The next time we reach this DFA state with an SLL conflict, through DFA
+// simulation, we will again retry the ATN simulation using full context mode.
+// This is slow because we can't save the results and have to "interpret" the
+// ATN each time we get that input.</p>
+//
+// <p>
+// <strong>CACHING FULL CONTEXT PREDICTIONS</strong></p>
+//
+// <p>
+// We could cache results from full context to predicted alternative easily and
+// that saves a lot of time but doesn't work in presence of predicates. The set
+// of visible predicates from the ATN start state changes depending on the
+// context, because closure can fall off the end of a rule. I tried to cache
+// tuples (stack context, semantic context, predicted alt) but it was slower
+// than interpreting and much more complicated. Also required a huge amount of
+// memory. The goal is not to create the world's fastest parser anyway. I'd like
+// to keep this algorithm simple. By launching multiple threads, we can improve
+// the speed of parsing across a large number of files.</p>
+//
+// <p>
+// There is no strict ordering between the amount of input used by SLL vs LL,
+// which makes it really hard to build a cache for full context. Let's say that
+// we have input A B C that leads to an SLL conflict with full context X. That
+// implies that using X we might only use A B but we could also use A B C D to
+// resolve conflict. Input A B C D could predict alternative 1 in one position
+// in the input and A B C E could predict alternative 2 in another position in
+// input. The conflicting SLL configurations could still be non-unique in the
+// full context prediction, which would lead us to requiring more input than the
+// original A B C.	To make a	prediction cache work, we have to track	the exact
+// input	used during the previous prediction. That amounts to a cache that maps
+// X to a specific DFA for that context.</p>
+//
+// <p>
+// Something should be done for left-recursive expression predictions. They are
+// likely LL(1) + pred eval. Easier to do the whole SLL unless error and retry
+// with full LL thing Sam does.</p>
+//
+// <p>
+// <strong>AVOIDING FULL CONTEXT PREDICTION</strong></p>
+//
+// <p>
+// We avoid doing full context retry when the outer context is empty, we did not
+// dip into the outer context by falling off the end of the decision state rule,
+// or when we force SLL mode.</p>
+//
+// <p>
+// As an example of the not dip into outer context case, consider as super
+// constructor calls versus function calls. One grammar might look like
+// this:</p>
+//
+// <pre>
+// ctorBody
+//   : '{' superCall? stat* '}'
+//   ;
+// </pre>
+//
+// <p>
+// Or, you might see something like</p>
+//
+// <pre>
+// stat
+//   : superCall ';'
+//   | expression ';'
+//   | ...
+//   ;
+// </pre>
+//
+// <p>
+// In both cases I believe that no closure operations will dip into the outer
+// context. In the first case ctorBody in the worst case will stop at the '}'.
+// In the 2nd case it should stop at the ';'. Both cases should stay within the
+// entry rule and not dip into the outer context.</p>
+//
+// <p>
+// <strong>PREDICATES</strong></p>
+//
+// <p>
+// Predicates are always evaluated if present in either SLL or LL both. SLL and
+// LL simulation deals with predicates differently. SLL collects predicates as
+// it performs closure operations like ANTLR v3 did. It delays predicate
+// evaluation until it reaches and accept state. This allows us to cache the SLL
+// ATN simulation whereas, if we had evaluated predicates on-the-fly during
+// closure, the DFA state configuration sets would be different and we couldn't
+// build up a suitable DFA.</p>
+//
+// <p>
+// When building a DFA accept state during ATN simulation, we evaluate any
+// predicates and return the sole semantically valid alternative. If there is
+// more than 1 alternative, we report an ambiguity. If there are 0 alternatives,
+// we throw an exception. Alternatives without predicates act like they have
+// true predicates. The simple way to think about it is to strip away all
+// alternatives with false predicates and choose the minimum alternative that
+// remains.</p>
+//
+// <p>
+// When we start in the DFA and reach an accept state that's predicated, we test
+// those and return the minimum semantically viable alternative. If no
+// alternatives are viable, we throw an exception.</p>
+//
+// <p>
+// During full LL ATN simulation, closure always evaluates predicates and
+// on-the-fly. This is crucial to reducing the configuration set size during
+// closure. It hits a landmine when parsing with the Java grammar, for example,
+// without this on-the-fly evaluation.</p>
+//
+// <p>
+// <strong>SHARING DFA</strong></p>
+//
+// <p>
+// All instances of the same parser share the same decision DFAs through a
+// static field. Each instance gets its own ATN simulator but they share the
+// same {@link //decisionToDFA} field. They also share a
+// {@link PredictionContextCache} object that makes sure that all
+// {@link PredictionContext} objects are shared among the DFA states. This makes
+// a big size difference.</p>
+//
+// <p>
+// <strong>THREAD SAFETY</strong></p>
+//
+// <p>
+// The {@link ParserATNSimulator} locks on the {@link //decisionToDFA} field when
+// it adds a new DFA object to that array. {@link //addDFAEdge}
+// locks on the DFA for the current decision when setting the
+// {@link DFAState//edges} field. {@link //addDFAState} locks on
+// the DFA for the current decision when looking up a DFA state to see if it
+// already exists. We must make sure that all requests to add DFA states that
+// are equivalent result in the same shared DFA object. This is because lots of
+// threads will be trying to update the DFA at once. The
+// {@link //addDFAState} method also locks inside the DFA lock
+// but this time on the shared context cache when it rebuilds the
+// configurations' {@link PredictionContext} objects using cached
+// subgraphs/nodes. No other locking occurs, even during DFA simulation. This is
+// safe as long as we can guarantee that all threads referencing
+// {@code s.edge[t]} get the same physical target {@link DFAState}, or
+// {@code null}. Once into the DFA, the DFA simulation does not reference the
+// {@link DFA//states} map. It follows the {@link DFAState//edges} field to new
+// targets. The DFA simulator will either find {@link DFAState//edges} to be
+// {@code null}, to be non-{@code null} and {@code dfa.edges[t]} null, or
+// {@code dfa.edges[t]} to be non-null. The
+// {@link //addDFAEdge} method could be racing to set the field
+// but in either case the DFA simulator works; if {@code null}, and requests ATN
+// simulation. It could also race trying to get {@code dfa.edges[t]}, but either
+// way it will work because it's not doing a test and set operation.</p>
+//
+// <p>
+// <strong>Starting with SLL then failing to combined SLL/LL (Two-Stage
+// Parsing)</strong></p>
+//
+// <p>
+// Sam pointed out that if SLL does not give a syntax error, then there is no
+// point in doing full LL, which is slower. We only have to try LL if we get a
+// syntax error. For maximum speed, Sam starts the parser set to pure SLL
+// mode with the {@link BailErrorStrategy}:</p>
+//
+// <pre>
+// parser.{@link Parser//getInterpreter() getInterpreter()}.{@link //setPredictionMode setPredictionMode}{@code (}{@link PredictionMode//SLL}{@code )};
+// parser.{@link Parser//setErrorHandler setErrorHandler}(new {@link BailErrorStrategy}());
+// </pre>
+//
+// <p>
+// If it does not get a syntax error, then we're done. If it does get a syntax
+// error, we need to retry with the combined SLL/LL strategy.</p>
+//
+// <p>
+// The reason this works is as follows. If there are no SLL conflicts, then the
+// grammar is SLL (at least for that input set). If there is an SLL conflict,
+// the full LL analysis must yield a set of viable alternatives which is a
+// subset of the alternatives reported by SLL. If the LL set is a singleton,
+// then the grammar is LL but not SLL. If the LL set is the same size as the SLL
+// set, the decision is SLL. If the LL set has size &gt; 1, then that decision
+// is truly ambiguous on the current input. If the LL set is smaller, then the
+// SLL conflict resolution might choose an alternative that the full LL would
+// rule out as a possibility based upon better context information. If that's
+// the case, then the SLL parse will definitely get an error because the full LL
+// analysis says it's not viable. If SLL conflict resolution chooses an
+// alternative within the LL set, them both SLL and LL would choose the same
+// alternative because they both choose the minimum of multiple conflicting
+// alternatives.</p>
+//
+// <p>
+// Let's say we have a set of SLL conflicting alternatives {@code {1, 2, 3}} and
+// a smaller LL set called <em>s</em>. If <em>s</em> is {@code {2, 3}}, then SLL
+// parsing will get an error because SLL will pursue alternative 1. If
+// <em>s</em> is {@code {1, 2}} or {@code {1, 3}} then both SLL and LL will
+// choose the same alternative because alternative one is the minimum of either
+// set. If <em>s</em> is {@code {2}} or {@code {3}} then SLL will get a syntax
+// error. If <em>s</em> is {@code {1}} then SLL will succeed.</p>
+//
+// <p>
+// Of course, if the input is invalid, then we will get an error for sure in
+// both SLL and LL parsing. Erroneous input will therefore require 2 passes over
+// the input.</p>
+//
+
+var Utils = require('./../Utils');
+var Set = Utils.Set;
+var BitSet = Utils.BitSet;
+var DoubleDict = Utils.DoubleDict;
+var ATN = require('./ATN').ATN;
+var ATNConfig = require('./ATNConfig').ATNConfig;
+var ATNConfigSet = require('./ATNConfigSet').ATNConfigSet;
+var Token = require('./../Token').Token;
+var DFAState = require('./../dfa/DFAState').DFAState;
+var PredPrediction = require('./../dfa/DFAState').PredPrediction;
+var ATNSimulator = require('./ATNSimulator').ATNSimulator;
+var PredictionMode = require('./PredictionMode').PredictionMode;
+var RuleContext = require('./../RuleContext').RuleContext;
+var ParserRuleContext = require('./../ParserRuleContext').ParserRuleContext;
+var SemanticContext = require('./SemanticContext').SemanticContext;
+var StarLoopEntryState = require('./ATNState').StarLoopEntryState;
+var RuleStopState = require('./ATNState').RuleStopState;
+var PredictionContext = require('./../PredictionContext').PredictionContext;
+var Interval = require('./../IntervalSet').Interval;
+var Transitions = require('./Transition');
+var Transition = Transitions.Transition;
+var SetTransition = Transitions.SetTransition;
+var NotSetTransition = Transitions.NotSetTransition;
+var RuleTransition = Transitions.RuleTransition;
+var ActionTransition = Transitions.ActionTransition;
+var NoViableAltException = require('./../error/Errors').NoViableAltException;
+
+var SingletonPredictionContext = require('./../PredictionContext').SingletonPredictionContext;
+var predictionContextFromRuleContext = require('./../PredictionContext').predictionContextFromRuleContext;
+
+function ParserATNSimulator(parser, atn, decisionToDFA, sharedContextCache) {
+	ATNSimulator.call(this, atn, sharedContextCache);
+    this.parser = parser;
+    this.decisionToDFA = decisionToDFA;
+    // SLL, LL, or LL + exact ambig detection?//
+    this.predictionMode = PredictionMode.LL;
+    // LAME globals to avoid parameters!!!!! I need these down deep in predTransition
+    this._input = null;
+    this._startIndex = 0;
+    this._outerContext = null;
+    this._dfa = null;
+    // Each prediction operation uses a cache for merge of prediction contexts.
+    //  Don't keep around as it wastes huge amounts of memory. DoubleKeyMap
+    //  isn't synchronized but we're ok since two threads shouldn't reuse same
+    //  parser/atnsim object because it can only handle one input at a time.
+    //  This maps graphs a and b to merged result c. (a,b)&rarr;c. We can avoid
+    //  the merge if we ever see a and b again.  Note that (b,a)&rarr;c should
+    //  also be examined during cache lookup.
+    //
+    this.mergeCache = null;
+    return this;
+}
+
+ParserATNSimulator.prototype = Object.create(ATNSimulator.prototype);
+ParserATNSimulator.prototype.constructor = ParserATNSimulator;
+
+ParserATNSimulator.prototype.debug = false;
+ParserATNSimulator.prototype.debug_list_atn_decisions = false;
+ParserATNSimulator.prototype.dfa_debug = false;
+ParserATNSimulator.prototype.retry_debug = false;
+
+
+ParserATNSimulator.prototype.reset = function() {
+};
+
+ParserATNSimulator.prototype.adaptivePredict = function(input, decision, outerContext) {
+    if (this.debug || this.debug_list_atn_decisions) {
+        console.log("adaptivePredict decision " + decision +
+                               " exec LA(1)==" + this.getLookaheadName(input) +
+                               " line " + input.LT(1).line + ":" +
+                               input.LT(1).column);
+    }
+    this._input = input;
+    this._startIndex = input.index;
+    this._outerContext = outerContext;
+    
+    var dfa = this.decisionToDFA[decision];
+    this._dfa = dfa;
+    var m = input.mark();
+    var index = input.index;
+
+    // Now we are certain to have a specific decision's DFA
+    // But, do we still need an initial state?
+    try {
+        var s0;
+        if (dfa.precedenceDfa) {
+            // the start state for a precedence DFA depends on the current
+            // parser precedence, and is provided by a DFA method.
+            s0 = dfa.getPrecedenceStartState(this.parser.getPrecedence());
+        } else {
+            // the start state for a "regular" DFA is just s0
+            s0 = dfa.s0;
+        }
+        if (s0===null) {
+            if (outerContext===null) {
+                outerContext = RuleContext.EMPTY;
+            }
+            if (this.debug || this.debug_list_atn_decisions) {
+                console.log("predictATN decision " + dfa.decision +
+                                   " exec LA(1)==" + this.getLookaheadName(input) +
+                                   ", outerContext=" + outerContext.toString(this.parser.ruleNames));
+            }
+            // If this is not a precedence DFA, we check the ATN start state
+            // to determine if this ATN start state is the decision for the
+            // closure block that determines whether a precedence rule
+            // should continue or complete.
+            //
+            if (!dfa.precedenceDfa && (dfa.atnStartState instanceof StarLoopEntryState)) {
+                if (dfa.atnStartState.precedenceRuleDecision) {
+                    dfa.setPrecedenceDfa(true);
+                }
+            }
+            var fullCtx = false;
+            var s0_closure = this.computeStartState(dfa.atnStartState, RuleContext.EMPTY, fullCtx);
+
+            if( dfa.precedenceDfa) {
+                // If this is a precedence DFA, we use applyPrecedenceFilter
+                // to convert the computed start state to a precedence start
+                // state. We then use DFA.setPrecedenceStartState to set the
+                // appropriate start state for the precedence level rather
+                // than simply setting DFA.s0.
+                //
+                s0_closure = this.applyPrecedenceFilter(s0_closure);
+                s0 = this.addDFAState(dfa, new DFAState(null, s0_closure));
+                dfa.setPrecedenceStartState(this.parser.getPrecedence(), s0);
+            } else {
+                s0 = this.addDFAState(dfa, new DFAState(null, s0_closure));
+                dfa.s0 = s0;
+            }
+        }
+        var alt = this.execATN(dfa, s0, input, index, outerContext);
+        if (this.debug) {
+            console.log("DFA after predictATN: " + dfa.toString(this.parser.literalNames));
+        }
+        return alt;
+    } finally {
+        this._dfa = null;
+        this.mergeCache = null; // wack cache after each prediction
+        input.seek(index);
+        input.release(m);
+    }
+};
+// Performs ATN simulation to compute a predicted alternative based
+//  upon the remaining input, but also updates the DFA cache to avoid
+//  having to traverse the ATN again for the same input sequence.
+
+// There are some key conditions we're looking for after computing a new
+// set of ATN configs (proposed DFA state):
+      // if the set is empty, there is no viable alternative for current symbol
+      // does the state uniquely predict an alternative?
+      // does the state have a conflict that would prevent us from
+      //   putting it on the work list?
+
+// We also have some key operations to do:
+      // add an edge from previous DFA state to potentially new DFA state, D,
+      //   upon current symbol but only if adding to work list, which means in all
+      //   cases except no viable alternative (and possibly non-greedy decisions?)
+      // collecting predicates and adding semantic context to DFA accept states
+      // adding rule context to context-sensitive DFA accept states
+      // consuming an input symbol
+      // reporting a conflict
+      // reporting an ambiguity
+      // reporting a context sensitivity
+      // reporting insufficient predicates
+
+// cover these cases:
+//    dead end
+//    single alt
+//    single alt + preds
+//    conflict
+//    conflict + preds
+//
+ParserATNSimulator.prototype.execATN = function(dfa, s0, input, startIndex, outerContext ) {
+    if (this.debug || this.debug_list_atn_decisions) {
+        console.log("execATN decision " + dfa.decision +
+                " exec LA(1)==" + this.getLookaheadName(input) +
+                " line " + input.LT(1).line + ":" + input.LT(1).column);
+    }
+    var alt;
+    var previousD = s0;
+
+    if (this.debug) {
+        console.log("s0 = " + s0);
+    }
+    var t = input.LA(1);
+    while(true) { // while more work
+        var D = this.getExistingTargetState(previousD, t);
+        if(D===null) {
+            D = this.computeTargetState(dfa, previousD, t);
+        }
+        if(D===ATNSimulator.ERROR) {
+            // if any configs in previous dipped into outer context, that
+            // means that input up to t actually finished entry rule
+            // at least for SLL decision. Full LL doesn't dip into outer
+            // so don't need special case.
+            // We will get an error no matter what so delay until after
+            // decision; better error message. Also, no reachable target
+            // ATN states in SLL implies LL will also get nowhere.
+            // If conflict in states that dip out, choose min since we
+            // will get error no matter what.
+            var e = this.noViableAlt(input, outerContext, previousD.configs, startIndex);
+            input.seek(startIndex);
+            alt = this.getSynValidOrSemInvalidAltThatFinishedDecisionEntryRule(previousD.configs, outerContext);
+            if(alt!==ATN.INVALID_ALT_NUMBER) {
+                return alt;
+            } else {
+                throw e;
+            }
+        }
+        if(D.requiresFullContext && this.predictionMode !== PredictionMode.SLL) {
+            // IF PREDS, MIGHT RESOLVE TO SINGLE ALT => SLL (or syntax error)
+            var conflictingAlts = null;
+            if (D.predicates!==null) {
+                if (this.debug) {
+                    console.log("DFA state has preds in DFA sim LL failover");
+                }
+                var conflictIndex = input.index;
+                if(conflictIndex !== startIndex) {
+                    input.seek(startIndex);
+                }
+                conflictingAlts = this.evalSemanticContext(D.predicates, outerContext, true);
+                if (conflictingAlts.length===1) {
+                    if(this.debug) {
+                        console.log("Full LL avoided");
+                    }
+                    return conflictingAlts.minValue();
+                }
+                if (conflictIndex !== startIndex) {
+                    // restore the index so reporting the fallback to full
+                    // context occurs with the index at the correct spot
+                    input.seek(conflictIndex);
+                }
+            }
+            if (this.dfa_debug) {
+                console.log("ctx sensitive state " + outerContext +" in " + D);
+            }
+            var fullCtx = true;
+            var s0_closure = this.computeStartState(dfa.atnStartState, outerContext, fullCtx);
+            this.reportAttemptingFullContext(dfa, conflictingAlts, D.configs, startIndex, input.index);
+            alt = this.execATNWithFullContext(dfa, D, s0_closure, input, startIndex, outerContext);
+            return alt;
+        }
+        if (D.isAcceptState) {
+            if (D.predicates===null) {
+                return D.prediction;
+            }
+            var stopIndex = input.index;
+            input.seek(startIndex);
+            var alts = this.evalSemanticContext(D.predicates, outerContext, true);
+            if (alts.length===0) {
+                throw this.noViableAlt(input, outerContext, D.configs, startIndex);
+            } else if (alts.length===1) {
+                return alts.minValue();
+            } else {
+                // report ambiguity after predicate evaluation to make sure the correct set of ambig alts is reported.
+                this.reportAmbiguity(dfa, D, startIndex, stopIndex, false, alts, D.configs);
+                return alts.minValue();
+            }
+        }
+        previousD = D;
+
+        if (t !== Token.EOF) {
+            input.consume();
+            t = input.LA(1);
+        }
+    }
+};
+//
+// Get an existing target state for an edge in the DFA. If the target state
+// for the edge has not yet been computed or is otherwise not available,
+// this method returns {@code null}.
+//
+// @param previousD The current DFA state
+// @param t The next input symbol
+// @return The existing target DFA state for the given input symbol
+// {@code t}, or {@code null} if the target state for this edge is not
+// already cached
+//
+ParserATNSimulator.prototype.getExistingTargetState = function(previousD, t) {
+    var edges = previousD.edges;
+    if (edges===null) {
+        return null;
+    } else {
+        return edges[t + 1] || null;
+    }
+};
+//
+// Compute a target state for an edge in the DFA, and attempt to add the
+// computed state and corresponding edge to the DFA.
+//
+// @param dfa The DFA
+// @param previousD The current DFA state
+// @param t The next input symbol
+//
+// @return The computed target DFA state for the given input symbol
+// {@code t}. If {@code t} does not lead to a valid DFA state, this method
+// returns {@link //ERROR}.
+//
+ParserATNSimulator.prototype.computeTargetState = function(dfa, previousD, t) {
+   var reach = this.computeReachSet(previousD.configs, t, false);
+    if(reach===null) {
+        this.addDFAEdge(dfa, previousD, t, ATNSimulator.ERROR);
+        return ATNSimulator.ERROR;
+    }
+    // create new target state; we'll add to DFA after it's complete
+    var D = new DFAState(null, reach);
+
+    var predictedAlt = this.getUniqueAlt(reach);
+
+    if (this.debug) {
+        var altSubSets = PredictionMode.getConflictingAltSubsets(reach);
+        console.log("SLL altSubSets=" + Utils.arrayToString(altSubSets) +
+                    ", previous=" + previousD.configs +
+                    ", configs=" + reach +
+                    ", predict=" + predictedAlt +
+                    ", allSubsetsConflict=" +
+                    PredictionMode.allSubsetsConflict(altSubSets) + ", conflictingAlts=" +
+                    this.getConflictingAlts(reach));
+    }
+    if (predictedAlt!==ATN.INVALID_ALT_NUMBER) {
+        // NO CONFLICT, UNIQUELY PREDICTED ALT
+        D.isAcceptState = true;
+        D.configs.uniqueAlt = predictedAlt;
+        D.prediction = predictedAlt;
+    } else if (PredictionMode.hasSLLConflictTerminatingPrediction(this.predictionMode, reach)) {
+        // MORE THAN ONE VIABLE ALTERNATIVE
+        D.configs.conflictingAlts = this.getConflictingAlts(reach);
+        D.requiresFullContext = true;
+        // in SLL-only mode, we will stop at this state and return the minimum alt
+        D.isAcceptState = true;
+        D.prediction = D.configs.conflictingAlts.minValue();
+    }
+    if (D.isAcceptState && D.configs.hasSemanticContext) {
+        this.predicateDFAState(D, this.atn.getDecisionState(dfa.decision));
+        if( D.predicates!==null) {
+            D.prediction = ATN.INVALID_ALT_NUMBER;
+        }
+    }
+    // all adds to dfa are done after we've created full D state
+    D = this.addDFAEdge(dfa, previousD, t, D);
+    return D;
+};
+
+ParserATNSimulator.prototype.predicateDFAState = function(dfaState, decisionState) {
+    // We need to test all predicates, even in DFA states that
+    // uniquely predict alternative.
+    var nalts = decisionState.transitions.length;
+    // Update DFA so reach becomes accept state with (predicate,alt)
+    // pairs if preds found for conflicting alts
+    var altsToCollectPredsFrom = this.getConflictingAltsOrUniqueAlt(dfaState.configs);
+    var altToPred = this.getPredsForAmbigAlts(altsToCollectPredsFrom, dfaState.configs, nalts);
+    if (altToPred!==null) {
+        dfaState.predicates = this.getPredicatePredictions(altsToCollectPredsFrom, altToPred);
+        dfaState.prediction = ATN.INVALID_ALT_NUMBER; // make sure we use preds
+    } else {
+        // There are preds in configs but they might go away
+        // when OR'd together like {p}? || NONE == NONE. If neither
+        // alt has preds, resolve to min alt
+        dfaState.prediction = altsToCollectPredsFrom.minValue();
+    }
+};
+
+// comes back with reach.uniqueAlt set to a valid alt
+ParserATNSimulator.prototype.execATNWithFullContext = function(dfa, D, // how far we got before failing over
+                                     s0,
+                                     input,
+                                     startIndex,
+                                     outerContext) {
+    if (this.debug || this.debug_list_atn_decisions) {
+        console.log("execATNWithFullContext "+s0);
+    }
+    var fullCtx = true;
+    var foundExactAmbig = false;
+    var reach = null;
+    var previous = s0;
+    input.seek(startIndex);
+    var t = input.LA(1);
+    var predictedAlt = -1;
+    while (true) { // while more work
+        reach = this.computeReachSet(previous, t, fullCtx);
+        if (reach===null) {
+            // if any configs in previous dipped into outer context, that
+            // means that input up to t actually finished entry rule
+            // at least for LL decision. Full LL doesn't dip into outer
+            // so don't need special case.
+            // We will get an error no matter what so delay until after
+            // decision; better error message. Also, no reachable target
+            // ATN states in SLL implies LL will also get nowhere.
+            // If conflict in states that dip out, choose min since we
+            // will get error no matter what.
+            var e = this.noViableAlt(input, outerContext, previous, startIndex);
+            input.seek(startIndex);
+            var alt = this.getSynValidOrSemInvalidAltThatFinishedDecisionEntryRule(previous, outerContext);
+            if(alt!==ATN.INVALID_ALT_NUMBER) {
+                return alt;
+            } else {
+                throw e;
+            }
+        }
+        var altSubSets = PredictionMode.getConflictingAltSubsets(reach);
+        if(this.debug) {
+            console.log("LL altSubSets=" + altSubSets + ", predict=" +
+                  PredictionMode.getUniqueAlt(altSubSets) + ", resolvesToJustOneViableAlt=" +
+                  PredictionMode.resolvesToJustOneViableAlt(altSubSets));
+        }
+        reach.uniqueAlt = this.getUniqueAlt(reach);
+        // unique prediction?
+        if(reach.uniqueAlt!==ATN.INVALID_ALT_NUMBER) {
+            predictedAlt = reach.uniqueAlt;
+            break;
+        } else if (this.predictionMode !== PredictionMode.LL_EXACT_AMBIG_DETECTION) {
+            predictedAlt = PredictionMode.resolvesToJustOneViableAlt(altSubSets);
+            if(predictedAlt !== ATN.INVALID_ALT_NUMBER) {
+                break;
+            }
+        } else {
+            // In exact ambiguity mode, we never try to terminate early.
+            // Just keeps scarfing until we know what the conflict is
+            if (PredictionMode.allSubsetsConflict(altSubSets) && PredictionMode.allSubsetsEqual(altSubSets)) {
+                foundExactAmbig = true;
+                predictedAlt = PredictionMode.getSingleViableAlt(altSubSets);
+                break;
+            }
+            // else there are multiple non-conflicting subsets or
+            // we're not sure what the ambiguity is yet.
+            // So, keep going.
+        }
+        previous = reach;
+        if( t !== Token.EOF) {
+            input.consume();
+            t = input.LA(1);
+        }
+    }
+    // If the configuration set uniquely predicts an alternative,
+    // without conflict, then we know that it's a full LL decision
+    // not SLL.
+    if (reach.uniqueAlt !== ATN.INVALID_ALT_NUMBER ) {
+        this.reportContextSensitivity(dfa, predictedAlt, reach, startIndex, input.index);
+        return predictedAlt;
+    }
+    // We do not check predicates here because we have checked them
+    // on-the-fly when doing full context prediction.
+
+    //
+    // In non-exact ambiguity detection mode, we might	actually be able to
+    // detect an exact ambiguity, but I'm not going to spend the cycles
+    // needed to check. We only emit ambiguity warnings in exact ambiguity
+    // mode.
+    //
+    // For example, we might know that we have conflicting configurations.
+    // But, that does not mean that there is no way forward without a
+    // conflict. It's possible to have nonconflicting alt subsets as in:
+
+    // altSubSets=[{1, 2}, {1, 2}, {1}, {1, 2}]
+
+    // from
+    //
+    //    [(17,1,[5 $]), (13,1,[5 10 $]), (21,1,[5 10 $]), (11,1,[$]),
+    //     (13,2,[5 10 $]), (21,2,[5 10 $]), (11,2,[$])]
+    //
+    // In this case, (17,1,[5 $]) indicates there is some next sequence that
+    // would resolve this without conflict to alternative 1. Any other viable
+    // next sequence, however, is associated with a conflict.  We stop
+    // looking for input because no amount of further lookahead will alter
+    // the fact that we should predict alternative 1.  We just can't say for
+    // sure that there is an ambiguity without looking further.
+
+    this.reportAmbiguity(dfa, D, startIndex, input.index, foundExactAmbig, null, reach);
+
+    return predictedAlt;
+};
+
+ParserATNSimulator.prototype.computeReachSet = function(closure, t, fullCtx) {
+    if (this.debug) {
+        console.log("in computeReachSet, starting closure: " + closure);
+    }
+    if( this.mergeCache===null) {
+        this.mergeCache = new DoubleDict();
+    }
+    var intermediate = new ATNConfigSet(fullCtx);
+
+    // Configurations already in a rule stop state indicate reaching the end
+    // of the decision rule (local context) or end of the start rule (full
+    // context). Once reached, these configurations are never updated by a
+    // closure operation, so they are handled separately for the performance
+    // advantage of having a smaller intermediate set when calling closure.
+    //
+    // For full-context reach operations, separate handling is required to
+    // ensure that the alternative matching the longest overall sequence is
+    // chosen when multiple such configurations can match the input.
+    
+    var skippedStopStates = null;
+
+    // First figure out where we can reach on input t
+    for (var i=0; i<closure.items.length;i++) {
+        var c = closure.items[i];
+        if(this.debug) {
+            console.log("testing " + this.getTokenName(t) + " at " + c);
+        }
+        if (c.state instanceof RuleStopState) {
+            if (fullCtx || t === Token.EOF) {
+                if (skippedStopStates===null) {
+                    skippedStopStates = [];
+                }
+                skippedStopStates.push(c);
+                if(this.debug) {
+                    console.log("added " + c + " to skippedStopStates");
+                }
+            }
+            continue;
+        }
+        for(var j=0;j<c.state.transitions.length;j++) {
+            var trans = c.state.transitions[j];
+            var target = this.getReachableTarget(trans, t);
+            if (target!==null) {
+                var cfg = new ATNConfig({state:target}, c);
+                intermediate.add(cfg, this.mergeCache);
+                if(this.debug) {
+                    console.log("added " + cfg + " to intermediate");
+                }
+            }
+        }
+    }
+    // Now figure out where the reach operation can take us...
+    var reach = null;
+
+    // This block optimizes the reach operation for intermediate sets which
+    // trivially indicate a termination state for the overall
+    // adaptivePredict operation.
+    //
+    // The conditions assume that intermediate
+    // contains all configurations relevant to the reach set, but this
+    // condition is not true when one or more configurations have been
+    // withheld in skippedStopStates, or when the current symbol is EOF.
+    //
+    if (skippedStopStates===null && t!==Token.EOF) {
+        if (intermediate.items.length===1) {
+            // Don't pursue the closure if there is just one state.
+            // It can only have one alternative; just add to result
+            // Also don't pursue the closure if there is unique alternative
+            // among the configurations.
+            reach = intermediate;
+        } else if (this.getUniqueAlt(intermediate)!==ATN.INVALID_ALT_NUMBER) {
+            // Also don't pursue the closure if there is unique alternative
+            // among the configurations.
+            reach = intermediate;
+        }
+    }
+    // If the reach set could not be trivially determined, perform a closure
+    // operation on the intermediate set to compute its initial value.
+    //
+    if (reach===null) {
+        reach = new ATNConfigSet(fullCtx);
+        var closureBusy = new Set();
+        var treatEofAsEpsilon = t === Token.EOF;
+        for (var k=0; k<intermediate.items.length;k++) {
+            this.closure(intermediate.items[k], reach, closureBusy, false, fullCtx, treatEofAsEpsilon);
+        }
+    }
+    if (t === Token.EOF) {
+        // After consuming EOF no additional input is possible, so we are
+        // only interested in configurations which reached the end of the
+        // decision rule (local context) or end of the start rule (full
+        // context). Update reach to contain only these configurations. This
+        // handles both explicit EOF transitions in the grammar and implicit
+        // EOF transitions following the end of the decision or start rule.
+        //
+        // When reach==intermediate, no closure operation was performed. In
+        // this case, removeAllConfigsNotInRuleStopState needs to check for
+        // reachable rule stop states as well as configurations already in
+        // a rule stop state.
+        //
+        // This is handled before the configurations in skippedStopStates,
+        // because any configurations potentially added from that list are
+        // already guaranteed to meet this condition whether or not it's
+        // required.
+        //
+        reach = this.removeAllConfigsNotInRuleStopState(reach, reach === intermediate);
+    }
+    // If skippedStopStates!==null, then it contains at least one
+    // configuration. For full-context reach operations, these
+    // configurations reached the end of the start rule, in which case we
+    // only add them back to reach if no configuration during the current
+    // closure operation reached such a state. This ensures adaptivePredict
+    // chooses an alternative matching the longest overall sequence when
+    // multiple alternatives are viable.
+    //
+    if (skippedStopStates!==null && ( (! fullCtx) || (! PredictionMode.hasConfigInRuleStopState(reach)))) {
+        for (var l=0; l<skippedStopStates.length;l++) {
+            reach.add(skippedStopStates[l], this.mergeCache);
+        }
+    }
+    if (reach.items.length===0) {
+        return null;
+    } else {
+        return reach;
+    }
+};
+//
+// Return a configuration set containing only the configurations from
+// {@code configs} which are in a {@link RuleStopState}. If all
+// configurations in {@code configs} are already in a rule stop state, this
+// method simply returns {@code configs}.
+//
+// <p>When {@code lookToEndOfRule} is true, this method uses
+// {@link ATN//nextTokens} for each configuration in {@code configs} which is
+// not already in a rule stop state to see if a rule stop state is reachable
+// from the configuration via epsilon-only transitions.</p>
+//
+// @param configs the configuration set to update
+// @param lookToEndOfRule when true, this method checks for rule stop states
+// reachable by epsilon-only transitions from each configuration in
+// {@code configs}.
+//
+// @return {@code configs} if all configurations in {@code configs} are in a
+// rule stop state, otherwise return a new configuration set containing only
+// the configurations from {@code configs} which are in a rule stop state
+//
+ParserATNSimulator.prototype.removeAllConfigsNotInRuleStopState = function(configs, lookToEndOfRule) {
+    if (PredictionMode.allConfigsInRuleStopStates(configs)) {
+        return configs;
+    }
+    var result = new ATNConfigSet(configs.fullCtx);
+    for(var i=0; i<configs.items.length;i++) {
+        var config = configs.items[i];
+        if (config.state instanceof RuleStopState) {
+            result.add(config, this.mergeCache);
+            continue;
+        }
+        if (lookToEndOfRule && config.state.epsilonOnlyTransitions) {
+            var nextTokens = this.atn.nextTokens(config.state);
+            if (nextTokens.contains(Token.EPSILON)) {
+                var endOfRuleState = this.atn.ruleToStopState[config.state.ruleIndex];
+                result.add(new ATNConfig({state:endOfRuleState}, config), this.mergeCache);
+            }
+        }
+    }
+    return result;
+};
+
+ParserATNSimulator.prototype.computeStartState = function(p, ctx, fullCtx) {
+    // always at least the implicit call to start rule
+    var initialContext = predictionContextFromRuleContext(this.atn, ctx);
+    var configs = new ATNConfigSet(fullCtx);
+    for(var i=0;i<p.transitions.length;i++) {
+        var target = p.transitions[i].target;
+        var c = new ATNConfig({ state:target, alt:i+1, context:initialContext }, null);
+        var closureBusy = new Set();
+        this.closure(c, configs, closureBusy, true, fullCtx, false);
+    }
+    return configs;
+};
+
+//
+// This method transforms the start state computed by
+// {@link //computeStartState} to the special start state used by a
+// precedence DFA for a particular precedence value. The transformation
+// process applies the following changes to the start state's configuration
+// set.
+//
+// <ol>
+// <li>Evaluate the precedence predicates for each configuration using
+// {@link SemanticContext//evalPrecedence}.</li>
+// <li>Remove all configurations which predict an alternative greater than
+// 1, for which another configuration that predicts alternative 1 is in the
+// same ATN state with the same prediction context. This transformation is
+// valid for the following reasons:
+// <ul>
+// <li>The closure block cannot contain any epsilon transitions which bypass
+// the body of the closure, so all states reachable via alternative 1 are
+// part of the precedence alternatives of the transformed left-recursive
+// rule.</li>
+// <li>The "primary" portion of a left recursive rule cannot contain an
+// epsilon transition, so the only way an alternative other than 1 can exist
+// in a state that is also reachable via alternative 1 is by nesting calls
+// to the left-recursive rule, with the outer calls not being at the
+// preferred precedence level.</li>
+// </ul>
+// </li>
+// </ol>
+//
+// <p>
+// The prediction context must be considered by this filter to address
+// situations like the following.
+// </p>
+// <code>
+// <pre>
+// grammar TA;
+// prog: statement* EOF;
+// statement: letterA | statement letterA 'b' ;
+// letterA: 'a';
+// </pre>
+// </code>
+// <p>
+// If the above grammar, the ATN state immediately before the token
+// reference {@code 'a'} in {@code letterA} is reachable from the left edge
+// of both the primary and closure blocks of the left-recursive rule
+// {@code statement}. The prediction context associated with each of these
+// configurations distinguishes between them, and prevents the alternative
+// which stepped out to {@code prog} (and then back in to {@code statement}
+// from being eliminated by the filter.
+// </p>
+//
+// @param configs The configuration set computed by
+// {@link //computeStartState} as the start state for the DFA.
+// @return The transformed configuration set representing the start state
+// for a precedence DFA at a particular precedence level (determined by
+// calling {@link Parser//getPrecedence}).
+//
+ParserATNSimulator.prototype.applyPrecedenceFilter = function(configs) {
+	var config;
+	var statesFromAlt1 = [];
+    var configSet = new ATNConfigSet(configs.fullCtx);
+    for(var i=0; i<configs.items.length; i++) {
+        config = configs.items[i];
+        // handle alt 1 first
+        if (config.alt !== 1) {
+            continue;
+        }
+        var updatedContext = config.semanticContext.evalPrecedence(this.parser, this._outerContext);
+        if (updatedContext===null) {
+            // the configuration was eliminated
+            continue;
+        }
+        statesFromAlt1[config.state.stateNumber] = config.context;
+        if (updatedContext !== config.semanticContext) {
+            configSet.add(new ATNConfig({semanticContext:updatedContext}, config), this.mergeCache);
+        } else {
+            configSet.add(config, this.mergeCache);
+        }
+    }
+    for(i=0; i<configs.items.length; i++) {
+        config = configs.items[i];
+        if (config.alt === 1) {
+            // already handled
+            continue;
+        }
+        // In the future, this elimination step could be updated to also
+        // filter the prediction context for alternatives predicting alt>1
+        // (basically a graph subtraction algorithm).
+		if (!config.precedenceFilterSuppressed) {
+            var context = statesFromAlt1[config.state.stateNumber] || null;
+            if (context!==null && context.equals(config.context)) {
+                // eliminated
+                continue;
+            }
+		}
+        configSet.add(config, this.mergeCache);
+    }
+    return configSet;
+};
+
+ParserATNSimulator.prototype.getReachableTarget = function(trans, ttype) {
+    if (trans.matches(ttype, 0, this.atn.maxTokenType)) {
+        return trans.target;
+    } else {
+        return null;
+    }
+};
+
+ParserATNSimulator.prototype.getPredsForAmbigAlts = function(ambigAlts, configs, nalts) {
+    // REACH=[1|1|[]|0:0, 1|2|[]|0:1]
+    // altToPred starts as an array of all null contexts. The entry at index i
+    // corresponds to alternative i. altToPred[i] may have one of three values:
+    //   1. null: no ATNConfig c is found such that c.alt==i
+    //   2. SemanticContext.NONE: At least one ATNConfig c exists such that
+    //      c.alt==i and c.semanticContext==SemanticContext.NONE. In other words,
+    //      alt i has at least one unpredicated config.
+    //   3. Non-NONE Semantic Context: There exists at least one, and for all
+    //      ATNConfig c such that c.alt==i, c.semanticContext!=SemanticContext.NONE.
+    //
+    // From this, it is clear that NONE||anything==NONE.
+    //
+    var altToPred = [];
+    for(var i=0;i<configs.items.length;i++) {
+        var c = configs.items[i];
+        if(ambigAlts.contains( c.alt )) {
+            altToPred[c.alt] = SemanticContext.orContext(altToPred[c.alt] || null, c.semanticContext);
+        }
+    }
+    var nPredAlts = 0;
+    for (i =1;i< nalts+1;i++) {
+        var pred = altToPred[i] || null;
+        if (pred===null) {
+            altToPred[i] = SemanticContext.NONE;
+        } else if (pred !== SemanticContext.NONE) {
+            nPredAlts += 1;
+        }
+    }
+    // nonambig alts are null in altToPred
+    if (nPredAlts===0) {
+        altToPred = null;
+    }
+    if (this.debug) {
+        console.log("getPredsForAmbigAlts result " + Utils.arrayToString(altToPred));
+    }
+    return altToPred;
+};
+
+ParserATNSimulator.prototype.getPredicatePredictions = function(ambigAlts, altToPred) {
+    var pairs = [];
+    var containsPredicate = false;
+    for (var i=1; i<altToPred.length;i++) {
+        var pred = altToPred[i];
+        // unpredicated is indicated by SemanticContext.NONE
+        if( ambigAlts!==null && ambigAlts.contains( i )) {
+            pairs.push(new PredPrediction(pred, i));
+        }
+        if (pred !== SemanticContext.NONE) {
+            containsPredicate = true;
+        }
+    }
+    if (! containsPredicate) {
+        return null;
+    }
+    return pairs;
+};
+
+//
+// This method is used to improve the localization of error messages by
+// choosing an alternative rather than throwing a
+// {@link NoViableAltException} in particular prediction scenarios where the
+// {@link //ERROR} state was reached during ATN simulation.
+//
+// <p>
+// The default implementation of this method uses the following
+// algorithm to identify an ATN configuration which successfully parsed the
+// decision entry rule. Choosing such an alternative ensures that the
+// {@link ParserRuleContext} returned by the calling rule will be complete
+// and valid, and the syntax error will be reported later at a more
+// localized location.</p>
+//
+// <ul>
+// <li>If a syntactically valid path or paths reach the end of the decision rule and
+// they are semantically valid if predicated, return the min associated alt.</li>
+// <li>Else, if a semantically invalid but syntactically valid path exist
+// or paths exist, return the minimum associated alt.
+// </li>
+// <li>Otherwise, return {@link ATN//INVALID_ALT_NUMBER}.</li>
+// </ul>
+//
+// <p>
+// In some scenarios, the algorithm described above could predict an
+// alternative which will result in a {@link FailedPredicateException} in
+// the parser. Specifically, this could occur if the <em>only</em> configuration
+// capable of successfully parsing to the end of the decision rule is
+// blocked by a semantic predicate. By choosing this alternative within
+// {@link //adaptivePredict} instead of throwing a
+// {@link NoViableAltException}, the resulting
+// {@link FailedPredicateException} in the parser will identify the specific
+// predicate which is preventing the parser from successfully parsing the
+// decision rule, which helps developers identify and correct logic errors
+// in semantic predicates.
+// </p>
+//
+// @param configs The ATN configurations which were valid immediately before
+// the {@link //ERROR} state was reached
+// @param outerContext The is the \gamma_0 initial parser context from the paper
+// or the parser stack at the instant before prediction commences.
+//
+// @return The value to return from {@link //adaptivePredict}, or
+// {@link ATN//INVALID_ALT_NUMBER} if a suitable alternative was not
+// identified and {@link //adaptivePredict} should report an error instead.
+//
+ParserATNSimulator.prototype.getSynValidOrSemInvalidAltThatFinishedDecisionEntryRule = function(configs, outerContext) {
+    var cfgs = this.splitAccordingToSemanticValidity(configs, outerContext);
+    var semValidConfigs = cfgs[0];
+    var semInvalidConfigs = cfgs[1];
+    var alt = this.getAltThatFinishedDecisionEntryRule(semValidConfigs);
+    if (alt!==ATN.INVALID_ALT_NUMBER) { // semantically/syntactically viable path exists
+        return alt;
+    }
+    // Is there a syntactically valid path with a failed pred?
+    if (semInvalidConfigs.items.length>0) {
+        alt = this.getAltThatFinishedDecisionEntryRule(semInvalidConfigs);
+        if (alt!==ATN.INVALID_ALT_NUMBER) { // syntactically viable path exists
+            return alt;
+        }
+    }
+    return ATN.INVALID_ALT_NUMBER;
+};
+    
+ParserATNSimulator.prototype.getAltThatFinishedDecisionEntryRule = function(configs) {
+    var alts = [];
+    for(var i=0;i<configs.items.length; i++) {
+        var c = configs.items[i];
+        if (c.reachesIntoOuterContext>0 || ((c.state instanceof RuleStopState) && c.context.hasEmptyPath())) {
+            if(alts.indexOf(c.alt)<0) {
+                alts.push(c.alt);
+            }
+        }
+    }
+    if (alts.length===0) {
+        return ATN.INVALID_ALT_NUMBER;
+    } else {
+        return Math.min.apply(null, alts);
+    }
+};
+// Walk the list of configurations and split them according to
+//  those that have preds evaluating to true/false.  If no pred, assume
+//  true pred and include in succeeded set.  Returns Pair of sets.
+//
+//  Create a new set so as not to alter the incoming parameter.
+//
+//  Assumption: the input stream has been restored to the starting point
+//  prediction, which is where predicates need to evaluate.
+//
+ParserATNSimulator.prototype.splitAccordingToSemanticValidity = function( configs, outerContext) {
+    var succeeded = new ATNConfigSet(configs.fullCtx);
+    var failed = new ATNConfigSet(configs.fullCtx);
+    for(var i=0;i<configs.items.length; i++) {
+        var c = configs.items[i];
+        if (c.semanticContext !== SemanticContext.NONE) {
+            var predicateEvaluationResult = c.semanticContext.evaluate(this.parser, outerContext);
+            if (predicateEvaluationResult) {
+                succeeded.add(c);
+            } else {
+                failed.add(c);
+            }
+        } else {
+            succeeded.add(c);
+        }
+    }
+    return [succeeded, failed];
+};
+
+// Look through a list of predicate/alt pairs, returning alts for the
+//  pairs that win. A {@code NONE} predicate indicates an alt containing an
+//  unpredicated config which behaves as "always true." If !complete
+//  then we stop at the first predicate that evaluates to true. This
+//  includes pairs with null predicates.
+//
+ParserATNSimulator.prototype.evalSemanticContext = function(predPredictions, outerContext, complete) {
+    var predictions = new BitSet();
+    for(var i=0;i<predPredictions.length;i++) {
+    	var pair = predPredictions[i];
+        if (pair.pred === SemanticContext.NONE) {
+            predictions.add(pair.alt);
+            if (! complete) {
+                break;
+            }
+            continue;
+        }
+        var predicateEvaluationResult = pair.pred.evaluate(this.parser, outerContext);
+        if (this.debug || this.dfa_debug) {
+            console.log("eval pred " + pair + "=" + predicateEvaluationResult);
+        }
+        if (predicateEvaluationResult) {
+            if (this.debug || this.dfa_debug) {
+                console.log("PREDICT " + pair.alt);
+            }
+            predictions.add(pair.alt);
+            if (! complete) {
+                break;
+            }
+        }
+    }
+    return predictions;
+};
+
+// TODO: If we are doing predicates, there is no point in pursuing
+//     closure operations if we reach a DFA state that uniquely predicts
+//     alternative. We will not be caching that DFA state and it is a
+//     waste to pursue the closure. Might have to advance when we do
+//     ambig detection thought :(
+//
+
+ParserATNSimulator.prototype.closure = function(config, configs, closureBusy, collectPredicates, fullCtx, treatEofAsEpsilon) {
+    var initialDepth = 0;
+    this.closureCheckingStopState(config, configs, closureBusy, collectPredicates,
+                             fullCtx, initialDepth, treatEofAsEpsilon);
+};
+
+
+ParserATNSimulator.prototype.closureCheckingStopState = function(config, configs, closureBusy, collectPredicates, fullCtx, depth, treatEofAsEpsilon) {
+    if (this.debug) {
+        console.log("closure(" + config.toString(this.parser,true) + ")");
+        console.log("configs(" + configs.toString() + ")");
+        if(config.reachesIntoOuterContext>50) {
+            throw "problem";
+        }
+    }
+    if (config.state instanceof RuleStopState) {
+        // We hit rule end. If we have context info, use it
+        // run thru all possible stack tops in ctx
+        if (! config.context.isEmpty()) {
+            for ( var i =0; i<config.context.length; i++) {
+                if (config.context.getReturnState(i) === PredictionContext.EMPTY_RETURN_STATE) {
+                    if (fullCtx) {
+                        configs.add(new ATNConfig({state:config.state, context:PredictionContext.EMPTY}, config), this.mergeCache);
+                        continue;
+                    } else {
+                        // we have no context info, just chase follow links (if greedy)
+                        if (this.debug) {
+                            console.log("FALLING off rule " + this.getRuleName(config.state.ruleIndex));
+                        }
+                        this.closure_(config, configs, closureBusy, collectPredicates,
+                                 fullCtx, depth, treatEofAsEpsilon);
+                    }
+                    continue;
+                }
+                var returnState = this.atn.states[config.context.getReturnState(i)];
+                var newContext = config.context.getParent(i); // "pop" return state
+                var parms = {state:returnState, alt:config.alt, context:newContext, semanticContext:config.semanticContext};
+                var c = new ATNConfig(parms, null);
+                // While we have context to pop back from, we may have
+                // gotten that context AFTER having falling off a rule.
+                // Make sure we track that we are now out of context.
+                c.reachesIntoOuterContext = config.reachesIntoOuterContext;
+                this.closureCheckingStopState(c, configs, closureBusy, collectPredicates, fullCtx, depth - 1, treatEofAsEpsilon);
+            }
+            return;
+        } else if( fullCtx) {
+            // reached end of start rule
+            configs.add(config, this.mergeCache);
+            return;
+        } else {
+            // else if we have no context info, just chase follow links (if greedy)
+            if (this.debug) {
+                console.log("FALLING off rule " + this.getRuleName(config.state.ruleIndex));
+            }
+        }
+    }
+    this.closure_(config, configs, closureBusy, collectPredicates, fullCtx, depth, treatEofAsEpsilon);
+};
+
+// Do the actual work of walking epsilon edges//
+ParserATNSimulator.prototype.closure_ = function(config, configs, closureBusy, collectPredicates, fullCtx, depth, treatEofAsEpsilon) {
+    var p = config.state;
+    // optimization
+    if (! p.epsilonOnlyTransitions) {
+        configs.add(config, this.mergeCache);
+        // make sure to not return here, because EOF transitions can act as
+        // both epsilon transitions and non-epsilon transitions.
+    }
+    for(var i = 0;i<p.transitions.length; i++) {
+        var t = p.transitions[i];
+        var continueCollecting = collectPredicates && !(t instanceof ActionTransition);
+        var c = this.getEpsilonTarget(config, t, continueCollecting, depth === 0, fullCtx, treatEofAsEpsilon);
+        if (c!==null) {
+			if (!t.isEpsilon && closureBusy.add(c)!==c){
+				// avoid infinite recursion for EOF* and EOF+
+				continue;
+			}
+            var newDepth = depth;
+            if ( config.state instanceof RuleStopState) {
+                // target fell off end of rule; mark resulting c as having dipped into outer context
+                // We can't get here if incoming config was rule stop and we had context
+                // track how far we dip into outer context.  Might
+                // come in handy and we avoid evaluating context dependent
+                // preds if this is > 0.
+
+                if (closureBusy.add(c)!==c) {
+                    // avoid infinite recursion for right-recursive rules
+                    continue;
+                }
+
+				if (this._dfa !== null && this._dfa.precedenceDfa) {
+					if (t.outermostPrecedenceReturn === this._dfa.atnStartState.ruleIndex) {
+						c.precedenceFilterSuppressed = true;
+					}
+				}
+
+                c.reachesIntoOuterContext += 1;
+                configs.dipsIntoOuterContext = true; // TODO: can remove? only care when we add to set per middle of this method
+                newDepth -= 1;
+                if (this.debug) {
+                    console.log("dips into outer ctx: " + c);
+                }
+            } else if (t instanceof RuleTransition) {
+                // latch when newDepth goes negative - once we step out of the entry context we can't return
+                if (newDepth >= 0) {
+                    newDepth += 1;
+                }
+            }
+            this.closureCheckingStopState(c, configs, closureBusy, continueCollecting, fullCtx, newDepth, treatEofAsEpsilon);
+        }
+    }
+};
+
+ParserATNSimulator.prototype.getRuleName = function( index) {
+    if (this.parser!==null && index>=0) {
+        return this.parser.ruleNames[index];
+    } else {
+        return "<rule " + index + ">";
+    }
+};
+
+ParserATNSimulator.prototype.getEpsilonTarget = function(config, t, collectPredicates, inContext, fullCtx, treatEofAsEpsilon) {
+    switch(t.serializationType) {
+    case Transition.RULE:
+        return this.ruleTransition(config, t);
+    case Transition.PRECEDENCE:
+        return this.precedenceTransition(config, t, collectPredicates, inContext, fullCtx);
+    case Transition.PREDICATE:
+        return this.predTransition(config, t, collectPredicates, inContext, fullCtx);
+    case Transition.ACTION:
+        return this.actionTransition(config, t);
+    case Transition.EPSILON:
+        return new ATNConfig({state:t.target}, config);
+    case Transition.ATOM:
+    case Transition.RANGE:
+    case Transition.SET:
+        // EOF transitions act like epsilon transitions after the first EOF
+        // transition is traversed
+        if (treatEofAsEpsilon) {
+            if (t.matches(Token.EOF, 0, 1)) {
+                return new ATNConfig({state: t.target}, config);
+            }
+        }
+        return null;
+    default:
+    	return null;
+    }
+};
+
+ParserATNSimulator.prototype.actionTransition = function(config, t) {
+    if (this.debug) {
+        console.log("ACTION edge " + t.ruleIndex + ":" + t.actionIndex);
+    }
+    return new ATNConfig({state:t.target}, config);
+};
+
+ParserATNSimulator.prototype.precedenceTransition = function(config, pt,  collectPredicates, inContext, fullCtx) {
+    if (this.debug) {
+        console.log("PRED (collectPredicates=" + collectPredicates + ") " +
+                pt.precedence + ">=_p, ctx dependent=true");
+        if (this.parser!==null) {
+        	console.log("context surrounding pred is " + Utils.arrayToString(this.parser.getRuleInvocationStack()));
+        }
+    }
+    var c = null;
+    if (collectPredicates && inContext) {
+        if (fullCtx) {
+            // In full context mode, we can evaluate predicates on-the-fly
+            // during closure, which dramatically reduces the size of
+            // the config sets. It also obviates the need to test predicates
+            // later during conflict resolution.
+            var currentPosition = this._input.index;
+            this._input.seek(this._startIndex);
+            var predSucceeds = pt.getPredicate().evaluate(this.parser, this._outerContext);
+            this._input.seek(currentPosition);
+            if (predSucceeds) {
+                c = new ATNConfig({state:pt.target}, config); // no pred context
+            }
+        } else {
+            newSemCtx = SemanticContext.andContext(config.semanticContext, pt.getPredicate());
+            c = new ATNConfig({state:pt.target, semanticContext:newSemCtx}, config);
+        }
+    } else {
+        c = new ATNConfig({state:pt.target}, config);
+    }
+    if (this.debug) {
+        console.log("config from pred transition=" + c);
+    }
+    return c;
+};
+
+ParserATNSimulator.prototype.predTransition = function(config, pt, collectPredicates, inContext, fullCtx) {
+    if (this.debug) {
+        console.log("PRED (collectPredicates=" + collectPredicates + ") " + pt.ruleIndex +
+                ":" + pt.predIndex + ", ctx dependent=" + pt.isCtxDependent);
+        if (this.parser!==null) {
+            console.log("context surrounding pred is " + Utils.arrayToString(this.parser.getRuleInvocationStack()));
+        }
+    }
+    var c = null;
+    if (collectPredicates && ((pt.isCtxDependent && inContext) || ! pt.isCtxDependent)) {
+        if (fullCtx) {
+            // In full context mode, we can evaluate predicates on-the-fly
+            // during closure, which dramatically reduces the size of
+            // the config sets. It also obviates the need to test predicates
+            // later during conflict resolution.
+            var currentPosition = this._input.index;
+            this._input.seek(this._startIndex);
+            var predSucceeds = pt.getPredicate().evaluate(this.parser, this._outerContext);
+            this._input.seek(currentPosition);
+            if (predSucceeds) {
+                c = new ATNConfig({state:pt.target}, config); // no pred context
+            }
+        } else {
+            var newSemCtx = SemanticContext.andContext(config.semanticContext, pt.getPredicate());
+            c = new ATNConfig({state:pt.target, semanticContext:newSemCtx}, config);
+        }
+    } else {
+        c = new ATNConfig({state:pt.target}, config);
+    }
+    if (this.debug) {
+        console.log("config from pred transition=" + c);
+    }
+    return c;
+};
+
+ParserATNSimulator.prototype.ruleTransition = function(config, t) {
+    if (this.debug) {
+        console.log("CALL rule " + this.getRuleName(t.target.ruleIndex) + ", ctx=" + config.context);
+    }
+    var returnState = t.followState;
+    var newContext = SingletonPredictionContext.create(config.context, returnState.stateNumber);
+    return new ATNConfig({state:t.target, context:newContext}, config );
+};
+
+ParserATNSimulator.prototype.getConflictingAlts = function(configs) {
+    var altsets = PredictionMode.getConflictingAltSubsets(configs);
+    return PredictionMode.getAlts(altsets);
+};
+
+ // Sam pointed out a problem with the previous definition, v3, of
+ // ambiguous states. If we have another state associated with conflicting
+ // alternatives, we should keep going. For example, the following grammar
+ //
+ // s : (ID | ID ID?) ';' ;
+ //
+ // When the ATN simulation reaches the state before ';', it has a DFA
+ // state that looks like: [12|1|[], 6|2|[], 12|2|[]]. Naturally
+ // 12|1|[] and 12|2|[] conflict, but we cannot stop processing this node
+ // because alternative to has another way to continue, via [6|2|[]].
+ // The key is that we have a single state that has config's only associated
+ // with a single alternative, 2, and crucially the state transitions
+ // among the configurations are all non-epsilon transitions. That means
+ // we don't consider any conflicts that include alternative 2. So, we
+ // ignore the conflict between alts 1 and 2. We ignore a set of
+ // conflicting alts when there is an intersection with an alternative
+ // associated with a single alt state in the state&rarr;config-list map.
+ //
+ // It's also the case that we might have two conflicting configurations but
+ // also a 3rd nonconflicting configuration for a different alternative:
+ // [1|1|[], 1|2|[], 8|3|[]]. This can come about from grammar:
+ //
+ // a : A | A | A B ;
+ //
+ // After matching input A, we reach the stop state for rule A, state 1.
+ // State 8 is the state right before B. Clearly alternatives 1 and 2
+ // conflict and no amount of further lookahead will separate the two.
+ // However, alternative 3 will be able to continue and so we do not
+ // stop working on this state. In the previous example, we're concerned
+ // with states associated with the conflicting alternatives. Here alt
+ // 3 is not associated with the conflicting configs, but since we can continue
+ // looking for input reasonably, I don't declare the state done. We
+ // ignore a set of conflicting alts when we have an alternative
+ // that we still need to pursue.
+//
+
+ParserATNSimulator.prototype.getConflictingAltsOrUniqueAlt = function(configs) {
+    var conflictingAlts = null;
+    if (configs.uniqueAlt!== ATN.INVALID_ALT_NUMBER) {
+        conflictingAlts = new BitSet();
+        conflictingAlts.add(configs.uniqueAlt);
+    } else {
+        conflictingAlts = configs.conflictingAlts;
+    }
+    return conflictingAlts;
+};
+
+ParserATNSimulator.prototype.getTokenName = function( t) {
+    if (t===Token.EOF) {
+        return "EOF";
+    }
+    if( this.parser!==null && this.parser.literalNames!==null) {
+        if (t >= this.parser.literalNames.length) {
+            console.log("" + t + " ttype out of range: " + this.parser.literalNames);
+            console.log("" + this.parser.getInputStream().getTokens());
+        } else {
+            return this.parser.literalNames[t] + "<" + t + ">";
+        }
+    }
+    return "" + t;
+};
+
+ParserATNSimulator.prototype.getLookaheadName = function(input) {
+    return this.getTokenName(input.LA(1));
+};
+
+// Used for debugging in adaptivePredict around execATN but I cut
+//  it out for clarity now that alg. works well. We can leave this
+//  "dead" code for a bit.
+//
+ParserATNSimulator.prototype.dumpDeadEndConfigs = function(nvae) {
+    console.log("dead end configs: ");
+    var decs = nvae.getDeadEndConfigs();
+    for(var i=0; i<decs.length; i++) {
+    	var c = decs[i];
+        var trans = "no edges";
+        if (c.state.transitions.length>0) {
+            var t = c.state.transitions[0];
+            if (t instanceof AtomTransition) {
+                trans = "Atom "+ this.getTokenName(t.label);
+            } else if (t instanceof SetTransition) {
+                var neg = (t instanceof NotSetTransition);
+                trans = (neg ? "~" : "") + "Set " + t.set;
+            }
+        }
+        console.error(c.toString(this.parser, true) + ":" + trans);
+    }
+};
+
+ParserATNSimulator.prototype.noViableAlt = function(input, outerContext, configs, startIndex) {
+    return new NoViableAltException(this.parser, input, input.get(startIndex), input.LT(1), configs, outerContext);
+};
+
+ParserATNSimulator.prototype.getUniqueAlt = function(configs) {
+    var alt = ATN.INVALID_ALT_NUMBER;
+    for(var i=0;i<configs.items.length;i++) {
+    	var c = configs.items[i];
+        if (alt === ATN.INVALID_ALT_NUMBER) {
+            alt = c.alt // found first alt
+        } else if( c.alt!==alt) {
+            return ATN.INVALID_ALT_NUMBER;
+        }
+    }
+    return alt;
+};
+
+//
+// Add an edge to the DFA, if possible. This method calls
+// {@link //addDFAState} to ensure the {@code to} state is present in the
+// DFA. If {@code from} is {@code null}, or if {@code t} is outside the
+// range of edges that can be represented in the DFA tables, this method
+// returns without adding the edge to the DFA.
+//
+// <p>If {@code to} is {@code null}, this method returns {@code null}.
+// Otherwise, this method returns the {@link DFAState} returned by calling
+// {@link //addDFAState} for the {@code to} state.</p>
+//
+// @param dfa The DFA
+// @param from The source state for the edge
+// @param t The input symbol
+// @param to The target state for the edge
+//
+// @return If {@code to} is {@code null}, this method returns {@code null};
+// otherwise this method returns the result of calling {@link //addDFAState}
+// on {@code to}
+//
+ParserATNSimulator.prototype.addDFAEdge = function(dfa, from_, t, to) {
+    if( this.debug) {
+        console.log("EDGE " + from_ + " -> " + to + " upon " + this.getTokenName(t));
+    }
+    if (to===null) {
+        return null;
+    }
+    to = this.addDFAState(dfa, to); // used existing if possible not incoming
+    if (from_===null || t < -1 || t > this.atn.maxTokenType) {
+        return to;
+    }
+    if (from_.edges===null) {
+        from_.edges = [];
+    }
+    from_.edges[t+1] = to; // connect
+
+    if (this.debug) {
+        var names = this.parser===null ? null : this.parser.literalNames;
+        console.log("DFA=\n" + dfa.toString(names));
+    }
+    return to;
+};
+//
+// Add state {@code D} to the DFA if it is not already present, and return
+// the actual instance stored in the DFA. If a state equivalent to {@code D}
+// is already in the DFA, the existing state is returned. Otherwise this
+// method returns {@code D} after adding it to the DFA.
+//
+// <p>If {@code D} is {@link //ERROR}, this method returns {@link //ERROR} and
+// does not change the DFA.</p>
+//
+// @param dfa The dfa
+// @param D The DFA state to add
+// @return The state stored in the DFA. This will be either the existing
+// state if {@code D} is already in the DFA, or {@code D} itself if the
+// state was not already present.
+//
+ParserATNSimulator.prototype.addDFAState = function(dfa, D) {
+    if (D == ATNSimulator.ERROR) {
+        return D;
+    }
+    var hash = D.hashString();
+    var existing = dfa.states[hash] || null;
+    if(existing!==null) {
+        return existing;
+    }
+    D.stateNumber = dfa.states.length;
+    if (! D.configs.readOnly) {
+        D.configs.optimizeConfigs(this);
+        D.configs.setReadonly(true);
+    }
+    dfa.states[hash] = D;
+    if (this.debug) {
+        console.log("adding new DFA state: " + D);
+    }
+    return D;
+};
+
+ParserATNSimulator.prototype.reportAttemptingFullContext = function(dfa, conflictingAlts, configs, startIndex, stopIndex) {
+    if (this.debug || this.retry_debug) {
+        var interval = new Interval(startIndex, stopIndex + 1);
+        console.log("reportAttemptingFullContext decision=" + dfa.decision + ":" + configs +
+                           ", input=" + this.parser.getTokenStream().getText(interval));
+    }
+    if (this.parser!==null) {
+        this.parser.getErrorListenerDispatch().reportAttemptingFullContext(this.parser, dfa, startIndex, stopIndex, conflictingAlts, configs);
+    }
+};
+
+ParserATNSimulator.prototype.reportContextSensitivity = function(dfa, prediction, configs, startIndex, stopIndex) {
+    if (this.debug || this.retry_debug) {
+        var interval = new Interval(startIndex, stopIndex + 1);
+        console.log("reportContextSensitivity decision=" + dfa.decision + ":" + configs +
+                           ", input=" + this.parser.getTokenStream().getText(interval));
+    }
+    if (this.parser!==null) {
+        this.parser.getErrorListenerDispatch().reportContextSensitivity(this.parser, dfa, startIndex, stopIndex, prediction, configs);
+    }
+};
+    
+// If context sensitive parsing, we know it's ambiguity not conflict//
+ParserATNSimulator.prototype.reportAmbiguity = function(dfa, D, startIndex, stopIndex,
+                               exact, ambigAlts, configs ) {
+    if (this.debug || this.retry_debug) {
+        var interval = new Interval(startIndex, stopIndex + 1);
+        console.log("reportAmbiguity " + ambigAlts + ":" + configs +
+                           ", input=" + this.parser.getTokenStream().getText(interval));
+    }
+    if (this.parser!==null) {
+        this.parser.getErrorListenerDispatch().reportAmbiguity(this.parser, dfa, startIndex, stopIndex, exact, ambigAlts, configs);
+    }
+};
+            
+exports.ParserATNSimulator = ParserATNSimulator;
\ No newline at end of file
diff --git a/runtime/JavaScript/src/antlr4/atn/PredictionMode.js b/runtime/JavaScript/src/antlr4/atn/PredictionMode.js
new file mode 100644
index 000000000..c04d502ba
--- /dev/null
+++ b/runtime/JavaScript/src/antlr4/atn/PredictionMode.js
@@ -0,0 +1,586 @@
+//
+// [The "BSD license"]
+//  Copyright (c) 2012 Terence Parr
+//  Copyright (c) 2012 Sam Harwell
+//  Copyright (c) 2014 Eric Vergnaud
+//  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.
+//
+//
+// This enumeration defines the prediction modes available in ANTLR 4 along with
+// utility methods for analyzing configuration sets for conflicts and/or
+// ambiguities.
+
+var Set = require('./../Utils').Set;
+var BitSet = require('./../Utils').BitSet;
+var AltDict = require('./../Utils').AltDict;
+var ATN = require('./ATN').ATN;
+var RuleStopState = require('./ATNState').RuleStopState;
+var ATNConfigSet = require('./ATNConfigSet').ATNConfigSet;
+var ATNConfig = require('./ATNConfig').ATNConfig;
+var SemanticContext = require('./SemanticContext').SemanticContext;
+
+function PredictionMode() {
+	return this;
+}
+
+//
+// The SLL(*) prediction mode. This prediction mode ignores the current
+// parser context when making predictions. This is the fastest prediction
+// mode, and provides correct results for many grammars. This prediction
+// mode is more powerful than the prediction mode provided by ANTLR 3, but
+// may result in syntax errors for grammar and input combinations which are
+// not SLL.
+//
+// <p>
+// When using this prediction mode, the parser will either return a correct
+// parse tree (i.e. the same parse tree that would be returned with the
+// {@link //LL} prediction mode), or it will report a syntax error. If a
+// syntax error is encountered when using the {@link //SLL} prediction mode,
+// it may be due to either an actual syntax error in the input or indicate
+// that the particular combination of grammar and input requires the more
+// powerful {@link //LL} prediction abilities to complete successfully.</p>
+//
+// <p>
+// This prediction mode does not provide any guarantees for prediction
+// behavior for syntactically-incorrect inputs.</p>
+//
+PredictionMode.SLL = 0;
+//
+// The LL(*) prediction mode. This prediction mode allows the current parser
+// context to be used for resolving SLL conflicts that occur during
+// prediction. This is the fastest prediction mode that guarantees correct
+// parse results for all combinations of grammars with syntactically correct
+// inputs.
+//
+// <p>
+// When using this prediction mode, the parser will make correct decisions
+// for all syntactically-correct grammar and input combinations. However, in
+// cases where the grammar is truly ambiguous this prediction mode might not
+// report a precise answer for <em>exactly which</em> alternatives are
+// ambiguous.</p>
+//
+// <p>
+// This prediction mode does not provide any guarantees for prediction
+// behavior for syntactically-incorrect inputs.</p>
+//
+PredictionMode.LL = 1;
+//
+// The LL(*) prediction mode with exact ambiguity detection. In addition to
+// the correctness guarantees provided by the {@link //LL} prediction mode,
+// this prediction mode instructs the prediction algorithm to determine the
+// complete and exact set of ambiguous alternatives for every ambiguous
+// decision encountered while parsing.
+//
+// <p>
+// This prediction mode may be used for diagnosing ambiguities during
+// grammar development. Due to the performance overhead of calculating sets
+// of ambiguous alternatives, this prediction mode should be avoided when
+// the exact results are not necessary.</p>
+//
+// <p>
+// This prediction mode does not provide any guarantees for prediction
+// behavior for syntactically-incorrect inputs.</p>
+//
+PredictionMode.LL_EXACT_AMBIG_DETECTION = 2;
+
+
+//
+// Computes the SLL prediction termination condition.
+//
+// <p>
+// This method computes the SLL prediction termination condition for both of
+// the following cases.</p>
+//
+// <ul>
+// <li>The usual SLL+LL fallback upon SLL conflict</li>
+// <li>Pure SLL without LL fallback</li>
+// </ul>
+//
+// <p><strong>COMBINED SLL+LL PARSING</strong></p>
+//
+// <p>When LL-fallback is enabled upon SLL conflict, correct predictions are
+// ensured regardless of how the termination condition is computed by this
+// method. Due to the substantially higher cost of LL prediction, the
+// prediction should only fall back to LL when the additional lookahead
+// cannot lead to a unique SLL prediction.</p>
+//
+// <p>Assuming combined SLL+LL parsing, an SLL configuration set with only
+// conflicting subsets should fall back to full LL, even if the
+// configuration sets don't resolve to the same alternative (e.g.
+// {@code {1,2}} and {@code {3,4}}. If there is at least one non-conflicting
+// configuration, SLL could continue with the hopes that more lookahead will
+// resolve via one of those non-conflicting configurations.</p>
+//
+// <p>Here's the prediction termination rule them: SLL (for SLL+LL parsing)
+// stops when it sees only conflicting configuration subsets. In contrast,
+// full LL keeps going when there is uncertainty.</p>
+//
+// <p><strong>HEURISTIC</strong></p>
+//
+// <p>As a heuristic, we stop prediction when we see any conflicting subset
+// unless we see a state that only has one alternative associated with it.
+// The single-alt-state thing lets prediction continue upon rules like
+// (otherwise, it would admit defeat too soon):</p>
+//
+// <p>{@code [12|1|[], 6|2|[], 12|2|[]]. s : (ID | ID ID?) ';' ;}</p>
+//
+// <p>When the ATN simulation reaches the state before {@code ';'}, it has a
+// DFA state that looks like: {@code [12|1|[], 6|2|[], 12|2|[]]}. Naturally
+// {@code 12|1|[]} and {@code 12|2|[]} conflict, but we cannot stop
+// processing this node because alternative to has another way to continue,
+// via {@code [6|2|[]]}.</p>
+//
+// <p>It also let's us continue for this rule:</p>
+//
+// <p>{@code [1|1|[], 1|2|[], 8|3|[]] a : A | A | A B ;}</p>
+//
+// <p>After matching input A, we reach the stop state for rule A, state 1.
+// State 8 is the state right before B. Clearly alternatives 1 and 2
+// conflict and no amount of further lookahead will separate the two.
+// However, alternative 3 will be able to continue and so we do not stop
+// working on this state. In the previous example, we're concerned with
+// states associated with the conflicting alternatives. Here alt 3 is not
+// associated with the conflicting configs, but since we can continue
+// looking for input reasonably, don't declare the state done.</p>
+//
+// <p><strong>PURE SLL PARSING</strong></p>
+//
+// <p>To handle pure SLL parsing, all we have to do is make sure that we
+// combine stack contexts for configurations that differ only by semantic
+// predicate. From there, we can do the usual SLL termination heuristic.</p>
+//
+// <p><strong>PREDICATES IN SLL+LL PARSING</strong></p>
+//
+// <p>SLL decisions don't evaluate predicates until after they reach DFA stop
+// states because they need to create the DFA cache that works in all
+// semantic situations. In contrast, full LL evaluates predicates collected
+// during start state computation so it can ignore predicates thereafter.
+// This means that SLL termination detection can totally ignore semantic
+// predicates.</p>
+//
+// <p>Implementation-wise, {@link ATNConfigSet} combines stack contexts but not
+// semantic predicate contexts so we might see two configurations like the
+// following.</p>
+//
+// <p>{@code (s, 1, x, {}), (s, 1, x', {p})}</p>
+//
+// <p>Before testing these configurations against others, we have to merge
+// {@code x} and {@code x'} (without modifying the existing configurations).
+// For example, we test {@code (x+x')==x''} when looking for conflicts in
+// the following configurations.</p>
+//
+// <p>{@code (s, 1, x, {}), (s, 1, x', {p}), (s, 2, x'', {})}</p>
+//
+// <p>If the configuration set has predicates (as indicated by
+// {@link ATNConfigSet//hasSemanticContext}), this algorithm makes a copy of
+// the configurations to strip out all of the predicates so that a standard
+// {@link ATNConfigSet} will merge everything ignoring predicates.</p>
+//
+PredictionMode.hasSLLConflictTerminatingPrediction = function( mode, configs) {
+    // Configs in rule stop states indicate reaching the end of the decision
+    // rule (local context) or end of start rule (full context). If all
+    // configs meet this condition, then none of the configurations is able
+    // to match additional input so we terminate prediction.
+    //
+    if (PredictionMode.allConfigsInRuleStopStates(configs)) {
+        return true;
+    }
+    // pure SLL mode parsing
+    if (mode === PredictionMode.SLL) {
+        // Don't bother with combining configs from different semantic
+        // contexts if we can fail over to full LL; costs more time
+        // since we'll often fail over anyway.
+        if (configs.hasSemanticContext) {
+            // dup configs, tossing out semantic predicates
+            var dup = new ATNConfigSet();
+            for(var i=0;i<configs.items.length;i++) {
+            	var c = configs.items[i];
+                c = new ATNConfig({semanticContext:SemanticContext.NONE}, c);
+                dup.add(c);
+            }
+            configs = dup;
+        }
+        // now we have combined contexts for configs with dissimilar preds
+    }
+    // pure SLL or combined SLL+LL mode parsing
+    var altsets = PredictionMode.getConflictingAltSubsets(configs);
+    return PredictionMode.hasConflictingAltSet(altsets) && !PredictionMode.hasStateAssociatedWithOneAlt(configs);
+};
+
+// Checks if any configuration in {@code configs} is in a
+// {@link RuleStopState}. Configurations meeting this condition have reached
+// the end of the decision rule (local context) or end of start rule (full
+// context).
+//
+// @param configs the configuration set to test
+// @return {@code true} if any configuration in {@code configs} is in a
+// {@link RuleStopState}, otherwise {@code false}
+PredictionMode.hasConfigInRuleStopState = function(configs) {
+	for(var i=0;i<configs.items.length;i++) {
+		var c = configs.items[i];
+        if (c.state instanceof RuleStopState) {
+            return true;
+        }
+	}
+    return false;
+};
+
+// Checks if all configurations in {@code configs} are in a
+// {@link RuleStopState}. Configurations meeting this condition have reached
+// the end of the decision rule (local context) or end of start rule (full
+// context).
+//
+// @param configs the configuration set to test
+// @return {@code true} if all configurations in {@code configs} are in a
+// {@link RuleStopState}, otherwise {@code false}
+PredictionMode.allConfigsInRuleStopStates = function(configs) {
+	for(var i=0;i<configs.items.length;i++) {
+		var c = configs.items[i];
+        if (!(c.state instanceof RuleStopState)) {
+            return false;
+        }
+	}
+    return true;
+};
+
+//
+// Full LL prediction termination.
+//
+// <p>Can we stop looking ahead during ATN simulation or is there some
+// uncertainty as to which alternative we will ultimately pick, after
+// consuming more input? Even if there are partial conflicts, we might know
+// that everything is going to resolve to the same minimum alternative. That
+// means we can stop since no more lookahead will change that fact. On the
+// other hand, there might be multiple conflicts that resolve to different
+// minimums. That means we need more look ahead to decide which of those
+// alternatives we should predict.</p>
+//
+// <p>The basic idea is to split the set of configurations {@code C}, into
+// conflicting subsets {@code (s, _, ctx, _)} and singleton subsets with
+// non-conflicting configurations. Two configurations conflict if they have
+// identical {@link ATNConfig//state} and {@link ATNConfig//context} values
+// but different {@link ATNConfig//alt} value, e.g. {@code (s, i, ctx, _)}
+// and {@code (s, j, ctx, _)} for {@code i!=j}.</p>
+//
+// <p>Reduce these configuration subsets to the set of possible alternatives.
+// You can compute the alternative subsets in one pass as follows:</p>
+//
+// <p>{@code A_s,ctx = {i | (s, i, ctx, _)}} for each configuration in
+// {@code C} holding {@code s} and {@code ctx} fixed.</p>
+//
+// <p>Or in pseudo-code, for each configuration {@code c} in {@code C}:</p>
+//
+// <pre>
+// map[c] U= c.{@link ATNConfig//alt alt} // map hash/equals uses s and x, not
+// alt and not pred
+// </pre>
+//
+// <p>The values in {@code map} are the set of {@code A_s,ctx} sets.</p>
+//
+// <p>If {@code |A_s,ctx|=1} then there is no conflict associated with
+// {@code s} and {@code ctx}.</p>
+//
+// <p>Reduce the subsets to singletons by choosing a minimum of each subset. If
+// the union of these alternative subsets is a singleton, then no amount of
+// more lookahead will help us. We will always pick that alternative. If,
+// however, there is more than one alternative, then we are uncertain which
+// alternative to predict and must continue looking for resolution. We may
+// or may not discover an ambiguity in the future, even if there are no
+// conflicting subsets this round.</p>
+//
+// <p>The biggest sin is to terminate early because it means we've made a
+// decision but were uncertain as to the eventual outcome. We haven't used
+// enough lookahead. On the other hand, announcing a conflict too late is no
+// big deal; you will still have the conflict. It's just inefficient. It
+// might even look until the end of file.</p>
+//
+// <p>No special consideration for semantic predicates is required because
+// predicates are evaluated on-the-fly for full LL prediction, ensuring that
+// no configuration contains a semantic context during the termination
+// check.</p>
+//
+// <p><strong>CONFLICTING CONFIGS</strong></p>
+//
+// <p>Two configurations {@code (s, i, x)} and {@code (s, j, x')}, conflict
+// when {@code i!=j} but {@code x=x'}. Because we merge all
+// {@code (s, i, _)} configurations together, that means that there are at
+// most {@code n} configurations associated with state {@code s} for
+// {@code n} possible alternatives in the decision. The merged stacks
+// complicate the comparison of configuration contexts {@code x} and
+// {@code x'}. Sam checks to see if one is a subset of the other by calling
+// merge and checking to see if the merged result is either {@code x} or
+// {@code x'}. If the {@code x} associated with lowest alternative {@code i}
+// is the superset, then {@code i} is the only possible prediction since the
+// others resolve to {@code min(i)} as well. However, if {@code x} is
+// associated with {@code j>i} then at least one stack configuration for
+// {@code j} is not in conflict with alternative {@code i}. The algorithm
+// should keep going, looking for more lookahead due to the uncertainty.</p>
+//
+// <p>For simplicity, I'm doing a equality check between {@code x} and
+// {@code x'} that lets the algorithm continue to consume lookahead longer
+// than necessary. The reason I like the equality is of course the
+// simplicity but also because that is the test you need to detect the
+// alternatives that are actually in conflict.</p>
+//
+// <p><strong>CONTINUE/STOP RULE</strong></p>
+//
+// <p>Continue if union of resolved alternative sets from non-conflicting and
+// conflicting alternative subsets has more than one alternative. We are
+// uncertain about which alternative to predict.</p>
+//
+// <p>The complete set of alternatives, {@code [i for (_,i,_)]}, tells us which
+// alternatives are still in the running for the amount of input we've
+// consumed at this point. The conflicting sets let us to strip away
+// configurations that won't lead to more states because we resolve
+// conflicts to the configuration with a minimum alternate for the
+// conflicting set.</p>
+//
+// <p><strong>CASES</strong></p>
+//
+// <ul>
+//
+// <li>no conflicts and more than 1 alternative in set =&gt; continue</li>
+//
+// <li> {@code (s, 1, x)}, {@code (s, 2, x)}, {@code (s, 3, z)},
+// {@code (s', 1, y)}, {@code (s', 2, y)} yields non-conflicting set
+// {@code {3}} U conflicting sets {@code min({1,2})} U {@code min({1,2})} =
+// {@code {1,3}} =&gt; continue
+// </li>
+//
+// <li>{@code (s, 1, x)}, {@code (s, 2, x)}, {@code (s', 1, y)},
+// {@code (s', 2, y)}, {@code (s'', 1, z)} yields non-conflicting set
+// {@code {1}} U conflicting sets {@code min({1,2})} U {@code min({1,2})} =
+// {@code {1}} =&gt; stop and predict 1</li>
+//
+// <li>{@code (s, 1, x)}, {@code (s, 2, x)}, {@code (s', 1, y)},
+// {@code (s', 2, y)} yields conflicting, reduced sets {@code {1}} U
+// {@code {1}} = {@code {1}} =&gt; stop and predict 1, can announce
+// ambiguity {@code {1,2}}</li>
+//
+// <li>{@code (s, 1, x)}, {@code (s, 2, x)}, {@code (s', 2, y)},
+// {@code (s', 3, y)} yields conflicting, reduced sets {@code {1}} U
+// {@code {2}} = {@code {1,2}} =&gt; continue</li>
+//
+// <li>{@code (s, 1, x)}, {@code (s, 2, x)}, {@code (s', 3, y)},
+// {@code (s', 4, y)} yields conflicting, reduced sets {@code {1}} U
+// {@code {3}} = {@code {1,3}} =&gt; continue</li>
+//
+// </ul>
+//
+// <p><strong>EXACT AMBIGUITY DETECTION</strong></p>
+//
+// <p>If all states report the same conflicting set of alternatives, then we
+// know we have the exact ambiguity set.</p>
+//
+// <p><code>|A_<em>i</em>|&gt;1</code> and
+// <code>A_<em>i</em> = A_<em>j</em></code> for all <em>i</em>, <em>j</em>.</p>
+//
+// <p>In other words, we continue examining lookahead until all {@code A_i}
+// have more than one alternative and all {@code A_i} are the same. If
+// {@code A={{1,2}, {1,3}}}, then regular LL prediction would terminate
+// because the resolved set is {@code {1}}. To determine what the real
+// ambiguity is, we have to know whether the ambiguity is between one and
+// two or one and three so we keep going. We can only stop prediction when
+// we need exact ambiguity detection when the sets look like
+// {@code A={{1,2}}} or {@code {{1,2},{1,2}}}, etc...</p>
+//
+PredictionMode.resolvesToJustOneViableAlt = function(altsets) {
+    return PredictionMode.getSingleViableAlt(altsets);
+};
+
+//
+// Determines if every alternative subset in {@code altsets} contains more
+// than one alternative.
+//
+// @param altsets a collection of alternative subsets
+// @return {@code true} if every {@link BitSet} in {@code altsets} has
+// {@link BitSet//cardinality cardinality} &gt; 1, otherwise {@code false}
+//
+PredictionMode.allSubsetsConflict = function(altsets) {
+    return ! PredictionMode.hasNonConflictingAltSet(altsets);
+};
+//
+// Determines if any single alternative subset in {@code altsets} contains
+// exactly one alternative.
+//
+// @param altsets a collection of alternative subsets
+// @return {@code true} if {@code altsets} contains a {@link BitSet} with
+// {@link BitSet//cardinality cardinality} 1, otherwise {@code false}
+//
+PredictionMode.hasNonConflictingAltSet = function(altsets) {
+	for(var i=0;i<altsets.length;i++) {
+		var alts = altsets[i];
+        if (alts.length===1) {
+            return true;
+        }
+	}
+    return false;
+};
+
+//
+// Determines if any single alternative subset in {@code altsets} contains
+// more than one alternative.
+//
+// @param altsets a collection of alternative subsets
+// @return {@code true} if {@code altsets} contains a {@link BitSet} with
+// {@link BitSet//cardinality cardinality} &gt; 1, otherwise {@code false}
+//
+PredictionMode.hasConflictingAltSet = function(altsets) {
+	for(var i=0;i<altsets.length;i++) {
+		var alts = altsets[i];
+        if (alts.length>1) {
+            return true;
+        }
+	}
+    return false;
+};
+
+//
+// Determines if every alternative subset in {@code altsets} is equivalent.
+//
+// @param altsets a collection of alternative subsets
+// @return {@code true} if every member of {@code altsets} is equal to the
+// others, otherwise {@code false}
+//
+PredictionMode.allSubsetsEqual = function(altsets) {
+    var first = null;
+	for(var i=0;i<altsets.length;i++) {
+		var alts = altsets[i];
+        if (first === null) {
+            first = alts;
+        } else if (alts!==first) {
+            return false;
+        }
+	}
+    return true;
+};
+
+//
+// Returns the unique alternative predicted by all alternative subsets in
+// {@code altsets}. If no such alternative exists, this method returns
+// {@link ATN//INVALID_ALT_NUMBER}.
+//
+// @param altsets a collection of alternative subsets
+//
+PredictionMode.getUniqueAlt = function(altsets) {
+    var all = PredictionMode.getAlts(altsets);
+    if (all.length===1) {
+        return all.minValue();
+    } else {
+        return ATN.INVALID_ALT_NUMBER;
+    }
+};
+
+// Gets the complete set of represented alternatives for a collection of
+// alternative subsets. This method returns the union of each {@link BitSet}
+// in {@code altsets}.
+//
+// @param altsets a collection of alternative subsets
+// @return the set of represented alternatives in {@code altsets}
+//
+PredictionMode.getAlts = function(altsets) {
+    var all = new BitSet();
+    altsets.map( function(alts) { all.or(alts); });
+    return all;
+};
+
+//
+// This function gets the conflicting alt subsets from a configuration set.
+// For each configuration {@code c} in {@code configs}:
+//
+// <pre>
+// map[c] U= c.{@link ATNConfig//alt alt} // map hash/equals uses s and x, not
+// alt and not pred
+// </pre>
+//
+PredictionMode.getConflictingAltSubsets = function(configs) {
+    var configToAlts = {};
+	for(var i=0;i<configs.items.length;i++) {
+		var c = configs.items[i];
+        var key = "key_" + c.state.stateNumber + "/" + c.context;
+        var alts = configToAlts[key] || null;
+        if (alts === null) {
+            alts = new BitSet();
+            configToAlts[key] = alts;
+        }
+        alts.add(c.alt);
+	}
+	var values = [];
+	for(var k in configToAlts) {
+		if(k.indexOf("key_")!==0) {
+			continue;
+		}
+		values.push(configToAlts[k]);
+	}
+    return values;
+};
+
+//
+// Get a map from state to alt subset from a configuration set. For each
+// configuration {@code c} in {@code configs}:
+//
+// <pre>
+// map[c.{@link ATNConfig//state state}] U= c.{@link ATNConfig//alt alt}
+// </pre>
+//
+PredictionMode.getStateToAltMap = function(configs) {
+    var m = new AltDict();
+    configs.items.map(function(c) {
+        var alts = m.get(c.state);
+        if (alts === null) {
+            alts = new BitSet();
+            m.put(c.state, alts);
+        }
+        alts.add(c.alt);
+    });
+    return m;
+};
+
+PredictionMode.hasStateAssociatedWithOneAlt = function(configs) {
+    var values = PredictionMode.getStateToAltMap(configs).values();
+    for(var i=0;i<values.length;i++) {
+        if (values[i].length===1) {
+            return true;
+        }
+    }
+    return false;
+};
+
+PredictionMode.getSingleViableAlt = function(altsets) {
+    var result = null;
+	for(var i=0;i<altsets.length;i++) {
+		var alts = altsets[i];
+        var minAlt = alts.minValue();
+        if(result===null) {
+            result = minAlt;
+        } else if(result!==minAlt) { // more than 1 viable alt
+            return ATN.INVALID_ALT_NUMBER;
+        }
+	}
+    return result;
+};
+
+exports.PredictionMode = PredictionMode;
diff --git a/runtime/JavaScript/src/antlr4/atn/SemanticContext.js b/runtime/JavaScript/src/antlr4/atn/SemanticContext.js
new file mode 100644
index 000000000..05210e988
--- /dev/null
+++ b/runtime/JavaScript/src/antlr4/atn/SemanticContext.js
@@ -0,0 +1,421 @@
+//
+// [The "BSD license"]
+//  Copyright (c) 2012 Terence Parr
+//  Copyright (c) 2012 Sam Harwell
+//  Copyright (c) 2014 Eric Vergnaud
+//  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 tree structure used to record the semantic context in which
+//  an ATN configuration is valid.  It's either a single predicate,
+//  a conjunction {@code p1&&p2}, or a sum of products {@code p1||p2}.
+//
+//  <p>I have scoped the {@link AND}, {@link OR}, and {@link Predicate} subclasses of
+//  {@link SemanticContext} within the scope of this outer class.</p>
+//
+
+var Set = require('./../Utils').Set;
+
+function SemanticContext() {
+	return this;
+}
+
+// For context independent predicates, we evaluate them without a local
+// context (i.e., null context). That way, we can evaluate them without
+// having to create proper rule-specific context during prediction (as
+// opposed to the parser, which creates them naturally). In a practical
+// sense, this avoids a cast exception from RuleContext to myruleContext.
+//
+// <p>For context dependent predicates, we must pass in a local context so that
+// references such as $arg evaluate properly as _localctx.arg. We only
+// capture context dependent predicates in the context in which we begin
+// prediction, so we passed in the outer context here in case of context
+// dependent predicate evaluation.</p>
+//
+SemanticContext.prototype.evaluate = function(parser, outerContext) {
+};
+
+//
+// Evaluate the precedence predicates for the context and reduce the result.
+//
+// @param parser The parser instance.
+// @param outerContext The current parser context object.
+// @return The simplified semantic context after precedence predicates are
+// evaluated, which will be one of the following values.
+// <ul>
+// <li>{@link //NONE}: if the predicate simplifies to {@code true} after
+// precedence predicates are evaluated.</li>
+// <li>{@code null}: if the predicate simplifies to {@code false} after
+// precedence predicates are evaluated.</li>
+// <li>{@code this}: if the semantic context is not changed as a result of
+// precedence predicate evaluation.</li>
+// <li>A non-{@code null} {@link SemanticContext}: the new simplified
+// semantic context after precedence predicates are evaluated.</li>
+// </ul>
+//
+SemanticContext.prototype.evalPrecedence = function(parser, outerContext) {
+	return this;
+};
+
+SemanticContext.andContext = function(a, b) {
+	if (a === null || a === SemanticContext.NONE) {
+		return b;
+	}
+	if (b === null || b === SemanticContext.NONE) {
+		return a;
+	}
+	var result = new AND(a, b);
+	if (result.opnds.length === 1) {
+		return result.opnds[0];
+	} else {
+		return result;
+	}
+};
+
+SemanticContext.orContext = function(a, b) {
+	if (a === null) {
+		return b;
+	}
+	if (b === null) {
+		return a;
+	}
+	if (a === SemanticContext.NONE || b === SemanticContext.NONE) {
+		return SemanticContext.NONE;
+	}
+	var result = new OR(a, b);
+	if (result.opnds.length === 1) {
+		return result.opnds[0];
+	} else {
+		return result;
+	}
+};
+
+function Predicate(ruleIndex, predIndex, isCtxDependent) {
+	SemanticContext.call(this);
+	this.ruleIndex = ruleIndex === undefined ? -1 : ruleIndex;
+	this.predIndex = predIndex === undefined ? -1 : predIndex;
+	this.isCtxDependent = isCtxDependent === undefined ? false : isCtxDependent; // e.g., $i ref in pred
+	return this;
+}
+
+Predicate.prototype = Object.create(SemanticContext.prototype);
+Predicate.prototype.constructor = Predicate;
+
+//The default {@link SemanticContext}, which is semantically equivalent to
+//a predicate of the form {@code {true}?}.
+//
+SemanticContext.NONE = new Predicate();
+
+
+Predicate.prototype.evaluate = function(parser, outerContext) {
+	var localctx = this.isCtxDependent ? outerContext : null;
+	return parser.sempred(localctx, this.ruleIndex, this.predIndex);
+};
+
+Predicate.prototype.hashString = function() {
+	return "" + this.ruleIndex + "/" + this.predIndex + "/" + this.isCtxDependent;
+};
+
+Predicate.prototype.equals = function(other) {
+	if (this === other) {
+		return true;
+	} else if (!(other instanceof Predicate)) {
+		return false;
+	} else {
+		return this.ruleIndex === other.ruleIndex &&
+				this.predIndex === other.predIndex &&
+				this.isCtxDependent === other.isCtxDependent;
+	}
+};
+
+Predicate.prototype.toString = function() {
+	return "{" + this.ruleIndex + ":" + this.predIndex + "}?";
+};
+
+function PrecedencePredicate(precedence) {
+	SemanticContext.call(this);
+	this.precedence = precedence === undefined ? 0 : precedence;
+}
+
+PrecedencePredicate.prototype = Object.create(SemanticContext.prototype);
+PrecedencePredicate.prototype.constructor = PrecedencePredicate;
+
+PrecedencePredicate.prototype.evaluate = function(parser, outerContext) {
+	return parser.precpred(outerContext, this.precedence);
+};
+
+PrecedencePredicate.prototype.evalPrecedence = function(parser, outerContext) {
+	if (parser.precpred(outerContext, this.precedence)) {
+		return SemanticContext.NONE;
+	} else {
+		return null;
+	}
+};
+
+PrecedencePredicate.prototype.compareTo = function(other) {
+	return this.precedence - other.precedence;
+};
+
+PrecedencePredicate.prototype.hashString = function() {
+	return "31";
+};
+
+PrecedencePredicate.prototype.equals = function(other) {
+	if (this === other) {
+		return true;
+	} else if (!(other instanceof PrecedencePredicate)) {
+		return false;
+	} else {
+		return this.precedence === other.precedence;
+	}
+};
+
+PrecedencePredicate.prototype.toString = function() {
+	return "{"+this.precedence+">=prec}?";
+};
+
+
+
+PrecedencePredicate.filterPrecedencePredicates = function(set) {
+	var result = [];
+	set.values().map( function(context) {
+		if (context instanceof PrecedencePredicate) {
+			result.push(context);
+		}
+	});
+	return result;
+};
+
+
+// A semantic context which is true whenever none of the contained contexts
+// is false.
+//
+function AND(a, b) {
+	SemanticContext.call(this);
+	var operands = new Set();
+	if (a instanceof AND) {
+		a.opnds.map(function(o) {
+			operands.add(o);
+		});
+	} else {
+		operands.add(a);
+	}
+	if (b instanceof AND) {
+		b.opnds.map(function(o) {
+			operands.add(o);
+		});
+	} else {
+		operands.add(b);
+	}
+	var precedencePredicates = PrecedencePredicate.filterPrecedencePredicates(operands);
+	if (precedencePredicates.length > 0) {
+		// interested in the transition with the lowest precedence
+		var reduced = null;
+		precedencePredicates.map( function(p) {
+			if(reduced===null || p.precedence<reduced.precedence) {
+				reduced = p;
+			}
+		});
+		operands.add(reduced);
+	}
+	this.opnds = operands.values();
+	return this;
+}
+
+AND.prototype = Object.create(SemanticContext.prototype);
+AND.prototype.constructor = AND;
+
+AND.prototype.equals = function(other) {
+	if (this === other) {
+		return true;
+	} else if (!(other instanceof AND)) {
+		return false;
+	} else {
+		return this.opnds === other.opnds;
+	}
+};
+
+AND.prototype.hashString = function() {
+	return "" + this.opnds + "/AND";
+};
+//
+// {@inheritDoc}
+//
+// <p>
+// The evaluation of predicates by this context is short-circuiting, but
+// unordered.</p>
+//
+AND.prototype.evaluate = function(parser, outerContext) {
+	for (var i = 0; i < this.opnds.length; i++) {
+		if (!this.opnds[i].evaluate(parser, outerContext)) {
+			return false;
+		}
+	}
+	return true;
+};
+
+AND.prototype.evalPrecedence = function(parser, outerContext) {
+	var differs = false;
+	var operands = [];
+	for (var i = 0; i < this.opnds.length; i++) {
+		var context = this.opnds[i];
+		var evaluated = context.evalPrecedence(parser, outerContext);
+		differs |= (evaluated !== context);
+		if (evaluated === null) {
+			// The AND context is false if any element is false
+			return null;
+		} else if (evaluated !== SemanticContext.NONE) {
+			// Reduce the result by skipping true elements
+			operands.push(evaluated);
+		}
+	}
+	if (!differs) {
+		return this;
+	}
+	if (operands.length === 0) {
+		// all elements were true, so the AND context is true
+		return SemanticContext.NONE;
+	}
+	var result = null;
+	operands.map(function(o) {
+		result = result === null ? o : SemanticContext.andContext(result, o);
+	});
+	return result;
+};
+
+AND.prototype.toString = function() {
+	var s = "";
+	this.opnds.map(function(o) {
+		s += "&& " + o.toString();
+	});
+	return s.length > 3 ? s.slice(3) : s;
+};
+
+//
+// A semantic context which is true whenever at least one of the contained
+// contexts is true.
+//
+function OR(a, b) {
+	SemanticContext.call(this);
+	var operands = new Set();
+	if (a instanceof OR) {
+		a.opnds.map(function(o) {
+			operands.add(o);
+		});
+	} else {
+		operands.add(a);
+	}
+	if (b instanceof OR) {
+		b.opnds.map(function(o) {
+			operands.add(o);
+		});
+	} else {
+		operands.add(b);
+	}
+
+	var precedencePredicates = PrecedencePredicate.filterPrecedencePredicates(operands);
+	if (precedencePredicates.length > 0) {
+		// interested in the transition with the highest precedence
+		var s = precedencePredicates.sort(function(a, b) {
+			return a.compareTo(b);
+		});
+		var reduced = s[s.length-1];
+		operands.add(reduced);
+	}
+	this.opnds = operands.values();
+	return this;
+}
+
+OR.prototype = Object.create(SemanticContext.prototype);
+OR.prototype.constructor = OR;
+
+OR.prototype.constructor = function(other) {
+	if (this === other) {
+		return true;
+	} else if (!(other instanceof OR)) {
+		return false;
+	} else {
+		return this.opnds === other.opnds;
+	}
+};
+
+OR.prototype.hashString = function() {
+	return "" + this.opnds + "/OR"; 
+};
+
+// <p>
+// The evaluation of predicates by this context is short-circuiting, but
+// unordered.</p>
+//
+OR.prototype.evaluate = function(parser, outerContext) {
+	for (var i = 0; i < this.opnds.length; i++) {
+		if (this.opnds[i].evaluate(parser, outerContext)) {
+			return true;
+		}
+	}
+	return false;
+};
+
+OR.prototype.evalPrecedence = function(parser, outerContext) {
+	var differs = false;
+	var operands = [];
+	for (var i = 0; i < this.opnds.length; i++) {
+		var context = this.opnds[i];
+		var evaluated = context.evalPrecedence(parser, outerContext);
+		differs |= (evaluated !== context);
+		if (evaluated === SemanticContext.NONE) {
+			// The OR context is true if any element is true
+			return SemanticContext.NONE;
+		} else if (evaluated !== null) {
+			// Reduce the result by skipping false elements
+			operands.push(evaluated);
+		}
+	}
+	if (!differs) {
+		return this;
+	}
+	if (operands.length === 0) {
+		// all elements were false, so the OR context is false
+		return null;
+	}
+	var result = null;
+	operands.map(function(o) {
+		return result === null ? o : SemanticContext.orContext(result, o);
+	});
+	return result;
+};
+
+OR.prototype.toString = function() {
+	var s = "";
+	this.opnds.map(function(o) {
+		s += "|| " + o.toString();
+	});
+	return s.length > 3 ? s.slice(3) : s;
+};
+
+exports.SemanticContext = SemanticContext;
+exports.PrecedencePredicate = PrecedencePredicate;
+exports.Predicate = Predicate;
diff --git a/runtime/JavaScript/src/antlr4/atn/Transition.js b/runtime/JavaScript/src/antlr4/atn/Transition.js
new file mode 100644
index 000000000..99f6df8b1
--- /dev/null
+++ b/runtime/JavaScript/src/antlr4/atn/Transition.js
@@ -0,0 +1,340 @@
+// [The "BSD license"]
+//  Copyright (c) 2012 Terence Parr
+//  Copyright (c) 2012 Sam Harwell
+//  Copyright (c) 2014 Eric Vergnaud
+//  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.
+//
+
+//  An ATN transition between any two ATN states.  Subclasses define
+//  atom, set, epsilon, action, predicate, rule transitions.
+//
+//  <p>This is a one way link.  It emanates from a state (usually via a list of
+//  transitions) and has a target state.</p>
+//
+//  <p>Since we never have to change the ATN transitions once we construct it,
+//  we can fix these transitions as specific classes. The DFA transitions
+//  on the other hand need to update the labels as it adds transitions to
+//  the states. We'll use the term Edge for the DFA to distinguish them from
+//  ATN transitions.</p>
+
+var Token = require('./../Token').Token;
+var Interval = require('./../IntervalSet').Interval;
+var IntervalSet = require('./../IntervalSet').IntervalSet;
+var Predicate = require('./SemanticContext').Predicate;
+var PrecedencePredicate = require('./SemanticContext').PrecedencePredicate;
+
+function Transition (target) {
+    // The target of this transition.
+    if (target===undefined || target===null) {
+        throw "target cannot be null.";
+    }
+    this.target = target;
+    // Are we epsilon, action, sempred?
+    this.isEpsilon = false;
+    this.label = null;
+    return this;
+}
+    // constants for serialization
+Transition.EPSILON = 1;
+Transition.RANGE = 2;
+Transition.RULE = 3;
+Transition.PREDICATE = 4; // e.g., {isType(input.LT(1))}?
+Transition.ATOM = 5;
+Transition.ACTION = 6;
+Transition.SET = 7; // ~(A|B) or ~atom, wildcard, which convert to next 2
+Transition.NOT_SET = 8;
+Transition.WILDCARD = 9;
+Transition.PRECEDENCE = 10;
+
+Transition.serializationNames = [
+            "INVALID",
+            "EPSILON",
+            "RANGE",
+            "RULE",
+            "PREDICATE",
+            "ATOM",
+            "ACTION",
+            "SET",
+            "NOT_SET",
+            "WILDCARD",
+            "PRECEDENCE"
+        ];
+
+Transition.serializationTypes = {
+        EpsilonTransition: Transition.EPSILON,
+        RangeTransition: Transition.RANGE,
+        RuleTransition: Transition.RULE,
+        PredicateTransition: Transition.PREDICATE,
+        AtomTransition: Transition.ATOM,
+        ActionTransition: Transition.ACTION,
+        SetTransition: Transition.SET,
+        NotSetTransition: Transition.NOT_SET,
+        WildcardTransition: Transition.WILDCARD,
+        PrecedencePredicateTransition: Transition.PRECEDENCE
+    };
+
+
+// TODO: make all transitions sets? no, should remove set edges
+function AtomTransition(target, label) {
+	Transition.call(this, target);
+	this.label_ = label; // The token type or character value; or, signifies special label.
+    this.label = this.makeLabel();
+    this.serializationType = Transition.ATOM;
+    return this;
+}
+
+AtomTransition.prototype = Object.create(Transition.prototype);
+AtomTransition.prototype.constructor = AtomTransition;
+
+AtomTransition.prototype.makeLabel = function() {
+	var s = new IntervalSet();
+    s.addOne(this.label_);
+    return s;
+};
+
+AtomTransition.prototype.matches = function( symbol, minVocabSymbol,  maxVocabSymbol) {
+    return this.label_ === symbol;
+};
+
+AtomTransition.prototype.toString = function() {
+	return this.label_;
+};
+
+function RuleTransition(ruleStart, ruleIndex, precedence, followState) {
+	Transition.call(this, ruleStart);
+    this.ruleIndex = ruleIndex; // ptr to the rule definition object for this rule ref
+    this.precedence = precedence;
+    this.followState = followState; // what node to begin computations following ref to rule
+    this.serializationType = Transition.RULE;
+    this.isEpsilon = true;
+    return this;
+}
+
+RuleTransition.prototype = Object.create(Transition.prototype);
+RuleTransition.prototype.constructor = RuleTransition;
+
+RuleTransition.prototype.matches = function(symbol, minVocabSymbol,  maxVocabSymbol) {
+	return false;
+};
+
+
+function EpsilonTransition(target, outermostPrecedenceReturn) {
+	Transition.call(this, target);
+    this.serializationType = Transition.EPSILON;
+    this.isEpsilon = true;
+    this.outermostPrecedenceReturn = outermostPrecedenceReturn;
+    return this;
+}
+
+EpsilonTransition.prototype = Object.create(Transition.prototype);
+EpsilonTransition.prototype.constructor = EpsilonTransition;
+
+EpsilonTransition.prototype.matches = function( symbol, minVocabSymbol,  maxVocabSymbol) {
+	return false;
+};
+
+EpsilonTransition.prototype.toString = function() {
+	return "epsilon";
+};
+
+function RangeTransition(target, start, stop) {
+	Transition.call(this, target);
+	this.serializationType = Transition.RANGE;
+    this.start = start;
+    this.stop = stop;
+    this.label = this.makeLabel();
+    return this;
+}
+
+RangeTransition.prototype = Object.create(Transition.prototype);
+RangeTransition.prototype.constructor = RangeTransition;
+
+RangeTransition.prototype.makeLabel = function() {
+    var s = new IntervalSet();
+    s.addRange(this.start, this.stop);
+    return s;
+};
+
+RangeTransition.prototype.matches = function(symbol, minVocabSymbol,  maxVocabSymbol) {
+	return symbol >= this.start && symbol <= this.stop;
+};
+
+RangeTransition.prototype.toString = function() {
+	return "'" + String.fromCharCode(this.start) + "'..'" + String.fromCharCode(this.stop) + "'";
+};
+
+function AbstractPredicateTransition(target) {
+	Transition.call(this, target);
+	return this;
+}
+
+AbstractPredicateTransition.prototype = Object.create(Transition.prototype);
+AbstractPredicateTransition.prototype.constructor = AbstractPredicateTransition;
+
+function PredicateTransition(target, ruleIndex, predIndex, isCtxDependent) {
+	AbstractPredicateTransition.call(this, target);
+    this.serializationType = Transition.PREDICATE;
+    this.ruleIndex = ruleIndex;
+    this.predIndex = predIndex;
+    this.isCtxDependent = isCtxDependent; // e.g., $i ref in pred
+    this.isEpsilon = true;
+    return this;
+}
+
+PredicateTransition.prototype = Object.create(AbstractPredicateTransition.prototype);
+PredicateTransition.prototype.constructor = PredicateTransition;
+
+PredicateTransition.prototype.matches = function(symbol, minVocabSymbol,  maxVocabSymbol) {
+	return false;
+};
+
+PredicateTransition.prototype.getPredicate = function() {
+	return new Predicate(this.ruleIndex, this.predIndex, this.isCtxDependent);
+};
+
+PredicateTransition.prototype.toString = function() {
+	return "pred_" + this.ruleIndex + ":" + this.predIndex;
+};
+
+function ActionTransition(target, ruleIndex, actionIndex, isCtxDependent) {
+	Transition.call(this, target);
+    this.serializationType = Transition.ACTION;
+    this.ruleIndex = ruleIndex;
+    this.actionIndex = actionIndex===undefined ? -1 : actionIndex;
+    this.isCtxDependent = isCtxDependent===undefined ? false : isCtxDependent; // e.g., $i ref in pred
+    this.isEpsilon = true;
+    return this;
+}
+
+ActionTransition.prototype = Object.create(Transition.prototype);
+ActionTransition.prototype.constructor = ActionTransition;
+
+
+ActionTransition.prototype.matches = function(symbol, minVocabSymbol,  maxVocabSymbol) {
+	return false;
+};
+
+ActionTransition.prototype.toString = function() {
+	return "action_" + this.ruleIndex + ":" + this.actionIndex;
+};
+        
+
+// A transition containing a set of values.
+function SetTransition(target, set) {
+	Transition.call(this, target);
+	this.serializationType = Transition.SET;
+    if (set !==undefined && set !==null) {
+        this.label = set;
+    } else {
+        this.label = new IntervalSet();
+        this.label.addOne(Token.INVALID_TYPE);
+    }
+    return this;
+}
+
+SetTransition.prototype = Object.create(Transition.prototype);
+SetTransition.prototype.constructor = SetTransition;
+
+SetTransition.prototype.matches = function(symbol, minVocabSymbol,  maxVocabSymbol) {
+	return this.label.contains(symbol);
+};
+        
+
+SetTransition.prototype.toString = function() {
+	return this.label.toString();
+};
+
+function NotSetTransition(target, set) {
+	SetTransition.call(this, target, set);
+	this.serializationType = Transition.NOT_SET;
+	return this;
+}
+
+NotSetTransition.prototype = Object.create(SetTransition.prototype);
+NotSetTransition.prototype.constructor = NotSetTransition;
+
+NotSetTransition.prototype.matches = function(symbol, minVocabSymbol,  maxVocabSymbol) {
+	return symbol >= minVocabSymbol && symbol <= maxVocabSymbol &&
+			!SetTransition.prototype.matches.call(this, symbol, minVocabSymbol, maxVocabSymbol);
+};
+
+NotSetTransition.prototype.toString = function() {
+	return '~' + SetTransition.prototype.toString.call(this);
+};
+
+function WildcardTransition(target) {
+	Transition.call(this, target);
+	this.serializationType = Transition.WILDCARD;
+	return this;
+}
+
+WildcardTransition.prototype = Object.create(Transition.prototype);
+WildcardTransition.prototype.constructor = WildcardTransition;
+
+
+WildcardTransition.prototype.matches = function(symbol, minVocabSymbol,  maxVocabSymbol) {
+	return symbol >= minVocabSymbol && symbol <= maxVocabSymbol;
+};
+
+WildcardTransition.prototype.toString = function() {
+	return ".";
+};
+
+function PrecedencePredicateTransition(target, precedence) {
+	AbstractPredicateTransition.call(this, target);
+    this.serializationType = Transition.PRECEDENCE;
+    this.precedence = precedence;
+    this.isEpsilon = true;
+    return this;
+}
+
+PrecedencePredicateTransition.prototype = Object.create(AbstractPredicateTransition.prototype);
+PrecedencePredicateTransition.prototype.constructor = PrecedencePredicateTransition;
+
+PrecedencePredicateTransition.prototype.matches = function(symbol, minVocabSymbol,  maxVocabSymbol) {
+	return false;
+};
+
+PrecedencePredicateTransition.prototype.getPredicate = function() {
+	return new PrecedencePredicate(this.precedence);
+};
+
+PrecedencePredicateTransition.prototype.toString = function() {
+	return this.precedence + " >= _p";
+};
+        
+exports.Transition = Transition;
+exports.AtomTransition = AtomTransition;
+exports.SetTransition = SetTransition;
+exports.NotSetTransition = NotSetTransition;
+exports.RuleTransition = RuleTransition;
+exports.ActionTransition = ActionTransition;
+exports.EpsilonTransition = EpsilonTransition;
+exports.RangeTransition = RangeTransition;
+exports.WildcardTransition = WildcardTransition;
+exports.PredicateTransition = PredicateTransition;
+exports.PrecedencePredicateTransition = PrecedencePredicateTransition;
+exports.AbstractPredicateTransition = AbstractPredicateTransition;
\ No newline at end of file
diff --git a/runtime/JavaScript/src/antlr4/atn/index.js b/runtime/JavaScript/src/antlr4/atn/index.js
new file mode 100644
index 000000000..1b8dfddd5
--- /dev/null
+++ b/runtime/JavaScript/src/antlr4/atn/index.js
@@ -0,0 +1,5 @@
+exports.ATN = require('./ATN').ATN;
+exports.ATNDeserializer = require('./ATNDeserializer').ATNDeserializer;
+exports.LexerATNSimulator = require('./LexerATNSimulator').LexerATNSimulator;
+exports.ParserATNSimulator = require('./ParserATNSimulator').ParserATNSimulator;
+exports.PredictionMode = require('./PredictionMode').PredictionMode;
\ No newline at end of file
diff --git a/runtime/JavaScript/src/antlr4/dfa/DFA.js b/runtime/JavaScript/src/antlr4/dfa/DFA.js
new file mode 100644
index 000000000..d93d9c5ab
--- /dev/null
+++ b/runtime/JavaScript/src/antlr4/dfa/DFA.js
@@ -0,0 +1,177 @@
+//
+// [The "BSD license"]
+//  Copyright (c) 2012 Terence Parr
+//  Copyright (c) 2012 Sam Harwell
+//  Copyright (c) 2014 Eric Vergnaud
+//  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.
+
+var DFAState = require('./DFAState').DFAState;
+var ATNConfigSet = require('./../atn/ATNConfigSet').ATNConfigSet;
+var DFASerializer = require('./DFASerializer').DFASerializer;
+var LexerDFASerializer = require('./DFASerializer').LexerDFASerializer;
+
+function DFAStatesSet() {
+	return this;
+}
+
+Object.defineProperty(DFAStatesSet.prototype, "length", {
+	get : function() {
+		return Object.keys(this).length;
+	}
+});
+
+function DFA(atnStartState, decision) {
+	if (decision === undefined) {
+		decision = 0;
+	}
+	// From which ATN state did we create this DFA?
+	this.atnStartState = atnStartState;
+	this.decision = decision;
+	// A set of all DFA states. Use {@link Map} so we can get old state back
+	// ({@link Set} only allows you to see if it's there).
+	this._states = new DFAStatesSet();
+	this.s0 = null;
+	// {@code true} if this DFA is for a precedence decision; otherwise,
+	// {@code false}. This is the backing field for {@link //isPrecedenceDfa},
+	// {@link //setPrecedenceDfa}.
+	this.precedenceDfa = false;
+	return this;
+}
+
+// Get the start state for a specific precedence value.
+//
+// @param precedence The current precedence.
+// @return The start state corresponding to the specified precedence, or
+// {@code null} if no start state exists for the specified precedence.
+//
+// @throws IllegalStateException if this is not a precedence DFA.
+// @see //isPrecedenceDfa()
+
+DFA.prototype.getPrecedenceStartState = function(precedence) {
+	if (!(this.precedenceDfa)) {
+		throw ("Only precedence DFAs may contain a precedence start state.");
+	}
+	// s0.edges is never null for a precedence DFA
+	if (precedence < 0 || precedence >= this.s0.edges.length) {
+		return null;
+	}
+	return this.s0.edges[precedence] || null;
+};
+
+// Set the start state for a specific precedence value.
+//
+// @param precedence The current precedence.
+// @param startState The start state corresponding to the specified
+// precedence.
+//
+// @throws IllegalStateException if this is not a precedence DFA.
+// @see //isPrecedenceDfa()
+//
+DFA.prototype.setPrecedenceStartState = function(precedence, startState) {
+	if (!(this.precedenceDfa)) {
+		throw ("Only precedence DFAs may contain a precedence start state.");
+	}
+	if (precedence < 0) {
+		return;
+	}
+
+	// synchronization on s0 here is ok. when the DFA is turned into a
+	// precedence DFA, s0 will be initialized once and not updated again
+	// s0.edges is never null for a precedence DFA
+	this.s0.edges[precedence] = startState;
+};
+
+//
+// Sets whether this is a precedence DFA. If the specified value differs
+// from the current DFA configuration, the following actions are taken;
+// otherwise no changes are made to the current DFA.
+//
+// <ul>
+// <li>The {@link //states} map is cleared</li>
+// <li>If {@code precedenceDfa} is {@code false}, the initial state
+// {@link //s0} is set to {@code null}; otherwise, it is initialized to a new
+// {@link DFAState} with an empty outgoing {@link DFAState//edges} array to
+// store the start states for individual precedence values.</li>
+// <li>The {@link //precedenceDfa} field is updated</li>
+// </ul>
+//
+// @param precedenceDfa {@code true} if this is a precedence DFA; otherwise,
+// {@code false}
+
+DFA.prototype.setPrecedenceDfa = function(precedenceDfa) {
+	if (this.precedenceDfa!==precedenceDfa) {
+		this._states = new DFAStatesSet();
+		if (precedenceDfa) {
+			var precedenceState = new DFAState(new ATNConfigSet());
+			precedenceState.edges = [];
+			precedenceState.isAcceptState = false;
+			precedenceState.requiresFullContext = false;
+			this.s0 = precedenceState;
+		} else {
+			this.s0 = null;
+		}
+		this.precedenceDfa = precedenceDfa;
+	}
+};
+
+Object.defineProperty(DFA.prototype, "states", {
+	get : function() {
+		return this._states;
+	}
+});
+
+// Return a list of all states in this DFA, ordered by state number.
+DFA.prototype.sortedStates = function() {
+	// states_ is a map of state/state, where key=value
+	var keys = Object.keys(this._states);
+	var list = [];
+	for(var i=0;i<keys.length;i++) {
+		list.push(this._states[keys[i]]);
+	}
+	return list.sort(function(a, b) {
+		return a.stateNumber - b.stateNumber;
+	});
+};
+
+DFA.prototype.toString = function(literalNames, symbolicNames) {
+	literalNames = literalNames || null;
+	symbolicNames = symbolicNames || null;
+	if (this.s0 === null) {
+		return "";
+	}
+	var serializer = new DFASerializer(this, literalNames, symbolicNames);
+	return serializer.toString();
+};
+
+DFA.prototype.toLexerString = function() {
+	if (this.s0 === null) {
+		return "";
+	}
+	var serializer = new LexerDFASerializer(this);
+	return serializer.toString();
+};
+
+exports.DFA = DFA;
diff --git a/runtime/JavaScript/src/antlr4/dfa/DFASerializer.js b/runtime/JavaScript/src/antlr4/dfa/DFASerializer.js
new file mode 100644
index 000000000..21fa9aedd
--- /dev/null
+++ b/runtime/JavaScript/src/antlr4/dfa/DFASerializer.js
@@ -0,0 +1,103 @@
+// [The "BSD license"]
+//  Copyright (c) 2012 Terence Parr
+//  Copyright (c) 2012 Sam Harwell
+//  Copyright (c) 2014 Eric Vergnaud
+//  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 DFA walker that knows how to dump them to serialized strings.#/
+
+
+function DFASerializer(dfa, literalNames, symbolicNames) {
+	this.dfa = dfa;
+	this.literalNames = literalNames || [];
+	this.symbolicNames = symbolicNames || [];
+	return this;
+}
+
+DFASerializer.prototype.toString = function() {
+   if(this.dfa.s0 === null) {
+       return null;
+   }
+   var buf = "";
+   var states = this.dfa.sortedStates();
+   for(var i=0;i<states.length;i++) {
+       var s = states[i];
+       if(s.edges!==null) {
+            var n = s.edges.length;
+            for(var j=0;j<n;j++) {
+                var t = s.edges[j] || null;
+                if(t!==null && t.stateNumber !== 0x7FFFFFFF) {
+                    buf = buf.concat(this.getStateString(s));
+                    buf = buf.concat("-");
+                    buf = buf.concat(this.getEdgeLabel(j));
+                    buf = buf.concat("->");
+                    buf = buf.concat(this.getStateString(t));
+                    buf = buf.concat('\n');
+                }
+            }
+       }
+   }
+   return buf.length===0 ? null : buf;
+};
+
+DFASerializer.prototype.getEdgeLabel = function(i) {
+    if (i===0) {
+        return "EOF";
+    } else if(this.literalNames !==null || this.symbolicNames!==null) {
+        return this.literalNames[i-1] || this.symbolicNames[i-1];
+    } else {
+        return String.fromCharCode(i-1);
+    }
+};
+
+DFASerializer.prototype.getStateString = function(s) {
+    var baseStateStr = ( s.isAcceptState ? ":" : "") + "s" + s.stateNumber + ( s.requiresFullContext ? "^" : "");
+    if(s.isAcceptState) {
+        if (s.predicates !== null) {
+            return baseStateStr + "=>" + s.predicates.toString();
+        } else {
+            return baseStateStr + "=>" + s.prediction.toString();
+        }
+    } else {
+        return baseStateStr;
+    }
+};
+
+function LexerDFASerializer(dfa) {
+	DFASerializer.call(this, dfa, null);
+	return this;
+}
+
+LexerDFASerializer.prototype = Object.create(DFASerializer.prototype);
+LexerDFASerializer.prototype.constructor = LexerDFASerializer;
+
+LexerDFASerializer.prototype.getEdgeLabel = function(i) {
+	return "'" + String.fromCharCode(i) + "'";
+};
+
+exports.DFASerializer = DFASerializer;
+exports.LexerDFASerializer = LexerDFASerializer;
+
diff --git a/runtime/JavaScript/src/antlr4/dfa/DFAState.js b/runtime/JavaScript/src/antlr4/dfa/DFAState.js
new file mode 100644
index 000000000..a1d6c9945
--- /dev/null
+++ b/runtime/JavaScript/src/antlr4/dfa/DFAState.js
@@ -0,0 +1,168 @@
+//
+// [The "BSD license"]
+//  Copyright (c) 2012 Terence Parr
+//  Copyright (c) 2012 Sam Harwell
+//  Copyright (c) 2014 Eric Vergnaud
+//  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.
+///
+
+var ATNConfigSet = require('./../atn/ATNConfigSet').ATNConfigSet;
+var Utils = require('./../Utils');
+var Set = Utils.Set;
+
+// Map a predicate to a predicted alternative.///
+
+function PredPrediction(pred, alt) {
+	this.alt = alt;
+	this.pred = pred;
+	return this;
+}
+
+PredPrediction.prototype.toString = function() {
+	return "(" + this.pred + ", " + this.alt + ")";
+};
+
+// A DFA state represents a set of possible ATN configurations.
+// As Aho, Sethi, Ullman p. 117 says "The DFA uses its state
+// to keep track of all possible states the ATN can be in after
+// reading each input symbol. That is to say, after reading
+// input a1a2..an, the DFA is in a state that represents the
+// subset T of the states of the ATN that are reachable from the
+// ATN's start state along some path labeled a1a2..an."
+// In conventional NFA&rarr;DFA conversion, therefore, the subset T
+// would be a bitset representing the set of states the
+// ATN could be in. We need to track the alt predicted by each
+// state as well, however. More importantly, we need to maintain
+// a stack of states, tracking the closure operations as they
+// jump from rule to rule, emulating rule invocations (method calls).
+// I have to add a stack to simulate the proper lookahead sequences for
+// the underlying LL grammar from which the ATN was derived.
+//
+// <p>I use a set of ATNConfig objects not simple states. An ATNConfig
+// is both a state (ala normal conversion) and a RuleContext describing
+// the chain of rules (if any) followed to arrive at that state.</p>
+//
+// <p>A DFA state may have multiple references to a particular state,
+// but with different ATN contexts (with same or different alts)
+// meaning that state was reached via a different set of rule invocations.</p>
+// /
+
+function DFAState(stateNumber, configs) {
+	if (stateNumber === null) {
+		stateNumber = -1;
+	}
+	if (configs === null) {
+		configs = new ATNConfigSet();
+	}
+	this.stateNumber = stateNumber;
+	this.configs = configs;
+	// {@code edges[symbol]} points to target of symbol. Shift up by 1 so (-1)
+	// {@link Token//EOF} maps to {@code edges[0]}.
+	this.edges = null;
+	this.isAcceptState = false;
+	// if accept state, what ttype do we match or alt do we predict?
+	// This is set to {@link ATN//INVALID_ALT_NUMBER} when {@link
+	// //predicates}{@code !=null} or
+	// {@link //requiresFullContext}.
+	this.prediction = 0;
+	this.lexerActionExecutor = null;
+	// Indicates that this state was created during SLL prediction that
+	// discovered a conflict between the configurations in the state. Future
+	// {@link ParserATNSimulator//execATN} invocations immediately jumped doing
+	// full context prediction if this field is true.
+	this.requiresFullContext = false;
+	// During SLL parsing, this is a list of predicates associated with the
+	// ATN configurations of the DFA state. When we have predicates,
+	// {@link //requiresFullContext} is {@code false} since full context
+	// prediction evaluates predicates
+	// on-the-fly. If this is not null, then {@link //prediction} is
+	// {@link ATN//INVALID_ALT_NUMBER}.
+	//
+	// <p>We only use these for non-{@link //requiresFullContext} but
+	// conflicting states. That
+	// means we know from the context (it's $ or we don't dip into outer
+	// context) that it's an ambiguity not a conflict.</p>
+	//
+	// <p>This list is computed by {@link
+	// ParserATNSimulator//predicateDFAState}.</p>
+	this.predicates = null;
+	return this;
+}
+
+// Get the set of all alts mentioned by all ATN configurations in this
+// DFA state.
+DFAState.prototype.getAltSet = function() {
+	var alts = new Set();
+	if (this.configs !== null) {
+		for (var i = 0; i < this.configs.length; i++) {
+			var c = this.configs[i];
+			alts.add(c.alt);
+		}
+	}
+	if (alts.length === 0) {
+		return null;
+	} else {
+		return alts;
+	}
+};
+
+// Two {@link DFAState} instances are equal if their ATN configuration sets
+// are the same. This method is used to see if a state already exists.
+//
+// <p>Because the number of alternatives and number of ATN configurations are
+// finite, there is a finite number of DFA states that can be processed.
+// This is necessary to show that the algorithm terminates.</p>
+//
+// <p>Cannot test the DFA state numbers here because in
+// {@link ParserATNSimulator//addDFAState} we need to know if any other state
+// exists that has this exact set of ATN configurations. The
+// {@link //stateNumber} is irrelevant.</p>
+DFAState.prototype.equals = function(other) {
+	// compare set of ATN configurations in this set with other
+	if (this === other) {
+		return true;
+	} else if (!(other instanceof DFAState)) {
+		return false;
+	} else {
+		return this.configs.equals(other.configs);
+	}
+};
+
+DFAState.prototype.toString = function() {
+	return "" + this.stateNumber + ":" + this.hashString();
+};
+
+DFAState.prototype.hashString = function() {
+	return "" +  this.configs +
+			(this.isAcceptState ?
+					"=>" + (this.predicates !== null ?
+								this.predicates :
+								this.prediction) :
+					"");
+};
+
+exports.DFAState = DFAState;
+exports.PredPrediction = PredPrediction;
diff --git a/runtime/JavaScript/src/antlr4/dfa/index.js b/runtime/JavaScript/src/antlr4/dfa/index.js
new file mode 100644
index 000000000..0f5794c6b
--- /dev/null
+++ b/runtime/JavaScript/src/antlr4/dfa/index.js
@@ -0,0 +1,4 @@
+exports.DFA = require('./DFA').DFA;
+exports.DFASerializer = require('./DFASerializer').DFASerializer;
+exports.LexerDFASerializer = require('./DFASerializer').LexerDFASerializer;
+exports.PredPrediction = require('./DFAState').PredPrediction;
diff --git a/runtime/JavaScript/src/antlr4/error/DiagnosticErrorListener.js b/runtime/JavaScript/src/antlr4/error/DiagnosticErrorListener.js
new file mode 100644
index 000000000..14a8b3ab6
--- /dev/null
+++ b/runtime/JavaScript/src/antlr4/error/DiagnosticErrorListener.js
@@ -0,0 +1,135 @@
+//
+// [The "BSD license"]
+//  Copyright (c) 2012 Terence Parr
+//  Copyright (c) 2012 Sam Harwell
+//  Copyright (c) 2014 Eric Vergnaud
+//  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.
+//
+
+//
+// This implementation of {@link ANTLRErrorListener} can be used to identify
+// certain potential correctness and performance problems in grammars. "Reports"
+// are made by calling {@link Parser//notifyErrorListeners} with the appropriate
+// message.
+//
+// <ul>
+// <li><b>Ambiguities</b>: These are cases where more than one path through the
+// grammar can match the input.</li>
+// <li><b>Weak context sensitivity</b>: These are cases where full-context
+// prediction resolved an SLL conflict to a unique alternative which equaled the
+// minimum alternative of the SLL conflict.</li>
+// <li><b>Strong (forced) context sensitivity</b>: These are cases where the
+// full-context prediction resolved an SLL conflict to a unique alternative,
+// <em>and</em> the minimum alternative of the SLL conflict was found to not be
+// a truly viable alternative. Two-stage parsing cannot be used for inputs where
+// this situation occurs.</li>
+// </ul>
+
+var BitSet = require('./../Utils').BitSet;
+var ErrorListener = require('./ErrorListener').ErrorListener;
+var Interval = require('./../IntervalSet').Interval;
+
+function DiagnosticErrorListener(exactOnly) {
+	ErrorListener.call(this);
+	exactOnly = exactOnly || true;
+	// whether all ambiguities or only exact ambiguities are reported.
+	this.exactOnly = exactOnly;
+	return this;
+}
+
+DiagnosticErrorListener.prototype = Object.create(ErrorListener.prototype);
+DiagnosticErrorListener.prototype.constructor = DiagnosticErrorListener;
+
+DiagnosticErrorListener.prototype.reportAmbiguity = function(recognizer, dfa,
+		startIndex, stopIndex, exact, ambigAlts, configs) {
+	if (this.exactOnly && !exact) {
+		return;
+	}
+	var msg = "reportAmbiguity d=" +
+			this.getDecisionDescription(recognizer, dfa) +
+			": ambigAlts=" +
+			this.getConflictingAlts(ambigAlts, configs) +
+			", input='" +
+			recognizer.getTokenStream().getText(new Interval(startIndex, stopIndex)) + "'";
+	recognizer.notifyErrorListeners(msg);
+};
+
+DiagnosticErrorListener.prototype.reportAttemptingFullContext = function(
+		recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs) {
+	var msg = "reportAttemptingFullContext d=" +
+			this.getDecisionDescription(recognizer, dfa) +
+			", input='" +
+			recognizer.getTokenStream().getText(new Interval(startIndex, stopIndex)) + "'";
+	recognizer.notifyErrorListeners(msg);
+};
+
+DiagnosticErrorListener.prototype.reportContextSensitivity = function(
+		recognizer, dfa, startIndex, stopIndex, prediction, configs) {
+	var msg = "reportContextSensitivity d=" +
+			this.getDecisionDescription(recognizer, dfa) +
+			", input='" +
+			recognizer.getTokenStream().getText(new Interval(startIndex, stopIndex)) + "'";
+	recognizer.notifyErrorListeners(msg);
+};
+
+DiagnosticErrorListener.prototype.getDecisionDescription = function(recognizer, dfa) {
+	var decision = dfa.decision;
+	var ruleIndex = dfa.atnStartState.ruleIndex;
+
+	var ruleNames = recognizer.ruleNames;
+	if (ruleIndex < 0 || ruleIndex >= ruleNames.length) {
+		return "" + decision;
+	}
+	var ruleName = ruleNames[ruleIndex] || null;
+	if (ruleName === null || ruleName.length === 0) {
+		return "" + decision;
+	}
+	return "" + decision + " (" + ruleName + ")";
+};
+
+//
+// Computes the set of conflicting or ambiguous alternatives from a
+// configuration set, if that information was not already provided by the
+// parser.
+//
+// @param reportedAlts The set of conflicting or ambiguous alternatives, as
+// reported by the parser.
+// @param configs The conflicting or ambiguous configuration set.
+// @return Returns {@code reportedAlts} if it is not {@code null}, otherwise
+// returns the set of alternatives represented in {@code configs}.
+//
+DiagnosticErrorListener.prototype.getConflictingAlts = function(reportedAlts, configs) {
+	if (reportedAlts !== null) {
+		return reportedAlts;
+	}
+	var result = new BitSet();
+	for (var i = 0; i < configs.items.length; i++) {
+		result.add(configs.items[i].alt);
+	}
+	return "{" + result.values().join(", ") + "}";
+};
+
+exports.DiagnosticErrorListener = DiagnosticErrorListener;
\ No newline at end of file
diff --git a/runtime/JavaScript/src/antlr4/error/ErrorListener.js b/runtime/JavaScript/src/antlr4/error/ErrorListener.js
new file mode 100644
index 000000000..7a1b512cf
--- /dev/null
+++ b/runtime/JavaScript/src/antlr4/error/ErrorListener.js
@@ -0,0 +1,111 @@
+//
+// [The "BSD license"]
+//  Copyright (c) 2012 Terence Parr
+//  Copyright (c) 2012 Sam Harwell
+//  Copyright (c) 2014 Eric Vergnaud
+//  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.
+
+// Provides an empty default implementation of {@link ANTLRErrorListener}. The
+// default implementation of each method does nothing, but can be overridden as
+// necessary.
+
+function ErrorListener() {
+	return this;
+}
+
+ErrorListener.prototype.syntaxError = function(recognizer, offendingSymbol, line, column, msg, e) {
+};
+
+ErrorListener.prototype.reportAmbiguity = function(recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs) {
+};
+
+ErrorListener.prototype.reportAttemptingFullContext = function(recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs) {
+};
+
+ErrorListener.prototype.reportContextSensitivity = function(recognizer, dfa, startIndex, stopIndex, prediction, configs) {
+};
+
+function ConsoleErrorListener() {
+	ErrorListener.call(this);
+	return this;
+}
+
+ConsoleErrorListener.prototype = Object.create(ErrorListener.prototype);
+ConsoleErrorListener.prototype.constructor = ConsoleErrorListener;
+
+//
+// Provides a default instance of {@link ConsoleErrorListener}.
+//
+ConsoleErrorListener.INSTANCE = new ConsoleErrorListener();
+
+//
+// {@inheritDoc}
+//
+// <p>
+// This implementation prints messages to {@link System//err} containing the
+// values of {@code line}, {@code charPositionInLine}, and {@code msg} using
+// the following format.</p>
+//
+// <pre>
+// line <em>line</em>:<em>charPositionInLine</em> <em>msg</em>
+// </pre>
+//
+ConsoleErrorListener.prototype.syntaxError = function(recognizer, offendingSymbol, line, column, msg, e) {
+    console.error("line " + line + ":" + column + " " + msg);
+};
+
+function ProxyErrorListener(delegates) {
+	ErrorListener.call(this);
+    if (delegates===null) {
+        throw "delegates";
+    }
+    this.delegates = delegates;
+	return this;
+}
+
+ProxyErrorListener.prototype = Object.create(ErrorListener.prototype);
+ProxyErrorListener.prototype.constructor = ProxyErrorListener;
+
+ProxyErrorListener.prototype.syntaxError = function(recognizer, offendingSymbol, line, column, msg, e) {
+    this.delegates.map(function(d) { d.syntaxError(recognizer, offendingSymbol, line, column, msg, e); });
+};
+
+ProxyErrorListener.prototype.reportAmbiguity = function(recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs) {
+    this.delegates.map(function(d) { d.reportAmbiguity(recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs); });
+};
+
+ProxyErrorListener.prototype.reportAttemptingFullContext = function(recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs) {
+	this.delegates.map(function(d) { d.reportAttemptingFullContext(recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs); });
+};
+
+ProxyErrorListener.prototype.reportContextSensitivity = function(recognizer, dfa, startIndex, stopIndex, prediction, configs) {
+	this.delegates.map(function(d) { d.reportContextSensitivity(recognizer, dfa, startIndex, stopIndex, prediction, configs); });
+};
+
+exports.ErrorListener = ErrorListener;
+exports.ConsoleErrorListener = ConsoleErrorListener;
+exports.ProxyErrorListener = ProxyErrorListener;
+
diff --git a/runtime/JavaScript/src/antlr4/error/ErrorStrategy.js b/runtime/JavaScript/src/antlr4/error/ErrorStrategy.js
new file mode 100644
index 000000000..f2993e713
--- /dev/null
+++ b/runtime/JavaScript/src/antlr4/error/ErrorStrategy.js
@@ -0,0 +1,783 @@
+//
+// [The "BSD license"]
+//  Copyright (c) 2012 Terence Parr
+//  Copyright (c) 2012 Sam Harwell
+//  Copyright (c) 2014 Eric Vergnaud
+//  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.
+//
+
+var Token = require('./../Token').Token;
+var Errors = require('./Errors');
+var NoViableAltException = Errors.NoViableAltException;
+var InputMismatchException = Errors.InputMismatchException;
+var FailedPredicateException = Errors.FailedPredicateException;
+var ParseCancellationException = Errors.ParseCancellationException;
+var ATNState = require('./../atn/ATNState').ATNState;
+var Interval = require('./../IntervalSet').Interval;
+var IntervalSet = require('./../IntervalSet').IntervalSet;
+
+function ErrorStrategy() {
+	
+}
+
+ErrorStrategy.prototype.reset = function(recognizer){
+};
+
+ErrorStrategy.prototype.recoverInline = function(recognizer){
+};
+
+ErrorStrategy.prototype.recover = function(recognizer, e){
+};
+
+ErrorStrategy.prototype.sync = function(recognizer){
+};
+
+ErrorStrategy.prototype.inErrorRecoveryMode = function(recognizer){
+};
+
+ErrorStrategy.prototype.reportError = function(recognizer){
+};
+
+
+
+// This is the default implementation of {@link ANTLRErrorStrategy} used for
+// error reporting and recovery in ANTLR parsers.
+//
+function DefaultErrorStrategy() {
+	ErrorStrategy.call(this);
+    // Indicates whether the error strategy is currently "recovering from an
+    // error". This is used to suppress reporting multiple error messages while
+    // attempting to recover from a detected syntax error.
+    //
+    // @see //inErrorRecoveryMode
+    //
+    this.errorRecoveryMode = false;
+
+    // The index into the input stream where the last error occurred.
+    // This is used to prevent infinite loops where an error is found
+    // but no token is consumed during recovery...another error is found,
+    // ad nauseum. This is a failsafe mechanism to guarantee that at least
+    // one token/tree node is consumed for two errors.
+    //
+    this.lastErrorIndex = -1;
+    this.lastErrorStates = null;
+    return this;
+}
+
+DefaultErrorStrategy.prototype = Object.create(ErrorStrategy.prototype);
+DefaultErrorStrategy.prototype.constructor = DefaultErrorStrategy;
+
+// <p>The default implementation simply calls {@link //endErrorCondition} to
+// ensure that the handler is not in error recovery mode.</p>
+DefaultErrorStrategy.prototype.reset = function(recognizer) {
+    this.endErrorCondition(recognizer);
+};
+
+//
+// This method is called to enter error recovery mode when a recognition
+// exception is reported.
+//
+// @param recognizer the parser instance
+//
+DefaultErrorStrategy.prototype.beginErrorCondition = function(recognizer) {
+    this.errorRecoveryMode = true;
+};
+
+DefaultErrorStrategy.prototype.inErrorRecoveryMode = function(recognizer) {
+    return this.errorRecoveryMode;
+};
+
+//
+// This method is called to leave error recovery mode after recovering from
+// a recognition exception.
+//
+// @param recognizer
+//
+DefaultErrorStrategy.prototype.endErrorCondition = function(recognizer) {
+    this.errorRecoveryMode = false;
+    this.lastErrorStates = null;
+    this.lastErrorIndex = -1;
+};
+
+//
+// {@inheritDoc}
+//
+// <p>The default implementation simply calls {@link //endErrorCondition}.</p>
+//
+DefaultErrorStrategy.prototype.reportMatch = function(recognizer) {
+    this.endErrorCondition(recognizer);
+};
+
+//
+// {@inheritDoc}
+//
+// <p>The default implementation returns immediately if the handler is already
+// in error recovery mode. Otherwise, it calls {@link //beginErrorCondition}
+// and dispatches the reporting task based on the runtime type of {@code e}
+// according to the following table.</p>
+//
+// <ul>
+// <li>{@link NoViableAltException}: Dispatches the call to
+// {@link //reportNoViableAlternative}</li>
+// <li>{@link InputMismatchException}: Dispatches the call to
+// {@link //reportInputMismatch}</li>
+// <li>{@link FailedPredicateException}: Dispatches the call to
+// {@link //reportFailedPredicate}</li>
+// <li>All other types: calls {@link Parser//notifyErrorListeners} to report
+// the exception</li>
+// </ul>
+//
+DefaultErrorStrategy.prototype.reportError = function(recognizer, e) {
+   // if we've already reported an error and have not matched a token
+   // yet successfully, don't report any errors.
+    if(this.inErrorRecoveryMode(recognizer)) {
+        return; // don't report spurious errors
+    }
+    this.beginErrorCondition(recognizer);
+    if ( e instanceof NoViableAltException ) {
+        this.reportNoViableAlternative(recognizer, e);
+    } else if ( e instanceof InputMismatchException ) {
+        this.reportInputMismatch(recognizer, e);
+    } else if ( e instanceof FailedPredicateException ) {
+        this.reportFailedPredicate(recognizer, e);
+    } else {
+        console.log("unknown recognition error type: " + e.constructor.name);
+        console.log(e.stack);
+        recognizer.notifyErrorListeners(e.getOffendingToken(), e.getMessage(), e);
+    }
+};
+//
+// {@inheritDoc}
+//
+// <p>The default implementation resynchronizes the parser by consuming tokens
+// until we find one in the resynchronization set--loosely the set of tokens
+// that can follow the current rule.</p>
+//
+DefaultErrorStrategy.prototype.recover = function(recognizer, e) {
+    if (this.lastErrorIndex===recognizer.getInputStream().index &&
+        this.lastErrorStates !== null && this.lastErrorStates.indexOf(recognizer.state)>=0) {
+		// uh oh, another error at same token index and previously-visited
+		// state in ATN; must be a case where LT(1) is in the recovery
+		// token set so nothing got consumed. Consume a single token
+		// at least to prevent an infinite loop; this is a failsafe.
+		recognizer.consume();
+    }
+    this.lastErrorIndex = recognizer._input.index;
+    if (this.lastErrorStates === null) {
+        this.lastErrorStates = [];
+    }
+    this.lastErrorStates.push(recognizer.state);
+    var followSet = this.getErrorRecoverySet(recognizer);
+    this.consumeUntil(recognizer, followSet);
+};
+
+// The default implementation of {@link ANTLRErrorStrategy//sync} makes sure
+// that the current lookahead symbol is consistent with what were expecting
+// at this point in the ATN. You can call this anytime but ANTLR only
+// generates code to check before subrules/loops and each iteration.
+//
+// <p>Implements Jim Idle's magic sync mechanism in closures and optional
+// subrules. E.g.,</p>
+//
+// <pre>
+// a : sync ( stuff sync )* ;
+// sync : {consume to what can follow sync} ;
+// </pre>
+//
+// At the start of a sub rule upon error, {@link //sync} performs single
+// token deletion, if possible. If it can't do that, it bails on the current
+// rule and uses the default error recovery, which consumes until the
+// resynchronization set of the current rule.
+//
+// <p>If the sub rule is optional ({@code (...)?}, {@code (...)*}, or block
+// with an empty alternative), then the expected set includes what follows
+// the subrule.</p>
+//
+// <p>During loop iteration, it consumes until it sees a token that can start a
+// sub rule or what follows loop. Yes, that is pretty aggressive. We opt to
+// stay in the loop as long as possible.</p>
+//
+// <p><strong>ORIGINS</strong></p>
+//
+// <p>Previous versions of ANTLR did a poor job of their recovery within loops.
+// A single mismatch token or missing token would force the parser to bail
+// out of the entire rules surrounding the loop. So, for rule</p>
+//
+// <pre>
+// classDef : 'class' ID '{' member* '}'
+// </pre>
+//
+// input with an extra token between members would force the parser to
+// consume until it found the next class definition rather than the next
+// member definition of the current class.
+//
+// <p>This functionality cost a little bit of effort because the parser has to
+// compare token set at the start of the loop and at each iteration. If for
+// some reason speed is suffering for you, you can turn off this
+// functionality by simply overriding this method as a blank { }.</p>
+//
+DefaultErrorStrategy.prototype.sync = function(recognizer) {
+    // If already recovering, don't try to sync
+    if (this.inErrorRecoveryMode(recognizer)) {
+        return;
+    }
+    var s = recognizer._interp.atn.states[recognizer.state];
+    var la = recognizer.getTokenStream().LA(1);
+    // try cheaper subset first; might get lucky. seems to shave a wee bit off
+    if (la===Token.EOF || recognizer.atn.nextTokens(s).contains(la)) {
+        return;
+    }
+    // Return but don't end recovery. only do that upon valid token match
+    if(recognizer.isExpectedToken(la)) {
+        return;
+    }
+    switch (s.stateType) {
+    case ATNState.BLOCK_START:
+    case ATNState.STAR_BLOCK_START:
+    case ATNState.PLUS_BLOCK_START:
+    case ATNState.STAR_LOOP_ENTRY:
+       // report error and recover if possible
+        if( this.singleTokenDeletion(recognizer) !== null) {
+            return;
+        } else {
+            throw new InputMismatchException(recognizer);
+        }
+        break;
+    case ATNState.PLUS_LOOP_BACK:
+    case ATNState.STAR_LOOP_BACK:
+        this.reportUnwantedToken(recognizer);
+        var expecting = new IntervalSet();
+        expecting.addSet(recognizer.getExpectedTokens());
+        var whatFollowsLoopIterationOrRule = expecting.addSet(this.getErrorRecoverySet(recognizer));
+        this.consumeUntil(recognizer, whatFollowsLoopIterationOrRule);
+        break;
+    default:
+        // do nothing if we can't identify the exact kind of ATN state
+    }
+};
+
+// This is called by {@link //reportError} when the exception is a
+// {@link NoViableAltException}.
+//
+// @see //reportError
+//
+// @param recognizer the parser instance
+// @param e the recognition exception
+//
+DefaultErrorStrategy.prototype.reportNoViableAlternative = function(recognizer, e) {
+    var tokens = recognizer.getTokenStream();
+    var input;
+    if(tokens !== null) {
+        if (e.startToken.type===Token.EOF) {
+            input = "<EOF>";
+        } else {
+            input = tokens.getText(new Interval(e.startToken, e.offendingToken));
+        }
+    } else {
+        input = "<unknown input>";
+    }
+    var msg = "no viable alternative at input " + this.escapeWSAndQuote(input);
+    recognizer.notifyErrorListeners(msg, e.offendingToken, e);
+};
+
+//
+// This is called by {@link //reportError} when the exception is an
+// {@link InputMismatchException}.
+//
+// @see //reportError
+//
+// @param recognizer the parser instance
+// @param e the recognition exception
+//
+DefaultErrorStrategy.prototype.reportInputMismatch = function(recognizer, e) {
+    var msg = "mismatched input " + this.getTokenErrorDisplay(e.offendingToken) +
+          " expecting " + e.getExpectedTokens().toString(recognizer.literalNames, recognizer.symbolicNames);
+    recognizer.notifyErrorListeners(msg, e.offendingToken, e);
+};
+
+//
+// This is called by {@link //reportError} when the exception is a
+// {@link FailedPredicateException}.
+//
+// @see //reportError
+//
+// @param recognizer the parser instance
+// @param e the recognition exception
+//
+DefaultErrorStrategy.prototype.reportFailedPredicate = function(recognizer, e) {
+    var ruleName = recognizer.ruleNames[recognizer._ctx.ruleIndex];
+    var msg = "rule " + ruleName + " " + e.message;
+    recognizer.notifyErrorListeners(msg, e.offendingToken, e);
+};
+
+// This method is called to report a syntax error which requires the removal
+// of a token from the input stream. At the time this method is called, the
+// erroneous symbol is current {@code LT(1)} symbol and has not yet been
+// removed from the input stream. When this method returns,
+// {@code recognizer} is in error recovery mode.
+//
+// <p>This method is called when {@link //singleTokenDeletion} identifies
+// single-token deletion as a viable recovery strategy for a mismatched
+// input error.</p>
+//
+// <p>The default implementation simply returns if the handler is already in
+// error recovery mode. Otherwise, it calls {@link //beginErrorCondition} to
+// enter error recovery mode, followed by calling
+// {@link Parser//notifyErrorListeners}.</p>
+//
+// @param recognizer the parser instance
+//
+DefaultErrorStrategy.prototype.reportUnwantedToken = function(recognizer) {
+    if (this.inErrorRecoveryMode(recognizer)) {
+        return;
+    }
+    this.beginErrorCondition(recognizer);
+    var t = recognizer.getCurrentToken();
+    var tokenName = this.getTokenErrorDisplay(t);
+    var expecting = this.getExpectedTokens(recognizer);
+    var msg = "extraneous input " + tokenName + " expecting " +
+        expecting.toString(recognizer.literalNames, recognizer.symbolicNames);
+    recognizer.notifyErrorListeners(msg, t, null);
+};
+// This method is called to report a syntax error which requires the
+// insertion of a missing token into the input stream. At the time this
+// method is called, the missing token has not yet been inserted. When this
+// method returns, {@code recognizer} is in error recovery mode.
+//
+// <p>This method is called when {@link //singleTokenInsertion} identifies
+// single-token insertion as a viable recovery strategy for a mismatched
+// input error.</p>
+//
+// <p>The default implementation simply returns if the handler is already in
+// error recovery mode. Otherwise, it calls {@link //beginErrorCondition} to
+// enter error recovery mode, followed by calling
+// {@link Parser//notifyErrorListeners}.</p>
+//
+// @param recognizer the parser instance
+//
+DefaultErrorStrategy.prototype.reportMissingToken = function(recognizer) {
+    if ( this.inErrorRecoveryMode(recognizer)) {
+        return;
+    }
+    this.beginErrorCondition(recognizer);
+    var t = recognizer.getCurrentToken();
+    var expecting = this.getExpectedTokens(recognizer);
+    var msg = "missing " + expecting.toString(recognizer.literalNames, recognizer.symbolicNames) +
+          " at " + this.getTokenErrorDisplay(t);
+    recognizer.notifyErrorListeners(msg, t, null);
+};
+
+// <p>The default implementation attempts to recover from the mismatched input
+// by using single token insertion and deletion as described below. If the
+// recovery attempt fails, this method throws an
+// {@link InputMismatchException}.</p>
+//
+// <p><strong>EXTRA TOKEN</strong> (single token deletion)</p>
+//
+// <p>{@code LA(1)} is not what we are looking for. If {@code LA(2)} has the
+// right token, however, then assume {@code LA(1)} is some extra spurious
+// token and delete it. Then consume and return the next token (which was
+// the {@code LA(2)} token) as the successful result of the match operation.</p>
+//
+// <p>This recovery strategy is implemented by {@link
+// //singleTokenDeletion}.</p>
+//
+// <p><strong>MISSING TOKEN</strong> (single token insertion)</p>
+//
+// <p>If current token (at {@code LA(1)}) is consistent with what could come
+// after the expected {@code LA(1)} token, then assume the token is missing
+// and use the parser's {@link TokenFactory} to create it on the fly. The
+// "insertion" is performed by returning the created token as the successful
+// result of the match operation.</p>
+//
+// <p>This recovery strategy is implemented by {@link
+// //singleTokenInsertion}.</p>
+//
+// <p><strong>EXAMPLE</strong></p>
+//
+// <p>For example, Input {@code i=(3;} is clearly missing the {@code ')'}. When
+// the parser returns from the nested call to {@code expr}, it will have
+// call chain:</p>
+//
+// <pre>
+// stat &rarr; expr &rarr; atom
+// </pre>
+//
+// and it will be trying to match the {@code ')'} at this point in the
+// derivation:
+//
+// <pre>
+// =&gt; ID '=' '(' INT ')' ('+' atom)* ';'
+// ^
+// </pre>
+//
+// The attempt to match {@code ')'} will fail when it sees {@code ';'} and
+// call {@link //recoverInline}. To recover, it sees that {@code LA(1)==';'}
+// is in the set of tokens that can follow the {@code ')'} token reference
+// in rule {@code atom}. It can assume that you forgot the {@code ')'}.
+//
+DefaultErrorStrategy.prototype.recoverInline = function(recognizer) {
+    // SINGLE TOKEN DELETION
+    var matchedSymbol = this.singleTokenDeletion(recognizer);
+    if (matchedSymbol !== null) {
+        // we have deleted the extra token.
+        // now, move past ttype token as if all were ok
+        recognizer.consume();
+        return matchedSymbol;
+    }
+    // SINGLE TOKEN INSERTION
+    if (this.singleTokenInsertion(recognizer)) {
+        return this.getMissingSymbol(recognizer);
+    }
+    // even that didn't work; must throw the exception
+    throw new InputMismatchException(recognizer);
+};
+
+//
+// This method implements the single-token insertion inline error recovery
+// strategy. It is called by {@link //recoverInline} if the single-token
+// deletion strategy fails to recover from the mismatched input. If this
+// method returns {@code true}, {@code recognizer} will be in error recovery
+// mode.
+//
+// <p>This method determines whether or not single-token insertion is viable by
+// checking if the {@code LA(1)} input symbol could be successfully matched
+// if it were instead the {@code LA(2)} symbol. If this method returns
+// {@code true}, the caller is responsible for creating and inserting a
+// token with the correct type to produce this behavior.</p>
+//
+// @param recognizer the parser instance
+// @return {@code true} if single-token insertion is a viable recovery
+// strategy for the current mismatched input, otherwise {@code false}
+//
+DefaultErrorStrategy.prototype.singleTokenInsertion = function(recognizer) {
+    var currentSymbolType = recognizer.getTokenStream().LA(1);
+    // if current token is consistent with what could come after current
+    // ATN state, then we know we're missing a token; error recovery
+    // is free to conjure up and insert the missing token
+    var atn = recognizer._interp.atn;
+    var currentState = atn.states[recognizer.state];
+    var next = currentState.transitions[0].target;
+    var expectingAtLL2 = atn.nextTokens(next, recognizer._ctx);
+    if (expectingAtLL2.contains(currentSymbolType) ){
+        this.reportMissingToken(recognizer);
+        return true;
+    } else {
+        return false;
+    }
+};
+
+// This method implements the single-token deletion inline error recovery
+// strategy. It is called by {@link //recoverInline} to attempt to recover
+// from mismatched input. If this method returns null, the parser and error
+// handler state will not have changed. If this method returns non-null,
+// {@code recognizer} will <em>not</em> be in error recovery mode since the
+// returned token was a successful match.
+//
+// <p>If the single-token deletion is successful, this method calls
+// {@link //reportUnwantedToken} to report the error, followed by
+// {@link Parser//consume} to actually "delete" the extraneous token. Then,
+// before returning {@link //reportMatch} is called to signal a successful
+// match.</p>
+//
+// @param recognizer the parser instance
+// @return the successfully matched {@link Token} instance if single-token
+// deletion successfully recovers from the mismatched input, otherwise
+// {@code null}
+//
+DefaultErrorStrategy.prototype.singleTokenDeletion = function(recognizer) {
+    var nextTokenType = recognizer.getTokenStream().LA(2);
+    var expecting = this.getExpectedTokens(recognizer);
+    if (expecting.contains(nextTokenType)) {
+        this.reportUnwantedToken(recognizer);
+        // print("recoverFromMismatchedToken deleting " \
+        // + str(recognizer.getTokenStream().LT(1)) \
+        // + " since " + str(recognizer.getTokenStream().LT(2)) \
+        // + " is what we want", file=sys.stderr)
+        recognizer.consume(); // simply delete extra token
+        // we want to return the token we're actually matching
+        var matchedSymbol = recognizer.getCurrentToken();
+        this.reportMatch(recognizer); // we know current token is correct
+        return matchedSymbol;
+    } else {
+        return null;
+    }
+};
+
+// Conjure up a missing token during error recovery.
+//
+// The recognizer attempts to recover from single missing
+// symbols. But, actions might refer to that missing symbol.
+// For example, x=ID {f($x);}. The action clearly assumes
+// that there has been an identifier matched previously and that
+// $x points at that token. If that token is missing, but
+// the next token in the stream is what we want we assume that
+// this token is missing and we keep going. Because we
+// have to return some token to replace the missing token,
+// we have to conjure one up. This method gives the user control
+// over the tokens returned for missing tokens. Mostly,
+// you will want to create something special for identifier
+// tokens. For literals such as '{' and ',', the default
+// action in the parser or tree parser works. It simply creates
+// a CommonToken of the appropriate type. The text will be the token.
+// If you change what tokens must be created by the lexer,
+// override this method to create the appropriate tokens.
+//
+DefaultErrorStrategy.prototype.getMissingSymbol = function(recognizer) {
+    var currentSymbol = recognizer.getCurrentToken();
+    var expecting = this.getExpectedTokens(recognizer);
+    var expectedTokenType = expecting.first(); // get any element
+    var tokenText;
+    if (expectedTokenType===Token.EOF) {
+        tokenText = "<missing EOF>";
+    } else {
+        tokenText = "<missing " + recognizer.literalNames[expectedTokenType] + ">";
+    }
+    var current = currentSymbol;
+    var lookback = recognizer.getTokenStream().LT(-1);
+    if (current.type===Token.EOF && lookback !== null) {
+        current = lookback;
+    }
+    return recognizer.getTokenFactory().create(current.source,
+        expectedTokenType, tokenText, Token.DEFAULT_CHANNEL,
+        -1, -1, current.line, current.column);
+};
+
+DefaultErrorStrategy.prototype.getExpectedTokens = function(recognizer) {
+    return recognizer.getExpectedTokens();
+};
+
+// How should a token be displayed in an error message? The default
+// is to display just the text, but during development you might
+// want to have a lot of information spit out. Override in that case
+// to use t.toString() (which, for CommonToken, dumps everything about
+// the token). This is better than forcing you to override a method in
+// your token objects because you don't have to go modify your lexer
+// so that it creates a new Java type.
+//
+DefaultErrorStrategy.prototype.getTokenErrorDisplay = function(t) {
+    if (t === null) {
+        return "<no token>";
+    }
+    var s = t.text;
+    if (s === null) {
+        if (t.type===Token.EOF) {
+            s = "<EOF>";
+        } else {
+            s = "<" + t.type + ">";
+        }
+    }
+    return this.escapeWSAndQuote(s);
+};
+
+DefaultErrorStrategy.prototype.escapeWSAndQuote = function(s) {
+    s = s.replace(/\n/g,"\\n");
+    s = s.replace(/\r/g,"\\r");
+    s = s.replace(/\t/g,"\\t");
+    return "'" + s + "'";
+};
+
+// Compute the error recovery set for the current rule. During
+// rule invocation, the parser pushes the set of tokens that can
+// follow that rule reference on the stack; this amounts to
+// computing FIRST of what follows the rule reference in the
+// enclosing rule. See LinearApproximator.FIRST().
+// This local follow set only includes tokens
+// from within the rule; i.e., the FIRST computation done by
+// ANTLR stops at the end of a rule.
+//
+// EXAMPLE
+//
+// When you find a "no viable alt exception", the input is not
+// consistent with any of the alternatives for rule r. The best
+// thing to do is to consume tokens until you see something that
+// can legally follow a call to r//or* any rule that called r.
+// You don't want the exact set of viable next tokens because the
+// input might just be missing a token--you might consume the
+// rest of the input looking for one of the missing tokens.
+//
+// Consider grammar:
+//
+// a : '[' b ']'
+// | '(' b ')'
+// ;
+// b : c '^' INT ;
+// c : ID
+// | INT
+// ;
+//
+// At each rule invocation, the set of tokens that could follow
+// that rule is pushed on a stack. Here are the various
+// context-sensitive follow sets:
+//
+// FOLLOW(b1_in_a) = FIRST(']') = ']'
+// FOLLOW(b2_in_a) = FIRST(')') = ')'
+// FOLLOW(c_in_b) = FIRST('^') = '^'
+//
+// Upon erroneous input "[]", the call chain is
+//
+// a -> b -> c
+//
+// and, hence, the follow context stack is:
+//
+// depth follow set start of rule execution
+// 0 <EOF> a (from main())
+// 1 ']' b
+// 2 '^' c
+//
+// Notice that ')' is not included, because b would have to have
+// been called from a different context in rule a for ')' to be
+// included.
+//
+// For error recovery, we cannot consider FOLLOW(c)
+// (context-sensitive or otherwise). We need the combined set of
+// all context-sensitive FOLLOW sets--the set of all tokens that
+// could follow any reference in the call chain. We need to
+// resync to one of those tokens. Note that FOLLOW(c)='^' and if
+// we resync'd to that token, we'd consume until EOF. We need to
+// sync to context-sensitive FOLLOWs for a, b, and c: {']','^'}.
+// In this case, for input "[]", LA(1) is ']' and in the set, so we would
+// not consume anything. After printing an error, rule c would
+// return normally. Rule b would not find the required '^' though.
+// At this point, it gets a mismatched token error and throws an
+// exception (since LA(1) is not in the viable following token
+// set). The rule exception handler tries to recover, but finds
+// the same recovery set and doesn't consume anything. Rule b
+// exits normally returning to rule a. Now it finds the ']' (and
+// with the successful match exits errorRecovery mode).
+//
+// So, you can see that the parser walks up the call chain looking
+// for the token that was a member of the recovery set.
+//
+// Errors are not generated in errorRecovery mode.
+//
+// ANTLR's error recovery mechanism is based upon original ideas:
+//
+// "Algorithms + Data Structures = Programs" by Niklaus Wirth
+//
+// and
+//
+// "A note on error recovery in recursive descent parsers":
+// http://portal.acm.org/citation.cfm?id=947902.947905
+//
+// Later, Josef Grosch had some good ideas:
+//
+// "Efficient and Comfortable Error Recovery in Recursive Descent
+// Parsers":
+// ftp://www.cocolab.com/products/cocktail/doca4.ps/ell.ps.zip
+//
+// Like Grosch I implement context-sensitive FOLLOW sets that are combined
+// at run-time upon error to avoid overhead during parsing.
+//
+DefaultErrorStrategy.prototype.getErrorRecoverySet = function(recognizer) {
+    var atn = recognizer._interp.atn;
+    var ctx = recognizer._ctx;
+    var recoverSet = new IntervalSet();
+    while (ctx !== null && ctx.invokingState>=0) {
+        // compute what follows who invoked us
+        var invokingState = atn.states[ctx.invokingState];
+        var rt = invokingState.transitions[0];
+        var follow = atn.nextTokens(rt.followState);
+        recoverSet.addSet(follow);
+        ctx = ctx.parentCtx;
+    }
+    recoverSet.removeOne(Token.EPSILON);
+    return recoverSet;
+};
+
+// Consume tokens until one matches the given token set.//
+DefaultErrorStrategy.prototype.consumeUntil = function(recognizer, set) {
+    var ttype = recognizer.getTokenStream().LA(1);
+    while( ttype !== Token.EOF && !set.contains(ttype)) {
+        recognizer.consume();
+        ttype = recognizer.getTokenStream().LA(1);
+    }
+};
+
+//
+// This implementation of {@link ANTLRErrorStrategy} responds to syntax errors
+// by immediately canceling the parse operation with a
+// {@link ParseCancellationException}. The implementation ensures that the
+// {@link ParserRuleContext//exception} field is set for all parse tree nodes
+// that were not completed prior to encountering the error.
+//
+// <p>
+// This error strategy is useful in the following scenarios.</p>
+//
+// <ul>
+// <li><strong>Two-stage parsing:</strong> This error strategy allows the first
+// stage of two-stage parsing to immediately terminate if an error is
+// encountered, and immediately fall back to the second stage. In addition to
+// avoiding wasted work by attempting to recover from errors here, the empty
+// implementation of {@link BailErrorStrategy//sync} improves the performance of
+// the first stage.</li>
+// <li><strong>Silent validation:</strong> When syntax errors are not being
+// reported or logged, and the parse result is simply ignored if errors occur,
+// the {@link BailErrorStrategy} avoids wasting work on recovering from errors
+// when the result will be ignored either way.</li>
+// </ul>
+//
+// <p>
+// {@code myparser.setErrorHandler(new BailErrorStrategy());}</p>
+//
+// @see Parser//setErrorHandler(ANTLRErrorStrategy)
+//
+function BailErrorStrategy() {
+	DefaultErrorStrategy.call(this);
+	return this;
+}
+
+BailErrorStrategy.prototype = Object.create(DefaultErrorStrategy.prototype);
+BailErrorStrategy.prototype.constructor = BailErrorStrategy;
+
+// Instead of recovering from exception {@code e}, re-throw it wrapped
+// in a {@link ParseCancellationException} so it is not caught by the
+// rule function catches. Use {@link Exception//getCause()} to get the
+// original {@link RecognitionException}.
+//
+BailErrorStrategy.prototype.recover = function(recognizer, e) {
+    var context = recognizer._ctx;
+    while (context !== null) {
+        context.exception = e;
+        context = context.parentCtx;
+    }
+    throw new ParseCancellationException(e);
+};
+    
+// Make sure we don't attempt to recover inline; if the parser
+// successfully recovers, it won't throw an exception.
+//
+BailErrorStrategy.prototype.recoverInline = function(recognizer) {
+    this.recover(recognizer, new InputMismatchException(recognizer));
+};
+
+// Make sure we don't attempt to recover from problems in subrules.//
+BailErrorStrategy.prototype.sync = function(recognizer) {
+    // pass
+};
+
+exports.BailErrorStrategy = BailErrorStrategy;
+exports.DefaultErrorStrategy = DefaultErrorStrategy;
\ No newline at end of file
diff --git a/runtime/JavaScript/src/antlr4/error/Errors.js b/runtime/JavaScript/src/antlr4/error/Errors.js
new file mode 100644
index 000000000..343f6c969
--- /dev/null
+++ b/runtime/JavaScript/src/antlr4/error/Errors.js
@@ -0,0 +1,192 @@
+// [The "BSD license"]
+//  Copyright (c) 2012 Terence Parr
+//  Copyright (c) 2012 Sam Harwell
+//  Copyright (c) 2014 Eric Vergnaud
+//  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.
+
+// The root of the ANTLR exception hierarchy. In general, ANTLR tracks just
+//  3 kinds of errors: prediction errors, failed predicate errors, and
+//  mismatched input errors. In each case, the parser knows where it is
+//  in the input, where it is in the ATN, the rule invocation stack,
+//  and what kind of problem occurred.
+
+var PredicateTransition = require('./../atn/Transition').PredicateTransition;
+
+function RecognitionException(params) {
+	Error.call(this);
+	if (!!Error.captureStackTrace) {
+        Error.captureStackTrace(this, RecognitionException);
+	} else {
+		var stack = new Error().stack;
+	}
+	this.message = params.message;
+    this.recognizer = params.recognizer;
+    this.input = params.input;
+    this.ctx = params.ctx;
+    // The current {@link Token} when an error occurred. Since not all streams
+    // support accessing symbols by index, we have to track the {@link Token}
+    // instance itself.
+    this.offendingToken = null;
+    // Get the ATN state number the parser was in at the time the error
+    // occurred. For {@link NoViableAltException} and
+    // {@link LexerNoViableAltException} exceptions, this is the
+    // {@link DecisionState} number. For others, it is the state whose outgoing
+    // edge we couldn't match.
+    this.offendingState = -1;
+    if (this.recognizer!==null) {
+        this.offendingState = this.recognizer.state;
+    }
+    return this;
+}
+
+RecognitionException.prototype = Object.create(Error.prototype);
+RecognitionException.prototype.constructor = RecognitionException;
+
+// <p>If the state number is not known, this method returns -1.</p>
+
+//
+// Gets the set of input symbols which could potentially follow the
+// previously matched symbol at the time this exception was thrown.
+//
+// <p>If the set of expected tokens is not known and could not be computed,
+// this method returns {@code null}.</p>
+//
+// @return The set of token types that could potentially follow the current
+// state in the ATN, or {@code null} if the information is not available.
+// /
+RecognitionException.prototype.getExpectedTokens = function() {
+    if (this.recognizer!==null) {
+        return this.recognizer.atn.getExpectedTokens(this.offendingState, this.ctx);
+    } else {
+        return null;
+    }
+};
+
+RecognitionException.prototype.toString = function() {
+    return this.message;
+};
+
+function LexerNoViableAltException(lexer, input, startIndex, deadEndConfigs) {
+	RecognitionException.call(this, {message:"", recognizer:lexer, input:input, ctx:null});
+    this.startIndex = startIndex;
+    this.deadEndConfigs = deadEndConfigs;
+    return this;
+}
+
+LexerNoViableAltException.prototype = Object.create(RecognitionException.prototype);
+LexerNoViableAltException.prototype.constructor = LexerNoViableAltException;
+
+LexerNoViableAltException.prototype.toString = function() {
+    var symbol = "";
+    if (this.startIndex >= 0 && this.startIndex < this.input.size) {
+        symbol = this.input.getText((this.startIndex,this.startIndex));
+    }
+    return "LexerNoViableAltException" + symbol;
+};
+
+// Indicates that the parser could not decide which of two or more paths
+// to take based upon the remaining input. It tracks the starting token
+// of the offending input and also knows where the parser was
+// in the various paths when the error. Reported by reportNoViableAlternative()
+//
+function NoViableAltException(recognizer, input, startToken, offendingToken, deadEndConfigs, ctx) {
+	ctx = ctx || recognizer._ctx;
+	offendingToken = offendingToken || recognizer.getCurrentToken();
+	startToken = startToken || recognizer.getCurrentToken();
+	input = input || recognizer.getInputStream();
+	RecognitionException.call(this, {message:"", recognizer:recognizer, input:input, ctx:ctx});
+    // Which configurations did we try at input.index() that couldn't match
+	// input.LT(1)?//
+    this.deadEndConfigs = deadEndConfigs;
+    // The token object at the start index; the input stream might
+    // not be buffering tokens so get a reference to it. (At the
+    // time the error occurred, of course the stream needs to keep a
+    // buffer all of the tokens but later we might not have access to those.)
+    this.startToken = startToken;
+    this.offendingToken = offendingToken;
+}
+
+NoViableAltException.prototype = Object.create(RecognitionException.prototype);
+NoViableAltException.prototype.constructor = NoViableAltException;
+
+// This signifies any kind of mismatched input exceptions such as
+// when the current input does not match the expected token.
+//
+function InputMismatchException(recognizer) {
+	RecognitionException.call(this, {message:"", recognizer:recognizer, input:recognizer.getInputStream(), ctx:recognizer._ctx});
+    this.offendingToken = recognizer.getCurrentToken();
+}
+
+InputMismatchException.prototype = Object.create(RecognitionException.prototype);
+InputMismatchException.prototype.constructor = InputMismatchException;
+
+// A semantic predicate failed during validation. Validation of predicates
+// occurs when normally parsing the alternative just like matching a token.
+// Disambiguating predicate evaluation occurs when we test a predicate during
+// prediction.
+
+function FailedPredicateException(recognizer, predicate, message) {
+	RecognitionException.call(this, {message:this.formatMessage(predicate,message || null), recognizer:recognizer,
+                         input:recognizer.getInputStream(), ctx:recognizer._ctx});
+    var s = recognizer._interp.atn.states[recognizer.state];
+    var trans = s.transitions[0];
+    if (trans instanceof PredicateTransition) {
+        this.ruleIndex = trans.ruleIndex;
+        this.predicateIndex = trans.predIndex;
+    } else {
+        this.ruleIndex = 0;
+        this.predicateIndex = 0;
+    }
+    this.predicate = predicate;
+    this.offendingToken = recognizer.getCurrentToken();
+    return this;
+}
+
+FailedPredicateException.prototype = Object.create(RecognitionException.prototype);
+FailedPredicateException.prototype.constructor = FailedPredicateException;
+
+FailedPredicateException.prototype.formatMessage = function(predicate, message) {
+    if (message !==null) {
+        return message;
+    } else {
+        return "failed predicate: {" + predicate + "}?";
+    }
+};
+
+function ParseCancellationException() {
+	Error.call(this);
+	Error.captureStackTrace(this, ParseCancellationException);
+	return this;
+}
+
+ParseCancellationException.prototype = Object.create(Error.prototype);
+ParseCancellationException.prototype.constructor = ParseCancellationException;
+
+exports.RecognitionException = RecognitionException;
+exports.NoViableAltException = NoViableAltException;
+exports.LexerNoViableAltException = LexerNoViableAltException;
+exports.InputMismatchException = InputMismatchException;
+exports.FailedPredicateException = FailedPredicateException;
diff --git a/runtime/JavaScript/src/antlr4/error/index.js b/runtime/JavaScript/src/antlr4/error/index.js
new file mode 100644
index 000000000..92f7abbe6
--- /dev/null
+++ b/runtime/JavaScript/src/antlr4/error/index.js
@@ -0,0 +1,8 @@
+exports.RecognitionException = require('./Errors').RecognitionException;
+exports.NoViableAltException = require('./Errors').NoViableAltException;
+exports.LexerNoViableAltException = require('./Errors').LexerNoViableAltException;
+exports.InputMismatchException = require('./Errors').InputMismatchException;
+exports.FailedPredicateException = require('./Errors').FailedPredicateException;
+exports.DiagnosticErrorListener = require('./DiagnosticErrorListener').DiagnosticErrorListener;
+exports.BailErrorStrategy = require('./ErrorStrategy').BailErrorStrategy;
+exports.ErrorListener = require('./ErrorListener').ErrorListener;
\ No newline at end of file
diff --git a/runtime/JavaScript/src/antlr4/index.js b/runtime/JavaScript/src/antlr4/index.js
new file mode 100644
index 000000000..46fb8f440
--- /dev/null
+++ b/runtime/JavaScript/src/antlr4/index.js
@@ -0,0 +1,16 @@
+exports.atn = require('./atn/index');
+exports.dfa = require('./dfa/index');
+exports.tree = require('./tree/index');
+exports.error = require('./error/index');
+exports.Token = require('./Token').Token;
+exports.CommonToken = require('./Token').CommonToken;
+exports.InputStream = require('./InputStream').InputStream;
+exports.FileStream = require('./FileStream').FileStream;
+exports.CommonTokenStream = require('./CommonTokenStream').CommonTokenStream;
+exports.Lexer = require('./Lexer').Lexer;
+exports.Parser = require('./Parser').Parser;
+var pc = require('./PredictionContext');
+exports.PredictionContextCache = pc.PredictionContextCache;
+exports.ParserRuleContext = require('./ParserRuleContext').ParserRuleContext;
+exports.Interval = require('./IntervalSet').Interval;
+exports.Utils = require('./Utils');
diff --git a/runtime/JavaScript/src/antlr4/package.json b/runtime/JavaScript/src/antlr4/package.json
new file mode 100644
index 000000000..dfa05e29e
--- /dev/null
+++ b/runtime/JavaScript/src/antlr4/package.json
@@ -0,0 +1,19 @@
+{
+  "name": "antlr4",
+  "version": "4.5.3",
+  "description": "JavaScript runtime for ANTLR4",
+  "main": "src/antlr4/index.js",
+  "repository": "antlr/antlr4.git",
+  "keywords": [
+    "lexer",
+    "parser",
+    "antlr",
+    "antlr4",
+    "grammar"
+  ],
+  "license": "BSD",
+  "bugs": {
+    "url": "https://github.com/antlr/antlr4/issues"
+  },
+  "homepage": "https://github.com/antlr/antlr4"
+}
diff --git a/runtime/JavaScript/src/antlr4/tree/Tree.js b/runtime/JavaScript/src/antlr4/tree/Tree.js
new file mode 100644
index 000000000..03581c740
--- /dev/null
+++ b/runtime/JavaScript/src/antlr4/tree/Tree.js
@@ -0,0 +1,256 @@
+// [The "BSD license"]
+//  Copyright (c) 2012 Terence Parr
+//  Copyright (c) 2012 Sam Harwell
+//  Copyright (c) 2014 Eric Vergnaud
+//  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.
+///
+
+// The basic notion of a tree has a parent, a payload, and a list of children.
+//  It is the most abstract interface for all the trees used by ANTLR.
+///
+
+var Token = require('./../Token').Token;
+var Interval = require('./../IntervalSet').Interval;
+var INVALID_INTERVAL = new Interval(-1, -2);
+var Utils = require('../Utils.js');
+
+
+function Tree() {
+	return this;
+}
+
+function SyntaxTree() {
+	Tree.call(this);
+	return this;
+}
+
+SyntaxTree.prototype = Object.create(Tree.prototype);
+SyntaxTree.prototype.constructor = SyntaxTree;
+
+function ParseTree() {
+	SyntaxTree.call(this);
+	return this;
+}
+
+ParseTree.prototype = Object.create(SyntaxTree.prototype);
+ParseTree.prototype.constructor = ParseTree;
+
+function RuleNode() {
+	ParseTree.call(this);
+	return this;
+}
+
+RuleNode.prototype = Object.create(ParseTree.prototype);
+RuleNode.prototype.constructor = RuleNode;
+
+function TerminalNode() {
+	ParseTree.call(this);
+	return this;
+}
+
+TerminalNode.prototype = Object.create(ParseTree.prototype);
+TerminalNode.prototype.constructor = TerminalNode;
+
+function ErrorNode() {
+	TerminalNode.call(this);
+	return this;
+}
+
+ErrorNode.prototype = Object.create(TerminalNode.prototype);
+ErrorNode.prototype.constructor = ErrorNode;
+
+function ParseTreeVisitor() {
+	return this;
+}
+
+ParseTreeVisitor.prototype.visit = function(ctx) {
+	if (Utils.isArray(ctx)) {
+		var self = this;
+		return ctx.map(function(child) { return visitAtom(self, child)});
+	} else {
+		return visitAtom(this, ctx);
+	}
+};
+
+ParseTreeVisitor.prototype.visitTerminal = function(node) {
+};
+
+ParseTreeVisitor.prototype.visitErrorNode = function(node) {
+};
+
+
+var visitAtom = function(visitor, ctx) {
+	if (ctx.parser === undefined) { //is terminal
+		return;
+	}
+
+	var name = ctx.parser.ruleNames[ctx.ruleIndex];
+	var funcName = "visit" + Utils.titleCase(name);
+
+	return visitor[funcName](ctx);
+};
+
+function ParseTreeListener() {
+	return this;
+}
+
+ParseTreeListener.prototype.visitTerminal = function(node) {
+};
+
+ParseTreeListener.prototype.visitErrorNode = function(node) {
+};
+
+ParseTreeListener.prototype.enterEveryRule = function(node) {
+};
+
+ParseTreeListener.prototype.exitEveryRule = function(node) {
+};
+
+function TerminalNodeImpl(symbol) {
+	TerminalNode.call(this);
+	this.parentCtx = null;
+	this.symbol = symbol;
+	return this;
+}
+
+TerminalNodeImpl.prototype = Object.create(TerminalNode.prototype);
+TerminalNodeImpl.prototype.constructor = TerminalNodeImpl;
+
+TerminalNodeImpl.prototype.getChild = function(i) {
+	return null;
+};
+
+TerminalNodeImpl.prototype.getSymbol = function() {
+	return this.symbol;
+};
+
+TerminalNodeImpl.prototype.getParent = function() {
+	return this.parentCtx;
+};
+
+TerminalNodeImpl.prototype.getPayload = function() {
+	return this.symbol;
+};
+
+TerminalNodeImpl.prototype.getSourceInterval = function() {
+	if (this.symbol === null) {
+		return INVALID_INTERVAL;
+	}
+	var tokenIndex = this.symbol.tokenIndex;
+	return new Interval(tokenIndex, tokenIndex);
+};
+
+TerminalNodeImpl.prototype.getChildCount = function() {
+	return 0;
+};
+
+TerminalNodeImpl.prototype.accept = function(visitor) {
+	return visitor.visitTerminal(this);
+};
+
+TerminalNodeImpl.prototype.getText = function() {
+	return this.symbol.text;
+};
+
+TerminalNodeImpl.prototype.toString = function() {
+	if (this.symbol.type === Token.EOF) {
+		return "<EOF>";
+	} else {
+		return this.symbol.text;
+	}
+};
+
+// Represents a token that was consumed during resynchronization
+// rather than during a valid match operation. For example,
+// we will create this kind of a node during single token insertion
+// and deletion as well as during "consume until error recovery set"
+// upon no viable alternative exceptions.
+
+function ErrorNodeImpl(token) {
+	TerminalNodeImpl.call(this, token);
+	return this;
+}
+
+ErrorNodeImpl.prototype = Object.create(TerminalNodeImpl.prototype);
+ErrorNodeImpl.prototype.constructor = ErrorNodeImpl;
+
+ErrorNodeImpl.prototype.isErrorNode = function() {
+	return true;
+};
+
+ErrorNodeImpl.prototype.accept = function(visitor) {
+	return visitor.visitErrorNode(this);
+};
+
+function ParseTreeWalker() {
+	return this;
+}
+
+ParseTreeWalker.prototype.walk = function(listener, t) {
+	var errorNode = t instanceof ErrorNode ||
+			(t.isErrorNode !== undefined && t.isErrorNode());
+	if (errorNode) {
+		listener.visitErrorNode(t);
+	} else if (t instanceof TerminalNode) {
+		listener.visitTerminal(t);
+	} else {
+		this.enterRule(listener, t);
+		for (var i = 0; i < t.getChildCount(); i++) {
+			var child = t.getChild(i);
+			this.walk(listener, child);
+		}
+		this.exitRule(listener, t);
+	}
+};
+//
+// The discovery of a rule node, involves sending two events: the generic
+// {@link ParseTreeListener//enterEveryRule} and a
+// {@link RuleContext}-specific event. First we trigger the generic and then
+// the rule specific. We to them in reverse order upon finishing the node.
+//
+ParseTreeWalker.prototype.enterRule = function(listener, r) {
+	var ctx = r.getRuleContext();
+	listener.enterEveryRule(ctx);
+	ctx.enterRule(listener);
+};
+
+ParseTreeWalker.prototype.exitRule = function(listener, r) {
+	var ctx = r.getRuleContext();
+	ctx.exitRule(listener);
+	listener.exitEveryRule(ctx);
+};
+
+ParseTreeWalker.DEFAULT = new ParseTreeWalker();
+
+exports.RuleNode = RuleNode;
+exports.ErrorNode = ErrorNode;
+exports.TerminalNode = TerminalNode;
+exports.ErrorNodeImpl = ErrorNodeImpl;
+exports.TerminalNodeImpl = TerminalNodeImpl;
+exports.ParseTreeListener = ParseTreeListener;
+exports.ParseTreeVisitor = ParseTreeVisitor;
+exports.ParseTreeWalker = ParseTreeWalker;
+exports.INVALID_INTERVAL = INVALID_INTERVAL;
\ No newline at end of file
diff --git a/runtime/JavaScript/src/antlr4/tree/Trees.js b/runtime/JavaScript/src/antlr4/tree/Trees.js
new file mode 100644
index 000000000..d20258e73
--- /dev/null
+++ b/runtime/JavaScript/src/antlr4/tree/Trees.js
@@ -0,0 +1,165 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2012 Terence Parr
+ *  Copyright (c) 2012 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.
+ */
+
+var Utils = require('./../Utils');
+var Token = require('./../Token').Token;
+var RuleNode = require('./Tree').RuleNode;
+var ErrorNode = require('./Tree').ErrorNode;
+var TerminalNode = require('./Tree').TerminalNode;
+var ParserRuleContext = require('./../ParserRuleContext').ParserRuleContext;
+var RuleContext = require('./../RuleContext').RuleContext;
+var INVALID_ALT_NUMBER = require('./../atn/ATN').INVALID_ALT_NUMBER;
+
+
+/** A set of utility routines useful for all kinds of ANTLR trees. */
+function Trees() {
+}
+
+// Print out a whole tree in LISP form. {@link //getNodeText} is used on the
+//  node payloads to get the text for the nodes.  Detect
+//  parse trees and extract data appropriately.
+Trees.toStringTree = function(tree, ruleNames, recog) {
+	ruleNames = ruleNames || null;
+	recog = recog || null;
+    if(recog!==null) {
+       ruleNames = recog.ruleNames;
+    }
+    var s = Trees.getNodeText(tree, ruleNames);
+    s = Utils.escapeWhitespace(s, false);
+    var c = tree.getChildCount();
+    if(c===0) {
+        return s;
+    }
+    var res = "(" + s + ' ';
+    if(c>0) {
+        s = Trees.toStringTree(tree.getChild(0), ruleNames);
+        res = res.concat(s);
+    }
+    for(var i=1;i<c;i++) {
+        s = Trees.toStringTree(tree.getChild(i), ruleNames);
+        res = res.concat(' ' + s);
+    }
+    res = res.concat(")");
+    return res;
+};
+
+Trees.getNodeText = function(t, ruleNames, recog) {
+	ruleNames = ruleNames || null;
+	recog = recog || null;
+    if(recog!==null) {
+        ruleNames = recog.ruleNames;
+    }
+    if(ruleNames!==null) {
+       if (t instanceof RuleContext) {
+           var altNumber = t.getAltNumber();
+           if ( altNumber!=INVALID_ALT_NUMBER ) {
+               return ruleNames[t.ruleIndex]+":"+altNumber;
+           }
+           return ruleNames[t.ruleIndex];
+       } else if ( t instanceof ErrorNode) {
+           return t.toString();
+       } else if(t instanceof TerminalNode) {
+           if(t.symbol!==null) {
+               return t.symbol.text;
+           }
+       }
+    }
+    // no recog for rule names
+    var payload = t.getPayload();
+    if (payload instanceof Token ) {
+       return payload.text;
+    }
+    return t.getPayload().toString();
+};
+
+
+// Return ordered list of all children of this node
+Trees.getChildren = function(t) {
+	var list = [];
+	for(var i=0;i<t.getChildCount();i++) {
+		list.push(t.getChild(i));
+	}
+	return list;
+};
+
+// Return a list of all ancestors of this node.  The first node of
+//  list is the root and the last is the parent of this node.
+//
+Trees.getAncestors = function(t) {
+    var ancestors = [];
+    t = t.getParent();
+    while(t!==null) {
+        ancestors = [t].concat(ancestors);
+        t = t.getParent();
+    }
+    return ancestors;
+};
+
+Trees.findAllTokenNodes = function(t, ttype) {
+    return Trees.findAllNodes(t, ttype, true);
+};
+
+Trees.findAllRuleNodes = function(t, ruleIndex) {
+	return Trees.findAllNodes(t, ruleIndex, false);
+};
+
+Trees.findAllNodes = function(t, index, findTokens) {
+	var nodes = [];
+	Trees._findAllNodes(t, index, findTokens, nodes);
+	return nodes;
+};
+
+Trees._findAllNodes = function(t, index, findTokens, nodes) {
+	// check this node (the root) first
+	if(findTokens && (t instanceof TerminalNode)) {
+		if(t.symbol.type===index) {
+			nodes.push(t);
+		}
+	} else if(!findTokens && (t instanceof ParserRuleContext)) {
+		if(t.ruleIndex===index) {
+			nodes.push(t);
+		}
+	}
+	// check children
+	for(var i=0;i<t.getChildCount();i++) {
+		Trees._findAllNodes(t.getChild(i), index, findTokens, nodes);
+	}
+};
+
+Trees.descendants = function(t) {
+	var nodes = [t];
+    for(var i=0;i<t.getChildCount();i++) {
+        nodes = nodes.concat(Trees.descendants(t.getChild(i)));
+    }
+    return nodes;
+};
+
+
+exports.Trees = Trees;
\ No newline at end of file
diff --git a/runtime/JavaScript/src/antlr4/tree/index.js b/runtime/JavaScript/src/antlr4/tree/index.js
new file mode 100644
index 000000000..e6b760ed0
--- /dev/null
+++ b/runtime/JavaScript/src/antlr4/tree/index.js
@@ -0,0 +1,6 @@
+var Tree = require('./Tree');
+exports.Trees = require('./Trees').Trees;
+exports.RuleNode = Tree.RuleNode;
+exports.ParseTreeListener = Tree.ParseTreeListener;
+exports.ParseTreeVisitor = Tree.ParseTreeVisitor;
+exports.ParseTreeWalker = Tree.ParseTreeWalker;
diff --git a/runtime/JavaScript/src/lib/require.js b/runtime/JavaScript/src/lib/require.js
new file mode 100644
index 000000000..d14210d24
--- /dev/null
+++ b/runtime/JavaScript/src/lib/require.js
@@ -0,0 +1,264 @@
+//
+// This file is part of Honey Require
+//
+// Copyright (c) 2015 Torben Haase
+//
+// Honey Require is free software: you can redistribute it and/or modify it
+// under the terms of the MIT License (MIT).
+//
+// 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.
+//
+// You should have received a copy of the MIT License along with Honey Require.
+// If not, see <https://opensource.org/licenses/MIT>.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+// NOTE The load parameter points to the function, which prepares the
+//      environment for each module and runs its code. Scroll down to the end of
+//      the file to see the function definition.
+(function(load) { 'use strict';
+
+// NOTE Mozilla still sets the wrong fileName property for errors that occur
+//      inside an eval call (even with sourceURL). However, the stack
+//      contains the correct source, so it can be used to re-threw the error
+//      with the correct fileName property.
+// WARN Re-throwing an error object will mess up the stack trace and the
+//      column number.
+    if (typeof (new Error()).fileName == "string") {
+        self.addEventListener("error", function(evt) {
+            if (evt.error instanceof Error) {
+                if (pwd[0]) {
+                    evt.preventDefault();
+                    throw new evt.error.constructor(evt.error.message, pwd[0].uri, evt.error.lineNumber);
+                }
+                else {
+                    var m = evt.error.stack.match(/^[^\n@]*@([^\n]+):\d+:\d+/);
+                    if (m === null) {
+                        console.warn("Honey: unable to read file name from stack");
+                    }
+                    else if (evt.error.fileName != m[1]) {
+                        evt.preventDefault();
+                        throw new evt.error.constructor(evt.error.message, m[1], evt.error.lineNumber);
+                    }
+                }
+            }
+        }, false);
+    }
+
+// INFO Current module descriptors
+//      pwd[0] contains the descriptor of the currently loaded module,
+//      pwd[1] contains the descriptor its parent module and so on.
+
+    var pwd = Array();
+
+// INFO Path parser
+//      Older browsers don't support the URL interface, therefore we use an
+//      anchor element as parser in that case. Thes breaks web worker support,
+//      but we don't care since these browsers also don't support web workers.
+
+    try {
+        var parser = new URL(location.href);
+    }
+    catch (e) {
+        console.warn("Honey: falling back to DOM workaround for URL parser ("+e+")");
+        parser = document.createElement('A');
+    }
+
+// INFO Module cache
+//      Contains getter functions for the exports objects of all the loaded
+//      modules. The getter for the module 'mymod' is name '$name' to prevent
+//      collisions with predefined object properties (see note below).
+//      As long as a module has not been loaded the getter is either undefined
+//      or contains the module code as a function (in case the module has been
+//      pre-loaded in a bundle).
+// WARN IE8 supports defineProperty only for DOM objects, therfore we use a
+//      HTMLDivElement as cache in that case. This breaks web worker support,
+//      but we don't care since IE8 has no web workers at all.
+
+    try {
+        var cache = new Object();
+        Object.defineProperty(cache, "foo", {'value':"bar",'configurable':true});
+        delete cache.foo;
+    }
+    catch (e) {
+        console.warn("Honey: falling back to DOM workaround for cache object ("+e+")");
+        cache = document.createElement('DIV');
+    }
+
+// INFO Send lock
+//      Sending the request causes the event loop to continue. Therefore
+//      pending AJAX load events for the same url might be executed before
+//      the synchronous onLoad is called. This should be no problem, but in
+//      Chrome the responseText of the sneaked in load events will be empty.
+//      Therefore we have to lock the loading while executing send().
+
+    var lock = new Object();
+
+// INFO Honey options
+//      The values can be set by defining a object called Honey. The
+//      Honey object has to be defined before this script here is loaded
+//      and changing the values in the Honey object will have no effect
+//      afterwards!
+
+    var requirePath = self.Honey&&self.Honey.requirePath!==undefined ? self.Honey.requirePath.slice(0) : ['./'];
+    var requireCompiler = self.Honey&&self.Honey.requireCompiler!==undefined ? self.Honey.requireCompiler : null;
+
+// NOTE Parse module root paths
+    var base = [location.origin, location.href.substr(0, location.href.lastIndexOf("/")+1)];
+    for (var i=0; i<requirePath.length; i++) {
+        parser.href = (requirePath[i][0]=="."?base[1]:base[0])+requirePath[i];
+        requirePath[i] = parser.href;
+    }
+
+// NOTE Add preloaded modules to cache
+    for (var id in (self.Honey && self.Honey.requirePreloaded))
+        cache['$'+resolve(id).id] = self.Honey.requirePreloaded[id].toString();
+
+// NOTE Add module overrides to cache
+    for (var id in (self.Honey && self.Honey.requireOverrides))
+        cache['$'+resolve(id).id] = self.Honey.requireOverrides[id];
+
+// INFO Module getter
+//      Takes a module identifier, resolves it and gets the module code via an
+//      AJAX request from the module URI. If this was successful the code and
+//      some environment variables are passed to the load function. The return
+//      value is the module's `exports` object. If the cache already
+//      contains an object for the module id, this object is returned directly.
+// NOTE If a callback function has been passed, the AJAX request is asynchronous
+//      and the mpdule exports are passed to the callback function after the
+//      module has been loaded.
+
+    function require(identifier, callback, compiler) {
+        if (identifier instanceof Array) {
+            var modules = new Array();
+            var modcount = identifier.length;
+            for (var index = 0; index < identifier.length; index++) {
+                (function(id, i) {
+                    modules.push(require(id, callback&&function(mod) {
+                        modules[i] = mod;
+                        (--modcount==0) && callback(modules);
+                    }, compiler));
+                })(identifier[index], index);
+            }
+            return modules;
+        }
+
+        compiler = compiler!==undefined ? compiler : requireCompiler;
+        var descriptor = resolve(identifier);
+        var cacheid = '$'+descriptor.id;
+
+        if (cache[cacheid]) {
+            if (typeof cache[cacheid] === 'string')
+                load(descriptor, cache, pwd, cache[cacheid]);
+            // NOTE The callback should always be called asynchronously to ensure
+            //      that a cached call won't differ from an uncached one.
+            callback && setTimeout(function(){callback(cache[cacheid])}, 0);
+            return cache[cacheid];
+        }
+
+        var request = new XMLHttpRequest();
+
+        // NOTE IE8 doesn't support the onload event, therefore we use
+        //      onreadystatechange as a fallback here. However, onreadystatechange
+        //      shouldn't be used for all browsers, since at least mobile Safari
+        //      seems to have an issue where onreadystatechange is called twice for
+        //      readyState 4.
+        callback && (request[request.onload===null?'onload':'onreadystatechange'] = onLoad);
+        request.open('GET', descriptor.uri, !!callback);
+        lock[cacheid] = lock[cacheid]++||1;
+        request.send();
+        lock[cacheid]--;
+        !callback && onLoad();
+        return cache[cacheid];
+
+        function onLoad() {
+            if (request.readyState != 4)
+                return;
+            if (request.status != 200)
+                throw new Error("Honey: unable to load "+descriptor.id+" ("+request.status+" "+request.statusText+")");
+            if (lock[cacheid]) {
+                console.warn("Honey: module locked: "+descriptor.id);
+                callback && setTimeout(onLoad, 0);
+                return;
+            }
+            if (!cache[cacheid]) {
+                var source = compiler ? compiler(request.responseText) : request.responseText;
+                load(descriptor, cache, pwd, 'function(){\n'+source+'\n}');
+            }
+            callback && callback(cache[cacheid]);
+        }
+    }
+
+// INFO Module resolver
+//      Takes a module identifier and resolves it to a module id and URI. Both
+//      values are returned as a module descriptor, which can be passed to
+//      `fetch` to load a module.
+
+    function resolve(identifier) {
+        // NOTE Matches [1]:[..]/[path/to/][file][.js]
+        var m = identifier.match(/^(?:([^:\/]+):)?(\.\.?)?\/?((?:.*\/)?)([^\.]+)?(\..*)?$/);
+        // NOTE Matches [1]:[/path/to/]file.js
+        var p = (pwd[0]?pwd[0].id:"").match(/^(?:([^:\/]+):)?(.*\/|)[^\/]*$/);
+        var root = m[2] ? requirePath[p[1]?parseInt(p[1]):0] : requirePath[m[1]?parseInt(m[1]):0];
+        parser.href = (m[2]?root+p[2]+m[2]+'/':root)+m[3]+(m[4]?m[4]:'index');
+        var uri = parser.href+(m[5]?m[5]:'.js');
+        if (uri.substr(0,root.length) != root)
+            throw new Error("Honey: relative identifier outside of module root");
+        var id = (m[1]?m[1]+":":"0:")+parser.href.substr(root.length);
+        return {'id':id,'uri':uri};
+    }
+
+// INFO Exporting require to global scope
+
+    if (self.require !== undefined)
+        throw new Error("Honey: '\'require\' already defined in global scope");
+
+    try {
+        Object.defineProperty(self, 'require', {'value':require});
+        Object.defineProperty(self.require, 'resolve', {'value':resolve});
+        Object.defineProperty(self.require, 'path', {'get':function(){return requirePath.slice(0);}});
+    }
+    catch (e) {
+        // NOTE IE8 can't use defineProperty on non-DOM objects, so we have to fall
+        //      back to unsave property assignments in this case.
+        self.require = require;
+        self.require.resolve = resolve;
+        self.require.path = requirePath.slice(0);
+    }
+
+})(
+
+// INFO Module loader
+//      Takes the module descriptor, the global variables and the module code,
+//      sets up the module envirinment, defines the module getter in the cache
+//      and evaluates the module code. If module is a bundle the code of the
+//      pre-loaded modules will be stored in the cache afterwards.
+// NOTE This functions is defined as an anonymous function, which is passed as
+//      a parameter to the closure above to provide a clean environment (only
+//      global variables, module and exports) for the loaded module. This is
+//      also the reason why `source`, `pwd` & `cache` are not named parameters.
+// NOTE If we would strict use mode here, the evaluated code would be forced to be
+//      in strict mode, too.
+
+    function /*load*/(module/*, cache, pwd, source*/) {
+        var global = self;
+        var exports = new Object();
+        Object.defineProperty(module, 'exports', {'get':function(){return exports;},'set':function(e){exports=e;}});
+        arguments[2].unshift(module);
+        Object.defineProperty(arguments[1], '$'+module.id, {'get':function(){return exports;}});
+        arguments[3] = '('+arguments[3]+')();\n//# sourceURL='+module.uri;
+        eval(arguments[3]);
+        // NOTE Store module code in the cache if the loaded file is a bundle
+        if (typeof module.id !== 'string')
+            for (id in module)
+                arguments[1]['$'+require.resolve(id).id] = module[id].toString();
+        arguments[2].shift();
+    }
+
+);
\ No newline at end of file
diff --git a/runtime/Python2/LICENSE.txt b/runtime/Python2/LICENSE.txt
new file mode 100644
index 000000000..dff211c19
--- /dev/null
+++ b/runtime/Python2/LICENSE.txt
@@ -0,0 +1,26 @@
+[The "BSD license"]
+Copyright (c) 2015 Terence Parr, Sam Harwell, Eric Vergnaud
+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.
diff --git a/runtime/Python2/MANIFEST.in b/runtime/Python2/MANIFEST.in
new file mode 100644
index 000000000..86604e496
--- /dev/null
+++ b/runtime/Python2/MANIFEST.in
@@ -0,0 +1 @@
+include *.txt
\ No newline at end of file
diff --git a/runtime/Python2/README.txt b/runtime/Python2/README.txt
new file mode 100644
index 000000000..8763fc473
--- /dev/null
+++ b/runtime/Python2/README.txt
@@ -0,0 +1,4 @@
+This is the Python 2.7 runtime for ANTLR.
+Visit the ANTLR web sites for more information:
+http://www.antlr.org
+https://raw.githubusercontent.com/antlr/antlr4/master/doc/python-target.md
diff --git a/runtime/Python2/RELEASE-4.5.txt b/runtime/Python2/RELEASE-4.5.txt
new file mode 100644
index 000000000..8f976dc77
--- /dev/null
+++ b/runtime/Python2/RELEASE-4.5.txt
@@ -0,0 +1,13 @@
+What's in this release?
+
+ - fixed minor bugs due to mix of ascii/unicode encoding
+ - fixed bug where non-ascii input streams would fail
+ - added support for visitor pattern
+ - added support for wildcards in grammar
+
+ Breaking change:
+
+ In version 4.4, the parser/lexer had a tokenNames member.
+ This has been removed in favor of the following members:
+  - lexicalNames, containing the parsed text
+  - symbolicNames, corresponding to tokenNames
diff --git a/runtime/Python2/setup.py b/runtime/Python2/setup.py
new file mode 100644
index 000000000..b4815753e
--- /dev/null
+++ b/runtime/Python2/setup.py
@@ -0,0 +1,13 @@
+from distutils.core import setup
+
+setup(
+    name='antlr4-python2-runtime',
+    version='4.5.3',
+    packages=['antlr4', 'antlr4.atn', 'antlr4.dfa', 'antlr4.tree', 'antlr4.error', 'antlr4.xpath'],
+    package_dir={'': 'src'},
+    url='http://www.antlr.org',
+    license='BSD',
+    author='Eric Vergnaud, Terence Parr, Sam Harwell',
+    author_email='eric.vergnaud@wanadoo.fr',
+    description='ANTLR 4.5.3 runtime for Python 2.7.6'
+)
diff --git a/runtime/Python2/src/antlr4/BufferedTokenStream.py b/runtime/Python2/src/antlr4/BufferedTokenStream.py
new file mode 100644
index 000000000..fe11d2118
--- /dev/null
+++ b/runtime/Python2/src/antlr4/BufferedTokenStream.py
@@ -0,0 +1,325 @@
+#
+# [The "BSD license"]
+#  Copyright (c) 2012 Terence Parr
+#  Copyright (c) 2012 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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.
+
+# This implementation of {@link TokenStream} loads tokens from a
+# {@link TokenSource} on-demand, and places the tokens in a buffer to provide
+# access to any previous token by index.
+#
+# <p>
+# This token stream ignores the value of {@link Token#getChannel}. If your
+# parser requires the token stream filter tokens to only those on a particular
+# channel, such as {@link Token#DEFAULT_CHANNEL} or
+# {@link Token#HIDDEN_CHANNEL}, use a filtering token stream such a
+# {@link CommonTokenStream}.</p>
+from io import StringIO
+from antlr4.Token import Token
+from antlr4.error.Errors import IllegalStateException
+
+# this is just to keep meaningful parameter types to Parser
+class TokenStream(object):
+
+    pass
+
+
+class BufferedTokenStream(TokenStream):
+
+    def __init__(self, tokenSource):
+        # The {@link TokenSource} from which tokens for this stream are fetched.
+        self.tokenSource = tokenSource
+
+        # A collection of all tokens fetched from the token source. The list is
+        # considered a complete view of the input once {@link #fetchedEOF} is set
+        # to {@code true}.
+        self.tokens = []
+
+        # The index into {@link #tokens} of the current token (next token to
+        # {@link #consume}). {@link #tokens}{@code [}{@link #p}{@code ]} should be
+        # {@link #LT LT(1)}.
+        #
+        # <p>This field is set to -1 when the stream is first constructed or when
+        # {@link #setTokenSource} is called, indicating that the first token has
+        # not yet been fetched from the token source. For additional information,
+        # see the documentation of {@link IntStream} for a description of
+        # Initializing Methods.</p>
+        self.index = -1
+
+        # Indicates whether the {@link Token#EOF} token has been fetched from
+        # {@link #tokenSource} and added to {@link #tokens}. This field improves
+        # performance for the following cases:
+        #
+        # <ul>
+        # <li>{@link #consume}: The lookahead check in {@link #consume} to prevent
+        # consuming the EOF symbol is optimized by checking the values of
+        # {@link #fetchedEOF} and {@link #p} instead of calling {@link #LA}.</li>
+        # <li>{@link #fetch}: The check to prevent adding multiple EOF symbols into
+        # {@link #tokens} is trivial with this field.</li>
+        # <ul>
+        self.fetchedEOF = False
+        
+    def mark(self):
+        return 0
+    
+    def release(self, marker):
+        # no resources to release
+        pass
+    
+    def reset(self):
+        self.seek(0)
+
+    def seek(self, index):
+        self.lazyInit()
+        self.index = self.adjustSeekIndex(index)
+
+    def get(self, index):
+        self.lazyInit()
+        return self.tokens[index]
+
+    def consume(self):
+        skipEofCheck = False
+        if self.index >= 0:
+            if self.fetchedEOF:
+                # the last token in tokens is EOF. skip check if p indexes any
+                # fetched token except the last.
+                skipEofCheck = self.index < len(self.tokens) - 1
+            else:
+                # no EOF token in tokens. skip check if p indexes a fetched token.
+                skipEofCheck = self.index < len(self.tokens)
+        else:
+            # not yet initialized
+            skipEofCheck = False
+
+        if not skipEofCheck and self.LA(1) == Token.EOF:
+            raise IllegalStateException("cannot consume EOF")
+
+        if self.sync(self.index + 1):
+            self.index = self.adjustSeekIndex(self.index + 1)
+
+    # Make sure index {@code i} in tokens has a token.
+    #
+    # @return {@code true} if a token is located at index {@code i}, otherwise
+    #    {@code false}.
+    # @see #get(int i)
+    #/
+    def sync(self, i):
+        n = i - len(self.tokens) + 1 # how many more elements we need?
+        if n > 0 :
+            fetched = self.fetch(n)
+            return fetched >= n
+        return True
+
+    # Add {@code n} elements to buffer.
+    #
+    # @return The actual number of elements added to the buffer.
+    #/
+    def fetch(self, n):
+        if self.fetchedEOF:
+            return 0
+        for i in range(0, n):
+            t = self.tokenSource.nextToken()
+            t.tokenIndex = len(self.tokens)
+            self.tokens.append(t)
+            if t.type==Token.EOF:
+                self.fetchedEOF = True
+                return i + 1
+        return n
+
+
+    # Get all tokens from start..stop inclusively#/
+    def getTokens(self, start, stop, types=None):
+        if start<0 or stop<0:
+            return None
+        self.lazyInit()
+        subset = []
+        if stop >= len(self.tokens):
+            stop = len(self.tokens)-1
+        for i in range(start, stop):
+            t = self.tokens[i]
+            if t.type==Token.EOF:
+                break
+            if types is None or t.type in types:
+                subset.append(t)
+        return subset
+
+    def LA(self, i):
+        return self.LT(i).type
+
+    def LB(self, k):
+        if (self.index-k) < 0:
+            return None
+        return self.tokens[self.index-k]
+
+    def LT(self, k):
+        self.lazyInit()
+        if k==0:
+            return None
+        if k < 0:
+            return self.LB(-k)
+        i = self.index + k - 1
+        self.sync(i)
+        if i >= len(self.tokens): # return EOF token
+            # EOF must be last token
+            return self.tokens[len(self.tokens)-1]
+        return self.tokens[i]
+
+    # Allowed derived classes to modify the behavior of operations which change
+    # the current stream position by adjusting the target token index of a seek
+    # operation. The default implementation simply returns {@code i}. If an
+    # exception is thrown in this method, the current stream index should not be
+    # changed.
+    #
+    # <p>For example, {@link CommonTokenStream} overrides this method to ensure that
+    # the seek target is always an on-channel token.</p>
+    #
+    # @param i The target token index.
+    # @return The adjusted target token index.
+
+    def adjustSeekIndex(self, i):
+        return i
+
+    def lazyInit(self):
+        if self.index == -1:
+            self.setup()
+
+    def setup(self):
+        self.sync(0)
+        self.index = self.adjustSeekIndex(0)
+
+    # Reset this token stream by setting its token source.#/
+    def setTokenSource(self, tokenSource):
+        self.tokenSource = tokenSource
+        self.tokens = []
+        self.index = -1
+
+
+
+    # Given a starting index, return the index of the next token on channel.
+    #  Return i if tokens[i] is on channel.  Return -1 if there are no tokens
+    #  on channel between i and EOF.
+    #/
+    def nextTokenOnChannel(self, i, channel):
+        self.sync(i)
+        if i>=len(self.tokens):
+            return -1
+        token = self.tokens[i]
+        while token.channel!=channel:
+            if token.type==Token.EOF:
+                return -1
+            i += 1
+            self.sync(i)
+            token = self.tokens[i]
+        return i
+
+    # Given a starting index, return the index of the previous token on channel.
+    #  Return i if tokens[i] is on channel. Return -1 if there are no tokens
+    #  on channel between i and 0.
+    def previousTokenOnChannel(self, i, channel):
+        while i>=0 and self.tokens[i].channel!=channel:
+            i -= 1
+        return i
+
+    # Collect all tokens on specified channel to the right of
+    #  the current token up until we see a token on DEFAULT_TOKEN_CHANNEL or
+    #  EOF. If channel is -1, find any non default channel token.
+    def getHiddenTokensToRight(self, tokenIndex, channel=-1):
+        self.lazyInit()
+        if tokenIndex<0 or tokenIndex>=len(self.tokens):
+            raise Exception(str(tokenIndex) + " not in 0.." + str(len(self.tokens)-1))
+        from antlr4.Lexer import Lexer
+        nextOnChannel = self.nextTokenOnChannel(tokenIndex + 1, Lexer.DEFAULT_TOKEN_CHANNEL)
+        from_ = tokenIndex+1
+        # if none onchannel to right, nextOnChannel=-1 so set to = last token
+        to = (len(self.tokens)-1) if nextOnChannel==-1 else nextOnChannel
+        return self.filterForChannel(from_, to, channel)
+
+
+    # Collect all tokens on specified channel to the left of
+    #  the current token up until we see a token on DEFAULT_TOKEN_CHANNEL.
+    #  If channel is -1, find any non default channel token.
+    def getHiddenTokensToLeft(self, tokenIndex, channel=-1):
+        self.lazyInit()
+        if tokenIndex<0 or tokenIndex>=len(self.tokens):
+            raise Exception(str(tokenIndex) + " not in 0.." + str(len(self.tokens)-1))
+        from antlr4.Lexer import Lexer
+        prevOnChannel = self.previousTokenOnChannel(tokenIndex - 1, Lexer.DEFAULT_TOKEN_CHANNEL)
+        if prevOnChannel == tokenIndex - 1:
+            return None
+        # if none on channel to left, prevOnChannel=-1 then from=0
+        from_ = prevOnChannel+1
+        to = tokenIndex-1
+        return self.filterForChannel(from_, to, channel)
+
+
+    def filterForChannel(self, left, right, channel):
+        hidden = []
+        for i in range(left, right+1):
+            t = self.tokens[i]
+            if channel==-1:
+                from antlr4.Lexer import Lexer
+                if t.channel!= Lexer.DEFAULT_TOKEN_CHANNEL:
+                    hidden.append(t)
+            elif t.channel==channel:
+                    hidden.append(t)
+        if len(hidden)==0:
+            return None
+        return hidden
+
+    def getSourceName(self):
+        return self.tokenSource.getSourceName()
+
+    # Get the text of all tokens in this buffer.#/
+    def getText(self, interval=None):
+        self.lazyInit()
+        self.fill()
+        if interval is None:
+            interval = (0, len(self.tokens)-1)
+        start = interval[0]
+        if isinstance(start, Token):
+            start = start.tokenIndex
+        stop = interval[1]
+        if isinstance(stop, Token):
+            stop = stop.tokenIndex
+        if start is None or stop is None or start<0 or stop<0:
+            return ""
+        if stop >= len(self.tokens):
+            stop = len(self.tokens)-1
+        with StringIO() as buf:
+            for i in range(start, stop+1):
+                t = self.tokens[i]
+                if t.type==Token.EOF:
+                    break
+                buf.write(t.text)
+            return buf.getvalue()
+
+
+    # Get all tokens from lexer until EOF#/
+    def fill(self):
+        self.lazyInit()
+        while self.fetch(1000)==1000:
+            pass
diff --git a/runtime/Python2/src/antlr4/CommonTokenFactory.py b/runtime/Python2/src/antlr4/CommonTokenFactory.py
new file mode 100644
index 000000000..8434479d4
--- /dev/null
+++ b/runtime/Python2/src/antlr4/CommonTokenFactory.py
@@ -0,0 +1,84 @@
+#
+# [The "BSD license"]
+#  Copyright (c) 2012 Terence Parr
+#  Copyright (c) 2012 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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.
+#
+
+#
+# This default implementation of {@link TokenFactory} creates
+# {@link CommonToken} objects.
+#
+from antlr4.Token import CommonToken
+
+class TokenFactory(object):
+
+    pass
+
+class CommonTokenFactory(TokenFactory):
+    #
+    # The default {@link CommonTokenFactory} instance.
+    #
+    # <p>
+    # This token factory does not explicitly copy token text when constructing
+    # tokens.</p>
+    #
+    DEFAULT = None
+
+    def __init__(self, copyText=False):
+        # Indicates whether {@link CommonToken#setText} should be called after
+        # constructing tokens to explicitly set the text. This is useful for cases
+        # where the input stream might not be able to provide arbitrary substrings
+        # of text from the input after the lexer creates a token (e.g. the
+        # implementation of {@link CharStream#getText} in
+        # {@link UnbufferedCharStream} throws an
+        # {@link UnsupportedOperationException}). Explicitly setting the token text
+        # allows {@link Token#getText} to be called at any time regardless of the
+        # input stream implementation.
+        #
+        # <p>
+        # The default value is {@code false} to avoid the performance and memory
+        # overhead of copying text for every token unless explicitly requested.</p>
+        #
+        self.copyText = copyText
+
+    def create(self, source, type, text, channel, start, stop, line, column):
+        t = CommonToken(source, type, channel, start, stop)
+        t.line = line
+        t.column = column
+        if text is not None:
+            t.text = text
+        elif self.copyText and source[1] is not None:
+            t.text = source[1].getText(start,stop)
+        return t
+
+    def createThin(self, type, text):
+        t = CommonToken(type=type)
+        t.text = text
+        return t
+
+CommonTokenFactory.DEFAULT = CommonTokenFactory()
\ No newline at end of file
diff --git a/runtime/Python2/src/antlr4/CommonTokenStream.py b/runtime/Python2/src/antlr4/CommonTokenStream.py
new file mode 100644
index 000000000..05ff7f520
--- /dev/null
+++ b/runtime/Python2/src/antlr4/CommonTokenStream.py
@@ -0,0 +1,110 @@
+#
+# [The "BSD license"]
+#  Copyright (c) 2012 Terence Parr
+#  Copyright (c) 2012 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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.
+#/
+
+#
+# This class extends {@link BufferedTokenStream} with functionality to filter
+# token streams to tokens on a particular channel (tokens where
+# {@link Token#getChannel} returns a particular value).
+#
+# <p>
+# This token stream provides access to all tokens by index or when calling
+# methods like {@link #getText}. The channel filtering is only used for code
+# accessing tokens via the lookahead methods {@link #LA}, {@link #LT}, and
+# {@link #LB}.</p>
+#
+# <p>
+# By default, tokens are placed on the default channel
+# ({@link Token#DEFAULT_CHANNEL}), but may be reassigned by using the
+# {@code ->channel(HIDDEN)} lexer command, or by using an embedded action to
+# call {@link Lexer#setChannel}.
+# </p>
+#
+# <p>
+# Note: lexer rules which use the {@code ->skip} lexer command or call
+# {@link Lexer#skip} do not produce tokens at all, so input text matched by
+# such a rule will not be available as part of the token stream, regardless of
+# channel.</p>
+#/
+
+from antlr4.BufferedTokenStream import BufferedTokenStream
+from antlr4.Token import Token
+
+
+class CommonTokenStream(BufferedTokenStream):
+
+    def __init__(self, lexer, channel=Token.DEFAULT_CHANNEL):
+        super(CommonTokenStream, self).__init__(lexer)
+        self.channel = channel
+
+    def adjustSeekIndex(self, i):
+        return self.nextTokenOnChannel(i, self.channel)
+
+    def LB(self, k):
+        if k==0 or (self.index-k)<0:
+            return None
+        i = self.index
+        n = 1
+        # find k good tokens looking backwards
+        while n <= k:
+            # skip off-channel tokens
+            i = self.previousTokenOnChannel(i - 1, self.channel)
+            n += 1
+        if i < 0:
+            return None
+        return self.tokens[i]
+
+    def LT(self, k):
+        self.lazyInit()
+        if k == 0:
+            return None
+        if k < 0:
+            return self.LB(-k)
+        i = self.index
+        n = 1 # we know tokens[pos] is a good one
+        # find k good tokens
+        while n < k:
+            # skip off-channel tokens, but make sure to not look past EOF
+            if self.sync(i + 1):
+                i = self.nextTokenOnChannel(i + 1, self.channel)
+            n += 1
+        return self.tokens[i]
+
+    # Count EOF just once.#/
+    def getNumberOfOnChannelTokens(self):
+        n = 0
+        self.fill()
+        for i in range(0, len(self.tokens)):
+            t = self.tokens[i]
+            if t.channel==self.channel:
+                n += 1
+            if t.type==Token.EOF:
+                break
+        return n
diff --git a/runtime/Python2/src/antlr4/FileStream.py b/runtime/Python2/src/antlr4/FileStream.py
new file mode 100644
index 000000000..733672413
--- /dev/null
+++ b/runtime/Python2/src/antlr4/FileStream.py
@@ -0,0 +1,57 @@
+#
+#  [The "BSD license"]
+#   Copyright (c) 2012 Terence Parr
+#   Copyright (c) 2012 Sam Harwell
+#   Copyright (c) 2014 Eric Vergnaud
+#   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.
+# 
+
+#
+#  This is an InputStream that is loaded from a file all at once
+#  when you construct the object.
+# 
+
+import codecs
+import unittest
+from antlr4.InputStream import InputStream
+
+
+class FileStream(InputStream):
+
+    def __init__(self, fileName, encoding='ascii'):
+        self.fileName = fileName
+        # read binary to avoid line ending conversion
+        with open(fileName, 'rb') as file:
+            bytes = file.read()
+            data = codecs.decode(bytes, encoding)
+            super(type(self), self).__init__(data)
+
+
+class TestFileStream(unittest.TestCase):
+
+    def testStream(self):
+        stream = FileStream("FileStream.py")
+        self.assertTrue(stream.size>0)
diff --git a/runtime/Python2/src/antlr4/InputStream.py b/runtime/Python2/src/antlr4/InputStream.py
new file mode 100644
index 000000000..633f2aa05
--- /dev/null
+++ b/runtime/Python2/src/antlr4/InputStream.py
@@ -0,0 +1,133 @@
+# 
+#  [The "BSD license"]
+#   Copyright (c) 2012 Terence Parr
+#   Copyright (c) 2012 Sam Harwell
+#   Copyright (c) 2014 Eric Vergnaud
+#   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.
+# 
+import unittest
+
+
+# 
+#  Vacuum all input from a string and then treat it like a buffer. 
+#
+from antlr4.Token import Token
+
+
+class InputStream (object):
+    
+    def __init__(self, data):
+        self.name = "<empty>"
+        self.strdata = unicode(data)
+        self._loadString()
+
+    def _loadString(self):    
+        self._index = 0
+        self.data = [ord(c) for c in self.strdata]
+        self._size = len(self.data)
+
+    @property
+    def index(self):
+        return self._index
+
+    @property
+    def size(self):
+        return self._size
+
+    # Reset the stream so that it's in the same state it was
+    #  when the object was created *except* the data array is not
+    #  touched.
+    #
+    def reset(self):
+        self._index = 0
+
+    def consume(self):
+        if self._index >= self._size:
+            assert self.LA(1) == Token.EOF
+            raise Exception("cannot consume EOF")
+        self._index += 1
+
+    def LA(self, offset):
+        if offset==0:
+            return 0 # undefined
+        if offset<0:
+            offset += 1 # e.g., translate LA(-1) to use offset=0
+        pos = self._index + offset - 1
+        if pos < 0 or pos >= self._size: # invalid
+            return Token.EOF
+        return self.data[pos]
+
+    def LT(self, offset):
+        return self.LA(offset)
+
+    # mark/release do nothing; we have entire buffer
+    def mark(self):
+        return -1
+
+    def release(self, marker):
+        pass
+
+    # consume() ahead until p==_index; can't just set p=_index as we must
+    # update line and column. If we seek backwards, just set p
+    #
+    def seek(self, _index):
+        if _index<=self._index:
+            self._index = _index # just jump; don't update stream state (line, ...)
+            return
+        # seek forward
+        self._index = min(_index, self._size)
+
+    def getText(self, start, stop):
+        if stop >= self._size:
+            stop = self._size-1
+        if start >= self._size:
+            return ""
+        else:
+            return self.strdata[start:stop+1]
+
+    def __str__(self):
+        return unicode(self)
+
+    def __unicode__(self):
+        return self.strdata
+
+
+class TestInputStream(unittest.TestCase):
+    
+    def testStream(self):
+        stream = InputStream("abcde")
+        self.assertEqual(0, stream.index)
+        self.assertEqual(5, stream.size)
+        self.assertEqual(ord("a"), stream.LA(1))
+        stream.consume()
+        self.assertEqual(1, stream.index)
+        stream.seek(5)
+        self.assertEqual(Token.EOF, stream.LA(1))
+        self.assertEqual("bcd", stream.getText(1, 3))
+        stream.reset()
+        self.assertEqual(0, stream.index)
+        
+        
\ No newline at end of file
diff --git a/runtime/Python2/src/antlr4/IntervalSet.py b/runtime/Python2/src/antlr4/IntervalSet.py
new file mode 100644
index 000000000..e28a556d4
--- /dev/null
+++ b/runtime/Python2/src/antlr4/IntervalSet.py
@@ -0,0 +1,295 @@
+from io import StringIO
+import unittest
+from antlr4.Token import Token
+
+class Interval(object):
+
+    def __init__(self, start, stop):
+        self.start = start
+        self.stop = stop
+        self.range = xrange(start, stop)
+
+    def __contains__(self, item):
+        return item in self.range
+    
+    def __len__(self):
+        return self.stop - self.start
+
+    def __iter__(self):
+        return iter(self.range)
+
+class IntervalSet(object):
+
+    def __init__(self):
+        self.intervals = None
+        self.readOnly = False
+
+    def __iter__(self):
+        if self.intervals is not None:
+            for i in self.intervals:
+                for c in i:
+                    yield c
+
+    def __getitem__(self, item):
+        i = 0
+        for k in self:
+            if i==item:
+                return k
+            else:
+                i += 1
+        return Token.INVALID_TYPE
+
+    def addOne(self, v):
+        self.addRange(Interval(v, v+1))
+
+    def addRange(self, v):
+        if self.intervals is None:
+            self.intervals = list()
+            self.intervals.append(v)
+        else:
+            # find insert pos
+            k = 0
+            for i in self.intervals:
+                # distinct range -> insert
+                if v.stop<i.start:
+                    self.intervals.insert(k, v)
+                    return
+                # contiguous range -> adjust
+                elif v.stop==i.start:
+                    self.intervals[k] = Interval(v.start, i.stop)
+                    return
+                # overlapping range -> adjust and reduce
+                elif v.start<=i.stop:
+                    self.intervals[k] = Interval(min(i.start,v.start), max(i.stop,v.stop))
+                    self.reduce(k)
+                    return
+                k += 1
+            # greater than any existing
+            self.intervals.append(v)
+
+    def addSet(self, other):
+        if other.intervals is not None:
+            for i in other.intervals:
+                self.addRange(i)
+        return self
+
+    def reduce(self, k):
+        # only need to reduce if k is not the last
+        if k<len(self.intervals)-1:
+            l = self.intervals[k]
+            r = self.intervals[k+1]
+            # if r contained in l
+            if l.stop >= r.stop:
+                self.intervals.pop(k+1)
+                self.reduce(k)
+            elif l.stop >= r.start:
+                self.intervals[k] = Interval(l.start, r.stop)
+                self.intervals.pop(k+1)
+
+    def complement(self, start, stop):
+        result = IntervalSet()
+        result.addRange(Interval(start,stop+1))
+        for i in self.intervals:
+            result.removeRange(i)
+        return result
+
+    def __contains__(self, item):
+        if self.intervals is None:
+            return False
+        else:
+            for i in self.intervals:
+                if item in i:
+                    return True
+            return False
+
+    def __len__(self):
+        xlen = 0
+        for i in self.intervals:
+            xlen += len(i)
+        return xlen
+
+    def removeRange(self, v):
+        if v.start==v.stop-1:
+            self.removeOne(v.start)
+        elif self.intervals is not None:
+            k = 0
+            for i in self.intervals:
+                # intervals are ordered
+                if v.stop<=i.start:
+                    return
+                # check for including range, split it
+                elif v.start>i.start and v.stop<i.stop:
+                    self.intervals[k] = Interval(i.start, v.start)
+                    x = Interval(v.stop, i.stop)
+                    self.intervals.insert(k, x)
+                    return
+                # check for included range, remove it
+                elif v.start<=i.start and v.stop>=i.stop:
+                    self.intervals.pop(k)
+                    k = k - 1 # need another pass
+                # check for lower boundary
+                elif v.start<i.stop:
+                    self.intervals[k] = Interval(i.start, v.start)
+                # check for upper boundary
+                elif v.stop<i.stop:
+                    self.intervals[k] = Interval(v.stop, i.stop)
+                k += 1
+
+    def removeOne(self, v):
+        if self.intervals is not None:
+            k = 0
+            for i in self.intervals:
+                # intervals is ordered
+                if v<i.start:
+                    return
+                # check for single value range
+                elif v==i.start and v==i.stop-1:
+                    self.intervals.pop(k)
+                    return
+                # check for lower boundary
+                elif v==i.start:
+                    self.intervals[k] = Interval(i.start+1, i.stop)
+                    return
+                # check for upper boundary
+                elif v==i.stop-1:
+                    self.intervals[k] = Interval(i.start, i.stop-1)
+                    return
+                # split existing range
+                elif v<i.stop-1:
+                    x = Interval(i.start, v)
+                    i.start = v + 1
+                    self.intervals.insert(k, x)
+                    return
+                k += 1
+
+
+    def toString(self, literalNames, symbolicNames):
+        if self.intervals is None:
+            return u"{}"
+        with StringIO() as buf:
+            if len(self)>1:
+                buf.write(u"{")
+            first = True
+            for i in self.intervals:
+                for j in i:
+                    if not first:
+                        buf.write(u", ")
+                    buf.write(self.elementName(literalNames, symbolicNames, j))
+                    first = False
+            if len(self)>1:
+                buf.write(u"}")
+            return buf.getvalue()
+
+    def elementName(self, literalNames, symbolicNames, a):
+        if a==Token.EOF:
+            return u"<EOF>"
+        elif a==Token.EPSILON:
+            return u"<EPSILON>"
+        else:
+            if a<len(literalNames):
+                return literalNames[a]
+            if a<len(symbolicNames):
+                return symbolicNames[a]
+            return u"<UNKNOWN>"
+
+
+class TestIntervalSet(unittest.TestCase):
+
+    def testEmpty(self):
+        s = IntervalSet()
+        self.assertIsNone(s.intervals)
+        self.assertFalse(30 in s)
+
+    def testOne(self):
+        s = IntervalSet()
+        s.addOne(30)
+        self.assertTrue(30 in s)
+        self.assertFalse(29 in s)
+        self.assertFalse(31 in s)
+
+    def testTwo(self):
+        s = IntervalSet()
+        s.addOne(30)
+        s.addOne(40)
+        self.assertTrue(30 in s)
+        self.assertTrue(40 in s)
+        self.assertFalse(35 in s)
+
+    def testRange(self):
+        s = IntervalSet()
+        s.addRange(Interval(30,41))
+        self.assertTrue(30 in s)
+        self.assertTrue(40 in s)
+        self.assertTrue(35 in s)
+
+    def testDistinct1(self):
+        s = IntervalSet()
+        s.addRange(Interval(30,32))
+        s.addRange(Interval(40,42))
+        self.assertEquals(2,len(s.intervals))
+        self.assertTrue(30 in s)
+        self.assertTrue(40 in s)
+        self.assertFalse(35 in s)
+
+    def testDistinct2(self):
+        s = IntervalSet()
+        s.addRange(Interval(40,42))
+        s.addRange(Interval(30,32))
+        self.assertEquals(2,len(s.intervals))
+        self.assertTrue(30 in s)
+        self.assertTrue(40 in s)
+        self.assertFalse(35 in s)
+
+    def testContiguous1(self):
+        s = IntervalSet()
+        s.addRange(Interval(30,36))
+        s.addRange(Interval(36,41))
+        self.assertEquals(1,len(s.intervals))
+        self.assertTrue(30 in s)
+        self.assertTrue(40 in s)
+        self.assertTrue(35 in s)
+
+    def testContiguous2(self):
+        s = IntervalSet()
+        s.addRange(Interval(36,41))
+        s.addRange(Interval(30,36))
+        self.assertEquals(1,len(s.intervals))
+        self.assertTrue(30 in s)
+        self.assertTrue(40 in s)
+
+    def testOverlapping1(self):
+        s = IntervalSet()
+        s.addRange(Interval(30,40))
+        s.addRange(Interval(35,45))
+        self.assertEquals(1,len(s.intervals))
+        self.assertTrue(30 in s)
+        self.assertTrue(44 in s)
+
+    def testOverlapping2(self):
+        s = IntervalSet()
+        s.addRange(Interval(35,45))
+        s.addRange(Interval(30,40))
+        self.assertEquals(1,len(s.intervals))
+        self.assertTrue(30 in s)
+        self.assertTrue(44 in s)
+
+    def testOverlapping3(self):
+        s = IntervalSet()
+        s.addRange(Interval(30,32))
+        s.addRange(Interval(40,42))
+        s.addRange(Interval(50,52))
+        s.addRange(Interval(20,61))
+        self.assertEquals(1,len(s.intervals))
+        self.assertTrue(20 in s)
+        self.assertTrue(60 in s)
+
+    def testComplement(self):
+        s = IntervalSet()
+        s.addRange(Interval(10,21))
+        c = s.complement(1,100)
+        self.assertTrue(1 in c)
+        self.assertTrue(100 in c)
+        self.assertTrue(10 not in c)
+        self.assertTrue(20 not in c)
+
+
diff --git a/runtime/Python2/src/antlr4/LL1Analyzer.py b/runtime/Python2/src/antlr4/LL1Analyzer.py
new file mode 100644
index 000000000..66b7a1dd3
--- /dev/null
+++ b/runtime/Python2/src/antlr4/LL1Analyzer.py
@@ -0,0 +1,195 @@
+#
+# [The "BSD license"]
+#  Copyright (c) 2012 Terence Parr
+#  Copyright (c) 2012 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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.
+#/
+from antlr4.IntervalSet import IntervalSet, Interval
+from antlr4.Token import Token
+from antlr4.PredictionContext import PredictionContext, SingletonPredictionContext, PredictionContextFromRuleContext
+from antlr4.atn.ATNConfig import ATNConfig
+from antlr4.atn.ATNState import ATNState, RuleStopState
+from antlr4.atn.Transition import WildcardTransition, NotSetTransition, AbstractPredicateTransition, RuleTransition
+
+
+class LL1Analyzer (object):
+    
+    #* Special value added to the lookahead sets to indicate that we hit
+    #  a predicate during analysis if {@code seeThruPreds==false}.
+    #/
+    HIT_PRED = Token.INVALID_TYPE
+
+    def __init__(self, atn):
+        self.atn = atn
+
+    #*
+    # Calculates the SLL(1) expected lookahead set for each outgoing transition
+    # of an {@link ATNState}. The returned array has one element for each
+    # outgoing transition in {@code s}. If the closure from transition
+    # <em>i</em> leads to a semantic predicate before matching a symbol, the
+    # element at index <em>i</em> of the result will be {@code null}.
+    #
+    # @param s the ATN state
+    # @return the expected symbols for each outgoing transition of {@code s}.
+    #/
+    def getDecisionLookahead(self, s):
+        if s is None:
+            return None
+
+        count = len(s.transitions)
+        look = [] * count
+        for alt in range(0, count):
+            look[alt] = set()
+            lookBusy = set()
+            seeThruPreds = False # fail to get lookahead upon pred
+            self._LOOK(s.transition(alt).target, None, PredictionContext.EMPTY, \
+                  look[alt], lookBusy, set(), seeThruPreds, False)
+            # Wipe out lookahead for this alternative if we found nothing
+            # or we had a predicate when we !seeThruPreds
+            if len(look[alt])==0 or self.HIT_PRED in look[alt]:
+                look[alt] = None
+        return look
+
+    #*
+    # Compute set of tokens that can follow {@code s} in the ATN in the
+    # specified {@code ctx}.
+    #
+    # <p>If {@code ctx} is {@code null} and the end of the rule containing
+    # {@code s} is reached, {@link Token#EPSILON} is added to the result set.
+    # If {@code ctx} is not {@code null} and the end of the outermost rule is
+    # reached, {@link Token#EOF} is added to the result set.</p>
+    #
+    # @param s the ATN state
+    # @param stopState the ATN state to stop at. This can be a
+    # {@link BlockEndState} to detect epsilon paths through a closure.
+    # @param ctx the complete parser context, or {@code null} if the context
+    # should be ignored
+    #
+    # @return The set of tokens that can follow {@code s} in the ATN in the
+    # specified {@code ctx}.
+    #/
+    def LOOK(self, s, stopState=None, ctx=None):
+        r = IntervalSet()
+        seeThruPreds = True # ignore preds; get all lookahead
+        lookContext = PredictionContextFromRuleContext(s.atn, ctx) if ctx is not None else None
+        self._LOOK(s, stopState, lookContext, r, set(), set(), seeThruPreds, True)
+        return r
+
+    #*
+    # Compute set of tokens that can follow {@code s} in the ATN in the
+    # specified {@code ctx}.
+    #
+    # <p>If {@code ctx} is {@code null} and {@code stopState} or the end of the
+    # rule containing {@code s} is reached, {@link Token#EPSILON} is added to
+    # the result set. If {@code ctx} is not {@code null} and {@code addEOF} is
+    # {@code true} and {@code stopState} or the end of the outermost rule is
+    # reached, {@link Token#EOF} is added to the result set.</p>
+    #
+    # @param s the ATN state.
+    # @param stopState the ATN state to stop at. This can be a
+    # {@link BlockEndState} to detect epsilon paths through a closure.
+    # @param ctx The outer context, or {@code null} if the outer context should
+    # not be used.
+    # @param look The result lookahead set.
+    # @param lookBusy A set used for preventing epsilon closures in the ATN
+    # from causing a stack overflow. Outside code should pass
+    # {@code new HashSet<ATNConfig>} for this argument.
+    # @param calledRuleStack A set used for preventing left recursion in the
+    # ATN from causing a stack overflow. Outside code should pass
+    # {@code new BitSet()} for this argument.
+    # @param seeThruPreds {@code true} to true semantic predicates as
+    # implicitly {@code true} and "see through them", otherwise {@code false}
+    # to treat semantic predicates as opaque and add {@link #HIT_PRED} to the
+    # result if one is encountered.
+    # @param addEOF Add {@link Token#EOF} to the result if the end of the
+    # outermost context is reached. This parameter has no effect if {@code ctx}
+    # is {@code null}.
+    #/
+    def _LOOK(self, s, stopState , ctx, look, lookBusy, \
+                     calledRuleStack, seeThruPreds, addEOF):
+        c = ATNConfig(s, 0, ctx)
+
+        if c in lookBusy:
+            return
+        lookBusy.add(c)
+
+        if s == stopState:
+            if ctx is None:
+                look.addOne(Token.EPSILON)
+                return
+            elif ctx.isEmpty() and addEOF:
+                look.addOne(Token.EOF)
+                return
+
+        if isinstance(s, RuleStopState ):
+            if ctx is None:
+                look.addOne(Token.EPSILON)
+                return
+            elif ctx.isEmpty() and addEOF:
+                look.addOne(Token.EOF)
+                return
+
+            if ctx != PredictionContext.EMPTY:
+                # run thru all possible stack tops in ctx
+                for i in range(0, len(ctx)):
+                    returnState = self.atn.states[ctx.getReturnState(i)]
+                    removed = returnState.ruleIndex in calledRuleStack
+                    try:
+                        calledRuleStack.discard(returnState.ruleIndex)
+                        self._LOOK(returnState, stopState, ctx.getParent(i), look, lookBusy, calledRuleStack, seeThruPreds, addEOF)
+                    finally:
+                        if removed:
+                            calledRuleStack.add(returnState.ruleIndex)
+                return
+
+        for t in s.transitions:
+            if type(t) == RuleTransition:
+                if t.target.ruleIndex in calledRuleStack:
+                    continue
+
+                newContext = SingletonPredictionContext.create(ctx, t.followState.stateNumber)
+
+                try:
+                    calledRuleStack.add(t.target.ruleIndex)
+                    self._LOOK(t.target, stopState, newContext, look, lookBusy, calledRuleStack, seeThruPreds, addEOF)
+                finally:
+                    calledRuleStack.remove(t.target.ruleIndex)
+            elif isinstance(t, AbstractPredicateTransition ):
+                if seeThruPreds:
+                    self._LOOK(t.target, stopState, ctx, look, lookBusy, calledRuleStack, seeThruPreds, addEOF)
+                else:
+                    look.addOne(self.HIT_PRED)
+            elif t.isEpsilon:
+                self._LOOK(t.target, stopState, ctx, look, lookBusy, calledRuleStack, seeThruPreds, addEOF)
+            elif type(t) == WildcardTransition:
+                look.addRange( Interval(Token.MIN_USER_TOKEN_TYPE, self.atn.maxTokenType + 1) )
+            else:
+                set = t.label
+                if set is not None:
+                    if isinstance(t, NotSetTransition):
+                        set = set.complement(Token.MIN_USER_TOKEN_TYPE, self.atn.maxTokenType)
+                    look.addSet(set)
diff --git a/runtime/Python2/src/antlr4/Lexer.py b/runtime/Python2/src/antlr4/Lexer.py
new file mode 100644
index 000000000..c0fe4eb15
--- /dev/null
+++ b/runtime/Python2/src/antlr4/Lexer.py
@@ -0,0 +1,341 @@
+# [The "BSD license"]
+#  Copyright (c) 2012 Terence Parr
+#  Copyright (c) 2012 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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, self list of conditions and the following disclaimer.
+#  2. Redistributions in binary form must reproduce the above copyright
+#     notice, self 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 self software without specific prior written permission.
+#
+#  self 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
+#  self SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#/
+
+# A lexer is recognizer that draws input symbols from a character stream.
+#  lexer grammars result in a subclass of self object. A Lexer object
+#  uses simplified match() and error recovery mechanisms in the interest
+#  of speed.
+#/
+from io import StringIO
+from antlr4.CommonTokenFactory import CommonTokenFactory
+from antlr4.Recognizer import Recognizer
+from antlr4.Token import Token
+from antlr4.error.Errors import IllegalStateException, LexerNoViableAltException
+
+class TokenSource(object):
+
+    pass
+
+
+class Lexer(Recognizer, TokenSource):
+
+    DEFAULT_MODE = 0
+    MORE = -2
+    SKIP = -3
+
+    DEFAULT_TOKEN_CHANNEL = Token.DEFAULT_CHANNEL
+    HIDDEN = Token.HIDDEN_CHANNEL
+    MIN_CHAR_VALUE = '\u0000'
+    MAX_CHAR_VALUE = '\uFFFE'
+
+    def __init__(self, input):
+        super(Lexer, self).__init__()
+        self._input = input
+        self._factory = CommonTokenFactory.DEFAULT
+        self._tokenFactorySourcePair = (self, input)
+
+        self._interp = None # child classes must populate this
+        
+        # The goal of all lexer rules/methods is to create a token object.
+        #  self is an instance variable as multiple rules may collaborate to
+        #  create a single token.  nextToken will return self object after
+        #  matching lexer rule(s).  If you subclass to allow multiple token
+        #  emissions, then set self to the last token to be matched or
+        #  something nonnull so that the auto token emit mechanism will not
+        #  emit another token.
+        self._token = None
+
+        # What character index in the stream did the current token start at?
+        #  Needed, for example, to get the text for current token.  Set at
+        #  the start of nextToken.
+        self._tokenStartCharIndex = -1
+
+        # The line on which the first character of the token resides#/
+        self._tokenStartLine = -1
+
+        # The character position of first character within the line#/
+        self._tokenStartColumn = -1
+
+        # Once we see EOF on char stream, next token will be EOF.
+        #  If you have DONE : EOF ; then you see DONE EOF.
+        self._hitEOF = False
+
+        # The channel number for the current token#/
+        self._channel = Token.DEFAULT_CHANNEL
+
+        # The token type for the current token#/
+        self._type = Token.INVALID_TYPE
+
+        self._modeStack = []
+        self._mode = self.DEFAULT_MODE
+
+        # You can set the text for the current token to override what is in
+        #  the input char buffer.  Use setText() or can set self instance var.
+        #/
+        self._text = None
+
+
+    def reset(self):
+        # wack Lexer state variables
+        if self._input is not None:
+            self._input.seek(0) # rewind the input
+        self._token = None
+        self._type = Token.INVALID_TYPE
+        self._channel = Token.DEFAULT_CHANNEL
+        self._tokenStartCharIndex = -1
+        self._tokenStartColumn = -1
+        self._tokenStartLine = -1
+        self._text = None
+
+        self._hitEOF = False
+        self._mode = Lexer.DEFAULT_MODE
+        self._modeStack = []
+
+        self._interp.reset()
+
+    # Return a token from self source; i.e., match a token on the char
+    #  stream.
+    def nextToken(self):
+        if self._input is None:
+            raise IllegalStateException("nextToken requires a non-null input stream.")
+
+        # Mark start location in char stream so unbuffered streams are
+        # guaranteed at least have text of current token
+        tokenStartMarker = self._input.mark()
+        try:
+            while True:
+                if self._hitEOF:
+                    self.emitEOF()
+                    return self._token
+                self._token = None
+                self._channel = Token.DEFAULT_CHANNEL
+                self._tokenStartCharIndex = self._input.index
+                self._tokenStartColumn = self._interp.column
+                self._tokenStartLine = self._interp.line
+                self._text = None
+                continueOuter = False
+                while True:
+                    self._type = Token.INVALID_TYPE
+                    ttype = self.SKIP
+                    try:
+                        ttype = self._interp.match(self._input, self._mode)
+                    except LexerNoViableAltException as e:
+                        self.notifyListeners(e)		# report error
+                        self.recover(e)
+                    if self._input.LA(1)==Token.EOF:
+                        self._hitEOF = True
+                    if self._type == Token.INVALID_TYPE:
+                        self._type = ttype
+                    if self._type == self.SKIP:
+                        continueOuter = True
+                        break
+                    if self._type!=self.MORE:
+                        break
+                if continueOuter:
+                    continue
+                if self._token is None:
+                    self.emit()
+                return self._token
+        finally:
+            # make sure we release marker after match or
+            # unbuffered char stream will keep buffering
+            self._input.release(tokenStartMarker)
+
+    # Instruct the lexer to skip creating a token for current lexer rule
+    #  and look for another token.  nextToken() knows to keep looking when
+    #  a lexer rule finishes with token set to SKIP_TOKEN.  Recall that
+    #  if token==null at end of any token rule, it creates one for you
+    #  and emits it.
+    #/
+    def skip(self):
+        self._type = self.SKIP
+
+    def more(self):
+        self._type = self.MORE
+
+    def mode(self, m):
+        self._mode = m
+
+    def pushMode(self, m):
+        if self._interp.debug:
+            print("pushMode " + str(m))
+        self._modeStack.append(self._mode)
+        self.mode(m)
+
+    def popMode(self):
+        if len(self._modeStack)==0:
+            raise Exception("Empty Stack")
+        if self._interp.debug:
+            print("popMode back to "+ self._modeStack[:-1])
+        self.mode( self._modeStack.pop() )
+        return self._mode
+
+    # Set the char stream and reset the lexer#/
+    @property
+    def inputStream(self):
+        return self._input
+
+    @inputStream.setter
+    def inputStream(self, input):
+        self._input = None
+        self._tokenFactorySourcePair = (self, self._input)
+        self.reset()
+        self._input = input
+        self._tokenFactorySourcePair = (self, self._input)
+
+    @property
+    def sourceName(self):
+        return self._input.sourceName
+
+    # By default does not support multiple emits per nextToken invocation
+    #  for efficiency reasons.  Subclass and override self method, nextToken,
+    #  and getToken (to push tokens into a list and pull from that list
+    #  rather than a single variable as self implementation does).
+    #/
+    def emitToken(self, token):
+        self._token = token
+
+    # The standard method called to automatically emit a token at the
+    #  outermost lexical rule.  The token object should point into the
+    #  char buffer start..stop.  If there is a text override in 'text',
+    #  use that to set the token's text.  Override self method to emit
+    #  custom Token objects or provide a new factory.
+    #/
+    def emit(self):
+        t = self._factory.create(self._tokenFactorySourcePair, self._type, self._text, self._channel, self._tokenStartCharIndex,
+                                 self.getCharIndex()-1, self._tokenStartLine, self._tokenStartColumn)
+        self.emitToken(t)
+        return t
+
+    def emitEOF(self):
+        cpos = self.column
+        lpos = self.line
+        eof = self._factory.create(self._tokenFactorySourcePair, Token.EOF, None, Token.DEFAULT_CHANNEL, self._input.index,
+                                   self._input.index-1, lpos, cpos)
+        self.emitToken(eof)
+        return eof
+
+    @property
+    def type(self):
+        return self._type
+
+    @type.setter
+    def type(self, type):
+        self._type = type
+
+    @property
+    def line(self):
+        return self._interp.line
+
+    @line.setter
+    def line(self, line):
+        self._interp.line = line
+
+    @property
+    def column(self):
+        return self._interp.column
+
+    @column.setter
+    def column(self, column):
+        self._interp.column = column
+
+    # What is the index of the current character of lookahead?#/
+    def getCharIndex(self):
+        return self._input.index
+
+    # Return the text matched so far for the current token or any
+    #  text override.
+    @property
+    def text(self):
+        if self._text is not None:
+            return self._text
+        else:
+            return self._interp.getText(self._input)
+
+    # Set the complete text of self token; it wipes any previous
+    #  changes to the text.
+    @text.setter
+    def text(self, txt):
+        self._text = txt
+
+    # Return a list of all Token objects in input char stream.
+    #  Forces load of all tokens. Does not include EOF token.
+    #/
+    def getAllTokens(self):
+        tokens = []
+        t = self.nextToken()
+        while t.type!=Token.EOF:
+            tokens.append(t)
+            t = self.nextToken()
+        return tokens
+
+    def notifyListeners(self, e):
+        start = self._tokenStartCharIndex
+        stop = self._input.index
+        text = self._input.getText(start, stop)
+        msg = "token recognition error at: '" + self.getErrorDisplay(text) + "'"
+        listener = self.getErrorListenerDispatch()
+        listener.syntaxError(self, None, self._tokenStartLine, self._tokenStartColumn, msg, e)
+
+    def getErrorDisplay(self, s):
+        with StringIO() as buf:
+            for c in s:
+                buf.write(unicode(self.getErrorDisplayForChar(c)))
+            return buf.getvalue()
+
+    def getErrorDisplayForChar(self, c):
+        if ord(c[0])==Token.EOF:
+            return "<EOF>"
+        elif c=='\n':
+            return "\\n"
+        elif c=='\t':
+            return "\\t"
+        elif c=='\r':
+            return "\\r"
+        else:
+            return unicode(c)
+
+    def getCharErrorDisplay(self, c):
+        return "'" + self.getErrorDisplayForChar(c) + "'"
+
+    # Lexers can normally match any char in it's vocabulary after matching
+    #  a token, so do the easy thing and just kill a character and hope
+    #  it all works out.  You can instead use the rule invocation stack
+    #  to do sophisticated error recovery if you are in a fragment rule.
+    #/
+    def recover(self, re):
+        if self._input.LA(1) != Token.EOF:
+            if isinstance(re, LexerNoViableAltException):
+                    # skip a char and try again
+                    self._interp.consume(self._input)
+            else:
+                # TODO: Do we lose character or line position information?
+                self._input.consume()
+
diff --git a/runtime/Python2/src/antlr4/ListTokenSource.py b/runtime/Python2/src/antlr4/ListTokenSource.py
new file mode 100644
index 000000000..5e5e03a02
--- /dev/null
+++ b/runtime/Python2/src/antlr4/ListTokenSource.py
@@ -0,0 +1,139 @@
+#
+# Provides an implementation of {@link TokenSource} as a wrapper around a list
+# of {@link Token} objects.
+#
+# <p>If the final token in the list is an {@link Token#EOF} token, it will be used
+# as the EOF token for every call to {@link #nextToken} after the end of the
+# list is reached. Otherwise, an EOF token will be created.</p>
+#
+from antlr4.CommonTokenFactory import CommonTokenFactory
+from antlr4.Lexer import TokenSource
+from antlr4.Token import Token
+
+
+class ListTokenSource(TokenSource):
+
+    # Constructs a new {@link ListTokenSource} instance from the specified
+    # collection of {@link Token} objects and source name.
+    #
+    # @param tokens The collection of {@link Token} objects to provide as a
+    # {@link TokenSource}.
+    # @param sourceName The name of the {@link TokenSource}. If this value is
+    # {@code null}, {@link #getSourceName} will attempt to infer the name from
+    # the next {@link Token} (or the previous token if the end of the input has
+    # been reached).
+    #
+    # @exception NullPointerException if {@code tokens} is {@code null}
+    #
+    def __init__(self, tokens, sourceName=None):
+        if tokens is None:
+            raise ReferenceError("tokens cannot be null")
+        self.tokens = tokens
+        self.sourceName = sourceName
+        # The index into {@link #tokens} of token to return by the next call to
+        # {@link #nextToken}. The end of the input is indicated by this value
+        # being greater than or equal to the number of items in {@link #tokens}.
+        self.pos = 0
+        # This field caches the EOF token for the token source.
+        self.eofToken = None
+        # This is the backing field for {@link #getTokenFactory} and
+        self._factory = CommonTokenFactory.DEFAULT
+
+
+    #
+    # {@inheritDoc}
+    #
+    @property
+    def column(self):
+        if self.pos < len(self.tokens):
+            return self.tokens[self.pos].column
+        elif self.eofToken is not None:
+            return self.eofToken.column
+        elif len(self.tokens) > 0:
+            # have to calculate the result from the line/column of the previous
+            # token, along with the text of the token.
+            lastToken = self.tokens[len(self.tokens) - 1]
+            tokenText = lastToken.getText()
+            if tokenText is not None:
+                lastNewLine = tokenText.rfind('\n')
+                if lastNewLine >= 0:
+                    return len(tokenText) - lastNewLine - 1
+            return lastToken.column + lastToken.stopIndex - lastToken.startIndex + 1
+
+        # only reach this if tokens is empty, meaning EOF occurs at the first
+        # position in the input
+        return 0
+
+    #
+    # {@inheritDoc}
+    #
+    def nextToken(self):
+        if self.pos >= len(self.tokens):
+            if self.eofToken is None:
+                start = -1
+                if len(self.tokens) > 0:
+                    previousStop = self.tokens[len(self.tokens) - 1].stopIndex
+                    if previousStop != -1:
+                        start = previousStop + 1
+                stop = max(-1, start - 1)
+                self.eofToken = self._factory.create((self, self.getInputStream()),
+                            Token.EOF, "EOF", Token.DEFAULT_CHANNEL, start, stop, self.line, self.column)
+            return self.eofToken
+        t = self.tokens[self.pos]
+        if self.pos == len(self.tokens) - 1 and t.type == Token.EOF:
+            eofToken = t
+        self.pos += 1
+        return t
+
+    #
+    # {@inheritDoc}
+    #
+    @property
+    def line(self):
+        if self.pos < len(self.tokens):
+            return self.tokens[self.pos].line
+        elif self.eofToken is not None:
+            return self.eofToken.line
+        elif len(self.tokens) > 0:
+            # have to calculate the result from the line/column of the previous
+            # token, along with the text of the token.
+            lastToken = self.tokens[len(self.tokens) - 1]
+            line = lastToken.line
+            tokenText = lastToken.text
+            if tokenText is not None:
+                for c in tokenText:
+                    if c  == '\n':
+                        line += 1
+
+            # if no text is available, assume the token did not contain any newline characters.
+            return line
+
+        # only reach this if tokens is empty, meaning EOF occurs at the first
+        # position in the input
+        return 1
+
+    #
+    # {@inheritDoc}
+    #
+    def getInputStream(self):
+        if self.pos < len(self.tokens):
+            return self.tokens[self.pos].getInputStream()
+        elif self.eofToken is not None:
+            return self.eofToken.getInputStream()
+        elif len(self.tokens) > 0:
+            return self.tokens[len(self.tokens) - 1].getInputStream()
+        else:
+            # no input stream information is available
+            return None
+
+    #
+    # {@inheritDoc}
+    #
+    def getSourceName(self):
+        if self.sourceName is not None:
+            return self.sourceName
+        inputStream = self.getInputStream()
+        if inputStream is not None:
+            return inputStream.getSourceName()
+        else:
+            return "List"
\ No newline at end of file
diff --git a/runtime/Python2/src/antlr4/Parser.py b/runtime/Python2/src/antlr4/Parser.py
new file mode 100644
index 000000000..0439df2c4
--- /dev/null
+++ b/runtime/Python2/src/antlr4/Parser.py
@@ -0,0 +1,576 @@
+# [The "BSD license"]
+#  Copyright (c) 2012 Terence Parr
+#  Copyright (c) 2012 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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, self list of conditions and the following disclaimer.
+#  2. Redistributions in binary form must reproduce the above copyright
+#     notice, self 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 self software without specific prior written permission.
+#
+#  self 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
+#  self SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+from __future__ import print_function
+from antlr4.error.ErrorStrategy import DefaultErrorStrategy
+from antlr4.Recognizer import Recognizer
+from antlr4.Token import Token
+from antlr4.Lexer import Lexer
+from antlr4.atn.ATNDeserializer import ATNDeserializer
+from antlr4.atn.ATNDeserializationOptions import ATNDeserializationOptions
+from antlr4.error.Errors import UnsupportedOperationException
+from antlr4.tree.ParseTreePatternMatcher import ParseTreePatternMatcher
+from antlr4.tree.Tree import ParseTreeListener
+
+class TraceListener(ParseTreeListener):
+
+    def __init__(self, parser):
+        self._parser = parser
+
+    def enterEveryRule(self, ctx):
+        print("enter   " + self._parser.ruleNames[ctx.getRuleIndex()] + ", LT(1)=" + self._parser._input.LT(1).text)
+
+    def visitTerminal(self, node):
+        print("consume " + str(node.symbol) + " rule " + self._parser.ruleNames[self._parser._ctx.getRuleIndex()])
+
+    def visitErrorNode(self, node):
+        pass
+
+    def exitEveryRule(self, ctx):
+        print("exit    " + self._parser.ruleNames[ctx.getRuleIndex()] + ", LT(1)=" + self._parser._input.LT(1).text)
+
+
+# self is all the parsing support code essentially; most of it is error recovery stuff.#
+class Parser (Recognizer):
+
+    # self field maps from the serialized ATN string to the deserialized {@link ATN} with
+    # bypass alternatives.
+    #
+    # @see ATNDeserializationOptions#isGenerateRuleBypassTransitions()
+    #
+    bypassAltsAtnCache = dict()
+
+    def __init__(self, input):
+        super(Parser, self).__init__()
+        # The input stream.
+        self._input = None
+        # The error handling strategy for the parser. The default value is a new
+        # instance of {@link DefaultErrorStrategy}.
+        self._errHandler = DefaultErrorStrategy()
+        self._precedenceStack = list()
+        self._precedenceStack.append(0)
+        # The {@link ParserRuleContext} object for the currently executing rule.
+        # self is always non-null during the parsing process.
+        self._ctx = None
+        # Specifies whether or not the parser should construct a parse tree during
+        # the parsing process. The default value is {@code true}.
+        self.buildParseTrees = True
+        # When {@link #setTrace}{@code (true)} is called, a reference to the
+        # {@link TraceListener} is stored here so it can be easily removed in a
+        # later call to {@link #setTrace}{@code (false)}. The listener itself is
+        # implemented as a parser listener so self field is not directly used by
+        # other parser methods.
+        self._tracer = None
+        # The list of {@link ParseTreeListener} listeners registered to receive
+        # events during the parse.
+        self._parseListeners = None
+        # The number of syntax errors reported during parsing. self value is
+        # incremented each time {@link #notifyErrorListeners} is called.
+        self._syntaxErrors = 0
+        self.setInputStream(input)
+
+    # reset the parser's state#
+    def reset(self):
+        if self._input is not None:
+            self._input.seek(0)
+        self._errHandler.reset(self)
+        self._ctx = None
+        self._syntaxErrors = 0
+        self.setTrace(False)
+        self._precedenceStack = list()
+        self._precedenceStack.append(0)
+        if self._interp is not None:
+            self._interp.reset()
+
+    # Match current input symbol against {@code ttype}. If the symbol type
+    # matches, {@link ANTLRErrorStrategy#reportMatch} and {@link #consume} are
+    # called to complete the match process.
+    #
+    # <p>If the symbol type does not match,
+    # {@link ANTLRErrorStrategy#recoverInline} is called on the current error
+    # strategy to attempt recovery. If {@link #getBuildParseTree} is
+    # {@code true} and the token index of the symbol returned by
+    # {@link ANTLRErrorStrategy#recoverInline} is -1, the symbol is added to
+    # the parse tree by calling {@link ParserRuleContext#addErrorNode}.</p>
+    #
+    # @param ttype the token type to match
+    # @return the matched symbol
+    # @throws RecognitionException if the current input symbol did not match
+    # {@code ttype} and the error strategy could not recover from the
+    # mismatched symbol
+
+    def match(self, ttype):
+        t = self.getCurrentToken()
+        if t.type==ttype:
+            self._errHandler.reportMatch(self)
+            self.consume()
+        else:
+            t = self._errHandler.recoverInline(self)
+            if self.buildParseTrees and t.tokenIndex==-1:
+                # we must have conjured up a new token during single token insertion
+                # if it's not the current symbol
+                self._ctx.addErrorNode(t)
+        return t
+
+    # Match current input symbol as a wildcard. If the symbol type matches
+    # (i.e. has a value greater than 0), {@link ANTLRErrorStrategy#reportMatch}
+    # and {@link #consume} are called to complete the match process.
+    #
+    # <p>If the symbol type does not match,
+    # {@link ANTLRErrorStrategy#recoverInline} is called on the current error
+    # strategy to attempt recovery. If {@link #getBuildParseTree} is
+    # {@code true} and the token index of the symbol returned by
+    # {@link ANTLRErrorStrategy#recoverInline} is -1, the symbol is added to
+    # the parse tree by calling {@link ParserRuleContext#addErrorNode}.</p>
+    #
+    # @return the matched symbol
+    # @throws RecognitionException if the current input symbol did not match
+    # a wildcard and the error strategy could not recover from the mismatched
+    # symbol
+
+    def matchWildcard(self):
+        t = self.getCurrentToken()
+        if t.type > 0:
+            self._errHandler.reportMatch(self)
+            self.consume()
+        else:
+            t = self._errHandler.recoverInline(self)
+            if self.buildParseTrees and t.tokenIndex == -1:
+                # we must have conjured up a new token during single token insertion
+                # if it's not the current symbol
+                self._ctx.addErrorNode(t)
+
+        return t
+
+    def getParseListeners(self):
+        return list() if self._parseListeners is None else self._parseListeners
+
+    # Registers {@code listener} to receive events during the parsing process.
+    #
+    # <p>To support output-preserving grammar transformations (including but not
+    # limited to left-recursion removal, automated left-factoring, and
+    # optimized code generation), calls to listener methods during the parse
+    # may differ substantially from calls made by
+    # {@link ParseTreeWalker#DEFAULT} used after the parse is complete. In
+    # particular, rule entry and exit events may occur in a different order
+    # during the parse than after the parser. In addition, calls to certain
+    # rule entry methods may be omitted.</p>
+    #
+    # <p>With the following specific exceptions, calls to listener events are
+    # <em>deterministic</em>, i.e. for identical input the calls to listener
+    # methods will be the same.</p>
+    #
+    # <ul>
+    # <li>Alterations to the grammar used to generate code may change the
+    # behavior of the listener calls.</li>
+    # <li>Alterations to the command line options passed to ANTLR 4 when
+    # generating the parser may change the behavior of the listener calls.</li>
+    # <li>Changing the version of the ANTLR Tool used to generate the parser
+    # may change the behavior of the listener calls.</li>
+    # </ul>
+    #
+    # @param listener the listener to add
+    #
+    # @throws NullPointerException if {@code} listener is {@code null}
+    #
+    def addParseListener(self, listener):
+        if listener is None:
+            raise ReferenceError("listener")
+        if self._parseListeners is None:
+            self._parseListeners = []
+        self._parseListeners.append(listener)
+
+    #
+    # Remove {@code listener} from the list of parse listeners.
+    #
+    # <p>If {@code listener} is {@code null} or has not been added as a parse
+    # listener, self method does nothing.</p>
+    # @param listener the listener to remove
+    #
+    def removeParseListener(self, listener):
+        if self._parseListeners is not None:
+            self._parseListeners.remove(listener)
+            if len(self._parseListeners)==0:
+                    self._parseListeners = None
+
+    # Remove all parse listeners.
+    def removeParseListeners(self):
+        self._parseListeners = None
+
+    # Notify any parse listeners of an enter rule event.
+    def triggerEnterRuleEvent(self):
+        if self._parseListeners is not None:
+            for listener in self._parseListeners:
+                listener.enterEveryRule(self._ctx)
+                self._ctx.enterRule(listener)
+
+    #
+    # Notify any parse listeners of an exit rule event.
+    #
+    # @see #addParseListener
+    #
+    def triggerExitRuleEvent(self):
+        if self._parseListeners is not None:
+            # reverse order walk of listeners
+            for listener in reversed(self._parseListeners):
+                self._ctx.exitRule(listener)
+                listener.exitEveryRule(self._ctx)
+
+
+    def getTokenFactory(self):
+        return self._input.tokenSource._factory
+
+    # Tell our token source and error strategy about a new way to create tokens.#
+    def setTokenFactory(self, factory):
+        self._input.tokenSource._factory = factory
+
+    # The ATN with bypass alternatives is expensive to create so we create it
+    # lazily.
+    #
+    # @throws UnsupportedOperationException if the current parser does not
+    # implement the {@link #getSerializedATN()} method.
+    #
+    def getATNWithBypassAlts(self):
+        serializedAtn = self.getSerializedATN()
+        if serializedAtn is None:
+            raise UnsupportedOperationException("The current parser does not support an ATN with bypass alternatives.")
+        result = self.bypassAltsAtnCache.get(serializedAtn, None)
+        if result is None:
+            deserializationOptions = ATNDeserializationOptions()
+            deserializationOptions.generateRuleBypassTransitions = True
+            result = ATNDeserializer(deserializationOptions).deserialize(serializedAtn)
+            self.bypassAltsAtnCache[serializedAtn] = result
+        return result
+
+    # The preferred method of getting a tree pattern. For example, here's a
+    # sample use:
+    #
+    # <pre>
+    # ParseTree t = parser.expr();
+    # ParseTreePattern p = parser.compileParseTreePattern("&lt;ID&gt;+0", MyParser.RULE_expr);
+    # ParseTreeMatch m = p.match(t);
+    # String id = m.get("ID");
+    # </pre>
+    #
+    def compileParseTreePattern(self, pattern, patternRuleIndex, lexer = None):
+        if lexer is None:
+            if self.getTokenStream() is not None:
+                tokenSource = self.getTokenStream().tokenSource
+                if isinstance( tokenSource, Lexer ):
+                    lexer = tokenSource
+        if lexer is None:
+            raise UnsupportedOperationException("Parser can't discover a lexer to use")
+
+        m = ParseTreePatternMatcher(lexer, self)
+        return m.compile(pattern, patternRuleIndex)
+
+
+    def getInputStream(self):
+        return self.getTokenStream()
+
+    def setInputStream(self, input):
+        self.setTokenStream(input)
+
+    def getTokenStream(self):
+        return self._input
+
+    # Set the token stream and reset the parser.#
+    def setTokenStream(self, input):
+        self._input = None
+        self.reset()
+        self._input = input
+
+    # Match needs to return the current input symbol, which gets put
+    #  into the label for the associated token ref; e.g., x=ID.
+    #
+    def getCurrentToken(self):
+        return self._input.LT(1)
+
+    def notifyErrorListeners(self, msg, offendingToken = None, e = None):
+        if offendingToken is None:
+            offendingToken = self.getCurrentToken()
+        self._syntaxErrors += 1
+        line = offendingToken.line
+        column = offendingToken.column
+        listener = self.getErrorListenerDispatch()
+        listener.syntaxError(self, offendingToken, line, column, msg, e)
+
+    #
+    # Consume and return the {@linkplain #getCurrentToken current symbol}.
+    #
+    # <p>E.g., given the following input with {@code A} being the current
+    # lookahead symbol, self function moves the cursor to {@code B} and returns
+    # {@code A}.</p>
+    #
+    # <pre>
+    #  A B
+    #  ^
+    # </pre>
+    #
+    # If the parser is not in error recovery mode, the consumed symbol is added
+    # to the parse tree using {@link ParserRuleContext#addChild(Token)}, and
+    # {@link ParseTreeListener#visitTerminal} is called on any parse listeners.
+    # If the parser <em>is</em> in error recovery mode, the consumed symbol is
+    # added to the parse tree using
+    # {@link ParserRuleContext#addErrorNode(Token)}, and
+    # {@link ParseTreeListener#visitErrorNode} is called on any parse
+    # listeners.
+    #
+    def consume(self):
+        o = self.getCurrentToken()
+        if o.type != Token.EOF:
+            self.getInputStream().consume()
+        hasListener = self._parseListeners is not None and len(self._parseListeners)>0
+        if self.buildParseTrees or hasListener:
+            if self._errHandler.inErrorRecoveryMode(self):
+                node = self._ctx.addErrorNode(o)
+            else:
+                node = self._ctx.addTokenNode(o)
+            if hasListener:
+                for listener in self._parseListeners:
+                    listener.visitTerminal(node)
+        return o
+
+    def addContextToParseTree(self):
+        # add current context to parent if we have a parent
+        if self._ctx.parentCtx is not None:
+            self._ctx.parentCtx.addChild(self._ctx)
+
+    # Always called by generated parsers upon entry to a rule. Access field
+    # {@link #_ctx} get the current context.
+    #
+    def enterRule(self, localctx , state , ruleIndex ):
+        self.state = state
+        self._ctx = localctx
+        self._ctx.start = self._input.LT(1)
+        if self.buildParseTrees:
+            self.addContextToParseTree()
+        if self._parseListeners  is not None:
+            self.triggerEnterRuleEvent()
+
+    def exitRule(self):
+        self._ctx.stop = self._input.LT(-1)
+        # trigger event on _ctx, before it reverts to parent
+        if self._parseListeners is not None:
+            self.triggerExitRuleEvent()
+        self.state = self._ctx.invokingState
+        self._ctx = self._ctx.parentCtx
+
+    def enterOuterAlt(self, localctx, altNum):
+        localctx.setAltNumber(altNum)
+        # if we have new localctx, make sure we replace existing ctx
+        # that is previous child of parse tree
+        if self.buildParseTrees and self._ctx != localctx:
+            if self._ctx.parentCtx is not None:
+                self._ctx.parentCtx.removeLastChild()
+                self._ctx.parentCtx.addChild(localctx)
+        self._ctx = localctx
+
+    # Get the precedence level for the top-most precedence rule.
+    #
+    # @return The precedence level for the top-most precedence rule, or -1 if
+    # the parser context is not nested within a precedence rule.
+    #
+    def getPrecedence(self):
+        if len(self._precedenceStack)==0:
+            return -1
+        else:
+            return self._precedenceStack[-1]
+
+    def enterRecursionRule(self, localctx, state, ruleIndex, precedence):
+        self.state = state
+        self._precedenceStack.append(precedence)
+        self._ctx = localctx
+        self._ctx.start = self._input.LT(1)
+        if self._parseListeners is not None:
+            self.triggerEnterRuleEvent() # simulates rule entry for left-recursive rules
+
+    #
+    # Like {@link #enterRule} but for recursive rules.
+    #
+    def pushNewRecursionContext(self, localctx, state, ruleIndex):
+        previous = self._ctx
+        previous.parentCtx = localctx
+        previous.invokingState = state
+        previous.stop = self._input.LT(-1)
+
+        self._ctx = localctx
+        self._ctx.start = previous.start
+        if self.buildParseTrees:
+            self._ctx.addChild(previous)
+
+        if self._parseListeners is not None:
+            self.triggerEnterRuleEvent() # simulates rule entry for left-recursive rules
+
+    def unrollRecursionContexts(self, parentCtx):
+        self._precedenceStack.pop()
+        self._ctx.stop = self._input.LT(-1)
+        retCtx = self._ctx # save current ctx (return value)
+        # unroll so _ctx is as it was before call to recursive method
+        if self._parseListeners is not None:
+            while self._ctx is not parentCtx:
+                self.triggerExitRuleEvent()
+                self._ctx = self._ctx.parentCtx
+        else:
+            self._ctx = parentCtx
+
+        # hook into tree
+        retCtx.parentCtx = parentCtx
+
+        if self.buildParseTrees and parentCtx is not None:
+            # add return ctx into invoking rule's tree
+            parentCtx.addChild(retCtx)
+
+    def getInvokingContext(self, ruleIndex):
+        ctx = self._ctx
+        while ctx is not None:
+            if ctx.ruleIndex == ruleIndex:
+                return ctx
+            ctx = ctx.parentCtx
+        return None
+
+
+    def precpred(self, localctx , precedence):
+        return precedence >= self._precedenceStack[-1]
+
+    def inContext(self, context):
+        # TODO: useful in parser?
+        return False
+
+    #
+    # Checks whether or not {@code symbol} can follow the current state in the
+    # ATN. The behavior of self method is equivalent to the following, but is
+    # implemented such that the complete context-sensitive follow set does not
+    # need to be explicitly constructed.
+    #
+    # <pre>
+    # return getExpectedTokens().contains(symbol);
+    # </pre>
+    #
+    # @param symbol the symbol type to check
+    # @return {@code true} if {@code symbol} can follow the current state in
+    # the ATN, otherwise {@code false}.
+    #
+    def isExpectedToken(self, symbol):
+        atn = self._interp.atn
+        ctx = self._ctx
+        s = atn.states[self.state]
+        following = atn.nextTokens(s)
+        if symbol in following:
+            return True
+        if not Token.EPSILON in following:
+            return False
+
+        while ctx is not None and ctx.invokingState>=0 and Token.EPSILON in following:
+            invokingState = atn.states[ctx.invokingState]
+            rt = invokingState.transitions[0]
+            following = atn.nextTokens(rt.followState)
+            if symbol in following:
+                return True
+            ctx = ctx.parentCtx
+
+        if Token.EPSILON in following and symbol == Token.EOF:
+            return True
+        else:
+            return False
+
+    # Computes the set of input symbols which could follow the current parser
+    # state and context, as given by {@link #getState} and {@link #getContext},
+    # respectively.
+    #
+    # @see ATN#getExpectedTokens(int, RuleContext)
+    #
+    def getExpectedTokens(self):
+        return self._interp.atn.getExpectedTokens(self.state, self._ctx)
+
+    def getExpectedTokensWithinCurrentRule(self):
+        atn = self._interp.atn
+        s = atn.states[self.state]
+        return atn.nextTokens(s)
+
+    # Get a rule's index (i.e., {@code RULE_ruleName} field) or -1 if not found.#
+    def getRuleIndex(self, ruleName):
+        ruleIndex = self.getRuleIndexMap().get(ruleName, None)
+        if ruleIndex is not None:
+            return ruleIndex
+        else:
+            return -1
+
+    # Return List&lt;String&gt; of the rule names in your parser instance
+    #  leading up to a call to the current rule.  You could override if
+    #  you want more details such as the file/line info of where
+    #  in the ATN a rule is invoked.
+    #
+    #  this is very useful for error messages.
+    #
+    def getRuleInvocationStack(self, p=None):
+        if p is None:
+            p = self._ctx
+        stack = list()
+        while p is not None:
+            # compute what follows who invoked us
+            ruleIndex = p.getRuleIndex()
+            if ruleIndex<0:
+                stack.append("n/a")
+            else:
+                stack.append(self.ruleNames[ruleIndex])
+            p = p.parentCtx
+        return stack
+
+    # For debugging and other purposes.#
+    def getDFAStrings(self):
+        return [ unicode(dfa) for dfa in self._interp.decisionToDFA]
+
+    # For debugging and other purposes.#
+    def dumpDFA(self):
+        seenOne = False
+        for i in range(0, len(self._interp.decisionToDFA)):
+            dfa = self._interp.decisionToDFA[i]
+            if len(dfa.states)>0:
+                if seenOne:
+                    print()
+                print("Decision " + str(dfa.decision) + ":")
+                print(dfa.toString(self.literalNames, self.symbolicNames), end='')
+                seenOne = True
+
+
+    def getSourceName(self):
+        return self._input.sourceName
+
+    # During a parse is sometimes useful to listen in on the rule entry and exit
+    #  events as well as token matches. self is for quick and dirty debugging.
+    #
+    def setTrace(self, trace):
+        if not trace:
+            self.removeParseListener(self._tracer)
+            self._tracer = None
+        else:
+            if self._tracer is not None:
+                self.removeParseListener(self._tracer)
+            self._tracer = TraceListener(self)
+            self.addParseListener(self._tracer)
diff --git a/runtime/Python2/src/antlr4/ParserInterpreter.py b/runtime/Python2/src/antlr4/ParserInterpreter.py
new file mode 100644
index 000000000..ed059f9d5
--- /dev/null
+++ b/runtime/Python2/src/antlr4/ParserInterpreter.py
@@ -0,0 +1,187 @@
+#
+# [The "BSD license"]
+# Copyright (c) 2013 Terence Parr
+# Copyright (c) 2013 Sam Harwell
+# Copyright (c) 2014 Eric Vergnaud
+# 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 parser simulator that mimics what ANTLR's generated
+#  parser code does. A ParserATNSimulator is used to make
+#  predictions via adaptivePredict but this class moves a pointer through the
+#  ATN to simulate parsing. ParserATNSimulator just
+#  makes us efficient rather than having to backtrack, for example.
+#
+#  This properly creates parse trees even for left recursive rules.
+#
+#  We rely on the left recursive rule invocation and special predicate
+#  transitions to make left recursive rules work.
+#
+#  See TestParserInterpreter for examples.
+#
+from antlr4 import PredictionContextCache
+from antlr4.dfa.DFA import DFA
+from antlr4.Parser import Parser
+from antlr4.ParserRuleContext import InterpreterRuleContext
+from antlr4.Token import Token
+from antlr4.atn.ATNState import StarLoopEntryState, ATNState, LoopEndState
+from antlr4.atn.ParserATNSimulator import ParserATNSimulator
+from antlr4.atn.Transition import Transition
+from antlr4.error.Errors import RecognitionException, UnsupportedOperationException, FailedPredicateException
+
+
+class ParserInterpreter(Parser):
+
+    def __init__(self, grammarFileName, tokenNames, ruleNames, atn, input):
+        super(ParserInterpreter, self).__init__(input)
+        self.grammarFileName = grammarFileName
+        self.atn = atn
+        self.tokenNames = tokenNames
+        self.ruleNames = ruleNames
+        self.decisionToDFA = [ DFA(state) for state in atn.decisionToState ]
+        self.sharedContextCache = PredictionContextCache()
+        self._parentContextStack = list()
+        # identify the ATN states where pushNewRecursionContext must be called
+        self.pushRecursionContextStates = set()
+        for state in atn.states:
+            if not isinstance(state, StarLoopEntryState):
+                continue
+            if state.precedenceRuleDecision:
+                self.pushRecursionContextStates.add(state.stateNumber)
+        # get atn simulator that knows how to do predictions
+        self._interp = ParserATNSimulator(self, atn, self.decisionToDFA, self.sharedContextCache)
+
+    # Begin parsing at startRuleIndex#
+    def parse(self, startRuleIndex):
+        startRuleStartState = self.atn.ruleToStartState[startRuleIndex]
+        rootContext = InterpreterRuleContext(None, ATNState.INVALID_STATE_NUMBER, startRuleIndex)
+        if startRuleStartState.isPrecedenceRule:
+            self.enterRecursionRule(rootContext, startRuleStartState.stateNumber, startRuleIndex, 0)
+        else:
+            self.enterRule(rootContext, startRuleStartState.stateNumber, startRuleIndex)
+        while True:
+            p = self.getATNState()
+            if p.stateType==ATNState.RULE_STOP :
+                # pop; return from rule
+                if len(self._ctx)==0:
+                    if startRuleStartState.isPrecedenceRule:
+                        result = self._ctx
+                        parentContext = self._parentContextStack.pop()
+                        self.unrollRecursionContexts(parentContext.a)
+                        return result
+                    else:
+                        self.exitRule()
+                        return rootContext
+                self.visitRuleStopState(p)
+
+            else:
+                try:
+                    self.visitState(p)
+                except RecognitionException as e:
+                    self.state = self.atn.ruleToStopState[p.ruleIndex].stateNumber
+                    self._ctx.exception = e
+                    self._errHandler.reportError(self, e)
+                    self._errHandler.recover(self, e)
+
+    def enterRecursionRule(self, localctx, state, ruleIndex, precedence):
+        self._parentContextStack.append((self._ctx, localctx.invokingState))
+        super(ParserInterpreter, self).enterRecursionRule(localctx, state, ruleIndex, precedence)
+
+    def getATNState(self):
+        return self.atn.states[self.state]
+
+    def visitState(self, p):
+        edge = 0
+        if len(p.transitions) > 1:
+            self._errHandler.sync(self)
+            edge = self._interp.adaptivePredict(self._input, p.decision, self._ctx)
+        else:
+            edge = 1
+
+        transition = p.transitions[edge - 1]
+        tt = transition.serializationType
+        if tt==Transition.EPSILON:
+
+            if self.pushRecursionContextStates[p.stateNumber] and not isinstance(transition.target, LoopEndState):
+                t = self._parentContextStack[-1]
+                ctx = InterpreterRuleContext(t[0], t[1], self._ctx.ruleIndex)
+                self.pushNewRecursionContext(ctx, self.atn.ruleToStartState[p.ruleIndex].stateNumber, self._ctx.ruleIndex)
+
+        elif tt==Transition.ATOM:
+
+            self.match(transition.label)
+
+        elif tt in [ Transition.RANGE, Transition.SET, Transition.NOT_SET]:
+
+            if not transition.matches(self._input.LA(1), Token.MIN_USER_TOKEN_TYPE, 0xFFFF):
+                self._errHandler.recoverInline(self)
+            self.matchWildcard()
+
+        elif tt==Transition.WILDCARD:
+
+            self.matchWildcard()
+
+        elif tt==Transition.RULE:
+
+            ruleStartState = transition.target
+            ruleIndex = ruleStartState.ruleIndex
+            ctx = InterpreterRuleContext(self._ctx, p.stateNumber, ruleIndex)
+            if ruleStartState.isPrecedenceRule:
+                self.enterRecursionRule(ctx, ruleStartState.stateNumber, ruleIndex, transition.precedence)
+            else:
+                self.enterRule(ctx, transition.target.stateNumber, ruleIndex)
+
+        elif tt==Transition.PREDICATE:
+
+            if not self.sempred(self._ctx, transition.ruleIndex, transition.predIndex):
+                raise FailedPredicateException(self)
+
+        elif tt==Transition.ACTION:
+
+            self.action(self._ctx, transition.ruleIndex, transition.actionIndex)
+
+        elif tt==Transition.PRECEDENCE:
+
+            if not self.precpred(self._ctx, transition.precedence):
+                msg = "precpred(_ctx, " + str(transition.precedence) + ")"
+                raise FailedPredicateException(self, msg)
+
+        else:
+            raise UnsupportedOperationException("Unrecognized ATN transition type.")
+
+        self.state = transition.target.stateNumber
+
+    def visitRuleStopState(self, p):
+        ruleStartState = self.atn.ruleToStartState[p.ruleIndex]
+        if ruleStartState.isPrecedenceRule:
+            parentContext = self._parentContextStack.pop()
+            self.unrollRecursionContexts(parentContext.a)
+            self.state = parentContext[1]
+        else:
+            self.exitRule()
+
+        ruleTransition = self.atn.states[self.state].transitions[0]
+        self.state = ruleTransition.followState.stateNumber
diff --git a/runtime/Python2/src/antlr4/ParserRuleContext.py b/runtime/Python2/src/antlr4/ParserRuleContext.py
new file mode 100644
index 000000000..290a10af1
--- /dev/null
+++ b/runtime/Python2/src/antlr4/ParserRuleContext.py
@@ -0,0 +1,188 @@
+# [The "BSD license"]
+#  Copyright (c) 2012 Terence Parr
+#  Copyright (c) 2012 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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 rule invocation record for parsing.
+#
+#  Contains all of the information about the current rule not stored in the
+#  RuleContext. It handles parse tree children list, Any ATN state
+#  tracing, and the default values available for rule indications:
+#  start, stop, rule index, current alt number, current
+#  ATN state.
+#
+#  Subclasses made for each rule and grammar track the parameters,
+#  return values, locals, and labels specific to that rule. These
+#  are the objects that are returned from rules.
+#
+#  Note text is not an actual field of a rule return value; it is computed
+#  from start and stop using the input stream's toString() method.  I
+#  could add a ctor to this so that we can pass in and store the input
+#  stream, but I'm not sure we want to do that.  It would seem to be undefined
+#  to get the .text property anyway if the rule matches tokens from multiple
+#  input streams.
+#
+#  I do not use getters for fields of objects that are used simply to
+#  group values such as this aggregate.  The getters/setters are there to
+#  satisfy the superclass interface.
+
+from antlr4.RuleContext import RuleContext
+from antlr4.tree.Tree import TerminalNodeImpl, ErrorNodeImpl, TerminalNode, INVALID_INTERVAL
+
+class ParserRuleContext(RuleContext):
+
+    def __init__(self, parent = None, invokingStateNumber = None ):
+        super(ParserRuleContext, self).__init__(parent, invokingStateNumber)
+        #* If we are debugging or building a parse tree for a visitor,
+        #  we need to track all of the tokens and rule invocations associated
+        #  with this rule's context. This is empty for parsing w/o tree constr.
+        #  operation because we don't the need to track the details about
+        #  how we parse this rule.
+        #/
+        self.children = None
+        self.start = None
+        self.stop = None
+        # The exception that forced this rule to return. If the rule successfully
+        # completed, this is {@code null}.
+        self.exception = None
+
+    #* COPY a ctx (I'm deliberately not using copy constructor)#/
+    def copyFrom(self, ctx):
+        # from RuleContext
+        self.parentCtx = ctx.parentCtx
+        self.invokingState = ctx.invokingState
+        self.children = None
+        self.start = ctx.start
+        self.stop = ctx.stop
+
+    # Double dispatch methods for listeners
+    def enterRule(self, listener):
+        pass
+
+    def exitRule(self, listener):
+        pass
+
+    #* Does not set parent link; other add methods do that#/
+    def addChild(self, child):
+        if self.children is None:
+            self.children = []
+        self.children.append(child)
+        return child
+
+    #* Used by enterOuterAlt to toss out a RuleContext previously added as
+    #  we entered a rule. If we have # label, we will need to remove
+    #  generic ruleContext object.
+    #/
+    def removeLastChild(self):
+        if self.children is not None:
+            del self.children[len(self.children)-1]
+
+    def addTokenNode(self, token):
+        node = TerminalNodeImpl(token)
+        self.addChild(node)
+        node.parentCtx = self
+        return node
+
+    def addErrorNode(self, badToken):
+        node = ErrorNodeImpl(badToken)
+        self.addChild(node)
+        node.parentCtx = self
+        return node
+
+    def getChild(self, i, ttype = None):
+        if ttype is None:
+            return self.children[i] if len(self.children)>i else None
+        else:
+            for child in self.getChildren():
+                if not isinstance(child, ttype):
+                    continue
+                if i==0:
+                    return child
+                i -= 1
+            return None
+
+    def getChildren(self, predicate = None):
+        if self.children is not None:
+            for child in self.children:
+                if predicate is not None and not predicate(child):
+                    continue
+                yield child
+
+    def getToken(self, ttype, i):
+        for child in self.getChildren():
+            if not isinstance(child, TerminalNode):
+                continue
+            if child.symbol.type != ttype:
+                continue
+            if i==0:
+                return child
+            i -= 1
+        return None
+
+    def getTokens(self, ttype ):
+        if self.getChildren() is None:
+            return []
+        tokens = []
+        for child in self.getChildren():
+            if not isinstance(child, TerminalNode):
+                continue
+            if child.symbol.type != ttype:
+                continue
+            tokens.append(child)
+        return tokens
+
+    def getTypedRuleContext(self, ctxType, i):
+        return self.getChild(i, ctxType)
+
+    def getTypedRuleContexts(self, ctxType):
+        children = self.getChildren()
+        if children is None:
+            return []
+        contexts = []
+        for child in children:
+            if not isinstance(child, ctxType):
+                continue
+            contexts.append(child)
+        return contexts
+
+    def getChildCount(self):
+        return len(self.children) if self.children else 0
+
+    def getSourceInterval(self):
+        if self.start is None or self.stop is None:
+            return INVALID_INTERVAL
+        else:
+            return (self.start.tokenIndex, self.stop.tokenIndex)
+
+
+RuleContext.EMPTY = ParserRuleContext()
+
+class InterpreterRuleContext(ParserRuleContext):
+
+    def __init__(self, parent, invokingStateNumber, ruleIndex):
+        super(InterpreterRuleContext, self).__init__(parent, invokingStateNumber)
+        self.ruleIndex = ruleIndex
diff --git a/runtime/Python2/src/antlr4/PredictionContext.py b/runtime/Python2/src/antlr4/PredictionContext.py
new file mode 100644
index 000000000..ba28eca7b
--- /dev/null
+++ b/runtime/Python2/src/antlr4/PredictionContext.py
@@ -0,0 +1,647 @@
+#
+# [The "BSD license"]
+#  Copyright (c) 2012 Terence Parr
+#  Copyright (c) 2012 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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.
+#/
+from io import StringIO
+from antlr4.RuleContext import RuleContext
+from antlr4.atn.ATNState import ATNState
+
+
+class PredictionContext(object):
+
+    # Represents {@code $} in local context prediction, which means wildcard.
+    # {@code#+x =#}.
+    #/
+    EMPTY = None
+
+    # Represents {@code $} in an array in full context mode, when {@code $}
+    # doesn't mean wildcard: {@code $ + x = [$,x]}. Here,
+    # {@code $} = {@link #EMPTY_RETURN_STATE}.
+    #/
+    EMPTY_RETURN_STATE = 0x7FFFFFFF
+
+    globalNodeCount = 1
+    id = globalNodeCount
+
+    # Stores the computed hash code of this {@link PredictionContext}. The hash
+    # code is computed in parts to match the following reference algorithm.
+    #
+    # <pre>
+    #  private int referenceHashCode() {
+    #      int hash = {@link MurmurHash#initialize MurmurHash.initialize}({@link #INITIAL_HASH});
+    #
+    #      for (int i = 0; i &lt; {@link #size()}; i++) {
+    #          hash = {@link MurmurHash#update MurmurHash.update}(hash, {@link #getParent getParent}(i));
+    #      }
+    #
+    #      for (int i = 0; i &lt; {@link #size()}; i++) {
+    #          hash = {@link MurmurHash#update MurmurHash.update}(hash, {@link #getReturnState getReturnState}(i));
+    #      }
+    #
+    #      hash = {@link MurmurHash#finish MurmurHash.finish}(hash, 2# {@link #size()});
+    #      return hash;
+    #  }
+    # </pre>
+    #/
+    
+    def __init__(self, cachedHashCode):
+        self.cachedHashCode = cachedHashCode
+
+    def __len__(self):
+        return 0
+
+    # This means only the {@link #EMPTY} context is in set.
+    def isEmpty(self):
+        return self is self.EMPTY
+
+    def hasEmptyPath(self):
+        return self.getReturnState(len(self) - 1) == self.EMPTY_RETURN_STATE
+
+    def getReturnState(self, index):
+        raise "illegal!"
+
+    def __hash__(self):
+        return self.cachedHashCode
+
+    def __str__(self):
+        return unicode(self)
+
+
+def calculateHashCode(parent, returnState):
+    return hash("") if parent is None else hash((hash(parent), returnState))
+
+def calculateListsHashCode(parents, returnStates ):
+    h = 0
+    for parent, returnState in parents, returnStates:
+        h = hash((h, calculateHashCode(parent, returnState)))
+    return h
+
+#  Used to cache {@link PredictionContext} objects. Its used for the shared
+#  context cash associated with contexts in DFA states. This cache
+#  can be used for both lexers and parsers.
+
+class PredictionContextCache(object):
+
+    def __init__(self):
+        self.cache = dict()
+
+    #  Add a context to the cache and return it. If the context already exists,
+    #  return that one instead and do not add a new context to the cache.
+    #  Protect shared cache from unsafe thread access.
+    #
+    def add(self, ctx):
+        if ctx==PredictionContext.EMPTY:
+            return PredictionContext.EMPTY
+        existing = self.cache.get(ctx, None)
+        if existing is not None:
+            return existing
+        self.cache[ctx] = ctx
+        return ctx
+
+    def get(self, ctx):
+        return self.cache.get(ctx, None)
+
+    def __len__(self):
+        return len(self.cache)
+
+
+class SingletonPredictionContext(PredictionContext):
+
+    @staticmethod
+    def create(parent , returnState ):
+        if returnState == PredictionContext.EMPTY_RETURN_STATE and parent is None:
+            # someone can pass in the bits of an array ctx that mean $
+            return SingletonPredictionContext.EMPTY
+        else:
+            return SingletonPredictionContext(parent, returnState)
+
+    def __init__(self, parent, returnState):
+        hashCode = calculateHashCode(parent, returnState)
+        super(SingletonPredictionContext, self).__init__(hashCode)
+        self.parentCtx = parent
+        self.returnState = returnState
+
+    def __len__(self):
+        return 1
+
+    def getParent(self, index):
+        return self.parentCtx
+
+    def getReturnState(self, index):
+        return self.returnState
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif other is None:
+            return False
+        elif not isinstance(other, SingletonPredictionContext):
+            return False
+        else:
+            return self.returnState == other.returnState and self.parentCtx==other.parentCtx
+
+    def __hash__(self):
+        return self.cachedHashCode
+
+    def __unicode__(self):
+        up = "" if self.parentCtx is None else unicode(self.parentCtx)
+        if len(up)==0:
+            if self.returnState == self.EMPTY_RETURN_STATE:
+                return u"$"
+            else:
+                return unicode(self.returnState)
+        else:
+            return unicode(self.returnState) + u" " + up
+
+
+class EmptyPredictionContext(SingletonPredictionContext):
+
+    def __init__(self):
+        super(EmptyPredictionContext, self).__init__(None, self.EMPTY_RETURN_STATE)
+
+    def isEmpty(self):
+        return True
+
+    def __eq__(self, other):
+        return self is other
+
+    def __hash__(self):
+        return self.cachedHashCode
+
+    def __unicode__(self):
+        return "$"
+
+
+PredictionContext.EMPTY = EmptyPredictionContext()
+
+class ArrayPredictionContext(PredictionContext):
+    # Parent can be null only if full ctx mode and we make an array
+    #  from {@link #EMPTY} and non-empty. We merge {@link #EMPTY} by using null parent and
+    #  returnState == {@link #EMPTY_RETURN_STATE}.
+
+    def __init__(self, parents, returnStates):
+        super(ArrayPredictionContext, self).__init__(calculateListsHashCode(parents, returnStates))
+        self.parents = parents
+        self.returnStates = returnStates
+
+    def isEmpty(self):
+        # since EMPTY_RETURN_STATE can only appear in the last position, we
+        # don't need to verify that size==1
+        return self.returnStates[0]==PredictionContext.EMPTY_RETURN_STATE
+
+    def __len__(self):
+        return len(self.returnStates)
+
+    def getParent(self, index):
+        return self.parents[index]
+
+    def getReturnState(self, index):
+        return self.returnStates[index]
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, ArrayPredictionContext):
+            return False
+        elif hash(self) != hash(other):
+            return False # can't be same if hash is different
+        else:
+            return self.returnStates==other.returnStates and self.parents==other.parents
+
+    def __unicode__(self):
+        if self.isEmpty():
+            return "[]"
+        with StringIO() as buf:
+            buf.write(u"[")
+            for i in range(0,len(self.returnStates)):
+                if i>0:
+                    buf.write(u", ")
+                if self.returnStates[i]==PredictionContext.EMPTY_RETURN_STATE:
+                    buf.write(u"$")
+                    continue
+                buf.write(self.returnStates[i])
+                if self.parents[i] is not None:
+                    buf.write(u' ')
+                    buf.write(unicode(self.parents[i]))
+                else:
+                    buf.write(u"null")
+            buf.write(u"]")
+            return buf.getvalue()
+
+
+#  Convert a {@link RuleContext} tree to a {@link PredictionContext} graph.
+#  Return {@link #EMPTY} if {@code outerContext} is empty or null.
+#/
+def PredictionContextFromRuleContext(atn, outerContext=None):
+    if outerContext is None:
+        outerContext = RuleContext.EMPTY
+
+    # if we are in RuleContext of start rule, s, then PredictionContext
+    # is EMPTY. Nobody called us. (if we are empty, return empty)
+    if outerContext.parentCtx is None or outerContext is RuleContext.EMPTY:
+        return PredictionContext.EMPTY
+
+    # If we have a parent, convert it to a PredictionContext graph
+    parent = PredictionContextFromRuleContext(atn, outerContext.parentCtx)
+    state = atn.states[outerContext.invokingState]
+    transition = state.transitions[0]
+    return SingletonPredictionContext.create(parent, transition.followState.stateNumber)
+
+
+def merge(a, b, rootIsWildcard, mergeCache):
+
+    # share same graph if both same
+    if a==b:
+        return a
+
+    if isinstance(a, SingletonPredictionContext) and isinstance(b, SingletonPredictionContext):
+        return mergeSingletons(a, b, rootIsWildcard, mergeCache)
+
+    # At least one of a or b is array
+    # If one is $ and rootIsWildcard, return $ as# wildcard
+    if rootIsWildcard:
+        if isinstance( a, EmptyPredictionContext ):
+            return a
+        if isinstance( b, EmptyPredictionContext ):
+            return b
+
+    # convert singleton so both are arrays to normalize
+    if isinstance( a, SingletonPredictionContext ):
+        a = ArrayPredictionContext([a.parentCtx], [a.returnState])
+    if isinstance( b, SingletonPredictionContext):
+        b = ArrayPredictionContext([b.parentCtx], [b.returnState])
+    return mergeArrays(a, b, rootIsWildcard, mergeCache)
+
+
+#
+# Merge two {@link SingletonPredictionContext} instances.
+#
+# <p>Stack tops equal, parents merge is same; return left graph.<br>
+# <embed src="images/SingletonMerge_SameRootSamePar.svg" type="image/svg+xml"/></p>
+#
+# <p>Same stack top, parents differ; merge parents giving array node, then
+# remainders of those graphs. A new root node is created to point to the
+# merged parents.<br>
+# <embed src="images/SingletonMerge_SameRootDiffPar.svg" type="image/svg+xml"/></p>
+#
+# <p>Different stack tops pointing to same parent. Make array node for the
+# root where both element in the root point to the same (original)
+# parent.<br>
+# <embed src="images/SingletonMerge_DiffRootSamePar.svg" type="image/svg+xml"/></p>
+#
+# <p>Different stack tops pointing to different parents. Make array node for
+# the root where each element points to the corresponding original
+# parent.<br>
+# <embed src="images/SingletonMerge_DiffRootDiffPar.svg" type="image/svg+xml"/></p>
+#
+# @param a the first {@link SingletonPredictionContext}
+# @param b the second {@link SingletonPredictionContext}
+# @param rootIsWildcard {@code true} if this is a local-context merge,
+# otherwise false to indicate a full-context merge
+# @param mergeCache
+#/
+def mergeSingletons(a, b, rootIsWildcard, mergeCache):
+    if mergeCache is not None:
+        previous = mergeCache.get(a,b)
+        if previous is not None:
+            return previous
+        previous = mergeCache.get(b,a)
+        if previous is not None:
+            return previous
+
+    rootMerge = mergeRoot(a, b, rootIsWildcard)
+    if rootMerge is not None:
+        if mergeCache is not None:
+            mergeCache.put(a, b, rootMerge)
+        return rootMerge
+
+    if a.returnState==b.returnState:
+        parent = merge(a.parentCtx, b.parentCtx, rootIsWildcard, mergeCache)
+        # if parent is same as existing a or b parent or reduced to a parent, return it
+        if parent == a.parentCtx:
+            return a # ax + bx = ax, if a=b
+        if parent == b.parentCtx:
+            return b # ax + bx = bx, if a=b
+        # else: ax + ay = a'[x,y]
+        # merge parents x and y, giving array node with x,y then remainders
+        # of those graphs.  dup a, a' points at merged array
+        # new joined parent so create new singleton pointing to it, a'
+        a_ = SingletonPredictionContext.create(parent, a.returnState)
+        if mergeCache is not None:
+            mergeCache.put(a, b, a_)
+        return a_
+    else: # a != b payloads differ
+        # see if we can collapse parents due to $+x parents if local ctx
+        singleParent = None
+        if a is b or (a.parentCtx is not None and a.parentCtx==b.parentCtx): # ax + bx = [a,b]x
+            singleParent = a.parentCtx
+        if singleParent is not None:	# parents are same
+            # sort payloads and use same parent
+            payloads = [ a.returnState, b.returnState ]
+            if a.returnState > b.returnState:
+                payloads[0] = b.returnState
+                payloads[1] = a.returnState
+            parents = [singleParent, singleParent]
+            a_ = ArrayPredictionContext(parents, payloads)
+            if mergeCache is not None:
+                mergeCache.put(a, b, a_)
+            return a_
+        # parents differ and can't merge them. Just pack together
+        # into array; can't merge.
+        # ax + by = [ax,by]
+        payloads = [ a.returnState, b.returnState ]
+        parents = [ a.parentCtx, b.parentCtx ]
+        if a.returnState > b.returnState: # sort by payload
+            payloads[0] = b.returnState
+            payloads[1] = a.returnState
+            parents = [ b.parentCtx, a.parentCtx ]
+        a_ = ArrayPredictionContext(parents, payloads)
+        if mergeCache is not None:
+            mergeCache.put(a, b, a_)
+        return a_
+
+
+#
+# Handle case where at least one of {@code a} or {@code b} is
+# {@link #EMPTY}. In the following diagrams, the symbol {@code $} is used
+# to represent {@link #EMPTY}.
+#
+# <h2>Local-Context Merges</h2>
+#
+# <p>These local-context merge operations are used when {@code rootIsWildcard}
+# is true.</p>
+#
+# <p>{@link #EMPTY} is superset of any graph; return {@link #EMPTY}.<br>
+# <embed src="images/LocalMerge_EmptyRoot.svg" type="image/svg+xml"/></p>
+#
+# <p>{@link #EMPTY} and anything is {@code #EMPTY}, so merged parent is
+# {@code #EMPTY}; return left graph.<br>
+# <embed src="images/LocalMerge_EmptyParent.svg" type="image/svg+xml"/></p>
+#
+# <p>Special case of last merge if local context.<br>
+# <embed src="images/LocalMerge_DiffRoots.svg" type="image/svg+xml"/></p>
+#
+# <h2>Full-Context Merges</h2>
+#
+# <p>These full-context merge operations are used when {@code rootIsWildcard}
+# is false.</p>
+#
+# <p><embed src="images/FullMerge_EmptyRoots.svg" type="image/svg+xml"/></p>
+#
+# <p>Must keep all contexts; {@link #EMPTY} in array is a special value (and
+# null parent).<br>
+# <embed src="images/FullMerge_EmptyRoot.svg" type="image/svg+xml"/></p>
+#
+# <p><embed src="images/FullMerge_SameRoot.svg" type="image/svg+xml"/></p>
+#
+# @param a the first {@link SingletonPredictionContext}
+# @param b the second {@link SingletonPredictionContext}
+# @param rootIsWildcard {@code true} if this is a local-context merge,
+# otherwise false to indicate a full-context merge
+#/
+def mergeRoot(a, b, rootIsWildcard):
+    if rootIsWildcard:
+        if a == PredictionContext.EMPTY:
+            return PredictionContext.EMPTY  ## + b =#
+        if b == PredictionContext.EMPTY:
+            return PredictionContext.EMPTY  # a +# =#
+    else:
+        if a == PredictionContext.EMPTY and b == PredictionContext.EMPTY:
+            return PredictionContext.EMPTY # $ + $ = $
+        elif a == PredictionContext.EMPTY: # $ + x = [$,x]
+            payloads = [ b.returnState, PredictionContext.EMPTY_RETURN_STATE ]
+            parents = [ b.parentCtx, None ]
+            return ArrayPredictionContext(parents, payloads)
+        elif b == PredictionContext.EMPTY: # x + $ = [$,x] ($ is always first if present)
+            payloads = [ a.returnState, PredictionContext.EMPTY_RETURN_STATE ]
+            parents = [ a.parentCtx, None ]
+            return ArrayPredictionContext(parents, payloads)
+    return None
+
+
+#
+# Merge two {@link ArrayPredictionContext} instances.
+#
+# <p>Different tops, different parents.<br>
+# <embed src="images/ArrayMerge_DiffTopDiffPar.svg" type="image/svg+xml"/></p>
+#
+# <p>Shared top, same parents.<br>
+# <embed src="images/ArrayMerge_ShareTopSamePar.svg" type="image/svg+xml"/></p>
+#
+# <p>Shared top, different parents.<br>
+# <embed src="images/ArrayMerge_ShareTopDiffPar.svg" type="image/svg+xml"/></p>
+#
+# <p>Shared top, all shared parents.<br>
+# <embed src="images/ArrayMerge_ShareTopSharePar.svg" type="image/svg+xml"/></p>
+#
+# <p>Equal tops, merge parents and reduce top to
+# {@link SingletonPredictionContext}.<br>
+# <embed src="images/ArrayMerge_EqualTop.svg" type="image/svg+xml"/></p>
+#/
+def mergeArrays(a, b, rootIsWildcard, mergeCache):
+    if mergeCache is not None:
+        previous = mergeCache.get(a,b)
+        if previous is not None:
+            return previous
+        previous = mergeCache.get(b,a)
+        if previous is not None:
+            return previous
+
+    # merge sorted payloads a + b => M
+    i = 0 # walks a
+    j = 0 # walks b
+    k = 0 # walks target M array
+
+    mergedReturnStates = [] * (len(a.returnState) + len( b.returnStates))
+    mergedParents = [] * len(mergedReturnStates)
+    # walk and merge to yield mergedParents, mergedReturnStates
+    while i<len(a.returnStates) and j<len(b.returnStates):
+        a_parent = a.parents[i]
+        b_parent = b.parents[j]
+        if a.returnStates[i]==b.returnStates[j]:
+            # same payload (stack tops are equal), must yield merged singleton
+            payload = a.returnStates[i]
+            # $+$ = $
+            bothDollars = payload == PredictionContext.EMPTY_RETURN_STATE and \
+                            a_parent is None and b_parent is None
+            ax_ax = (a_parent is not None and b_parent is not None) and a_parent==b_parent # ax+ax -> ax
+            if bothDollars or ax_ax:
+                mergedParents[k] = a_parent # choose left
+                mergedReturnStates[k] = payload
+            else: # ax+ay -> a'[x,y]
+                mergedParent = merge(a_parent, b_parent, rootIsWildcard, mergeCache)
+                mergedParents[k] = mergedParent
+                mergedReturnStates[k] = payload
+            i += 1 # hop over left one as usual
+            j += 1 # but also skip one in right side since we merge
+        elif a.returnStates[i]<b.returnStates[j]: # copy a[i] to M
+            mergedParents[k] = a_parent
+            mergedReturnStates[k] = a.returnStates[i]
+            i += 1
+        else: # b > a, copy b[j] to M
+            mergedParents[k] = b_parent
+            mergedReturnStates[k] = b.returnStates[j]
+            j += 1
+        k += 1
+
+    # copy over any payloads remaining in either array
+    if i < len(a.returnStates):
+        for p in range(i, len(a.returnStates)):
+            mergedParents[k] = a.parents[p]
+            mergedReturnStates[k] = a.returnStates[p]
+            k += 1
+    else:
+        for p in range(j, len(b.returnStates)):
+            mergedParents[k] = b.parents[p]
+            mergedReturnStates[k] = b.returnStates[p]
+            k += 1
+
+    # trim merged if we combined a few that had same stack tops
+    if k < len(mergedParents): # write index < last position; trim
+        if k == 1: # for just one merged element, return singleton top
+            a_ = SingletonPredictionContext.create(mergedParents[0], mergedReturnStates[0])
+            if mergeCache is not None:
+                mergeCache.put(a,b,a_)
+            return a_
+        mergedParents = mergedParents[0:k]
+        mergedReturnStates = mergedReturnStates[0:k]
+
+    M = ArrayPredictionContext(mergedParents, mergedReturnStates)
+
+    # if we created same array as a or b, return that instead
+    # TODO: track whether this is possible above during merge sort for speed
+    if M==a:
+        if mergeCache is not None:
+            mergeCache.put(a,b,a)
+        return a
+    if M==b:
+        if mergeCache is not None:
+            mergeCache.put(a,b,b)
+        return b
+    combineCommonParents(mergedParents)
+
+    if mergeCache is not None:
+        mergeCache.put(a,b,M)
+    return M
+
+
+#
+# Make pass over all <em>M</em> {@code parents}; merge any {@code equals()}
+# ones.
+#/
+def combineCommonParents(parents):
+    uniqueParents = dict()
+
+    for p in range(0, len(parents)):
+        parent = parents[p]
+        if uniqueParents.get(parent, None) is None:
+            uniqueParents[parent] = parent
+
+    for p in range(0, len(parents)):
+        parents[p] = uniqueParents[parents[p]]
+
+def getCachedPredictionContext(context, contextCache, visited):
+    if context.isEmpty():
+        return context
+    existing = visited.get(context)
+    if existing is not None:
+        return existing
+    existing = contextCache.get(context)
+    if existing is not None:
+        visited[context] = existing
+        return existing
+    changed = False
+    parents = [None] * len(context)
+    for i in range(0, len(parents)):
+        parent = getCachedPredictionContext(context.getParent(i), contextCache, visited)
+        if changed or parent is not context.getParent(i):
+            if not changed:
+                parents = [None] * len(context)
+                for j in range(0, len(context)):
+                    parents[j] = context.getParent(j)
+                changed = True
+            parents[i] = parent
+    if not changed:
+        contextCache.add(context)
+        visited[context] = context
+        return context
+    updated = None
+    if len(parents) == 0:
+        updated = PredictionContext.EMPTY
+    elif len(parents) == 1:
+        updated = SingletonPredictionContext.create(parents[0], context.getReturnState(0))
+    else:
+        updated = ArrayPredictionContext(parents, context.returnStates)
+
+    contextCache.add(updated)
+    visited[updated] = updated
+    visited[context] = updated
+
+    return updated
+
+
+#	# extra structures, but cut/paste/morphed works, so leave it.
+#	# seems to do a breadth-first walk
+#	public static List<PredictionContext> getAllNodes(PredictionContext context) {
+#		Map<PredictionContext, PredictionContext> visited =
+#			new IdentityHashMap<PredictionContext, PredictionContext>();
+#		Deque<PredictionContext> workList = new ArrayDeque<PredictionContext>();
+#		workList.add(context);
+#		visited.put(context, context);
+#		List<PredictionContext> nodes = new ArrayList<PredictionContext>();
+#		while (!workList.isEmpty()) {
+#			PredictionContext current = workList.pop();
+#			nodes.add(current);
+#			for (int i = 0; i < current.size(); i++) {
+#				PredictionContext parent = current.getParent(i);
+#				if ( parent!=null && visited.put(parent, parent) == null) {
+#					workList.push(parent);
+#				}
+#			}
+#		}
+#		return nodes;
+#	}
+
+# ter's recursive version of Sam's getAllNodes()
+def getAllContextNodes(context, nodes=None, visited=None):
+    if nodes is None:
+        nodes = list()
+        return getAllContextNodes(context, nodes, visited)
+    elif visited is None:
+        visited = dict()
+        return getAllContextNodes(context, nodes, visited)
+    else:
+        if context is None or visited.get(context, None) is not None:
+            return nodes
+        visited.put(context, context)
+        nodes.add(context)
+        for i in range(0, len(context)):
+            getAllContextNodes(context.getParent(i), nodes, visited);
+        return nodes
+
diff --git a/runtime/Python2/src/antlr4/Recognizer.py b/runtime/Python2/src/antlr4/Recognizer.py
new file mode 100644
index 000000000..438e80cb7
--- /dev/null
+++ b/runtime/Python2/src/antlr4/Recognizer.py
@@ -0,0 +1,166 @@
+#
+# [The "BSD license"]
+#  Copyright (c) 2012 Terence Parr
+#  Copyright (c) 2012 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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.
+#
+from __builtin__ import unicode
+from antlr4.Token import Token
+from antlr4.error.ErrorListener import ProxyErrorListener, ConsoleErrorListener
+
+class Recognizer(object):
+
+    tokenTypeMapCache = dict()
+    ruleIndexMapCache = dict()
+
+    def __init__(self):
+        self._listeners = [ ConsoleErrorListener.INSTANCE ]
+        self._interp = None
+        self._stateNumber = -1
+
+    def extractVersion(self, version):
+        pos = version.find(".")
+        major = version[0:pos]
+        version = version[pos+1:]
+        pos = version.find(".")
+        if pos==-1:
+            pos = version.find("-")
+        if pos==-1:
+            pos = len(version)
+        minor = version[0:pos]
+        return major, minor
+
+    def checkVersion(self, toolVersion):
+        runtimeVersion = "4.5.3"
+        rvmajor, rvminor = self.extractVersion(runtimeVersion)
+        tvmajor, tvminor = self.extractVersion(toolVersion)
+        if rvmajor!=tvmajor or rvminor!=tvminor:
+            print("ANTLR runtime and generated code versions disagree: "+runtimeVersion+"!="+toolVersion)
+
+    def addErrorListener(self, listener):
+        self._listeners.append(listener)
+
+    def removeErrorListener(self, listener):
+        self._listeners.remove(listener)
+        
+    def removeErrorListeners(self):
+        self._listeners = []
+    
+    def getTokenTypeMap(self):
+        tokenNames = self.getTokenNames()
+        if tokenNames is None:
+            from antlr4.error.Errors import UnsupportedOperationException
+            raise UnsupportedOperationException("The current recognizer does not provide a list of token names.")
+        result = self.tokenTypeMapCache.get(tokenNames, None)
+        if result is None:
+            result = zip( tokenNames, range(0, len(tokenNames)))
+            result["EOF"] = Token.EOF
+            self.tokenTypeMapCache[tokenNames] = result
+        return result
+
+    # Get a map from rule names to rule indexes.
+    #
+    # <p>Used for XPath and tree pattern compilation.</p>
+    #
+    def getRuleIndexMap(self):
+        ruleNames = self.getRuleNames()
+        if ruleNames is None:
+            from antlr4.error.Errors import UnsupportedOperationException
+            raise UnsupportedOperationException("The current recognizer does not provide a list of rule names.")
+        result = self.ruleIndexMapCache.get(ruleNames, None)
+        if result is None:
+            result = zip( ruleNames, range(0, len(ruleNames)))
+            self.ruleIndexMapCache[ruleNames] = result
+        return result
+
+    def getTokenType(self, tokenName):
+        ttype = self.getTokenTypeMap().get(tokenName, None)
+        if ttype is not None:
+            return ttype
+        else:
+            return Token.INVALID_TYPE
+
+
+    # What is the error header, normally line/character position information?#
+    def getErrorHeader(self, e):
+        line = e.getOffendingToken().line
+        column = e.getOffendingToken().column
+        return u"line " + unicode(line) + u":" + unicode(column)
+
+
+    # How should a token be displayed in an error message? The default
+    #  is to display just the text, but during development you might
+    #  want to have a lot of information spit out.  Override in that case
+    #  to use t.toString() (which, for CommonToken, dumps everything about
+    #  the token). This is better than forcing you to override a method in
+    #  your token objects because you don't have to go modify your lexer
+    #  so that it creates a new Java type.
+    #
+    # @deprecated This method is not called by the ANTLR 4 Runtime. Specific
+    # implementations of {@link ANTLRErrorStrategy} may provide a similar
+    # feature when necessary. For example, see
+    # {@link DefaultErrorStrategy#getTokenErrorDisplay}.
+    #
+    def getTokenErrorDisplay(self, t):
+        if t is None:
+            return u"<no token>"
+        s = t.text
+        if s is None:
+            if t.type==Token.EOF:
+                s = u"<EOF>"
+            else:
+                s = u"<" + unicode(t.type) + u">"
+        s = s.replace(u"\n",u"\\n")
+        s = s.replace(u"\r",u"\\r")
+        s = s.replace(u"\t",u"\\t")
+        return u"'" + s + u"'"
+
+    def getErrorListenerDispatch(self):
+        return ProxyErrorListener(self._listeners)
+
+    # subclass needs to override these if there are sempreds or actions
+    # that the ATN interp needs to execute
+    def sempred(self, localctx, ruleIndex, actionIndex):
+        return True
+
+    def precpred(self, localctx , precedence):
+        return True
+
+    @property
+    def state(self):
+        return self._stateNumber
+
+    # Indicate that the recognizer has changed internal state that is
+    #  consistent with the ATN state passed in.  This way we always know
+    #  where we are in the ATN as the parser goes along. The rule
+    #  context objects form a stack that lets us see the stack of
+    #  invoking rules. Combine this and we have complete ATN
+    #  configuration information.
+
+    @state.setter
+    def state(self, atnState):
+        self._stateNumber = atnState
diff --git a/runtime/Python2/src/antlr4/RuleContext.py b/runtime/Python2/src/antlr4/RuleContext.py
new file mode 100644
index 000000000..517f873d6
--- /dev/null
+++ b/runtime/Python2/src/antlr4/RuleContext.py
@@ -0,0 +1,250 @@
+# [The "BSD license"]
+#  Copyright (c) 2013 Terence Parr
+#  Copyright (c) 2013 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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 rule context is a record of a single rule invocation. It knows
+#  which context invoked it, if any. If there is no parent context, then
+#  naturally the invoking state is not valid.  The parent link
+#  provides a chain upwards from the current rule invocation to the root
+#  of the invocation tree, forming a stack. We actually carry no
+#  information about the rule associated with this context (except
+#  when parsing). We keep only the state number of the invoking state from
+#  the ATN submachine that invoked this. Contrast this with the s
+#  pointer inside ParserRuleContext that tracks the current state
+#  being "executed" for the current rule.
+#
+#  The parent contexts are useful for computing lookahead sets and
+#  getting error information.
+#
+#  These objects are used during parsing and prediction.
+#  For the special case of parsers, we use the subclass
+#  ParserRuleContext.
+#
+#  @see ParserRuleContext
+#/
+from io import StringIO
+from antlr4.tree.Tree import RuleNode, INVALID_INTERVAL
+from antlr4.tree.Trees import Trees
+from antlr4.atn.ATN import ATN
+
+class RuleContext(RuleNode):
+
+    EMPTY = None
+
+    def __init__(self, parent=None, invokingState=-1):
+        super(RuleContext, self).__init__()
+        # What context invoked this rule?
+        self.parentCtx = parent
+        # What state invoked the rule associated with this context?
+        #  The "return address" is the followState of invokingState
+        #  If parent is null, this should be -1.
+        self.invokingState = invokingState
+
+
+    def depth(self):
+        n = 0
+        p = self
+        while p is not None:
+            p = p.parentCtx
+            n += 1
+        return n
+
+    # A context is empty if there is no invoking state; meaning nobody call
+    #  current context.
+    def isEmpty(self):
+        return self.invokingState == -1
+
+    # satisfy the ParseTree / SyntaxTree interface
+
+    def getSourceInterval(self):
+        return INVALID_INTERVAL
+
+    def getRuleContext(self):
+        return self
+
+    def getPayload(self):
+        return self
+
+    # Return the combined text of all child nodes. This method only considers
+    #  tokens which have been added to the parse tree.
+    #  <p>
+    #  Since tokens on hidden channels (e.g. whitespace or comments) are not
+    #  added to the parse trees, they will not appear in the output of this
+    #  method.
+    #/
+    def getText(self):
+        if self.getChildCount() == 0:
+            return u""
+        with StringIO() as builder:
+            for child in self.getChildren():
+                builder.write(child.getText())
+            return builder.getvalue()
+
+    def getRuleIndex(self):
+        return -1
+
+	# For rule associated with this parse tree internal node, return
+	# the outer alternative number used to match the input. Default
+	# implementation does not compute nor store this alt num. Create
+	# a subclass of ParserRuleContext with backing field and set
+	# option contextSuperClass.
+	# to set it.
+    def getAltNumber(self):
+        return ATN.INVALID_ALT_NUMBER
+
+	# Set the outer alternative number for this context node. Default
+	# implementation does nothing to avoid backing field overhead for
+	# trees that don't need it.  Create
+	# a subclass of ParserRuleContext with backing field and set
+	# option contextSuperClass.
+    def setAltNumber(self, altNumber):
+        pass
+
+    def getChild(self, i):
+        return None
+
+    def getChildCount(self):
+        return 0
+
+    def getChildren(self):
+        for c in []:
+            yield c
+
+    def accept(self, visitor):
+        return visitor.visitChildren(self)
+
+    # # Call this method to view a parse tree in a dialog box visually.#/
+    #  public Future<JDialog> inspect(@Nullable Parser parser) {
+    #      List<String> ruleNames = parser != null ? Arrays.asList(parser.getRuleNames()) : null;
+    #      return inspect(ruleNames);
+    #  }
+    #
+    #  public Future<JDialog> inspect(@Nullable List<String> ruleNames) {
+    #      TreeViewer viewer = new TreeViewer(ruleNames, this);
+    #      return viewer.open();
+    #  }
+    #
+    # # Save this tree in a postscript file#/
+    #  public void save(@Nullable Parser parser, String fileName)
+    #      throws IOException, PrintException
+    #  {
+    #      List<String> ruleNames = parser != null ? Arrays.asList(parser.getRuleNames()) : null;
+    #      save(ruleNames, fileName);
+    #  }
+    #
+    # # Save this tree in a postscript file using a particular font name and size#/
+    #  public void save(@Nullable Parser parser, String fileName,
+    #                   String fontName, int fontSize)
+    #      throws IOException
+    #  {
+    #      List<String> ruleNames = parser != null ? Arrays.asList(parser.getRuleNames()) : null;
+    #      save(ruleNames, fileName, fontName, fontSize);
+    #  }
+    #
+    # # Save this tree in a postscript file#/
+    #  public void save(@Nullable List<String> ruleNames, String fileName)
+    #      throws IOException, PrintException
+    #  {
+    #      Trees.writePS(this, ruleNames, fileName);
+    #  }
+    #
+    # # Save this tree in a postscript file using a particular font name and size#/
+    #  public void save(@Nullable List<String> ruleNames, String fileName,
+    #                   String fontName, int fontSize)
+    #      throws IOException
+    #  {
+    #      Trees.writePS(this, ruleNames, fileName, fontName, fontSize);
+    #  }
+    #
+    # # Print out a whole tree, not just a node, in LISP format
+    #  #  (root child1 .. childN). Print just a node if this is a leaf.
+    #  #  We have to know the recognizer so we can get rule names.
+    #  #/
+    #  @Override
+    #  public String toStringTree(@Nullable Parser recog) {
+    #      return Trees.toStringTree(this, recog);
+    #  }
+    #
+    # Print out a whole tree, not just a node, in LISP format
+    #  (root child1 .. childN). Print just a node if this is a leaf.
+    #
+    def toStringTree(self, ruleNames=None, recog=None):
+        return Trees.toStringTree(self, ruleNames=ruleNames, recog=recog)
+    #  }
+    #
+    #  @Override
+    #  public String toStringTree() {
+    #      return toStringTree((List<String>)null);
+    #  }
+    #
+    def __unicode__(self):
+        return self.toString(None, None)
+
+    #  @Override
+    #  public String toString() {
+    #      return toString((List<String>)null, (RuleContext)null);
+    #  }
+    #
+    #  public final String toString(@Nullable Recognizer<?,?> recog) {
+    #      return toString(recog, ParserRuleContext.EMPTY);
+    #  }
+    #
+    #  public final String toString(@Nullable List<String> ruleNames) {
+    #      return toString(ruleNames, null);
+    #  }
+    #
+    #  // recog null unless ParserRuleContext, in which case we use subclass toString(...)
+    #  public String toString(@Nullable Recognizer<?,?> recog, @Nullable RuleContext stop) {
+    #      String[] ruleNames = recog != null ? recog.getRuleNames() : null;
+    #      List<String> ruleNamesList = ruleNames != null ? Arrays.asList(ruleNames) : null;
+    #      return toString(ruleNamesList, stop);
+    #  }
+
+    def toString(self, ruleNames, stop):
+        with StringIO() as buf:
+            p = self
+            buf.write(u"[")
+            while p is not None and p is not stop:
+                if ruleNames is None:
+                    if not p.isEmpty():
+                        buf.write(unicode(p.invokingState))
+                else:
+                    ri = p.getRuleIndex()
+                    ruleName = ruleNames[ri] if ri >= 0 and ri < len(ruleNames) else unicode(ri)
+                    buf.write(ruleName)
+
+                if p.parentCtx is not None and (ruleNames is not None or not p.parentCtx.isEmpty()):
+                    buf.write(u" ")
+
+                p = p.parentCtx
+
+            buf.write(u"]")
+            return buf.getvalue()
+
diff --git a/runtime/Python2/src/antlr4/StdinStream.py b/runtime/Python2/src/antlr4/StdinStream.py
new file mode 100644
index 000000000..d48f98d79
--- /dev/null
+++ b/runtime/Python2/src/antlr4/StdinStream.py
@@ -0,0 +1,46 @@
+#
+#  [The "BSD license"]
+#   Copyright (c) 2012 Terence Parr
+#   Copyright (c) 2012 Sam Harwell
+#   Copyright (c) 2014 Eric Vergnaud
+#   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.
+# 
+
+#
+#  This is an InputStream that is loaded from stdin all at once
+#  when you construct the object.
+# 
+
+import codecs
+import sys
+from antlr4.InputStream import InputStream
+
+class StdinStream(InputStream):
+
+	def __init__(self, encoding='ascii'):
+		bytes = sys.stdin.read()
+		data = codecs.decode(bytes, encoding)
+		super(type(self), self).__init__(data)
\ No newline at end of file
diff --git a/runtime/Python2/src/antlr4/Token.py b/runtime/Python2/src/antlr4/Token.py
new file mode 100644
index 000000000..900def230
--- /dev/null
+++ b/runtime/Python2/src/antlr4/Token.py
@@ -0,0 +1,184 @@
+#[The "BSD license"]
+# Copyright (c) 2012 Terence Parr
+# Copyright (c) 2012 Sam Harwell
+# Copyright (c) 2014 Eric Vergnaud
+# 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 token has properties: text, type, line, character position in the line
+# (so we can ignore tabs), token channel, index, and source from which
+# we obtained this token.
+from io import StringIO
+
+
+class Token (object):
+
+    INVALID_TYPE = 0
+
+    # During lookahead operations, this "token" signifies we hit rule end ATN state
+    # and did not follow it despite needing to.
+    EPSILON = -2
+
+    MIN_USER_TOKEN_TYPE = 1
+
+    EOF = -1
+
+    # All tokens go to the parser (unless skip() is called in that rule)
+    # on a particular "channel".  The parser tunes to a particular channel
+    # so that whitespace etc... can go to the parser on a "hidden" channel.
+
+    DEFAULT_CHANNEL = 0
+
+    # Anything on different channel than DEFAULT_CHANNEL is not parsed
+    # by parser.
+
+    HIDDEN_CHANNEL = 1
+
+    def __init__(self):
+        self.source = None
+        self.type = None # token type of the token
+        self.channel = None # The parser ignores everything not on DEFAULT_CHANNEL
+        self.start = None # optional; return -1 if not implemented.
+        self.stop = None  # optional; return -1 if not implemented.
+        self.tokenIndex = None # from 0..n-1 of the token object in the input stream
+        self.line = None # line=1..n of the 1st character
+        self.column = None # beginning of the line at which it occurs, 0..n-1
+        self._text = None # text of the token.
+
+    @property
+    def text(self):
+        return self._text
+
+    # Explicitly set the text for this token. If {code text} is not
+    # {@code null}, then {@link #getText} will return this value rather than
+    # extracting the text from the input.
+    #
+    # @param text The explicit text of the token, or {@code null} if the text
+    # should be obtained from the input along with the start and stop indexes
+    # of the token.
+
+    @text.setter
+    def text(self, text):
+        self._text = text
+
+
+    def getTokenSource(self):
+        return self.source[0]
+
+    def getInputStream(self):
+        return self.source[1]
+
+    def __str__(self):
+        return unicode(self)
+
+
+class CommonToken(Token):
+
+
+    # An empty {@link Pair} which is used as the default value of
+    # {@link #source} for tokens that do not have a source.
+    EMPTY_SOURCE = (None, None)
+
+    def __init__(self, source = EMPTY_SOURCE, type = None, channel=Token.DEFAULT_CHANNEL, start=-1, stop=-1):
+        super(CommonToken, self).__init__()
+        self.source = source
+        self.type = type
+        self.channel = channel
+        self.start = start
+        self.stop = stop
+        self.tokenIndex = -1
+        if source[0] is not None:
+            self.line = source[0].line
+            self.column = source[0].column
+        else:
+            self.column = -1
+
+    # Constructs a new {@link CommonToken} as a copy of another {@link Token}.
+    #
+    # <p>
+    # If {@code oldToken} is also a {@link CommonToken} instance, the newly
+    # constructed token will share a reference to the {@link #text} field and
+    # the {@link Pair} stored in {@link #source}. Otherwise, {@link #text} will
+    # be assigned the result of calling {@link #getText}, and {@link #source}
+    # will be constructed from the result of {@link Token#getTokenSource} and
+    # {@link Token#getInputStream}.</p>
+    #
+    # @param oldToken The token to copy.
+    #
+    def clone(self):
+        t = CommonToken(self.source, self.type, self.channel, self.start, self.stop)
+        t.tokenIndex = self.tokenIndex
+        t.line = self.line
+        t.column = self.column
+        t.text = self.text
+        return t
+
+    @property
+    def text(self):
+        if self._text is not None:
+            return self._text
+        input = self.getInputStream()
+        if input is None:
+            return None
+        n = input.size
+        if self.start < n and self.stop < n:
+            return input.getText(self.start, self.stop)
+        else:
+            return u"<EOF>"
+
+    @text.setter
+    def text(self, text):
+        self._text = text
+
+    def __unicode__(self):
+        with StringIO() as buf:
+            buf.write(u"[@")
+            buf.write(unicode(self.tokenIndex))
+            buf.write(u",")
+            buf.write(unicode(self.start))
+            buf.write(u":")
+            buf.write(unicode(self.stop))
+            buf.write(u"='")
+            txt = self.text
+            if txt is not None:
+                txt = txt.replace(u"\n",u"\\n")
+                txt = txt.replace(u"\r",u"\\r")
+                txt = txt.replace(u"\t",u"\\t")
+            else:
+                txt = u"<no text>"
+            buf.write(txt)
+            buf.write(u"',<")
+            buf.write(unicode(self.type))
+            buf.write(u">")
+            if self.channel > 0:
+                buf.write(u",channel=")
+                buf.write(unicode(self.channel))
+            buf.write(u",")
+            buf.write(unicode(self.line))
+            buf.write(u":")
+            buf.write(unicode(self.column))
+            buf.write(u"]")
+            return buf.getvalue()
diff --git a/runtime/Python2/src/antlr4/Utils.py b/runtime/Python2/src/antlr4/Utils.py
new file mode 100644
index 000000000..0bc6d5644
--- /dev/null
+++ b/runtime/Python2/src/antlr4/Utils.py
@@ -0,0 +1,64 @@
+#[The "BSD license"]
+# Copyright (c) 2012 Terence Parr
+# Copyright (c) 2012 Sam Harwell
+# Copyright (c) 2014 Eric Vergnaud
+# 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.
+#
+
+from io import StringIO
+
+def str_collection(val, begin, end):
+    with StringIO() as buf:
+        buf.write(begin)
+        first = True
+        for item in val:
+            if not first:
+                buf.write(u', ')
+            buf.write(unicode(item))
+            first = False
+        buf.write(end)
+        return buf.getvalue()
+
+def str_list(val):
+    return str_collection(val, u'[', u']')
+
+def str_set(val):
+    return str_collection(val, u'{', u'}')
+
+def escapeWhitespace(s, escapeSpaces):
+    with StringIO() as buf:
+        for c in s:
+            if c==' ' and escapeSpaces:
+                buf.write(u'\u00B7')
+            elif c=='\t':
+                buf.write(u"\\t")
+            elif c=='\n':
+                buf.write(u"\\n")
+            elif c=='\r':
+                buf.write(u"\\r")
+            else:
+                buf.write(unicode(c))
+        return buf.getvalue()
diff --git a/runtime/Python2/src/antlr4/__init__.py b/runtime/Python2/src/antlr4/__init__.py
new file mode 100644
index 000000000..37ce0bb5d
--- /dev/null
+++ b/runtime/Python2/src/antlr4/__init__.py
@@ -0,0 +1,21 @@
+from antlr4.Token import Token
+from antlr4.InputStream import InputStream
+from antlr4.FileStream import FileStream
+from antlr4.StdinStream import StdinStream
+from antlr4.BufferedTokenStream import TokenStream
+from antlr4.CommonTokenStream import CommonTokenStream
+from antlr4.Lexer import Lexer
+from antlr4.Parser import Parser
+from antlr4.dfa.DFA import DFA
+from antlr4.atn.ATN import ATN
+from antlr4.atn.ATNDeserializer import ATNDeserializer
+from antlr4.atn.LexerATNSimulator import LexerATNSimulator
+from antlr4.atn.ParserATNSimulator import ParserATNSimulator
+from antlr4.atn.PredictionMode import PredictionMode
+from antlr4.PredictionContext import PredictionContextCache
+from antlr4.ParserRuleContext import ParserRuleContext
+from antlr4.tree.Tree import ParseTreeListener, ParseTreeVisitor, ParseTreeWalker, TerminalNode, ErrorNode, RuleNode
+from antlr4.error.Errors import RecognitionException, IllegalStateException, NoViableAltException
+from antlr4.error.ErrorStrategy import BailErrorStrategy
+from antlr4.error.DiagnosticErrorListener import DiagnosticErrorListener
+from antlr4.Utils import str_list
\ No newline at end of file
diff --git a/runtime/Python2/src/antlr4/atn/ATN.py b/runtime/Python2/src/antlr4/atn/ATN.py
new file mode 100644
index 000000000..c597eb041
--- /dev/null
+++ b/runtime/Python2/src/antlr4/atn/ATN.py
@@ -0,0 +1,147 @@
+# [The "BSD license"]
+#  Copyright (c) 2013 Terence Parr
+#  Copyright (c) 2013 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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.
+#/
+from antlr4.IntervalSet import IntervalSet
+from antlr4.Token import Token
+
+
+class ATN(object):
+
+    INVALID_ALT_NUMBER = 0
+
+    # Used for runtime deserialization of ATNs from strings#/
+    def __init__(self, grammarType , maxTokenType ):
+        # The type of the ATN.
+        self.grammarType = grammarType
+        # The maximum value for any symbol recognized by a transition in the ATN.
+        self.maxTokenType = maxTokenType
+        self.states = []
+        # Each subrule/rule is a decision point and we must track them so we
+        #  can go back later and build DFA predictors for them.  This includes
+        #  all the rules, subrules, optional blocks, ()+, ()* etc...
+        self.decisionToState = []
+        # Maps from rule index to starting state number.
+        self.ruleToStartState = []
+        # Maps from rule index to stop state number.
+        self.ruleToStopState = None
+        self.modeNameToStartState = dict()
+        # For lexer ATNs, this maps the rule index to the resulting token type.
+        # For parser ATNs, this maps the rule index to the generated bypass token
+        # type if the
+        # {@link ATNDeserializationOptions#isGenerateRuleBypassTransitions}
+        # deserialization option was specified; otherwise, this is {@code null}.
+        self.ruleToTokenType = None
+        # For lexer ATNs, this is an array of {@link LexerAction} objects which may
+        # be referenced by action transitions in the ATN.
+        self.lexerActions = None
+        self.modeToStartState = []
+
+    # Compute the set of valid tokens that can occur starting in state {@code s}.
+    #  If {@code ctx} is null, the set of tokens will not include what can follow
+    #  the rule surrounding {@code s}. In other words, the set will be
+    #  restricted to tokens reachable staying within {@code s}'s rule.
+    def nextTokensInContext(self, s, ctx):
+        from antlr4.LL1Analyzer import LL1Analyzer
+        anal = LL1Analyzer(self)
+        return anal.LOOK(s, ctx=ctx)
+
+    # Compute the set of valid tokens that can occur starting in {@code s} and
+    # staying in same rule. {@link Token#EPSILON} is in set if we reach end of
+    # rule.
+    def nextTokensNoContext(self, s):
+        if s.nextTokenWithinRule is not None:
+            return s.nextTokenWithinRule
+        s.nextTokenWithinRule = self.nextTokensInContext(s, None)
+        s.nextTokenWithinRule.readonly = True
+        return s.nextTokenWithinRule
+
+    def nextTokens(self, s, ctx = None):
+        if ctx==None:
+            return self.nextTokensNoContext(s)
+        else:
+            return self.nextTokensInContext(s, ctx)
+
+    def addState(self, state):
+        if state is not None:
+            state.atn = self
+            state.stateNumber = len(self.states)
+        self.states.append(state)
+
+    def removeState(self, state):
+        self.states[state.stateNumber] = None # just free mem, don't shift states in list
+
+    def defineDecisionState(self, s):
+        self.decisionToState.append(s)
+        s.decision = len(self.decisionToState)-1
+        return s.decision
+
+    def getDecisionState(self, decision):
+        if len(self.decisionToState)==0:
+            return None
+        else:
+            return self.decisionToState[decision]
+
+    # Computes the set of input symbols which could follow ATN state number
+    # {@code stateNumber} in the specified full {@code context}. This method
+    # considers the complete parser context, but does not evaluate semantic
+    # predicates (i.e. all predicates encountered during the calculation are
+    # assumed true). If a path in the ATN exists from the starting state to the
+    # {@link RuleStopState} of the outermost context without matching any
+    # symbols, {@link Token#EOF} is added to the returned set.
+    #
+    # <p>If {@code context} is {@code null}, it is treated as
+    # {@link ParserRuleContext#EMPTY}.</p>
+    #
+    # @param stateNumber the ATN state number
+    # @param context the full parse context
+    # @return The set of potentially valid input symbols which could follow the
+    # specified state in the specified context.
+    # @throws IllegalArgumentException if the ATN does not contain a state with
+    # number {@code stateNumber}
+    #/
+    def getExpectedTokens(self, stateNumber, ctx ):
+        if stateNumber < 0 or stateNumber >= len(self.states):
+            raise Exception("Invalid state number.")
+        s = self.states[stateNumber]
+        following = self.nextTokens(s)
+        if Token.EPSILON not in following:
+            return following
+        expected = IntervalSet()
+        expected.addSet(following)
+        expected.removeOne(Token.EPSILON)
+        while (ctx != None and ctx.invokingState >= 0 and Token.EPSILON in following):
+            invokingState = self.states[ctx.invokingState]
+            rt = invokingState.transitions[0]
+            following = self.nextTokens(rt.followState)
+            expected.addSet(following)
+            expected.removeOne(Token.EPSILON)
+            ctx = ctx.parentCtx
+        if Token.EPSILON in following:
+            expected.addOne(Token.EOF)
+        return expected
\ No newline at end of file
diff --git a/runtime/Python2/src/antlr4/atn/ATNConfig.py b/runtime/Python2/src/antlr4/atn/ATNConfig.py
new file mode 100644
index 000000000..c8ffa8755
--- /dev/null
+++ b/runtime/Python2/src/antlr4/atn/ATNConfig.py
@@ -0,0 +1,149 @@
+#
+# [The "BSD license"]
+#  Copyright (c) 2012 Terence Parr
+#  Copyright (c) 2012 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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 tuple: (ATN state, predicted alt, syntactic, semantic context).
+#  The syntactic context is a graph-structured stack node whose
+#  path(s) to the root is the rule invocation(s)
+#  chain used to arrive at the state.  The semantic context is
+#  the tree of semantic predicates encountered before reaching
+#  an ATN state.
+#/
+from io import StringIO
+from antlr4.atn.ATNState import ATNState, DecisionState
+from antlr4.atn.SemanticContext import SemanticContext
+
+class ATNConfig(object):
+
+    def __init__(self, state=None, alt=None, context=None, semantic=None, config=None):
+        if config is not None:
+            if state is None:
+                state = config.state
+            if alt is None:
+                alt = config.alt
+            if context is None:
+                context = config.context
+            if semantic is None:
+                semantic = config.semanticContext
+        if semantic is None:
+            semantic = SemanticContext.NONE
+
+        # The ATN state associated with this configuration#/
+        self.state = state
+        # What alt (or lexer rule) is predicted by this configuration#/
+        self.alt = alt
+        # The stack of invoking states leading to the rule/states associated
+        #  with this config.  We track only those contexts pushed during
+        #  execution of the ATN simulator.
+        self.context = context
+        self.semanticContext = semantic
+        # We cannot execute predicates dependent upon local context unless
+        # we know for sure we are in the correct context. Because there is
+        # no way to do this efficiently, we simply cannot evaluate
+        # dependent predicates unless we are in the rule that initially
+        # invokes the ATN simulator.
+        #
+        # closure() tracks the depth of how far we dip into the
+        # outer context: depth &gt; 0.  Note that it may not be totally
+        # accurate depth since I don't ever decrement. TODO: make it a boolean then
+        self.reachesIntoOuterContext = 0 if config is None else config.reachesIntoOuterContext
+        self.precedenceFilterSuppressed = False if config is None else config.precedenceFilterSuppressed
+
+    # An ATN configuration is equal to another if both have
+    #  the same state, they predict the same alternative, and
+    #  syntactic/semantic contexts are the same.
+    #/
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, ATNConfig):
+            return False
+        else:
+            return self.state.stateNumber==other.state.stateNumber \
+                and self.alt==other.alt \
+                and ((self.context is other.context) or (self.context==other.context)) \
+                and self.semanticContext==other.semanticContext \
+                and self.precedenceFilterSuppressed==other.precedenceFilterSuppressed
+
+    def __hash__(self):
+        return hash((self.state.stateNumber, self.alt, self.context, self.semanticContext))
+
+    def __str__(self):
+        return unicode(self)
+
+    def __unicode__(self):
+        with StringIO() as buf:
+            buf.write(u"(")
+            buf.write(unicode(self.state))
+            buf.write(u",")
+            buf.write(unicode(self.alt))
+            if self.context is not None:
+                buf.write(u",[")
+                buf.write(unicode(self.context))
+                buf.write(u"]")
+            if self.semanticContext is not None and self.semanticContext is not SemanticContext.NONE:
+                buf.write(u",")
+                buf.write(unicode(self.semanticContext))
+            if self.reachesIntoOuterContext>0:
+                buf.write(u",up=")
+                buf.write(unicode(self.reachesIntoOuterContext))
+            buf.write(u')')
+            return buf.getvalue()
+
+class LexerATNConfig(ATNConfig):
+
+    def __init__(self, state, alt=None, context=None, semantic=SemanticContext.NONE, lexerActionExecutor=None, config=None):
+        super(LexerATNConfig, self).__init__(state=state, alt=alt, context=context, semantic=semantic, config=config)
+        if config is not None:
+            if lexerActionExecutor is None:
+                lexerActionExecutor = config.lexerActionExecutor
+        # This is the backing field for {@link #getLexerActionExecutor}.
+        self.lexerActionExecutor = lexerActionExecutor
+        self.passedThroughNonGreedyDecision = False if config is None else self.checkNonGreedyDecision(config, state)
+
+    def __hash__(self):
+        return hash((self.state.stateNumber, self.alt, self.context,
+                self.semanticContext, self.passedThroughNonGreedyDecision,
+                self.lexerActionExecutor))
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, LexerATNConfig):
+            return False
+        if self.passedThroughNonGreedyDecision != other.passedThroughNonGreedyDecision:
+            return False
+        if not(self.lexerActionExecutor==other.lexerActionExecutor):
+            return False
+        return super(LexerATNConfig, self).__eq__(other)
+
+    def checkNonGreedyDecision(self, source, target):
+        return source.passedThroughNonGreedyDecision \
+            or isinstance(target, DecisionState) and target.nonGreedy
diff --git a/runtime/Python2/src/antlr4/atn/ATNConfigSet.py b/runtime/Python2/src/antlr4/atn/ATNConfigSet.py
new file mode 100755
index 000000000..620902dff
--- /dev/null
+++ b/runtime/Python2/src/antlr4/atn/ATNConfigSet.py
@@ -0,0 +1,239 @@
+#
+# [The "BSD license"]
+#  Copyright (c) 2012 Terence Parr
+#  Copyright (c) 2012 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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.
+
+#
+# Specialized {@link Set}{@code <}{@link ATNConfig}{@code >} that can track
+# info about the set, with support for combining similar configurations using a
+# graph-structured stack.
+#/
+from io import StringIO
+from antlr4.PredictionContext import merge
+from antlr4.Utils import str_list
+from antlr4.atn.ATN import ATN
+from antlr4.atn.SemanticContext import SemanticContext
+from antlr4.error.Errors import UnsupportedOperationException, IllegalStateException
+
+class ATNConfigSet(object):
+    #
+    # The reason that we need this is because we don't want the hash map to use
+    # the standard hash code and equals. We need all configurations with the same
+    # {@code (s,i,_,semctx)} to be equal. Unfortunately, this key effectively doubles
+    # the number of objects associated with ATNConfigs. The other solution is to
+    # use a hash table that lets us specify the equals/hashcode operation.
+
+    def __init__(self, fullCtx=True):
+        # All configs but hashed by (s, i, _, pi) not including context. Wiped out
+        # when we go readonly as this set becomes a DFA state.
+        self.configLookup = dict()
+        # Indicates that this configuration set is part of a full context
+        #  LL prediction. It will be used to determine how to merge $. With SLL
+        #  it's a wildcard whereas it is not for LL context merge.
+        self.fullCtx = fullCtx
+        # Indicates that the set of configurations is read-only. Do not
+        #  allow any code to manipulate the set; DFA states will point at
+        #  the sets and they must not change. This does not protect the other
+        #  fields; in particular, conflictingAlts is set after
+        #  we've made this readonly.
+        self.readonly = False
+        # Track the elements as they are added to the set; supports get(i)#/
+        self.configs = []
+
+        # TODO: these fields make me pretty uncomfortable but nice to pack up info together, saves recomputation
+        # TODO: can we track conflicts as they are added to save scanning configs later?
+        self.uniqueAlt = 0
+        self.conflictingAlts = None
+
+        # Used in parser and lexer. In lexer, it indicates we hit a pred
+        # while computing a closure operation.  Don't make a DFA state from this.
+        self.hasSemanticContext = False
+        self.dipsIntoOuterContext = False
+
+        self.cachedHashCode = -1
+
+    def __iter__(self):
+        return self.configs.__iter__()
+
+    # Adding a new config means merging contexts with existing configs for
+    # {@code (s, i, pi, _)}, where {@code s} is the
+    # {@link ATNConfig#state}, {@code i} is the {@link ATNConfig#alt}, and
+    # {@code pi} is the {@link ATNConfig#semanticContext}. We use
+    # {@code (s,i,pi)} as key.
+    #
+    # <p>This method updates {@link #dipsIntoOuterContext} and
+    # {@link #hasSemanticContext} when necessary.</p>
+    #/
+    def add(self, config, mergeCache=None):
+        if self.readonly:
+            raise Exception("This set is readonly")
+        if config.semanticContext is not SemanticContext.NONE:
+            self.hasSemanticContext = True
+        if config.reachesIntoOuterContext > 0:
+            self.dipsIntoOuterContext = True
+        existing = self.getOrAdd(config)
+        if existing is config:
+            self.cachedHashCode = -1
+            self.configs.append(config)  # track order here
+            return True
+        # a previous (s,i,pi,_), merge with it and save result
+        rootIsWildcard = not self.fullCtx
+        merged = merge(existing.context, config.context, rootIsWildcard, mergeCache)
+        # no need to check for existing.context, config.context in cache
+        # since only way to create new graphs is "call rule" and here. We
+        # cache at both places.
+        existing.reachesIntoOuterContext = max(existing.reachesIntoOuterContext, config.reachesIntoOuterContext)
+        # make sure to preserve the precedence filter suppression during the merge
+        if config.precedenceFilterSuppressed:
+            existing.precedenceFilterSuppressed = True
+        existing.context = merged # replace context; no need to alt mapping
+        return True
+
+    def getOrAdd(self, config):
+        h = hash(config)
+        l = self.configLookup.get(h, None)
+        if l is not None:
+            for c in l:
+                if c==config:
+                    return c
+        if l is None:
+            l = [config]
+            self.configLookup[h] = l
+        else:
+            l.append(config)
+        return config
+
+    def getStates(self):
+        states = set()
+        for c in self.configs:
+            states.add(c.state)
+        return states
+
+    def getPredicates(self):
+        preds = list()
+        for c in self.configs:
+            if c.semanticContext!=SemanticContext.NONE:
+                preds.append(c.semanticContext)
+        return preds
+
+    def get(self, i):
+        return self.configs[i]
+
+    def optimizeConfigs(self, interpreter):
+        if self.readonly:
+            raise IllegalStateException("This set is readonly")
+        if len(self.configs)==0:
+            return
+        for config in self.configs:
+            config.context = interpreter.getCachedContext(config.context)
+
+    def addAll(self, coll):
+        for c in coll:
+            self.add(c)
+        return False
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, ATNConfigSet):
+            return False
+
+        same = self.configs is not None and \
+            self.configs == other.configs and \
+            self.fullCtx == other.fullCtx and \
+            self.uniqueAlt == other.uniqueAlt and \
+            self.conflictingAlts == other.conflictingAlts and \
+            self.hasSemanticContext == other.hasSemanticContext and \
+            self.dipsIntoOuterContext == other.dipsIntoOuterContext
+
+        return same
+
+    def __hash__(self):
+        if self.readonly:
+            if self.cachedHashCode == -1:
+                self.cachedHashCode = self.hashConfigs()
+            return self.cachedHashCode
+        return self.hashConfigs()
+
+    def hashConfigs(self):
+        h = 0
+        for cfg in self.configs:
+            h = hash((h, cfg))
+        return h
+
+    def __len__(self):
+        return len(self.configs)
+
+    def isEmpty(self):
+        return len(self.configs)==0
+
+    def __contains__(self, config):
+        if self.configLookup is None:
+            raise UnsupportedOperationException("This method is not implemented for readonly sets.")
+        h = hash(config)
+        l = self.configLookup.get(h, None)
+        return l is not None and config in l
+
+    def clear(self):
+        if self.readonly:
+            raise IllegalStateException("This set is readonly")
+        self.configs.clear()
+        self.cachedHashCode = -1
+        self.configLookup.clear()
+
+    def setReadonly(self, readonly):
+        self.readonly = readonly
+        self.configLookup = None # can't mod, no need for lookup cache
+
+    def __str__(self):
+        return unicode(self)
+
+    def __unicode__(self):
+        with StringIO() as buf:
+            buf.write(str_list(self.configs))
+            if self.hasSemanticContext:
+                buf.write(u",hasSemanticContext=")
+                buf.write(unicode(self.hasSemanticContext))
+            if self.uniqueAlt!=ATN.INVALID_ALT_NUMBER:
+                buf.write(u",uniqueAlt=")
+                buf.write(unicode(self.uniqueAlt))
+            if self.conflictingAlts is not None:
+                buf.write(u",conflictingAlts=")
+                buf.write(unicode(self.conflictingAlts))
+            if self.dipsIntoOuterContext:
+                buf.write(u",dipsIntoOuterContext")
+            return buf.getvalue()
+
+
+class OrderedATNConfigSet(ATNConfigSet):
+
+    def __init__(self):
+        super(OrderedATNConfigSet, self).__init__()
+
+
+
diff --git a/runtime/Python2/src/antlr4/atn/ATNDeserializationOptions.py b/runtime/Python2/src/antlr4/atn/ATNDeserializationOptions.py
new file mode 100644
index 000000000..5cf432991
--- /dev/null
+++ b/runtime/Python2/src/antlr4/atn/ATNDeserializationOptions.py
@@ -0,0 +1,46 @@
+#[The "BSD license"]
+# Copyright (c) 2013 Terence Parr
+# Copyright (c) 2013 Sam Harwell
+# Copyright (c) 2014 Eric Vergnaud
+# 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.
+
+class ATNDeserializationOptions(object):
+
+    defaultOptions = None
+
+    def __init__(self, copyFrom = None):
+        self.readOnly = False
+        self.verifyATN = True if copyFrom is None else copyFrom.verifyATN
+        self.generateRuleBypassTransitions = False if copyFrom is None else copyFrom.generateRuleBypassTransitions
+
+    def __setattr__(self, key, value):
+        if key!="readOnly" and self.readOnly:
+            raise Exception("The object is read only.")
+        super(type(self), self).__setattr__(key,value)
+
+ATNDeserializationOptions.defaultOptions = ATNDeserializationOptions()
+ATNDeserializationOptions.defaultOptions.readOnly = True
+
diff --git a/runtime/Python2/src/antlr4/atn/ATNDeserializer.py b/runtime/Python2/src/antlr4/atn/ATNDeserializer.py
new file mode 100644
index 000000000..8745806be
--- /dev/null
+++ b/runtime/Python2/src/antlr4/atn/ATNDeserializer.py
@@ -0,0 +1,540 @@
+# [The "BSD license"]
+#  Copyright (c) 2013 Terence Parr
+#  Copyright (c) 2013 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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.
+#/
+from uuid import UUID
+from antlr4.atn.ATN import ATN
+from antlr4.atn.ATNType import ATNType
+from antlr4.atn.ATNState import *
+from antlr4.atn.Transition import *
+from antlr4.atn.LexerAction import *
+from antlr4.atn.ATNDeserializationOptions import ATNDeserializationOptions
+
+# This is the earliest supported serialized UUID.
+BASE_SERIALIZED_UUID = UUID("AADB8D7E-AEEF-4415-AD2B-8204D6CF042E")
+
+# This list contains all of the currently supported UUIDs, ordered by when
+# the feature first appeared in this branch.
+SUPPORTED_UUIDS = [ BASE_SERIALIZED_UUID ]
+
+SERIALIZED_VERSION = 3
+
+# This is the current serialized UUID.
+SERIALIZED_UUID = BASE_SERIALIZED_UUID
+
+class ATNDeserializer (object):
+
+    def __init__(self, options = None):
+        if options is None:
+            options = ATNDeserializationOptions.defaultOptions
+        self.deserializationOptions = options
+        self.edgeFactories = None
+        self.stateFactories = None
+        self.actionFactories = None
+
+    # Determines if a particular serialized representation of an ATN supports
+    # a particular feature, identified by the {@link UUID} used for serializing
+    # the ATN at the time the feature was first introduced.
+    #
+    # @param feature The {@link UUID} marking the first time the feature was
+    # supported in the serialized ATN.
+    # @param actualUuid The {@link UUID} of the actual serialized ATN which is
+    # currently being deserialized.
+    # @return {@code true} if the {@code actualUuid} value represents a
+    # serialized ATN at or after the feature identified by {@code feature} was
+    # introduced; otherwise, {@code false}.
+
+    def isFeatureSupported(self, feature, actualUuid):
+        idx1 = SUPPORTED_UUIDS.index(feature)
+        if idx1<0:
+            return False
+        idx2 = SUPPORTED_UUIDS.index(actualUuid)
+        return idx2 >= idx1
+
+    def deserialize(self, data):
+        self.reset(data)
+        self.checkVersion()
+        self.checkUUID()
+        atn = self.readATN()
+        self.readStates(atn)
+        self.readRules(atn)
+        self.readModes(atn)
+        sets = self.readSets(atn)
+        self.readEdges(atn, sets)
+        self.readDecisions(atn)
+        self.readLexerActions(atn)
+        self.markPrecedenceDecisions(atn)
+        self.verifyATN(atn)
+        if self.deserializationOptions.generateRuleBypassTransitions \
+                and atn.grammarType == ATNType.PARSER:
+            self.generateRuleBypassTransitions(atn)
+            # re-verify after modification
+            self.verifyATN(atn)
+        return atn
+
+    def reset(self, data):
+        def adjust(c):
+            v = ord(c)
+            return v-2 if v>1 else -1
+        temp = [ adjust(c) for c in data ]
+        # don't adjust the first value since that's the version number
+        temp[0] = ord(data[0])
+        self.data = temp
+        self.pos = 0
+
+    def checkVersion(self):
+        version = self.readInt()
+        if version != SERIALIZED_VERSION:
+            raise Exception("Could not deserialize ATN with version " + str(version) + " (expected " + str(SERIALIZED_VERSION) + ").")
+
+    def checkUUID(self):
+        uuid = self.readUUID()
+        if not uuid in SUPPORTED_UUIDS:
+            raise Exception("Could not deserialize ATN with UUID: " + str(uuid) + \
+                            " (expected " + str(SERIALIZED_UUID) + " or a legacy UUID).", uuid, SERIALIZED_UUID)
+        self.uuid = uuid
+
+    def readATN(self):
+        grammarType = self.readInt()
+        maxTokenType = self.readInt()
+        return ATN(grammarType, maxTokenType)
+
+    def readStates(self, atn):
+        loopBackStateNumbers = []
+        endStateNumbers = []
+        nstates = self.readInt()
+        for i in range(0, nstates):
+            stype = self.readInt()
+            # ignore bad type of states
+            if stype==ATNState.INVALID_TYPE:
+                atn.addState(None)
+                continue
+            ruleIndex = self.readInt()
+            if ruleIndex == 0xFFFF:
+                ruleIndex = -1
+
+            s = self.stateFactory(stype, ruleIndex)
+            if stype == ATNState.LOOP_END: # special case
+                loopBackStateNumber = self.readInt()
+                loopBackStateNumbers.append((s, loopBackStateNumber))
+            elif isinstance(s, BlockStartState):
+                endStateNumber = self.readInt()
+                endStateNumbers.append((s, endStateNumber))
+
+            atn.addState(s)
+
+        # delay the assignment of loop back and end states until we know all the state instances have been initialized
+        for pair in loopBackStateNumbers:
+            pair[0].loopBackState = atn.states[pair[1]]
+
+        for pair in endStateNumbers:
+            pair[0].endState = atn.states[pair[1]]
+
+        numNonGreedyStates = self.readInt()
+        for i in range(0, numNonGreedyStates):
+            stateNumber = self.readInt()
+            atn.states[stateNumber].nonGreedy = True
+
+        numPrecedenceStates = self.readInt()
+        for i in range(0, numPrecedenceStates):
+            stateNumber = self.readInt()
+            atn.states[stateNumber].isPrecedenceRule = True
+            
+    def readRules(self, atn):        
+        nrules = self.readInt()
+        if atn.grammarType == ATNType.LEXER:
+            atn.ruleToTokenType = [0] * nrules
+
+        atn.ruleToStartState = [0] * nrules
+        for i in range(0, nrules):
+            s = self.readInt()
+            startState = atn.states[s]
+            atn.ruleToStartState[i] = startState
+            if atn.grammarType == ATNType.LEXER:
+                tokenType = self.readInt()
+                if tokenType == 0xFFFF:
+                    tokenType = Token.EOF
+
+                atn.ruleToTokenType[i] = tokenType
+
+        atn.ruleToStopState = [0] * nrules
+        for state in atn.states:
+            if not isinstance(state, RuleStopState):
+                continue
+            atn.ruleToStopState[state.ruleIndex] = state
+            atn.ruleToStartState[state.ruleIndex].stopState = state
+
+    def readModes(self, atn):
+        nmodes = self.readInt()
+        for i in range(0, nmodes):
+            s = self.readInt()
+            atn.modeToStartState.append(atn.states[s])
+
+    def readSets(self, atn):
+        sets = []
+        m = self.readInt()
+        for i in range(0, m):
+            iset = IntervalSet()
+            sets.append(iset)
+            n = self.readInt()
+            containsEof = self.readInt()
+            if containsEof!=0:
+                iset.addOne(-1)
+            for j in range(0, n):
+                i1 = self.readInt()
+                i2 = self.readInt()
+                iset.addRange(Interval(i1, i2 + 1)) # range upper limit is exclusive
+        return sets
+
+    def readEdges(self, atn, sets):
+        nedges = self.readInt()
+        for i in range(0, nedges):
+            src = self.readInt()
+            trg = self.readInt()
+            ttype = self.readInt()
+            arg1 = self.readInt()
+            arg2 = self.readInt()
+            arg3 = self.readInt()
+            trans = self.edgeFactory(atn, ttype, src, trg, arg1, arg2, arg3, sets)
+            srcState = atn.states[src]
+            srcState.addTransition(trans)
+
+        # edges for rule stop states can be derived, so they aren't serialized
+        for state in atn.states:
+            for i in range(0, len(state.transitions)):
+                t = state.transitions[i]
+                if not isinstance(t, RuleTransition):
+                    continue
+                outermostPrecedenceReturn = -1
+                if atn.ruleToStartState[t.target.ruleIndex].isPrecedenceRule:
+                    if t.precedence == 0:
+                        outermostPrecedenceReturn = t.target.ruleIndex
+                trans = EpsilonTransition(t.followState, outermostPrecedenceReturn)
+                atn.ruleToStopState[t.target.ruleIndex].addTransition(trans)
+
+        for state in atn.states:
+            if isinstance(state, BlockStartState):
+                # we need to know the end state to set its start state
+                if state.endState is None:
+                    raise Exception("IllegalState")
+                # block end states can only be associated to a single block start state
+                if state.endState.startState is not None:
+                    raise Exception("IllegalState")
+                state.endState.startState = state
+
+            elif isinstance(state, PlusLoopbackState):
+                for i in range(0, len(state.transitions)):
+                    target = state.transitions[i].target
+                    if isinstance(target, PlusBlockStartState):
+                        target.loopBackState = state
+            elif isinstance(state, StarLoopbackState):
+                for i in range(0, len(state.transitions)):
+                    target = state.transitions[i].target
+                    if isinstance(target, StarLoopEntryState):
+                        target.loopBackState = state
+
+    def readDecisions(self, atn):
+        ndecisions = self.readInt()
+        for i in range(0, ndecisions):
+            s = self.readInt()
+            decState = atn.states[s]
+            atn.decisionToState.append(decState)
+            decState.decision = i
+
+    def readLexerActions(self, atn):
+        if atn.grammarType == ATNType.LEXER:
+            count = self.readInt()
+            atn.lexerActions = [ None ] * count
+            for i in range(0, count):
+                actionType = self.readInt()
+                data1 = self.readInt()
+                if data1 == 0xFFFF:
+                    data1 = -1
+                data2 = self.readInt()
+                if data2 == 0xFFFF:
+                    data2 = -1
+                lexerAction = self.lexerActionFactory(actionType, data1, data2)
+                atn.lexerActions[i] = lexerAction
+
+    def generateRuleBypassTransitions(self, atn):
+
+        count = len(atn.ruleToStartState)
+        atn.ruleToTokenType = [ 0 ] * count
+        for i in range(0, count):
+            atn.ruleToTokenType[i] = atn.maxTokenType + i + 1
+
+        for i in range(0, count):
+            self.generateRuleBypassTransition(atn, i)
+
+    def generateRuleBypassTransition(self, atn, idx):
+
+        bypassStart = BasicBlockStartState()
+        bypassStart.ruleIndex = idx
+        atn.addState(bypassStart)
+
+        bypassStop = BlockEndState()
+        bypassStop.ruleIndex = idx
+        atn.addState(bypassStop)
+
+        bypassStart.endState = bypassStop
+        atn.defineDecisionState(bypassStart)
+
+        bypassStop.startState = bypassStart
+
+        excludeTransition = None
+
+        if atn.ruleToStartState[idx].isPrecedenceRule:
+            # wrap from the beginning of the rule to the StarLoopEntryState
+            endState = None
+            for state in atn.states:
+                if self.stateIsEndStateFor(state, idx):
+                    endState = state
+                    excludeTransition = state.loopBackState.transitions[0]
+                    break
+
+            if excludeTransition is None:
+                raise Exception("Couldn't identify final state of the precedence rule prefix section.")
+
+        else:
+
+            endState = atn.ruleToStopState[idx]
+
+        # all non-excluded transitions that currently target end state need to target blockEnd instead
+        for state in atn.states:
+            for transition in state.transitions:
+                if transition == excludeTransition:
+                    continue
+                if transition.target == endState:
+                    transition.target = bypassStop
+
+        # all transitions leaving the rule start state need to leave blockStart instead
+        ruleToStartState = atn.ruleToStartState[idx]
+        count = len(ruleToStartState.transitions)
+        while count > 0:
+            bypassStart.addTransition(ruleToStartState.transitions[count-1])
+            del ruleToStartState.transitions[-1]
+
+        # link the new states
+        atn.ruleToStartState[idx].addTransition(EpsilonTransition(bypassStart))
+        bypassStop.addTransition(EpsilonTransition(endState))
+
+        matchState = BasicState()
+        atn.addState(matchState)
+        matchState.addTransition(AtomTransition(bypassStop, atn.ruleToTokenType[idx]))
+        bypassStart.addTransition(EpsilonTransition(matchState))
+
+
+    def stateIsEndStateFor(self, state, idx):
+        if state.ruleIndex != idx:
+            return None
+        if not isinstance(state, StarLoopEntryState):
+            return None
+
+        maybeLoopEndState = state.transitions[len(state.transitions) - 1].target
+        if not isinstance(maybeLoopEndState, LoopEndState):
+            return None
+
+        if maybeLoopEndState.epsilonOnlyTransitions and \
+                isinstance(maybeLoopEndState.transitions[0].target, RuleStopState):
+            return state
+        else:
+            return None
+
+
+    #
+    # Analyze the {@link StarLoopEntryState} states in the specified ATN to set
+    # the {@link StarLoopEntryState#precedenceRuleDecision} field to the
+    # correct value.
+    #
+    # @param atn The ATN.
+    #
+    def markPrecedenceDecisions(self, atn):
+        for state in atn.states:
+            if not isinstance(state, StarLoopEntryState):
+                continue
+
+            # We analyze the ATN to determine if this ATN decision state is the
+            # decision for the closure block that determines whether a
+            # precedence rule should continue or complete.
+            #
+            if atn.ruleToStartState[state.ruleIndex].isPrecedenceRule:
+                maybeLoopEndState = state.transitions[len(state.transitions) - 1].target
+                if isinstance(maybeLoopEndState, LoopEndState):
+                    if maybeLoopEndState.epsilonOnlyTransitions and \
+                            isinstance(maybeLoopEndState.transitions[0].target, RuleStopState):
+                        state.precedenceRuleDecision = True
+
+    def verifyATN(self, atn):
+        if not self.deserializationOptions.verifyATN:
+            return
+        # verify assumptions
+        for state in atn.states:
+            if state is None:
+                continue
+
+            self.checkCondition(state.epsilonOnlyTransitions or len(state.transitions) <= 1)
+
+            if isinstance(state, PlusBlockStartState):
+                self.checkCondition(state.loopBackState is not None)
+
+            if isinstance(state, StarLoopEntryState):
+                self.checkCondition(state.loopBackState is not None)
+                self.checkCondition(len(state.transitions) == 2)
+
+                if isinstance(state.transitions[0].target, StarBlockStartState):
+                    self.checkCondition(isinstance(state.transitions[1].target, LoopEndState))
+                    self.checkCondition(not state.nonGreedy)
+                elif isinstance(state.transitions[0].target, LoopEndState):
+                    self.checkCondition(isinstance(state.transitions[1].target, StarBlockStartState))
+                    self.checkCondition(state.nonGreedy)
+                else:
+                    raise Exception("IllegalState")
+
+            if isinstance(state, StarLoopbackState):
+                self.checkCondition(len(state.transitions) == 1)
+                self.checkCondition(isinstance(state.transitions[0].target, StarLoopEntryState))
+
+            if isinstance(state, LoopEndState):
+                self.checkCondition(state.loopBackState is not None)
+
+            if isinstance(state, RuleStartState):
+                self.checkCondition(state.stopState is not None)
+
+            if isinstance(state, BlockStartState):
+                self.checkCondition(state.endState is not None)
+
+            if isinstance(state, BlockEndState):
+                self.checkCondition(state.startState is not None)
+
+            if isinstance(state, DecisionState):
+                self.checkCondition(len(state.transitions) <= 1 or state.decision >= 0)
+            else:
+                self.checkCondition(len(state.transitions) <= 1 or isinstance(state, RuleStopState))
+
+    def checkCondition(self, condition, message=None):
+        if not condition:
+            if message is None:
+                message = "IllegalState"
+            raise Exception(message)
+
+    def readInt(self):
+        i = self.data[self.pos]
+        self.pos += 1
+        return i
+
+    def readInt32(self):
+        low = self.readInt()
+        high = self.readInt()
+        return low | (high << 16)
+
+    def readLong(self):
+        low = self.readInt32()
+        high = self.readInt32()
+        return (low & 0x00000000FFFFFFFF) | (high << 32)
+
+    def readUUID(self):
+        low = self.readLong()
+        high = self.readLong()
+        allBits = (low & 0xFFFFFFFFFFFFFFFF) | (high << 64)
+        return UUID(int=allBits)
+
+    def edgeFactory(self, atn, type, src, trg, arg1, arg2, arg3, sets):
+        target = atn.states[trg]
+        if self.edgeFactories is None:
+            ef = [None] * 11
+            ef[0] = lambda args : None
+            ef[Transition.EPSILON] = lambda atn, src, trg, arg1, arg2, arg3, sets, target : \
+                EpsilonTransition(target)
+            ef[Transition.RANGE] = lambda atn, src, trg, arg1, arg2, arg3, sets, target : \
+                RangeTransition(target, Token.EOF, arg2) if arg3 != 0 else RangeTransition(target, arg1, arg2)
+            ef[Transition.RULE] = lambda atn, src, trg, arg1, arg2, arg3, sets, target : \
+                RuleTransition(atn.states[arg1], arg2, arg3, target)
+            ef[Transition.PREDICATE] = lambda atn, src, trg, arg1, arg2, arg3, sets, target : \
+                PredicateTransition(target, arg1, arg2, arg3 != 0)
+            ef[Transition.PRECEDENCE] = lambda atn, src, trg, arg1, arg2, arg3, sets, target : \
+                PrecedencePredicateTransition(target, arg1)
+            ef[Transition.ATOM] = lambda atn, src, trg, arg1, arg2, arg3, sets, target : \
+                AtomTransition(target, Token.EOF) if arg3 != 0 else AtomTransition(target, arg1)
+            ef[Transition.ACTION] = lambda atn, src, trg, arg1, arg2, arg3, sets, target : \
+                ActionTransition(target, arg1, arg2, arg3 != 0)
+            ef[Transition.SET] = lambda atn, src, trg, arg1, arg2, arg3, sets, target : \
+                SetTransition(target, sets[arg1])
+            ef[Transition.NOT_SET] = lambda atn, src, trg, arg1, arg2, arg3, sets, target : \
+                NotSetTransition(target, sets[arg1])
+            ef[Transition.WILDCARD] = lambda atn, src, trg, arg1, arg2, arg3, sets, target : \
+                WildcardTransition(target)
+            self.edgeFactories = ef
+
+        if type> len(self.edgeFactories) or self.edgeFactories[type] is None:
+            raise Exception("The specified transition type: " + str(type) + " is not valid.")
+        else:
+            return self.edgeFactories[type](atn, src, trg, arg1, arg2, arg3, sets, target)
+
+    def stateFactory(self, type, ruleIndex):
+        if self.stateFactories is None:
+            sf = [None] * 13
+            sf[ATNState.INVALID_TYPE] = lambda : None
+            sf[ATNState.BASIC] = lambda : BasicState()
+            sf[ATNState.RULE_START] = lambda : RuleStartState()
+            sf[ATNState.BLOCK_START] = lambda : BasicBlockStartState()
+            sf[ATNState.PLUS_BLOCK_START] = lambda : PlusBlockStartState()
+            sf[ATNState.STAR_BLOCK_START] = lambda : StarBlockStartState()
+            sf[ATNState.TOKEN_START] = lambda : TokensStartState()
+            sf[ATNState.RULE_STOP] = lambda : RuleStopState()
+            sf[ATNState.BLOCK_END] = lambda : BlockEndState()
+            sf[ATNState.STAR_LOOP_BACK] = lambda : StarLoopbackState()
+            sf[ATNState.STAR_LOOP_ENTRY] = lambda : StarLoopEntryState()
+            sf[ATNState.PLUS_LOOP_BACK] = lambda : PlusLoopbackState()
+            sf[ATNState.LOOP_END] = lambda : LoopEndState()
+            self.stateFactories = sf
+
+        if type> len(self.stateFactories) or self.stateFactories[type] is None:
+            raise Exception("The specified state type " + str(type) + " is not valid.")
+        else:
+            s = self.stateFactories[type]()
+            if s is not None:
+                s.ruleIndex = ruleIndex
+            return s
+
+    def lexerActionFactory(self, type, data1, data2):
+        if self.actionFactories is None:
+            af = [ None ] * 8
+            af[LexerActionType.CHANNEL] = lambda data1, data2: LexerChannelAction(data1)
+            af[LexerActionType.CUSTOM] = lambda data1, data2: LexerCustomAction(data1, data2)
+            af[LexerActionType.MODE] = lambda data1, data2: LexerModeAction(data1)
+            af[LexerActionType.MORE] = lambda data1, data2: LexerMoreAction.INSTANCE
+            af[LexerActionType.POP_MODE] = lambda data1, data2: LexerPopModeAction.INSTANCE
+            af[LexerActionType.PUSH_MODE] = lambda data1, data2: LexerPushModeAction(data1)
+            af[LexerActionType.SKIP] = lambda data1, data2: LexerSkipAction.INSTANCE
+            af[LexerActionType.TYPE] = lambda data1, data2: LexerTypeAction(data1)
+            self.actionFactories = af
+
+        if type> len(self.actionFactories) or self.actionFactories[type] is None:
+            raise Exception("The specified lexer action type " + str(type) + " is not valid.")
+        else:
+            return self.actionFactories[type](data1, data2)
diff --git a/runtime/Python2/src/antlr4/atn/ATNSimulator.py b/runtime/Python2/src/antlr4/atn/ATNSimulator.py
new file mode 100644
index 000000000..a02de0cbf
--- /dev/null
+++ b/runtime/Python2/src/antlr4/atn/ATNSimulator.py
@@ -0,0 +1,70 @@
+#
+# [The "BSD license"]
+#  Copyright (c) 2013 Terence Parr
+#  Copyright (c) 2013 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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.
+#/
+from antlr4.PredictionContext import getCachedPredictionContext
+from antlr4.atn.ATNConfigSet import ATNConfigSet
+from antlr4.dfa.DFAState import DFAState
+
+
+class ATNSimulator(object):
+
+    # Must distinguish between missing edge and edge we know leads nowhere#/
+    ERROR = DFAState(0x7FFFFFFF, ATNConfigSet())
+ 
+    # The context cache maps all PredictionContext objects that are ==
+    #  to a single cached copy. This cache is shared across all contexts
+    #  in all ATNConfigs in all DFA states.  We rebuild each ATNConfigSet
+    #  to use only cached nodes/graphs in addDFAState(). We don't want to
+    #  fill this during closure() since there are lots of contexts that
+    #  pop up but are not used ever again. It also greatly slows down closure().
+    #
+    #  <p>This cache makes a huge difference in memory and a little bit in speed.
+    #  For the Java grammar on java.*, it dropped the memory requirements
+    #  at the end from 25M to 16M. We don't store any of the full context
+    #  graphs in the DFA because they are limited to local context only,
+    #  but apparently there's a lot of repetition there as well. We optimize
+    #  the config contexts before storing the config set in the DFA states
+    #  by literally rebuilding them with cached subgraphs only.</p>
+    #
+    #  <p>I tried a cache for use during closure operations, that was
+    #  whacked after each adaptivePredict(). It cost a little bit
+    #  more time I think and doesn't save on the overall footprint
+    #  so it's not worth the complexity.</p>
+    #/
+    def __init__(self, atn, sharedContextCache):
+        self.atn = atn
+        self.sharedContextCache = sharedContextCache
+
+    def getCachedContext(self, context):
+        if self.sharedContextCache is None:
+            return context
+        visited = dict()
+        return getCachedPredictionContext(context, self.sharedContextCache, visited)
+
diff --git a/runtime/Python2/src/antlr4/atn/ATNState.py b/runtime/Python2/src/antlr4/atn/ATNState.py
new file mode 100644
index 000000000..36b8d92f3
--- /dev/null
+++ b/runtime/Python2/src/antlr4/atn/ATNState.py
@@ -0,0 +1,283 @@
+#
+# [The "BSD license"]
+#  Copyright (c) 2012 Terence Parr
+#  Copyright (c) 2012 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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.
+#
+
+# The following images show the relation of states and
+# {@link ATNState#transitions} for various grammar constructs.
+#
+# <ul>
+#
+# <li>Solid edges marked with an &#0949; indicate a required
+# {@link EpsilonTransition}.</li>
+#
+# <li>Dashed edges indicate locations where any transition derived from
+# {@link Transition} might appear.</li>
+#
+# <li>Dashed nodes are place holders for either a sequence of linked
+# {@link BasicState} states or the inclusion of a block representing a nested
+# construct in one of the forms below.</li>
+#
+# <li>Nodes showing multiple outgoing alternatives with a {@code ...} support
+# any number of alternatives (one or more). Nodes without the {@code ...} only
+# support the exact number of alternatives shown in the diagram.</li>
+#
+# </ul>
+#
+# <h2>Basic Blocks</h2>
+#
+# <h3>Rule</h3>
+#
+# <embed src="images/Rule.svg" type="image/svg+xml"/>
+#
+# <h3>Block of 1 or more alternatives</h3>
+#
+# <embed src="images/Block.svg" type="image/svg+xml"/>
+#
+# <h2>Greedy Loops</h2>
+#
+# <h3>Greedy Closure: {@code (...)*}</h3>
+#
+# <embed src="images/ClosureGreedy.svg" type="image/svg+xml"/>
+#
+# <h3>Greedy Positive Closure: {@code (...)+}</h3>
+#
+# <embed src="images/PositiveClosureGreedy.svg" type="image/svg+xml"/>
+#
+# <h3>Greedy Optional: {@code (...)?}</h3>
+#
+# <embed src="images/OptionalGreedy.svg" type="image/svg+xml"/>
+#
+# <h2>Non-Greedy Loops</h2>
+#
+# <h3>Non-Greedy Closure: {@code (...)*?}</h3>
+#
+# <embed src="images/ClosureNonGreedy.svg" type="image/svg+xml"/>
+#
+# <h3>Non-Greedy Positive Closure: {@code (...)+?}</h3>
+#
+# <embed src="images/PositiveClosureNonGreedy.svg" type="image/svg+xml"/>
+#
+# <h3>Non-Greedy Optional: {@code (...)??}</h3>
+#
+# <embed src="images/OptionalNonGreedy.svg" type="image/svg+xml"/>
+#
+
+INITIAL_NUM_TRANSITIONS = 4
+
+class ATNState(object):
+
+    # constants for serialization
+    INVALID_TYPE = 0
+    BASIC = 1
+    RULE_START = 2
+    BLOCK_START = 3
+    PLUS_BLOCK_START = 4
+    STAR_BLOCK_START = 5
+    TOKEN_START = 6
+    RULE_STOP = 7
+    BLOCK_END = 8
+    STAR_LOOP_BACK = 9
+    STAR_LOOP_ENTRY = 10
+    PLUS_LOOP_BACK = 11
+    LOOP_END = 12
+
+    serializationNames = [
+            "INVALID",
+            "BASIC",
+            "RULE_START",
+            "BLOCK_START",
+            "PLUS_BLOCK_START",
+            "STAR_BLOCK_START",
+            "TOKEN_START",
+            "RULE_STOP",
+            "BLOCK_END",
+            "STAR_LOOP_BACK",
+            "STAR_LOOP_ENTRY",
+            "PLUS_LOOP_BACK",
+            "LOOP_END" ]
+
+    INVALID_STATE_NUMBER = -1
+
+    def __init__(self):
+        # Which ATN are we in?
+        self.atn = None
+        self.stateNumber = ATNState.INVALID_STATE_NUMBER
+        self.stateType = None
+        self.ruleIndex = 0 # at runtime, we don't have Rule objects
+        self.epsilonOnlyTransitions = False
+        # Track the transitions emanating from this ATN state.
+        self.transitions = []
+        # Used to cache lookahead during parsing, not used during construction
+        self.nextTokenWithinRule = None
+
+    def __hash__(self):
+        return self.stateNumber
+
+    def __eq__(self, other):
+        if isinstance(other, ATNState):
+            return self.stateNumber==other.stateNumber
+        else:
+            return False
+
+    def onlyHasEpsilonTransitions(self):
+        return self.epsilonOnlyTransitions
+
+    def isNonGreedyExitState(self):
+        return False
+
+    def __str__(self):
+        return unicode(self)
+
+    def __unicode__(self):
+        return unicode(self.stateNumber)
+
+    def addTransition(self, trans, index=-1):
+        if len(self.transitions)==0:
+            self.epsilonOnlyTransitions = trans.isEpsilon
+        elif self.epsilonOnlyTransitions != trans.isEpsilon:
+            self.epsilonOnlyTransitions = False
+            # TODO System.err.format(Locale.getDefault(), "ATN state %d has both epsilon and non-epsilon transitions.\n", stateNumber);
+        if index==-1:
+            self.transitions.append(trans)
+        else:
+            self.transitions.insert(index, trans)
+
+class BasicState(ATNState):
+
+    def __init__(self):
+        super(BasicState, self).__init__()
+        self.stateType = self.BASIC
+
+
+class DecisionState(ATNState):
+
+    def __init__(self):
+        super(DecisionState, self).__init__()
+        self.decision = -1
+        self.nonGreedy = False
+
+#  The start of a regular {@code (...)} block.
+class BlockStartState(DecisionState):
+
+    def __init__(self):
+        super(BlockStartState, self).__init__()
+        self.endState = None
+
+class BasicBlockStartState(BlockStartState):
+
+    def __init__(self):
+        super(BasicBlockStartState, self).__init__()
+        self.stateType = self.BLOCK_START
+
+# Terminal node of a simple {@code (a|b|c)} block.
+class BlockEndState(ATNState):
+
+    def __init__(self):
+        super(BlockEndState, self).__init__()
+        self.stateType = self.BLOCK_END
+        self.startState = None
+
+# The last node in the ATN for a rule, unless that rule is the start symbol.
+#  In that case, there is one transition to EOF. Later, we might encode
+#  references to all calls to this rule to compute FOLLOW sets for
+#  error handling.
+#
+class RuleStopState(ATNState):
+
+    def __init__(self):
+        super(RuleStopState, self).__init__()
+        self.stateType = self.RULE_STOP
+
+class RuleStartState(ATNState):
+
+    def __init__(self):
+        super(RuleStartState, self).__init__()
+        self.stateType = self.RULE_START
+        self.stopState = None
+        self.isPrecedenceRule = False
+
+# Decision state for {@code A+} and {@code (A|B)+}.  It has two transitions:
+#  one to the loop back to start of the block and one to exit.
+#
+class PlusLoopbackState(DecisionState):
+
+    def __init__(self):
+        super(PlusLoopbackState, self).__init__()
+        self.stateType = self.PLUS_LOOP_BACK
+
+# Start of {@code (A|B|...)+} loop. Technically a decision state, but
+#  we don't use for code generation; somebody might need it, so I'm defining
+#  it for completeness. In reality, the {@link PlusLoopbackState} node is the
+#  real decision-making note for {@code A+}.
+#
+class PlusBlockStartState(BlockStartState):
+
+    def __init__(self):
+        super(PlusBlockStartState, self).__init__()
+        self.stateType = self.PLUS_BLOCK_START
+        self.loopBackState = None
+
+# The block that begins a closure loop.
+class StarBlockStartState(BlockStartState):
+
+    def __init__(self):
+        super(StarBlockStartState, self).__init__()
+        self.stateType = self.STAR_BLOCK_START
+
+class StarLoopbackState(ATNState):
+
+    def __init__(self):
+        super(StarLoopbackState, self).__init__()
+        self.stateType = self.STAR_LOOP_BACK
+
+
+class StarLoopEntryState(DecisionState):
+
+    def __init__(self):
+        super(StarLoopEntryState, self).__init__()
+        self.stateType = self.STAR_LOOP_ENTRY
+        self.loopBackState = None
+        # Indicates whether this state can benefit from a precedence DFA during SLL decision making.
+        self.precedenceRuleDecision = None
+
+# Mark the end of a * or + loop.
+class LoopEndState(ATNState):
+
+    def __init__(self):
+        super(LoopEndState, self).__init__()
+        self.stateType = self.LOOP_END
+        self.loopBackState = None
+
+# The Tokens rule start state linking to each lexer rule start state */
+class TokensStartState(DecisionState):
+
+    def __init__(self):
+        super(TokensStartState, self).__init__()
+        self.stateType = self.TOKEN_START
diff --git a/runtime/Python2/src/antlr4/atn/ATNType.py b/runtime/Python2/src/antlr4/atn/ATNType.py
new file mode 100644
index 000000000..b351b18d1
--- /dev/null
+++ b/runtime/Python2/src/antlr4/atn/ATNType.py
@@ -0,0 +1,37 @@
+# [The "BSD license"]
+#  Copyright (c) 2013 Terence Parr
+#  Copyright (c) 2013 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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.
+#/
+
+# Represents the type of recognizer an ATN applies to.
+
+class ATNType(object):
+
+    LEXER = 0
+    PARSER = 1
+
diff --git a/runtime/Python2/src/antlr4/atn/LexerATNSimulator.py b/runtime/Python2/src/antlr4/atn/LexerATNSimulator.py
new file mode 100644
index 000000000..02aff7aa0
--- /dev/null
+++ b/runtime/Python2/src/antlr4/atn/LexerATNSimulator.py
@@ -0,0 +1,586 @@
+#
+# [The "BSD license"]
+#  Copyright (c) 2012 Terence Parr
+#  Copyright (c) 2012 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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.
+#/
+
+# When we hit an accept state in either the DFA or the ATN, we
+#  have to notify the character stream to start buffering characters
+#  via {@link IntStream#mark} and record the current state. The current sim state
+#  includes the current index into the input, the current line,
+#  and current character position in that line. Note that the Lexer is
+#  tracking the starting line and characterization of the token. These
+#  variables track the "state" of the simulator when it hits an accept state.
+#
+#  <p>We track these variables separately for the DFA and ATN simulation
+#  because the DFA simulation often has to fail over to the ATN
+#  simulation. If the ATN simulation fails, we need the DFA to fall
+#  back to its previously accepted state, if any. If the ATN succeeds,
+#  then the ATN does the accept and the DFA simulator that invoked it
+#  can simply return the predicted token type.</p>
+#/
+from antlr4 import Lexer
+from antlr4.PredictionContext import SingletonPredictionContext, PredictionContext
+from antlr4.Token import Token
+from antlr4.atn.ATN import ATN
+from antlr4.atn.ATNConfig import LexerATNConfig
+from antlr4.atn.ATNSimulator import ATNSimulator
+from antlr4.atn.ATNConfigSet import ATNConfigSet, OrderedATNConfigSet
+from antlr4.atn.ATNState import RuleStopState, ATNState
+from antlr4.atn.LexerActionExecutor import LexerActionExecutor
+from antlr4.atn.Transition import Transition
+from antlr4.dfa.DFAState import DFAState
+from antlr4.error.Errors import LexerNoViableAltException, UnsupportedOperationException
+
+class SimState(object):
+
+    def __init__(self):
+        self.reset()
+
+    def reset(self):
+        self.index = -1
+        self.line = 0
+        self.column = -1
+        self.dfaState = None
+
+class LexerATNSimulator(ATNSimulator):
+    
+    debug = False
+    dfa_debug = False
+
+    MIN_DFA_EDGE = 0
+    MAX_DFA_EDGE = 127 # forces unicode to stay in ATN
+
+    ERROR = None
+
+    match_calls = 0
+
+    def __init__(self, recog, atn, decisionToDFA, sharedContextCache):
+        super(LexerATNSimulator, self).__init__(atn, sharedContextCache)
+        self.decisionToDFA = decisionToDFA
+        self.recog = recog
+        # The current token's starting index into the character stream.
+        #  Shared across DFA to ATN simulation in case the ATN fails and the
+        #  DFA did not have a previous accept state. In this case, we use the
+        #  ATN-generated exception object.
+        self.startIndex = -1
+        # line number 1..n within the input#/
+        self.line = 1
+        # The index of the character relative to the beginning of the line 0..n-1#/
+        self.column = 0
+        from antlr4.Lexer import Lexer
+        self.mode = Lexer.DEFAULT_MODE
+        # Used during DFA/ATN exec to record the most recent accept configuration info
+        self.prevAccept = SimState()
+
+
+    def copyState(self, simulator ):
+        self.column = simulator.column
+        self.line = simulator.line
+        self.mode = simulator.mode
+        self.startIndex = simulator.startIndex
+
+    def match(self, input , mode):
+        self.match_calls += 1
+        self.mode = mode
+        mark = input.mark()
+        try:
+            self.startIndex = input.index
+            self.prevAccept.reset()
+            dfa = self.decisionToDFA[mode]
+            if dfa.s0 is None:
+                return self.matchATN(input)
+            else:
+                return self.execATN(input, dfa.s0)
+        finally:
+            input.release(mark)
+
+    def reset(self):
+        self.prevAccept.reset()
+        self.startIndex = -1
+        self.line = 1
+        self.column = 0
+        self.mode = Lexer.DEFAULT_MODE
+
+    def matchATN(self, input):
+        startState = self.atn.modeToStartState[self.mode]
+
+        if self.debug:
+            print("matchATN mode " + str(self.mode) + " start: " + str(startState))
+
+        old_mode = self.mode
+        s0_closure = self.computeStartState(input, startState)
+        suppressEdge = s0_closure.hasSemanticContext
+        s0_closure.hasSemanticContext = False
+
+        next = self.addDFAState(s0_closure)
+        if not suppressEdge:
+            self.decisionToDFA[self.mode].s0 = next
+
+        predict = self.execATN(input, next)
+
+        if self.debug:
+            print("DFA after matchATN: " + str(self.decisionToDFA[old_mode].toLexerString()))
+
+        return predict
+
+    def execATN(self, input, ds0):
+        if self.debug:
+            print("start state closure=" + str(ds0.configs))
+
+        if ds0.isAcceptState:
+            # allow zero-length tokens
+            self.captureSimState(self.prevAccept, input, ds0)
+
+        t = input.LA(1)
+        s = ds0 # s is current/from DFA state
+
+        while True: # while more work
+            if self.debug:
+                print("execATN loop starting closure: %s\n", s.configs)
+
+            # As we move src->trg, src->trg, we keep track of the previous trg to
+            # avoid looking up the DFA state again, which is expensive.
+            # If the previous target was already part of the DFA, we might
+            # be able to avoid doing a reach operation upon t. If s!=null,
+            # it means that semantic predicates didn't prevent us from
+            # creating a DFA state. Once we know s!=null, we check to see if
+            # the DFA state has an edge already for t. If so, we can just reuse
+            # it's configuration set; there's no point in re-computing it.
+            # This is kind of like doing DFA simulation within the ATN
+            # simulation because DFA simulation is really just a way to avoid
+            # computing reach/closure sets. Technically, once we know that
+            # we have a previously added DFA state, we could jump over to
+            # the DFA simulator. But, that would mean popping back and forth
+            # a lot and making things more complicated algorithmically.
+            # This optimization makes a lot of sense for loops within DFA.
+            # A character will take us back to an existing DFA state
+            # that already has lots of edges out of it. e.g., .* in comments.
+            # print("Target for:" + str(s) + " and:" + str(t))
+            target = self.getExistingTargetState(s, t)
+            # print("Existing:" + str(target))
+            if target is None:
+                target = self.computeTargetState(input, s, t)
+                # print("Computed:" + str(target))
+
+            if target == self.ERROR:
+                break
+
+            # If this is a consumable input element, make sure to consume before
+            # capturing the accept state so the input index, line, and char
+            # position accurately reflect the state of the interpreter at the
+            # end of the token.
+            if t != Token.EOF:
+                self.consume(input)
+
+            if target.isAcceptState:
+                self.captureSimState(self.prevAccept, input, target)
+                if t == Token.EOF:
+                    break
+
+            t = input.LA(1)
+
+            s = target # flip; current DFA target becomes new src/from state
+
+        return self.failOrAccept(self.prevAccept, input, s.configs, t)
+
+    # Get an existing target state for an edge in the DFA. If the target state
+    # for the edge has not yet been computed or is otherwise not available,
+    # this method returns {@code null}.
+    #
+    # @param s The current DFA state
+    # @param t The next input symbol
+    # @return The existing target DFA state for the given input symbol
+    # {@code t}, or {@code null} if the target state for this edge is not
+    # already cached
+    def getExistingTargetState(self, s, t):
+        if s.edges is None or t < self.MIN_DFA_EDGE or t > self.MAX_DFA_EDGE:
+            return None
+
+        target = s.edges[t - self.MIN_DFA_EDGE]
+        if self.debug and target is not None:
+            print("reuse state "+s.stateNumber+ " edge to "+target.stateNumber)
+
+        return target
+
+    # Compute a target state for an edge in the DFA, and attempt to add the
+    # computed state and corresponding edge to the DFA.
+    #
+    # @param input The input stream
+    # @param s The current DFA state
+    # @param t The next input symbol
+    #
+    # @return The computed target DFA state for the given input symbol
+    # {@code t}. If {@code t} does not lead to a valid DFA state, this method
+    # returns {@link #ERROR}.
+    def computeTargetState(self, input, s, t):
+        reach = OrderedATNConfigSet()
+
+        # if we don't find an existing DFA state
+        # Fill reach starting from closure, following t transitions
+        self.getReachableConfigSet(input, s.configs, reach, t)
+
+        if len(reach)==0: # we got nowhere on t from s
+            if not reach.hasSemanticContext:
+                # we got nowhere on t, don't throw out this knowledge; it'd
+                # cause a failover from DFA later.
+                self. addDFAEdge(s, t, self.ERROR)
+
+            # stop when we can't match any more char
+            return self.ERROR
+
+        # Add an edge from s to target DFA found/created for reach
+        return self.addDFAEdge(s, t, cfgs=reach)
+
+    def failOrAccept(self, prevAccept , input, reach, t):
+        if self.prevAccept.dfaState is not None:
+            lexerActionExecutor = prevAccept.dfaState.lexerActionExecutor
+            self.accept(input, lexerActionExecutor, self.startIndex, prevAccept.index, prevAccept.line, prevAccept.column)
+            return prevAccept.dfaState.prediction
+        else:
+            # if no accept and EOF is first char, return EOF
+            if t==Token.EOF and input.index==self.startIndex:
+                return Token.EOF
+            raise LexerNoViableAltException(self.recog, input, self.startIndex, reach)
+
+    # Given a starting configuration set, figure out all ATN configurations
+    #  we can reach upon input {@code t}. Parameter {@code reach} is a return
+    #  parameter.
+    def getReachableConfigSet(self, input, closure, reach, t):
+        # this is used to skip processing for configs which have a lower priority
+        # than a config that already reached an accept state for the same rule
+        skipAlt = ATN.INVALID_ALT_NUMBER
+        for cfg in closure:
+            currentAltReachedAcceptState = ( cfg.alt == skipAlt )
+            if currentAltReachedAcceptState and cfg.passedThroughNonGreedyDecision:
+                continue
+
+            if self.debug:
+                print("testing %s at %s\n", self.getTokenName(t), cfg.toString(self.recog, True))
+
+            for trans in cfg.state.transitions:          # for each transition
+                target = self.getReachableTarget(trans, t)
+                if target is not None:
+                    lexerActionExecutor = cfg.lexerActionExecutor
+                    if lexerActionExecutor is not None:
+                        lexerActionExecutor = lexerActionExecutor.fixOffsetBeforeMatch(input.index - self.startIndex)
+
+                    treatEofAsEpsilon = (t == Token.EOF)
+                    config = LexerATNConfig(state=target, lexerActionExecutor=lexerActionExecutor, config=cfg)
+                    if self.closure(input, config, reach, currentAltReachedAcceptState, True, treatEofAsEpsilon):
+                        # any remaining configs for this alt have a lower priority than
+                        # the one that just reached an accept state.
+                        skipAlt = cfg.alt
+
+    def accept(self, input, lexerActionExecutor, startIndex, index, line, charPos):
+        if self.debug:
+            print("ACTION %s\n", lexerActionExecutor)
+
+        # seek to after last char in token
+        input.seek(index)
+        self.line = line
+        self.column = charPos
+
+        if lexerActionExecutor is not None and self.recog is not None:
+            lexerActionExecutor.execute(self.recog, input, startIndex)
+
+    def getReachableTarget(self, trans, t):
+        if trans.matches(t, 0, 0xFFFE):
+            return trans.target
+        else:
+            return None
+
+    def computeStartState(self, input, p):
+        initialContext = PredictionContext.EMPTY
+        configs = OrderedATNConfigSet()
+        for i in range(0,len(p.transitions)):
+            target = p.transitions[i].target
+            c = LexerATNConfig(state=target, alt=i+1, context=initialContext)
+            self.closure(input, c, configs, False, False, False)
+        return configs
+
+    # Since the alternatives within any lexer decision are ordered by
+    # preference, this method stops pursuing the closure as soon as an accept
+    # state is reached. After the first accept state is reached by depth-first
+    # search from {@code config}, all other (potentially reachable) states for
+    # this rule would have a lower priority.
+    #
+    # @return {@code true} if an accept state is reached, otherwise
+    # {@code false}.
+    def closure(self, input, config, configs, currentAltReachedAcceptState,
+                speculative, treatEofAsEpsilon):
+        if self.debug:
+            print("closure("+config.toString(self.recog, True)+")")
+
+        if isinstance( config.state, RuleStopState ):
+            if self.debug:
+                if self.recog is not None:
+                    print("closure at %s rule stop %s\n", self.recog.getRuleNames()[config.state.ruleIndex], config)
+                else:
+                    print("closure at rule stop %s\n", config)
+
+            if config.context is None or config.context.hasEmptyPath():
+                if config.context is None or config.context.isEmpty():
+                    configs.add(config)
+                    return True
+                else:
+                    configs.add(LexerATNConfig(state=config.state, config=config, context=PredictionContext.EMPTY))
+                    currentAltReachedAcceptState = True
+
+            if config.context is not None and not config.context.isEmpty():
+                for i in range(0,len(config.context)):
+                    if config.context.getReturnState(i) != PredictionContext.EMPTY_RETURN_STATE:
+                        newContext = config.context.getParent(i) # "pop" return state
+                        returnState = self.atn.states[config.context.getReturnState(i)]
+                        c = LexerATNConfig(state=returnState, config=config, context=newContext)
+                        currentAltReachedAcceptState = self.closure(input, c, configs,
+                                    currentAltReachedAcceptState, speculative, treatEofAsEpsilon)
+
+            return currentAltReachedAcceptState
+
+        # optimization
+        if not config.state.epsilonOnlyTransitions:
+            if not currentAltReachedAcceptState or not config.passedThroughNonGreedyDecision:
+                configs.add(config)
+
+        for t in config.state.transitions:
+            c = self.getEpsilonTarget(input, config, t, configs, speculative, treatEofAsEpsilon)
+            if c is not None:
+                currentAltReachedAcceptState = self.closure(input, c, configs, currentAltReachedAcceptState, speculative, treatEofAsEpsilon)
+
+        return currentAltReachedAcceptState
+
+    # side-effect: can alter configs.hasSemanticContext
+    def getEpsilonTarget(self, input, config, t, configs, speculative, treatEofAsEpsilon):
+        c = None
+        if t.serializationType==Transition.RULE:
+                newContext = SingletonPredictionContext.create(config.context, t.followState.stateNumber)
+                c = LexerATNConfig(state=t.target, config=config, context=newContext)
+
+        elif t.serializationType==Transition.PRECEDENCE:
+                raise UnsupportedOperationException("Precedence predicates are not supported in lexers.")
+
+        elif t.serializationType==Transition.PREDICATE:
+                #  Track traversing semantic predicates. If we traverse,
+                # we cannot add a DFA state for this "reach" computation
+                # because the DFA would not test the predicate again in the
+                # future. Rather than creating collections of semantic predicates
+                # like v3 and testing them on prediction, v4 will test them on the
+                # fly all the time using the ATN not the DFA. This is slower but
+                # semantically it's not used that often. One of the key elements to
+                # this predicate mechanism is not adding DFA states that see
+                # predicates immediately afterwards in the ATN. For example,
+
+                # a : ID {p1}? | ID {p2}? ;
+
+                # should create the start state for rule 'a' (to save start state
+                # competition), but should not create target of ID state. The
+                # collection of ATN states the following ID references includes
+                # states reached by traversing predicates. Since this is when we
+                # test them, we cannot cash the DFA state target of ID.
+
+                if self.debug:
+                    print("EVAL rule "+ str(t.ruleIndex) + ":" + str(t.predIndex))
+                configs.hasSemanticContext = True
+                if self.evaluatePredicate(input, t.ruleIndex, t.predIndex, speculative):
+                    c = LexerATNConfig(state=t.target, config=config)
+
+        elif t.serializationType==Transition.ACTION:
+                if config.context is None or config.context.hasEmptyPath():
+                    # execute actions anywhere in the start rule for a token.
+                    #
+                    # TODO: if the entry rule is invoked recursively, some
+                    # actions may be executed during the recursive call. The
+                    # problem can appear when hasEmptyPath() is true but
+                    # isEmpty() is false. In this case, the config needs to be
+                    # split into two contexts - one with just the empty path
+                    # and another with everything but the empty path.
+                    # Unfortunately, the current algorithm does not allow
+                    # getEpsilonTarget to return two configurations, so
+                    # additional modifications are needed before we can support
+                    # the split operation.
+                    lexerActionExecutor = LexerActionExecutor.append(config.lexerActionExecutor,
+                                    self.atn.lexerActions[t.actionIndex])
+                    c = LexerATNConfig(state=t.target, config=config, lexerActionExecutor=lexerActionExecutor)
+
+                else:
+                    # ignore actions in referenced rules
+                    c = LexerATNConfig(state=t.target, config=config)
+
+        elif t.serializationType==Transition.EPSILON:
+            c = LexerATNConfig(state=t.target, config=config)
+
+        elif t.serializationType in [ Transition.ATOM, Transition.RANGE, Transition.SET ]:
+            if treatEofAsEpsilon:
+                if t.matches(Token.EOF, 0, 0xFFFF):
+                    c = LexerATNConfig(state=t.target, config=config)
+
+        return c
+
+    # Evaluate a predicate specified in the lexer.
+    #
+    # <p>If {@code speculative} is {@code true}, this method was called before
+    # {@link #consume} for the matched character. This method should call
+    # {@link #consume} before evaluating the predicate to ensure position
+    # sensitive values, including {@link Lexer#getText}, {@link Lexer#getLine},
+    # and {@link Lexer#getcolumn}, properly reflect the current
+    # lexer state. This method should restore {@code input} and the simulator
+    # to the original state before returning (i.e. undo the actions made by the
+    # call to {@link #consume}.</p>
+    #
+    # @param input The input stream.
+    # @param ruleIndex The rule containing the predicate.
+    # @param predIndex The index of the predicate within the rule.
+    # @param speculative {@code true} if the current index in {@code input} is
+    # one character before the predicate's location.
+    #
+    # @return {@code true} if the specified predicate evaluates to
+    # {@code true}.
+    #/
+    def evaluatePredicate(self, input, ruleIndex, predIndex, speculative):
+        # assume true if no recognizer was provided
+        if self.recog is None:
+            return True
+
+        if not speculative:
+            return self.recog.sempred(None, ruleIndex, predIndex)
+
+        savedcolumn = self.column
+        savedLine = self.line
+        index = input.index
+        marker = input.mark()
+        try:
+            self.consume(input)
+            return self.recog.sempred(None, ruleIndex, predIndex)
+        finally:
+            self.column = savedcolumn
+            self.line = savedLine
+            input.seek(index)
+            input.release(marker)
+
+    def captureSimState(self, settings, input, dfaState):
+        settings.index = input.index
+        settings.line = self.line
+        settings.column = self.column
+        settings.dfaState = dfaState
+
+    def addDFAEdge(self, from_, tk, to=None, cfgs=None):
+
+        if to is None and cfgs is not None:
+            # leading to this call, ATNConfigSet.hasSemanticContext is used as a
+            # marker indicating dynamic predicate evaluation makes this edge
+            # dependent on the specific input sequence, so the static edge in the
+            # DFA should be omitted. The target DFAState is still created since
+            # execATN has the ability to resynchronize with the DFA state cache
+            # following the predicate evaluation step.
+            #
+            # TJP notes: next time through the DFA, we see a pred again and eval.
+            # If that gets us to a previously created (but dangling) DFA
+            # state, we can continue in pure DFA mode from there.
+            #/
+            suppressEdge = cfgs.hasSemanticContext
+            cfgs.hasSemanticContext = False
+
+            to = self.addDFAState(cfgs)
+
+            if suppressEdge:
+                return to
+
+        # add the edge
+        if tk < self.MIN_DFA_EDGE or tk > self.MAX_DFA_EDGE:
+            # Only track edges within the DFA bounds
+            return to
+
+        if self.debug:
+            print("EDGE " + str(from_) + " -> " + str(to) + " upon "+ chr(tk))
+
+        if from_.edges is None:
+            #  make room for tokens 1..n and -1 masquerading as index 0
+            from_.edges = [ None ] * (self.MAX_DFA_EDGE - self.MIN_DFA_EDGE + 1)
+
+        from_.edges[tk - self.MIN_DFA_EDGE] = to # connect
+
+        return to
+
+
+    # Add a new DFA state if there isn't one with this set of
+    # configurations already. This method also detects the first
+    # configuration containing an ATN rule stop state. Later, when
+    # traversing the DFA, we will know which rule to accept.
+    def addDFAState(self, configs):
+
+        proposed = DFAState(configs=configs)
+        firstConfigWithRuleStopState = None
+        for c in configs:
+            if isinstance(c.state, RuleStopState):
+                firstConfigWithRuleStopState = c
+                break
+
+        if firstConfigWithRuleStopState is not None:
+            proposed.isAcceptState = True
+            proposed.lexerActionExecutor = firstConfigWithRuleStopState.lexerActionExecutor
+            proposed.prediction = self.atn.ruleToTokenType[firstConfigWithRuleStopState.state.ruleIndex]
+
+        dfa = self.decisionToDFA[self.mode]
+        existing = dfa.states.get(proposed, None)
+        if existing is not None:
+            return existing
+
+        newState = proposed
+
+        newState.stateNumber = len(dfa.states)
+        configs.setReadonly(True)
+        newState.configs = configs
+        dfa.states[newState] = newState
+        return newState
+
+    def getDFA(self, mode):
+        return self.decisionToDFA[mode]
+
+    # Get the text matched so far for the current token.
+    def getText(self, input):
+        # index is first lookahead char, don't include.
+        return input.getText(self.startIndex, input.index-1)
+
+    def consume(self, input):
+        curChar = input.LA(1)
+        if curChar==ord('\n'):
+            self.line += 1
+            self.column = 0
+        else:
+            self.column += 1
+        input.consume()
+
+    def getTokenName(self, t):
+        if t==-1:
+            return "EOF"
+        else:
+            return "'" + chr(t) + "'"
+
+
+LexerATNSimulator.ERROR = DFAState(0x7FFFFFFF, ATNConfigSet())
diff --git a/runtime/Python2/src/antlr4/atn/LexerAction.py b/runtime/Python2/src/antlr4/atn/LexerAction.py
new file mode 100644
index 000000000..207d9025f
--- /dev/null
+++ b/runtime/Python2/src/antlr4/atn/LexerAction.py
@@ -0,0 +1,316 @@
+#
+#[The "BSD license"]
+# Copyright (c) 2013 Terence Parr
+# Copyright (c) 2013 Sam Harwell
+# Copyright (c) 2014 Eric Vergnaud
+# 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.
+#
+
+class LexerActionType(object):
+
+    CHANNEL = 0     #The type of a {@link LexerChannelAction} action.
+    CUSTOM = 1      #The type of a {@link LexerCustomAction} action.
+    MODE = 2        #The type of a {@link LexerModeAction} action.
+    MORE = 3        #The type of a {@link LexerMoreAction} action.
+    POP_MODE = 4    #The type of a {@link LexerPopModeAction} action.
+    PUSH_MODE = 5   #The type of a {@link LexerPushModeAction} action.
+    SKIP = 6        #The type of a {@link LexerSkipAction} action.
+    TYPE = 7        #The type of a {@link LexerTypeAction} action.
+
+class LexerAction(object):
+
+    def __init__(self, action):
+        self.actionType = action
+        self.isPositionDependent = False
+
+    def __hash__(self):
+        return hash(self.actionType)
+
+    def __eq__(self, other):
+        return self is other
+
+    def __str__(self):
+        return unicode(self)
+
+    def __unicode__(self):
+        return unicode(super(LexerAction, self))
+
+
+#
+# Implements the {@code skip} lexer action by calling {@link Lexer#skip}.
+#
+# <p>The {@code skip} command does not have any parameters, so this action is
+# implemented as a singleton instance exposed by {@link #INSTANCE}.</p>
+class LexerSkipAction(LexerAction ):
+
+    # Provides a singleton instance of this parameterless lexer action.
+    INSTANCE = None
+
+    def __init__(self):
+        super(LexerSkipAction, self).__init__(LexerActionType.SKIP)
+
+    def execute(self, lexer):
+        lexer.skip()
+
+    def __unicode__(self):
+        return u"skip"
+
+LexerSkipAction.INSTANCE = LexerSkipAction()
+
+#  Implements the {@code type} lexer action by calling {@link Lexer#setType}
+# with the assigned type.
+class LexerTypeAction(LexerAction):
+
+    def __init__(self, type):
+        super(LexerTypeAction, self).__init__(LexerActionType.TYPE)
+        self.type = type
+
+    def execute(self, lexer):
+        lexer.type = self.type
+
+    def __hash__(self):
+        return hash((self.actionType, self.type))
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, LexerTypeAction):
+            return False
+        else:
+            return self.type == other.type
+
+    def __unicode__(self):
+        return u"type(" + unicode(self.type) + u")"
+
+
+# Implements the {@code pushMode} lexer action by calling
+# {@link Lexer#pushMode} with the assigned mode.
+class LexerPushModeAction(LexerAction):
+
+    def __init__(self, mode):
+        super(LexerPushModeAction, self).__init__(LexerActionType.PUSH_MODE)
+        self.mode = mode
+
+    # <p>This action is implemented by calling {@link Lexer#pushMode} with the
+    # value provided by {@link #getMode}.</p>
+    def execute(self, lexer):
+        lexer.pushMode(self.mode)
+
+    def __hash__(self):
+        return hash((self.actionType, self.mode))
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, LexerPushModeAction):
+            return False
+        else:
+            return self.mode == other.mode
+
+    def __unicode__(self):
+        return u"pushMode(" + unicode(self.mode) + u")"
+
+
+# Implements the {@code popMode} lexer action by calling {@link Lexer#popMode}.
+#
+# <p>The {@code popMode} command does not have any parameters, so this action is
+# implemented as a singleton instance exposed by {@link #INSTANCE}.</p>
+class LexerPopModeAction(LexerAction):
+
+    INSTANCE = None
+
+    def __init__(self):
+        super(LexerPopModeAction, self).__init__(LexerActionType.POP_MODE)
+
+    # <p>This action is implemented by calling {@link Lexer#popMode}.</p>
+    def execute(self, lexer):
+        lexer.popMode()
+
+    def __unicode__(self):
+        return "popMode"
+
+LexerPopModeAction.INSTANCE = LexerPopModeAction()
+
+# Implements the {@code more} lexer action by calling {@link Lexer#more}.
+#
+# <p>The {@code more} command does not have any parameters, so this action is
+# implemented as a singleton instance exposed by {@link #INSTANCE}.</p>
+class LexerMoreAction(LexerAction):
+
+    INSTANCE = None
+
+    def __init__(self):
+        super(LexerMoreAction, self).__init__(LexerActionType.MORE)
+
+    # <p>This action is implemented by calling {@link Lexer#popMode}.</p>
+    def execute(self, lexer):
+        lexer.more()
+
+    def __unicode__(self):
+        return "more"
+
+LexerMoreAction.INSTANCE = LexerMoreAction()
+
+# Implements the {@code mode} lexer action by calling {@link Lexer#mode} with
+# the assigned mode.
+class LexerModeAction(LexerAction):
+
+    def __init__(self, mode):
+        super(LexerModeAction, self).__init__(LexerActionType.MODE)
+        self.mode = mode
+
+    # <p>This action is implemented by calling {@link Lexer#mode} with the
+    # value provided by {@link #getMode}.</p>
+    def execute(self, lexer):
+        lexer.mode(self.mode)
+
+    def __hash__(self):
+        return hash((self.actionType, self.mode))
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, LexerModeAction):
+            return False
+        else:
+            return self.mode == other.mode
+
+    def __unicode__(self):
+        return u"mode(" + unicode(self.mode) + u")"
+
+# Executes a custom lexer action by calling {@link Recognizer#action} with the
+# rule and action indexes assigned to the custom action. The implementation of
+# a custom action is added to the generated code for the lexer in an override
+# of {@link Recognizer#action} when the grammar is compiled.
+#
+# <p>This class may represent embedded actions created with the <code>{...}</code>
+# syntax in ANTLR 4, as well as actions created for lexer commands where the
+# command argument could not be evaluated when the grammar was compiled.</p>
+
+class LexerCustomAction(LexerAction):
+
+    # Constructs a custom lexer action with the specified rule and action
+    # indexes.
+    #
+    # @param ruleIndex The rule index to use for calls to
+    # {@link Recognizer#action}.
+    # @param actionIndex The action index to use for calls to
+    # {@link Recognizer#action}.
+    #/
+    def __init__(self, ruleIndex, actionIndex):
+        super(LexerCustomAction, self).__init__(LexerActionType.CUSTOM)
+        self.ruleIndex = ruleIndex
+        self.actionIndex = actionIndex
+        self.isPositionDependent = True
+
+    # <p>Custom actions are implemented by calling {@link Lexer#action} with the
+    # appropriate rule and action indexes.</p>
+    def execute(self, lexer):
+        lexer.action(None, self.ruleIndex, self.actionIndex)
+
+    def __hash__(self):
+        return hash((self.actionType, self.ruleIndex, self.actionIndex))
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, LexerCustomAction):
+            return False
+        else:
+            return self.ruleIndex == other.ruleIndex and self.actionIndex == other.actionIndex
+
+# Implements the {@code channel} lexer action by calling
+# {@link Lexer#setChannel} with the assigned channel.
+class LexerChannelAction(LexerAction):
+
+    # Constructs a new {@code channel} action with the specified channel value.
+    # @param channel The channel value to pass to {@link Lexer#setChannel}.
+    def __init__(self, channel):
+        super(LexerChannelAction, self).__init__(LexerActionType.CHANNEL)
+        self.channel = channel
+
+    # <p>This action is implemented by calling {@link Lexer#setChannel} with the
+    # value provided by {@link #getChannel}.</p>
+    def execute(self, lexer):
+        lexer._channel = self.channel
+
+    def __hash__(self):
+        return hash((self.actionType, self.channel))
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, LexerChannelAction):
+            return False
+        else:
+            return self.channel == other.channel
+
+    def __unicode__(self):
+        return u"channel(" + unicode(self.channel) + u")"
+
+# This implementation of {@link LexerAction} is used for tracking input offsets
+# for position-dependent actions within a {@link LexerActionExecutor}.
+#
+# <p>This action is not serialized as part of the ATN, and is only required for
+# position-dependent lexer actions which appear at a location other than the
+# end of a rule. For more information about DFA optimizations employed for
+# lexer actions, see {@link LexerActionExecutor#append} and
+# {@link LexerActionExecutor#fixOffsetBeforeMatch}.</p>
+class LexerIndexedCustomAction(LexerAction):
+
+    # Constructs a new indexed custom action by associating a character offset
+    # with a {@link LexerAction}.
+    #
+    # <p>Note: This class is only required for lexer actions for which
+    # {@link LexerAction#isPositionDependent} returns {@code true}.</p>
+    #
+    # @param offset The offset into the input {@link CharStream}, relative to
+    # the token start index, at which the specified lexer action should be
+    # executed.
+    # @param action The lexer action to execute at a particular offset in the
+    # input {@link CharStream}.
+    def __init__(self, offset, action):
+        super(LexerIndexedCustomAction, self).__init__(action.actionType)
+        self.offset = offset
+        self.action = action
+        self.isPositionDependent = True
+
+    # <p>This method calls {@link #execute} on the result of {@link #getAction}
+    # using the provided {@code lexer}.</p>
+    def execute(self, lexer):
+        # assume the input stream position was properly set by the calling code
+        self.action.execute(lexer)
+
+    def __hash__(self):
+        return hash((self.actionType, self.offset, self.action))
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, LexerIndexedCustomAction):
+            return False
+        else:
+            return self.offset == other.offset and self.action == other.action
diff --git a/runtime/Python2/src/antlr4/atn/LexerActionExecutor.py b/runtime/Python2/src/antlr4/atn/LexerActionExecutor.py
new file mode 100644
index 000000000..7149a29d4
--- /dev/null
+++ b/runtime/Python2/src/antlr4/atn/LexerActionExecutor.py
@@ -0,0 +1,160 @@
+#
+# [The "BSD license"]
+#  Copyright (c) 2013 Terence Parr
+#  Copyright (c) 2013 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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.
+#/
+
+# Represents an executor for a sequence of lexer actions which traversed during
+# the matching operation of a lexer rule (token).
+#
+# <p>The executor tracks position information for position-dependent lexer actions
+# efficiently, ensuring that actions appearing only at the end of the rule do
+# not cause bloating of the {@link DFA} created for the lexer.</p>
+
+
+from antlr4.atn.LexerAction import LexerIndexedCustomAction
+
+class LexerActionExecutor(object):
+
+    def __init__(self, lexerActions=list()):
+        self.lexerActions = lexerActions
+        # Caches the result of {@link #hashCode} since the hash code is an element
+        # of the performance-critical {@link LexerATNConfig#hashCode} operation.
+        self.hashCode = hash("".join([str(la) for la in lexerActions]))
+
+
+    # Creates a {@link LexerActionExecutor} which executes the actions for
+    # the input {@code lexerActionExecutor} followed by a specified
+    # {@code lexerAction}.
+    #
+    # @param lexerActionExecutor The executor for actions already traversed by
+    # the lexer while matching a token within a particular
+    # {@link LexerATNConfig}. If this is {@code null}, the method behaves as
+    # though it were an empty executor.
+    # @param lexerAction The lexer action to execute after the actions
+    # specified in {@code lexerActionExecutor}.
+    #
+    # @return A {@link LexerActionExecutor} for executing the combine actions
+    # of {@code lexerActionExecutor} and {@code lexerAction}.
+    @staticmethod
+    def append(lexerActionExecutor, lexerAction):
+        if lexerActionExecutor is None:
+            return LexerActionExecutor([ lexerAction ])
+
+        lexerActions = lexerActionExecutor.lexerActions + [ lexerAction ]
+        return LexerActionExecutor(lexerActions)
+
+    # Creates a {@link LexerActionExecutor} which encodes the current offset
+    # for position-dependent lexer actions.
+    #
+    # <p>Normally, when the executor encounters lexer actions where
+    # {@link LexerAction#isPositionDependent} returns {@code true}, it calls
+    # {@link IntStream#seek} on the input {@link CharStream} to set the input
+    # position to the <em>end</em> of the current token. This behavior provides
+    # for efficient DFA representation of lexer actions which appear at the end
+    # of a lexer rule, even when the lexer rule matches a variable number of
+    # characters.</p>
+    #
+    # <p>Prior to traversing a match transition in the ATN, the current offset
+    # from the token start index is assigned to all position-dependent lexer
+    # actions which have not already been assigned a fixed offset. By storing
+    # the offsets relative to the token start index, the DFA representation of
+    # lexer actions which appear in the middle of tokens remains efficient due
+    # to sharing among tokens of the same length, regardless of their absolute
+    # position in the input stream.</p>
+    #
+    # <p>If the current executor already has offsets assigned to all
+    # position-dependent lexer actions, the method returns {@code this}.</p>
+    #
+    # @param offset The current offset to assign to all position-dependent
+    # lexer actions which do not already have offsets assigned.
+    #
+    # @return A {@link LexerActionExecutor} which stores input stream offsets
+    # for all position-dependent lexer actions.
+    #/
+    def fixOffsetBeforeMatch(self, offset):
+        updatedLexerActions = None
+        for i in range(0, len(self.lexerActions)):
+            if self.lexerActions[i].isPositionDependent and not isinstance(self.lexerActions[i], LexerIndexedCustomAction):
+                if updatedLexerActions is None:
+                    updatedLexerActions = [ la for la in self.lexerActions ]
+                updatedLexerActions[i] = LexerIndexedCustomAction(offset, self.lexerActions[i])
+
+        if updatedLexerActions is None:
+            return self
+        else:
+            return LexerActionExecutor(updatedLexerActions)
+
+
+    # Execute the actions encapsulated by this executor within the context of a
+    # particular {@link Lexer}.
+    #
+    # <p>This method calls {@link IntStream#seek} to set the position of the
+    # {@code input} {@link CharStream} prior to calling
+    # {@link LexerAction#execute} on a position-dependent action. Before the
+    # method returns, the input position will be restored to the same position
+    # it was in when the method was invoked.</p>
+    #
+    # @param lexer The lexer instance.
+    # @param input The input stream which is the source for the current token.
+    # When this method is called, the current {@link IntStream#index} for
+    # {@code input} should be the start of the following token, i.e. 1
+    # character past the end of the current token.
+    # @param startIndex The token start index. This value may be passed to
+    # {@link IntStream#seek} to set the {@code input} position to the beginning
+    # of the token.
+    #/
+    def execute(self, lexer, input, startIndex):
+        requiresSeek = False
+        stopIndex = input.index
+        try:
+            for lexerAction in self.lexerActions:
+                if isinstance(lexerAction, LexerIndexedCustomAction):
+                    offset = lexerAction.offset
+                    input.seek(startIndex + offset)
+                    lexerAction = lexerAction.action
+                    requiresSeek = (startIndex + offset) != stopIndex
+                elif lexerAction.isPositionDependent:
+                    input.seek(stopIndex)
+                    requiresSeek = False
+                lexerAction.execute(lexer)
+        finally:
+            if requiresSeek:
+                input.seek(stopIndex)
+
+    def __hash__(self):
+        return self.hashCode
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, LexerActionExecutor):
+            return False
+        else:
+            return self.hashCode == other.hashCode \
+                and self.lexerActions == other.lexerActions
diff --git a/runtime/Python2/src/antlr4/atn/ParserATNSimulator.py b/runtime/Python2/src/antlr4/atn/ParserATNSimulator.py
new file mode 100755
index 000000000..dea6b7e14
--- /dev/null
+++ b/runtime/Python2/src/antlr4/atn/ParserATNSimulator.py
@@ -0,0 +1,1518 @@
+#
+# [The "BSD license"]
+#  Copyright (c) 2012 Terence Parr
+#  Copyright (c) 2012 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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.
+#
+
+#
+# The embodiment of the adaptive LL(*), ALL(*), parsing strategy.
+#
+# <p>
+# The basic complexity of the adaptive strategy makes it harder to understand.
+# We begin with ATN simulation to build paths in a DFA. Subsequent prediction
+# requests go through the DFA first. If they reach a state without an edge for
+# the current symbol, the algorithm fails over to the ATN simulation to
+# complete the DFA path for the current input (until it finds a conflict state
+# or uniquely predicting state).</p>
+#
+# <p>
+# All of that is done without using the outer context because we want to create
+# a DFA that is not dependent upon the rule invocation stack when we do a
+# prediction. One DFA works in all contexts. We avoid using context not
+# necessarily because it's slower, although it can be, but because of the DFA
+# caching problem. The closure routine only considers the rule invocation stack
+# created during prediction beginning in the decision rule. For example, if
+# prediction occurs without invoking another rule's ATN, there are no context
+# stacks in the configurations. When lack of context leads to a conflict, we
+# don't know if it's an ambiguity or a weakness in the strong LL(*) parsing
+# strategy (versus full LL(*)).</p>
+#
+# <p>
+# When SLL yields a configuration set with conflict, we rewind the input and
+# retry the ATN simulation, this time using full outer context without adding
+# to the DFA. Configuration context stacks will be the full invocation stacks
+# from the start rule. If we get a conflict using full context, then we can
+# definitively say we have a true ambiguity for that input sequence. If we
+# don't get a conflict, it implies that the decision is sensitive to the outer
+# context. (It is not context-sensitive in the sense of context-sensitive
+# grammars.)</p>
+#
+# <p>
+# The next time we reach this DFA state with an SLL conflict, through DFA
+# simulation, we will again retry the ATN simulation using full context mode.
+# This is slow because we can't save the results and have to "interpret" the
+# ATN each time we get that input.</p>
+#
+# <p>
+# <strong>CACHING FULL CONTEXT PREDICTIONS</strong></p>
+#
+# <p>
+# We could cache results from full context to predicted alternative easily and
+# that saves a lot of time but doesn't work in presence of predicates. The set
+# of visible predicates from the ATN start state changes depending on the
+# context, because closure can fall off the end of a rule. I tried to cache
+# tuples (stack context, semantic context, predicted alt) but it was slower
+# than interpreting and much more complicated. Also required a huge amount of
+# memory. The goal is not to create the world's fastest parser anyway. I'd like
+# to keep this algorithm simple. By launching multiple threads, we can improve
+# the speed of parsing across a large number of files.</p>
+#
+# <p>
+# There is no strict ordering between the amount of input used by SLL vs LL,
+# which makes it really hard to build a cache for full context. Let's say that
+# we have input A B C that leads to an SLL conflict with full context X. That
+# implies that using X we might only use A B but we could also use A B C D to
+# resolve conflict. Input A B C D could predict alternative 1 in one position
+# in the input and A B C E could predict alternative 2 in another position in
+# input. The conflicting SLL configurations could still be non-unique in the
+# full context prediction, which would lead us to requiring more input than the
+# original A B C.	To make a	prediction cache work, we have to track	the exact
+# input	used during the previous prediction. That amounts to a cache that maps
+# X to a specific DFA for that context.</p>
+#
+# <p>
+# Something should be done for left-recursive expression predictions. They are
+# likely LL(1) + pred eval. Easier to do the whole SLL unless error and retry
+# with full LL thing Sam does.</p>
+#
+# <p>
+# <strong>AVOIDING FULL CONTEXT PREDICTION</strong></p>
+#
+# <p>
+# We avoid doing full context retry when the outer context is empty, we did not
+# dip into the outer context by falling off the end of the decision state rule,
+# or when we force SLL mode.</p>
+#
+# <p>
+# As an example of the not dip into outer context case, consider as super
+# constructor calls versus function calls. One grammar might look like
+# this:</p>
+#
+# <pre>
+# ctorBody
+#   : '{' superCall? stat* '}'
+#   ;
+# </pre>
+#
+# <p>
+# Or, you might see something like</p>
+#
+# <pre>
+# stat
+#   : superCall ';'
+#   | expression ';'
+#   | ...
+#   ;
+# </pre>
+#
+# <p>
+# In both cases I believe that no closure operations will dip into the outer
+# context. In the first case ctorBody in the worst case will stop at the '}'.
+# In the 2nd case it should stop at the ';'. Both cases should stay within the
+# entry rule and not dip into the outer context.</p>
+#
+# <p>
+# <strong>PREDICATES</strong></p>
+#
+# <p>
+# Predicates are always evaluated if present in either SLL or LL both. SLL and
+# LL simulation deals with predicates differently. SLL collects predicates as
+# it performs closure operations like ANTLR v3 did. It delays predicate
+# evaluation until it reaches and accept state. This allows us to cache the SLL
+# ATN simulation whereas, if we had evaluated predicates on-the-fly during
+# closure, the DFA state configuration sets would be different and we couldn't
+# build up a suitable DFA.</p>
+#
+# <p>
+# When building a DFA accept state during ATN simulation, we evaluate any
+# predicates and return the sole semantically valid alternative. If there is
+# more than 1 alternative, we report an ambiguity. If there are 0 alternatives,
+# we throw an exception. Alternatives without predicates act like they have
+# true predicates. The simple way to think about it is to strip away all
+# alternatives with false predicates and choose the minimum alternative that
+# remains.</p>
+#
+# <p>
+# When we start in the DFA and reach an accept state that's predicated, we test
+# those and return the minimum semantically viable alternative. If no
+# alternatives are viable, we throw an exception.</p>
+#
+# <p>
+# During full LL ATN simulation, closure always evaluates predicates and
+# on-the-fly. This is crucial to reducing the configuration set size during
+# closure. It hits a landmine when parsing with the Java grammar, for example,
+# without this on-the-fly evaluation.</p>
+#
+# <p>
+# <strong>SHARING DFA</strong></p>
+#
+# <p>
+# All instances of the same parser share the same decision DFAs through a
+# static field. Each instance gets its own ATN simulator but they share the
+# same {@link #decisionToDFA} field. They also share a
+# {@link PredictionContextCache} object that makes sure that all
+# {@link PredictionContext} objects are shared among the DFA states. This makes
+# a big size difference.</p>
+#
+# <p>
+# <strong>THREAD SAFETY</strong></p>
+#
+# <p>
+# The {@link ParserATNSimulator} locks on the {@link #decisionToDFA} field when
+# it adds a new DFA object to that array. {@link #addDFAEdge}
+# locks on the DFA for the current decision when setting the
+# {@link DFAState#edges} field. {@link #addDFAState} locks on
+# the DFA for the current decision when looking up a DFA state to see if it
+# already exists. We must make sure that all requests to add DFA states that
+# are equivalent result in the same shared DFA object. This is because lots of
+# threads will be trying to update the DFA at once. The
+# {@link #addDFAState} method also locks inside the DFA lock
+# but this time on the shared context cache when it rebuilds the
+# configurations' {@link PredictionContext} objects using cached
+# subgraphs/nodes. No other locking occurs, even during DFA simulation. This is
+# safe as long as we can guarantee that all threads referencing
+# {@code s.edge[t]} get the same physical target {@link DFAState}, or
+# {@code null}. Once into the DFA, the DFA simulation does not reference the
+# {@link DFA#states} map. It follows the {@link DFAState#edges} field to new
+# targets. The DFA simulator will either find {@link DFAState#edges} to be
+# {@code null}, to be non-{@code null} and {@code dfa.edges[t]} null, or
+# {@code dfa.edges[t]} to be non-null. The
+# {@link #addDFAEdge} method could be racing to set the field
+# but in either case the DFA simulator works; if {@code null}, and requests ATN
+# simulation. It could also race trying to get {@code dfa.edges[t]}, but either
+# way it will work because it's not doing a test and set operation.</p>
+#
+# <p>
+# <strong>Starting with SLL then failing to combined SLL/LL (Two-Stage
+# Parsing)</strong></p>
+#
+# <p>
+# Sam pointed out that if SLL does not give a syntax error, then there is no
+# point in doing full LL, which is slower. We only have to try LL if we get a
+# syntax error. For maximum speed, Sam starts the parser set to pure SLL
+# mode with the {@link BailErrorStrategy}:</p>
+#
+# <pre>
+# parser.{@link Parser#getInterpreter() getInterpreter()}.{@link #setPredictionMode setPredictionMode}{@code (}{@link PredictionMode#SLL}{@code )};
+# parser.{@link Parser#setErrorHandler setErrorHandler}(new {@link BailErrorStrategy}());
+# </pre>
+#
+# <p>
+# If it does not get a syntax error, then we're done. If it does get a syntax
+# error, we need to retry with the combined SLL/LL strategy.</p>
+#
+# <p>
+# The reason this works is as follows. If there are no SLL conflicts, then the
+# grammar is SLL (at least for that input set). If there is an SLL conflict,
+# the full LL analysis must yield a set of viable alternatives which is a
+# subset of the alternatives reported by SLL. If the LL set is a singleton,
+# then the grammar is LL but not SLL. If the LL set is the same size as the SLL
+# set, the decision is SLL. If the LL set has size &gt; 1, then that decision
+# is truly ambiguous on the current input. If the LL set is smaller, then the
+# SLL conflict resolution might choose an alternative that the full LL would
+# rule out as a possibility based upon better context information. If that's
+# the case, then the SLL parse will definitely get an error because the full LL
+# analysis says it's not viable. If SLL conflict resolution chooses an
+# alternative within the LL set, them both SLL and LL would choose the same
+# alternative because they both choose the minimum of multiple conflicting
+# alternatives.</p>
+#
+# <p>
+# Let's say we have a set of SLL conflicting alternatives {@code {1, 2, 3}} and
+# a smaller LL set called <em>s</em>. If <em>s</em> is {@code {2, 3}}, then SLL
+# parsing will get an error because SLL will pursue alternative 1. If
+# <em>s</em> is {@code {1, 2}} or {@code {1, 3}} then both SLL and LL will
+# choose the same alternative because alternative one is the minimum of either
+# set. If <em>s</em> is {@code {2}} or {@code {3}} then SLL will get a syntax
+# error. If <em>s</em> is {@code {1}} then SLL will succeed.</p>
+#
+# <p>
+# Of course, if the input is invalid, then we will get an error for sure in
+# both SLL and LL parsing. Erroneous input will therefore require 2 passes over
+# the input.</p>
+#
+from __future__ import print_function
+import sys
+from antlr4.PredictionContext import PredictionContext, SingletonPredictionContext, PredictionContextFromRuleContext
+from antlr4.ParserRuleContext import ParserRuleContext
+from antlr4.Token import Token
+from antlr4.Utils import str_list
+from antlr4.atn.ATN import ATN
+from antlr4.atn.ATNConfig import ATNConfig
+from antlr4.atn.ATNConfigSet import ATNConfigSet
+from antlr4.atn.ATNSimulator import ATNSimulator
+from antlr4.atn.ATNState import StarLoopEntryState, RuleStopState
+from antlr4.atn.PredictionMode import PredictionMode
+from antlr4.atn.SemanticContext import SemanticContext, AND, andContext, orContext
+from antlr4.atn.Transition import Transition, RuleTransition, ActionTransition, AtomTransition, SetTransition, NotSetTransition
+from antlr4.dfa.DFAState import DFAState, PredPrediction
+from antlr4.error.Errors import NoViableAltException
+
+
+class ParserATNSimulator(ATNSimulator):
+
+    debug = False
+    debug_list_atn_decisions = False
+    dfa_debug = False
+    retry_debug = False
+
+
+    def __init__(self, parser, atn, decisionToDFA, sharedContextCache):
+        super(ParserATNSimulator, self).__init__(atn, sharedContextCache)
+        self.parser = parser
+        self.decisionToDFA = decisionToDFA
+        # SLL, LL, or LL + exact ambig detection?#
+        self.predictionMode = PredictionMode.LL
+        # LAME globals to avoid parameters!!!!! I need these down deep in predTransition
+        self._input = None
+        self._startIndex = 0
+        self._outerContext = None
+        self._dfa = None
+        # Each prediction operation uses a cache for merge of prediction contexts.
+        #  Don't keep around as it wastes huge amounts of memory. DoubleKeyMap
+        #  isn't synchronized but we're ok since two threads shouldn't reuse same
+        #  parser/atnsim object because it can only handle one input at a time.
+        #  This maps graphs a and b to merged result c. (a,b)&rarr;c. We can avoid
+        #  the merge if we ever see a and b again.  Note that (b,a)&rarr;c should
+        #  also be examined during cache lookup.
+        #
+        self.mergeCache = None
+
+
+    def reset(self):
+        pass
+
+    def adaptivePredict(self, input, decision, outerContext):
+        if self.debug or self.debug_list_atn_decisions:
+            print("adaptivePredict decision " + str(decision) +
+                                   " exec LA(1)==" + self.getLookaheadName(input) +
+                                   " line " + str(input.LT(1).line) + ":" +
+                                   str(input.LT(1).column))
+        self._input = input
+        self._startIndex = input.index
+        self._outerContext = outerContext
+        
+        dfa = self.decisionToDFA[decision]
+        self._dfa = dfa
+        m = input.mark()
+        index = input.index
+
+        # Now we are certain to have a specific decision's DFA
+        # But, do we still need an initial state?
+        try:
+            if dfa.precedenceDfa:
+                # the start state for a precedence DFA depends on the current
+                # parser precedence, and is provided by a DFA method.
+                s0 = dfa.getPrecedenceStartState(self.parser.getPrecedence())
+            else:
+                # the start state for a "regular" DFA is just s0
+                s0 = dfa.s0
+
+            if s0 is None:
+                if outerContext is None:
+                    outerContext = ParserRuleContext.EMPTY
+                if self.debug or self.debug_list_atn_decisions:
+                    print("predictATN decision " + str(dfa.decision) +
+                                       " exec LA(1)==" + self.getLookaheadName(input) +
+                                       ", outerContext=" + outerContext.toString(self.parser))
+
+                # If this is not a precedence DFA, we check the ATN start state
+                # to determine if this ATN start state is the decision for the
+                # closure block that determines whether a precedence rule
+                # should continue or complete.
+                #
+                if not dfa.precedenceDfa and isinstance(dfa.atnStartState, StarLoopEntryState):
+                    if dfa.atnStartState.precedenceRuleDecision:
+                        dfa.setPrecedenceDfa(True)
+
+                fullCtx = False
+                s0_closure = self.computeStartState(dfa.atnStartState, ParserRuleContext.EMPTY, fullCtx)
+
+                if dfa.precedenceDfa:
+                    # If this is a precedence DFA, we use applyPrecedenceFilter
+                    # to convert the computed start state to a precedence start
+                    # state. We then use DFA.setPrecedenceStartState to set the
+                    # appropriate start state for the precedence level rather
+                    # than simply setting DFA.s0.
+                    #
+                    s0_closure = self.applyPrecedenceFilter(s0_closure)
+                    s0 = self.addDFAState(dfa, DFAState(configs=s0_closure))
+                    dfa.setPrecedenceStartState(self.parser.getPrecedence(), s0)
+                else:
+                    s0 = self.addDFAState(dfa, DFAState(configs=s0_closure))
+                    dfa.s0 = s0
+
+            alt = self.execATN(dfa, s0, input, index, outerContext)
+            if self.debug:
+                print("DFA after predictATN: " + dfa.toString(self.parser.tokenNames))
+            return alt
+        finally:
+            self._dfa = None
+            self.mergeCache = None # wack cache after each prediction
+            input.seek(index)
+            input.release(m)
+
+    # Performs ATN simulation to compute a predicted alternative based
+    #  upon the remaining input, but also updates the DFA cache to avoid
+    #  having to traverse the ATN again for the same input sequence.
+
+    # There are some key conditions we're looking for after computing a new
+    # set of ATN configs (proposed DFA state):
+    # if the set is empty, there is no viable alternative for current symbol
+    # does the state uniquely predict an alternative?
+    # does the state have a conflict that would prevent us from
+    #   putting it on the work list?
+
+    # We also have some key operations to do:
+    # add an edge from previous DFA state to potentially new DFA state, D,
+    #   upon current symbol but only if adding to work list, which means in all
+    #   cases except no viable alternative (and possibly non-greedy decisions?)
+    # collecting predicates and adding semantic context to DFA accept states
+    # adding rule context to context-sensitive DFA accept states
+    # consuming an input symbol
+    # reporting a conflict
+    # reporting an ambiguity
+    # reporting a context sensitivity
+    # reporting insufficient predicates
+
+    # cover these cases:
+    #    dead end
+    #    single alt
+    #    single alt + preds
+    #    conflict
+    #    conflict + preds
+    #
+    def execATN(self, dfa, s0, input, startIndex, outerContext ):
+        if self.debug or self.debug_list_atn_decisions:
+            print("execATN decision " + str(dfa.decision) +
+                    " exec LA(1)==" + self.getLookaheadName(input) +
+                    " line " + str(input.LT(1).line) + ":" + str(input.LT(1).column))
+
+        previousD = s0
+
+        if self.debug:
+            print("s0 = " + str(s0))
+
+        t = input.LA(1)
+
+        while True: # while more work
+            D = self.getExistingTargetState(previousD, t)
+            if D is None:
+                D = self.computeTargetState(dfa, previousD, t)
+            if D is self.ERROR:
+                # if any configs in previous dipped into outer context, that
+                # means that input up to t actually finished entry rule
+                # at least for SLL decision. Full LL doesn't dip into outer
+                # so don't need special case.
+                # We will get an error no matter what so delay until after
+                # decision; better error message. Also, no reachable target
+                # ATN states in SLL implies LL will also get nowhere.
+                # If conflict in states that dip out, choose min since we
+                # will get error no matter what.
+                e = self.noViableAlt(input, outerContext, previousD.configs, startIndex)
+                input.seek(startIndex)
+                alt = self.getSynValidOrSemInvalidAltThatFinishedDecisionEntryRule(previousD.configs, outerContext)
+                if alt!=ATN.INVALID_ALT_NUMBER:
+                    return alt
+                raise e
+
+            if D.requiresFullContext and self.predictionMode != PredictionMode.SLL:
+                # IF PREDS, MIGHT RESOLVE TO SINGLE ALT => SLL (or syntax error)
+                conflictingAlts = None
+                if D.predicates is not None:
+                    if self.debug:
+                        print("DFA state has preds in DFA sim LL failover")
+                    conflictIndex = input.index
+                    if conflictIndex != startIndex:
+                        input.seek(startIndex)
+
+                    conflictingAlts = self.evalSemanticContext(D.predicates, outerContext, True)
+                    if len(conflictingAlts)==1:
+                        if self.debug:
+                            print("Full LL avoided")
+                        return min(conflictingAlts)
+
+                    if conflictIndex != startIndex:
+                        # restore the index so reporting the fallback to full
+                        # context occurs with the index at the correct spot
+                        input.seek(conflictIndex)
+
+                if self.dfa_debug:
+                    print("ctx sensitive state " + str(outerContext) +" in " + str(D))
+                fullCtx = True
+                s0_closure = self.computeStartState(dfa.atnStartState, outerContext, fullCtx)
+                self.reportAttemptingFullContext(dfa, conflictingAlts, D.configs, startIndex, input.index)
+                alt = self.execATNWithFullContext(dfa, D, s0_closure, input, startIndex, outerContext)
+                return alt
+
+            if D.isAcceptState:
+                if D.predicates is None:
+                    return D.prediction
+
+                stopIndex = input.index
+                input.seek(startIndex)
+                alts = self.evalSemanticContext(D.predicates, outerContext, True)
+                if len(alts)==0:
+                    raise self.noViableAlt(input, outerContext, D.configs, startIndex)
+                elif len(alts)==1:
+                    return min(alts)
+                else:
+                    # report ambiguity after predicate evaluation to make sure the correct
+                    # set of ambig alts is reported.
+                    self.reportAmbiguity(dfa, D, startIndex, stopIndex, False, alts, D.configs)
+                    return min(alts)
+
+            previousD = D
+
+            if t != Token.EOF:
+                input.consume()
+                t = input.LA(1)
+
+    #
+    # Get an existing target state for an edge in the DFA. If the target state
+    # for the edge has not yet been computed or is otherwise not available,
+    # this method returns {@code null}.
+    #
+    # @param previousD The current DFA state
+    # @param t The next input symbol
+    # @return The existing target DFA state for the given input symbol
+    # {@code t}, or {@code null} if the target state for this edge is not
+    # already cached
+    #
+    def getExistingTargetState(self, previousD, t):
+        edges = previousD.edges
+        if edges is None or t + 1 < 0 or t + 1 >= len(edges):
+            return None
+        else:
+            return edges[t + 1]
+
+    #
+    # Compute a target state for an edge in the DFA, and attempt to add the
+    # computed state and corresponding edge to the DFA.
+    #
+    # @param dfa The DFA
+    # @param previousD The current DFA state
+    # @param t The next input symbol
+    #
+    # @return The computed target DFA state for the given input symbol
+    # {@code t}. If {@code t} does not lead to a valid DFA state, this method
+    # returns {@link #ERROR}.
+    #
+    def computeTargetState(self, dfa, previousD, t):
+        reach = self.computeReachSet(previousD.configs, t, False)
+        if reach is None:
+            self.addDFAEdge(dfa, previousD, t, self.ERROR)
+            return self.ERROR
+
+        # create new target state; we'll add to DFA after it's complete
+        D = DFAState(configs=reach)
+
+        predictedAlt = self.getUniqueAlt(reach)
+
+        if self.debug:
+            altSubSets = PredictionMode.getConflictingAltSubsets(reach)
+            print("SLL altSubSets=" + str(altSubSets) + ", configs=" + str(reach) +
+                        ", predict=" + str(predictedAlt) + ", allSubsetsConflict=" +
+                        str(PredictionMode.allSubsetsConflict(altSubSets)) + ", conflictingAlts=" +
+                        str(self.getConflictingAlts(reach)))
+
+        if predictedAlt!=ATN.INVALID_ALT_NUMBER:
+            # NO CONFLICT, UNIQUELY PREDICTED ALT
+            D.isAcceptState = True
+            D.configs.uniqueAlt = predictedAlt
+            D.prediction = predictedAlt
+        elif PredictionMode.hasSLLConflictTerminatingPrediction(self.predictionMode, reach):
+            # MORE THAN ONE VIABLE ALTERNATIVE
+            D.configs.conflictingAlts = self.getConflictingAlts(reach)
+            D.requiresFullContext = True
+            # in SLL-only mode, we will stop at this state and return the minimum alt
+            D.isAcceptState = True
+            D.prediction = min(D.configs.conflictingAlts)
+
+        if D.isAcceptState and D.configs.hasSemanticContext:
+            self.predicateDFAState(D, self.atn.getDecisionState(dfa.decision))
+            if D.predicates is not None:
+                D.prediction = ATN.INVALID_ALT_NUMBER
+
+        # all adds to dfa are done after we've created full D state
+        D = self.addDFAEdge(dfa, previousD, t, D)
+        return D
+
+    def predicateDFAState(self, dfaState, decisionState):
+        # We need to test all predicates, even in DFA states that
+        # uniquely predict alternative.
+        nalts = len(decisionState.transitions)
+        # Update DFA so reach becomes accept state with (predicate,alt)
+        # pairs if preds found for conflicting alts
+        altsToCollectPredsFrom = self.getConflictingAltsOrUniqueAlt(dfaState.configs)
+        altToPred = self.getPredsForAmbigAlts(altsToCollectPredsFrom, dfaState.configs, nalts)
+        if altToPred is not None:
+            dfaState.predicates = self.getPredicatePredictions(altsToCollectPredsFrom, altToPred)
+            dfaState.prediction = ATN.INVALID_ALT_NUMBER # make sure we use preds
+        else:
+            # There are preds in configs but they might go away
+            # when OR'd together like {p}? || NONE == NONE. If neither
+            # alt has preds, resolve to min alt
+            dfaState.prediction = min(altsToCollectPredsFrom)
+
+    # comes back with reach.uniqueAlt set to a valid alt
+    def execATNWithFullContext(self, dfa, D, # how far we got before failing over
+                                         s0,
+                                         input,
+                                         startIndex,
+                                         outerContext):
+        if self.debug or self.debug_list_atn_decisions:
+            print("execATNWithFullContext "+s0)
+        fullCtx = True
+        foundExactAmbig = False
+        reach = None
+        previous = s0
+        input.seek(startIndex)
+        t = input.LA(1)
+        predictedAlt = -1
+        while (True): # while more work
+            reach = self.computeReachSet(previous, t, fullCtx)
+            if reach is None:
+                # if any configs in previous dipped into outer context, that
+                # means that input up to t actually finished entry rule
+                # at least for LL decision. Full LL doesn't dip into outer
+                # so don't need special case.
+                # We will get an error no matter what so delay until after
+                # decision; better error message. Also, no reachable target
+                # ATN states in SLL implies LL will also get nowhere.
+                # If conflict in states that dip out, choose min since we
+                # will get error no matter what.
+                e = self.noViableAlt(input, outerContext, previous, startIndex)
+                input.seek(startIndex)
+                alt = self.getSynValidOrSemInvalidAltThatFinishedDecisionEntryRule(previous, outerContext)
+                if alt!=ATN.INVALID_ALT_NUMBER:
+                    return alt
+                else:
+                    raise e
+
+            altSubSets = PredictionMode.getConflictingAltSubsets(reach)
+            if self.debug:
+                print("LL altSubSets=" + str(altSubSets) + ", predict=" +
+                      str(PredictionMode.getUniqueAlt(altSubSets)) + ", resolvesToJustOneViableAlt=" +
+                      str(PredictionMode.resolvesToJustOneViableAlt(altSubSets)))
+
+            reach.uniqueAlt = self.getUniqueAlt(reach)
+            # unique prediction?
+            if reach.uniqueAlt!=ATN.INVALID_ALT_NUMBER:
+                predictedAlt = reach.uniqueAlt
+                break
+            elif self.predictionMode is not PredictionMode.LL_EXACT_AMBIG_DETECTION:
+                predictedAlt = PredictionMode.resolvesToJustOneViableAlt(altSubSets)
+                if predictedAlt != ATN.INVALID_ALT_NUMBER:
+                    break
+            else:
+                # In exact ambiguity mode, we never try to terminate early.
+                # Just keeps scarfing until we know what the conflict is
+                if PredictionMode.allSubsetsConflict(altSubSets) and PredictionMode.allSubsetsEqual(altSubSets):
+                    foundExactAmbig = True
+                    predictedAlt = PredictionMode.getSingleViableAlt(altSubSets)
+                    break
+                # else there are multiple non-conflicting subsets or
+                # we're not sure what the ambiguity is yet.
+                # So, keep going.
+
+            previous = reach
+            if t != Token.EOF:
+                input.consume()
+                t = input.LA(1)
+
+        # If the configuration set uniquely predicts an alternative,
+        # without conflict, then we know that it's a full LL decision
+        # not SLL.
+        if reach.uniqueAlt != ATN.INVALID_ALT_NUMBER :
+            self.reportContextSensitivity(dfa, predictedAlt, reach, startIndex, input.index)
+            return predictedAlt
+
+        # We do not check predicates here because we have checked them
+        # on-the-fly when doing full context prediction.
+
+        #
+        # In non-exact ambiguity detection mode, we might	actually be able to
+        # detect an exact ambiguity, but I'm not going to spend the cycles
+        # needed to check. We only emit ambiguity warnings in exact ambiguity
+        # mode.
+        #
+        # For example, we might know that we have conflicting configurations.
+        # But, that does not mean that there is no way forward without a
+        # conflict. It's possible to have nonconflicting alt subsets as in:
+
+        # altSubSets=[{1, 2}, {1, 2}, {1}, {1, 2}]
+
+        # from
+        #
+        #    [(17,1,[5 $]), (13,1,[5 10 $]), (21,1,[5 10 $]), (11,1,[$]),
+        #     (13,2,[5 10 $]), (21,2,[5 10 $]), (11,2,[$])]
+        #
+        # In this case, (17,1,[5 $]) indicates there is some next sequence that
+        # would resolve this without conflict to alternative 1. Any other viable
+        # next sequence, however, is associated with a conflict.  We stop
+        # looking for input because no amount of further lookahead will alter
+        # the fact that we should predict alternative 1.  We just can't say for
+        # sure that there is an ambiguity without looking further.
+
+        self.reportAmbiguity(dfa, D, startIndex, input.index, foundExactAmbig, None, reach)
+
+        return predictedAlt
+
+    def computeReachSet(self, closure, t, fullCtx):
+        if self.debug:
+            print("in computeReachSet, starting closure: " + str(closure))
+
+        if self.mergeCache is None:
+            self.mergeCache = dict()
+
+        intermediate = ATNConfigSet(fullCtx)
+
+        # Configurations already in a rule stop state indicate reaching the end
+        # of the decision rule (local context) or end of the start rule (full
+        # context). Once reached, these configurations are never updated by a
+        # closure operation, so they are handled separately for the performance
+        # advantage of having a smaller intermediate set when calling closure.
+        #
+        # For full-context reach operations, separate handling is required to
+        # ensure that the alternative matching the longest overall sequence is
+        # chosen when multiple such configurations can match the input.
+        
+        skippedStopStates = None
+
+        # First figure out where we can reach on input t
+        for c in closure:
+            if self.debug:
+                print("testing " + self.getTokenName(t) + " at " + str(c))
+
+            if isinstance(c.state, RuleStopState):
+                if fullCtx or t == Token.EOF:
+                    if skippedStopStates is None:
+                        skippedStopStates = list()
+                    skippedStopStates.append(c)
+                continue
+
+            for trans in c.state.transitions:
+                target = self.getReachableTarget(trans, t)
+                if target is not None:
+                    intermediate.add(ATNConfig(state=target, config=c), self.mergeCache)
+
+        # Now figure out where the reach operation can take us...
+
+        reach = None
+
+        # This block optimizes the reach operation for intermediate sets which
+        # trivially indicate a termination state for the overall
+        # adaptivePredict operation.
+        #
+        # The conditions assume that intermediate
+        # contains all configurations relevant to the reach set, but this
+        # condition is not true when one or more configurations have been
+        # withheld in skippedStopStates , or when the current symbol is EOF.
+        #
+        if skippedStopStates is None and t!=Token.EOF:
+            if len(intermediate)==1:
+                # Don't pursue the closure if there is just one state.
+                # It can only have one alternative; just add to result
+                # Also don't pursue the closure if there is unique alternative
+                # among the configurations.
+                reach = intermediate
+            elif self.getUniqueAlt(intermediate)!=ATN.INVALID_ALT_NUMBER:
+                # Also don't pursue the closure if there is unique alternative
+                # among the configurations.
+                reach = intermediate
+
+        # If the reach set could not be trivially determined, perform a closure
+        # operation on the intermediate set to compute its initial value.
+        #
+        if reach is None:
+            reach = ATNConfigSet(fullCtx)
+            closureBusy = set()
+            treatEofAsEpsilon = t == Token.EOF
+            for c in intermediate:
+                self.closure(c, reach, closureBusy, False, fullCtx, treatEofAsEpsilon)
+
+        if t == Token.EOF:
+            # After consuming EOF no additional input is possible, so we are
+            # only interested in configurations which reached the end of the
+            # decision rule (local context) or end of the start rule (full
+            # context). Update reach to contain only these configurations. This
+            # handles both explicit EOF transitions in the grammar and implicit
+            # EOF transitions following the end of the decision or start rule.
+            #
+            # When reach==intermediate, no closure operation was performed. In
+            # this case, removeAllConfigsNotInRuleStopState needs to check for
+            # reachable rule stop states as well as configurations already in
+            # a rule stop state.
+            #
+            # This is handled before the configurations in skippedStopStates,
+            # because any configurations potentially added from that list are
+            # already guaranteed to meet this condition whether or not it's
+            # required.
+            #
+            reach = self.removeAllConfigsNotInRuleStopState(reach, reach is intermediate)
+
+        # If skippedStopStates is not null, then it contains at least one
+        # configuration. For full-context reach operations, these
+        # configurations reached the end of the start rule, in which case we
+        # only add them back to reach if no configuration during the current
+        # closure operation reached such a state. This ensures adaptivePredict
+        # chooses an alternative matching the longest overall sequence when
+        # multiple alternatives are viable.
+        #
+        if skippedStopStates is not None and ( (not fullCtx) or (not PredictionMode.hasConfigInRuleStopState(reach))):
+            for c in skippedStopStates:
+                reach.add(c, self.mergeCache)
+        if len(reach)==0:
+            return None
+        else:
+            return reach
+
+    #
+    # Return a configuration set containing only the configurations from
+    # {@code configs} which are in a {@link RuleStopState}. If all
+    # configurations in {@code configs} are already in a rule stop state, this
+    # method simply returns {@code configs}.
+    #
+    # <p>When {@code lookToEndOfRule} is true, this method uses
+    # {@link ATN#nextTokens} for each configuration in {@code configs} which is
+    # not already in a rule stop state to see if a rule stop state is reachable
+    # from the configuration via epsilon-only transitions.</p>
+    #
+    # @param configs the configuration set to update
+    # @param lookToEndOfRule when true, this method checks for rule stop states
+    # reachable by epsilon-only transitions from each configuration in
+    # {@code configs}.
+    #
+    # @return {@code configs} if all configurations in {@code configs} are in a
+    # rule stop state, otherwise return a new configuration set containing only
+    # the configurations from {@code configs} which are in a rule stop state
+    #
+    def removeAllConfigsNotInRuleStopState(self, configs, lookToEndOfRule):
+        if PredictionMode.allConfigsInRuleStopStates(configs):
+            return configs
+        result = ATNConfigSet(configs.fullCtx)
+        for config in configs:
+            if isinstance(config.state, RuleStopState):
+                result.add(config, self.mergeCache)
+                continue
+            if lookToEndOfRule and config.state.epsilonOnlyTransitions:
+                nextTokens = self.atn.nextTokens(config.state)
+                if Token.EPSILON in nextTokens:
+                    endOfRuleState = self.atn.ruleToStopState[config.state.ruleIndex]
+                    result.add(ATNConfig(state=endOfRuleState, config=config), self.mergeCache)
+        return result
+
+    def computeStartState(self, p, ctx, fullCtx):
+        # always at least the implicit call to start rule
+        initialContext = PredictionContextFromRuleContext(self.atn, ctx)
+        configs = ATNConfigSet(fullCtx)
+
+        for i in range(0, len(p.transitions)):
+            target = p.transitions[i].target
+            c = ATNConfig(target, i+1, initialContext)
+            closureBusy = set()
+            self.closure(c, configs, closureBusy, True, fullCtx, False)
+        return configs
+
+    #
+    # This method transforms the start state computed by
+    # {@link #computeStartState} to the special start state used by a
+    # precedence DFA for a particular precedence value. The transformation
+    # process applies the following changes to the start state's configuration
+    # set.
+    #
+    # <ol>
+    # <li>Evaluate the precedence predicates for each configuration using
+    # {@link SemanticContext#evalPrecedence}.</li>
+    # <li>Remove all configurations which predict an alternative greater than
+    # 1, for which another configuration that predicts alternative 1 is in the
+    # same ATN state with the same prediction context. This transformation is
+    # valid for the following reasons:
+    # <ul>
+    # <li>The closure block cannot contain any epsilon transitions which bypass
+    # the body of the closure, so all states reachable via alternative 1 are
+    # part of the precedence alternatives of the transformed left-recursive
+    # rule.</li>
+    # <li>The "primary" portion of a left recursive rule cannot contain an
+    # epsilon transition, so the only way an alternative other than 1 can exist
+    # in a state that is also reachable via alternative 1 is by nesting calls
+    # to the left-recursive rule, with the outer calls not being at the
+    # preferred precedence level.</li>
+    # </ul>
+    # </li>
+    # </ol>
+    #
+    # <p>
+    # The prediction context must be considered by this filter to address
+    # situations like the following.
+    # </p>
+    # <code>
+    # <pre>
+    # grammar TA;
+    # prog: statement* EOF;
+    # statement: letterA | statement letterA 'b' ;
+    # letterA: 'a';
+    # </pre>
+    # </code>
+    # <p>
+    # If the above grammar, the ATN state immediately before the token
+    # reference {@code 'a'} in {@code letterA} is reachable from the left edge
+    # of both the primary and closure blocks of the left-recursive rule
+    # {@code statement}. The prediction context associated with each of these
+    # configurations distinguishes between them, and prevents the alternative
+    # which stepped out to {@code prog} (and then back in to {@code statement}
+    # from being eliminated by the filter.
+    # </p>
+    #
+    # @param configs The configuration set computed by
+    # {@link #computeStartState} as the start state for the DFA.
+    # @return The transformed configuration set representing the start state
+    # for a precedence DFA at a particular precedence level (determined by
+    # calling {@link Parser#getPrecedence}).
+    #
+    def applyPrecedenceFilter(self, configs):
+        statesFromAlt1 = dict()
+        configSet = ATNConfigSet(configs.fullCtx)
+        for config in configs:
+            # handle alt 1 first
+            if config.alt != 1:
+                continue
+            updatedContext = config.semanticContext.evalPrecedence(self.parser, self._outerContext)
+            if updatedContext is None:
+                # the configuration was eliminated
+                continue
+
+            statesFromAlt1[config.state.stateNumber] = config.context
+            if updatedContext is not config.semanticContext:
+                configSet.add(ATNConfig(config=config, semantic=updatedContext), self.mergeCache)
+            else:
+                configSet.add(config, self.mergeCache)
+
+        for config in configs:
+            if config.alt == 1:
+                # already handled
+                continue
+
+            # In the future, this elimination step could be updated to also
+            # filter the prediction context for alternatives predicting alt>1
+            # (basically a graph subtraction algorithm).
+            #
+            if not config.precedenceFilterSuppressed:
+                context = statesFromAlt1.get(config.state.stateNumber, None)
+                if context==config.context:
+                    # eliminated
+                    continue
+
+            configSet.add(config, self.mergeCache)
+
+        return configSet
+
+    def getReachableTarget(self, trans, ttype):
+        if trans.matches(ttype, 0, self.atn.maxTokenType):
+            return trans.target
+        else:
+            return None
+
+    def getPredsForAmbigAlts(self, ambigAlts, configs, nalts):
+        # REACH=[1|1|[]|0:0, 1|2|[]|0:1]
+        # altToPred starts as an array of all null contexts. The entry at index i
+        # corresponds to alternative i. altToPred[i] may have one of three values:
+        #   1. null: no ATNConfig c is found such that c.alt==i
+        #   2. SemanticContext.NONE: At least one ATNConfig c exists such that
+        #      c.alt==i and c.semanticContext==SemanticContext.NONE. In other words,
+        #      alt i has at least one unpredicated config.
+        #   3. Non-NONE Semantic Context: There exists at least one, and for all
+        #      ATNConfig c such that c.alt==i, c.semanticContext!=SemanticContext.NONE.
+        #
+        # From this, it is clear that NONE||anything==NONE.
+        #
+        altToPred = [None] * (nalts + 1)
+        for c in configs:
+            if c.alt in ambigAlts:
+                altToPred[c.alt] = orContext(altToPred[c.alt], c.semanticContext)
+
+        nPredAlts = 0
+        for i in range(1, nalts+1):
+            if altToPred[i] is None:
+                altToPred[i] = SemanticContext.NONE
+            elif altToPred[i] is not SemanticContext.NONE:
+                nPredAlts += 1
+
+        # nonambig alts are null in altToPred
+        if nPredAlts==0:
+            altToPred = None
+        if self.debug:
+            print("getPredsForAmbigAlts result " + str_list(altToPred))
+        return altToPred
+
+    def getPredicatePredictions(self, ambigAlts, altToPred):
+        pairs = []
+        containsPredicate = False
+        for i in range(1, len(altToPred)):
+            pred = altToPred[i]
+            # unpredicated is indicated by SemanticContext.NONE
+            if ambigAlts is not None and i in ambigAlts:
+                pairs.append(PredPrediction(pred, i))
+            if pred is not SemanticContext.NONE:
+                containsPredicate = True
+
+        if not containsPredicate:
+            return None
+
+        return pairs
+
+    #
+    # This method is used to improve the localization of error messages by
+    # choosing an alternative rather than throwing a
+    # {@link NoViableAltException} in particular prediction scenarios where the
+    # {@link #ERROR} state was reached during ATN simulation.
+    #
+    # <p>
+    # The default implementation of this method uses the following
+    # algorithm to identify an ATN configuration which successfully parsed the
+    # decision entry rule. Choosing such an alternative ensures that the
+    # {@link ParserRuleContext} returned by the calling rule will be complete
+    # and valid, and the syntax error will be reported later at a more
+    # localized location.</p>
+    #
+    # <ul>
+    # <li>If a syntactically valid path or paths reach the end of the decision rule and
+    # they are semantically valid if predicated, return the min associated alt.</li>
+    # <li>Else, if a semantically invalid but syntactically valid path exist
+    # or paths exist, return the minimum associated alt.
+    # </li>
+    # <li>Otherwise, return {@link ATN#INVALID_ALT_NUMBER}.</li>
+    # </ul>
+    #
+    # <p>
+    # In some scenarios, the algorithm described above could predict an
+    # alternative which will result in a {@link FailedPredicateException} in
+    # the parser. Specifically, this could occur if the <em>only</em> configuration
+    # capable of successfully parsing to the end of the decision rule is
+    # blocked by a semantic predicate. By choosing this alternative within
+    # {@link #adaptivePredict} instead of throwing a
+    # {@link NoViableAltException}, the resulting
+    # {@link FailedPredicateException} in the parser will identify the specific
+    # predicate which is preventing the parser from successfully parsing the
+    # decision rule, which helps developers identify and correct logic errors
+    # in semantic predicates.
+    # </p>
+    #
+    # @param configs The ATN configurations which were valid immediately before
+    # the {@link #ERROR} state was reached
+    # @param outerContext The is the \gamma_0 initial parser context from the paper
+    # or the parser stack at the instant before prediction commences.
+    #
+    # @return The value to return from {@link #adaptivePredict}, or
+    # {@link ATN#INVALID_ALT_NUMBER} if a suitable alternative was not
+    # identified and {@link #adaptivePredict} should report an error instead.
+    #
+    def getSynValidOrSemInvalidAltThatFinishedDecisionEntryRule(self, configs, outerContext):
+        semValidConfigs, semInvalidConfigs = self.splitAccordingToSemanticValidity(configs, outerContext)
+        alt = self.getAltThatFinishedDecisionEntryRule(semValidConfigs)
+        if alt!=ATN.INVALID_ALT_NUMBER: # semantically/syntactically viable path exists
+            return alt
+        # Is there a syntactically valid path with a failed pred?
+        if len(semInvalidConfigs)>0:
+            alt = self.getAltThatFinishedDecisionEntryRule(semInvalidConfigs)
+            if alt!=ATN.INVALID_ALT_NUMBER: # syntactically viable path exists
+                return alt
+        return ATN.INVALID_ALT_NUMBER
+
+    def getAltThatFinishedDecisionEntryRule(self, configs):
+        alts = set()
+        for c in configs:
+            if c.reachesIntoOuterContext>0 or (isinstance(c.state, RuleStopState) and c.context.hasEmptyPath() ):
+                alts.add(c.alt)
+        if len(alts)==0:
+            return ATN.INVALID_ALT_NUMBER
+        else:
+            return min(alts)
+
+    # Walk the list of configurations and split them according to
+    #  those that have preds evaluating to true/false.  If no pred, assume
+    #  true pred and include in succeeded set.  Returns Pair of sets.
+    #
+    #  Create a new set so as not to alter the incoming parameter.
+    #
+    #  Assumption: the input stream has been restored to the starting point
+    #  prediction, which is where predicates need to evaluate.
+    #
+    def splitAccordingToSemanticValidity(self, configs, outerContext):
+        succeeded = ATNConfigSet(configs.fullCtx)
+        failed = ATNConfigSet(configs.fullCtx)
+        for c in configs:
+            if c.semanticContext is not SemanticContext.NONE:
+                predicateEvaluationResult = c.semanticContext.eval(self.parser, outerContext)
+                if predicateEvaluationResult:
+                    succeeded.add(c)
+                else:
+                    failed.add(c)
+            else:
+                succeeded.add(c)
+        return (succeeded,failed)
+
+    # Look through a list of predicate/alt pairs, returning alts for the
+    #  pairs that win. A {@code NONE} predicate indicates an alt containing an
+    #  unpredicated config which behaves as "always true." If !complete
+    #  then we stop at the first predicate that evaluates to true. This
+    #  includes pairs with null predicates.
+    #
+    def evalSemanticContext(self, predPredictions, outerContext, complete):
+        predictions = set()
+        for pair in predPredictions:
+            if pair.pred is SemanticContext.NONE:
+                predictions.add(pair.alt)
+                if not complete:
+                    break
+                continue
+            predicateEvaluationResult = pair.pred.eval(self.parser, outerContext)
+            if self.debug or self.dfa_debug:
+                print("eval pred " + str(pair) + "=" + str(predicateEvaluationResult))
+
+            if predicateEvaluationResult:
+                if self.debug or self.dfa_debug:
+                    print("PREDICT " + str(pair.alt))
+                predictions.add(pair.alt)
+                if not complete:
+                    break
+        return predictions
+
+
+    # TODO: If we are doing predicates, there is no point in pursuing
+    #     closure operations if we reach a DFA state that uniquely predicts
+    #     alternative. We will not be caching that DFA state and it is a
+    #     waste to pursue the closure. Might have to advance when we do
+    #     ambig detection thought :(
+    #
+
+    def closure(self, config, configs, closureBusy, collectPredicates, fullCtx, treatEofAsEpsilon):
+        initialDepth = 0;
+        self.closureCheckingStopState(config, configs, closureBusy, collectPredicates,
+                                 fullCtx, initialDepth, treatEofAsEpsilon)
+
+
+    def closureCheckingStopState(self, config, configs, closureBusy, collectPredicates, fullCtx, depth, treatEofAsEpsilon):
+        if self.debug:
+            print("closure(" + config.toString(self.parser,True) + ")")
+
+        if isinstance(config.state, RuleStopState):
+            # We hit rule end. If we have context info, use it
+            # run thru all possible stack tops in ctx
+            if not config.context.isEmpty():
+                for i in range(0, len(config.context)):
+                    state = config.context.getReturnState(i)
+                    if state is PredictionContext.EMPTY_RETURN_STATE:
+                        if fullCtx:
+                            configs.add(ATNConfig(state=config.state, context=PredictionContext.EMPTY, config=config), self.mergeCache)
+                            continue
+                        else:
+                            # we have no context info, just chase follow links (if greedy)
+                            if self.debug:
+                                print("FALLING off rule " + self.getRuleName(config.state.ruleIndex))
+                            self.closure_(config, configs, closureBusy, collectPredicates,
+                                     fullCtx, depth, treatEofAsEpsilon)
+                        continue
+                    returnState = self.atn.states[state]
+                    newContext = config.context.getParent(i) # "pop" return state
+                    c = ATNConfig(state=returnState, alt=config.alt, context=newContext, semantic=config.semanticContext)
+                    # While we have context to pop back from, we may have
+                    # gotten that context AFTER having falling off a rule.
+                    # Make sure we track that we are now out of context.
+                    c.reachesIntoOuterContext = config.reachesIntoOuterContext
+                    self.closureCheckingStopState(c, configs, closureBusy, collectPredicates, fullCtx, depth - 1, treatEofAsEpsilon)
+                return
+            elif fullCtx:
+                # reached end of start rule
+                configs.add(config, self.mergeCache)
+                return
+            else:
+                # else if we have no context info, just chase follow links (if greedy)
+                if self.debug:
+                    print("FALLING off rule " + self.getRuleName(config.state.ruleIndex))
+
+        self.closure_(config, configs, closureBusy, collectPredicates, fullCtx, depth, treatEofAsEpsilon)
+
+    # Do the actual work of walking epsilon edges#
+    def closure_(self, config, configs, closureBusy, collectPredicates, fullCtx, depth, treatEofAsEpsilon):
+        p = config.state
+        # optimization
+        if not p.epsilonOnlyTransitions:
+            configs.add(config, self.mergeCache)
+            # make sure to not return here, because EOF transitions can act as
+            # both epsilon transitions and non-epsilon transitions.
+
+        for t in p.transitions:
+            continueCollecting = collectPredicates and not isinstance(t, ActionTransition)
+            c = self.getEpsilonTarget(config, t, continueCollecting, depth == 0, fullCtx, treatEofAsEpsilon)
+            if c is not None:
+                if not t.isEpsilon:
+                    if c in closureBusy:
+                        # avoid infinite recursion for EOF* and EOF+
+                        continue
+                    closureBusy.add(c)
+                newDepth = depth
+                if isinstance( config.state, RuleStopState):
+                    # target fell off end of rule; mark resulting c as having dipped into outer context
+                    # We can't get here if incoming config was rule stop and we had context
+                    # track how far we dip into outer context.  Might
+                    # come in handy and we avoid evaluating context dependent
+                    # preds if this is > 0.
+
+                    if c in closureBusy:
+                        # avoid infinite recursion for right-recursive rules
+                        continue
+                    closureBusy.add(c)
+
+                    if self._dfa is not None and self._dfa.precedenceDfa:
+                        if t.outermostPrecedenceReturn == self._dfa.atnStartState.ruleIndex:
+                            c.precedenceFilterSuppressed = True
+                    c.reachesIntoOuterContext += 1
+                    configs.dipsIntoOuterContext = True # TODO: can remove? only care when we add to set per middle of this method
+                    newDepth -= 1
+                    if self.debug:
+                        print("dips into outer ctx: " + str(c))
+                elif isinstance(t, RuleTransition):
+                    # latch when newDepth goes negative - once we step out of the entry context we can't return
+                    if newDepth >= 0:
+                        newDepth += 1
+
+                self.closureCheckingStopState(c, configs, closureBusy, continueCollecting, fullCtx, newDepth, treatEofAsEpsilon)
+
+    def getRuleName(self, index):
+        if self.parser is not None and index>=0:
+            return self.parser.ruleNames[index]
+        else:
+            return "<rule " + str(index) + ">"
+
+    epsilonTargetMethods = dict()
+    epsilonTargetMethods[Transition.RULE] = lambda sim, config, t, collectPredicates, inContext, fullCtx, treatEofAsEpsilon: \
+        sim.ruleTransition(config, t)
+    epsilonTargetMethods[Transition.PRECEDENCE] = lambda sim, config, t, collectPredicates, inContext, fullCtx, treatEofAsEpsilon: \
+        sim.precedenceTransition(config, t, collectPredicates, inContext, fullCtx)
+    epsilonTargetMethods[Transition.PREDICATE] = lambda sim, config, t, collectPredicates, inContext, fullCtx, treatEofAsEpsilon: \
+        sim.predTransition(config, t, collectPredicates, inContext, fullCtx)
+    epsilonTargetMethods[Transition.ACTION] = lambda sim, config, t, collectPredicates, inContext, fullCtx, treatEofAsEpsilon: \
+        sim.actionTransition(config, t)
+    epsilonTargetMethods[Transition.EPSILON] = lambda sim, config, t, collectPredicates, inContext, fullCtx, treatEofAsEpsilon: \
+        ATNConfig(state=t.target, config=config)
+    epsilonTargetMethods[Transition.ATOM] = lambda sim, config, t, collectPredicates, inContext, fullCtx, treatEofAsEpsilon: \
+        ATNConfig(state=t.target, config=config) if treatEofAsEpsilon and t.matches(Token.EOF, 0, 1) else None
+    epsilonTargetMethods[Transition.RANGE] = lambda sim, config, t, collectPredicates, inContext, fullCtx, treatEofAsEpsilon: \
+        ATNConfig(state=t.target, config=config) if treatEofAsEpsilon and t.matches(Token.EOF, 0, 1) else None
+    epsilonTargetMethods[Transition.SET] = lambda sim, config, t, collectPredicates, inContext, fullCtx, treatEofAsEpsilon: \
+        ATNConfig(state=t.target, config=config) if treatEofAsEpsilon and t.matches(Token.EOF, 0, 1) else None
+
+    def getEpsilonTarget(self, config, t, collectPredicates, inContext, fullCtx, treatEofAsEpsilon):
+        m = self.epsilonTargetMethods.get(t.serializationType, None)
+        if m is None:
+            return None
+        else:
+            return m(self, config, t, collectPredicates, inContext, fullCtx, treatEofAsEpsilon)
+
+    def actionTransition(self, config, t):
+        if self.debug:
+            print("ACTION edge " + str(t.ruleIndex) + ":" + str(t.actionIndex))
+        return ATNConfig(state=t.target, config=config)
+
+    def precedenceTransition(self, config, pt,  collectPredicates, inContext, fullCtx):
+        if self.debug:
+            print("PRED (collectPredicates=" + str(collectPredicates) + ") " +
+                    str(pt.precedence) + ">=_p, ctx dependent=true")
+            if self.parser is not None:
+                print("context surrounding pred is " + str(self.parser.getRuleInvocationStack()))
+
+        c = None
+        if collectPredicates and inContext:
+            if fullCtx:
+                # In full context mode, we can evaluate predicates on-the-fly
+                # during closure, which dramatically reduces the size of
+                # the config sets. It also obviates the need to test predicates
+                # later during conflict resolution.
+                currentPosition = self._input.index
+                self._input.seek(self._startIndex)
+                predSucceeds = pt.getPredicate().eval(self.parser, self._outerContext)
+                self._input.seek(currentPosition)
+                if predSucceeds:
+                    c = ATNConfig(state=pt.target, config=config) # no pred context
+            else:
+                newSemCtx = andContext(config.semanticContext, pt.getPredicate())
+                c = ATNConfig(state=pt.target, semantic=newSemCtx, config=config)
+        else:
+            c = ATNConfig(state=pt.target, config=config)
+
+        if self.debug:
+            print("config from pred transition=" + str(c))
+        return c
+
+    def predTransition(self, config, pt, collectPredicates, inContext, fullCtx):
+        if self.debug:
+            print("PRED (collectPredicates=" + str(collectPredicates) + ") " + str(pt.ruleIndex) +
+                    ":" + str(pt.predIndex) + ", ctx dependent=" + str(pt.isCtxDependent))
+            if self.parser is not None:
+                print("context surrounding pred is " + str(self.parser.getRuleInvocationStack()))
+
+        c = None
+        if collectPredicates and (not pt.isCtxDependent or (pt.isCtxDependent and inContext)):
+            if fullCtx:
+                # In full context mode, we can evaluate predicates on-the-fly
+                # during closure, which dramatically reduces the size of
+                # the config sets. It also obviates the need to test predicates
+                # later during conflict resolution.
+                currentPosition = self._input.index
+                self._input.seek(self._startIndex)
+                predSucceeds = pt.getPredicate().eval(self.parser, self._outerContext)
+                self._input.seek(currentPosition)
+                if predSucceeds:
+                    c = ATNConfig(state=pt.target, config=config) # no pred context
+            else:
+                newSemCtx = andContext(config.semanticContext, pt.getPredicate())
+                c = ATNConfig(state=pt.target, semantic=newSemCtx, config=config)
+        else:
+            c = ATNConfig(state=pt.target, config=config)
+
+        if self.debug:
+            print("config from pred transition=" + str(c))
+        return c
+
+    def ruleTransition(self, config, t):
+        if self.debug:
+            print("CALL rule " + self.getRuleName(t.target.ruleIndex) + ", ctx=" + str(config.context))
+        returnState = t.followState
+        newContext = SingletonPredictionContext.create(config.context, returnState.stateNumber)
+        return ATNConfig(state=t.target, context=newContext, config=config )
+
+    def getConflictingAlts(self, configs):
+        altsets = PredictionMode.getConflictingAltSubsets(configs)
+        return PredictionMode.getAlts(altsets)
+
+    # Sam pointed out a problem with the previous definition, v3, of
+    # ambiguous states. If we have another state associated with conflicting
+    # alternatives, we should keep going. For example, the following grammar
+    #
+    # s : (ID | ID ID?) ';' ;
+    #
+    # When the ATN simulation reaches the state before ';', it has a DFA
+    # state that looks like: [12|1|[], 6|2|[], 12|2|[]]. Naturally
+    # 12|1|[] and 12|2|[] conflict, but we cannot stop processing this node
+    # because alternative to has another way to continue, via [6|2|[]].
+    # The key is that we have a single state that has config's only associated
+    # with a single alternative, 2, and crucially the state transitions
+    # among the configurations are all non-epsilon transitions. That means
+    # we don't consider any conflicts that include alternative 2. So, we
+    # ignore the conflict between alts 1 and 2. We ignore a set of
+    # conflicting alts when there is an intersection with an alternative
+    # associated with a single alt state in the state&rarr;config-list map.
+    #
+    # It's also the case that we might have two conflicting configurations but
+    # also a 3rd nonconflicting configuration for a different alternative:
+    # [1|1|[], 1|2|[], 8|3|[]]. This can come about from grammar:
+    #
+    # a : A | A | A B ;
+    #
+    # After matching input A, we reach the stop state for rule A, state 1.
+    # State 8 is the state right before B. Clearly alternatives 1 and 2
+    # conflict and no amount of further lookahead will separate the two.
+    # However, alternative 3 will be able to continue and so we do not
+    # stop working on this state. In the previous example, we're concerned
+    # with states associated with the conflicting alternatives. Here alt
+    # 3 is not associated with the conflicting configs, but since we can continue
+    # looking for input reasonably, I don't declare the state done. We
+    # ignore a set of conflicting alts when we have an alternative
+    # that we still need to pursue.
+    #
+
+    def getConflictingAltsOrUniqueAlt(self, configs):
+        conflictingAlts = None
+        if configs.uniqueAlt!= ATN.INVALID_ALT_NUMBER:
+            conflictingAlts = set()
+            conflictingAlts.add(configs.uniqueAlt)
+        else:
+            conflictingAlts = configs.conflictingAlts
+        return conflictingAlts
+
+    def getTokenName(self, t):
+        if t==Token.EOF:
+            return u"EOF"
+        if self.parser is not None and self.parser.tokenNames is not None:
+            if t >= len(self.parser.tokenNames):
+                print(str(t) + " ttype out of range: " + str_list(self.parser.tokenNames))
+                print(str_list(self.parser.getInputStream().getTokens()))
+            else:
+                return self.parser.tokensNames[t] + u"<" + unicode(t) + ">"
+        return unicode(t)
+
+    def getLookaheadName(self, input):
+        return self.getTokenName(input.LA(1))
+
+    # Used for debugging in adaptivePredict around execATN but I cut
+    #  it out for clarity now that alg. works well. We can leave this
+    #  "dead" code for a bit.
+    #
+    def dumpDeadEndConfigs(self, nvae):
+        print("dead end configs: ")
+        for c in nvae.getDeadEndConfigs():
+            trans = "no edges"
+            if len(c.state.transitions)>0:
+                t = c.state.transitions[0]
+                if isinstance(t, AtomTransition):
+                    trans = "Atom "+ self.getTokenName(t.label)
+                elif isinstance(t, SetTransition):
+                    neg = isinstance(t, NotSetTransition)
+                    trans = ("~" if neg else "")+"Set "+ str(t.set)
+            print(c.toString(self.parser, True) + ":" + trans, file=sys.stderr)
+
+    def noViableAlt(self, input, outerContext, configs, startIndex):
+        return NoViableAltException(self.parser, input, input.get(startIndex), input.LT(1), configs, outerContext)
+
+    def getUniqueAlt(self, configs):
+        alt = ATN.INVALID_ALT_NUMBER
+        for c in configs:
+            if alt == ATN.INVALID_ALT_NUMBER:
+                alt = c.alt # found first alt
+            elif c.alt!=alt:
+                return ATN.INVALID_ALT_NUMBER
+        return alt
+
+    #
+    # Add an edge to the DFA, if possible. This method calls
+    # {@link #addDFAState} to ensure the {@code to} state is present in the
+    # DFA. If {@code from} is {@code null}, or if {@code t} is outside the
+    # range of edges that can be represented in the DFA tables, this method
+    # returns without adding the edge to the DFA.
+    #
+    # <p>If {@code to} is {@code null}, this method returns {@code null}.
+    # Otherwise, this method returns the {@link DFAState} returned by calling
+    # {@link #addDFAState} for the {@code to} state.</p>
+    #
+    # @param dfa The DFA
+    # @param from The source state for the edge
+    # @param t The input symbol
+    # @param to The target state for the edge
+    #
+    # @return If {@code to} is {@code null}, this method returns {@code null};
+    # otherwise this method returns the result of calling {@link #addDFAState}
+    # on {@code to}
+    #
+    def addDFAEdge(self, dfa, from_, t, to):
+        if self.debug:
+            print("EDGE " + str(from_) + " -> " + str(to) + " upon " + self.getTokenName(t))
+
+        if to is None:
+            return None
+
+        to = self.addDFAState(dfa, to) # used existing if possible not incoming
+        if from_ is None or t < -1 or t > self.atn.maxTokenType:
+            return to
+
+        if from_.edges is None:
+            from_.edges = [None] * (self.atn.maxTokenType + 2)
+        from_.edges[t+1] = to # connect
+
+        if self.debug:
+            names = None if self.parser is None else self.parser.tokenNames
+            print("DFA=\n" + dfa.toString(names))
+
+        return to
+
+    #
+    # Add state {@code D} to the DFA if it is not already present, and return
+    # the actual instance stored in the DFA. If a state equivalent to {@code D}
+    # is already in the DFA, the existing state is returned. Otherwise this
+    # method returns {@code D} after adding it to the DFA.
+    #
+    # <p>If {@code D} is {@link #ERROR}, this method returns {@link #ERROR} and
+    # does not change the DFA.</p>
+    #
+    # @param dfa The dfa
+    # @param D The DFA state to add
+    # @return The state stored in the DFA. This will be either the existing
+    # state if {@code D} is already in the DFA, or {@code D} itself if the
+    # state was not already present.
+    #
+    def addDFAState(self, dfa, D):
+        if D is self.ERROR:
+            return D
+
+
+        existing = dfa.states.get(D, None)
+        if existing is not None:
+            return existing
+
+        D.stateNumber = len(dfa.states)
+        if not D.configs.readonly:
+            D.configs.optimizeConfigs(self)
+            D.configs.setReadonly(True)
+        dfa.states[D] = D
+        if self.debug:
+            print("adding new DFA state: " + str(D))
+        return D
+
+    def reportAttemptingFullContext(self, dfa, conflictingAlts, configs, startIndex, stopIndex):
+        if self.debug or self.retry_debug:
+            interval = range(startIndex, stopIndex + 1)
+            print("reportAttemptingFullContext decision=" + str(dfa.decision) + ":" + str(configs) +
+                               ", input=" + self.parser.getTokenStream().getText(interval))
+        if self.parser is not None:
+            self.parser.getErrorListenerDispatch().reportAttemptingFullContext(self.parser, dfa, startIndex, stopIndex, conflictingAlts, configs)
+
+    def reportContextSensitivity(self, dfa, prediction, configs, startIndex, stopIndex):
+        if self.debug or self.retry_debug:
+            interval = range(startIndex, stopIndex + 1)
+            print("reportContextSensitivity decision=" + str(dfa.decision) + ":" + str(configs) +
+                               ", input=" + self.parser.getTokenStream().getText(interval))
+        if self.parser is not None:
+            self.parser.getErrorListenerDispatch().reportContextSensitivity(self.parser, dfa, startIndex, stopIndex, prediction, configs)
+
+    # If context sensitive parsing, we know it's ambiguity not conflict#
+    def reportAmbiguity(self, dfa, D, startIndex, stopIndex,
+                                   exact, ambigAlts, configs ):
+        if self.debug or self.retry_debug:
+#			ParserATNPathFinder finder = new ParserATNPathFinder(parser, atn);
+#			int i = 1;
+#			for (Transition t : dfa.atnStartState.transitions) {
+#				print("ALT "+i+"=");
+#				print(startIndex+".."+stopIndex+", len(input)="+parser.getInputStream().size());
+#				TraceTree path = finder.trace(t.target, parser.getContext(), (TokenStream)parser.getInputStream(),
+#											  startIndex, stopIndex);
+#				if ( path!=null ) {
+#					print("path = "+path.toStringTree());
+#					for (TraceTree leaf : path.leaves) {
+#						List<ATNState> states = path.getPathToNode(leaf);
+#						print("states="+states);
+#					}
+#				}
+#				i++;
+#			}
+            interval = range(startIndex, stopIndex + 1)
+            print("reportAmbiguity " + str(ambigAlts) + ":" + str(configs) +
+                               ", input=" + self.parser.getTokenStream().getText(interval))
+        if self.parser is not None:
+            self.parser.getErrorListenerDispatch().reportAmbiguity(self.parser, dfa, startIndex, stopIndex, exact, ambigAlts, configs)
+
diff --git a/runtime/Python2/src/antlr4/atn/PredictionMode.py b/runtime/Python2/src/antlr4/atn/PredictionMode.py
new file mode 100644
index 000000000..c01641972
--- /dev/null
+++ b/runtime/Python2/src/antlr4/atn/PredictionMode.py
@@ -0,0 +1,544 @@
+#
+# [The "BSD license"]
+#  Copyright (c) 2012 Terence Parr
+#  Copyright (c) 2012 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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.
+#
+#
+# This enumeration defines the prediction modes available in ANTLR 4 along with
+# utility methods for analyzing configuration sets for conflicts and/or
+# ambiguities.
+
+
+from antlr4.atn.ATN import ATN
+from antlr4.atn.ATNConfig import ATNConfig
+from antlr4.atn.ATNConfigSet import ATNConfigSet
+from antlr4.atn.ATNState import RuleStopState
+from antlr4.atn.SemanticContext import SemanticContext
+
+class PredictionMode(object):
+    #
+    # The SLL(*) prediction mode. This prediction mode ignores the current
+    # parser context when making predictions. This is the fastest prediction
+    # mode, and provides correct results for many grammars. This prediction
+    # mode is more powerful than the prediction mode provided by ANTLR 3, but
+    # may result in syntax errors for grammar and input combinations which are
+    # not SLL.
+    #
+    # <p>
+    # When using this prediction mode, the parser will either return a correct
+    # parse tree (i.e. the same parse tree that would be returned with the
+    # {@link #LL} prediction mode), or it will report a syntax error. If a
+    # syntax error is encountered when using the {@link #SLL} prediction mode,
+    # it may be due to either an actual syntax error in the input or indicate
+    # that the particular combination of grammar and input requires the more
+    # powerful {@link #LL} prediction abilities to complete successfully.</p>
+    #
+    # <p>
+    # This prediction mode does not provide any guarantees for prediction
+    # behavior for syntactically-incorrect inputs.</p>
+    #
+    SLL = 0
+    #
+    # The LL(*) prediction mode. This prediction mode allows the current parser
+    # context to be used for resolving SLL conflicts that occur during
+    # prediction. This is the fastest prediction mode that guarantees correct
+    # parse results for all combinations of grammars with syntactically correct
+    # inputs.
+    #
+    # <p>
+    # When using this prediction mode, the parser will make correct decisions
+    # for all syntactically-correct grammar and input combinations. However, in
+    # cases where the grammar is truly ambiguous this prediction mode might not
+    # report a precise answer for <em>exactly which</em> alternatives are
+    # ambiguous.</p>
+    #
+    # <p>
+    # This prediction mode does not provide any guarantees for prediction
+    # behavior for syntactically-incorrect inputs.</p>
+    #
+    LL = 1
+    #
+    # The LL(*) prediction mode with exact ambiguity detection. In addition to
+    # the correctness guarantees provided by the {@link #LL} prediction mode,
+    # this prediction mode instructs the prediction algorithm to determine the
+    # complete and exact set of ambiguous alternatives for every ambiguous
+    # decision encountered while parsing.
+    #
+    # <p>
+    # This prediction mode may be used for diagnosing ambiguities during
+    # grammar development. Due to the performance overhead of calculating sets
+    # of ambiguous alternatives, this prediction mode should be avoided when
+    # the exact results are not necessary.</p>
+    #
+    # <p>
+    # This prediction mode does not provide any guarantees for prediction
+    # behavior for syntactically-incorrect inputs.</p>
+    #
+    LL_EXACT_AMBIG_DETECTION = 2
+
+
+    #
+    # Computes the SLL prediction termination condition.
+    #
+    # <p>
+    # This method computes the SLL prediction termination condition for both of
+    # the following cases.</p>
+    #
+    # <ul>
+    # <li>The usual SLL+LL fallback upon SLL conflict</li>
+    # <li>Pure SLL without LL fallback</li>
+    # </ul>
+    #
+    # <p><strong>COMBINED SLL+LL PARSING</strong></p>
+    #
+    # <p>When LL-fallback is enabled upon SLL conflict, correct predictions are
+    # ensured regardless of how the termination condition is computed by this
+    # method. Due to the substantially higher cost of LL prediction, the
+    # prediction should only fall back to LL when the additional lookahead
+    # cannot lead to a unique SLL prediction.</p>
+    #
+    # <p>Assuming combined SLL+LL parsing, an SLL configuration set with only
+    # conflicting subsets should fall back to full LL, even if the
+    # configuration sets don't resolve to the same alternative (e.g.
+    # {@code {1,2}} and {@code {3,4}}. If there is at least one non-conflicting
+    # configuration, SLL could continue with the hopes that more lookahead will
+    # resolve via one of those non-conflicting configurations.</p>
+    #
+    # <p>Here's the prediction termination rule them: SLL (for SLL+LL parsing)
+    # stops when it sees only conflicting configuration subsets. In contrast,
+    # full LL keeps going when there is uncertainty.</p>
+    #
+    # <p><strong>HEURISTIC</strong></p>
+    #
+    # <p>As a heuristic, we stop prediction when we see any conflicting subset
+    # unless we see a state that only has one alternative associated with it.
+    # The single-alt-state thing lets prediction continue upon rules like
+    # (otherwise, it would admit defeat too soon):</p>
+    #
+    # <p>{@code [12|1|[], 6|2|[], 12|2|[]]. s : (ID | ID ID?) ';' ;}</p>
+    #
+    # <p>When the ATN simulation reaches the state before {@code ';'}, it has a
+    # DFA state that looks like: {@code [12|1|[], 6|2|[], 12|2|[]]}. Naturally
+    # {@code 12|1|[]} and {@code 12|2|[]} conflict, but we cannot stop
+    # processing this node because alternative to has another way to continue,
+    # via {@code [6|2|[]]}.</p>
+    #
+    # <p>It also let's us continue for this rule:</p>
+    #
+    # <p>{@code [1|1|[], 1|2|[], 8|3|[]] a : A | A | A B ;}</p>
+    #
+    # <p>After matching input A, we reach the stop state for rule A, state 1.
+    # State 8 is the state right before B. Clearly alternatives 1 and 2
+    # conflict and no amount of further lookahead will separate the two.
+    # However, alternative 3 will be able to continue and so we do not stop
+    # working on this state. In the previous example, we're concerned with
+    # states associated with the conflicting alternatives. Here alt 3 is not
+    # associated with the conflicting configs, but since we can continue
+    # looking for input reasonably, don't declare the state done.</p>
+    #
+    # <p><strong>PURE SLL PARSING</strong></p>
+    #
+    # <p>To handle pure SLL parsing, all we have to do is make sure that we
+    # combine stack contexts for configurations that differ only by semantic
+    # predicate. From there, we can do the usual SLL termination heuristic.</p>
+    #
+    # <p><strong>PREDICATES IN SLL+LL PARSING</strong></p>
+    #
+    # <p>SLL decisions don't evaluate predicates until after they reach DFA stop
+    # states because they need to create the DFA cache that works in all
+    # semantic situations. In contrast, full LL evaluates predicates collected
+    # during start state computation so it can ignore predicates thereafter.
+    # This means that SLL termination detection can totally ignore semantic
+    # predicates.</p>
+    #
+    # <p>Implementation-wise, {@link ATNConfigSet} combines stack contexts but not
+    # semantic predicate contexts so we might see two configurations like the
+    # following.</p>
+    #
+    # <p>{@code (s, 1, x, {}), (s, 1, x', {p})}</p>
+    #
+    # <p>Before testing these configurations against others, we have to merge
+    # {@code x} and {@code x'} (without modifying the existing configurations).
+    # For example, we test {@code (x+x')==x''} when looking for conflicts in
+    # the following configurations.</p>
+    #
+    # <p>{@code (s, 1, x, {}), (s, 1, x', {p}), (s, 2, x'', {})}</p>
+    #
+    # <p>If the configuration set has predicates (as indicated by
+    # {@link ATNConfigSet#hasSemanticContext}), this algorithm makes a copy of
+    # the configurations to strip out all of the predicates so that a standard
+    # {@link ATNConfigSet} will merge everything ignoring predicates.</p>
+    #
+    @classmethod
+    def hasSLLConflictTerminatingPrediction(cls, mode, configs):
+        # Configs in rule stop states indicate reaching the end of the decision
+        # rule (local context) or end of start rule (full context). If all
+        # configs meet this condition, then none of the configurations is able
+        # to match additional input so we terminate prediction.
+        #
+        if cls.allConfigsInRuleStopStates(configs):
+            return True
+
+        # pure SLL mode parsing
+        if mode == PredictionMode.SLL:
+            # Don't bother with combining configs from different semantic
+            # contexts if we can fail over to full LL; costs more time
+            # since we'll often fail over anyway.
+            if configs.hasSemanticContext:
+                # dup configs, tossing out semantic predicates
+                dup = ATNConfigSet()
+                for c in configs:
+                    c = ATNConfig(c,SemanticContext.NONE)
+                    dup.add(c)
+                configs = dup
+            # now we have combined contexts for configs with dissimilar preds
+
+        # pure SLL or combined SLL+LL mode parsing
+        altsets = cls.getConflictingAltSubsets(configs)
+        return cls.hasConflictingAltSet(altsets) and not cls.hasStateAssociatedWithOneAlt(configs)
+
+    # Checks if any configuration in {@code configs} is in a
+    # {@link RuleStopState}. Configurations meeting this condition have reached
+    # the end of the decision rule (local context) or end of start rule (full
+    # context).
+    #
+    # @param configs the configuration set to test
+    # @return {@code true} if any configuration in {@code configs} is in a
+    # {@link RuleStopState}, otherwise {@code false}
+    @classmethod
+    def hasConfigInRuleStopState(cls, configs):
+        for c in configs:
+            if isinstance(c.state, RuleStopState):
+                return True
+        return False
+
+    # Checks if all configurations in {@code configs} are in a
+    # {@link RuleStopState}. Configurations meeting this condition have reached
+    # the end of the decision rule (local context) or end of start rule (full
+    # context).
+    #
+    # @param configs the configuration set to test
+    # @return {@code true} if all configurations in {@code configs} are in a
+    # {@link RuleStopState}, otherwise {@code false}
+    @classmethod
+    def allConfigsInRuleStopStates(cls, configs):
+        for config in configs:
+            if not isinstance(config.state, RuleStopState):
+                return False
+        return True
+
+    #
+    # Full LL prediction termination.
+    #
+    # <p>Can we stop looking ahead during ATN simulation or is there some
+    # uncertainty as to which alternative we will ultimately pick, after
+    # consuming more input? Even if there are partial conflicts, we might know
+    # that everything is going to resolve to the same minimum alternative. That
+    # means we can stop since no more lookahead will change that fact. On the
+    # other hand, there might be multiple conflicts that resolve to different
+    # minimums. That means we need more look ahead to decide which of those
+    # alternatives we should predict.</p>
+    #
+    # <p>The basic idea is to split the set of configurations {@code C}, into
+    # conflicting subsets {@code (s, _, ctx, _)} and singleton subsets with
+    # non-conflicting configurations. Two configurations conflict if they have
+    # identical {@link ATNConfig#state} and {@link ATNConfig#context} values
+    # but different {@link ATNConfig#alt} value, e.g. {@code (s, i, ctx, _)}
+    # and {@code (s, j, ctx, _)} for {@code i!=j}.</p>
+    #
+    # <p>Reduce these configuration subsets to the set of possible alternatives.
+    # You can compute the alternative subsets in one pass as follows:</p>
+    #
+    # <p>{@code A_s,ctx = {i | (s, i, ctx, _)}} for each configuration in
+    # {@code C} holding {@code s} and {@code ctx} fixed.</p>
+    #
+    # <p>Or in pseudo-code, for each configuration {@code c} in {@code C}:</p>
+    #
+    # <pre>
+    # map[c] U= c.{@link ATNConfig#alt alt} # map hash/equals uses s and x, not
+    # alt and not pred
+    # </pre>
+    #
+    # <p>The values in {@code map} are the set of {@code A_s,ctx} sets.</p>
+    #
+    # <p>If {@code |A_s,ctx|=1} then there is no conflict associated with
+    # {@code s} and {@code ctx}.</p>
+    #
+    # <p>Reduce the subsets to singletons by choosing a minimum of each subset. If
+    # the union of these alternative subsets is a singleton, then no amount of
+    # more lookahead will help us. We will always pick that alternative. If,
+    # however, there is more than one alternative, then we are uncertain which
+    # alternative to predict and must continue looking for resolution. We may
+    # or may not discover an ambiguity in the future, even if there are no
+    # conflicting subsets this round.</p>
+    #
+    # <p>The biggest sin is to terminate early because it means we've made a
+    # decision but were uncertain as to the eventual outcome. We haven't used
+    # enough lookahead. On the other hand, announcing a conflict too late is no
+    # big deal; you will still have the conflict. It's just inefficient. It
+    # might even look until the end of file.</p>
+    #
+    # <p>No special consideration for semantic predicates is required because
+    # predicates are evaluated on-the-fly for full LL prediction, ensuring that
+    # no configuration contains a semantic context during the termination
+    # check.</p>
+    #
+    # <p><strong>CONFLICTING CONFIGS</strong></p>
+    #
+    # <p>Two configurations {@code (s, i, x)} and {@code (s, j, x')}, conflict
+    # when {@code i!=j} but {@code x=x'}. Because we merge all
+    # {@code (s, i, _)} configurations together, that means that there are at
+    # most {@code n} configurations associated with state {@code s} for
+    # {@code n} possible alternatives in the decision. The merged stacks
+    # complicate the comparison of configuration contexts {@code x} and
+    # {@code x'}. Sam checks to see if one is a subset of the other by calling
+    # merge and checking to see if the merged result is either {@code x} or
+    # {@code x'}. If the {@code x} associated with lowest alternative {@code i}
+    # is the superset, then {@code i} is the only possible prediction since the
+    # others resolve to {@code min(i)} as well. However, if {@code x} is
+    # associated with {@code j>i} then at least one stack configuration for
+    # {@code j} is not in conflict with alternative {@code i}. The algorithm
+    # should keep going, looking for more lookahead due to the uncertainty.</p>
+    #
+    # <p>For simplicity, I'm doing a equality check between {@code x} and
+    # {@code x'} that lets the algorithm continue to consume lookahead longer
+    # than necessary. The reason I like the equality is of course the
+    # simplicity but also because that is the test you need to detect the
+    # alternatives that are actually in conflict.</p>
+    #
+    # <p><strong>CONTINUE/STOP RULE</strong></p>
+    #
+    # <p>Continue if union of resolved alternative sets from non-conflicting and
+    # conflicting alternative subsets has more than one alternative. We are
+    # uncertain about which alternative to predict.</p>
+    #
+    # <p>The complete set of alternatives, {@code [i for (_,i,_)]}, tells us which
+    # alternatives are still in the running for the amount of input we've
+    # consumed at this point. The conflicting sets let us to strip away
+    # configurations that won't lead to more states because we resolve
+    # conflicts to the configuration with a minimum alternate for the
+    # conflicting set.</p>
+    #
+    # <p><strong>CASES</strong></p>
+    #
+    # <ul>
+    #
+    # <li>no conflicts and more than 1 alternative in set =&gt; continue</li>
+    #
+    # <li> {@code (s, 1, x)}, {@code (s, 2, x)}, {@code (s, 3, z)},
+    # {@code (s', 1, y)}, {@code (s', 2, y)} yields non-conflicting set
+    # {@code {3}} U conflicting sets {@code min({1,2})} U {@code min({1,2})} =
+    # {@code {1,3}} =&gt; continue
+    # </li>
+    #
+    # <li>{@code (s, 1, x)}, {@code (s, 2, x)}, {@code (s', 1, y)},
+    # {@code (s', 2, y)}, {@code (s'', 1, z)} yields non-conflicting set
+    # {@code {1}} U conflicting sets {@code min({1,2})} U {@code min({1,2})} =
+    # {@code {1}} =&gt; stop and predict 1</li>
+    #
+    # <li>{@code (s, 1, x)}, {@code (s, 2, x)}, {@code (s', 1, y)},
+    # {@code (s', 2, y)} yields conflicting, reduced sets {@code {1}} U
+    # {@code {1}} = {@code {1}} =&gt; stop and predict 1, can announce
+    # ambiguity {@code {1,2}}</li>
+    #
+    # <li>{@code (s, 1, x)}, {@code (s, 2, x)}, {@code (s', 2, y)},
+    # {@code (s', 3, y)} yields conflicting, reduced sets {@code {1}} U
+    # {@code {2}} = {@code {1,2}} =&gt; continue</li>
+    #
+    # <li>{@code (s, 1, x)}, {@code (s, 2, x)}, {@code (s', 3, y)},
+    # {@code (s', 4, y)} yields conflicting, reduced sets {@code {1}} U
+    # {@code {3}} = {@code {1,3}} =&gt; continue</li>
+    #
+    # </ul>
+    #
+    # <p><strong>EXACT AMBIGUITY DETECTION</strong></p>
+    #
+    # <p>If all states report the same conflicting set of alternatives, then we
+    # know we have the exact ambiguity set.</p>
+    #
+    # <p><code>|A_<em>i</em>|&gt;1</code> and
+    # <code>A_<em>i</em> = A_<em>j</em></code> for all <em>i</em>, <em>j</em>.</p>
+    #
+    # <p>In other words, we continue examining lookahead until all {@code A_i}
+    # have more than one alternative and all {@code A_i} are the same. If
+    # {@code A={{1,2}, {1,3}}}, then regular LL prediction would terminate
+    # because the resolved set is {@code {1}}. To determine what the real
+    # ambiguity is, we have to know whether the ambiguity is between one and
+    # two or one and three so we keep going. We can only stop prediction when
+    # we need exact ambiguity detection when the sets look like
+    # {@code A={{1,2}}} or {@code {{1,2},{1,2}}}, etc...</p>
+    #
+    @classmethod
+    def resolvesToJustOneViableAlt(cls, altsets):
+        return cls.getSingleViableAlt(altsets)
+
+    #
+    # Determines if every alternative subset in {@code altsets} contains more
+    # than one alternative.
+    #
+    # @param altsets a collection of alternative subsets
+    # @return {@code true} if every {@link BitSet} in {@code altsets} has
+    # {@link BitSet#cardinality cardinality} &gt; 1, otherwise {@code false}
+    #
+    @classmethod
+    def allSubsetsConflict(cls, altsets):
+        return not cls.hasNonConflictingAltSet(altsets)
+
+    #
+    # Determines if any single alternative subset in {@code altsets} contains
+    # exactly one alternative.
+    #
+    # @param altsets a collection of alternative subsets
+    # @return {@code true} if {@code altsets} contains a {@link BitSet} with
+    # {@link BitSet#cardinality cardinality} 1, otherwise {@code false}
+    #
+    @classmethod
+    def hasNonConflictingAltSet(cls, altsets):
+        for alts in altsets:
+            if len(alts)==1:
+                return True
+        return False
+
+    #
+    # Determines if any single alternative subset in {@code altsets} contains
+    # more than one alternative.
+    #
+    # @param altsets a collection of alternative subsets
+    # @return {@code true} if {@code altsets} contains a {@link BitSet} with
+    # {@link BitSet#cardinality cardinality} &gt; 1, otherwise {@code false}
+    #
+    @classmethod
+    def hasConflictingAltSet(cls, altsets):
+        for alts in altsets:
+            if len(alts)>1:
+                return True
+        return False
+
+    #
+    # Determines if every alternative subset in {@code altsets} is equivalent.
+    #
+    # @param altsets a collection of alternative subsets
+    # @return {@code true} if every member of {@code altsets} is equal to the
+    # others, otherwise {@code false}
+    #
+    @classmethod
+    def allSubsetsEqual(cls, altsets):
+        first = None
+        for alts in altsets:
+            if first is None:
+                first = alts
+            elif not alts==first:
+                return False
+        return True
+
+    #
+    # Returns the unique alternative predicted by all alternative subsets in
+    # {@code altsets}. If no such alternative exists, this method returns
+    # {@link ATN#INVALID_ALT_NUMBER}.
+    #
+    # @param altsets a collection of alternative subsets
+    #
+    @classmethod
+    def getUniqueAlt(cls, altsets):
+        all = cls.getAlts(altsets)
+        if len(all)==1:
+            return all[0]
+        else:
+            return ATN.INVALID_ALT_NUMBER
+
+    # Gets the complete set of represented alternatives for a collection of
+    # alternative subsets. This method returns the union of each {@link BitSet}
+    # in {@code altsets}.
+    #
+    # @param altsets a collection of alternative subsets
+    # @return the set of represented alternatives in {@code altsets}
+    #
+    @classmethod
+    def getAlts(cls, altsets):
+        all = set()
+        for alts in altsets:
+            all = all | alts
+        return all
+
+    #
+    # This function gets the conflicting alt subsets from a configuration set.
+    # For each configuration {@code c} in {@code configs}:
+    #
+    # <pre>
+    # map[c] U= c.{@link ATNConfig#alt alt} # map hash/equals uses s and x, not
+    # alt and not pred
+    # </pre>
+    #
+    @classmethod
+    def getConflictingAltSubsets(cls, configs):
+        configToAlts = dict()
+        for c in configs:
+            h = hash((c.state.stateNumber, c.context))
+            alts = configToAlts.get(h, None)
+            if alts is None:
+                alts = set()
+                configToAlts[h] = alts
+            alts.add(c.alt)
+        return configToAlts.values()
+
+    #
+    # Get a map from state to alt subset from a configuration set. For each
+    # configuration {@code c} in {@code configs}:
+    #
+    # <pre>
+    # map[c.{@link ATNConfig#state state}] U= c.{@link ATNConfig#alt alt}
+    # </pre>
+    #
+    @classmethod
+    def getStateToAltMap(cls, configs):
+        m = dict()
+        for c in configs:
+            alts = m.get(c.state, None)
+            if alts is None:
+                alts = set()
+                m[c.state] = alts
+            alts.add(c.alt)
+        return m
+
+    @classmethod
+    def hasStateAssociatedWithOneAlt(cls, configs):
+        x = cls.getStateToAltMap(configs)
+        for alts in x.values():
+            if len(alts)==1:
+                return True
+        return False
+
+    @classmethod
+    def getSingleViableAlt(cls, altsets):
+        viableAlts = set()
+        for alts in altsets:
+            minAlt = min(alts)
+            viableAlts.add(minAlt);
+            if len(viableAlts)>1 : # more than 1 viable alt
+                return ATN.INVALID_ALT_NUMBER
+        return min(viableAlts)
diff --git a/runtime/Python2/src/antlr4/atn/SemanticContext.py b/runtime/Python2/src/antlr4/atn/SemanticContext.py
new file mode 100644
index 000000000..021d4770c
--- /dev/null
+++ b/runtime/Python2/src/antlr4/atn/SemanticContext.py
@@ -0,0 +1,360 @@
+#
+# [The "BSD license"]
+#  Copyright (c) 2012 Terence Parr
+#  Copyright (c) 2012 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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 tree structure used to record the semantic context in which
+#  an ATN configuration is valid.  It's either a single predicate,
+#  a conjunction {@code p1&&p2}, or a sum of products {@code p1||p2}.
+#
+#  <p>I have scoped the {@link AND}, {@link OR}, and {@link Predicate} subclasses of
+#  {@link SemanticContext} within the scope of this outer class.</p>
+#
+from io import StringIO
+
+
+class SemanticContext(object):
+    #
+    # The default {@link SemanticContext}, which is semantically equivalent to
+    # a predicate of the form {@code {true}?}.
+    #
+    NONE = None
+
+    #
+    # For context independent predicates, we evaluate them without a local
+    # context (i.e., null context). That way, we can evaluate them without
+    # having to create proper rule-specific context during prediction (as
+    # opposed to the parser, which creates them naturally). In a practical
+    # sense, this avoids a cast exception from RuleContext to myruleContext.
+    #
+    # <p>For context dependent predicates, we must pass in a local context so that
+    # references such as $arg evaluate properly as _localctx.arg. We only
+    # capture context dependent predicates in the context in which we begin
+    # prediction, so we passed in the outer context here in case of context
+    # dependent predicate evaluation.</p>
+    #
+    def eval(self, parser, outerContext):
+        pass
+
+    #
+    # Evaluate the precedence predicates for the context and reduce the result.
+    #
+    # @param parser The parser instance.
+    # @param outerContext The current parser context object.
+    # @return The simplified semantic context after precedence predicates are
+    # evaluated, which will be one of the following values.
+    # <ul>
+    # <li>{@link #NONE}: if the predicate simplifies to {@code true} after
+    # precedence predicates are evaluated.</li>
+    # <li>{@code null}: if the predicate simplifies to {@code false} after
+    # precedence predicates are evaluated.</li>
+    # <li>{@code this}: if the semantic context is not changed as a result of
+    # precedence predicate evaluation.</li>
+    # <li>A non-{@code null} {@link SemanticContext}: the new simplified
+    # semantic context after precedence predicates are evaluated.</li>
+    # </ul>
+    #
+    def evalPrecedence(self, parser, outerContext):
+        return self
+
+    def __str__(self):
+        return unicode(self)
+    
+    def __unicode__(self):
+        return unicode(super(SemanticContext, self))
+
+
+def andContext(a, b):
+    if a is None or a is SemanticContext.NONE:
+        return b
+    if b is None or b is SemanticContext.NONE:
+        return a
+    result = AND(a, b)
+    if len(result.opnds) == 1:
+        return result.opnds[0]
+    else:
+        return result
+
+def orContext(a, b):
+    if a is None:
+        return b
+    if b is None:
+        return a
+    if a is SemanticContext.NONE or b is SemanticContext.NONE:
+        return SemanticContext.NONE
+    result = OR(a, b)
+    if len(result.opnds) == 1:
+        return result.opnds[0]
+    else:
+        return result
+
+def filterPrecedencePredicates(collection):
+    result = []
+    for context in collection:
+        if isinstance(context, PrecedencePredicate):
+            if result is None:
+                result = []
+            result.append(context)
+    return result
+
+
+class Predicate(SemanticContext):
+
+    def __init__(self, ruleIndex=-1, predIndex=-1, isCtxDependent=False):
+        self.ruleIndex = ruleIndex
+        self.predIndex = predIndex
+        self.isCtxDependent = isCtxDependent # e.g., $i ref in pred
+
+    def eval(self, parser, outerContext):
+        localctx = outerContext if self.isCtxDependent else None
+        return parser.sempred(localctx, self.ruleIndex, self.predIndex)
+
+    def __hash__(self):
+        return hash((self.ruleIndex, self.predIndex, self.isCtxDependent))
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, Predicate):
+            return False
+        return self.ruleIndex == other.ruleIndex and \
+               self.predIndex == other.predIndex and \
+               self.isCtxDependent == other.isCtxDependent
+
+    def __unicode__(self):
+        return u"{" + unicode(self.ruleIndex) + u":" + unicode(self.predIndex) + u"}?"
+
+
+class PrecedencePredicate(SemanticContext):
+
+    def __init__(self, precedence=0):
+        self.precedence = precedence
+
+    def eval(self, parser, outerContext):
+        return parser.precpred(outerContext, self.precedence)
+
+    def evalPrecedence(self, parser, outerContext):
+        if parser.precpred(outerContext, self.precedence):
+            return SemanticContext.NONE
+        else:
+            return None
+
+    def __cmp__(self, other):
+        return self.precedence - other.precedence
+
+    def __hash__(self):
+        return 31
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, PrecedencePredicate):
+            return False
+        else:
+            return self.precedence == other.precedence
+
+# A semantic context which is true whenever none of the contained contexts
+# is false.
+#
+class AND(SemanticContext):
+
+    def __init__(self, a, b):
+        operands = set()
+        if isinstance( a, AND):
+            for o in a.opnds:
+                operands.add(o)
+        else:
+            operands.add(a)
+        if isinstance( b, AND):
+            for o in b.opnds:
+                operands.add(o)
+        else:
+            operands.add(b)
+
+        precedencePredicates = filterPrecedencePredicates(operands)
+        if len(precedencePredicates)>0:
+            # interested in the transition with the lowest precedence
+            reduced = min(precedencePredicates)
+            operands.add(reduced)
+
+        self.opnds = [ o for o in operands ]
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, AND):
+            return False
+        else:
+            return self.opnds == other.opnds
+
+    def __hash__(self):
+        h = 0
+        for o in self.opnds:
+            h = hash((h, o))
+        return hash((h, "AND"))
+
+    #
+    # {@inheritDoc}
+    #
+    # <p>
+    # The evaluation of predicates by this context is short-circuiting, but
+    # unordered.</p>
+    #
+    def eval(self, parser, outerContext):
+        for opnd in self.opnds:
+            if not opnd.eval(parser, outerContext):
+                return False
+        return True
+
+    def evalPrecedence(self, parser, outerContext):
+        differs = False
+        operands = []
+        for context in self.opnds:
+            evaluated = context.evalPrecedence(parser, outerContext)
+            differs |= evaluated is not context
+            if evaluated is None:
+                # The AND context is false if any element is false
+                return None
+            elif evaluated is not SemanticContext.NONE:
+                # Reduce the result by skipping true elements
+                operands.append(evaluated)
+
+        if not differs:
+            return self
+
+        if len(operands)==0:
+            # all elements were true, so the AND context is true
+            return SemanticContext.NONE
+
+        result = None
+        for o in operands:
+            result = o if result is None else andContext(result, o)
+
+        return result
+
+    def __unicode__(self):
+        with StringIO() as buf:
+            first = True
+            for o in self.opnds:
+                if not first:
+                    buf.write(u"&&")
+                buf.write(unicode(o))
+                first = False
+            return buf.getvalue()
+
+#
+# A semantic context which is true whenever at least one of the contained
+# contexts is true.
+#
+class OR (SemanticContext):
+
+    def __init__(self, a, b):
+        operands = set()
+        if isinstance( a, OR):
+            for o in a.opnds:
+                operands.add(o)
+        else:
+            operands.add(a)
+        if isinstance( b, OR):
+            for o in b.opnds:
+                operands.add(o)
+        else:
+            operands.add(b)
+
+        precedencePredicates = filterPrecedencePredicates(operands)
+        if len(precedencePredicates)>0:
+            # interested in the transition with the highest precedence
+            s = sorted(precedencePredicates)
+            reduced = s[len(s)-1]
+            operands.add(reduced)
+
+        self.opnds = [ o for o in operands ]
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, OR):
+            return False
+        else:
+            return self.opnds == other.opnds
+
+    def __hash__(self):
+        h = 0
+        for o in self.opnds:
+            h = hash((h, o))
+        return hash((h, "OR"))
+
+    # <p>
+    # The evaluation of predicates by this context is short-circuiting, but
+    # unordered.</p>
+    #
+    def eval(self, parser, outerContext):
+        for opnd in self.opnds:
+            if opnd.eval(parser, outerContext):
+                return True
+        return False
+
+    def evalPrecedence(self, parser, outerContext):
+        differs = False
+        operands = []
+        for context in self.opnds:
+            evaluated = context.evalPrecedence(parser, outerContext)
+            differs |= evaluated is not context
+            if evaluated is SemanticContext.NONE:
+                # The OR context is true if any element is true
+                return SemanticContext.NONE
+            elif evaluated is not None:
+                # Reduce the result by skipping false elements
+                operands.append(evaluated)
+
+        if not differs:
+            return self
+
+        if len(operands)==0:
+            # all elements were false, so the OR context is false
+            return None
+
+        result = None
+        for o in operands:
+            result = o if result is None else orContext(result, o)
+
+        return result
+
+    def __unicode__(self):
+        with StringIO() as buf:
+            first = True
+            for o in self.opnds:
+                if not first:
+                    buf.write(u"||")
+                buf.write(unicode(o))
+                first = False
+            return buf.getvalue()
+
+
+SemanticContext.NONE = Predicate()
\ No newline at end of file
diff --git a/runtime/Python2/src/antlr4/atn/Transition.py b/runtime/Python2/src/antlr4/atn/Transition.py
new file mode 100644
index 000000000..92212e741
--- /dev/null
+++ b/runtime/Python2/src/antlr4/atn/Transition.py
@@ -0,0 +1,277 @@
+#
+# [The "BSD license"]
+#  Copyright (c) 2012 Terence Parr
+#  Copyright (c) 2012 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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.
+#
+
+#  An ATN transition between any two ATN states.  Subclasses define
+#  atom, set, epsilon, action, predicate, rule transitions.
+#
+#  <p>This is a one way link.  It emanates from a state (usually via a list of
+#  transitions) and has a target state.</p>
+#
+#  <p>Since we never have to change the ATN transitions once we construct it,
+#  we can fix these transitions as specific classes. The DFA transitions
+#  on the other hand need to update the labels as it adds transitions to
+#  the states. We'll use the term Edge for the DFA to distinguish them from
+#  ATN transitions.</p>
+#
+from __builtin__ import unicode
+from antlr4.IntervalSet import IntervalSet, Interval
+from antlr4.Token import Token
+from antlr4.atn.SemanticContext import Predicate, PrecedencePredicate
+
+class Transition (object):
+    # constants for serialization
+    EPSILON			= 1
+    RANGE			= 2
+    RULE			= 3
+    PREDICATE		= 4 # e.g., {isType(input.LT(1))}?
+    ATOM			= 5
+    ACTION			= 6
+    SET				= 7 # ~(A|B) or ~atom, wildcard, which convert to next 2
+    NOT_SET			= 8
+    WILDCARD		= 9
+    PRECEDENCE		= 10
+
+    serializationNames = [
+            u"INVALID",
+            u"EPSILON",
+            u"RANGE",
+            u"RULE",
+            u"PREDICATE",
+            u"ATOM",
+            u"ACTION",
+            u"SET",
+            u"NOT_SET",
+            u"WILDCARD",
+            u"PRECEDENCE"
+        ]
+
+    serializationTypes = dict()
+
+    def __init__(self, target):
+        # The target of this transition.
+        if target is None:
+            raise Exception("target cannot be null.")
+        self.target = target
+        # Are we epsilon, action, sempred?
+        self.isEpsilon = False
+        self.label = None
+
+    def __str__(self):
+        return unicode(self)
+
+
+# TODO: make all transitions sets? no, should remove set edges
+class AtomTransition(Transition):
+
+    def __init__(self, target, label):
+        super(AtomTransition, self).__init__(target)
+        self.label_ = label # The token type or character value; or, signifies special label.
+        self.label = self.makeLabel()
+        self.serializationType = self.ATOM
+
+    def makeLabel(self):
+        s = IntervalSet()
+        s.addOne(self.label_)
+        return s
+
+    def matches( self, symbol, minVocabSymbol,  maxVocabSymbol):
+        return self.label_ == symbol
+
+    def __unicode__(self):
+        return unicode(self.label_)
+
+class RuleTransition(Transition):
+
+    def __init__(self, ruleStart, ruleIndex, precedence, followState):
+        super(RuleTransition, self).__init__(ruleStart)
+        self.ruleIndex = ruleIndex # ptr to the rule definition object for this rule ref
+        self.precedence = precedence
+        self.followState = followState # what node to begin computations following ref to rule
+        self.serializationType = self.RULE
+        self.isEpsilon = True
+
+    def matches( self, symbol, minVocabSymbol,  maxVocabSymbol):
+        return False
+
+
+class EpsilonTransition(Transition):
+
+    def __init__(self, target, outermostPrecedenceReturn=-1):
+        super(EpsilonTransition, self).__init__(target)
+        self.serializationType = self.EPSILON
+        self.isEpsilon = True
+        self.outermostPrecedenceReturn = outermostPrecedenceReturn
+
+    def matches( self, symbol, minVocabSymbol,  maxVocabSymbol):
+        return False
+
+    def __unicode__(self):
+        return "epsilon"
+
+class RangeTransition(Transition):
+
+    def __init__(self, target, start, stop):
+        super(RangeTransition, self).__init__(target)
+        self.serializationType = self.RANGE
+        self.start = start
+        self.stop = stop
+        self.label = self.makeLabel()
+
+    def makeLabel(self):
+        s = IntervalSet()
+        s.addRange(Interval(self.start, self.stop + 1))
+        return s
+
+    def matches( self, symbol, minVocabSymbol,  maxVocabSymbol):
+        return symbol >= self.start and symbol <= self.stop
+
+    def __unicode__(self):
+        return "'" + chr(self.start) + "'..'" + chr(self.stop) + "'"
+
+class AbstractPredicateTransition(Transition):
+
+    def __init__(self, target):
+        super(AbstractPredicateTransition, self).__init__(target)
+
+
+class PredicateTransition(AbstractPredicateTransition):
+
+    def __init__(self, target, ruleIndex, predIndex, isCtxDependent):
+        super(PredicateTransition, self).__init__(target)
+        self.serializationType = self.PREDICATE
+        self.ruleIndex = ruleIndex
+        self.predIndex = predIndex
+        self.isCtxDependent = isCtxDependent # e.g., $i ref in pred
+        self.isEpsilon = True
+
+    def matches( self, symbol, minVocabSymbol,  maxVocabSymbol):
+        return False
+
+    def getPredicate(self):
+        return Predicate(self.ruleIndex, self.predIndex, self.isCtxDependent)
+
+    def __unicode__(self):
+        return u"pred_" + unicode(self.ruleIndex) + u":" + unicode(self.predIndex)
+
+class ActionTransition(Transition):
+
+    def __init__(self, target, ruleIndex, actionIndex=-1, isCtxDependent=False):
+        super(ActionTransition, self).__init__(target)
+        self.serializationType = self.ACTION
+        self.ruleIndex = ruleIndex
+        self.actionIndex = actionIndex
+        self.isCtxDependent = isCtxDependent # e.g., $i ref in pred
+        self.isEpsilon = True
+
+    def matches( self, symbol, minVocabSymbol,  maxVocabSymbol):
+        return False
+
+    def __unicode__(self):
+        return u"action_" + unicode(self.ruleIndex) + u":" + unicode(self.actionIndex)
+
+# A transition containing a set of values.
+class SetTransition(Transition):
+
+    def __init__(self, target, set):
+        super(SetTransition, self).__init__(target)
+        self.serializationType = self.SET
+        if set is not None:
+            self.label = set
+        else:
+            self.label = IntervalSet()
+            self.label.addRange(Interval(Token.INVALID_TYPE, Token.INVALID_TYPE + 1))
+
+    def matches( self, symbol, minVocabSymbol,  maxVocabSymbol):
+        return symbol in self.label
+
+    def __unicode__(self):
+        return unicode(self.label)
+
+class NotSetTransition(SetTransition):
+
+    def __init__(self, target, set):
+        super(NotSetTransition, self).__init__(target, set)
+        self.serializationType = self.NOT_SET
+
+    def matches( self, symbol, minVocabSymbol,  maxVocabSymbol):
+        return symbol >= minVocabSymbol \
+            and symbol <= maxVocabSymbol \
+            and not super(type(self), self).matches(symbol, minVocabSymbol, maxVocabSymbol)
+
+    def __unicode__(self):
+        return u'~' + super(type(self), self).__unicode__()
+
+
+class WildcardTransition(Transition):
+
+    def __init__(self, target):
+        super(WildcardTransition, self).__init__(target)
+        self.serializationType = self.WILDCARD
+
+    def matches( self, symbol, minVocabSymbol,  maxVocabSymbol):
+        return symbol >= minVocabSymbol and symbol <= maxVocabSymbol
+
+    def __unicode__(self):
+        return u"."
+
+
+class PrecedencePredicateTransition(AbstractPredicateTransition):
+
+    def __init__(self, target, precedence):
+        super(PrecedencePredicateTransition, self).__init__(target)
+        self.serializationType = self.PRECEDENCE
+        self.precedence = precedence
+        self.isEpsilon = True
+
+    def matches( self, symbol, minVocabSymbol,  maxVocabSymbol):
+        return False
+
+
+    def getPredicate(self):
+        return PrecedencePredicate(self.precedence)
+
+    def __unicode__(self):
+        return self.precedence + " >= _p"
+
+
+Transition.serializationTypes = {
+             EpsilonTransition: Transition.EPSILON,
+             RangeTransition: Transition.RANGE,
+             RuleTransition: Transition.RULE,
+             PredicateTransition: Transition.PREDICATE,
+             AtomTransition: Transition.ATOM,
+             ActionTransition: Transition.ACTION,
+             SetTransition: Transition.SET,
+             NotSetTransition: Transition.NOT_SET,
+             WildcardTransition: Transition.WILDCARD,
+             PrecedencePredicateTransition: Transition.PRECEDENCE
+         }
+
diff --git a/runtime/Python2/src/antlr4/atn/__init__.py b/runtime/Python2/src/antlr4/atn/__init__.py
new file mode 100644
index 000000000..216c000dc
--- /dev/null
+++ b/runtime/Python2/src/antlr4/atn/__init__.py
@@ -0,0 +1 @@
+__author__ = 'ericvergnaud'
diff --git a/runtime/Python2/src/antlr4/dfa/DFA.py b/runtime/Python2/src/antlr4/dfa/DFA.py
new file mode 100644
index 000000000..4ed5fb6e9
--- /dev/null
+++ b/runtime/Python2/src/antlr4/dfa/DFA.py
@@ -0,0 +1,150 @@
+#
+# [The "BSD license"]
+#  Copyright (c) 2012 Terence Parr
+#  Copyright (c) 2012 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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.
+
+from antlr4.atn.ATNConfigSet import ATNConfigSet
+from antlr4.dfa.DFAState import DFAState
+from antlr4.error.Errors import IllegalStateException
+
+
+class DFA(object):
+
+    def __init__(self, atnStartState, decision=0):
+        # From which ATN state did we create this DFA?
+        self.atnStartState = atnStartState
+        self.decision = decision
+        # A set of all DFA states. Use {@link Map} so we can get old state back
+        #  ({@link Set} only allows you to see if it's there).
+        self._states = dict()
+        self.s0 = None
+        # {@code true} if this DFA is for a precedence decision; otherwise,
+        # {@code false}. This is the backing field for {@link #isPrecedenceDfa},
+        # {@link #setPrecedenceDfa}.
+        self.precedenceDfa = False
+
+
+    # Get the start state for a specific precedence value.
+    #
+    # @param precedence The current precedence.
+    # @return The start state corresponding to the specified precedence, or
+    # {@code null} if no start state exists for the specified precedence.
+    #
+    # @throws IllegalStateException if this is not a precedence DFA.
+    # @see #isPrecedenceDfa()
+
+    def getPrecedenceStartState(self, precedence):
+        if not self.precedenceDfa:
+            raise IllegalStateException("Only precedence DFAs may contain a precedence start state.")
+
+        # s0.edges is never null for a precedence DFA
+        if precedence < 0 or precedence >= len(self.s0.edges):
+            return None
+        return self.s0.edges[precedence]
+
+    # Set the start state for a specific precedence value.
+    #
+    # @param precedence The current precedence.
+    # @param startState The start state corresponding to the specified
+    # precedence.
+    #
+    # @throws IllegalStateException if this is not a precedence DFA.
+    # @see #isPrecedenceDfa()
+    #
+    def setPrecedenceStartState(self, precedence, startState):
+        if not self.precedenceDfa:
+            raise IllegalStateException("Only precedence DFAs may contain a precedence start state.")
+
+        if precedence < 0:
+            return
+
+        # synchronization on s0 here is ok. when the DFA is turned into a
+        # precedence DFA, s0 will be initialized once and not updated again
+        # s0.edges is never null for a precedence DFA
+        if precedence >= len(self.s0.edges):
+            ext = [None] * (precedence + 1 - len(self.s0.edges))
+            self.s0.edges.extend(ext)
+        self.s0.edges[precedence] = startState
+    #
+    # Sets whether this is a precedence DFA. If the specified value differs
+    # from the current DFA configuration, the following actions are taken;
+    # otherwise no changes are made to the current DFA.
+    #
+    # <ul>
+    # <li>The {@link #states} map is cleared</li>
+    # <li>If {@code precedenceDfa} is {@code false}, the initial state
+    # {@link #s0} is set to {@code null}; otherwise, it is initialized to a new
+    # {@link DFAState} with an empty outgoing {@link DFAState#edges} array to
+    # store the start states for individual precedence values.</li>
+    # <li>The {@link #precedenceDfa} field is updated</li>
+    # </ul>
+    #
+    # @param precedenceDfa {@code true} if this is a precedence DFA; otherwise,
+    # {@code false}
+
+    def setPrecedenceDfa(self, precedenceDfa):
+        if self.precedenceDfa != precedenceDfa:
+            self._states = dict()
+            if precedenceDfa:
+                precedenceState = DFAState(ATNConfigSet())
+                precedenceState.edges = []
+                precedenceState.isAcceptState = False
+                precedenceState.requiresFullContext = False
+                self.s0 = precedenceState
+            else:
+                self.s0 = None
+            self.precedenceDfa = precedenceDfa
+
+    @property
+    def states(self):
+        return self._states
+
+    # Return a list of all states in this DFA, ordered by state number.
+    def sortedStates(self):
+        return sorted(self._states.keys(), key=lambda state: state.stateNumber)
+
+    def __str__(self):
+        return unicode(self)
+
+    def __unicode__(self):
+        return self.toString(None)
+
+    def toString(self, literalNames=None, symbolicNames=None):
+        if self.s0 is None:
+            return ""
+        from antlr4.dfa.DFASerializer import DFASerializer
+        serializer = DFASerializer(self, literalNames, symbolicNames)
+        return unicode(serializer)
+
+    def toLexerString(self):
+        if self.s0 is None:
+            return ""
+        from antlr4.dfa.DFASerializer import LexerDFASerializer
+        serializer = LexerDFASerializer(self)
+        return unicode(serializer)
+
diff --git a/runtime/Python2/src/antlr4/dfa/DFASerializer.py b/runtime/Python2/src/antlr4/dfa/DFASerializer.py
new file mode 100644
index 000000000..2b0935035
--- /dev/null
+++ b/runtime/Python2/src/antlr4/dfa/DFASerializer.py
@@ -0,0 +1,99 @@
+#
+# [The "BSD license"]
+#  Copyright (c) 2012 Terence Parr
+#  Copyright (c) 2012 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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 DFA walker that knows how to dump them to serialized strings.#/
+from io import StringIO
+from antlr4.Utils import str_list
+
+
+class DFASerializer(object):
+
+    def __init__(self, dfa, literalNames=None, symbolicNames=None):
+        self.dfa = dfa
+        self.literalNames = literalNames
+        self.symbolicNames = symbolicNames
+
+    def __str__(self):
+        return unicode(self)
+
+    def __unicode__(self):
+        if self.dfa.s0 is None:
+            return None
+        with StringIO() as buf:
+            for s in self.dfa.sortedStates():
+                n = 0
+                if s.edges is not None:
+                    n = len(s.edges)
+                for i in range(0, n):
+                    t = s.edges[i]
+                    if t is not None and t.stateNumber != 0x7FFFFFFF:
+                        buf.write(self.getStateString(s))
+                        label = self.getEdgeLabel(i)
+                        buf.write(u"-")
+                        buf.write(label)
+                        buf.write(u"->")
+                        buf.write(self.getStateString(t))
+                        buf.write(u'\n')
+            output = buf.getvalue()
+            if len(output)==0:
+                return None
+            else:
+                return output
+
+    def getEdgeLabel(self, i):
+        if i==0:
+            return u"EOF"
+        if self.literalNames is not None and i<=len(self.literalNames):
+            return self.literalNames[i-1]
+        elif self.symbolicNames is not None and i<=len(self.symbolicNames):
+            return self.symbolicNames[i-1]
+        else:
+            return unicode(i-1)
+
+    def getStateString(self, s):
+        n = s.stateNumber
+        baseStateStr = ( u":" if s.isAcceptState else u"") + u"s" + unicode(n) + \
+            ( u"^" if s.requiresFullContext else u"")
+        if s.isAcceptState:
+            if s.predicates is not None:
+                return baseStateStr + u"=>" + str_list(s.predicates)
+            else:
+                return baseStateStr + u"=>" + unicode(s.prediction)
+        else:
+            return baseStateStr
+
+class LexerDFASerializer(DFASerializer):
+
+    def __init__(self, dfa):
+        super(LexerDFASerializer, self).__init__(dfa, None)
+
+    def getEdgeLabel(self, i):
+        return u"'" + unichr(i) + u"'"
diff --git a/runtime/Python2/src/antlr4/dfa/DFAState.py b/runtime/Python2/src/antlr4/dfa/DFAState.py
new file mode 100644
index 000000000..85ccac106
--- /dev/null
+++ b/runtime/Python2/src/antlr4/dfa/DFAState.py
@@ -0,0 +1,154 @@
+#
+# [The "BSD license"]
+#  Copyright (c) 2012 Terence Parr
+#  Copyright (c) 2012 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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.
+#/
+
+# Map a predicate to a predicted alternative.#/
+from io import StringIO
+from antlr4.atn.ATNConfigSet import ATNConfigSet
+
+class PredPrediction(object):
+    def __init__(self, pred, alt):
+        self.alt = alt
+        self.pred = pred
+
+    def __str__(self):
+        return unicode(self)
+
+    def __unicode__(self):
+        return u"(" + unicode(self.pred) + u", " + unicode(self.alt) +  u")"
+
+# A DFA state represents a set of possible ATN configurations.
+#  As Aho, Sethi, Ullman p. 117 says "The DFA uses its state
+#  to keep track of all possible states the ATN can be in after
+#  reading each input symbol.  That is to say, after reading
+#  input a1a2..an, the DFA is in a state that represents the
+#  subset T of the states of the ATN that are reachable from the
+#  ATN's start state along some path labeled a1a2..an."
+#  In conventional NFA&rarr;DFA conversion, therefore, the subset T
+#  would be a bitset representing the set of states the
+#  ATN could be in.  We need to track the alt predicted by each
+#  state as well, however.  More importantly, we need to maintain
+#  a stack of states, tracking the closure operations as they
+#  jump from rule to rule, emulating rule invocations (method calls).
+#  I have to add a stack to simulate the proper lookahead sequences for
+#  the underlying LL grammar from which the ATN was derived.
+#
+#  <p>I use a set of ATNConfig objects not simple states.  An ATNConfig
+#  is both a state (ala normal conversion) and a RuleContext describing
+#  the chain of rules (if any) followed to arrive at that state.</p>
+#
+#  <p>A DFA state may have multiple references to a particular state,
+#  but with different ATN contexts (with same or different alts)
+#  meaning that state was reached via a different set of rule invocations.</p>
+#/
+class DFAState(object):
+
+    def __init__(self, stateNumber=-1, configs=ATNConfigSet()):
+        self.stateNumber = stateNumber
+        self.configs = configs
+        # {@code edges[symbol]} points to target of symbol. Shift up by 1 so (-1)
+        #  {@link Token#EOF} maps to {@code edges[0]}.
+        self.edges = None
+        self.isAcceptState = False
+        # if accept state, what ttype do we match or alt do we predict?
+        #  This is set to {@link ATN#INVALID_ALT_NUMBER} when {@link #predicates}{@code !=null} or
+        #  {@link #requiresFullContext}.
+        self.prediction = 0
+        self.lexerActionExecutor = None
+        # Indicates that this state was created during SLL prediction that
+        # discovered a conflict between the configurations in the state. Future
+        # {@link ParserATNSimulator#execATN} invocations immediately jumped doing
+        # full context prediction if this field is true.
+        self.requiresFullContext = False
+        # During SLL parsing, this is a list of predicates associated with the
+        #  ATN configurations of the DFA state. When we have predicates,
+        #  {@link #requiresFullContext} is {@code false} since full context prediction evaluates predicates
+        #  on-the-fly. If this is not null, then {@link #prediction} is
+        #  {@link ATN#INVALID_ALT_NUMBER}.
+        #
+        #  <p>We only use these for non-{@link #requiresFullContext} but conflicting states. That
+        #  means we know from the context (it's $ or we don't dip into outer
+        #  context) that it's an ambiguity not a conflict.</p>
+        #
+        #  <p>This list is computed by {@link ParserATNSimulator#predicateDFAState}.</p>
+        self.predicates = None
+
+
+
+    # Get the set of all alts mentioned by all ATN configurations in this
+    #  DFA state.
+    def getAltSet(self):
+        alts = set()
+        if self.configs is not None:
+            for c in self.configs:
+                alts.add(c.alt)
+        if len(alts)==0:
+            return None
+        else:
+            return alts
+
+    def __hash__(self):
+        return hash(self.configs)
+
+    # Two {@link DFAState} instances are equal if their ATN configuration sets
+    # are the same. This method is used to see if a state already exists.
+    #
+    # <p>Because the number of alternatives and number of ATN configurations are
+    # finite, there is a finite number of DFA states that can be processed.
+    # This is necessary to show that the algorithm terminates.</p>
+    #
+    # <p>Cannot test the DFA state numbers here because in
+    # {@link ParserATNSimulator#addDFAState} we need to know if any other state
+    # exists that has this exact set of ATN configurations. The
+    # {@link #stateNumber} is irrelevant.</p>
+    def __eq__(self, other):
+        # compare set of ATN configurations in this set with other
+        if self is other:
+            return True
+        elif not isinstance(other, DFAState):
+            return False
+        else:
+            return self.configs==other.configs
+
+    def __str__(self):
+        return unicode(self)
+
+    def __unicode__(self):
+        with StringIO() as buf:
+            buf.write(unicode(self.stateNumber))
+            buf.write(u":")
+            buf.write(unicode(self.configs))
+            if self.isAcceptState:
+                buf.write(u"=>")
+                if self.predicates is not None:
+                    buf.write(unicode(self.predicates))
+                else:
+                    buf.write(unicode(self.prediction))
+            return buf.getvalue()
diff --git a/runtime/Python2/src/antlr4/dfa/__init__.py b/runtime/Python2/src/antlr4/dfa/__init__.py
new file mode 100644
index 000000000..216c000dc
--- /dev/null
+++ b/runtime/Python2/src/antlr4/dfa/__init__.py
@@ -0,0 +1 @@
+__author__ = 'ericvergnaud'
diff --git a/runtime/Python2/src/antlr4/error/DiagnosticErrorListener.py b/runtime/Python2/src/antlr4/error/DiagnosticErrorListener.py
new file mode 100644
index 000000000..7801f6a87
--- /dev/null
+++ b/runtime/Python2/src/antlr4/error/DiagnosticErrorListener.py
@@ -0,0 +1,131 @@
+#
+# [The "BSD license"]
+#  Copyright (c) 2012 Terence Parr
+#  Copyright (c) 2012 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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.
+#
+
+
+#
+# This implementation of {@link ANTLRErrorListener} can be used to identify
+# certain potential correctness and performance problems in grammars. "Reports"
+# are made by calling {@link Parser#notifyErrorListeners} with the appropriate
+# message.
+#
+# <ul>
+# <li><b>Ambiguities</b>: These are cases where more than one path through the
+# grammar can match the input.</li>
+# <li><b>Weak context sensitivity</b>: These are cases where full-context
+# prediction resolved an SLL conflict to a unique alternative which equaled the
+# minimum alternative of the SLL conflict.</li>
+# <li><b>Strong (forced) context sensitivity</b>: These are cases where the
+# full-context prediction resolved an SLL conflict to a unique alternative,
+# <em>and</em> the minimum alternative of the SLL conflict was found to not be
+# a truly viable alternative. Two-stage parsing cannot be used for inputs where
+# this situation occurs.</li>
+# </ul>
+
+from io import StringIO
+from antlr4.Utils import str_set
+from antlr4.error.ErrorListener import ErrorListener
+
+class DiagnosticErrorListener(ErrorListener):
+
+    def __init__(self, exactOnly=True):
+        # whether all ambiguities or only exact ambiguities are reported.
+        self.exactOnly = exactOnly
+
+    def reportAmbiguity(self, recognizer, dfa, startIndex,
+                       stopIndex, exact, ambigAlts, configs):
+        if self.exactOnly and not exact:
+            return
+
+        with StringIO() as buf:
+            buf.write(u"reportAmbiguity d=")
+            buf.write(self.getDecisionDescription(recognizer, dfa))
+            buf.write(u": ambigAlts=")
+            buf.write(str_set(self.getConflictingAlts(ambigAlts, configs)))
+            buf.write(u", input='")
+            buf.write(recognizer.getTokenStream().getText((startIndex, stopIndex)))
+            buf.write(u"'")
+            recognizer.notifyErrorListeners(buf.getvalue())
+
+
+    def reportAttemptingFullContext(self, recognizer, dfa, startIndex,
+                       stopIndex, conflictingAlts, configs):
+        with StringIO() as buf:
+            buf.write(u"reportAttemptingFullContext d=")
+            buf.write(self.getDecisionDescription(recognizer, dfa))
+            buf.write(u", input='")
+            buf.write(recognizer.getTokenStream().getText((startIndex, stopIndex)))
+            buf.write(u"'")
+            recognizer.notifyErrorListeners(buf.getvalue())
+
+    def reportContextSensitivity(self, recognizer, dfa, startIndex,
+                       stopIndex, prediction, configs):
+        with StringIO() as buf:
+            buf.write(u"reportContextSensitivity d=")
+            buf.write(self.getDecisionDescription(recognizer, dfa))
+            buf.write(u", input='")
+            buf.write(recognizer.getTokenStream().getText((startIndex, stopIndex)))
+            buf.write(u"'")
+            recognizer.notifyErrorListeners(buf.getvalue())
+
+    def getDecisionDescription(self, recognizer, dfa):
+        decision = dfa.decision
+        ruleIndex = dfa.atnStartState.ruleIndex
+
+        ruleNames = recognizer.ruleNames
+        if ruleIndex < 0 or ruleIndex >= len(ruleNames):
+            return unicode(decision)
+
+        ruleName = ruleNames[ruleIndex]
+        if ruleName is None or len(ruleName)==0:
+            return unicode(decision)
+
+        return unicode(decision) + u" (" + ruleName + u")"
+
+    #
+    # Computes the set of conflicting or ambiguous alternatives from a
+    # configuration set, if that information was not already provided by the
+    # parser.
+    #
+    # @param reportedAlts The set of conflicting or ambiguous alternatives, as
+    # reported by the parser.
+    # @param configs The conflicting or ambiguous configuration set.
+    # @return Returns {@code reportedAlts} if it is not {@code null}, otherwise
+    # returns the set of alternatives represented in {@code configs}.
+    #
+    def getConflictingAlts(self, reportedAlts, configs):
+        if reportedAlts is not None:
+            return reportedAlts
+
+        result = set()
+        for config in configs:
+            result.add(config.alt)
+
+        return result
diff --git a/runtime/Python2/src/antlr4/error/ErrorListener.py b/runtime/Python2/src/antlr4/error/ErrorListener.py
new file mode 100644
index 000000000..bfe06e03a
--- /dev/null
+++ b/runtime/Python2/src/antlr4/error/ErrorListener.py
@@ -0,0 +1,97 @@
+#
+# [The "BSD license"]
+#  Copyright (c) 2012 Terence Parr
+#  Copyright (c) 2012 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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.
+
+# Provides an empty default implementation of {@link ANTLRErrorListener}. The
+# default implementation of each method does nothing, but can be overridden as
+# necessary.
+
+from __future__ import print_function
+import sys
+
+class ErrorListener(object):
+
+    def syntaxError(self, recognizer, offendingSymbol, line, column, msg, e):
+        pass
+
+    def reportAmbiguity(self, recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs):
+        pass
+
+    def reportAttemptingFullContext(self, recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs):
+        pass
+
+    def reportContextSensitivity(self, recognizer, dfa, startIndex, stopIndex, prediction, configs):
+        pass
+
+class ConsoleErrorListener(ErrorListener):
+    #
+    # Provides a default instance of {@link ConsoleErrorListener}.
+    #
+    INSTANCE = None
+
+    #
+    # {@inheritDoc}
+    #
+    # <p>
+    # This implementation prints messages to {@link System#err} containing the
+    # values of {@code line}, {@code charPositionInLine}, and {@code msg} using
+    # the following format.</p>
+    #
+    # <pre>
+    # line <em>line</em>:<em>charPositionInLine</em> <em>msg</em>
+    # </pre>
+    #
+    def syntaxError(self, recognizer, offendingSymbol, line, column, msg, e):
+        print("line " + str(line) + ":" + str(column) + " " + msg, file=sys.stderr)
+
+ConsoleErrorListener.INSTANCE = ConsoleErrorListener()
+
+class ProxyErrorListener(ErrorListener):
+
+    def __init__(self, delegates):
+        super(ProxyErrorListener, self).__init__()
+        if delegates is None:
+            raise ReferenceError("delegates")
+        self.delegates = delegates
+
+    def syntaxError(self, recognizer, offendingSymbol, line, column, msg, e):
+        for delegate in self.delegates:
+            delegate.syntaxError(recognizer, offendingSymbol, line, column, msg, e)
+
+    def reportAmbiguity(self, recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs):
+        for delegate in self.delegates:
+            delegate.reportAmbiguity(recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs)
+
+    def reportAttemptingFullContext(self, recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs):
+        for delegate in self.delegates:
+            delegate.reportAttemptingFullContext(recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs)
+
+    def reportContextSensitivity(self, recognizer, dfa, startIndex, stopIndex, prediction, configs):
+        for delegate in self.delegates:
+            delegate.reportContextSensitivity(recognizer, dfa, startIndex, stopIndex, prediction, configs)
diff --git a/runtime/Python2/src/antlr4/error/ErrorStrategy.py b/runtime/Python2/src/antlr4/error/ErrorStrategy.py
new file mode 100644
index 000000000..94efb89a5
--- /dev/null
+++ b/runtime/Python2/src/antlr4/error/ErrorStrategy.py
@@ -0,0 +1,719 @@
+#
+# [The "BSD license"]
+#  Copyright (c) 2012 Terence Parr
+#  Copyright (c) 2012 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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.
+#
+from antlr4.IntervalSet import IntervalSet
+
+from antlr4.Token import Token
+from antlr4.atn.ATNState import ATNState
+from antlr4.error.Errors import NoViableAltException, InputMismatchException, FailedPredicateException, ParseCancellationException
+
+class ErrorStrategy(object):
+
+    def reset(self, recognizer):
+        pass
+
+    def recoverInline(self, recognizer):
+        pass
+
+    def recover(self, recognizer, e):
+        pass
+
+    def sync(self, recognizer):
+        pass
+
+    def inErrorRecoveryMode(self, recognizer):
+        pass
+
+    def reportError(self, recognizer, e):
+        pass
+
+
+# This is the default implementation of {@link ANTLRErrorStrategy} used for
+# error reporting and recovery in ANTLR parsers.
+#
+class DefaultErrorStrategy(ErrorStrategy):
+
+    def __init__(self):
+        super(DefaultErrorStrategy, self).__init__()
+        # Indicates whether the error strategy is currently "recovering from an
+        # error". This is used to suppress reporting multiple error messages while
+        # attempting to recover from a detected syntax error.
+        #
+        # @see #inErrorRecoveryMode
+        #
+        self.errorRecoveryMode = False
+
+        # The index into the input stream where the last error occurred.
+        # 	This is used to prevent infinite loops where an error is found
+        #  but no token is consumed during recovery...another error is found,
+        #  ad nauseum.  This is a failsafe mechanism to guarantee that at least
+        #  one token/tree node is consumed for two errors.
+        #
+        self.lastErrorIndex = -1
+        self.lastErrorStates = None
+
+    # <p>The default implementation simply calls {@link #endErrorCondition} to
+    # ensure that the handler is not in error recovery mode.</p>
+    def reset(self, recognizer):
+        self.endErrorCondition(recognizer)
+
+    #
+    # This method is called to enter error recovery mode when a recognition
+    # exception is reported.
+    #
+    # @param recognizer the parser instance
+    #
+    def beginErrorCondition(self, recognizer):
+        self.errorRecoveryMode = True
+
+    def inErrorRecoveryMode(self, recognizer):
+        return self.errorRecoveryMode
+
+    #
+    # This method is called to leave error recovery mode after recovering from
+    # a recognition exception.
+    #
+    # @param recognizer
+    #
+    def endErrorCondition(self, recognizer):
+        self.errorRecoveryMode = False
+        self.lastErrorStates = None
+        self.lastErrorIndex = -1
+
+    #
+    # {@inheritDoc}
+    #
+    # <p>The default implementation simply calls {@link #endErrorCondition}.</p>
+    #
+    def reportMatch(self, recognizer):
+        self.endErrorCondition(recognizer)
+
+    #
+    # {@inheritDoc}
+    #
+    # <p>The default implementation returns immediately if the handler is already
+    # in error recovery mode. Otherwise, it calls {@link #beginErrorCondition}
+    # and dispatches the reporting task based on the runtime type of {@code e}
+    # according to the following table.</p>
+    #
+    # <ul>
+    # <li>{@link NoViableAltException}: Dispatches the call to
+    # {@link #reportNoViableAlternative}</li>
+    # <li>{@link InputMismatchException}: Dispatches the call to
+    # {@link #reportInputMismatch}</li>
+    # <li>{@link FailedPredicateException}: Dispatches the call to
+    # {@link #reportFailedPredicate}</li>
+    # <li>All other types: calls {@link Parser#notifyErrorListeners} to report
+    # the exception</li>
+    # </ul>
+    #
+    def reportError(self, recognizer, e):
+        # if we've already reported an error and have not matched a token
+        # yet successfully, don't report any errors.
+        if self.inErrorRecoveryMode(recognizer):
+            return # don't report spurious errors
+        self.beginErrorCondition(recognizer)
+        if isinstance( e, NoViableAltException ):
+            self.reportNoViableAlternative(recognizer, e)
+        elif isinstance( e, InputMismatchException ):
+            self.reportInputMismatch(recognizer, e)
+        elif isinstance( e, FailedPredicateException ):
+            self.reportFailedPredicate(recognizer, e)
+        else:
+            print("unknown recognition error type: " + type(e).__name__)
+            recognizer.notifyErrorListeners(e.getOffendingToken(), e.getMessage(), e)
+
+    #
+    # {@inheritDoc}
+    #
+    # <p>The default implementation resynchronizes the parser by consuming tokens
+    # until we find one in the resynchronization set--loosely the set of tokens
+    # that can follow the current rule.</p>
+    #
+    def recover(self, recognizer, e):
+        if self.lastErrorIndex==recognizer.getInputStream().index \
+            and self.lastErrorStates is not None \
+            and recognizer.state in self.lastErrorStates:
+            # uh oh, another error at same token index and previously-visited
+            # state in ATN; must be a case where LT(1) is in the recovery
+            # token set so nothing got consumed. Consume a single token
+            # at least to prevent an infinite loop; this is a failsafe.
+            recognizer.consume()
+
+        self.lastErrorIndex = recognizer._input.index
+        if self.lastErrorStates is None:
+            self.lastErrorStates = []
+        self.lastErrorStates.append(recognizer.state)
+        followSet = self.getErrorRecoverySet(recognizer)
+        self.consumeUntil(recognizer, followSet)
+
+    # The default implementation of {@link ANTLRErrorStrategy#sync} makes sure
+    # that the current lookahead symbol is consistent with what were expecting
+    # at this point in the ATN. You can call this anytime but ANTLR only
+    # generates code to check before subrules/loops and each iteration.
+    #
+    # <p>Implements Jim Idle's magic sync mechanism in closures and optional
+    # subrules. E.g.,</p>
+    #
+    # <pre>
+    # a : sync ( stuff sync )* ;
+    # sync : {consume to what can follow sync} ;
+    # </pre>
+    #
+    # At the start of a sub rule upon error, {@link #sync} performs single
+    # token deletion, if possible. If it can't do that, it bails on the current
+    # rule and uses the default error recovery, which consumes until the
+    # resynchronization set of the current rule.
+    #
+    # <p>If the sub rule is optional ({@code (...)?}, {@code (...)*}, or block
+    # with an empty alternative), then the expected set includes what follows
+    # the subrule.</p>
+    #
+    # <p>During loop iteration, it consumes until it sees a token that can start a
+    # sub rule or what follows loop. Yes, that is pretty aggressive. We opt to
+    # stay in the loop as long as possible.</p>
+    #
+    # <p><strong>ORIGINS</strong></p>
+    #
+    # <p>Previous versions of ANTLR did a poor job of their recovery within loops.
+    # A single mismatch token or missing token would force the parser to bail
+    # out of the entire rules surrounding the loop. So, for rule</p>
+    #
+    # <pre>
+    # classDef : 'class' ID '{' member* '}'
+    # </pre>
+    #
+    # input with an extra token between members would force the parser to
+    # consume until it found the next class definition rather than the next
+    # member definition of the current class.
+    #
+    # <p>This functionality cost a little bit of effort because the parser has to
+    # compare token set at the start of the loop and at each iteration. If for
+    # some reason speed is suffering for you, you can turn off this
+    # functionality by simply overriding this method as a blank { }.</p>
+    #
+    def sync(self, recognizer):
+        # If already recovering, don't try to sync
+        if self.inErrorRecoveryMode(recognizer):
+            return
+
+        s = recognizer._interp.atn.states[recognizer.state]
+        la = recognizer.getTokenStream().LA(1)
+        # try cheaper subset first; might get lucky. seems to shave a wee bit off
+        if la==Token.EOF or la in recognizer.atn.nextTokens(s):
+            return
+
+        # Return but don't end recovery. only do that upon valid token match
+        if recognizer.isExpectedToken(la):
+            return
+
+        if s.stateType in [ATNState.BLOCK_START, ATNState.STAR_BLOCK_START,
+                                ATNState.PLUS_BLOCK_START, ATNState.STAR_LOOP_ENTRY]:
+            # report error and recover if possible
+            if self.singleTokenDeletion(recognizer)is not None:
+                return
+            else:
+                raise InputMismatchException(recognizer)
+
+        elif s.stateType in [ATNState.PLUS_LOOP_BACK, ATNState.STAR_LOOP_BACK]:
+            self.reportUnwantedToken(recognizer)
+            expecting = recognizer.getExpectedTokens()
+            whatFollowsLoopIterationOrRule = expecting.addSet(self.getErrorRecoverySet(recognizer))
+            self.consumeUntil(recognizer, whatFollowsLoopIterationOrRule)
+
+        else:
+            # do nothing if we can't identify the exact kind of ATN state
+            pass
+
+    # This is called by {@link #reportError} when the exception is a
+    # {@link NoViableAltException}.
+    #
+    # @see #reportError
+    #
+    # @param recognizer the parser instance
+    # @param e the recognition exception
+    #
+    def reportNoViableAlternative(self, recognizer, e):
+        tokens = recognizer.getTokenStream()
+        if tokens is not None:
+            if e.startToken.type==Token.EOF:
+                input = "<EOF>"
+            else:
+                input = tokens.getText((e.startToken, e.offendingToken))
+        else:
+            input = "<unknown input>"
+        msg = "no viable alternative at input " + self.escapeWSAndQuote(input)
+        recognizer.notifyErrorListeners(msg, e.offendingToken, e)
+
+    #
+    # This is called by {@link #reportError} when the exception is an
+    # {@link InputMismatchException}.
+    #
+    # @see #reportError
+    #
+    # @param recognizer the parser instance
+    # @param e the recognition exception
+    #
+    def reportInputMismatch(self, recognizer, e):
+        msg = "mismatched input " + self.getTokenErrorDisplay(e.offendingToken) \
+              + " expecting " + e.getExpectedTokens().toString(recognizer.literalNames, recognizer.symbolicNames)
+        recognizer.notifyErrorListeners(msg, e.offendingToken, e)
+
+    #
+    # This is called by {@link #reportError} when the exception is a
+    # {@link FailedPredicateException}.
+    #
+    # @see #reportError
+    #
+    # @param recognizer the parser instance
+    # @param e the recognition exception
+    #
+    def reportFailedPredicate(self, recognizer, e):
+        ruleName = recognizer.ruleNames[recognizer._ctx.getRuleIndex()]
+        msg = "rule " + ruleName + " " + e.message
+        recognizer.notifyErrorListeners(msg, e.offendingToken, e)
+
+    # This method is called to report a syntax error which requires the removal
+    # of a token from the input stream. At the time this method is called, the
+    # erroneous symbol is current {@code LT(1)} symbol and has not yet been
+    # removed from the input stream. When this method returns,
+    # {@code recognizer} is in error recovery mode.
+    #
+    # <p>This method is called when {@link #singleTokenDeletion} identifies
+    # single-token deletion as a viable recovery strategy for a mismatched
+    # input error.</p>
+    #
+    # <p>The default implementation simply returns if the handler is already in
+    # error recovery mode. Otherwise, it calls {@link #beginErrorCondition} to
+    # enter error recovery mode, followed by calling
+    # {@link Parser#notifyErrorListeners}.</p>
+    #
+    # @param recognizer the parser instance
+    #
+    def reportUnwantedToken(self, recognizer):
+        if self.inErrorRecoveryMode(recognizer):
+            return
+
+        self.beginErrorCondition(recognizer)
+        t = recognizer.getCurrentToken()
+        tokenName = self.getTokenErrorDisplay(t)
+        expecting = self.getExpectedTokens(recognizer)
+        msg = "extraneous input " + tokenName + " expecting " \
+            + expecting.toString(recognizer.literalNames, recognizer.symbolicNames)
+        recognizer.notifyErrorListeners(msg, t, None)
+
+    # This method is called to report a syntax error which requires the
+    # insertion of a missing token into the input stream. At the time this
+    # method is called, the missing token has not yet been inserted. When this
+    # method returns, {@code recognizer} is in error recovery mode.
+    #
+    # <p>This method is called when {@link #singleTokenInsertion} identifies
+    # single-token insertion as a viable recovery strategy for a mismatched
+    # input error.</p>
+    #
+    # <p>The default implementation simply returns if the handler is already in
+    # error recovery mode. Otherwise, it calls {@link #beginErrorCondition} to
+    # enter error recovery mode, followed by calling
+    # {@link Parser#notifyErrorListeners}.</p>
+    #
+    # @param recognizer the parser instance
+    #
+    def reportMissingToken(self, recognizer):
+        if self.inErrorRecoveryMode(recognizer):
+            return
+        self.beginErrorCondition(recognizer)
+        t = recognizer.getCurrentToken()
+        expecting = self.getExpectedTokens(recognizer)
+        msg = "missing " + expecting.toString(recognizer.literalNames, recognizer.symbolicNames) \
+              + " at " + self.getTokenErrorDisplay(t)
+        recognizer.notifyErrorListeners(msg, t, None)
+
+    # <p>The default implementation attempts to recover from the mismatched input
+    # by using single token insertion and deletion as described below. If the
+    # recovery attempt fails, this method throws an
+    # {@link InputMismatchException}.</p>
+    #
+    # <p><strong>EXTRA TOKEN</strong> (single token deletion)</p>
+    #
+    # <p>{@code LA(1)} is not what we are looking for. If {@code LA(2)} has the
+    # right token, however, then assume {@code LA(1)} is some extra spurious
+    # token and delete it. Then consume and return the next token (which was
+    # the {@code LA(2)} token) as the successful result of the match operation.</p>
+    #
+    # <p>This recovery strategy is implemented by {@link #singleTokenDeletion}.</p>
+    #
+    # <p><strong>MISSING TOKEN</strong> (single token insertion)</p>
+    #
+    # <p>If current token (at {@code LA(1)}) is consistent with what could come
+    # after the expected {@code LA(1)} token, then assume the token is missing
+    # and use the parser's {@link TokenFactory} to create it on the fly. The
+    # "insertion" is performed by returning the created token as the successful
+    # result of the match operation.</p>
+    #
+    # <p>This recovery strategy is implemented by {@link #singleTokenInsertion}.</p>
+    #
+    # <p><strong>EXAMPLE</strong></p>
+    #
+    # <p>For example, Input {@code i=(3;} is clearly missing the {@code ')'}. When
+    # the parser returns from the nested call to {@code expr}, it will have
+    # call chain:</p>
+    #
+    # <pre>
+    # stat &rarr; expr &rarr; atom
+    # </pre>
+    #
+    # and it will be trying to match the {@code ')'} at this point in the
+    # derivation:
+    #
+    # <pre>
+    # =&gt; ID '=' '(' INT ')' ('+' atom)* ';'
+    #                    ^
+    # </pre>
+    #
+    # The attempt to match {@code ')'} will fail when it sees {@code ';'} and
+    # call {@link #recoverInline}. To recover, it sees that {@code LA(1)==';'}
+    # is in the set of tokens that can follow the {@code ')'} token reference
+    # in rule {@code atom}. It can assume that you forgot the {@code ')'}.
+    #
+    def recoverInline(self, recognizer):
+        # SINGLE TOKEN DELETION
+        matchedSymbol = self.singleTokenDeletion(recognizer)
+        if matchedSymbol is not None:
+            # we have deleted the extra token.
+            # now, move past ttype token as if all were ok
+            recognizer.consume()
+            return matchedSymbol
+
+        # SINGLE TOKEN INSERTION
+        if self.singleTokenInsertion(recognizer):
+            return self.getMissingSymbol(recognizer)
+
+        # even that didn't work; must throw the exception
+        raise InputMismatchException(recognizer)
+
+    #
+    # This method implements the single-token insertion inline error recovery
+    # strategy. It is called by {@link #recoverInline} if the single-token
+    # deletion strategy fails to recover from the mismatched input. If this
+    # method returns {@code true}, {@code recognizer} will be in error recovery
+    # mode.
+    #
+    # <p>This method determines whether or not single-token insertion is viable by
+    # checking if the {@code LA(1)} input symbol could be successfully matched
+    # if it were instead the {@code LA(2)} symbol. If this method returns
+    # {@code true}, the caller is responsible for creating and inserting a
+    # token with the correct type to produce this behavior.</p>
+    #
+    # @param recognizer the parser instance
+    # @return {@code true} if single-token insertion is a viable recovery
+    # strategy for the current mismatched input, otherwise {@code false}
+    #
+    def singleTokenInsertion(self, recognizer):
+        currentSymbolType = recognizer.getTokenStream().LA(1)
+        # if current token is consistent with what could come after current
+        # ATN state, then we know we're missing a token; error recovery
+        # is free to conjure up and insert the missing token
+        atn = recognizer._interp.atn
+        currentState = atn.states[recognizer.state]
+        next = currentState.transitions[0].target
+        expectingAtLL2 = atn.nextTokens(next, recognizer._ctx)
+        if currentSymbolType in expectingAtLL2:
+            self.reportMissingToken(recognizer)
+            return True
+        else:
+            return False
+
+    # This method implements the single-token deletion inline error recovery
+    # strategy. It is called by {@link #recoverInline} to attempt to recover
+    # from mismatched input. If this method returns null, the parser and error
+    # handler state will not have changed. If this method returns non-null,
+    # {@code recognizer} will <em>not</em> be in error recovery mode since the
+    # returned token was a successful match.
+    #
+    # <p>If the single-token deletion is successful, this method calls
+    # {@link #reportUnwantedToken} to report the error, followed by
+    # {@link Parser#consume} to actually "delete" the extraneous token. Then,
+    # before returning {@link #reportMatch} is called to signal a successful
+    # match.</p>
+    #
+    # @param recognizer the parser instance
+    # @return the successfully matched {@link Token} instance if single-token
+    # deletion successfully recovers from the mismatched input, otherwise
+    # {@code null}
+    #
+    def singleTokenDeletion(self, recognizer):
+        nextTokenType = recognizer.getTokenStream().LA(2)
+        expecting = self.getExpectedTokens(recognizer)
+        if nextTokenType in expecting:
+            self.reportUnwantedToken(recognizer)
+            # print("recoverFromMismatchedToken deleting " \
+            #     + str(recognizer.getTokenStream().LT(1)) \
+            #     + " since " + str(recognizer.getTokenStream().LT(2)) \
+            #     + " is what we want", file=sys.stderr)
+            recognizer.consume() # simply delete extra token
+            # we want to return the token we're actually matching
+            matchedSymbol = recognizer.getCurrentToken()
+            self.reportMatch(recognizer) # we know current token is correct
+            return matchedSymbol
+        else:
+            return None
+
+    # Conjure up a missing token during error recovery.
+    #
+    #  The recognizer attempts to recover from single missing
+    #  symbols. But, actions might refer to that missing symbol.
+    #  For example, x=ID {f($x);}. The action clearly assumes
+    #  that there has been an identifier matched previously and that
+    #  $x points at that token. If that token is missing, but
+    #  the next token in the stream is what we want we assume that
+    #  this token is missing and we keep going. Because we
+    #  have to return some token to replace the missing token,
+    #  we have to conjure one up. This method gives the user control
+    #  over the tokens returned for missing tokens. Mostly,
+    #  you will want to create something special for identifier
+    #  tokens. For literals such as '{' and ',', the default
+    #  action in the parser or tree parser works. It simply creates
+    #  a CommonToken of the appropriate type. The text will be the token.
+    #  If you change what tokens must be created by the lexer,
+    #  override this method to create the appropriate tokens.
+    #
+    def getMissingSymbol(self, recognizer):
+        currentSymbol = recognizer.getCurrentToken()
+        expecting = self.getExpectedTokens(recognizer)
+        expectedTokenType = expecting[0] # get any element
+        if expectedTokenType==Token.EOF:
+            tokenText = "<missing EOF>"
+        else:
+            name = None
+            if expectedTokenType < len(recognizer.literalNames):
+                name = recognizer.literalNames[expectedTokenType]
+            if name is None and expectedTokenType < len(recognizer.symbolicNames):
+                name = recognizer.symbolicNames[expectedTokenType]
+            tokenText = "<missing " + str(name) + ">"
+        current = currentSymbol
+        lookback = recognizer.getTokenStream().LT(-1)
+        if current.type==Token.EOF and lookback is not None:
+            current = lookback
+        return recognizer.getTokenFactory().create(current.source,
+            expectedTokenType, tokenText, Token.DEFAULT_CHANNEL,
+            -1, -1, current.line, current.column)
+
+    def getExpectedTokens(self, recognizer):
+        return recognizer.getExpectedTokens()
+
+    # How should a token be displayed in an error message? The default
+    #  is to display just the text, but during development you might
+    #  want to have a lot of information spit out.  Override in that case
+    #  to use t.toString() (which, for CommonToken, dumps everything about
+    #  the token). This is better than forcing you to override a method in
+    #  your token objects because you don't have to go modify your lexer
+    #  so that it creates a new Java type.
+    #
+    def getTokenErrorDisplay(self, t):
+        if t is None:
+            return u"<no token>"
+        s = t.text
+        if s is None:
+            if t.type==Token.EOF:
+                s = u"<EOF>"
+            else:
+                s = u"<" + unicode(t.type) + u">"
+        return self.escapeWSAndQuote(s)
+
+    def escapeWSAndQuote(self, s):
+        s = s.replace(u"\n",u"\\n")
+        s = s.replace(u"\r",u"\\r")
+        s = s.replace(u"\t",u"\\t")
+        return u"'" + s + u"'"
+
+    #  Compute the error recovery set for the current rule.  During
+    #  rule invocation, the parser pushes the set of tokens that can
+    #  follow that rule reference on the stack; this amounts to
+    #  computing FIRST of what follows the rule reference in the
+    #  enclosing rule. See LinearApproximator.FIRST().
+    #  This local follow set only includes tokens
+    #  from within the rule; i.e., the FIRST computation done by
+    #  ANTLR stops at the end of a rule.
+    #
+    #  EXAMPLE
+    #
+    #  When you find a "no viable alt exception", the input is not
+    #  consistent with any of the alternatives for rule r.  The best
+    #  thing to do is to consume tokens until you see something that
+    #  can legally follow a call to r#or* any rule that called r.
+    #  You don't want the exact set of viable next tokens because the
+    #  input might just be missing a token--you might consume the
+    #  rest of the input looking for one of the missing tokens.
+    #
+    #  Consider grammar:
+    #
+    #  a : '[' b ']'
+    #    | '(' b ')'
+    #    ;
+    #  b : c '^' INT ;
+    #  c : ID
+    #    | INT
+    #    ;
+    #
+    #  At each rule invocation, the set of tokens that could follow
+    #  that rule is pushed on a stack.  Here are the various
+    #  context-sensitive follow sets:
+    #
+    #  FOLLOW(b1_in_a) = FIRST(']') = ']'
+    #  FOLLOW(b2_in_a) = FIRST(')') = ')'
+    #  FOLLOW(c_in_b) = FIRST('^') = '^'
+    #
+    #  Upon erroneous input "[]", the call chain is
+    #
+    #  a -> b -> c
+    #
+    #  and, hence, the follow context stack is:
+    #
+    #  depth     follow set       start of rule execution
+    #    0         <EOF>                    a (from main())
+    #    1          ']'                     b
+    #    2          '^'                     c
+    #
+    #  Notice that ')' is not included, because b would have to have
+    #  been called from a different context in rule a for ')' to be
+    #  included.
+    #
+    #  For error recovery, we cannot consider FOLLOW(c)
+    #  (context-sensitive or otherwise).  We need the combined set of
+    #  all context-sensitive FOLLOW sets--the set of all tokens that
+    #  could follow any reference in the call chain.  We need to
+    #  resync to one of those tokens.  Note that FOLLOW(c)='^' and if
+    #  we resync'd to that token, we'd consume until EOF.  We need to
+    #  sync to context-sensitive FOLLOWs for a, b, and c: {']','^'}.
+    #  In this case, for input "[]", LA(1) is ']' and in the set, so we would
+    #  not consume anything. After printing an error, rule c would
+    #  return normally.  Rule b would not find the required '^' though.
+    #  At this point, it gets a mismatched token error and throws an
+    #  exception (since LA(1) is not in the viable following token
+    #  set).  The rule exception handler tries to recover, but finds
+    #  the same recovery set and doesn't consume anything.  Rule b
+    #  exits normally returning to rule a.  Now it finds the ']' (and
+    #  with the successful match exits errorRecovery mode).
+    #
+    #  So, you can see that the parser walks up the call chain looking
+    #  for the token that was a member of the recovery set.
+    #
+    #  Errors are not generated in errorRecovery mode.
+    #
+    #  ANTLR's error recovery mechanism is based upon original ideas:
+    #
+    #  "Algorithms + Data Structures = Programs" by Niklaus Wirth
+    #
+    #  and
+    #
+    #  "A note on error recovery in recursive descent parsers":
+    #  http:#portal.acm.org/citation.cfm?id=947902.947905
+    #
+    #  Later, Josef Grosch had some good ideas:
+    #
+    #  "Efficient and Comfortable Error Recovery in Recursive Descent
+    #  Parsers":
+    #  ftp:#www.cocolab.com/products/cocktail/doca4.ps/ell.ps.zip
+    #
+    #  Like Grosch I implement context-sensitive FOLLOW sets that are combined
+    #  at run-time upon error to avoid overhead during parsing.
+    #
+    def getErrorRecoverySet(self, recognizer):
+        atn = recognizer._interp.atn
+        ctx = recognizer._ctx
+        recoverSet = IntervalSet()
+        while ctx is not None and ctx.invokingState>=0:
+            # compute what follows who invoked us
+            invokingState = atn.states[ctx.invokingState]
+            rt = invokingState.transitions[0]
+            follow = atn.nextTokens(rt.followState)
+            recoverSet.addSet(follow)
+            ctx = ctx.parentCtx
+        recoverSet.removeOne(Token.EPSILON)
+        return recoverSet
+
+    # Consume tokens until one matches the given token set.#
+    def consumeUntil(self, recognizer, set_):
+        ttype = recognizer.getTokenStream().LA(1)
+        while ttype != Token.EOF and not ttype in set_:
+            recognizer.consume()
+            ttype = recognizer.getTokenStream().LA(1)
+
+
+#
+# This implementation of {@link ANTLRErrorStrategy} responds to syntax errors
+# by immediately canceling the parse operation with a
+# {@link ParseCancellationException}. The implementation ensures that the
+# {@link ParserRuleContext#exception} field is set for all parse tree nodes
+# that were not completed prior to encountering the error.
+#
+# <p>
+# This error strategy is useful in the following scenarios.</p>
+#
+# <ul>
+# <li><strong>Two-stage parsing:</strong> This error strategy allows the first
+# stage of two-stage parsing to immediately terminate if an error is
+# encountered, and immediately fall back to the second stage. In addition to
+# avoiding wasted work by attempting to recover from errors here, the empty
+# implementation of {@link BailErrorStrategy#sync} improves the performance of
+# the first stage.</li>
+# <li><strong>Silent validation:</strong> When syntax errors are not being
+# reported or logged, and the parse result is simply ignored if errors occur,
+# the {@link BailErrorStrategy} avoids wasting work on recovering from errors
+# when the result will be ignored either way.</li>
+# </ul>
+#
+# <p>
+# {@code myparser.setErrorHandler(new BailErrorStrategy());}</p>
+#
+# @see Parser#setErrorHandler(ANTLRErrorStrategy)
+#
+class BailErrorStrategy(DefaultErrorStrategy):
+    # Instead of recovering from exception {@code e}, re-throw it wrapped
+    #  in a {@link ParseCancellationException} so it is not caught by the
+    #  rule function catches.  Use {@link Exception#getCause()} to get the
+    #  original {@link RecognitionException}.
+    #
+    def recover(self, recognizer, e):
+        context = recognizer._ctx
+        while context is not None:
+            context.exception = e
+            context = context.parentCtx
+        raise ParseCancellationException(e)
+
+    # Make sure we don't attempt to recover inline; if the parser
+    #  successfully recovers, it won't throw an exception.
+    #
+    def recoverInline(self, recognizer):
+        self.recover(recognizer, InputMismatchException(recognizer))
+
+    # Make sure we don't attempt to recover from problems in subrules.#
+    def sync(self, recognizer):
+        pass
diff --git a/runtime/Python2/src/antlr4/error/Errors.py b/runtime/Python2/src/antlr4/error/Errors.py
new file mode 100644
index 000000000..017116dba
--- /dev/null
+++ b/runtime/Python2/src/antlr4/error/Errors.py
@@ -0,0 +1,181 @@
+# [The "BSD license"]
+#  Copyright (c) 2012 Terence Parr
+#  Copyright (c) 2012 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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.
+#/
+from antlr4.atn.Transition import PredicateTransition
+
+
+class UnsupportedOperationException(Exception):
+
+    def __init__(self, msg):
+        super(UnsupportedOperationException, self).__init__(msg)
+
+class IllegalStateException(Exception):
+
+    def __init__(self, msg):
+        super(IllegalStateException, self).__init__(msg)
+
+class CancellationException(IllegalStateException):
+
+    def __init__(self, msg):
+        super(CancellationException, self).__init__(msg)
+
+# The root of the ANTLR exception hierarchy. In general, ANTLR tracks just
+#  3 kinds of errors: prediction errors, failed predicate errors, and
+#  mismatched input errors. In each case, the parser knows where it is
+#  in the input, where it is in the ATN, the rule invocation stack,
+#  and what kind of problem occurred.
+
+from antlr4.InputStream import InputStream
+from antlr4.ParserRuleContext import ParserRuleContext
+from antlr4.Recognizer import Recognizer
+
+class RecognitionException(Exception):
+
+
+    def __init__(self, message=None, recognizer=None, input=None, ctx=None):
+        super(RecognitionException, self).__init__(message)
+        self.recognizer = recognizer
+        self.input = input
+        self.ctx = ctx
+        # The current {@link Token} when an error occurred. Since not all streams
+        # support accessing symbols by index, we have to track the {@link Token}
+        # instance itself.
+        self.offendingToken = None
+        # Get the ATN state number the parser was in at the time the error
+        # occurred. For {@link NoViableAltException} and
+        # {@link LexerNoViableAltException} exceptions, this is the
+        # {@link DecisionState} number. For others, it is the state whose outgoing
+        # edge we couldn't match.
+        self.offendingState = -1
+        if recognizer is not None:
+            self.offendingState = recognizer.state
+
+    # <p>If the state number is not known, this method returns -1.</p>
+
+    #
+    # Gets the set of input symbols which could potentially follow the
+    # previously matched symbol at the time this exception was thrown.
+    #
+    # <p>If the set of expected tokens is not known and could not be computed,
+    # this method returns {@code null}.</p>
+    #
+    # @return The set of token types that could potentially follow the current
+    # state in the ATN, or {@code null} if the information is not available.
+    #/
+    def getExpectedTokens(self):
+        if self.recognizer is not None:
+            return self.recognizer.atn.getExpectedTokens(self.offendingState, self.ctx)
+        else:
+            return None
+
+    def __str__(self):
+        return unicode(self)
+
+
+class LexerNoViableAltException(RecognitionException):
+
+    def __init__(self, lexer, input, startIndex, deadEndConfigs):
+        super(LexerNoViableAltException, self).__init__(message=None, recognizer=lexer, input=input, ctx=None)
+        self.startIndex = startIndex
+        self.deadEndConfigs = deadEndConfigs
+
+    def __unicode__(self):
+        symbol = ""
+        if self.startIndex >= 0 and self.startIndex < self.input.size():
+            symbol = self.input.getText((self.startIndex,self.startIndex))
+            # TODO symbol = Utils.escapeWhitespace(symbol, false);
+        return u"LexerNoViableAltException" + symbol
+
+# Indicates that the parser could not decide which of two or more paths
+#  to take based upon the remaining input. It tracks the starting token
+#  of the offending input and also knows where the parser was
+#  in the various paths when the error. Reported by reportNoViableAlternative()
+#
+class NoViableAltException(RecognitionException):
+
+    def __init__(self, recognizer, input=None, startToken=None, offendingToken=None, deadEndConfigs=None, ctx=None):
+        if ctx is None:
+            ctx = recognizer._ctx
+        if offendingToken is None:
+            offendingToken = recognizer.getCurrentToken()
+        if startToken is None:
+            startToken = recognizer.getCurrentToken()
+        if input is None:
+            input = recognizer.getInputStream()
+        super(NoViableAltException, self).__init__(recognizer=recognizer, input=input, ctx=ctx)
+        # Which configurations did we try at input.index() that couldn't match input.LT(1)?#
+        self.deadEndConfigs = deadEndConfigs
+        # The token object at the start index; the input stream might
+        # 	not be buffering tokens so get a reference to it. (At the
+        #  time the error occurred, of course the stream needs to keep a
+        #  buffer all of the tokens but later we might not have access to those.)
+        self.startToken = startToken
+        self.offendingToken = offendingToken
+
+# This signifies any kind of mismatched input exceptions such as
+#  when the current input does not match the expected token.
+#
+class InputMismatchException(RecognitionException):
+
+    def __init__(self, recognizer):
+        super(InputMismatchException, self).__init__(recognizer=recognizer, input=recognizer.getInputStream(), ctx=recognizer._ctx)
+        self.offendingToken = recognizer.getCurrentToken()
+
+
+# A semantic predicate failed during validation.  Validation of predicates
+#  occurs when normally parsing the alternative just like matching a token.
+#  Disambiguating predicate evaluation occurs when we test a predicate during
+#  prediction.
+
+class FailedPredicateException(RecognitionException):
+
+    def __init__(self, recognizer, predicate=None, message=None):
+        super(FailedPredicateException, self).__init__(message=self.formatMessage(predicate,message), recognizer=recognizer,
+                         input=recognizer.getInputStream(), ctx=recognizer._ctx)
+        s = recognizer._interp.atn.states[recognizer.state]
+        trans = s.transitions[0]
+        if isinstance(trans, PredicateTransition):
+            self.ruleIndex = trans.ruleIndex
+            self.predicateIndex = trans.predIndex
+        else:
+            self.ruleIndex = 0
+            self.predicateIndex = 0
+        self.predicate = predicate
+        self.offendingToken = recognizer.getCurrentToken()
+
+    def formatMessage(self, predicate, message):
+        if message is not None:
+            return message
+        else:
+            return "failed predicate: {" + predicate + "}?"
+
+class ParseCancellationException(CancellationException):
+
+    pass
+
diff --git a/runtime/Python2/src/antlr4/error/__init__.py b/runtime/Python2/src/antlr4/error/__init__.py
new file mode 100644
index 000000000..216c000dc
--- /dev/null
+++ b/runtime/Python2/src/antlr4/error/__init__.py
@@ -0,0 +1 @@
+__author__ = 'ericvergnaud'
diff --git a/runtime/Python2/src/antlr4/tree/Chunk.py b/runtime/Python2/src/antlr4/tree/Chunk.py
new file mode 100644
index 000000000..f047f15aa
--- /dev/null
+++ b/runtime/Python2/src/antlr4/tree/Chunk.py
@@ -0,0 +1,26 @@
+class Chunk(object):
+
+    def __str__(self):
+        return unicode(self)
+
+
+class TagChunk(Chunk):
+
+    def __init__(self, tag, label=None):
+        self.tag = tag
+        self.label = label
+
+    def __unicode__(self):
+        if self.label is None:
+            return self.tag
+        else:
+            return self.label + ":" + self.tag
+
+class TextChunk(Chunk):
+
+    def __init__(self, text):
+        self.text = text
+
+    def __unicode__(self):
+        return "'" + self.text + "'"
+
diff --git a/runtime/Python2/src/antlr4/tree/ParseTreeMatch.py b/runtime/Python2/src/antlr4/tree/ParseTreeMatch.py
new file mode 100644
index 000000000..f658197ef
--- /dev/null
+++ b/runtime/Python2/src/antlr4/tree/ParseTreeMatch.py
@@ -0,0 +1,145 @@
+#
+# [The "BSD license"]
+# Copyright (c) 2013 Terence Parr
+# Copyright (c) 2013 Sam Harwell
+# Copyright (c) 2014 Eric Vergnaud
+# 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.
+#
+
+
+#
+# Represents the result of matching a {@link ParseTree} against a tree pattern.
+#
+from io import StringIO
+
+
+class ParseTreeMatch(object):
+
+    #
+    # Constructs a new instance of {@link ParseTreeMatch} from the specified
+    # parse tree and pattern.
+    #
+    # @param tree The parse tree to match against the pattern.
+    # @param pattern The parse tree pattern.
+    # @param labels A mapping from label names to collections of
+    # {@link ParseTree} objects located by the tree pattern matching process.
+    # @param mismatchedNode The first node which failed to match the tree
+    # pattern during the matching process.
+    #
+    # @exception IllegalArgumentException if {@code tree} is {@code null}
+    # @exception IllegalArgumentException if {@code pattern} is {@code null}
+    # @exception IllegalArgumentException if {@code labels} is {@code null}
+    #
+    def __init__(self, tree, pattern, labels, mismatchedNode):
+        if tree is None:
+            raise Exception("tree cannot be null")
+        if pattern is None:
+            raise Exception("pattern cannot be null")
+        if labels is None:
+            raise Exception("labels cannot be null")
+        self.tree = tree
+        self.pattern = pattern
+        self.labels = labels
+        self.mismatchedNode = mismatchedNode
+
+    #
+    # Get the last node associated with a specific {@code label}.
+    #
+    # <p>For example, for pattern {@code <id:ID>}, {@code get("id")} returns the
+    # node matched for that {@code ID}. If more than one node
+    # matched the specified label, only the last is returned. If there is
+    # no node associated with the label, this returns {@code null}.</p>
+    #
+    # <p>Pattern tags like {@code <ID>} and {@code <expr>} without labels are
+    # considered to be labeled with {@code ID} and {@code expr}, respectively.</p>
+    #
+    # @param label The label to check.
+    #
+    # @return The last {@link ParseTree} to match a tag with the specified
+    # label, or {@code null} if no parse tree matched a tag with the label.
+    #
+    def get(self, label):
+        parseTrees = self.labels.get(label, None)
+        if parseTrees is None or len(parseTrees)==0:
+            return None
+        else:
+            return parseTrees[len(parseTrees)-1]
+
+    #
+    # Return all nodes matching a rule or token tag with the specified label.
+    #
+    # <p>If the {@code label} is the name of a parser rule or token in the
+    # grammar, the resulting list will contain both the parse trees matching
+    # rule or tags explicitly labeled with the label and the complete set of
+    # parse trees matching the labeled and unlabeled tags in the pattern for
+    # the parser rule or token. For example, if {@code label} is {@code "foo"},
+    # the result will contain <em>all</em> of the following.</p>
+    #
+    # <ul>
+    # <li>Parse tree nodes matching tags of the form {@code <foo:anyRuleName>} and
+    # {@code <foo:AnyTokenName>}.</li>
+    # <li>Parse tree nodes matching tags of the form {@code <anyLabel:foo>}.</li>
+    # <li>Parse tree nodes matching tags of the form {@code <foo>}.</li>
+    # </ul>
+    #
+    # @param label The label.
+    #
+    # @return A collection of all {@link ParseTree} nodes matching tags with
+    # the specified {@code label}. If no nodes matched the label, an empty list
+    # is returned.
+    #
+    def getAll(self, label):
+        nodes = self.labels.get(label, None)
+        if nodes is None:
+            return list()
+        else:
+            return nodes
+
+
+    #
+    # Gets a value indicating whether the match operation succeeded.
+    #
+    # @return {@code true} if the match operation succeeded; otherwise,
+    # {@code false}.
+    #
+    def succeeded(self):
+        return self.mismatchedNode is None
+
+    #
+    # {@inheritDoc}
+    #
+    def __str__(self):
+        return unicode(self)
+
+
+    def __unicode__(self):
+        with StringIO() as buf:
+            buf.write(u"Match ")
+            buf.write(u"succeeded" if self.succeeded() else "failed")
+            buf.write(u"; found ")
+            buf.write(unicode(len(self.labels)))
+            buf.write(u" labels")
+            return buf.getvalue()
diff --git a/runtime/Python2/src/antlr4/tree/ParseTreePattern.py b/runtime/Python2/src/antlr4/tree/ParseTreePattern.py
new file mode 100644
index 000000000..96119c36f
--- /dev/null
+++ b/runtime/Python2/src/antlr4/tree/ParseTreePattern.py
@@ -0,0 +1,94 @@
+#
+# [The "BSD license"]
+# Copyright (c) 2013 Terence Parr
+# Copyright (c) 2013 Sam Harwell
+# Copyright (c) 2014 Eric Vergnaud
+# 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 pattern like {@code <ID> = <expr>;} converted to a {@link ParseTree} by
+# {@link ParseTreePatternMatcher#compile(String, int)}.
+#
+from antlr4.xpath.XPath import XPath
+
+
+class ParseTreePattern(object):
+
+    # Construct a new instance of the {@link ParseTreePattern} class.
+    #
+    # @param matcher The {@link ParseTreePatternMatcher} which created this
+    # tree pattern.
+    # @param pattern The tree pattern in concrete syntax form.
+    # @param patternRuleIndex The parser rule which serves as the root of the
+    # tree pattern.
+    # @param patternTree The tree pattern in {@link ParseTree} form.
+    #
+    def __init__(self, matcher, pattern, patternRuleIndex , patternTree):
+        self.matcher = matcher
+        self.patternRuleIndex = patternRuleIndex
+        self.pattern = pattern
+        self.patternTree = patternTree
+
+    #
+    # Match a specific parse tree against this tree pattern.
+    #
+    # @param tree The parse tree to match against this tree pattern.
+    # @return A {@link ParseTreeMatch} object describing the result of the
+    # match operation. The {@link ParseTreeMatch#succeeded()} method can be
+    # used to determine whether or not the match was successful.
+    #
+    def match(self, tree):
+        return self.matcher.match(tree, self)
+
+    #
+    # Determine whether or not a parse tree matches this tree pattern.
+    #
+    # @param tree The parse tree to match against this tree pattern.
+    # @return {@code true} if {@code tree} is a match for the current tree
+    # pattern; otherwise, {@code false}.
+    #
+    def matches(self, tree):
+        return self.matcher.match(tree, self).succeeded()
+
+    # Find all nodes using XPath and then try to match those subtrees against
+    # this tree pattern.
+    #
+    # @param tree The {@link ParseTree} to match against this pattern.
+    # @param xpath An expression matching the nodes
+    #
+    # @return A collection of {@link ParseTreeMatch} objects describing the
+    # successful matches. Unsuccessful matches are omitted from the result,
+    # regardless of the reason for the failure.
+    #
+    def findAll(self, tree, xpath):
+        subtrees = XPath.findAll(tree, xpath, self.matcher.parser)
+        matches = list()
+        for t in subtrees:
+            match = self.match(t)
+            if match.succeeded():
+                matches.append(match)
+        return matches
diff --git a/runtime/Python2/src/antlr4/tree/ParseTreePatternMatcher.py b/runtime/Python2/src/antlr4/tree/ParseTreePatternMatcher.py
new file mode 100644
index 000000000..5011e3ba6
--- /dev/null
+++ b/runtime/Python2/src/antlr4/tree/ParseTreePatternMatcher.py
@@ -0,0 +1,392 @@
+#
+# [The "BSD license"]
+# Copyright (c) 2013 Terence Parr
+# Copyright (c) 2013 Sam Harwell
+# Copyright (c) 2014 Eric Vergnaud
+# 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 tree pattern matching mechanism for ANTLR {@link ParseTree}s.
+#
+# <p>Patterns are strings of source input text with special tags representing
+# token or rule references such as:</p>
+#
+# <p>{@code <ID> = <expr>;}</p>
+#
+# <p>Given a pattern start rule such as {@code statement}, this object constructs
+# a {@link ParseTree} with placeholders for the {@code ID} and {@code expr}
+# subtree. Then the {@link #match} routines can compare an actual
+# {@link ParseTree} from a parse with this pattern. Tag {@code <ID>} matches
+# any {@code ID} token and tag {@code <expr>} references the result of the
+# {@code expr} rule (generally an instance of {@code ExprContext}.</p>
+#
+# <p>Pattern {@code x = 0;} is a similar pattern that matches the same pattern
+# except that it requires the identifier to be {@code x} and the expression to
+# be {@code 0}.</p>
+#
+# <p>The {@link #matches} routines return {@code true} or {@code false} based
+# upon a match for the tree rooted at the parameter sent in. The
+# {@link #match} routines return a {@link ParseTreeMatch} object that
+# contains the parse tree, the parse tree pattern, and a map from tag name to
+# matched nodes (more below). A subtree that fails to match, returns with
+# {@link ParseTreeMatch#mismatchedNode} set to the first tree node that did not
+# match.</p>
+#
+# <p>For efficiency, you can compile a tree pattern in string form to a
+# {@link ParseTreePattern} object.</p>
+#
+# <p>See {@code TestParseTreeMatcher} for lots of examples.
+# {@link ParseTreePattern} has two static helper methods:
+# {@link ParseTreePattern#findAll} and {@link ParseTreePattern#match} that
+# are easy to use but not super efficient because they create new
+# {@link ParseTreePatternMatcher} objects each time and have to compile the
+# pattern in string form before using it.</p>
+#
+# <p>The lexer and parser that you pass into the {@link ParseTreePatternMatcher}
+# constructor are used to parse the pattern in string form. The lexer converts
+# the {@code <ID> = <expr>;} into a sequence of four tokens (assuming lexer
+# throws out whitespace or puts it on a hidden channel). Be aware that the
+# input stream is reset for the lexer (but not the parser; a
+# {@link ParserInterpreter} is created to parse the input.). Any user-defined
+# fields you have put into the lexer might get changed when this mechanism asks
+# it to scan the pattern string.</p>
+#
+# <p>Normally a parser does not accept token {@code <expr>} as a valid
+# {@code expr} but, from the parser passed in, we create a special version of
+# the underlying grammar representation (an {@link ATN}) that allows imaginary
+# tokens representing rules ({@code <expr>}) to match entire rules. We call
+# these <em>bypass alternatives</em>.</p>
+#
+# <p>Delimiters are {@code <} and {@code >}, with {@code \} as the escape string
+# by default, but you can set them to whatever you want using
+# {@link #setDelimiters}. You must escape both start and stop strings
+# {@code \<} and {@code \>}.</p>
+#
+from antlr4 import CommonTokenStream, ParserRuleContext
+from antlr4.InputStream import InputStream
+from antlr4.ListTokenSource import ListTokenSource
+from antlr4.Token import Token
+from antlr4.error.ErrorStrategy import BailErrorStrategy
+from antlr4.error.Errors import RecognitionException, ParseCancellationException
+from antlr4.tree.Chunk import TagChunk, TextChunk
+from antlr4.tree.RuleTagToken import RuleTagToken
+from antlr4.tree.TokenTagToken import TokenTagToken
+from antlr4.tree.Tree import TerminalNode, RuleNode
+
+class CannotInvokeStartRule(Exception):
+
+    def __init__(self, e):
+        super(CannotInvokeStartRule, self).__init__(e)
+
+class StartRuleDoesNotConsumeFullPattern(Exception):
+
+    pass
+
+
+class ParseTreePatternMatcher(object):
+
+    # Constructs a {@link ParseTreePatternMatcher} or from a {@link Lexer} and
+    # {@link Parser} object. The lexer input stream is altered for tokenizing
+    # the tree patterns. The parser is used as a convenient mechanism to get
+    # the grammar name, plus token, rule names.
+    def __init__(self, lexer, parser):
+        self.lexer = lexer
+        self.parser = parser
+        self.start = "<"
+        self.stop = ">"
+        self.escape = "\\"  # e.g., \< and \> must escape BOTH!
+
+    # Set the delimiters used for marking rule and token tags within concrete
+    # syntax used by the tree pattern parser.
+    #
+    # @param start The start delimiter.
+    # @param stop The stop delimiter.
+    # @param escapeLeft The escape sequence to use for escaping a start or stop delimiter.
+    #
+    # @exception IllegalArgumentException if {@code start} is {@code null} or empty.
+    # @exception IllegalArgumentException if {@code stop} is {@code null} or empty.
+    #
+    def setDelimiters(self, start, stop, escapeLeft):
+        if start is None or len(start)==0:
+            raise Exception("start cannot be null or empty")
+        if stop is None or len(stop)==0:
+            raise Exception("stop cannot be null or empty")
+        self.start = start
+        self.stop = stop
+        self.escape = escapeLeft
+
+    # Does {@code pattern} matched as rule {@code patternRuleIndex} match {@code tree}?#
+    def matchesRuleIndex(self, tree, pattern, patternRuleIndex):
+        p = self.compileTreePattern(pattern, patternRuleIndex)
+        return self.matches(tree, p)
+
+    # Does {@code pattern} matched as rule patternRuleIndex match tree? Pass in a
+    #  compiled pattern instead of a string representation of a tree pattern.
+    #
+    def matchesPattern(self, tree, pattern):
+        mismatchedNode = self.matchImpl(tree, pattern.patternTree, dict())
+        return mismatchedNode is None
+
+    #
+    # Compare {@code pattern} matched as rule {@code patternRuleIndex} against
+    # {@code tree} and return a {@link ParseTreeMatch} object that contains the
+    # matched elements, or the node at which the match failed.
+    #
+    def matchRuleIndex(self, tree, pattern, patternRuleIndex):
+        p = self.compileTreePattern(pattern, patternRuleIndex)
+        return self.matchPattern(tree, p)
+
+    #
+    # Compare {@code pattern} matched against {@code tree} and return a
+    # {@link ParseTreeMatch} object that contains the matched elements, or the
+    # node at which the match failed. Pass in a compiled pattern instead of a
+    # string representation of a tree pattern.
+    #
+    def matchPattern(self, tree, pattern):
+        labels = dict()
+        mismatchedNode = self.matchImpl(tree, pattern.patternTree, labels)
+        from antlr4.tree.ParseTreeMatch import ParseTreeMatch
+        return ParseTreeMatch(tree, pattern, labels, mismatchedNode)
+
+    #
+    # For repeated use of a tree pattern, compile it to a
+    # {@link ParseTreePattern} using this method.
+    #
+    def compileTreePattern(self, pattern, patternRuleIndex):
+        tokenList = self.tokenize(pattern)
+        tokenSrc = ListTokenSource(tokenList)
+        tokens = CommonTokenStream(tokenSrc)
+        from antlr4.ParserInterpreter import ParserInterpreter
+        parserInterp = ParserInterpreter(self.parser.grammarFileName, self.parser.tokenNames,
+                                self.parser.ruleNames, self.parser.getATNWithBypassAlts(),tokens)
+        tree = None
+        try:
+            parserInterp.setErrorHandler(BailErrorStrategy())
+            tree = parserInterp.parse(patternRuleIndex)
+        except ParseCancellationException as e:
+            raise e.cause
+        except RecognitionException as e:
+            raise e
+        except Exception as e:
+            raise CannotInvokeStartRule(e)
+
+        # Make sure tree pattern compilation checks for a complete parse
+        if tokens.LA(1)!=Token.EOF:
+            raise StartRuleDoesNotConsumeFullPattern()
+
+        from antlr4.tree.ParseTreePattern import ParseTreePattern
+        return ParseTreePattern(self, pattern, patternRuleIndex, tree)
+
+    #
+    # Recursively walk {@code tree} against {@code patternTree}, filling
+    # {@code match.}{@link ParseTreeMatch#labels labels}.
+    #
+    # @return the first node encountered in {@code tree} which does not match
+    # a corresponding node in {@code patternTree}, or {@code null} if the match
+    # was successful. The specific node returned depends on the matching
+    # algorithm used by the implementation, and may be overridden.
+    #
+    def matchImpl(self, tree, patternTree, labels):
+        if tree is None:
+            raise Exception("tree cannot be null")
+        if patternTree is None:
+            raise Exception("patternTree cannot be null")
+
+        # x and <ID>, x and y, or x and x; or could be mismatched types
+        if isinstance(tree, TerminalNode) and isinstance(patternTree, TerminalNode ):
+            mismatchedNode = None
+            # both are tokens and they have same type
+            if tree.symbol.type == patternTree.symbol.type:
+                if isinstance( patternTree.symbol, TokenTagToken ): # x and <ID>
+                    tokenTagToken = patternTree.symbol
+                    # track label->list-of-nodes for both token name and label (if any)
+                    self.map(labels, tokenTagToken.tokenName, tree)
+                    if tokenTagToken.label is not None:
+                        self.map(labels, tokenTagToken.label, tree)
+                elif tree.getText()==patternTree.getText():
+                    # x and x
+                    pass
+                else:
+                    # x and y
+                    if mismatchedNode is None:
+                        mismatchedNode = tree
+            else:
+                if mismatchedNode is None:
+                    mismatchedNode = tree
+
+            return mismatchedNode
+
+        if isinstance(tree, ParserRuleContext) and isinstance(patternTree, ParserRuleContext):
+            mismatchedNode = None
+            # (expr ...) and <expr>
+            ruleTagToken = self.getRuleTagToken(patternTree)
+            if ruleTagToken is not None:
+                m = None
+                if tree.ruleContext.ruleIndex == patternTree.ruleContext.ruleIndex:
+                    # track label->list-of-nodes for both rule name and label (if any)
+                    self.map(labels, ruleTagToken.ruleName, tree)
+                    if ruleTagToken.label is not None:
+                        self.map(labels, ruleTagToken.label, tree)
+                else:
+                    if mismatchedNode is None:
+                        mismatchedNode = tree
+
+                return mismatchedNode
+
+            # (expr ...) and (expr ...)
+            if tree.getChildCount()!=patternTree.getChildCount():
+                if mismatchedNode is None:
+                    mismatchedNode = tree
+                return mismatchedNode
+
+            n = tree.getChildCount()
+            for i in range(0, n):
+                childMatch = self.matchImpl(tree.getChild(i), patternTree.getChild(i), labels)
+                if childMatch is not None:
+                    return childMatch
+
+            return mismatchedNode
+
+        # if nodes aren't both tokens or both rule nodes, can't match
+        return tree
+
+    def map(self, labels, label, tree):
+        v = labels.get(label, None)
+        if v is None:
+            v = list()
+            labels[label] = v
+        v.append(tree)
+
+    # Is {@code t} {@code (expr <expr>)} subtree?#
+    def getRuleTagToken(self, tree):
+        if isinstance( tree, RuleNode ):
+            if tree.getChildCount()==1 and isinstance(tree.getChild(0), TerminalNode ):
+                c = tree.getChild(0)
+                if isinstance( c.symbol, RuleTagToken ):
+                    return c.symbol
+        return None
+
+    def tokenize(self, pattern):
+        # split pattern into chunks: sea (raw input) and islands (<ID>, <expr>)
+        chunks = self.split(pattern)
+
+        # create token stream from text and tags
+        tokens = list()
+        for chunk in chunks:
+            if isinstance( chunk, TagChunk ):
+                # add special rule token or conjure up new token from name
+                if chunk.tag[0].isupper():
+                    ttype = self.parser.getTokenType(chunk.tag)
+                    if ttype==Token.INVALID_TYPE:
+                        raise Exception("Unknown token " + str(chunk.tag) + " in pattern: " + pattern)
+                    tokens.append(TokenTagToken(chunk.tag, ttype, chunk.label))
+                elif chunk.tag[0].islower():
+                    ruleIndex = self.parser.getRuleIndex(chunk.tag)
+                    if ruleIndex==-1:
+                        raise Exception("Unknown rule " + str(chunk.tag) + " in pattern: " + pattern)
+                    ruleImaginaryTokenType = self.parser.getATNWithBypassAlts().ruleToTokenType[ruleIndex]
+                    tokens.append(RuleTagToken(chunk.tag, ruleImaginaryTokenType, chunk.label))
+                else:
+                    raise Exception("invalid tag: " + str(chunk.tag) + " in pattern: " + pattern)
+            else:
+                self.lexer.setInputStream(InputStream(chunk.text))
+                t = self.lexer.nextToken()
+                while t.type!=Token.EOF:
+                    tokens.append(t)
+                    t = self.lexer.nextToken()
+        return tokens
+
+    # Split {@code <ID> = <e:expr> ;} into 4 chunks for tokenizing by {@link #tokenize}.#
+    def split(self, pattern):
+        p = 0
+        n = len(pattern)
+        chunks = list()
+        # find all start and stop indexes first, then collect
+        starts = list()
+        stops = list()
+        while p < n :
+            if p == pattern.find(self.escape + self.start, p):
+                p += len(self.escape) + len(self.start)
+            elif p == pattern.find(self.escape + self.stop, p):
+                p += len(self.escape) + len(self.stop)
+            elif p == pattern.find(self.start, p):
+                starts.append(p)
+                p += len(self.start)
+            elif p == pattern.find(self.stop, p):
+                stops.append(p)
+                p += len(self.stop)
+            else:
+                p += 1
+
+        nt = len(starts)
+
+        if nt > len(stops):
+            raise Exception("unterminated tag in pattern: " + pattern)
+        if nt < len(stops):
+            raise Exception("missing start tag in pattern: " + pattern)
+
+        for i in range(0, nt):
+            if starts[i] >= stops[i]:
+                raise Exception("tag delimiters out of order in pattern: " + pattern)
+
+        # collect into chunks now
+        if nt==0:
+            chunks.append(TextChunk(pattern))
+
+        if nt>0 and starts[0]>0: # copy text up to first tag into chunks
+            text = pattern[0:starts[0]]
+            chunks.add(TextChunk(text))
+
+        for i in range(0, nt):
+            # copy inside of <tag>
+            tag = pattern[starts[i] + len(self.start) : stops[i]]
+            ruleOrToken = tag
+            label = None
+            colon = tag.find(':')
+            if colon >= 0:
+                label = tag[0:colon]
+                ruleOrToken = tag[colon+1 : len(tag)]
+            chunks.append(TagChunk(label, ruleOrToken))
+            if i+1 < len(starts):
+                # copy from end of <tag> to start of next
+                text = pattern[stops[i] + len(self.stop) : starts[i + 1]]
+                chunks.append(TextChunk(text))
+
+        if nt > 0 :
+            afterLastTag = stops[nt - 1] + len(self.stop)
+            if afterLastTag < n : # copy text from end of last tag to end
+                text = pattern[afterLastTag : n]
+                chunks.append(TextChunk(text))
+
+        # strip out the escape sequences from text chunks but not tags
+        for i in range(0, len(chunks)):
+            c = chunks[i]
+            if isinstance( c, TextChunk ):
+                unescaped = c.text.replace(self.escape, "")
+                if len(unescaped) < len(c.text):
+                    chunks[i] = TextChunk(unescaped)
+        return chunks
diff --git a/runtime/Python2/src/antlr4/tree/RuleTagToken.py b/runtime/Python2/src/antlr4/tree/RuleTagToken.py
new file mode 100644
index 000000000..021373f01
--- /dev/null
+++ b/runtime/Python2/src/antlr4/tree/RuleTagToken.py
@@ -0,0 +1,74 @@
+#
+# [The "BSD license"]
+# Copyright (c) 2013 Terence Parr
+# Copyright (c) 2013 Sam Harwell
+# Copyright (c) 2014 Eric Vergnaud
+# 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 {@link Token} object representing an entire subtree matched by a parser
+# rule; e.g., {@code <expr>}. These tokens are created for {@link TagChunk}
+# chunks where the tag corresponds to a parser rule.
+#
+from antlr4.Token import Token
+
+
+class RuleTagToken(Token):
+    #
+    # Constructs a new instance of {@link RuleTagToken} with the specified rule
+    # name, bypass token type, and label.
+    #
+    # @param ruleName The name of the parser rule this rule tag matches.
+    # @param bypassTokenType The bypass token type assigned to the parser rule.
+    # @param label The label associated with the rule tag, or {@code null} if
+    # the rule tag is unlabeled.
+    #
+    # @exception IllegalArgumentException if {@code ruleName} is {@code null}
+    # or empty.
+
+    def __init__(self, ruleName, bypassTokenType, label=None):
+        if ruleName is None or len(ruleName)==0:
+            raise Exception("ruleName cannot be null or empty.")
+        self.source = None
+        self.type = bypassTokenType # token type of the token
+        self.channel = Token.DEFAULT_CHANNEL # The parser ignores everything not on DEFAULT_CHANNEL
+        self.start = -1 # optional; return -1 if not implemented.
+        self.stop = -1  # optional; return -1 if not implemented.
+        self.tokenIndex = -1 # from 0..n-1 of the token object in the input stream
+        self.line = 0 # line=1..n of the 1st character
+        self.column = -1 # beginning of the line at which it occurs, 0..n-1
+        self.label = label
+        self._text = self.getText() # text of the token.
+
+        self.ruleName = ruleName
+
+
+    def getText(self):
+        if self.label is None:
+            return "<" + self.ruleName + ">"
+        else:
+            return "<" + self.label + ":" + self.ruleName + ">"
diff --git a/runtime/Python2/src/antlr4/tree/TokenTagToken.py b/runtime/Python2/src/antlr4/tree/TokenTagToken.py
new file mode 100644
index 000000000..0517cef1f
--- /dev/null
+++ b/runtime/Python2/src/antlr4/tree/TokenTagToken.py
@@ -0,0 +1,72 @@
+#
+# [The "BSD license"]
+# Copyright (c) 2013 Terence Parr
+# Copyright (c) 2013 Sam Harwell
+# Copyright (c) 2014 Eric Vergnaud
+# 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 {@link Token} object representing a token of a particular type; e.g.,
+# {@code <ID>}. These tokens are created for {@link TagChunk} chunks where the
+# tag corresponds to a lexer rule or token type.
+#
+from antlr4.Token import CommonToken
+
+
+class TokenTagToken(CommonToken):
+
+    # Constructs a new instance of {@link TokenTagToken} with the specified
+    # token name, type, and label.
+    #
+    # @param tokenName The token name.
+    # @param type The token type.
+    # @param label The label associated with the token tag, or {@code null} if
+    # the token tag is unlabeled.
+    #
+    def __init__(self, tokenName, type, label=None):
+        super(TokenTagToken, self).__init__(type=type)
+        self.tokenName = tokenName
+        self.label = label
+        self._text = self.getText()
+
+    #
+    # {@inheritDoc}
+    #
+    # <p>The implementation for {@link TokenTagToken} returns the token tag
+    # formatted with {@code <} and {@code >} delimiters.</p>
+    #
+    def getText(self):
+        if self.label is None:
+            return "<" + self.tokenName + ">"
+        else:
+            return "<" + self.label + ":" + self.tokenName + ">"
+
+    # <p>The implementation for {@link TokenTagToken} returns a string of the form
+    # {@code tokenName:type}.</p>
+    #
+    def __unicode__(self):
+        return self.tokenName + u":" + unicode(self.type)
diff --git a/runtime/Python2/src/antlr4/tree/Tree.py b/runtime/Python2/src/antlr4/tree/Tree.py
new file mode 100644
index 000000000..272acf14f
--- /dev/null
+++ b/runtime/Python2/src/antlr4/tree/Tree.py
@@ -0,0 +1,191 @@
+# [The "BSD license"]
+#  Copyright (c) 2012 Terence Parr
+#  Copyright (c) 2012 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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.
+#/
+
+
+# The basic notion of a tree has a parent, a payload, and a list of children.
+#  It is the most abstract interface for all the trees used by ANTLR.
+#/
+from antlr4.Token import Token
+
+INVALID_INTERVAL = (-1, -2)
+
+class Tree(object):
+
+    def __str__(self):
+        return unicode(self)
+
+class SyntaxTree(Tree):
+    pass
+
+class ParseTree(SyntaxTree):
+    pass
+
+class RuleNode(ParseTree):
+    pass
+
+class TerminalNode(ParseTree):
+    pass
+
+class ErrorNode(TerminalNode):
+    pass
+
+class ParseTreeVisitor(object):
+    def visit(self, tree):
+        return tree.accept(self)
+
+    def visitChildren(self, node):
+        result = self.defaultResult()
+        n = node.getChildCount()
+        for i in range(n):
+            if not self.shouldVisitNextChild(node, result):
+                return
+
+            c = node.getChild(i)
+            childResult = c.accept(self)
+            result = self.aggregateResult(result, childResult)
+
+        return result
+
+    def visitTerminal(self, node):
+        return self.defaultResult()
+
+    def visitErrorNode(self, node):
+        return self.defaultResult()
+
+    def defaultResult(self):
+        return None
+
+    def aggregateResult(self, aggregate, nextResult):
+        return nextResult
+
+    def shouldVisitNextChild(self, node, currentResult):
+        return True
+
+class ParseTreeListener(object):
+
+    def visitTerminal(self, node):
+        pass
+
+    def visitErrorNode(self, node):
+        pass
+
+    def enterEveryRule(self, ctx):
+        pass
+
+    def exitEveryRule(self, ctx):
+        pass
+
+class TerminalNodeImpl(TerminalNode):
+
+    def __init__(self, symbol):
+        self.parentCtx = None
+        self.symbol = symbol
+
+    def getChild(self, i):
+        return None
+
+    def getSymbol(self):
+        return self.symbol
+
+    def getParent(self):
+        return self.parentCtx
+
+    def getPayload(self):
+        return self.symbol
+
+    def getSourceInterval(self):
+        if self.symbol is None:
+            return INVALID_INTERVAL
+        tokenIndex = self.symbol.tokenIndex
+        return (tokenIndex, tokenIndex)
+
+    def getChildCount(self):
+        return 0
+
+    def accept(self, visitor):
+        return visitor.visitTerminal(self)
+
+    def getText(self):
+        return self.symbol.text
+
+    def __unicode__(self):
+        if self.symbol.type == Token.EOF:
+            return "<EOF>"
+        else:
+            return self.symbol.text
+
+# Represents a token that was consumed during resynchronization
+#  rather than during a valid match operation. For example,
+#  we will create this kind of a node during single token insertion
+#  and deletion as well as during "consume until error recovery set"
+#  upon no viable alternative exceptions.
+
+class ErrorNodeImpl(TerminalNodeImpl,ErrorNode):
+
+    def __init__(self, token):
+        super(ErrorNodeImpl, self).__init__(token)
+
+    def accept(self, visitor):
+        return visitor.visitErrorNode(self)
+
+
+class ParseTreeWalker(object):
+
+    DEFAULT = None
+
+    def walk(self, listener, t):
+        if isinstance(t, ErrorNode):
+            listener.visitErrorNode(t)
+            return
+        elif isinstance(t, TerminalNode):
+            listener.visitTerminal(t)
+            return
+        self.enterRule(listener, t)
+        for child in t.getChildren():
+            self.walk(listener, child)
+        self.exitRule(listener, t)
+
+    #
+    # The discovery of a rule node, involves sending two events: the generic
+    # {@link ParseTreeListener#enterEveryRule} and a
+    # {@link RuleContext}-specific event. First we trigger the generic and then
+    # the rule specific. We to them in reverse order upon finishing the node.
+    #
+    def enterRule(self, listener, r):
+        ctx = r.getRuleContext()
+        listener.enterEveryRule(ctx)
+        ctx.enterRule(listener)
+
+    def exitRule(self, listener, r):
+        ctx = r.getRuleContext()
+        ctx.exitRule(listener)
+        listener.exitEveryRule(ctx)
+
+ParseTreeWalker.DEFAULT = ParseTreeWalker()
\ No newline at end of file
diff --git a/runtime/Python2/src/antlr4/tree/Trees.py b/runtime/Python2/src/antlr4/tree/Trees.py
new file mode 100644
index 000000000..d48f4a904
--- /dev/null
+++ b/runtime/Python2/src/antlr4/tree/Trees.py
@@ -0,0 +1,136 @@
+#
+# [The "BSD license"]
+#  Copyright (c) 2012 Terence Parr
+#  Copyright (c) 2012 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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 set of utility routines useful for all kinds of ANTLR trees.#
+from io import StringIO
+import antlr4
+from antlr4.atn.ATN import ATN
+from antlr4.Token import Token
+from antlr4.Utils import escapeWhitespace
+from antlr4.tree.Tree import RuleNode, ErrorNode, TerminalNode
+
+class Trees(object):
+
+    # Print out a whole tree in LISP form. {@link #getNodeText} is used on the
+    #  node payloads to get the text for the nodes.  Detect
+    #  parse trees and extract data appropriately.
+    @classmethod
+    def toStringTree(cls, t, ruleNames=None, recog=None):
+        if recog is not None:
+            ruleNames = recog.ruleNames
+        s = escapeWhitespace(cls.getNodeText(t, ruleNames), False)
+        if t.getChildCount()==0:
+            return s
+        with StringIO() as buf:
+            buf.write(u"(")
+            buf.write(s)
+            buf.write(u' ')
+            for i in range(0, t.getChildCount()):
+                if i > 0:
+                    buf.write(u' ')
+                buf.write(cls.toStringTree(t.getChild(i), ruleNames))
+            buf.write(u")")
+            return buf.getvalue()
+
+    @classmethod
+    def getNodeText(cls, t, ruleNames=None, recog=None):
+        if recog is not None:
+            ruleNames = recog.ruleNames
+        if ruleNames is not None:
+            if isinstance(t, RuleNode):
+                if t.getAltNumber()!=ATN.INVALID_ALT_NUMBER:
+                    return ruleNames[t.getRuleIndex()]+":"+str(t.getAltNumber())
+                return ruleNames[t.getRuleIndex()]
+            elif isinstance( t, ErrorNode):
+                return unicode(t)
+            elif isinstance(t, TerminalNode):
+                if t.symbol is not None:
+                    return t.symbol.text
+        # no recog for rule names
+        payload = t.getPayload()
+        if isinstance(payload, Token ):
+            return payload.text
+        return unicode(t.getPayload())
+
+
+    # Return ordered list of all children of this node
+    @classmethod
+    def getChildren(cls, t):
+        return [ t.getChild(i) for i in range(0, t.getChildCount()) ]
+
+    # Return a list of all ancestors of this node.  The first node of
+    #  list is the root and the last is the parent of this node.
+    #
+    @classmethod
+    def getAncestors(cls, t):
+        ancestors = []
+        t = t.getParent()
+        while t is not None:
+            ancestors.append(0, t) # insert at start
+            t = t.getParent()
+        return ancestors
+
+    @classmethod
+    def findAllTokenNodes(cls, t, ttype):
+        return cls.findAllNodes(t, ttype, True)
+
+    @classmethod
+    def findAllRuleNodes(cls, t, ruleIndex):
+        return cls.findAllNodes(t, ruleIndex, False)
+
+    @classmethod
+    def findAllNodes(cls, t, index, findTokens):
+        nodes = []
+        cls._findAllNodes(t, index, findTokens, nodes)
+        return nodes
+
+    @classmethod
+    def _findAllNodes(cls, t, index, findTokens, nodes):
+        from antlr4.ParserRuleContext import ParserRuleContext
+        # check this node (the root) first
+        if findTokens and isinstance(t, TerminalNode):
+            if t.symbol.type==index:
+                nodes.append(t)
+        elif not findTokens and isinstance(t, ParserRuleContext):
+            if t.ruleIndex == index:
+                nodes.append(t)
+        # check children
+        for i in range(0, t.getChildCount()):
+            cls._findAllNodes(t.getChild(i), index, findTokens, nodes)
+
+    @classmethod
+    def descendants(cls, t):
+        nodes = []
+        nodes.append(t)
+        for i in range(0, t.getChildCount()):
+            nodes.extend(cls.descendants(t.getChild(i)))
+        return nodes
diff --git a/runtime/Python2/src/antlr4/tree/__init__.py b/runtime/Python2/src/antlr4/tree/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/runtime/Python2/src/antlr4/xpath/XPath.py b/runtime/Python2/src/antlr4/xpath/XPath.py
new file mode 100644
index 000000000..eee87da6f
--- /dev/null
+++ b/runtime/Python2/src/antlr4/xpath/XPath.py
@@ -0,0 +1,346 @@
+
+#
+# Represent a subset of XPath XML path syntax for use in identifying nodes in
+# parse trees.
+#
+# <p>
+# Split path into words and separators {@code /} and {@code //} via ANTLR
+# itself then walk path elements from left to right. At each separator-word
+# pair, find set of nodes. Next stage uses those as work list.</p>
+#
+# <p>
+# The basic interface is
+# {@link XPath#findAll ParseTree.findAll}{@code (tree, pathString, parser)}.
+# But that is just shorthand for:</p>
+#
+# <pre>
+# {@link XPath} p = new {@link XPath#XPath XPath}(parser, pathString);
+# return p.{@link #evaluate evaluate}(tree);
+# </pre>
+#
+# <p>
+# See {@code org.antlr.v4.test.TestXPath} for descriptions. In short, this
+# allows operators:</p>
+#
+# <dl>
+# <dt>/</dt> <dd>root</dd>
+# <dt>//</dt> <dd>anywhere</dd>
+# <dt>!</dt> <dd>invert; this must appear directly after root or anywhere
+# operator</dd>
+# </dl>
+#
+# <p>
+# and path elements:</p>
+#
+# <dl>
+# <dt>ID</dt> <dd>token name</dd>
+# <dt>'string'</dt> <dd>any string literal token from the grammar</dd>
+# <dt>expr</dt> <dd>rule name</dd>
+# <dt>*</dt> <dd>wildcard matching any node</dd>
+# </dl>
+#
+# <p>
+# Whitespace is not allowed.</p>
+#
+from antlr4 import CommonTokenStream, DFA, PredictionContextCache, Lexer, LexerATNSimulator, ParserRuleContext, TerminalNode
+from antlr4.atn.ATNDeserializer import ATNDeserializer
+from antlr4.InputStream import InputStream
+from antlr4.Token import Token
+from antlr4.error.ErrorListener import ErrorListener
+from antlr4.error.Errors import LexerNoViableAltException
+from antlr4.tree.Trees import Trees
+
+from io import StringIO
+
+
+def serializedATN():
+    with StringIO() as buf:
+        buf.write(u"\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\2")
+        buf.write(u"\n\64\b\1\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7")
+        buf.write(u"\t\7\4\b\t\b\4\t\t\t\3\2\3\2\3\2\3\3\3\3\3\4\3\4\3\5")
+        buf.write(u"\3\5\3\6\3\6\7\6\37\n\6\f\6\16\6\"\13\6\3\6\3\6\3\7\3")
+        buf.write(u"\7\5\7(\n\7\3\b\3\b\3\t\3\t\7\t.\n\t\f\t\16\t\61\13\t")
+        buf.write(u"\3\t\3\t\3/\2\n\3\5\5\6\7\7\t\b\13\t\r\2\17\2\21\n\3")
+        buf.write(u"\2\4\7\2\62;aa\u00b9\u00b9\u0302\u0371\u2041\u2042\17")
+        buf.write(u"\2C\\c|\u00c2\u00d8\u00da\u00f8\u00fa\u0301\u0372\u037f")
+        buf.write(u"\u0381\u2001\u200e\u200f\u2072\u2191\u2c02\u2ff1\u3003")
+        buf.write(u"\ud801\uf902\ufdd1\ufdf2\uffff\64\2\3\3\2\2\2\2\5\3\2")
+        buf.write(u"\2\2\2\7\3\2\2\2\2\t\3\2\2\2\2\13\3\2\2\2\2\21\3\2\2")
+        buf.write(u"\2\3\23\3\2\2\2\5\26\3\2\2\2\7\30\3\2\2\2\t\32\3\2\2")
+        buf.write(u"\2\13\34\3\2\2\2\r\'\3\2\2\2\17)\3\2\2\2\21+\3\2\2\2")
+        buf.write(u"\23\24\7\61\2\2\24\25\7\61\2\2\25\4\3\2\2\2\26\27\7\61")
+        buf.write(u"\2\2\27\6\3\2\2\2\30\31\7,\2\2\31\b\3\2\2\2\32\33\7#")
+        buf.write(u"\2\2\33\n\3\2\2\2\34 \5\17\b\2\35\37\5\r\7\2\36\35\3")
+        buf.write(u"\2\2\2\37\"\3\2\2\2 \36\3\2\2\2 !\3\2\2\2!#\3\2\2\2\"")
+        buf.write(u" \3\2\2\2#$\b\6\2\2$\f\3\2\2\2%(\5\17\b\2&(\t\2\2\2\'")
+        buf.write(u"%\3\2\2\2\'&\3\2\2\2(\16\3\2\2\2)*\t\3\2\2*\20\3\2\2")
+        buf.write(u"\2+/\7)\2\2,.\13\2\2\2-,\3\2\2\2.\61\3\2\2\2/\60\3\2")
+        buf.write(u"\2\2/-\3\2\2\2\60\62\3\2\2\2\61/\3\2\2\2\62\63\7)\2\2")
+        buf.write(u"\63\22\3\2\2\2\6\2 \'/\3\3\6\2")
+        return buf.getvalue()
+
+
+class XPathLexer(Lexer):
+
+    atn = ATNDeserializer().deserialize(serializedATN())
+
+    decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
+
+
+    TOKEN_REF = 1
+    RULE_REF = 2
+    ANYWHERE = 3
+    ROOT = 4
+    WILDCARD = 5
+    BANG = 6
+    ID = 7
+    STRING = 8
+
+    modeNames = [ u"DEFAULT_MODE" ]
+
+    literalNames = [ u"<INVALID>",
+            u"'//'", u"'/'", u"'*'", u"'!'" ]
+
+    symbolicNames = [ u"<INVALID>",
+            u"TOKEN_REF", u"RULE_REF", u"ANYWHERE", u"ROOT", u"WILDCARD",
+            u"BANG", u"ID", u"STRING" ]
+
+    ruleNames = [ u"ANYWHERE", u"ROOT", u"WILDCARD", u"BANG", u"ID", u"NameChar",
+                  u"NameStartChar", u"STRING" ]
+
+    grammarFileName = u"XPathLexer.g4"
+
+    def __init__(self, input=None):
+        super(XPathLexer, self).__init__(input)
+        self.checkVersion("4.5")
+        self._interp = LexerATNSimulator(self, self.atn, self.decisionsToDFA, PredictionContextCache())
+        self._actions = None
+        self._predicates = None
+
+
+    def action(self, localctx, ruleIndex, actionIndex):
+        if self._actions is None:
+            actions = dict()
+            actions[4] = self.ID_action
+            self._actions = actions
+        action = self._actions.get(ruleIndex, None)
+        if action is not None:
+            action(localctx, actionIndex)
+        else:
+            raise Exception("No registered action for:" + str(ruleIndex))
+
+    def ID_action(self, localctx , actionIndex):
+        if actionIndex == 0:
+            char = self.text[0]
+            if char.isupper():
+                self.type = XPathLexer.TOKEN_REF
+            else:
+                self.type = XPathLexer.RULE_REF
+
+class XPath(object):
+
+    WILDCARD = "*" # word not operator/separator
+    NOT = "!" # word for invert operator
+
+    def __init__(self, parser, path):
+        self.parser = parser
+        self.path = path
+        self.elements = self.split(path)
+
+    def split(self, path):
+        input = InputStream(path)
+        lexer = XPathLexer(input)
+        def recover(self, e):
+            raise e
+        lexer.recover = recover
+        lexer.removeErrorListeners()
+        lexer.addErrorListener(ErrorListener()) # XPathErrorListener does no more
+        tokenStream = CommonTokenStream(lexer)
+        try:
+            tokenStream.fill()
+        except LexerNoViableAltException as e:
+            pos = lexer.getColumn()
+            msg = "Invalid tokens or characters at index " + str(pos) + " in path '" + path + "'"
+            raise Exception(msg, e)
+
+        tokens = tokenStream.getTokens()
+        elements = list()
+        n = len(tokens)
+        i=0
+        while i < n :
+            el = tokens[i]
+            next = None
+            if el.type in [XPathLexer.ROOT, XPathLexer.ANYWHERE]:
+                    anywhere = el.type == XPathLexer.ANYWHERE
+                    i += 1
+                    next = tokens[i]
+                    invert = next.type==XPathLexer.BANG
+                    if invert:
+                        i += 1
+                        next = tokens[i]
+                    pathElement = self.getXPathElement(next, anywhere)
+                    pathElement.invert = invert
+                    elements.append(pathElement)
+                    i += 1
+
+            elif el.type in [XPathLexer.TOKEN_REF, XPathLexer.RULE_REF, XPathLexer.WILDCARD] :
+                    elements.append( self.getXPathElement(el, False) )
+                    i += 1
+
+            elif el.type==Token.EOF :
+                    break
+
+            else:
+                    raise Exception("Unknown path element " + str(el))
+
+        return elements
+
+    #
+    # Convert word like {@code#} or {@code ID} or {@code expr} to a path
+    # element. {@code anywhere} is {@code true} if {@code //} precedes the
+    # word.
+    #
+    def getXPathElement(self, wordToken, anywhere):
+        if wordToken.type==Token.EOF:
+            raise Exception("Missing path element at end of path")
+        word = wordToken.text
+        ttype = self.parser.getTokenType(word)
+        ruleIndex = self.parser.getRuleIndex(word)
+
+        if wordToken.type==XPathLexer.WILDCARD :
+
+            return XPathWildcardAnywhereElement() if anywhere else XPathWildcardElement()
+
+        elif wordToken.type in [XPathLexer.TOKEN_REF, XPathLexer.STRING]:
+
+            if ttype==Token.INVALID_TYPE:
+                raise Exception( word + " at index " + str(wordToken.startIndex) + " isn't a valid token name")
+            return XPathTokenAnywhereElement(word, ttype) if anywhere else XPathTokenElement(word, ttype)
+
+        else:
+
+            if ruleIndex==-1:
+                raise Exception( word + " at index " + str(wordToken.getStartIndex()) + " isn't a valid rule name")
+            return XPathRuleAnywhereElement(word, ruleIndex) if anywhere else XPathRuleElement(word, ruleIndex)
+
+
+    def findAll(self, tree, xpath, parser):
+        p = XPath(parser, xpath)
+        return p.evaluate(tree)
+
+    #
+    # Return a list of all nodes starting at {@code t} as root that satisfy the
+    # path. The root {@code /} is relative to the node passed to
+    # {@link #evaluate}.
+    #
+    def evaluate(self, t):
+        dummyRoot = ParserRuleContext()
+        dummyRoot.children = [t] # don't set t's parent.
+
+        work = [dummyRoot]
+
+        for i in range(0, len(self.elements)):
+            next = set()
+            for node in work:
+                if len( node.children) > 0 :
+                    # only try to match next element if it has children
+                    # e.g., //func/*/stat might have a token node for which
+                    # we can't go looking for stat nodes.
+                    matching = self.elements[i].evaluate(node)
+                    next |= matching
+            i += 1
+            work = next
+
+        return work
+
+
+class XPathElement(object):
+
+    def __init__(self, nodeName):
+        self.nodeName = nodeName
+        self.invert = False
+
+    def __str__(self):
+        return unicode(self)
+
+    def __unicode__(self):
+        return type(self).__name__ + "[" + ("!" if self.invert else "") + self.nodeName + "]"
+
+
+
+#
+# Either {@code ID} at start of path or {@code ...//ID} in middle of path.
+#
+class XPathRuleAnywhereElement(XPathElement):
+
+    def __init__(self, ruleName, ruleIndex):
+        super(XPathRuleAnywhereElement, self).__init__(ruleName)
+        self.ruleIndex = ruleIndex
+
+    def evaluate(self, t):
+        return Trees.findAllRuleNodes(t, self.ruleIndex)
+
+
+class XPathRuleElement(XPathElement):
+
+    def __init__(self, ruleName, ruleIndex):
+        super(XPathRuleElement, self).__init__(ruleName)
+        self.ruleIndex = ruleIndex
+
+    def evaluate(self, t):
+        # return all children of t that match nodeName
+        nodes = []
+        for c in Trees.getChildren(t):
+            if isinstance(c, ParserRuleContext ):
+                if (c.ruleIndex == self.ruleIndex ) == (not self.invert):
+                    nodes.append(c)
+        return nodes
+
+class XPathTokenAnywhereElement(XPathElement):
+
+    def __init__(self, ruleName, tokenType):
+        super(XPathTokenAnywhereElement, self).__init__(ruleName)
+        self.tokenType = tokenType
+
+    def evaluate(self, t):
+        return Trees.findAllTokenNodes(t, self.tokenType)
+
+
+class XPathTokenElement(XPathElement):
+
+    def __init__(self, ruleName, tokenType):
+        super(XPathTokenElement, self).__init__(ruleName)
+        self.tokenType = tokenType
+
+    def evaluate(self, t):
+        # return all children of t that match nodeName
+        nodes = []
+        for c in Trees.getChildren(t):
+            if isinstance(c, TerminalNode):
+                if (c.symbol.type == self.tokenType ) == (not self.invert):
+                    nodes.append(c)
+        return nodes
+
+class XPathWildcardAnywhereElement(XPathElement):
+
+    def __init__(self):
+        super(XPathWildcardAnywhereElement, self).__init__(XPath.WILDCARD)
+
+    def evaluate(self, t):
+        if self.invert:
+            return list() # !* is weird but valid (empty)
+        else:
+            return Trees.descendants(t)
+
+
+class XPathWildcardElement(XPathElement):
+
+    def __init__(self):
+        super(XPathWildcardElement, self).__init__(XPath.WILDCARD)
+
+
+    def evaluate(self, t):
+        if self.invert:
+            return list() # !* is weird but valid (empty)
+        else:
+            return Trees.getChildren(t)
\ No newline at end of file
diff --git a/runtime/Python2/src/antlr4/xpath/__init__.py b/runtime/Python2/src/antlr4/xpath/__init__.py
new file mode 100644
index 000000000..216c000dc
--- /dev/null
+++ b/runtime/Python2/src/antlr4/xpath/__init__.py
@@ -0,0 +1 @@
+__author__ = 'ericvergnaud'
diff --git a/runtime/Python3/LICENSE.txt b/runtime/Python3/LICENSE.txt
new file mode 100644
index 000000000..dff211c19
--- /dev/null
+++ b/runtime/Python3/LICENSE.txt
@@ -0,0 +1,26 @@
+[The "BSD license"]
+Copyright (c) 2015 Terence Parr, Sam Harwell, Eric Vergnaud
+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.
diff --git a/runtime/Python3/MANIFEST b/runtime/Python3/MANIFEST
new file mode 100644
index 000000000..0a44f1d09
--- /dev/null
+++ b/runtime/Python3/MANIFEST
@@ -0,0 +1,59 @@
+# file GENERATED by distutils, do NOT edit
+LICENSE.txt
+README.txt
+RELEASE-4.5.txt
+setup.py
+src/antlr4/BufferedTokenStream.py
+src/antlr4/CommonTokenFactory.py
+src/antlr4/CommonTokenStream.py
+src/antlr4/FileStream.py
+src/antlr4/InputStream.py
+src/antlr4/IntervalSet.py
+src/antlr4/LL1Analyzer.py
+src/antlr4/Lexer.py
+src/antlr4/ListTokenSource.py
+src/antlr4/Parser.py
+src/antlr4/ParserInterpreter.py
+src/antlr4/ParserRuleContext.py
+src/antlr4/PredictionContext.py
+src/antlr4/Recognizer.py
+src/antlr4/RuleContext.py
+src/antlr4/Token.py
+src/antlr4/Utils.py
+src/antlr4/__init__.py
+src/antlr4/atn/ATN.py
+src/antlr4/atn/ATNConfig.py
+src/antlr4/atn/ATNConfigSet.py
+src/antlr4/atn/ATNDeserializationOptions.py
+src/antlr4/atn/ATNDeserializer.py
+src/antlr4/atn/ATNSimulator.py
+src/antlr4/atn/ATNState.py
+src/antlr4/atn/ATNType.py
+src/antlr4/atn/LexerATNSimulator.py
+src/antlr4/atn/LexerAction.py
+src/antlr4/atn/LexerActionExecutor.py
+src/antlr4/atn/ParserATNSimulator.py
+src/antlr4/atn/PredictionMode.py
+src/antlr4/atn/SemanticContext.py
+src/antlr4/atn/Transition.py
+src/antlr4/atn/__init__.py
+src/antlr4/dfa/DFA.py
+src/antlr4/dfa/DFASerializer.py
+src/antlr4/dfa/DFAState.py
+src/antlr4/dfa/__init__.py
+src/antlr4/error/DiagnosticErrorListener.py
+src/antlr4/error/ErrorListener.py
+src/antlr4/error/ErrorStrategy.py
+src/antlr4/error/Errors.py
+src/antlr4/error/__init__.py
+src/antlr4/tree/Chunk.py
+src/antlr4/tree/ParseTreeMatch.py
+src/antlr4/tree/ParseTreePattern.py
+src/antlr4/tree/ParseTreePatternMatcher.py
+src/antlr4/tree/RuleTagToken.py
+src/antlr4/tree/TokenTagToken.py
+src/antlr4/tree/Tree.py
+src/antlr4/tree/Trees.py
+src/antlr4/tree/__init__.py
+src/antlr4/xpath/XPath.py
+src/antlr4/xpath/__init__.py
diff --git a/runtime/Python3/MANIFEST.in b/runtime/Python3/MANIFEST.in
new file mode 100644
index 000000000..86604e496
--- /dev/null
+++ b/runtime/Python3/MANIFEST.in
@@ -0,0 +1 @@
+include *.txt
\ No newline at end of file
diff --git a/runtime/Python3/README.txt b/runtime/Python3/README.txt
new file mode 100644
index 000000000..25600107d
--- /dev/null
+++ b/runtime/Python3/README.txt
@@ -0,0 +1,4 @@
+This is the Python 3.4 runtime for ANTLR.
+Visit the ANTLR web sites for more information:
+http://www.antlr.org
+https://raw.githubusercontent.com/antlr/antlr4/master/doc/python-target.md
diff --git a/runtime/Python3/RELEASE-4.5.txt b/runtime/Python3/RELEASE-4.5.txt
new file mode 100644
index 000000000..5d28a98e0
--- /dev/null
+++ b/runtime/Python3/RELEASE-4.5.txt
@@ -0,0 +1,12 @@
+What's in this release?
+
+ - fixed bug where non-ascii input streams would fail
+ - added support for visitor pattern
+ - added support for wildcards in grammar
+
+ Breaking change:
+
+ In version 4.4, the parser/lexer had a tokenNames member.
+ This has been removed in favor of the following members:
+  - lexicalNames, containing the parsed text
+  - symbolicNames, corresponding to tokenNames
diff --git a/runtime/Python3/bin/pygrun b/runtime/Python3/bin/pygrun
new file mode 100755
index 000000000..96f1b40c2
--- /dev/null
+++ b/runtime/Python3/bin/pygrun
@@ -0,0 +1,164 @@
+#!python
+__author__ = 'jszheng'
+import optparse
+import sys
+import os
+import importlib
+from antlr4 import *
+
+
+# this is a python version of TestRig
+def beautify_lisp_string(in_string):
+    indent_size = 3
+    add_indent = ' '*indent_size
+    out_string = in_string[0]  # no indent for 1st (
+    indent = ''
+    for i in range(1, len(in_string)):
+        if in_string[i] == '(' and in_string[i+1] != ' ':
+            indent += add_indent
+            out_string += "\n" + indent + '('
+        elif in_string[i] == ')':
+            out_string += ')'
+            if len(indent) > 0:
+                indent = indent.replace(add_indent, '', 1)
+        else:
+            out_string += in_string[i]
+    return out_string
+
+
+if __name__ == '__main__':
+
+    #############################################################
+    # parse options
+    # not support -gui -encoding -ps
+    #############################################################
+    usage = "Usage: %prog [options] Grammar_Name Start_Rule"
+    parser = optparse.OptionParser(usage=usage)
+    # parser.add_option('-t', '--tree',
+    #                   dest="out_file",
+    #                   default="default.out",
+    #                   help='set output file name',
+    #                   )
+    parser.add_option('-t', '--tree',
+                      default=False,
+                      action='store_true',
+                      help='Print AST tree'
+                      )
+    parser.add_option('-k', '--tokens',
+                      dest="token",
+                      default=False,
+                      action='store_true',
+                      help='Show Tokens'
+                      )
+    parser.add_option('-s', '--sll',
+                      dest="sll",
+                      default=False,
+                      action='store_true',
+                      help='Show SLL'
+                      )
+    parser.add_option('-d', '--diagnostics',
+                      dest="diagnostics",
+                      default=False,
+                      action='store_true',
+                      help='Enable diagnostics error listener'
+                      )
+    parser.add_option('-a', '--trace',
+                      dest="trace",
+                      default=False,
+                      action='store_true',
+                      help='Enable Trace'
+                      )
+
+    options, remainder = parser.parse_args()
+    if len(remainder) < 2:
+        print('ERROR: You have to provide at least 2 arguments!')
+        parser.print_help()
+        exit(1)
+    else:
+        grammar = remainder.pop(0)
+        start_rule = remainder.pop(0)
+        file_list = remainder
+
+    #############################################################
+    # check and load antlr generated files
+    #############################################################
+    # dynamic load the module and class
+    lexerName = grammar + 'Lexer'
+    parserName = grammar + 'Parser'
+    # check if the generate file exist
+    lexer_file = lexerName + '.py'
+    parser_file = parserName + '.py'
+    if not os.path.exists(lexer_file):
+        print("[ERROR] Can't find lexer file {}!".format(lexer_file))
+        print(os.path.realpath('.'))
+        exit(1)
+    if not os.path.exists(parser_file):
+        print("[ERROR] Can't find parser file {}!".format(lexer_file))
+        print(os.path.realpath('.'))
+        exit(1)
+
+    # current directory is where the generated file loaded
+    # the script might be in different place.
+    sys.path.append('.')
+    # print(sys.path)
+
+    # print("Load Lexer {}".format(lexerName))
+    module_lexer = __import__(lexerName, globals(), locals(), lexerName)
+    class_lexer = getattr(module_lexer, lexerName)
+    # print(class_lexer)
+
+    # print("Load Parser {}".format(parserName))
+    module_parser = __import__(parserName, globals(), locals(), parserName)
+    class_parser = getattr(module_parser, parserName)
+    # print(class_parser)
+
+    #############################################################
+    # main process steps.
+    #############################################################
+    def process(input_stream, class_lexer, class_parser):
+        lexer = class_lexer(input_stream)
+        token_stream = CommonTokenStream(lexer)
+        token_stream.fill()
+        if options.token:  # need to show token
+            for tok in token_stream.tokens:
+                print(tok)
+        if start_rule == 'tokens':
+            return
+
+        parser = class_parser(token_stream)
+
+        if options.diagnostics:
+            parser.addErrorListener(DiagnosticErrorListener())
+            parser._interp.predictionMode = PredictionMode.LL_EXACT_AMBIG_DETECTION
+        if options.tree:
+            parser.buildParseTrees = True
+        if options.sll:
+            parser._interp.predictionMode = PredictionMode.SLL
+        #parser.setTokenStream(token_stream)
+        parser.setTrace(options.trace)
+        if hasattr(parser, start_rule):
+            func_start_rule = getattr(parser, start_rule)
+            parser_ret = func_start_rule()
+            if options.tree:
+                lisp_tree_str = parser_ret.toStringTree(recog=parser)
+                print(beautify_lisp_string(lisp_tree_str))
+        else:
+            print("[ERROR] Can't find start rule '{}' in parser '{}'".format(start_rule, parserName))
+
+    #############################################################
+    # use stdin if not provide file as input stream
+    #############################################################
+    if len(file_list) == 0:
+        input_stream = InputStream(sys.stdin.read())
+        process(input_stream, class_lexer, class_parser)
+        exit(0)
+
+    #############################################################
+    # iterate all input file
+    #############################################################
+    for file_name in file_list:
+        if os.path.exists(file_name) and os.path.isfile(file_name):
+            input_stream = FileStream(file_name)
+            process(input_stream, class_lexer, class_parser)
+        else:
+            print("[ERROR] file {} not exist".format(os.path.normpath(file_name)))
diff --git a/runtime/Python3/bin/pygrun.bat b/runtime/Python3/bin/pygrun.bat
new file mode 100755
index 000000000..d30af61e8
--- /dev/null
+++ b/runtime/Python3/bin/pygrun.bat
@@ -0,0 +1,6 @@
+@ECHO OFF
+IF NOT "%~f0" == "~f0" GOTO :WinNT
+@"python.exe" <Script>  %1 %2 %3 %4 %5 %6 %7 %8 %9
+GOTO :EOF
+:WinNT
+@"python.exe" "%~dpn0" %*
diff --git a/runtime/Python3/setup.py b/runtime/Python3/setup.py
new file mode 100644
index 000000000..2de08f223
--- /dev/null
+++ b/runtime/Python3/setup.py
@@ -0,0 +1,13 @@
+from distutils.core import setup
+
+setup(
+    name='antlr4-python3-runtime',
+    version='4.5.3',
+    packages=['antlr4', 'antlr4.atn', 'antlr4.dfa', 'antlr4.tree', 'antlr4.error', 'antlr4.xpath'],
+    package_dir={'': 'src'},
+    url='http://www.antlr.org',
+    license='BSD',
+    author='Eric Vergnaud, Terence Parr, Sam Harwell',
+    author_email='eric.vergnaud@wanadoo.fr',
+    description='ANTLR 4.5.3 runtime for Python 3.4.0'
+)
diff --git a/runtime/Python3/src/antlr4/BufferedTokenStream.py b/runtime/Python3/src/antlr4/BufferedTokenStream.py
new file mode 100644
index 000000000..919a27335
--- /dev/null
+++ b/runtime/Python3/src/antlr4/BufferedTokenStream.py
@@ -0,0 +1,328 @@
+#
+# [The "BSD license"]
+#  Copyright (c) 2012 Terence Parr
+#  Copyright (c) 2012 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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.
+
+# This implementation of {@link TokenStream} loads tokens from a
+# {@link TokenSource} on-demand, and places the tokens in a buffer to provide
+# access to any previous token by index.
+#
+# <p>
+# This token stream ignores the value of {@link Token#getChannel}. If your
+# parser requires the token stream filter tokens to only those on a particular
+# channel, such as {@link Token#DEFAULT_CHANNEL} or
+# {@link Token#HIDDEN_CHANNEL}, use a filtering token stream such a
+# {@link CommonTokenStream}.</p>
+from io import StringIO
+from antlr4.Token import Token
+from antlr4.error.Errors import IllegalStateException
+
+# need forward declaration
+Lexer = None
+
+# this is just to keep meaningful parameter types to Parser
+class TokenStream(object):
+
+    pass
+
+
+class BufferedTokenStream(TokenStream):
+
+    def __init__(self, tokenSource:Lexer):
+        # The {@link TokenSource} from which tokens for this stream are fetched.
+        self.tokenSource = tokenSource
+
+        # A collection of all tokens fetched from the token source. The list is
+        # considered a complete view of the input once {@link #fetchedEOF} is set
+        # to {@code true}.
+        self.tokens = []
+
+        # The index into {@link #tokens} of the current token (next token to
+        # {@link #consume}). {@link #tokens}{@code [}{@link #p}{@code ]} should be
+        # {@link #LT LT(1)}.
+        #
+        # <p>This field is set to -1 when the stream is first constructed or when
+        # {@link #setTokenSource} is called, indicating that the first token has
+        # not yet been fetched from the token source. For additional information,
+        # see the documentation of {@link IntStream} for a description of
+        # Initializing Methods.</p>
+        self.index = -1
+
+        # Indicates whether the {@link Token#EOF} token has been fetched from
+        # {@link #tokenSource} and added to {@link #tokens}. This field improves
+        # performance for the following cases:
+        #
+        # <ul>
+        # <li>{@link #consume}: The lookahead check in {@link #consume} to prevent
+        # consuming the EOF symbol is optimized by checking the values of
+        # {@link #fetchedEOF} and {@link #p} instead of calling {@link #LA}.</li>
+        # <li>{@link #fetch}: The check to prevent adding multiple EOF symbols into
+        # {@link #tokens} is trivial with this field.</li>
+        # <ul>
+        self.fetchedEOF = False
+        
+    def mark(self):
+        return 0
+    
+    def release(self, marker:int):
+        # no resources to release
+        pass
+    
+    def reset(self):
+        self.seek(0)
+
+    def seek(self, index:int):
+        self.lazyInit()
+        self.index = self.adjustSeekIndex(index)
+
+    def get(self, index:int):
+        self.lazyInit()
+        return self.tokens[index]
+
+    def consume(self):
+        skipEofCheck = False
+        if self.index >= 0:
+            if self.fetchedEOF:
+                # the last token in tokens is EOF. skip check if p indexes any
+                # fetched token except the last.
+                skipEofCheck = self.index < len(self.tokens) - 1
+            else:
+               # no EOF token in tokens. skip check if p indexes a fetched token.
+                skipEofCheck = self.index < len(self.tokens)
+        else:
+            # not yet initialized
+            skipEofCheck = False
+
+        if not skipEofCheck and self.LA(1) == Token.EOF:
+            raise IllegalStateException("cannot consume EOF")
+
+        if self.sync(self.index + 1):
+            self.index = self.adjustSeekIndex(self.index + 1)
+
+    # Make sure index {@code i} in tokens has a token.
+    #
+    # @return {@code true} if a token is located at index {@code i}, otherwise
+    #    {@code false}.
+    # @see #get(int i)
+    #/
+    def sync(self, i:int):
+        n = i - len(self.tokens) + 1 # how many more elements we need?
+        if n > 0 :
+            fetched = self.fetch(n)
+            return fetched >= n
+        return True
+
+    # Add {@code n} elements to buffer.
+    #
+    # @return The actual number of elements added to the buffer.
+    #/
+    def fetch(self, n:int):
+        if self.fetchedEOF:
+            return 0
+        for i in range(0, n):
+            t = self.tokenSource.nextToken()
+            t.tokenIndex = len(self.tokens)
+            self.tokens.append(t)
+            if t.type==Token.EOF:
+                self.fetchedEOF = True
+                return i + 1
+        return n
+
+
+    # Get all tokens from start..stop inclusively#/
+    def getTokens(self, start:int, stop:int, types:set=None):
+        if start<0 or stop<0:
+            return None
+        self.lazyInit()
+        subset = []
+        if stop >= len(self.tokens):
+            stop = len(self.tokens)-1
+        for i in range(start, stop):
+            t = self.tokens[i]
+            if t.type==Token.EOF:
+                break
+            if types is None or t.type in types:
+                subset.append(t)
+        return subset
+
+    def LA(self, i:int):
+        return self.LT(i).type
+
+    def LB(self, k:int):
+        if (self.index-k) < 0:
+            return None
+        return self.tokens[self.index-k]
+
+    def LT(self, k:int):
+        self.lazyInit()
+        if k==0:
+            return None
+        if k < 0:
+            return self.LB(-k)
+        i = self.index + k - 1
+        self.sync(i)
+        if i >= len(self.tokens): # return EOF token
+            # EOF must be last token
+            return self.tokens[len(self.tokens)-1]
+        return self.tokens[i]
+
+    # Allowed derived classes to modify the behavior of operations which change
+    # the current stream position by adjusting the target token index of a seek
+    # operation. The default implementation simply returns {@code i}. If an
+    # exception is thrown in this method, the current stream index should not be
+    # changed.
+    #
+    # <p>For example, {@link CommonTokenStream} overrides this method to ensure that
+    # the seek target is always an on-channel token.</p>
+    #
+    # @param i The target token index.
+    # @return The adjusted target token index.
+
+    def adjustSeekIndex(self, i:int):
+        return i
+
+    def lazyInit(self):
+        if self.index == -1:
+            self.setup()
+
+    def setup(self):
+        self.sync(0)
+        self.index = self.adjustSeekIndex(0)
+
+    # Reset this token stream by setting its token source.#/
+    def setTokenSource(self, tokenSource:Lexer):
+        self.tokenSource = tokenSource
+        self.tokens = []
+        self.index = -1
+
+
+
+    # Given a starting index, return the index of the next token on channel.
+    #  Return i if tokens[i] is on channel.  Return -1 if there are no tokens
+    #  on channel between i and EOF.
+    #/
+    def nextTokenOnChannel(self, i:int, channel:int):
+        self.sync(i)
+        if i>=len(self.tokens):
+            return -1
+        token = self.tokens[i]
+        while token.channel!=channel:
+            if token.type==Token.EOF:
+                return -1
+            i += 1
+            self.sync(i)
+            token = self.tokens[i]
+        return i
+
+    # Given a starting index, return the index of the previous token on channel.
+    #  Return i if tokens[i] is on channel. Return -1 if there are no tokens
+    #  on channel between i and 0.
+    def previousTokenOnChannel(self, i:int, channel:int):
+        while i>=0 and self.tokens[i].channel!=channel:
+            i -= 1
+        return i
+
+    # Collect all tokens on specified channel to the right of
+    #  the current token up until we see a token on DEFAULT_TOKEN_CHANNEL or
+    #  EOF. If channel is -1, find any non default channel token.
+    def getHiddenTokensToRight(self, tokenIndex:int, channel:int=-1):
+        self.lazyInit()
+        if tokenIndex<0 or tokenIndex>=len(self.tokens):
+            raise Exception(str(tokenIndex) + " not in 0.." + str(len(self.tokens)-1))
+        from antlr4.Lexer import Lexer
+        nextOnChannel = self.nextTokenOnChannel(tokenIndex + 1, Lexer.DEFAULT_TOKEN_CHANNEL)
+        from_ = tokenIndex+1
+        # if none onchannel to right, nextOnChannel=-1 so set to = last token
+        to = (len(self.tokens)-1) if nextOnChannel==-1 else nextOnChannel
+        return self.filterForChannel(from_, to, channel)
+
+
+    # Collect all tokens on specified channel to the left of
+    #  the current token up until we see a token on DEFAULT_TOKEN_CHANNEL.
+    #  If channel is -1, find any non default channel token.
+    def getHiddenTokensToLeft(self, tokenIndex:int, channel:int=-1):
+        self.lazyInit()
+        if tokenIndex<0 or tokenIndex>=len(self.tokens):
+            raise Exception(str(tokenIndex) + " not in 0.." + str(len(self.tokens)-1))
+        from antlr4.Lexer import Lexer
+        prevOnChannel = self.previousTokenOnChannel(tokenIndex - 1, Lexer.DEFAULT_TOKEN_CHANNEL)
+        if prevOnChannel == tokenIndex - 1:
+            return None
+        # if none on channel to left, prevOnChannel=-1 then from=0
+        from_ = prevOnChannel+1
+        to = tokenIndex-1
+        return self.filterForChannel(from_, to, channel)
+
+
+    def filterForChannel(self, left:int, right:int, channel:int):
+        hidden = []
+        for i in range(left, right+1):
+            t = self.tokens[i]
+            if channel==-1:
+                from antlr4.Lexer import Lexer
+                if t.channel!= Lexer.DEFAULT_TOKEN_CHANNEL:
+                    hidden.append(t)
+            elif t.channel==channel:
+                    hidden.append(t)
+        if len(hidden)==0:
+            return None
+        return hidden
+
+    def getSourceName(self):
+        return self.tokenSource.getSourceName()
+
+    # Get the text of all tokens in this buffer.#/
+    def getText(self, interval:tuple=None):
+        self.lazyInit()
+        self.fill()
+        if interval is None:
+            interval = (0, len(self.tokens)-1)
+        start = interval[0]
+        if isinstance(start, Token):
+            start = start.tokenIndex
+        stop = interval[1]
+        if isinstance(stop, Token):
+            stop = stop.tokenIndex
+        if start is None or stop is None or start<0 or stop<0:
+            return ""
+        if stop >= len(self.tokens):
+            stop = len(self.tokens)-1
+        with StringIO() as buf:
+            for i in range(start, stop+1):
+                t = self.tokens[i]
+                if t.type==Token.EOF:
+                    break
+                buf.write(t.text)
+            return buf.getvalue()
+
+
+    # Get all tokens from lexer until EOF#/
+    def fill(self):
+        self.lazyInit()
+        while self.fetch(1000)==1000:
+            pass
diff --git a/runtime/Python3/src/antlr4/CommonTokenFactory.py b/runtime/Python3/src/antlr4/CommonTokenFactory.py
new file mode 100644
index 000000000..c85bfa0cf
--- /dev/null
+++ b/runtime/Python3/src/antlr4/CommonTokenFactory.py
@@ -0,0 +1,84 @@
+#
+# [The "BSD license"]
+#  Copyright (c) 2012 Terence Parr
+#  Copyright (c) 2012 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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.
+#
+
+#
+# This default implementation of {@link TokenFactory} creates
+# {@link CommonToken} objects.
+#
+from antlr4.Token import CommonToken
+
+class TokenFactory(object):
+
+    pass
+
+class CommonTokenFactory(TokenFactory):
+    #
+    # The default {@link CommonTokenFactory} instance.
+    #
+    # <p>
+    # This token factory does not explicitly copy token text when constructing
+    # tokens.</p>
+    #
+    DEFAULT = None
+
+    def __init__(self, copyText:bool=False):
+        # Indicates whether {@link CommonToken#setText} should be called after
+        # constructing tokens to explicitly set the text. This is useful for cases
+        # where the input stream might not be able to provide arbitrary substrings
+        # of text from the input after the lexer creates a token (e.g. the
+        # implementation of {@link CharStream#getText} in
+        # {@link UnbufferedCharStream} throws an
+        # {@link UnsupportedOperationException}). Explicitly setting the token text
+        # allows {@link Token#getText} to be called at any time regardless of the
+        # input stream implementation.
+        #
+        # <p>
+        # The default value is {@code false} to avoid the performance and memory
+        # overhead of copying text for every token unless explicitly requested.</p>
+        #
+        self.copyText = copyText
+
+    def create(self, source, type:int, text:str, channel:int, start:int, stop:int, line:int, column:int):
+        t = CommonToken(source, type, channel, start, stop)
+        t.line = line
+        t.column = column
+        if text is not None:
+            t.text = text
+        elif self.copyText and source[1] is not None:
+            t.text = source[1].getText(start,stop)
+        return t
+
+    def createThin(self, type:int, text:str):
+        t = CommonToken(type=type)
+        t.text = text
+        return t
+
+CommonTokenFactory.DEFAULT = CommonTokenFactory()
\ No newline at end of file
diff --git a/runtime/Python3/src/antlr4/CommonTokenStream.py b/runtime/Python3/src/antlr4/CommonTokenStream.py
new file mode 100644
index 000000000..e4f4a979d
--- /dev/null
+++ b/runtime/Python3/src/antlr4/CommonTokenStream.py
@@ -0,0 +1,111 @@
+#
+# [The "BSD license"]
+#  Copyright (c) 2012 Terence Parr
+#  Copyright (c) 2012 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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.
+#/
+
+#
+# This class extends {@link BufferedTokenStream} with functionality to filter
+# token streams to tokens on a particular channel (tokens where
+# {@link Token#getChannel} returns a particular value).
+#
+# <p>
+# This token stream provides access to all tokens by index or when calling
+# methods like {@link #getText}. The channel filtering is only used for code
+# accessing tokens via the lookahead methods {@link #LA}, {@link #LT}, and
+# {@link #LB}.</p>
+#
+# <p>
+# By default, tokens are placed on the default channel
+# ({@link Token#DEFAULT_CHANNEL}), but may be reassigned by using the
+# {@code ->channel(HIDDEN)} lexer command, or by using an embedded action to
+# call {@link Lexer#setChannel}.
+# </p>
+#
+# <p>
+# Note: lexer rules which use the {@code ->skip} lexer command or call
+# {@link Lexer#skip} do not produce tokens at all, so input text matched by
+# such a rule will not be available as part of the token stream, regardless of
+# channel.</p>
+#/
+
+from antlr4.BufferedTokenStream import BufferedTokenStream
+from antlr4.Lexer import Lexer
+from antlr4.Token import Token
+
+
+class CommonTokenStream(BufferedTokenStream):
+
+    def __init__(self, lexer:Lexer, channel:int=Token.DEFAULT_CHANNEL):
+        super().__init__(lexer)
+        self.channel = channel
+
+    def adjustSeekIndex(self, i:int):
+        return self.nextTokenOnChannel(i, self.channel)
+
+    def LB(self, k:int):
+        if k==0 or (self.index-k)<0:
+            return None
+        i = self.index
+        n = 1
+        # find k good tokens looking backwards
+        while n <= k:
+            # skip off-channel tokens
+            i = self.previousTokenOnChannel(i - 1, self.channel)
+            n += 1
+        if i < 0:
+            return None
+        return self.tokens[i]
+
+    def LT(self, k:int):
+        self.lazyInit()
+        if k == 0:
+            return None
+        if k < 0:
+            return self.LB(-k)
+        i = self.index
+        n = 1 # we know tokens[pos] is a good one
+        # find k good tokens
+        while n < k:
+            # skip off-channel tokens, but make sure to not look past EOF
+            if self.sync(i + 1):
+                i = self.nextTokenOnChannel(i + 1, self.channel)
+            n += 1
+        return self.tokens[i]
+
+    # Count EOF just once.#/
+    def getNumberOfOnChannelTokens(self):
+        n = 0
+        self.fill()
+        for i in range(0, len(self.tokens)):
+            t = self.tokens[i]
+            if t.channel==self.channel:
+                n += 1
+            if t.type==Token.EOF:
+                break
+        return n
diff --git a/runtime/Python3/src/antlr4/FileStream.py b/runtime/Python3/src/antlr4/FileStream.py
new file mode 100644
index 000000000..b1f42e829
--- /dev/null
+++ b/runtime/Python3/src/antlr4/FileStream.py
@@ -0,0 +1,59 @@
+#
+#  [The "BSD license"]
+#   Copyright (c) 2012 Terence Parr
+#   Copyright (c) 2012 Sam Harwell
+#   Copyright (c) 2014 Eric Vergnaud
+#   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.
+# 
+
+#
+#  This is an InputStream that is loaded from a file all at once
+#  when you construct the object.
+# 
+
+import codecs
+import unittest
+from antlr4.InputStream import InputStream
+
+
+class FileStream(InputStream):
+
+    def __init__(self, fileName:str, encoding:str='ascii'):
+        super().__init__(self.readDataFrom(fileName, encoding))
+        self.fileName = fileName
+
+    def readDataFrom(self, fileName:str, encoding:str):
+        # read binary to avoid line ending conversion
+        with open(fileName, 'rb') as file:
+            bytes = file.read()
+            return codecs.decode(bytes, encoding)
+
+
+class TestFileStream(unittest.TestCase):
+
+    def testStream(self):
+        stream = FileStream(__file__)
+        self.assertTrue(stream.size>0)
\ No newline at end of file
diff --git a/runtime/Python3/src/antlr4/InputStream.py b/runtime/Python3/src/antlr4/InputStream.py
new file mode 100644
index 000000000..1769780ba
--- /dev/null
+++ b/runtime/Python3/src/antlr4/InputStream.py
@@ -0,0 +1,130 @@
+# 
+#  [The "BSD license"]
+#   Copyright (c) 2012 Terence Parr
+#   Copyright (c) 2012 Sam Harwell
+#   Copyright (c) 2014 Eric Vergnaud
+#   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.
+# 
+import unittest
+
+
+# 
+#  Vacuum all input from a string and then treat it like a buffer. 
+#
+from antlr4.Token import Token
+
+
+class InputStream (object):
+    
+    def __init__(self, data: str):
+        self.name = "<empty>"
+        self.strdata = data
+        self._loadString()
+
+    def _loadString(self):    
+        self._index = 0
+        self.data = [ord(c) for c in self.strdata]
+        self._size = len(self.data)
+
+    @property
+    def index(self):
+        return self._index
+
+    @property
+    def size(self):
+        return self._size
+
+    # Reset the stream so that it's in the same state it was
+    #  when the object was created *except* the data array is not
+    #  touched.
+    #
+    def reset(self):
+        self._index = 0
+
+    def consume(self):
+        if self._index >= self._size:
+            assert self.LA(1) == Token.EOF
+            raise Exception("cannot consume EOF")
+        self._index += 1
+
+    def LA(self, offset: int):
+        if offset==0:
+            return 0 # undefined
+        if offset<0:
+            offset += 1 # e.g., translate LA(-1) to use offset=0
+        pos = self._index + offset - 1
+        if pos < 0 or pos >= self._size: # invalid
+            return Token.EOF
+        return self.data[pos]
+
+    def LT(self, offset: int):
+        return self.LA(offset)
+
+    # mark/release do nothing; we have entire buffer
+    def mark(self):
+        return -1
+
+    def release(self, marker: int):
+        pass
+
+    # consume() ahead until p==_index; can't just set p=_index as we must
+    # update line and column. If we seek backwards, just set p
+    #
+    def seek(self, _index: int):
+        if _index<=self._index:
+            self._index = _index # just jump; don't update stream state (line, ...)
+            return
+        # seek forward
+        self._index = min(_index, self._size)
+
+    def getText(self, start :int, stop: int):
+        if stop >= self._size:
+            stop = self._size-1
+        if start >= self._size:
+            return ""
+        else:
+            return self.strdata[start:stop+1]
+    
+    def __str__(self):
+        return self.strdata
+
+
+class TestInputStream(unittest.TestCase):
+    
+    def testStream(self):
+        stream = InputStream("abcde")
+        self.assertEqual(0, stream.index)
+        self.assertEqual(5, stream.size)
+        self.assertEqual(ord("a"), stream.LA(1))
+        stream.consume()
+        self.assertEqual(1, stream.index)
+        stream.seek(5)
+        self.assertEqual(Token.EOF, stream.LA(1))
+        self.assertEqual("bcd", stream.getText(1, 3))
+        stream.reset()
+        self.assertEqual(0, stream.index)
+        
+        
\ No newline at end of file
diff --git a/runtime/Python3/src/antlr4/IntervalSet.py b/runtime/Python3/src/antlr4/IntervalSet.py
new file mode 100644
index 000000000..e5f535f45
--- /dev/null
+++ b/runtime/Python3/src/antlr4/IntervalSet.py
@@ -0,0 +1,282 @@
+from io import StringIO
+import unittest
+from antlr4.Token import Token
+
+# need forward declarations
+IntervalSet = None
+
+class IntervalSet(object):
+
+    def __init__(self):
+        self.intervals = None
+        self.readOnly = False
+
+    def __iter__(self):
+        if self.intervals is not None:
+            for i in self.intervals:
+                for c in i:
+                    yield c
+
+    def __getitem__(self, item):
+        i = 0
+        for k in self:
+            if i==item:
+                return k
+            else:
+                i += 1
+        return Token.INVALID_TYPE
+
+    def addOne(self, v:int):
+        self.addRange(range(v, v+1))
+
+    def addRange(self, v:range):
+        if self.intervals is None:
+            self.intervals = list()
+            self.intervals.append(v)
+        else:
+            # find insert pos
+            k = 0
+            for i in self.intervals:
+                # distinct range -> insert
+                if v.stop<i.start:
+                    self.intervals.insert(k, v)
+                    return
+                # contiguous range -> adjust
+                elif v.stop==i.start:
+                    self.intervals[k] = range(v.start, i.stop)
+                    return
+                # overlapping range -> adjust and reduce
+                elif v.start<=i.stop:
+                    self.intervals[k] = range(min(i.start,v.start), max(i.stop,v.stop))
+                    self.reduce(k)
+                    return
+                k += 1
+            # greater than any existing
+            self.intervals.append(v)
+
+    def addSet(self, other:IntervalSet):
+        if other.intervals is not None:
+            for i in other.intervals:
+                self.addRange(i)
+        return self
+
+    def reduce(self, k:int):
+        # only need to reduce if k is not the last
+        if k<len(self.intervals)-1:
+            l = self.intervals[k]
+            r = self.intervals[k+1]
+            # if r contained in l
+            if l.stop >= r.stop:
+                self.intervals.pop(k+1)
+                self.reduce(k)
+            elif l.stop >= r.start:
+                self.intervals[k] = range(l.start, r.stop)
+                self.intervals.pop(k+1)
+
+    def complement(self, start, stop):
+        result = IntervalSet()
+        result.addRange(range(start,stop+1))
+        for i in self.intervals:
+            result.removeRange(i)
+        return result
+
+    def __contains__(self, item):
+        if self.intervals is None:
+            return False
+        else:
+            for i in self.intervals:
+                if item in i:
+                    return True
+            return False
+
+    def __len__(self):
+        xlen = 0
+        for i in self.intervals:
+            xlen += len(i)
+        return xlen
+
+    def removeRange(self, v):
+        if v.start==v.stop-1:
+            self.removeOne(v.start)
+        elif self.intervals is not None:
+            k = 0
+            for i in self.intervals:
+                # intervals are ordered
+                if v.stop<=i.start:
+                    return
+                # check for including range, split it
+                elif v.start>i.start and v.stop<i.stop:
+                    self.intervals[k] = range(i.start, v.start)
+                    x = range(v.stop, i.stop)
+                    self.intervals.insert(k, x)
+                    return
+                # check for included range, remove it
+                elif v.start<=i.start and v.stop>=i.stop:
+                    self.intervals.pop(k)
+                    k = k - 1 # need another pass
+                # check for lower boundary
+                elif v.start<i.stop:
+                    self.intervals[k] = range(i.start, v.start)
+                # check for upper boundary
+                elif v.stop<i.stop:
+                    self.intervals[k] = range(v.stop, i.stop)
+                k += 1
+
+    def removeOne(self, v):
+        if self.intervals is not None:
+            k = 0
+            for i in self.intervals:
+                # intervals is ordered
+                if v<i.start:
+                    return
+                # check for single value range
+                elif v==i.start and v==i.stop-1:
+                    self.intervals.pop(k)
+                    return
+                # check for lower boundary
+                elif v==i.start:
+                    self.intervals[k] = range(i.start+1, i.stop)
+                    return
+                # check for upper boundary
+                elif v==i.stop-1:
+                    self.intervals[k] = range(i.start, i.stop-1)
+                    return
+                # split existing range
+                elif v<i.stop-1:
+                    x = range(i.start, v)
+                    i.start = v + 1
+                    self.intervals.insert(k, x)
+                    return
+                k += 1
+
+
+    def toString(self, literalNames:list, symbolicNames:list):
+        if self.intervals is None:
+            return "{}"
+        with StringIO() as buf:
+            if len(self)>1:
+                buf.write("{")
+            first = True
+            for i in self.intervals:
+                for j in i:
+                    if not first:
+                        buf.write(", ")
+                    buf.write(self.elementName(literalNames, symbolicNames, j))
+                    first = False
+            if len(self)>1:
+                buf.write("}")
+            return buf.getvalue()
+
+    def elementName(self, literalNames:list, symbolicNames:list, a:int):
+        if a==Token.EOF:
+            return "<EOF>"
+        elif a==Token.EPSILON:
+            return "<EPSILON>"
+        else:
+            if a<len(literalNames):
+                return literalNames[a]
+            if a<len(symbolicNames):
+                return symbolicNames[a]
+            return "<UNKNOWN>"
+
+
+class TestIntervalSet(unittest.TestCase):
+
+    def testEmpty(self):
+        s = IntervalSet()
+        self.assertIsNone(s.intervals)
+        self.assertFalse(30 in s)
+
+    def testOne(self):
+        s = IntervalSet()
+        s.addOne(30)
+        self.assertTrue(30 in s)
+        self.assertFalse(29 in s)
+        self.assertFalse(31 in s)
+
+    def testTwo(self):
+        s = IntervalSet()
+        s.addOne(30)
+        s.addOne(40)
+        self.assertTrue(30 in s)
+        self.assertTrue(40 in s)
+        self.assertFalse(35 in s)
+
+    def testRange(self):
+        s = IntervalSet()
+        s.addRange(range(30,41))
+        self.assertTrue(30 in s)
+        self.assertTrue(40 in s)
+        self.assertTrue(35 in s)
+
+    def testDistinct1(self):
+        s = IntervalSet()
+        s.addRange(range(30,32))
+        s.addRange(range(40,42))
+        self.assertEquals(2,len(s.intervals))
+        self.assertTrue(30 in s)
+        self.assertTrue(40 in s)
+        self.assertFalse(35 in s)
+
+    def testDistinct2(self):
+        s = IntervalSet()
+        s.addRange(range(40,42))
+        s.addRange(range(30,32))
+        self.assertEquals(2,len(s.intervals))
+        self.assertTrue(30 in s)
+        self.assertTrue(40 in s)
+        self.assertFalse(35 in s)
+
+    def testContiguous1(self):
+        s = IntervalSet()
+        s.addRange(range(30,36))
+        s.addRange(range(36,41))
+        self.assertEquals(1,len(s.intervals))
+        self.assertTrue(30 in s)
+        self.assertTrue(40 in s)
+        self.assertTrue(35 in s)
+
+    def testContiguous2(self):
+        s = IntervalSet()
+        s.addRange(range(36,41))
+        s.addRange(range(30,36))
+        self.assertEquals(1,len(s.intervals))
+        self.assertTrue(30 in s)
+        self.assertTrue(40 in s)
+
+    def testOverlapping1(self):
+        s = IntervalSet()
+        s.addRange(range(30,40))
+        s.addRange(range(35,45))
+        self.assertEquals(1,len(s.intervals))
+        self.assertTrue(30 in s)
+        self.assertTrue(44 in s)
+
+    def testOverlapping2(self):
+        s = IntervalSet()
+        s.addRange(range(35,45))
+        s.addRange(range(30,40))
+        self.assertEquals(1,len(s.intervals))
+        self.assertTrue(30 in s)
+        self.assertTrue(44 in s)
+
+    def testOverlapping3(self):
+        s = IntervalSet()
+        s.addRange(range(30,32))
+        s.addRange(range(40,42))
+        s.addRange(range(50,52))
+        s.addRange(range(20,61))
+        self.assertEquals(1,len(s.intervals))
+        self.assertTrue(20 in s)
+        self.assertTrue(60 in s)
+
+    def testComplement(self):
+        s = IntervalSet()
+        s.addRange(range(10,21))
+        c = s.complement(1,100)
+        self.assertTrue(1 in c)
+        self.assertTrue(100 in c)
+        self.assertTrue(10 not in c)
+        self.assertTrue(20 not in c)
+
+
diff --git a/runtime/Python3/src/antlr4/LL1Analyzer.py b/runtime/Python3/src/antlr4/LL1Analyzer.py
new file mode 100644
index 000000000..ea70a0a81
--- /dev/null
+++ b/runtime/Python3/src/antlr4/LL1Analyzer.py
@@ -0,0 +1,197 @@
+#
+# [The "BSD license"]
+#  Copyright (c) 2012 Terence Parr
+#  Copyright (c) 2012 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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.
+#/
+from antlr4.IntervalSet import IntervalSet
+from antlr4.Token import Token
+from antlr4.PredictionContext import PredictionContext, SingletonPredictionContext, PredictionContextFromRuleContext
+from antlr4.RuleContext import RuleContext
+from antlr4.atn.ATN import ATN
+from antlr4.atn.ATNConfig import ATNConfig
+from antlr4.atn.ATNState import ATNState, RuleStopState
+from antlr4.atn.Transition import WildcardTransition, NotSetTransition, AbstractPredicateTransition, RuleTransition
+
+
+class LL1Analyzer (object):
+    
+    #* Special value added to the lookahead sets to indicate that we hit
+    #  a predicate during analysis if {@code seeThruPreds==false}.
+    #/
+    HIT_PRED = Token.INVALID_TYPE
+
+    def __init__(self, atn:ATN):
+        self.atn = atn
+
+    #*
+    # Calculates the SLL(1) expected lookahead set for each outgoing transition
+    # of an {@link ATNState}. The returned array has one element for each
+    # outgoing transition in {@code s}. If the closure from transition
+    # <em>i</em> leads to a semantic predicate before matching a symbol, the
+    # element at index <em>i</em> of the result will be {@code null}.
+    #
+    # @param s the ATN state
+    # @return the expected symbols for each outgoing transition of {@code s}.
+    #/
+    def getDecisionLookahead(self, s:ATNState):
+        if s is None:
+            return None
+
+        count = len(s.transitions)
+        look = [] * count
+        for alt in range(0, count):
+            look[alt] = set()
+            lookBusy = set()
+            seeThruPreds = False # fail to get lookahead upon pred
+            self._LOOK(s.transition(alt).target, None, PredictionContext.EMPTY,
+                  look[alt], lookBusy, set(), seeThruPreds, False)
+            # Wipe out lookahead for this alternative if we found nothing
+            # or we had a predicate when we !seeThruPreds
+            if len(look[alt])==0 or self.HIT_PRED in look[alt]:
+                look[alt] = None
+        return look
+
+    #*
+    # Compute set of tokens that can follow {@code s} in the ATN in the
+    # specified {@code ctx}.
+    #
+    # <p>If {@code ctx} is {@code null} and the end of the rule containing
+    # {@code s} is reached, {@link Token#EPSILON} is added to the result set.
+    # If {@code ctx} is not {@code null} and the end of the outermost rule is
+    # reached, {@link Token#EOF} is added to the result set.</p>
+    #
+    # @param s the ATN state
+    # @param stopState the ATN state to stop at. This can be a
+    # {@link BlockEndState} to detect epsilon paths through a closure.
+    # @param ctx the complete parser context, or {@code null} if the context
+    # should be ignored
+    #
+    # @return The set of tokens that can follow {@code s} in the ATN in the
+    # specified {@code ctx}.
+    #/
+    def LOOK(self, s:ATNState, stopState:ATNState=None, ctx:RuleContext=None):
+        r = IntervalSet()
+        seeThruPreds = True # ignore preds; get all lookahead
+        lookContext = PredictionContextFromRuleContext(s.atn, ctx) if ctx is not None else None
+        self._LOOK(s, stopState, lookContext, r, set(), set(), seeThruPreds, True)
+        return r
+
+    #*
+    # Compute set of tokens that can follow {@code s} in the ATN in the
+    # specified {@code ctx}.
+    #
+    # <p>If {@code ctx} is {@code null} and {@code stopState} or the end of the
+    # rule containing {@code s} is reached, {@link Token#EPSILON} is added to
+    # the result set. If {@code ctx} is not {@code null} and {@code addEOF} is
+    # {@code true} and {@code stopState} or the end of the outermost rule is
+    # reached, {@link Token#EOF} is added to the result set.</p>
+    #
+    # @param s the ATN state.
+    # @param stopState the ATN state to stop at. This can be a
+    # {@link BlockEndState} to detect epsilon paths through a closure.
+    # @param ctx The outer context, or {@code null} if the outer context should
+    # not be used.
+    # @param look The result lookahead set.
+    # @param lookBusy A set used for preventing epsilon closures in the ATN
+    # from causing a stack overflow. Outside code should pass
+    # {@code new HashSet<ATNConfig>} for this argument.
+    # @param calledRuleStack A set used for preventing left recursion in the
+    # ATN from causing a stack overflow. Outside code should pass
+    # {@code new BitSet()} for this argument.
+    # @param seeThruPreds {@code true} to true semantic predicates as
+    # implicitly {@code true} and "see through them", otherwise {@code false}
+    # to treat semantic predicates as opaque and add {@link #HIT_PRED} to the
+    # result if one is encountered.
+    # @param addEOF Add {@link Token#EOF} to the result if the end of the
+    # outermost context is reached. This parameter has no effect if {@code ctx}
+    # is {@code null}.
+    #/
+    def _LOOK(self, s:ATNState, stopState:ATNState , ctx:PredictionContext, look:IntervalSet, lookBusy:set,
+                     calledRuleStack:set, seeThruPreds:bool, addEOF:bool):
+        c = ATNConfig(s, 0, ctx)
+
+        if c in lookBusy:
+            return
+        lookBusy.add(c)
+
+        if s == stopState:
+            if ctx is None:
+                look.addOne(Token.EPSILON)
+                return
+            elif ctx.isEmpty() and addEOF:
+                look.addOne(Token.EOF)
+                return
+
+        if isinstance(s, RuleStopState ):
+            if ctx is None:
+                look.addOne(Token.EPSILON)
+                return
+            elif ctx.isEmpty() and addEOF:
+                look.addOne(Token.EOF)
+                return
+
+            if ctx != PredictionContext.EMPTY:
+                # run thru all possible stack tops in ctx
+                for i in range(0, len(ctx)):
+                    returnState = self.atn.states[ctx.getReturnState(i)]
+                    removed = returnState.ruleIndex in calledRuleStack
+                    try:
+                        calledRuleStack.discard(returnState.ruleIndex)
+                        self._LOOK(returnState, stopState, ctx.getParent(i), look, lookBusy, calledRuleStack, seeThruPreds, addEOF)
+                    finally:
+                        if removed:
+                            calledRuleStack.add(returnState.ruleIndex)
+                return
+
+        for t in s.transitions:
+            if type(t) == RuleTransition:
+                if t.target.ruleIndex in calledRuleStack:
+                    continue
+
+                newContext = SingletonPredictionContext.create(ctx, t.followState.stateNumber)
+
+                try:
+                    calledRuleStack.add(t.target.ruleIndex)
+                    self._LOOK(t.target, stopState, newContext, look, lookBusy, calledRuleStack, seeThruPreds, addEOF)
+                finally:
+                    calledRuleStack.remove(t.target.ruleIndex)
+            elif isinstance(t, AbstractPredicateTransition ):
+                if seeThruPreds:
+                    self._LOOK(t.target, stopState, ctx, look, lookBusy, calledRuleStack, seeThruPreds, addEOF)
+                else:
+                    look.addOne(self.HIT_PRED)
+            elif t.isEpsilon:
+                self._LOOK(t.target, stopState, ctx, look, lookBusy, calledRuleStack, seeThruPreds, addEOF)
+            elif type(t) == WildcardTransition:
+                look.addRange( range(Token.MIN_USER_TOKEN_TYPE, self.atn.maxTokenType + 1) )
+            else:
+                set_ = t.label
+                if set_ is not None:
+                    if isinstance(t, NotSetTransition):
+                        set_ = set_.complement(Token.MIN_USER_TOKEN_TYPE, self.atn.maxTokenType)
+                    look.addSet(set_)
diff --git a/runtime/Python3/src/antlr4/Lexer.py b/runtime/Python3/src/antlr4/Lexer.py
new file mode 100644
index 000000000..7c9898d4c
--- /dev/null
+++ b/runtime/Python3/src/antlr4/Lexer.py
@@ -0,0 +1,343 @@
+# [The "BSD license"]
+#  Copyright (c) 2012 Terence Parr
+#  Copyright (c) 2012 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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, self list of conditions and the following disclaimer.
+#  2. Redistributions in binary form must reproduce the above copyright
+#     notice, self 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 self software without specific prior written permission.
+#
+#  self 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
+#  self SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#/
+
+# A lexer is recognizer that draws input symbols from a character stream.
+#  lexer grammars result in a subclass of self object. A Lexer object
+#  uses simplified match() and error recovery mechanisms in the interest
+#  of speed.
+#/
+from io import StringIO
+from antlr4.CommonTokenFactory import CommonTokenFactory
+from antlr4.atn.LexerATNSimulator import LexerATNSimulator
+from antlr4.InputStream import InputStream
+from antlr4.Recognizer import Recognizer
+from antlr4.Token import Token
+from antlr4.error.Errors import IllegalStateException, LexerNoViableAltException, RecognitionException
+
+class TokenSource(object):
+
+    pass
+
+
+class Lexer(Recognizer, TokenSource):
+
+    DEFAULT_MODE = 0
+    MORE = -2
+    SKIP = -3
+
+    DEFAULT_TOKEN_CHANNEL = Token.DEFAULT_CHANNEL
+    HIDDEN = Token.HIDDEN_CHANNEL
+    MIN_CHAR_VALUE = '\u0000'
+    MAX_CHAR_VALUE = '\uFFFE'
+
+    def __init__(self, input:InputStream):
+        super().__init__()
+        self._input = input
+        self._factory = CommonTokenFactory.DEFAULT
+        self._tokenFactorySourcePair = (self, input)
+
+        self._interp = None # child classes must populate this
+        
+        # The goal of all lexer rules/methods is to create a token object.
+        #  self is an instance variable as multiple rules may collaborate to
+        #  create a single token.  nextToken will return self object after
+        #  matching lexer rule(s).  If you subclass to allow multiple token
+        #  emissions, then set self to the last token to be matched or
+        #  something nonnull so that the auto token emit mechanism will not
+        #  emit another token.
+        self._token = None
+
+        # What character index in the stream did the current token start at?
+        #  Needed, for example, to get the text for current token.  Set at
+        #  the start of nextToken.
+        self._tokenStartCharIndex = -1
+
+        # The line on which the first character of the token resides#/
+        self._tokenStartLine = -1
+
+        # The character position of first character within the line#/
+        self._tokenStartColumn = -1
+
+        # Once we see EOF on char stream, next token will be EOF.
+        #  If you have DONE : EOF ; then you see DONE EOF.
+        self._hitEOF = False
+
+        # The channel number for the current token#/
+        self._channel = Token.DEFAULT_CHANNEL
+
+        # The token type for the current token#/
+        self._type = Token.INVALID_TYPE
+
+        self._modeStack = []
+        self._mode = self.DEFAULT_MODE
+
+        # You can set the text for the current token to override what is in
+        #  the input char buffer.  Use setText() or can set self instance var.
+        #/
+        self._text = None
+
+
+    def reset(self):
+        # wack Lexer state variables
+        if self._input is not None:
+            self._input.seek(0) # rewind the input
+        self._token = None
+        self._type = Token.INVALID_TYPE
+        self._channel = Token.DEFAULT_CHANNEL
+        self._tokenStartCharIndex = -1
+        self._tokenStartColumn = -1
+        self._tokenStartLine = -1
+        self._text = None
+
+        self._hitEOF = False
+        self._mode = Lexer.DEFAULT_MODE
+        self._modeStack = []
+
+        self._interp.reset()
+
+    # Return a token from self source; i.e., match a token on the char
+    #  stream.
+    def nextToken(self):
+        if self._input is None:
+            raise IllegalStateException("nextToken requires a non-null input stream.")
+
+        # Mark start location in char stream so unbuffered streams are
+        # guaranteed at least have text of current token
+        tokenStartMarker = self._input.mark()
+        try:
+            while True:
+                if self._hitEOF:
+                    self.emitEOF()
+                    return self._token
+                self._token = None
+                self._channel = Token.DEFAULT_CHANNEL
+                self._tokenStartCharIndex = self._input.index
+                self._tokenStartColumn = self._interp.column
+                self._tokenStartLine = self._interp.line
+                self._text = None
+                continueOuter = False
+                while True:
+                    self._type = Token.INVALID_TYPE
+                    ttype = self.SKIP
+                    try:
+                        ttype = self._interp.match(self._input, self._mode)
+                    except LexerNoViableAltException as e:
+                        self.notifyListeners(e)		# report error
+                        self.recover(e)
+                    if self._input.LA(1)==Token.EOF:
+                        self._hitEOF = True
+                    if self._type == Token.INVALID_TYPE:
+                        self._type = ttype
+                    if self._type == self.SKIP:
+                        continueOuter = True
+                        break
+                    if self._type!=self.MORE:
+                        break
+                if continueOuter:
+                    continue
+                if self._token is None:
+                    self.emit()
+                return self._token
+        finally:
+            # make sure we release marker after match or
+            # unbuffered char stream will keep buffering
+            self._input.release(tokenStartMarker)
+
+    # Instruct the lexer to skip creating a token for current lexer rule
+    #  and look for another token.  nextToken() knows to keep looking when
+    #  a lexer rule finishes with token set to SKIP_TOKEN.  Recall that
+    #  if token==null at end of any token rule, it creates one for you
+    #  and emits it.
+    #/
+    def skip(self):
+        self._type = self.SKIP
+
+    def more(self):
+        self._type = self.MORE
+
+    def mode(self, m:int):
+        self._mode = m
+
+    def pushMode(self, m:int):
+        if self._interp.debug:
+            print("pushMode " + str(m))
+        self._modeStack.append(self._mode)
+        self.mode(m)
+
+    def popMode(self):
+        if len(self._modeStack)==0:
+            raise Exception("Empty Stack")
+        if self._interp.debug:
+            print("popMode back to "+ self._modeStack[:-1])
+        self.mode( self._modeStack.pop() )
+        return self._mode
+
+    # Set the char stream and reset the lexer#/
+    @property
+    def inputStream(self):
+        return self._input
+
+    @inputStream.setter
+    def inputStream(self, input:InputStream):
+        self._input = None
+        self._tokenFactorySourcePair = (self, self._input)
+        self.reset()
+        self._input = input
+        self._tokenFactorySourcePair = (self, self._input)
+
+    @property
+    def sourceName(self):
+        return self._input.sourceName
+
+    # By default does not support multiple emits per nextToken invocation
+    #  for efficiency reasons.  Subclass and override self method, nextToken,
+    #  and getToken (to push tokens into a list and pull from that list
+    #  rather than a single variable as self implementation does).
+    #/
+    def emitToken(self, token:Token):
+        self._token = token
+
+    # The standard method called to automatically emit a token at the
+    #  outermost lexical rule.  The token object should point into the
+    #  char buffer start..stop.  If there is a text override in 'text',
+    #  use that to set the token's text.  Override self method to emit
+    #  custom Token objects or provide a new factory.
+    #/
+    def emit(self):
+        t = self._factory.create(self._tokenFactorySourcePair, self._type, self._text, self._channel, self._tokenStartCharIndex,
+                                 self.getCharIndex()-1, self._tokenStartLine, self._tokenStartColumn)
+        self.emitToken(t)
+        return t
+
+    def emitEOF(self):
+        cpos = self.column
+        lpos = self.line
+        eof = self._factory.create(self._tokenFactorySourcePair, Token.EOF, None, Token.DEFAULT_CHANNEL, self._input.index,
+                                   self._input.index-1, lpos, cpos)
+        self.emitToken(eof)
+        return eof
+
+    @property
+    def type(self):
+        return self._type
+
+    @type.setter
+    def type(self, type:int):
+        self._type = type
+
+    @property
+    def line(self):
+        return self._interp.line
+
+    @line.setter
+    def line(self, line:int):
+        self._interp.line = line
+
+    @property
+    def column(self):
+        return self._interp.column
+
+    @column.setter
+    def column(self, column:int):
+        self._interp.column = column
+
+    # What is the index of the current character of lookahead?#/
+    def getCharIndex(self):
+        return self._input.index
+
+    # Return the text matched so far for the current token or any
+    #  text override.
+    @property
+    def text(self):
+        if self._text is not None:
+            return self._text
+        else:
+            return self._interp.getText(self._input)
+
+    # Set the complete text of self token; it wipes any previous
+    #  changes to the text.
+    @text.setter
+    def text(self, txt:str):
+        self._text = txt
+
+    # Return a list of all Token objects in input char stream.
+    #  Forces load of all tokens. Does not include EOF token.
+    #/
+    def getAllTokens(self):
+        tokens = []
+        t = self.nextToken()
+        while t.type!=Token.EOF:
+            tokens.append(t)
+            t = self.nextToken()
+        return tokens
+
+    def notifyListeners(self, e:LexerNoViableAltException):
+        start = self._tokenStartCharIndex
+        stop = self._input.index
+        text = self._input.getText(start, stop)
+        msg = "token recognition error at: '" + self.getErrorDisplay(text) + "'"
+        listener = self.getErrorListenerDispatch()
+        listener.syntaxError(self, None, self._tokenStartLine, self._tokenStartColumn, msg, e)
+
+    def getErrorDisplay(self, s:str):
+        with StringIO() as buf:
+            for c in s:
+                buf.write(self.getErrorDisplayForChar(c))
+            return buf.getvalue()
+
+    def getErrorDisplayForChar(self, c:str):
+        if ord(c[0])==Token.EOF:
+            return "<EOF>"
+        elif c=='\n':
+            return "\\n"
+        elif c=='\t':
+            return "\\t"
+        elif c=='\r':
+            return "\\r"
+        else:
+            return c
+
+    def getCharErrorDisplay(self, c:str):
+        return "'" + self.getErrorDisplayForChar(c) + "'"
+
+    # Lexers can normally match any char in it's vocabulary after matching
+    #  a token, so do the easy thing and just kill a character and hope
+    #  it all works out.  You can instead use the rule invocation stack
+    #  to do sophisticated error recovery if you are in a fragment rule.
+    #/
+    def recover(self, re:RecognitionException):
+        if self._input.LA(1) != Token.EOF:
+            if isinstance(re, LexerNoViableAltException):
+                    # skip a char and try again
+                    self._interp.consume(self._input)
+            else:
+                # TODO: Do we lose character or line position information?
+                self._input.consume()
+
diff --git a/runtime/Python3/src/antlr4/ListTokenSource.py b/runtime/Python3/src/antlr4/ListTokenSource.py
new file mode 100644
index 000000000..c0b929a8d
--- /dev/null
+++ b/runtime/Python3/src/antlr4/ListTokenSource.py
@@ -0,0 +1,139 @@
+#
+# Provides an implementation of {@link TokenSource} as a wrapper around a list
+# of {@link Token} objects.
+#
+# <p>If the final token in the list is an {@link Token#EOF} token, it will be used
+# as the EOF token for every call to {@link #nextToken} after the end of the
+# list is reached. Otherwise, an EOF token will be created.</p>
+#
+from antlr4.CommonTokenFactory import CommonTokenFactory
+from antlr4.Lexer import TokenSource
+from antlr4.Token import Token
+
+
+class ListTokenSource(TokenSource):
+
+    # Constructs a new {@link ListTokenSource} instance from the specified
+    # collection of {@link Token} objects and source name.
+    #
+    # @param tokens The collection of {@link Token} objects to provide as a
+    # {@link TokenSource}.
+    # @param sourceName The name of the {@link TokenSource}. If this value is
+    # {@code null}, {@link #getSourceName} will attempt to infer the name from
+    # the next {@link Token} (or the previous token if the end of the input has
+    # been reached).
+    #
+    # @exception NullPointerException if {@code tokens} is {@code null}
+    #
+    def __init__(self, tokens:list, sourceName:str=None):
+        if tokens is None:
+            raise ReferenceError("tokens cannot be null")
+        self.tokens = tokens
+        self.sourceName = sourceName
+        # The index into {@link #tokens} of token to return by the next call to
+        # {@link #nextToken}. The end of the input is indicated by this value
+        # being greater than or equal to the number of items in {@link #tokens}.
+        self.pos = 0
+        # This field caches the EOF token for the token source.
+        self.eofToken = None
+        # This is the backing field for {@link #getTokenFactory} and
+        self._factory = CommonTokenFactory.DEFAULT
+
+
+    #
+    # {@inheritDoc}
+    #
+    @property
+    def column(self):
+        if self.pos < len(self.tokens):
+            return self.tokens[self.pos].column
+        elif self.eofToken is not None:
+            return self.eofToken.column
+        elif len(self.tokens) > 0:
+            # have to calculate the result from the line/column of the previous
+            # token, along with the text of the token.
+            lastToken = self.tokens[len(self.tokens) - 1]
+            tokenText = lastToken.getText()
+            if tokenText is not None:
+                lastNewLine = tokenText.rfind('\n')
+                if lastNewLine >= 0:
+                    return len(tokenText) - lastNewLine - 1
+            return lastToken.column + lastToken.stopIndex - lastToken.startIndex + 1
+
+        # only reach this if tokens is empty, meaning EOF occurs at the first
+        # position in the input
+        return 0
+
+    #
+    # {@inheritDoc}
+    #
+    def nextToken(self):
+        if self.pos >= len(self.tokens):
+            if self.eofToken is None:
+                start = -1
+                if len(self.tokens) > 0:
+                    previousStop = self.tokens[len(self.tokens) - 1].stopIndex
+                    if previousStop != -1:
+                        start = previousStop + 1
+                stop = max(-1, start - 1)
+                self.eofToken = self._factory.create((self, self.getInputStream()),
+                            Token.EOF, "EOF", Token.DEFAULT_CHANNEL, start, stop, self.line, self.column)
+            return self.eofToken
+        t = self.tokens[self.pos]
+        if self.pos == len(self.tokens) - 1 and t.type == Token.EOF:
+            eofToken = t
+        self.pos += 1
+        return t
+
+    #
+    # {@inheritDoc}
+    #
+    @property
+    def line(self):
+        if self.pos < len(self.tokens):
+            return self.tokens[self.pos].line
+        elif self.eofToken is not None:
+            return self.eofToken.line
+        elif len(self.tokens) > 0:
+            # have to calculate the result from the line/column of the previous
+            # token, along with the text of the token.
+            lastToken = self.tokens[len(self.tokens) - 1]
+            line = lastToken.line
+            tokenText = lastToken.text
+            if tokenText is not None:
+                for c in tokenText:
+                    if c  == '\n':
+                        line += 1
+
+            # if no text is available, assume the token did not contain any newline characters.
+            return line
+
+        # only reach this if tokens is empty, meaning EOF occurs at the first
+        # position in the input
+        return 1
+
+    #
+    # {@inheritDoc}
+    #
+    def getInputStream(self):
+        if self.pos < len(self.tokens):
+            return self.tokens[self.pos].getInputStream()
+        elif self.eofToken is not None:
+            return self.eofToken.getInputStream()
+        elif len(self.tokens) > 0:
+            return self.tokens[len(self.tokens) - 1].getInputStream()
+        else:
+            # no input stream information is available
+            return None
+
+    #
+    # {@inheritDoc}
+    #
+    def getSourceName(self):
+        if self.sourceName is not None:
+            return self.sourceName
+        inputStream = self.getInputStream()
+        if inputStream is not None:
+            return inputStream.getSourceName()
+        else:
+            return "List"
\ No newline at end of file
diff --git a/runtime/Python3/src/antlr4/Parser.py b/runtime/Python3/src/antlr4/Parser.py
new file mode 100644
index 000000000..0d6824b20
--- /dev/null
+++ b/runtime/Python3/src/antlr4/Parser.py
@@ -0,0 +1,583 @@
+#
+# [The "BSD license"]
+#  Copyright (c) 2012 Terence Parr
+#  Copyright (c) 2012 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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, self list of conditions and the following disclaimer.
+#  2. Redistributions in binary form must reproduce the above copyright
+#     notice, self 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 self software without specific prior written permission.
+#
+#  self 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
+#  self SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+from antlr4.BufferedTokenStream import TokenStream
+from antlr4.CommonTokenFactory import TokenFactory
+from antlr4.error.ErrorStrategy import DefaultErrorStrategy
+from antlr4.InputStream import InputStream
+from antlr4.Recognizer import Recognizer
+from antlr4.RuleContext import RuleContext
+from antlr4.ParserRuleContext import ParserRuleContext
+from antlr4.Token import Token
+from antlr4.Lexer import Lexer
+from antlr4.atn.ATNDeserializer import ATNDeserializer
+from antlr4.atn.ATNDeserializationOptions import ATNDeserializationOptions
+from antlr4.error.Errors import UnsupportedOperationException, RecognitionException
+from antlr4.tree.ParseTreePatternMatcher import ParseTreePatternMatcher
+from antlr4.tree.Tree import ParseTreeListener, TerminalNode, ErrorNode
+
+class TraceListener(ParseTreeListener):
+
+    def __init__(self, parser):
+        self._parser = parser
+
+    def enterEveryRule(self, ctx):
+        print("enter   " + self._parser.ruleNames[ctx.getRuleIndex()] + ", LT(1)=" + self._parser._input.LT(1).text)
+
+    def visitTerminal(self, node):
+
+        print("consume " + str(node.symbol) + " rule " + self._parser.ruleNames[self._parser._ctx.getRuleIndex()])
+
+    def visitErrorNode(self, node):
+        pass
+
+
+    def exitEveryRule(self, ctx):
+        print("exit    " + self._parser.ruleNames[ctx.getRuleIndex()] + ", LT(1)=" + self._parser._input.LT(1).text)
+
+
+# self is all the parsing support code essentially; most of it is error recovery stuff.#
+class Parser (Recognizer):
+
+    # self field maps from the serialized ATN string to the deserialized {@link ATN} with
+    # bypass alternatives.
+    #
+    # @see ATNDeserializationOptions#isGenerateRuleBypassTransitions()
+    #
+    bypassAltsAtnCache = dict()
+
+    def __init__(self, input:TokenStream):
+        super().__init__()
+        # The input stream.
+        self._input = None
+        # The error handling strategy for the parser. The default value is a new
+        # instance of {@link DefaultErrorStrategy}.
+        self._errHandler = DefaultErrorStrategy()
+        self._precedenceStack = list()
+        self._precedenceStack.append(0)
+        # The {@link ParserRuleContext} object for the currently executing rule.
+        # self is always non-null during the parsing process.
+        self._ctx = None
+        # Specifies whether or not the parser should construct a parse tree during
+        # the parsing process. The default value is {@code true}.
+        self.buildParseTrees = True
+        # When {@link #setTrace}{@code (true)} is called, a reference to the
+        # {@link TraceListener} is stored here so it can be easily removed in a
+        # later call to {@link #setTrace}{@code (false)}. The listener itself is
+        # implemented as a parser listener so self field is not directly used by
+        # other parser methods.
+        self._tracer = None
+        # The list of {@link ParseTreeListener} listeners registered to receive
+        # events during the parse.
+        self._parseListeners = None
+        # The number of syntax errors reported during parsing. self value is
+        # incremented each time {@link #notifyErrorListeners} is called.
+        self._syntaxErrors = 0
+        self.setInputStream(input)
+
+    # reset the parser's state#
+    def reset(self):
+        if self._input is not None:
+            self._input.seek(0)
+        self._errHandler.reset(self)
+        self._ctx = None
+        self._syntaxErrors = 0
+        self.setTrace(False)
+        self._precedenceStack = list()
+        self._precedenceStack.append(0)
+        if self._interp is not None:
+            self._interp.reset()
+
+    # Match current input symbol against {@code ttype}. If the symbol type
+    # matches, {@link ANTLRErrorStrategy#reportMatch} and {@link #consume} are
+    # called to complete the match process.
+    #
+    # <p>If the symbol type does not match,
+    # {@link ANTLRErrorStrategy#recoverInline} is called on the current error
+    # strategy to attempt recovery. If {@link #getBuildParseTree} is
+    # {@code true} and the token index of the symbol returned by
+    # {@link ANTLRErrorStrategy#recoverInline} is -1, the symbol is added to
+    # the parse tree by calling {@link ParserRuleContext#addErrorNode}.</p>
+    #
+    # @param ttype the token type to match
+    # @return the matched symbol
+    # @throws RecognitionException if the current input symbol did not match
+    # {@code ttype} and the error strategy could not recover from the
+    # mismatched symbol
+
+    def match(self, ttype:int):
+        t = self.getCurrentToken()
+        if t.type==ttype:
+            self._errHandler.reportMatch(self)
+            self.consume()
+        else:
+            t = self._errHandler.recoverInline(self)
+            if self.buildParseTrees and t.tokenIndex==-1:
+                # we must have conjured up a new token during single token insertion
+                # if it's not the current symbol
+                self._ctx.addErrorNode(t)
+        return t
+
+    # Match current input symbol as a wildcard. If the symbol type matches
+    # (i.e. has a value greater than 0), {@link ANTLRErrorStrategy#reportMatch}
+    # and {@link #consume} are called to complete the match process.
+    #
+    # <p>If the symbol type does not match,
+    # {@link ANTLRErrorStrategy#recoverInline} is called on the current error
+    # strategy to attempt recovery. If {@link #getBuildParseTree} is
+    # {@code true} and the token index of the symbol returned by
+    # {@link ANTLRErrorStrategy#recoverInline} is -1, the symbol is added to
+    # the parse tree by calling {@link ParserRuleContext#addErrorNode}.</p>
+    #
+    # @return the matched symbol
+    # @throws RecognitionException if the current input symbol did not match
+    # a wildcard and the error strategy could not recover from the mismatched
+    # symbol
+
+    def matchWildcard(self):
+        t = self.getCurrentToken()
+        if t.type > 0:
+            self._errHandler.reportMatch(self)
+            self.consume()
+        else:
+            t = self._errHandler.recoverInline(self)
+            if self.buildParseTrees and t.tokenIndex == -1:
+                # we must have conjured up a new token during single token insertion
+                # if it's not the current symbol
+                self._ctx.addErrorNode(t)
+
+        return t
+
+    def getParseListeners(self):
+        return list() if self._parseListeners is None else self._parseListeners
+
+    # Registers {@code listener} to receive events during the parsing process.
+    #
+    # <p>To support output-preserving grammar transformations (including but not
+    # limited to left-recursion removal, automated left-factoring, and
+    # optimized code generation), calls to listener methods during the parse
+    # may differ substantially from calls made by
+    # {@link ParseTreeWalker#DEFAULT} used after the parse is complete. In
+    # particular, rule entry and exit events may occur in a different order
+    # during the parse than after the parser. In addition, calls to certain
+    # rule entry methods may be omitted.</p>
+    #
+    # <p>With the following specific exceptions, calls to listener events are
+    # <em>deterministic</em>, i.e. for identical input the calls to listener
+    # methods will be the same.</p>
+    #
+    # <ul>
+    # <li>Alterations to the grammar used to generate code may change the
+    # behavior of the listener calls.</li>
+    # <li>Alterations to the command line options passed to ANTLR 4 when
+    # generating the parser may change the behavior of the listener calls.</li>
+    # <li>Changing the version of the ANTLR Tool used to generate the parser
+    # may change the behavior of the listener calls.</li>
+    # </ul>
+    #
+    # @param listener the listener to add
+    #
+    # @throws NullPointerException if {@code} listener is {@code null}
+    #
+    def addParseListener(self, listener:ParseTreeListener):
+        if listener is None:
+            raise ReferenceError("listener")
+        if self._parseListeners is None:
+            self._parseListeners = []
+        self._parseListeners.append(listener)
+
+    #
+    # Remove {@code listener} from the list of parse listeners.
+    #
+    # <p>If {@code listener} is {@code null} or has not been added as a parse
+    # listener, self method does nothing.</p>
+    # @param listener the listener to remove
+    #
+    def removeParseListener(self, listener:ParseTreeListener):
+        if self._parseListeners is not None:
+            self._parseListeners.remove(listener)
+            if len(self._parseListeners)==0:
+                    self._parseListeners = None
+
+    # Remove all parse listeners.
+    def removeParseListeners(self):
+        self._parseListeners = None
+
+    # Notify any parse listeners of an enter rule event.
+    def triggerEnterRuleEvent(self):
+        if self._parseListeners is not None:
+            for listener in self._parseListeners:
+                listener.enterEveryRule(self._ctx)
+                self._ctx.enterRule(listener)
+
+    #
+    # Notify any parse listeners of an exit rule event.
+    #
+    # @see #addParseListener
+    #
+    def triggerExitRuleEvent(self):
+        if self._parseListeners is not None:
+            # reverse order walk of listeners
+            for listener in reversed(self._parseListeners):
+                self._ctx.exitRule(listener)
+                listener.exitEveryRule(self._ctx)
+
+
+    def getTokenFactory(self):
+        return self._input.tokenSource._factory
+
+    # Tell our token source and error strategy about a new way to create tokens.#
+    def setTokenFactory(self, factory:TokenFactory):
+        self._input.tokenSource._factory = factory
+
+    # The ATN with bypass alternatives is expensive to create so we create it
+    # lazily.
+    #
+    # @throws UnsupportedOperationException if the current parser does not
+    # implement the {@link #getSerializedATN()} method.
+    #
+    def getATNWithBypassAlts(self):
+        serializedAtn = self.getSerializedATN()
+        if serializedAtn is None:
+            raise UnsupportedOperationException("The current parser does not support an ATN with bypass alternatives.")
+        result = self.bypassAltsAtnCache.get(serializedAtn, None)
+        if result is None:
+            deserializationOptions = ATNDeserializationOptions()
+            deserializationOptions.generateRuleBypassTransitions = True
+            result = ATNDeserializer(deserializationOptions).deserialize(serializedAtn)
+            self.bypassAltsAtnCache[serializedAtn] = result
+        return result
+
+    # The preferred method of getting a tree pattern. For example, here's a
+    # sample use:
+    #
+    # <pre>
+    # ParseTree t = parser.expr();
+    # ParseTreePattern p = parser.compileParseTreePattern("&lt;ID&gt;+0", MyParser.RULE_expr);
+    # ParseTreeMatch m = p.match(t);
+    # String id = m.get("ID");
+    # </pre>
+    #
+    def compileParseTreePattern(self, pattern:str, patternRuleIndex:int, lexer:Lexer = None):
+        if lexer is None:
+            if self.getTokenStream() is not None:
+                tokenSource = self.getTokenStream().tokenSource
+                if isinstance( tokenSource, Lexer ):
+                    lexer = tokenSource
+        if lexer is None:
+            raise UnsupportedOperationException("Parser can't discover a lexer to use")
+
+        m = ParseTreePatternMatcher(lexer, self)
+        return m.compile(pattern, patternRuleIndex)
+
+
+    def getInputStream(self):
+        return self.getTokenStream()
+
+    def setInputStream(self, input:InputStream):
+        self.setTokenStream(input)
+
+    def getTokenStream(self):
+        return self._input
+
+    # Set the token stream and reset the parser.#
+    def setTokenStream(self, input:TokenStream):
+        self._input = None
+        self.reset()
+        self._input = input
+
+    # Match needs to return the current input symbol, which gets put
+    #  into the label for the associated token ref; e.g., x=ID.
+    #
+    def getCurrentToken(self):
+        return self._input.LT(1)
+
+    def notifyErrorListeners(self, msg:str, offendingToken:Token = None, e:RecognitionException = None):
+        if offendingToken is None:
+            offendingToken = self.getCurrentToken()
+        self._syntaxErrors += 1
+        line = offendingToken.line
+        column = offendingToken.column
+        listener = self.getErrorListenerDispatch()
+        listener.syntaxError(self, offendingToken, line, column, msg, e)
+
+    #
+    # Consume and return the {@linkplain #getCurrentToken current symbol}.
+    #
+    # <p>E.g., given the following input with {@code A} being the current
+    # lookahead symbol, self function moves the cursor to {@code B} and returns
+    # {@code A}.</p>
+    #
+    # <pre>
+    #  A B
+    #  ^
+    # </pre>
+    #
+    # If the parser is not in error recovery mode, the consumed symbol is added
+    # to the parse tree using {@link ParserRuleContext#addChild(Token)}, and
+    # {@link ParseTreeListener#visitTerminal} is called on any parse listeners.
+    # If the parser <em>is</em> in error recovery mode, the consumed symbol is
+    # added to the parse tree using
+    # {@link ParserRuleContext#addErrorNode(Token)}, and
+    # {@link ParseTreeListener#visitErrorNode} is called on any parse
+    # listeners.
+    #
+    def consume(self):
+        o = self.getCurrentToken()
+        if o.type != Token.EOF:
+            self.getInputStream().consume()
+        hasListener = self._parseListeners is not None and len(self._parseListeners)>0
+        if self.buildParseTrees or hasListener:
+            if self._errHandler.inErrorRecoveryMode(self):
+                node = self._ctx.addErrorNode(o)
+            else:
+                node = self._ctx.addTokenNode(o)
+            if hasListener:
+                for listener in self._parseListeners:
+                    listener.visitTerminal(node)
+        return o
+
+    def addContextToParseTree(self):
+        # add current context to parent if we have a parent
+        if self._ctx.parentCtx is not None:
+            self._ctx.parentCtx.addChild(self._ctx)
+
+    # Always called by generated parsers upon entry to a rule. Access field
+    # {@link #_ctx} get the current context.
+    #
+    def enterRule(self, localctx:ParserRuleContext , state:int , ruleIndexint ):
+        self.state = state
+        self._ctx = localctx
+        self._ctx.start = self._input.LT(1)
+        if self.buildParseTrees:
+            self.addContextToParseTree()
+        if self._parseListeners  is not None:
+            self.triggerEnterRuleEvent()
+
+    def exitRule(self):
+        self._ctx.stop = self._input.LT(-1)
+        # trigger event on _ctx, before it reverts to parent
+        if self._parseListeners is not None:
+            self.triggerExitRuleEvent()
+        self.state = self._ctx.invokingState
+        self._ctx = self._ctx.parentCtx
+
+    def enterOuterAlt(self, localctx:ParserRuleContext, altNum:int):
+        localctx.setAltNumber(altNum)
+        # if we have new localctx, make sure we replace existing ctx
+        # that is previous child of parse tree
+        if self.buildParseTrees and self._ctx != localctx:
+            if self._ctx.parentCtx is not None:
+                self._ctx.parentCtx.removeLastChild()
+                self._ctx.parentCtx.addChild(localctx)
+        self._ctx = localctx
+
+    # Get the precedence level for the top-most precedence rule.
+    #
+    # @return The precedence level for the top-most precedence rule, or -1 if
+    # the parser context is not nested within a precedence rule.
+    #
+    def getPrecedence(self):
+        if len(self._precedenceStack)==0:
+            return -1
+        else:
+            return self._precedenceStack[-1]
+
+    def enterRecursionRule(self, localctx:ParserRuleContext, state:int, ruleIndex:int, precedence:int):
+        self.state = state
+        self._precedenceStack.append(precedence)
+        self._ctx = localctx
+        self._ctx.start = self._input.LT(1)
+        if self._parseListeners is not None:
+            self.triggerEnterRuleEvent() # simulates rule entry for left-recursive rules
+
+    #
+    # Like {@link #enterRule} but for recursive rules.
+    #
+    def pushNewRecursionContext(self, localctx:ParserRuleContext, state:int, ruleIndex:int):
+        previous = self._ctx
+        previous.parentCtx = localctx
+        previous.invokingState = state
+        previous.stop = self._input.LT(-1)
+
+        self._ctx = localctx
+        self._ctx.start = previous.start
+        if self.buildParseTrees:
+            self._ctx.addChild(previous)
+
+        if self._parseListeners is not None:
+            self.triggerEnterRuleEvent() # simulates rule entry for left-recursive rules
+
+    def unrollRecursionContexts(self, parentCtx:ParserRuleContext):
+        self._precedenceStack.pop()
+        self._ctx.stop = self._input.LT(-1)
+        retCtx = self._ctx # save current ctx (return value)
+        # unroll so _ctx is as it was before call to recursive method
+        if self._parseListeners is not None:
+            while self._ctx is not parentCtx:
+                self.triggerExitRuleEvent()
+                self._ctx = self._ctx.parentCtx
+        else:
+            self._ctx = parentCtx
+
+        # hook into tree
+        retCtx.parentCtx = parentCtx
+
+        if self.buildParseTrees and parentCtx is not None:
+            # add return ctx into invoking rule's tree
+            parentCtx.addChild(retCtx)
+
+    def getInvokingContext(self, ruleIndex:int):
+        ctx = self._ctx
+        while ctx is not None:
+            if ctx.ruleIndex == ruleIndex:
+                return ctx
+            ctx = ctx.parentCtx
+        return None
+
+
+    def precpred(self, localctx:RuleContext , precedence:int):
+        return precedence >= self._precedenceStack[-1]
+
+    def inContext(self, context:str):
+        # TODO: useful in parser?
+        return False
+
+    #
+    # Checks whether or not {@code symbol} can follow the current state in the
+    # ATN. The behavior of self method is equivalent to the following, but is
+    # implemented such that the complete context-sensitive follow set does not
+    # need to be explicitly constructed.
+    #
+    # <pre>
+    # return getExpectedTokens().contains(symbol);
+    # </pre>
+    #
+    # @param symbol the symbol type to check
+    # @return {@code true} if {@code symbol} can follow the current state in
+    # the ATN, otherwise {@code false}.
+    #
+    def isExpectedToken(self, symbol:int):
+        atn = self._interp.atn
+        ctx = self._ctx
+        s = atn.states[self.state]
+        following = atn.nextTokens(s)
+        if symbol in following:
+            return True
+        if not Token.EPSILON in following:
+            return False
+
+        while ctx is not None and ctx.invokingState>=0 and Token.EPSILON in following:
+            invokingState = atn.states[ctx.invokingState]
+            rt = invokingState.transitions[0]
+            following = atn.nextTokens(rt.followState)
+            if symbol in following:
+                return True
+            ctx = ctx.parentCtx
+
+        if Token.EPSILON in following and symbol == Token.EOF:
+            return True
+        else:
+            return False
+
+    # Computes the set of input symbols which could follow the current parser
+    # state and context, as given by {@link #getState} and {@link #getContext},
+    # respectively.
+    #
+    # @see ATN#getExpectedTokens(int, RuleContext)
+    #
+    def getExpectedTokens(self):
+        return self._interp.atn.getExpectedTokens(self.state, self._ctx)
+
+    def getExpectedTokensWithinCurrentRule(self):
+        atn = self._interp.atn
+        s = atn.states[self.state]
+        return atn.nextTokens(s)
+
+    # Get a rule's index (i.e., {@code RULE_ruleName} field) or -1 if not found.#
+    def getRuleIndex(self, ruleName:str):
+        ruleIndex = self.getRuleIndexMap().get(ruleName, None)
+        if ruleIndex is not None:
+            return ruleIndex
+        else:
+            return -1
+
+    # Return List&lt;String&gt; of the rule names in your parser instance
+    #  leading up to a call to the current rule.  You could override if
+    #  you want more details such as the file/line info of where
+    #  in the ATN a rule is invoked.
+    #
+    #  this is very useful for error messages.
+    #
+    def getRuleInvocationStack(self, p:RuleContext=None):
+        if p is None:
+            p = self._ctx
+        stack = list()
+        while p is not None:
+            # compute what follows who invoked us
+            ruleIndex = p.getRuleIndex()
+            if ruleIndex<0:
+                stack.append("n/a")
+            else:
+                stack.append(self.ruleNames[ruleIndex])
+            p = p.parentCtx
+        return stack
+
+    # For debugging and other purposes.#
+    def getDFAStrings(self):
+        return [ str(dfa) for dfa in self._interp.decisionToDFA]
+
+    # For debugging and other purposes.#
+    def dumpDFA(self):
+        seenOne = False
+        for i in range(0, len(self._interp.decisionToDFA)):
+            dfa = self._interp.decisionToDFA[i]
+            if len(dfa.states)>0:
+                if seenOne:
+                    print()
+                print("Decision " + str(dfa.decision) + ":")
+                print(dfa.toString(self.literalNames, self.symbolicNames), end='')
+                seenOne = True
+
+
+    def getSourceName(self):
+        return self._input.sourceName
+
+    # During a parse is sometimes useful to listen in on the rule entry and exit
+    #  events as well as token matches. self is for quick and dirty debugging.
+    #
+    def setTrace(self, trace:bool):
+        if not trace:
+            self.removeParseListener(self._tracer)
+            self._tracer = None
+        else:
+            if self._tracer is not None:
+                self.removeParseListener(self._tracer)
+            self._tracer = TraceListener(self)
+            self.addParseListener(self._tracer)
diff --git a/runtime/Python3/src/antlr4/ParserInterpreter.py b/runtime/Python3/src/antlr4/ParserInterpreter.py
new file mode 100644
index 000000000..1b6a990ef
--- /dev/null
+++ b/runtime/Python3/src/antlr4/ParserInterpreter.py
@@ -0,0 +1,189 @@
+#
+# [The "BSD license"]
+# Copyright (c) 2013 Terence Parr
+# Copyright (c) 2013 Sam Harwell
+# Copyright (c) 2014 Eric Vergnaud
+# 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 parser simulator that mimics what ANTLR's generated
+#  parser code does. A ParserATNSimulator is used to make
+#  predictions via adaptivePredict but this class moves a pointer through the
+#  ATN to simulate parsing. ParserATNSimulator just
+#  makes us efficient rather than having to backtrack, for example.
+#
+#  This properly creates parse trees even for left recursive rules.
+#
+#  We rely on the left recursive rule invocation and special predicate
+#  transitions to make left recursive rules work.
+#
+#  See TestParserInterpreter for examples.
+#
+from antlr4.dfa.DFA import DFA
+from antlr4.BufferedTokenStream import TokenStream
+from antlr4.Parser import Parser
+from antlr4.ParserRuleContext import InterpreterRuleContext, ParserRuleContext
+from antlr4.Token import Token
+from antlr4.atn.ATN import ATN
+from antlr4.atn.ATNState import StarLoopEntryState, ATNState, LoopEndState
+from antlr4.atn.ParserATNSimulator import ParserATNSimulator
+from antlr4.PredictionContext import PredictionContextCache
+from antlr4.atn.Transition import Transition
+from antlr4.error.Errors import RecognitionException, UnsupportedOperationException, FailedPredicateException
+
+
+class ParserInterpreter(Parser):
+
+    def __init__(self, grammarFileName:str, tokenNames:list, ruleNames:list, atn:ATN, input:TokenStream):
+        super().__init__(input)
+        self.grammarFileName = grammarFileName
+        self.atn = atn
+        self.tokenNames = tokenNames
+        self.ruleNames = ruleNames
+        self.decisionToDFA = [ DFA(state) for state in atn.decisionToState ]
+        self.sharedContextCache = PredictionContextCache()
+        self._parentContextStack = list()
+        # identify the ATN states where pushNewRecursionContext must be called
+        self.pushRecursionContextStates = set()
+        for state in atn.states:
+            if not isinstance(state, StarLoopEntryState):
+                continue
+            if state.precedenceRuleDecision:
+                self.pushRecursionContextStates.add(state.stateNumber)
+        # get atn simulator that knows how to do predictions
+        self._interp = ParserATNSimulator(self, atn, self.decisionToDFA, self.sharedContextCache)
+
+    # Begin parsing at startRuleIndex#
+    def parse(self, startRuleIndex:int):
+        startRuleStartState = self.atn.ruleToStartState[startRuleIndex]
+        rootContext = InterpreterRuleContext(None, ATNState.INVALID_STATE_NUMBER, startRuleIndex)
+        if startRuleStartState.isPrecedenceRule:
+            self.enterRecursionRule(rootContext, startRuleStartState.stateNumber, startRuleIndex, 0)
+        else:
+            self.enterRule(rootContext, startRuleStartState.stateNumber, startRuleIndex)
+        while True:
+            p = self.getATNState()
+            if p.stateType==ATNState.RULE_STOP :
+                # pop; return from rule
+                if len(self._ctx)==0:
+                    if startRuleStartState.isPrecedenceRule:
+                        result = self._ctx
+                        parentContext = self._parentContextStack.pop()
+                        self.unrollRecursionContexts(parentContext.a)
+                        return result
+                    else:
+                        self.exitRule()
+                        return rootContext
+                self.visitRuleStopState(p)
+
+            else:
+                try:
+                    self.visitState(p)
+                except RecognitionException as e:
+                    self.state = self.atn.ruleToStopState[p.ruleIndex].stateNumber
+                    self._ctx.exception = e
+                    self._errHandler.reportError(self, e)
+                    self._errHandler.recover(self, e)
+
+    def enterRecursionRule(self, localctx:ParserRuleContext, state:int, ruleIndex:int, precedence:int):
+        self._parentContextStack.append((self._ctx, localctx.invokingState))
+        super().enterRecursionRule(localctx, state, ruleIndex, precedence)
+
+    def getATNState(self):
+        return self.atn.states[self.state]
+
+    def visitState(self, p:ATNState):
+        edge = 0
+        if len(p.transitions) > 1:
+            self._errHandler.sync(self)
+            edge = self._interp.adaptivePredict(self._input, p.decision, self._ctx)
+        else:
+            edge = 1
+
+        transition = p.transitions[edge - 1]
+        tt = transition.serializationType
+        if tt==Transition.EPSILON:
+
+            if self.pushRecursionContextStates[p.stateNumber] and not isinstance(transition.target, LoopEndState):
+                t = self._parentContextStack[-1]
+                ctx = InterpreterRuleContext(t[0], t[1], self._ctx.ruleIndex)
+                self.pushNewRecursionContext(ctx, self.atn.ruleToStartState[p.ruleIndex].stateNumber, self._ctx.ruleIndex)
+
+        elif tt==Transition.ATOM:
+
+            self.match(transition.label)
+
+        elif tt in [ Transition.RANGE, Transition.SET, Transition.NOT_SET]:
+
+            if not transition.matches(self._input.LA(1), Token.MIN_USER_TOKEN_TYPE, 0xFFFF):
+                self._errHandler.recoverInline(self)
+            self.matchWildcard()
+
+        elif tt==Transition.WILDCARD:
+
+            self.matchWildcard()
+
+        elif tt==Transition.RULE:
+
+            ruleStartState = transition.target
+            ruleIndex = ruleStartState.ruleIndex
+            ctx = InterpreterRuleContext(self._ctx, p.stateNumber, ruleIndex)
+            if ruleStartState.isPrecedenceRule:
+                self.enterRecursionRule(ctx, ruleStartState.stateNumber, ruleIndex, transition.precedence)
+            else:
+                self.enterRule(ctx, transition.target.stateNumber, ruleIndex)
+
+        elif tt==Transition.PREDICATE:
+
+            if not self.sempred(self._ctx, transition.ruleIndex, transition.predIndex):
+                raise FailedPredicateException(self)
+
+        elif tt==Transition.ACTION:
+
+            self.action(self._ctx, transition.ruleIndex, transition.actionIndex)
+
+        elif tt==Transition.PRECEDENCE:
+
+            if not self.precpred(self._ctx, transition.precedence):
+                msg = "precpred(_ctx, " + str(transition.precedence) + ")"
+                raise FailedPredicateException(self, msg)
+
+        else:
+            raise UnsupportedOperationException("Unrecognized ATN transition type.")
+
+        self.state = transition.target.stateNumber
+
+    def visitRuleStopState(self, p:ATNState):
+        ruleStartState = self.atn.ruleToStartState[p.ruleIndex]
+        if ruleStartState.isPrecedenceRule:
+            parentContext = self._parentContextStack.pop()
+            self.unrollRecursionContexts(parentContext.a)
+            self.state = parentContext[1]
+        else:
+            self.exitRule()
+
+        ruleTransition = self.atn.states[self.state].transitions[0]
+        self.state = ruleTransition.followState.stateNumber
diff --git a/runtime/Python3/src/antlr4/ParserRuleContext.py b/runtime/Python3/src/antlr4/ParserRuleContext.py
new file mode 100644
index 000000000..f94448e51
--- /dev/null
+++ b/runtime/Python3/src/antlr4/ParserRuleContext.py
@@ -0,0 +1,193 @@
+# [The "BSD license"]
+#  Copyright (c) 2012 Terence Parr
+#  Copyright (c) 2012 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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 rule invocation record for parsing.
+#
+#  Contains all of the information about the current rule not stored in the
+#  RuleContext. It handles parse tree children list, Any ATN state
+#  tracing, and the default values available for rule indications:
+#  start, stop, rule index, current alt number, current
+#  ATN state.
+#
+#  Subclasses made for each rule and grammar track the parameters,
+#  return values, locals, and labels specific to that rule. These
+#  are the objects that are returned from rules.
+#
+#  Note text is not an actual field of a rule return value; it is computed
+#  from start and stop using the input stream's toString() method.  I
+#  could add a ctor to this so that we can pass in and store the input
+#  stream, but I'm not sure we want to do that.  It would seem to be undefined
+#  to get the .text property anyway if the rule matches tokens from multiple
+#  input streams.
+#
+#  I do not use getters for fields of objects that are used simply to
+#  group values such as this aggregate.  The getters/setters are there to
+#  satisfy the superclass interface.
+
+from antlr4.RuleContext import RuleContext
+from antlr4.Token import Token
+from antlr4.tree.Tree import ParseTreeListener, ParseTree, TerminalNodeImpl, ErrorNodeImpl, TerminalNode, \
+    INVALID_INTERVAL
+
+# need forward declaration
+ParserRuleContext = None
+
+class ParserRuleContext(RuleContext):
+
+    def __init__(self, parent:ParserRuleContext = None, invokingStateNumber:int = None ):
+        super().__init__(parent, invokingStateNumber)
+        #* If we are debugging or building a parse tree for a visitor,
+        #  we need to track all of the tokens and rule invocations associated
+        #  with this rule's context. This is empty for parsing w/o tree constr.
+        #  operation because we don't the need to track the details about
+        #  how we parse this rule.
+        #/
+        self.children = None
+        self.start = None
+        self.stop = None
+        # The exception that forced this rule to return. If the rule successfully
+        # completed, this is {@code null}.
+        self.exception = None
+
+    #* COPY a ctx (I'm deliberately not using copy constructor)#/
+    def copyFrom(self, ctx:ParserRuleContext):
+        # from RuleContext
+        self.parentCtx = ctx.parentCtx
+        self.invokingState = ctx.invokingState
+        self.children = None
+        self.start = ctx.start
+        self.stop = ctx.stop
+
+    # Double dispatch methods for listeners
+    def enterRule(self, listener:ParseTreeListener):
+        pass
+
+    def exitRule(self, listener:ParseTreeListener):
+        pass
+
+    #* Does not set parent link; other add methods do that#/
+    def addChild(self, child:ParseTree):
+        if self.children is None:
+            self.children = []
+        self.children.append(child)
+        return child
+
+    #* Used by enterOuterAlt to toss out a RuleContext previously added as
+    #  we entered a rule. If we have # label, we will need to remove
+    #  generic ruleContext object.
+    #/
+    def removeLastChild(self):
+        if self.children is not None:
+            del self.children[len(self.children)-1]
+
+    def addTokenNode(self, token:Token):
+        node = TerminalNodeImpl(token)
+        self.addChild(node)
+        node.parentCtx = self
+        return node
+
+    def addErrorNode(self, badToken:Token):
+        node = ErrorNodeImpl(badToken)
+        self.addChild(node)
+        node.parentCtx = self
+        return node
+
+    def getChild(self, i:int, ttype:type = None):
+        if ttype is None:
+            return self.children[i] if len(self.children)>=i else None
+        else:
+            for child in self.getChildren():
+                if not isinstance(child, ttype):
+                    continue
+                if i==0:
+                    return child
+                i -= 1
+            return None
+
+    def getChildren(self, predicate = None):
+        if self.children is not None:
+            for child in self.children:
+                if predicate is not None and not predicate(child):
+                    continue
+                yield child
+
+    def getToken(self, ttype:int, i:int):
+        for child in self.getChildren():
+            if not isinstance(child, TerminalNode):
+                continue
+            if child.symbol.type != ttype:
+                continue
+            if i==0:
+                return child
+            i -= 1
+        return None
+
+    def getTokens(self, ttype:int ):
+        if self.getChildren() is None:
+            return []
+        tokens = []
+        for child in self.getChildren():
+            if not isinstance(child, TerminalNode):
+                continue
+            if child.symbol.type != ttype:
+                continue
+            tokens.append(child)
+        return tokens
+
+    def getTypedRuleContext(self, ctxType:type, i:int):
+        return self.getChild(i, ctxType)
+
+    def getTypedRuleContexts(self, ctxType:type):
+        children = self.getChildren()
+        if children is None:
+            return []
+        contexts = []
+        for child in children:
+            if not isinstance(child, ctxType):
+                continue
+            contexts.append(child)
+        return contexts
+
+    def getChildCount(self):
+        return len(self.children) if self.children else 0
+
+    def getSourceInterval(self):
+        if self.start is None or self.stop is None:
+            return INVALID_INTERVAL
+        else:
+            return (self.start.tokenIndex, self.stop.tokenIndex)
+
+
+RuleContext.EMPTY = ParserRuleContext()
+
+class InterpreterRuleContext(ParserRuleContext):
+
+    def __init__(self, parent:ParserRuleContext, invokingStateNumber:int, ruleIndex:int):
+        super().__init__(parent, invokingStateNumber)
+        self.ruleIndex = ruleIndex
diff --git a/runtime/Python3/src/antlr4/PredictionContext.py b/runtime/Python3/src/antlr4/PredictionContext.py
new file mode 100644
index 000000000..a6e643ea4
--- /dev/null
+++ b/runtime/Python3/src/antlr4/PredictionContext.py
@@ -0,0 +1,644 @@
+#
+# [The "BSD license"]
+#  Copyright (c) 2012 Terence Parr
+#  Copyright (c) 2012 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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.
+#/
+from io import StringIO
+from antlr4.RuleContext import RuleContext
+from antlr4.atn.ATN import ATN
+from antlr4.atn.ATNState import ATNState
+
+
+class PredictionContext(object):
+
+    # Represents {@code $} in local context prediction, which means wildcard.
+    # {@code#+x =#}.
+    #/
+    EMPTY = None
+
+    # Represents {@code $} in an array in full context mode, when {@code $}
+    # doesn't mean wildcard: {@code $ + x = [$,x]}. Here,
+    # {@code $} = {@link #EMPTY_RETURN_STATE}.
+    #/
+    EMPTY_RETURN_STATE = 0x7FFFFFFF
+
+    globalNodeCount = 1
+    id = globalNodeCount
+
+    # Stores the computed hash code of this {@link PredictionContext}. The hash
+    # code is computed in parts to match the following reference algorithm.
+    #
+    # <pre>
+    #  private int referenceHashCode() {
+    #      int hash = {@link MurmurHash#initialize MurmurHash.initialize}({@link #INITIAL_HASH});
+    #
+    #      for (int i = 0; i &lt; {@link #size()}; i++) {
+    #          hash = {@link MurmurHash#update MurmurHash.update}(hash, {@link #getParent getParent}(i));
+    #      }
+    #
+    #      for (int i = 0; i &lt; {@link #size()}; i++) {
+    #          hash = {@link MurmurHash#update MurmurHash.update}(hash, {@link #getReturnState getReturnState}(i));
+    #      }
+    #
+    #      hash = {@link MurmurHash#finish MurmurHash.finish}(hash, 2# {@link #size()});
+    #      return hash;
+    #  }
+    # </pre>
+    #/
+    
+    def __init__(self, cachedHashCode:int):
+        self.cachedHashCode = cachedHashCode
+
+    def __len__(self):
+        return 0
+
+    # This means only the {@link #EMPTY} context is in set.
+    def isEmpty(self):
+        return self is self.EMPTY
+
+    def hasEmptyPath(self):
+        return self.getReturnState(len(self) - 1) == self.EMPTY_RETURN_STATE
+
+    def getReturnState(self, index:int):
+        raise "illegal!"
+
+    def __hash__(self):
+        return self.cachedHashCode
+
+def calculateHashCode(parent:PredictionContext, returnState:int):
+    return hash("") if parent is None else hash((hash(parent), returnState))
+
+def calculateListsHashCode(parents:[], returnStates:[] ):
+    h = 0
+    for parent, returnState in parents, returnStates:
+        h = hash((h, calculateHashCode(parent, returnState)))
+    return h
+
+#  Used to cache {@link PredictionContext} objects. Its used for the shared
+#  context cash associated with contexts in DFA states. This cache
+#  can be used for both lexers and parsers.
+
+class PredictionContextCache(object):
+
+    def __init__(self):
+        self.cache = dict()
+
+    #  Add a context to the cache and return it. If the context already exists,
+    #  return that one instead and do not add a new context to the cache.
+    #  Protect shared cache from unsafe thread access.
+    #
+    def add(self, ctx:PredictionContext):
+        if ctx==PredictionContext.EMPTY:
+            return PredictionContext.EMPTY
+        existing = self.cache.get(ctx, None)
+        if existing is not None:
+            return existing
+        self.cache[ctx] = ctx
+        return ctx
+
+    def get(self, ctx:PredictionContext):
+        return self.cache.get(ctx, None)
+
+    def __len__(self):
+        return len(self.cache)
+
+
+class SingletonPredictionContext(PredictionContext):
+
+    @staticmethod
+    def create(parent:PredictionContext , returnState:int ):
+        if returnState == PredictionContext.EMPTY_RETURN_STATE and parent is None:
+            # someone can pass in the bits of an array ctx that mean $
+            return SingletonPredictionContext.EMPTY
+        else:
+            return SingletonPredictionContext(parent, returnState)
+
+    def __init__(self, parent:PredictionContext, returnState:int):
+        hashCode = calculateHashCode(parent, returnState)
+        super().__init__(hashCode)
+        self.parentCtx = parent
+        self.returnState = returnState
+
+    def __len__(self):
+        return 1
+
+    def getParent(self, index:int):
+        return self.parentCtx
+
+    def getReturnState(self, index:int):
+        return self.returnState
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif other is None:
+            return False
+        elif not isinstance(other, SingletonPredictionContext):
+            return False
+        else:
+            return self.returnState == other.returnState and self.parentCtx == other.parentCtx
+
+    def __hash__(self):
+        return self.cachedHashCode
+
+    def __str__(self):
+        up = "" if self.parentCtx is None else str(self.parentCtx)
+        if len(up)==0:
+            if self.returnState == self.EMPTY_RETURN_STATE:
+                return "$"
+            else:
+                return str(self.returnState)
+        else:
+            return str(self.returnState) + " " + up
+
+
+class EmptyPredictionContext(SingletonPredictionContext):
+
+    def __init__(self):
+        super().__init__(None, self.EMPTY_RETURN_STATE)
+
+    def isEmpty(self):
+        return True
+
+    def __eq__(self, other):
+        return self is other
+
+    def __hash__(self):
+        return self.cachedHashCode
+
+    def __str__(self):
+        return "$"
+
+
+PredictionContext.EMPTY = EmptyPredictionContext()
+
+class ArrayPredictionContext(PredictionContext):
+    # Parent can be null only if full ctx mode and we make an array
+    #  from {@link #EMPTY} and non-empty. We merge {@link #EMPTY} by using null parent and
+    #  returnState == {@link #EMPTY_RETURN_STATE}.
+
+    def __init__(self, parents:list, returnStates:list):
+        super().__init__(calculateListsHashCode(parents, returnStates))
+        self.parents = parents
+        self.returnStates = returnStates
+
+    def isEmpty(self):
+        # since EMPTY_RETURN_STATE can only appear in the last position, we
+        # don't need to verify that size==1
+        return self.returnStates[0]==PredictionContext.EMPTY_RETURN_STATE
+
+    def __len__(self):
+        return len(self.returnStates)
+
+    def getParent(self, index:int):
+        return self.parents[index]
+
+    def getReturnState(self, index:int):
+        return self.returnStates[index]
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, ArrayPredictionContext):
+            return False
+        elif hash(self) != hash(other):
+            return False # can't be same if hash is different
+        else:
+            return self.returnStates==other.returnStates and self.parents==other.parents
+
+    def __str__(self):
+        if self.isEmpty():
+            return "[]"
+        with StringIO() as buf:
+            buf.write("[")
+            for i in range(0,len(self.returnStates)):
+                if i>0:
+                    buf.write(", ")
+                if self.returnStates[i]==PredictionContext.EMPTY_RETURN_STATE:
+                    buf.write("$")
+                    continue
+                buf.write(self.returnStates[i])
+                if self.parents[i] is not None:
+                    buf.write(' ')
+                    buf.write(str(self.parents[i]))
+                else:
+                    buf.write("null")
+            buf.write("]")
+            return buf.getvalue()
+
+
+#  Convert a {@link RuleContext} tree to a {@link PredictionContext} graph.
+#  Return {@link #EMPTY} if {@code outerContext} is empty or null.
+#/
+def PredictionContextFromRuleContext(atn:ATN, outerContext:RuleContext=None):
+    if outerContext is None:
+        outerContext = RuleContext.EMPTY
+
+    # if we are in RuleContext of start rule, s, then PredictionContext
+    # is EMPTY. Nobody called us. (if we are empty, return empty)
+    if outerContext.parentCtx is None or outerContext is RuleContext.EMPTY:
+        return PredictionContext.EMPTY
+
+    # If we have a parent, convert it to a PredictionContext graph
+    parent = PredictionContextFromRuleContext(atn, outerContext.parentCtx)
+    state = atn.states[outerContext.invokingState]
+    transition = state.transitions[0]
+    return SingletonPredictionContext.create(parent, transition.followState.stateNumber)
+
+
+def merge(a:PredictionContext, b:PredictionContext, rootIsWildcard:bool, mergeCache:dict):
+
+    # share same graph if both same
+    if a==b:
+        return a
+
+    if isinstance(a, SingletonPredictionContext) and isinstance(b, SingletonPredictionContext):
+        return mergeSingletons(a, b, rootIsWildcard, mergeCache)
+
+    # At least one of a or b is array
+    # If one is $ and rootIsWildcard, return $ as# wildcard
+    if rootIsWildcard:
+        if isinstance( a, EmptyPredictionContext ):
+            return a
+        if isinstance( b, EmptyPredictionContext ):
+            return b
+
+    # convert singleton so both are arrays to normalize
+    if isinstance( a, SingletonPredictionContext ):
+        a = ArrayPredictionContext([a.parentCtx], [a.returnState])
+    if isinstance( b, SingletonPredictionContext):
+        b = ArrayPredictionContext([b.parentCtx], [b.returnState])
+    return mergeArrays(a, b, rootIsWildcard, mergeCache)
+
+
+#
+# Merge two {@link SingletonPredictionContext} instances.
+#
+# <p>Stack tops equal, parents merge is same; return left graph.<br>
+# <embed src="images/SingletonMerge_SameRootSamePar.svg" type="image/svg+xml"/></p>
+#
+# <p>Same stack top, parents differ; merge parents giving array node, then
+# remainders of those graphs. A new root node is created to point to the
+# merged parents.<br>
+# <embed src="images/SingletonMerge_SameRootDiffPar.svg" type="image/svg+xml"/></p>
+#
+# <p>Different stack tops pointing to same parent. Make array node for the
+# root where both element in the root point to the same (original)
+# parent.<br>
+# <embed src="images/SingletonMerge_DiffRootSamePar.svg" type="image/svg+xml"/></p>
+#
+# <p>Different stack tops pointing to different parents. Make array node for
+# the root where each element points to the corresponding original
+# parent.<br>
+# <embed src="images/SingletonMerge_DiffRootDiffPar.svg" type="image/svg+xml"/></p>
+#
+# @param a the first {@link SingletonPredictionContext}
+# @param b the second {@link SingletonPredictionContext}
+# @param rootIsWildcard {@code true} if this is a local-context merge,
+# otherwise false to indicate a full-context merge
+# @param mergeCache
+#/
+def mergeSingletons(a:SingletonPredictionContext, b:SingletonPredictionContext, rootIsWildcard:bool, mergeCache:dict):
+    if mergeCache is not None:
+        previous = mergeCache.get(a,b)
+        if previous is not None:
+            return previous
+        previous = mergeCache.get(b,a)
+        if previous is not None:
+            return previous
+
+    rootMerge = mergeRoot(a, b, rootIsWildcard)
+    if rootMerge is not None:
+        if mergeCache is not None:
+            mergeCache.put(a, b, rootMerge)
+        return rootMerge
+
+    if a.returnState==b.returnState:
+        parent = merge(a.parentCtx, b.parentCtx, rootIsWildcard, mergeCache)
+        # if parent is same as existing a or b parent or reduced to a parent, return it
+        if parent == a.parentCtx:
+            return a # ax + bx = ax, if a=b
+        if parent == b.parentCtx:
+            return b # ax + bx = bx, if a=b
+        # else: ax + ay = a'[x,y]
+        # merge parents x and y, giving array node with x,y then remainders
+        # of those graphs.  dup a, a' points at merged array
+        # new joined parent so create new singleton pointing to it, a'
+        a_ = SingletonPredictionContext.create(parent, a.returnState)
+        if mergeCache is not None:
+            mergeCache.put(a, b, a_)
+        return a_
+    else: # a != b payloads differ
+        # see if we can collapse parents due to $+x parents if local ctx
+        singleParent = None
+        if a is b or (a.parentCtx is not None and a.parentCtx==b.parentCtx): # ax + bx = [a,b]x
+            singleParent = a.parentCtx
+        if singleParent is not None:	# parents are same
+            # sort payloads and use same parent
+            payloads = [ a.returnState, b.returnState ]
+            if a.returnState > b.returnState:
+                payloads[0] = b.returnState
+                payloads[1] = a.returnState
+            parents = [singleParent, singleParent]
+            a_ = ArrayPredictionContext(parents, payloads)
+            if mergeCache is not None:
+                mergeCache.put(a, b, a_)
+            return a_
+        # parents differ and can't merge them. Just pack together
+        # into array; can't merge.
+        # ax + by = [ax,by]
+        payloads = [ a.returnState, b.returnState ]
+        parents = [ a.parentCtx, b.parentCtx ]
+        if a.returnState > b.returnState: # sort by payload
+            payloads[0] = b.returnState
+            payloads[1] = a.returnState
+            parents = [ b.parentCtx, a.parentCtx ]
+        a_ = ArrayPredictionContext(parents, payloads)
+        if mergeCache is not None:
+            mergeCache.put(a, b, a_)
+        return a_
+
+
+#
+# Handle case where at least one of {@code a} or {@code b} is
+# {@link #EMPTY}. In the following diagrams, the symbol {@code $} is used
+# to represent {@link #EMPTY}.
+#
+# <h2>Local-Context Merges</h2>
+#
+# <p>These local-context merge operations are used when {@code rootIsWildcard}
+# is true.</p>
+#
+# <p>{@link #EMPTY} is superset of any graph; return {@link #EMPTY}.<br>
+# <embed src="images/LocalMerge_EmptyRoot.svg" type="image/svg+xml"/></p>
+#
+# <p>{@link #EMPTY} and anything is {@code #EMPTY}, so merged parent is
+# {@code #EMPTY}; return left graph.<br>
+# <embed src="images/LocalMerge_EmptyParent.svg" type="image/svg+xml"/></p>
+#
+# <p>Special case of last merge if local context.<br>
+# <embed src="images/LocalMerge_DiffRoots.svg" type="image/svg+xml"/></p>
+#
+# <h2>Full-Context Merges</h2>
+#
+# <p>These full-context merge operations are used when {@code rootIsWildcard}
+# is false.</p>
+#
+# <p><embed src="images/FullMerge_EmptyRoots.svg" type="image/svg+xml"/></p>
+#
+# <p>Must keep all contexts; {@link #EMPTY} in array is a special value (and
+# null parent).<br>
+# <embed src="images/FullMerge_EmptyRoot.svg" type="image/svg+xml"/></p>
+#
+# <p><embed src="images/FullMerge_SameRoot.svg" type="image/svg+xml"/></p>
+#
+# @param a the first {@link SingletonPredictionContext}
+# @param b the second {@link SingletonPredictionContext}
+# @param rootIsWildcard {@code true} if this is a local-context merge,
+# otherwise false to indicate a full-context merge
+#/
+def mergeRoot(a:SingletonPredictionContext, b:SingletonPredictionContext, rootIsWildcard:bool):
+    if rootIsWildcard:
+        if a == PredictionContext.EMPTY:
+            return PredictionContext.EMPTY  ## + b =#
+        if b == PredictionContext.EMPTY:
+            return PredictionContext.EMPTY  # a +# =#
+    else:
+        if a == PredictionContext.EMPTY and b == PredictionContext.EMPTY:
+            return PredictionContext.EMPTY # $ + $ = $
+        elif a == PredictionContext.EMPTY: # $ + x = [$,x]
+            payloads = [ b.returnState, PredictionContext.EMPTY_RETURN_STATE ]
+            parents = [ b.parentCtx, None ]
+            return ArrayPredictionContext(parents, payloads)
+        elif b == PredictionContext.EMPTY: # x + $ = [$,x] ($ is always first if present)
+            payloads = [ a.returnState, PredictionContext.EMPTY_RETURN_STATE ]
+            parents = [ a.parentCtx, None ]
+            return ArrayPredictionContext(parents, payloads)
+    return None
+
+
+#
+# Merge two {@link ArrayPredictionContext} instances.
+#
+# <p>Different tops, different parents.<br>
+# <embed src="images/ArrayMerge_DiffTopDiffPar.svg" type="image/svg+xml"/></p>
+#
+# <p>Shared top, same parents.<br>
+# <embed src="images/ArrayMerge_ShareTopSamePar.svg" type="image/svg+xml"/></p>
+#
+# <p>Shared top, different parents.<br>
+# <embed src="images/ArrayMerge_ShareTopDiffPar.svg" type="image/svg+xml"/></p>
+#
+# <p>Shared top, all shared parents.<br>
+# <embed src="images/ArrayMerge_ShareTopSharePar.svg" type="image/svg+xml"/></p>
+#
+# <p>Equal tops, merge parents and reduce top to
+# {@link SingletonPredictionContext}.<br>
+# <embed src="images/ArrayMerge_EqualTop.svg" type="image/svg+xml"/></p>
+#/
+def mergeArrays(a:ArrayPredictionContext, b:ArrayPredictionContext, rootIsWildcard:bool, mergeCache:dict):
+    if mergeCache is not None:
+        previous = mergeCache.get(a,b)
+        if previous is not None:
+            return previous
+        previous = mergeCache.get(b,a)
+        if previous is not None:
+            return previous
+
+    # merge sorted payloads a + b => M
+    i = 0 # walks a
+    j = 0 # walks b
+    k = 0 # walks target M array
+
+    mergedReturnStates = [] * (len(a.returnState) + len( b.returnStates))
+    mergedParents = [] * len(mergedReturnStates)
+    # walk and merge to yield mergedParents, mergedReturnStates
+    while i<len(a.returnStates) and j<len(b.returnStates):
+        a_parent = a.parents[i]
+        b_parent = b.parents[j]
+        if a.returnStates[i]==b.returnStates[j]:
+            # same payload (stack tops are equal), must yield merged singleton
+            payload = a.returnStates[i]
+            # $+$ = $
+            bothDollars = payload == PredictionContext.EMPTY_RETURN_STATE and \
+                            a_parent is None and b_parent is None
+            ax_ax = (a_parent is not None and b_parent is not None) and a_parent==b_parent # ax+ax -> ax
+            if bothDollars or ax_ax:
+                mergedParents[k] = a_parent # choose left
+                mergedReturnStates[k] = payload
+            else: # ax+ay -> a'[x,y]
+                mergedParent = merge(a_parent, b_parent, rootIsWildcard, mergeCache)
+                mergedParents[k] = mergedParent
+                mergedReturnStates[k] = payload
+            i += 1 # hop over left one as usual
+            j += 1 # but also skip one in right side since we merge
+        elif a.returnStates[i]<b.returnStates[j]: # copy a[i] to M
+            mergedParents[k] = a_parent
+            mergedReturnStates[k] = a.returnStates[i]
+            i += 1
+        else: # b > a, copy b[j] to M
+            mergedParents[k] = b_parent
+            mergedReturnStates[k] = b.returnStates[j]
+            j += 1
+        k += 1
+
+    # copy over any payloads remaining in either array
+    if i < len(a.returnStates):
+        for p in range(i, len(a.returnStates)):
+            mergedParents[k] = a.parents[p]
+            mergedReturnStates[k] = a.returnStates[p]
+            k += 1
+    else:
+        for p in range(j, len(b.returnStates)):
+            mergedParents[k] = b.parents[p]
+            mergedReturnStates[k] = b.returnStates[p]
+            k += 1
+
+    # trim merged if we combined a few that had same stack tops
+    if k < len(mergedParents): # write index < last position; trim
+        if k == 1: # for just one merged element, return singleton top
+            a_ = SingletonPredictionContext.create(mergedParents[0], mergedReturnStates[0])
+            if mergeCache is not None:
+                mergeCache.put(a,b,a_)
+            return a_
+        mergedParents = mergedParents[0:k]
+        mergedReturnStates = mergedReturnStates[0:k]
+
+    M = ArrayPredictionContext(mergedParents, mergedReturnStates)
+
+    # if we created same array as a or b, return that instead
+    # TODO: track whether this is possible above during merge sort for speed
+    if M==a:
+        if mergeCache is not None:
+            mergeCache.put(a,b,a)
+        return a
+    if M==b:
+        if mergeCache is not None:
+            mergeCache.put(a,b,b)
+        return b
+    combineCommonParents(mergedParents)
+
+    if mergeCache is not None:
+        mergeCache.put(a,b,M)
+    return M
+
+
+#
+# Make pass over all <em>M</em> {@code parents}; merge any {@code equals()}
+# ones.
+#/
+def combineCommonParents(parents:list):
+    uniqueParents = dict()
+
+    for p in range(0, len(parents)):
+        parent = parents[p]
+        if uniqueParents.get(parent, None) is None:
+            uniqueParents[parent] = parent
+
+    for p in range(0, len(parents)):
+        parents[p] = uniqueParents[parents[p]]
+
+def getCachedPredictionContext(context:PredictionContext, contextCache:PredictionContextCache, visited:dict):
+    if context.isEmpty():
+        return context
+    existing = visited.get(context)
+    if existing is not None:
+        return existing
+    existing = contextCache.get(context)
+    if existing is not None:
+        visited[context] = existing
+        return existing
+    changed = False
+    parents = [None] * len(context)
+    for i in range(0, len(parents)):
+        parent = getCachedPredictionContext(context.getParent(i), contextCache, visited)
+        if changed or parent is not context.getParent(i):
+            if not changed:
+                parents = [None] * len(context)
+                for j in range(0, len(context)):
+                    parents[j] = context.getParent(j)
+                changed = True
+            parents[i] = parent
+    if not changed:
+        contextCache.add(context)
+        visited[context] = context
+        return context
+    updated = None
+    if len(parents) == 0:
+        updated = PredictionContext.EMPTY
+    elif len(parents) == 1:
+        updated = SingletonPredictionContext.create(parents[0], context.getReturnState(0))
+    else:
+        updated = ArrayPredictionContext(parents, context.returnStates)
+
+    contextCache.add(updated)
+    visited[updated] = updated
+    visited[context] = updated
+
+    return updated
+
+
+#	# extra structures, but cut/paste/morphed works, so leave it.
+#	# seems to do a breadth-first walk
+#	public static List<PredictionContext> getAllNodes(PredictionContext context) {
+#		Map<PredictionContext, PredictionContext> visited =
+#			new IdentityHashMap<PredictionContext, PredictionContext>();
+#		Deque<PredictionContext> workList = new ArrayDeque<PredictionContext>();
+#		workList.add(context);
+#		visited.put(context, context);
+#		List<PredictionContext> nodes = new ArrayList<PredictionContext>();
+#		while (!workList.isEmpty()) {
+#			PredictionContext current = workList.pop();
+#			nodes.add(current);
+#			for (int i = 0; i < current.size(); i++) {
+#				PredictionContext parent = current.getParent(i);
+#				if ( parent!=null && visited.put(parent, parent) == null) {
+#					workList.push(parent);
+#				}
+#			}
+#		}
+#		return nodes;
+#	}
+
+# ter's recursive version of Sam's getAllNodes()
+def getAllContextNodes(context:PredictionContext, nodes:list=None, visited:dict=None):
+    if nodes is None:
+        nodes = list()
+        return getAllContextNodes(context, nodes, visited)
+    elif visited is None:
+        visited = dict()
+        return getAllContextNodes(context, nodes, visited)
+    else:
+        if context is None or visited.get(context, None) is not None:
+            return nodes
+        visited.put(context, context)
+        nodes.add(context)
+        for i in range(0, len(context)):
+            getAllContextNodes(context.getParent(i), nodes, visited)
+        return nodes
+
diff --git a/runtime/Python3/src/antlr4/Recognizer.py b/runtime/Python3/src/antlr4/Recognizer.py
new file mode 100644
index 000000000..8b31f106e
--- /dev/null
+++ b/runtime/Python3/src/antlr4/Recognizer.py
@@ -0,0 +1,185 @@
+#
+# [The "BSD license"]
+#  Copyright (c) 2012 Terence Parr
+#  Copyright (c) 2012 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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.
+#
+from antlr4.RuleContext import RuleContext
+from antlr4.Token import Token
+from antlr4.error.ErrorListener import ProxyErrorListener, ConsoleErrorListener
+
+# need forward delcaration
+RecognitionException = None
+
+class Recognizer(object):
+
+    tokenTypeMapCache = dict()
+    ruleIndexMapCache = dict()
+
+    def __init__(self):
+        self._listeners = [ ConsoleErrorListener.INSTANCE ]
+        self._interp = None
+        self._stateNumber = -1
+
+    def extractVersion(self, version):
+        pos = version.find(".")
+        major = version[0:pos]
+        version = version[pos+1:]
+        pos = version.find(".")
+        if pos==-1:
+            pos = version.find("-")
+        if pos==-1:
+            pos = len(version)
+        minor = version[0:pos]
+        return major, minor
+
+    def checkVersion(self, toolVersion):
+        runtimeVersion = "4.5.3"
+        rvmajor, rvminor = self.extractVersion(runtimeVersion)
+        tvmajor, tvminor = self.extractVersion(toolVersion)
+        if rvmajor!=tvmajor or rvminor!=tvminor:
+            print("ANTLR runtime and generated code versions disagree: "+runtimeVersion+"!="+toolVersion)
+
+    def addErrorListener(self, listener):
+        self._listeners.append(listener)
+
+    def removeErrorListener(self, listener):
+        self._listeners.remove(listener)
+
+    def removeErrorListeners(self):
+        self._listeners = []
+
+    def getTokenTypeMap(self):
+        tokenNames = self.getTokenNames()
+        if tokenNames is None:
+            from antlr4.error.Errors import UnsupportedOperationException
+            raise UnsupportedOperationException("The current recognizer does not provide a list of token names.")
+        result = self.tokenTypeMapCache.get(tokenNames, None)
+        if result is None:
+            result = zip( tokenNames, range(0, len(tokenNames)))
+            result["EOF"] = Token.EOF
+            self.tokenTypeMapCache[tokenNames] = result
+        return result
+
+    # Get a map from rule names to rule indexes.
+    #
+    # <p>Used for XPath and tree pattern compilation.</p>
+    #
+    def getRuleIndexMap(self):
+        ruleNames = self.getRuleNames()
+        if ruleNames is None:
+            from antlr4.error.Errors import UnsupportedOperationException
+            raise UnsupportedOperationException("The current recognizer does not provide a list of rule names.")
+        result = self.ruleIndexMapCache.get(ruleNames, None)
+        if result is None:
+            result = zip( ruleNames, range(0, len(ruleNames)))
+            self.ruleIndexMapCache[ruleNames] = result
+        return result
+
+    def getTokenType(self, tokenName:str):
+        ttype = self.getTokenTypeMap().get(tokenName, None)
+        if ttype is not None:
+            return ttype
+        else:
+            return Token.INVALID_TYPE
+
+
+    # What is the error header, normally line/character position information?#
+    def getErrorHeader(self, e:RecognitionException):
+        line = e.getOffendingToken().line
+        column = e.getOffendingToken().column
+        return "line "+line+":"+column
+
+
+    # How should a token be displayed in an error message? The default
+    #  is to display just the text, but during development you might
+    #  want to have a lot of information spit out.  Override in that case
+    #  to use t.toString() (which, for CommonToken, dumps everything about
+    #  the token). This is better than forcing you to override a method in
+    #  your token objects because you don't have to go modify your lexer
+    #  so that it creates a new Java type.
+    #
+    # @deprecated This method is not called by the ANTLR 4 Runtime. Specific
+    # implementations of {@link ANTLRErrorStrategy} may provide a similar
+    # feature when necessary. For example, see
+    # {@link DefaultErrorStrategy#getTokenErrorDisplay}.
+    #
+    def getTokenErrorDisplay(self, t:Token):
+        if t is None:
+            return "<no token>"
+        s = t.text
+        if s is None:
+            if t.type==Token.EOF:
+                s = "<EOF>"
+            else:
+                s = "<" + str(t.type) + ">"
+        s = s.replace("\n","\\n")
+        s = s.replace("\r","\\r")
+        s = s.replace("\t","\\t")
+        return "'" + s + "'"
+
+    def getErrorListenerDispatch(self):
+        return ProxyErrorListener(self._listeners)
+
+    # subclass needs to override these if there are sempreds or actions
+    # that the ATN interp needs to execute
+    def sempred(self, localctx:RuleContext, ruleIndex:int, actionIndex:int):
+        return True
+
+    def precpred(self, localctx:RuleContext , precedence:int):
+        return True
+
+    @property
+    def state(self):
+        return self._stateNumber
+
+    # Indicate that the recognizer has changed internal state that is
+    #  consistent with the ATN state passed in.  This way we always know
+    #  where we are in the ATN as the parser goes along. The rule
+    #  context objects form a stack that lets us see the stack of
+    #  invoking rules. Combine this and we have complete ATN
+    #  configuration information.
+
+    @state.setter
+    def state(self, atnState:int):
+        self._stateNumber = atnState
+
+del RecognitionException
+
+import unittest
+class Test(unittest.TestCase):
+
+    def testVersion(self):
+        major, minor = Recognizer().extractVersion("1.2")
+        self.assertEqual("1", major)
+        self.assertEqual("2", minor)
+        major, minor = Recognizer().extractVersion("1.2.3")
+        self.assertEqual("1", major)
+        self.assertEqual("2", minor)
+        major, minor = Recognizer().extractVersion("1.2-snapshot")
+        self.assertEqual("1", major)
+        self.assertEqual("2", minor)
diff --git a/runtime/Python3/src/antlr4/RuleContext.py b/runtime/Python3/src/antlr4/RuleContext.py
new file mode 100644
index 000000000..c8f5ae053
--- /dev/null
+++ b/runtime/Python3/src/antlr4/RuleContext.py
@@ -0,0 +1,253 @@
+# [The "BSD license"]
+#  Copyright (c) 2013 Terence Parr
+#  Copyright (c) 2013 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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 rule context is a record of a single rule invocation. It knows
+#  which context invoked it, if any. If there is no parent context, then
+#  naturally the invoking state is not valid.  The parent link
+#  provides a chain upwards from the current rule invocation to the root
+#  of the invocation tree, forming a stack. We actually carry no
+#  information about the rule associated with this context (except
+#  when parsing). We keep only the state number of the invoking state from
+#  the ATN submachine that invoked this. Contrast this with the s
+#  pointer inside ParserRuleContext that tracks the current state
+#  being "executed" for the current rule.
+#
+#  The parent contexts are useful for computing lookahead sets and
+#  getting error information.
+#
+#  These objects are used during parsing and prediction.
+#  For the special case of parsers, we use the subclass
+#  ParserRuleContext.
+#
+#  @see ParserRuleContext
+#/
+from io import StringIO
+from antlr4.tree.Tree import RuleNode, INVALID_INTERVAL, ParseTreeVisitor
+from antlr4.tree.Trees import Trees
+
+# need forward declarations
+RuleContext = None
+Parser = None
+
+class RuleContext(RuleNode):
+
+    EMPTY = None
+
+    def __init__(self, parent:RuleContext=None, invokingState:int=-1):
+        super().__init__()
+        # What context invoked this rule?
+        self.parentCtx = parent
+        # What state invoked the rule associated with this context?
+        #  The "return address" is the followState of invokingState
+        #  If parent is null, this should be -1.
+        self.invokingState = invokingState
+
+
+    def depth(self):
+        n = 0
+        p = self
+        while p is not None:
+            p = p.parentCtx
+            n += 1
+        return n
+
+    # A context is empty if there is no invoking state; meaning nobody call
+    #  current context.
+    def isEmpty(self):
+        return self.invokingState == -1
+
+    # satisfy the ParseTree / SyntaxTree interface
+
+    def getSourceInterval(self):
+        return INVALID_INTERVAL
+
+    def getRuleContext(self):
+        return self
+
+    def getPayload(self):
+        return self
+
+   # Return the combined text of all child nodes. This method only considers
+    #  tokens which have been added to the parse tree.
+    #  <p>
+    #  Since tokens on hidden channels (e.g. whitespace or comments) are not
+    #  added to the parse trees, they will not appear in the output of this
+    #  method.
+    #/
+    def getText(self):
+        if self.getChildCount() == 0:
+            return ""
+        with StringIO() as builder:
+            for child in self.getChildren():
+                builder.write(child.getText())
+            return builder.getvalue()
+
+    def getRuleIndex(self):
+        return -1
+
+    # For rule associated with this parse tree internal node, return
+    # the outer alternative number used to match the input. Default
+    # implementation does not compute nor store this alt num. Create
+    # a subclass of ParserRuleContext with backing field and set
+    # option contextSuperClass.
+    # to set it.
+    def getAltNumber(self):
+        return 0 # should use ATN.INVALID_ALT_NUMBER but won't compile
+
+    # Set the outer alternative number for this context node. Default
+    # implementation does nothing to avoid backing field overhead for
+    # trees that don't need it.  Create
+    # a subclass of ParserRuleContext with backing field and set
+    # option contextSuperClass.
+    def setAltNumber(self, altNumber:int):
+        pass
+
+    def getChild(self, i:int):
+        return None
+
+    def getChildCount(self):
+        return 0
+
+    def getChildren(self):
+        for c in []:
+            yield c
+
+    def accept(self, visitor:ParseTreeVisitor):
+        return visitor.visitChildren(self)
+
+   # # Call this method to view a parse tree in a dialog box visually.#/
+   #  public Future<JDialog> inspect(@Nullable Parser parser) {
+   #      List<String> ruleNames = parser != null ? Arrays.asList(parser.getRuleNames()) : null;
+   #      return inspect(ruleNames);
+   #  }
+   #
+   #  public Future<JDialog> inspect(@Nullable List<String> ruleNames) {
+   #      TreeViewer viewer = new TreeViewer(ruleNames, this);
+   #      return viewer.open();
+   #  }
+   #
+   # # Save this tree in a postscript file#/
+   #  public void save(@Nullable Parser parser, String fileName)
+   #      throws IOException, PrintException
+   #  {
+   #      List<String> ruleNames = parser != null ? Arrays.asList(parser.getRuleNames()) : null;
+   #      save(ruleNames, fileName);
+   #  }
+   #
+   # # Save this tree in a postscript file using a particular font name and size#/
+   #  public void save(@Nullable Parser parser, String fileName,
+   #                   String fontName, int fontSize)
+   #      throws IOException
+   #  {
+   #      List<String> ruleNames = parser != null ? Arrays.asList(parser.getRuleNames()) : null;
+   #      save(ruleNames, fileName, fontName, fontSize);
+   #  }
+   #
+   # # Save this tree in a postscript file#/
+   #  public void save(@Nullable List<String> ruleNames, String fileName)
+   #      throws IOException, PrintException
+   #  {
+   #      Trees.writePS(this, ruleNames, fileName);
+   #  }
+   #
+   # # Save this tree in a postscript file using a particular font name and size#/
+   #  public void save(@Nullable List<String> ruleNames, String fileName,
+   #                   String fontName, int fontSize)
+   #      throws IOException
+   #  {
+   #      Trees.writePS(this, ruleNames, fileName, fontName, fontSize);
+   #  }
+   #
+   # # Print out a whole tree, not just a node, in LISP format
+   #  #  (root child1 .. childN). Print just a node if this is a leaf.
+   #  #  We have to know the recognizer so we can get rule names.
+   #  #/
+   #  @Override
+   #  public String toStringTree(@Nullable Parser recog) {
+   #      return Trees.toStringTree(this, recog);
+   #  }
+   #
+   # Print out a whole tree, not just a node, in LISP format
+   #  (root child1 .. childN). Print just a node if this is a leaf.
+   #
+    def toStringTree(self, ruleNames:list=None, recog:Parser=None):
+        return Trees.toStringTree(self, ruleNames=ruleNames, recog=recog)
+   #  }
+   #
+   #  @Override
+   #  public String toStringTree() {
+   #      return toStringTree((List<String>)null);
+   #  }
+   #
+    def __str__(self):
+        return self.toString(None, None)
+
+   #  @Override
+   #  public String toString() {
+   #      return toString((List<String>)null, (RuleContext)null);
+   #  }
+   #
+   #  public final String toString(@Nullable Recognizer<?,?> recog) {
+   #      return toString(recog, ParserRuleContext.EMPTY);
+   #  }
+   #
+   #  public final String toString(@Nullable List<String> ruleNames) {
+   #      return toString(ruleNames, null);
+   #  }
+   #
+   #  // recog null unless ParserRuleContext, in which case we use subclass toString(...)
+   #  public String toString(@Nullable Recognizer<?,?> recog, @Nullable RuleContext stop) {
+   #      String[] ruleNames = recog != null ? recog.getRuleNames() : null;
+   #      List<String> ruleNamesList = ruleNames != null ? Arrays.asList(ruleNames) : null;
+   #      return toString(ruleNamesList, stop);
+   #  }
+
+    def toString(self, ruleNames:list, stop:RuleContext)->str:
+        with StringIO() as buf:
+            p = self
+            buf.write("[")
+            while p is not None and p is not stop:
+                if ruleNames is None:
+                    if not p.isEmpty():
+                        buf.write(str(p.invokingState))
+                else:
+                    ri = p.getRuleIndex()
+                    ruleName = ruleNames[ri] if ri >= 0 and ri < len(ruleNames) else str(ri)
+                    buf.write(ruleName)
+
+                if p.parentCtx is not None and (ruleNames is not None or not p.parentCtx.isEmpty()):
+                    buf.write(" ")
+
+                p = p.parentCtx
+
+            buf.write("]")
+            return buf.getvalue()
+
diff --git a/runtime/Python3/src/antlr4/Token.py b/runtime/Python3/src/antlr4/Token.py
new file mode 100644
index 000000000..ec3149687
--- /dev/null
+++ b/runtime/Python3/src/antlr4/Token.py
@@ -0,0 +1,180 @@
+#[The "BSD license"]
+# Copyright (c) 2012 Terence Parr
+# Copyright (c) 2012 Sam Harwell
+# Copyright (c) 2014 Eric Vergnaud
+# 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 token has properties: text, type, line, character position in the line
+# (so we can ignore tabs), token channel, index, and source from which
+# we obtained this token.
+from io import StringIO
+
+
+class Token (object):
+
+    INVALID_TYPE = 0
+
+    # During lookahead operations, this "token" signifies we hit rule end ATN state
+    # and did not follow it despite needing to.
+    EPSILON = -2
+
+    MIN_USER_TOKEN_TYPE = 1
+
+    EOF = -1
+
+    # All tokens go to the parser (unless skip() is called in that rule)
+    # on a particular "channel".  The parser tunes to a particular channel
+    # so that whitespace etc... can go to the parser on a "hidden" channel.
+
+    DEFAULT_CHANNEL = 0
+
+    # Anything on different channel than DEFAULT_CHANNEL is not parsed
+    # by parser.
+
+    HIDDEN_CHANNEL = 1
+
+    def __init__(self):
+        self.source = None
+        self.type = None # token type of the token
+        self.channel = None # The parser ignores everything not on DEFAULT_CHANNEL
+        self.start = None # optional; return -1 if not implemented.
+        self.stop = None  # optional; return -1 if not implemented.
+        self.tokenIndex = None # from 0..n-1 of the token object in the input stream
+        self.line = None # line=1..n of the 1st character
+        self.column = None # beginning of the line at which it occurs, 0..n-1
+        self._text = None # text of the token.
+
+    @property
+    def text(self):
+        return self._text
+
+    # Explicitly set the text for this token. If {code text} is not
+    # {@code null}, then {@link #getText} will return this value rather than
+    # extracting the text from the input.
+    #
+    # @param text The explicit text of the token, or {@code null} if the text
+    # should be obtained from the input along with the start and stop indexes
+    # of the token.
+
+    @text.setter
+    def text(self, text:str):
+        self._text = text
+
+
+    def getTokenSource(self):
+        return self.source[0]
+
+    def getInputStream(self):
+        return self.source[1]
+
+class CommonToken(Token):
+
+
+    # An empty {@link Pair} which is used as the default value of
+    # {@link #source} for tokens that do not have a source.
+    EMPTY_SOURCE = (None, None)
+
+    def __init__(self, source:tuple = EMPTY_SOURCE, type:int = None, channel:int=Token.DEFAULT_CHANNEL, start:int=-1, stop:int=-1):
+        super().__init__()
+        self.source = source
+        self.type = type
+        self.channel = channel
+        self.start = start
+        self.stop = stop
+        self.tokenIndex = -1
+        if source[0] is not None:
+            self.line = source[0].line
+            self.column = source[0].column
+        else:
+            self.column = -1
+
+    # Constructs a new {@link CommonToken} as a copy of another {@link Token}.
+    #
+    # <p>
+    # If {@code oldToken} is also a {@link CommonToken} instance, the newly
+    # constructed token will share a reference to the {@link #text} field and
+    # the {@link Pair} stored in {@link #source}. Otherwise, {@link #text} will
+    # be assigned the result of calling {@link #getText}, and {@link #source}
+    # will be constructed from the result of {@link Token#getTokenSource} and
+    # {@link Token#getInputStream}.</p>
+    #
+    # @param oldToken The token to copy.
+     #
+    def clone(self):
+        t = CommonToken(self.source, self.type, self.channel, self.start, self.stop)
+        t.tokenIndex = self.tokenIndex
+        t.line = self.line
+        t.column = self.column
+        t.text = self.text
+        return t
+
+    @property
+    def text(self):
+        if self._text is not None:
+            return self._text
+        input = self.getInputStream()
+        if input is None:
+            return None
+        n = input.size
+        if self.start < n and self.stop < n:
+            return input.getText(self.start, self.stop)
+        else:
+            return "<EOF>"
+
+    @text.setter
+    def text(self, text:str):
+        self._text = text
+
+    def __str__(self):
+        with StringIO() as buf:
+            buf.write("[@")
+            buf.write(str(self.tokenIndex))
+            buf.write(",")
+            buf.write(str(self.start))
+            buf.write(":")
+            buf.write(str(self.stop))
+            buf.write("='")
+            txt = self.text
+            if txt is not None:
+                txt = txt.replace("\n","\\n")
+                txt = txt.replace("\r","\\r")
+                txt = txt.replace("\t","\\t")
+            else:
+                txt = "<no text>"
+            buf.write(txt)
+            buf.write("',<")
+            buf.write(str(self.type))
+            buf.write(">")
+            if self.channel > 0:
+                buf.write(",channel=")
+                buf.write(str(self.channel))
+            buf.write(",")
+            buf.write(str(self.line))
+            buf.write(":")
+            buf.write(str(self.column))
+            buf.write("]")
+            return buf.getvalue()
diff --git a/runtime/Python3/src/antlr4/Utils.py b/runtime/Python3/src/antlr4/Utils.py
new file mode 100644
index 000000000..f71e74274
--- /dev/null
+++ b/runtime/Python3/src/antlr4/Utils.py
@@ -0,0 +1,58 @@
+#[The "BSD license"]
+# Copyright (c) 2012 Terence Parr
+# Copyright (c) 2012 Sam Harwell
+# Copyright (c) 2014 Eric Vergnaud
+# 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.
+#
+
+from io import StringIO
+
+def str_list(val):
+    with StringIO() as buf:
+        buf.write('[')
+        first = True
+        for item in val:
+            if not first:
+                buf.write(', ')
+            buf.write(str(item))
+            first = False
+        buf.write(']')
+        return buf.getvalue()
+
+def escapeWhitespace(s:str, escapeSpaces:bool):
+    with StringIO() as buf:
+        for c in s:
+            if c==' ' and escapeSpaces:
+                buf.write('\u00B7')
+            elif c=='\t':
+                buf.write("\\t")
+            elif c=='\n':
+                buf.write("\\n")
+            elif c=='\r':
+                buf.write("\\r")
+            else:
+                buf.write(c)
+        return buf.getvalue()
diff --git a/runtime/Python3/src/antlr4/__init__.py b/runtime/Python3/src/antlr4/__init__.py
new file mode 100644
index 000000000..4eac6c579
--- /dev/null
+++ b/runtime/Python3/src/antlr4/__init__.py
@@ -0,0 +1,20 @@
+from antlr4.Token import Token
+from antlr4.InputStream import InputStream
+from antlr4.FileStream import FileStream
+from antlr4.BufferedTokenStream import TokenStream
+from antlr4.CommonTokenStream import CommonTokenStream
+from antlr4.Lexer import Lexer
+from antlr4.Parser import Parser
+from antlr4.dfa.DFA import DFA
+from antlr4.atn.ATN import ATN
+from antlr4.atn.ATNDeserializer import ATNDeserializer
+from antlr4.atn.LexerATNSimulator import LexerATNSimulator
+from antlr4.atn.ParserATNSimulator import ParserATNSimulator
+from antlr4.atn.PredictionMode import PredictionMode
+from antlr4.PredictionContext import PredictionContextCache
+from antlr4.ParserRuleContext import ParserRuleContext
+from antlr4.tree.Tree import ParseTreeListener, ParseTreeVisitor, ParseTreeWalker, TerminalNode, ErrorNode, RuleNode
+from antlr4.error.Errors import RecognitionException, IllegalStateException, NoViableAltException
+from antlr4.error.ErrorStrategy import BailErrorStrategy
+from antlr4.error.DiagnosticErrorListener import DiagnosticErrorListener
+from antlr4.Utils import str_list
\ No newline at end of file
diff --git a/runtime/Python3/src/antlr4/atn/ATN.py b/runtime/Python3/src/antlr4/atn/ATN.py
new file mode 100644
index 000000000..30ca2da84
--- /dev/null
+++ b/runtime/Python3/src/antlr4/atn/ATN.py
@@ -0,0 +1,152 @@
+# [The "BSD license"]
+#  Copyright (c) 2013 Terence Parr
+#  Copyright (c) 2013 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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.
+#/
+from antlr4.IntervalSet import IntervalSet
+
+from antlr4.RuleContext import RuleContext
+
+from antlr4.Token import Token
+from antlr4.atn.ATNType import ATNType
+from antlr4.atn.ATNState import ATNState, DecisionState
+
+
+class ATN(object):
+
+    INVALID_ALT_NUMBER = 0
+
+    # Used for runtime deserialization of ATNs from strings#/
+    def __init__(self, grammarType:ATNType , maxTokenType:int ):
+        # The type of the ATN.
+        self.grammarType = grammarType
+        # The maximum value for any symbol recognized by a transition in the ATN.
+        self.maxTokenType = maxTokenType
+        self.states = []
+        # Each subrule/rule is a decision point and we must track them so we
+        #  can go back later and build DFA predictors for them.  This includes
+        #  all the rules, subrules, optional blocks, ()+, ()* etc...
+        self.decisionToState = []
+        # Maps from rule index to starting state number.
+        self.ruleToStartState = []
+        # Maps from rule index to stop state number.
+        self.ruleToStopState = None
+        self.modeNameToStartState = dict()
+        # For lexer ATNs, this maps the rule index to the resulting token type.
+        # For parser ATNs, this maps the rule index to the generated bypass token
+        # type if the
+        # {@link ATNDeserializationOptions#isGenerateRuleBypassTransitions}
+        # deserialization option was specified; otherwise, this is {@code null}.
+        self.ruleToTokenType = None
+        # For lexer ATNs, this is an array of {@link LexerAction} objects which may
+        # be referenced by action transitions in the ATN.
+        self.lexerActions = None
+        self.modeToStartState = []
+
+    # Compute the set of valid tokens that can occur starting in state {@code s}.
+    #  If {@code ctx} is null, the set of tokens will not include what can follow
+    #  the rule surrounding {@code s}. In other words, the set will be
+    #  restricted to tokens reachable staying within {@code s}'s rule.
+    def nextTokensInContext(self, s:ATNState, ctx:RuleContext):
+        from antlr4.LL1Analyzer import LL1Analyzer
+        anal = LL1Analyzer(self)
+        return anal.LOOK(s, ctx=ctx)
+
+    # Compute the set of valid tokens that can occur starting in {@code s} and
+    # staying in same rule. {@link Token#EPSILON} is in set if we reach end of
+    # rule.
+    def nextTokensNoContext(self, s:ATNState):
+        if s.nextTokenWithinRule is not None:
+            return s.nextTokenWithinRule
+        s.nextTokenWithinRule = self.nextTokensInContext(s, None)
+        s.nextTokenWithinRule.readonly = True
+        return s.nextTokenWithinRule
+
+    def nextTokens(self, s:ATNState, ctx:RuleContext = None):
+        if ctx==None:
+            return self.nextTokensNoContext(s)
+        else:
+            return self.nextTokensInContext(s, ctx)
+
+    def addState(self, state:ATNState):
+        if state is not None:
+            state.atn = self
+            state.stateNumber = len(self.states)
+        self.states.append(state)
+
+    def removeState(self, state:ATNState):
+        self.states[state.stateNumber] = None # just free mem, don't shift states in list
+
+    def defineDecisionState(self, s:DecisionState):
+        self.decisionToState.append(s)
+        s.decision = len(self.decisionToState)-1
+        return s.decision
+
+    def getDecisionState(self, decision:int):
+        if len(self.decisionToState)==0:
+            return None
+        else:
+            return self.decisionToState[decision]
+
+    # Computes the set of input symbols which could follow ATN state number
+    # {@code stateNumber} in the specified full {@code context}. This method
+    # considers the complete parser context, but does not evaluate semantic
+    # predicates (i.e. all predicates encountered during the calculation are
+    # assumed true). If a path in the ATN exists from the starting state to the
+    # {@link RuleStopState} of the outermost context without matching any
+    # symbols, {@link Token#EOF} is added to the returned set.
+    #
+    # <p>If {@code context} is {@code null}, it is treated as
+    # {@link ParserRuleContext#EMPTY}.</p>
+    #
+    # @param stateNumber the ATN state number
+    # @param context the full parse context
+    # @return The set of potentially valid input symbols which could follow the
+    # specified state in the specified context.
+    # @throws IllegalArgumentException if the ATN does not contain a state with
+    # number {@code stateNumber}
+    #/
+    def getExpectedTokens(self, stateNumber:int, ctx:RuleContext ):
+        if stateNumber < 0 or stateNumber >= len(self.states):
+            raise Exception("Invalid state number.")
+        s = self.states[stateNumber]
+        following = self.nextTokens(s)
+        if Token.EPSILON not in following:
+            return following
+        expected = IntervalSet()
+        expected.addSet(following)
+        expected.removeOne(Token.EPSILON)
+        while (ctx != None and ctx.invokingState >= 0 and Token.EPSILON in following):
+            invokingState = self.states[ctx.invokingState]
+            rt = invokingState.transitions[0]
+            following = self.nextTokens(rt.followState)
+            expected.addSet(following)
+            expected.removeOne(Token.EPSILON)
+            ctx = ctx.parentCtx
+        if Token.EPSILON in following:
+            expected.addOne(Token.EOF)
+        return expected
\ No newline at end of file
diff --git a/runtime/Python3/src/antlr4/atn/ATNConfig.py b/runtime/Python3/src/antlr4/atn/ATNConfig.py
new file mode 100644
index 000000000..3eb34d292
--- /dev/null
+++ b/runtime/Python3/src/antlr4/atn/ATNConfig.py
@@ -0,0 +1,155 @@
+#
+# [The "BSD license"]
+#  Copyright (c) 2012 Terence Parr
+#  Copyright (c) 2012 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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 tuple: (ATN state, predicted alt, syntactic, semantic context).
+#  The syntactic context is a graph-structured stack node whose
+#  path(s) to the root is the rule invocation(s)
+#  chain used to arrive at the state.  The semantic context is
+#  the tree of semantic predicates encountered before reaching
+#  an ATN state.
+#/
+from io import StringIO
+from antlr4.PredictionContext import PredictionContext
+from antlr4.atn.ATNState import ATNState, DecisionState
+from antlr4.atn.LexerActionExecutor import LexerActionExecutor
+from antlr4.atn.SemanticContext import SemanticContext
+
+# need a forward declaration
+ATNConfig = None
+
+class ATNConfig(object):
+
+    def __init__(self, state:ATNState=None, alt:int=None, context:PredictionContext=None, semantic:SemanticContext=None, config:ATNConfig=None):
+        if config is not None:
+            if state is None:
+                state = config.state
+            if alt is None:
+                alt = config.alt
+            if context is None:
+                context = config.context
+            if semantic is None:
+                semantic = config.semanticContext
+        if semantic is None:
+            semantic = SemanticContext.NONE
+
+        # The ATN state associated with this configuration#/
+        self.state = state
+        # What alt (or lexer rule) is predicted by this configuration#/
+        self.alt = alt
+        # The stack of invoking states leading to the rule/states associated
+        #  with this config.  We track only those contexts pushed during
+        #  execution of the ATN simulator.
+        self.context = context
+        self.semanticContext = semantic
+        # We cannot execute predicates dependent upon local context unless
+        # we know for sure we are in the correct context. Because there is
+        # no way to do this efficiently, we simply cannot evaluate
+        # dependent predicates unless we are in the rule that initially
+        # invokes the ATN simulator.
+        #
+        # closure() tracks the depth of how far we dip into the
+        # outer context: depth &gt; 0.  Note that it may not be totally
+        # accurate depth since I don't ever decrement. TODO: make it a boolean then
+        self.reachesIntoOuterContext = 0 if config is None else config.reachesIntoOuterContext
+        self.precedenceFilterSuppressed = False if config is None else config.precedenceFilterSuppressed
+
+    # An ATN configuration is equal to another if both have
+    #  the same state, they predict the same alternative, and
+    #  syntactic/semantic contexts are the same.
+    #/
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, ATNConfig):
+            return False
+        else:
+            return self.state.stateNumber==other.state.stateNumber \
+                and self.alt==other.alt \
+                and ((self.context is other.context) or (self.context==other.context)) \
+                and self.semanticContext==other.semanticContext \
+                and self.precedenceFilterSuppressed==other.precedenceFilterSuppressed
+
+    def __hash__(self):
+        return hash((self.state.stateNumber, self.alt, self.context, self.semanticContext))
+
+    def __str__(self):
+        with StringIO() as buf:
+            buf.write('(')
+            buf.write(str(self.state))
+            buf.write(",")
+            buf.write(str(self.alt))
+            if self.context is not None:
+                buf.write(",[")
+                buf.write(str(self.context))
+                buf.write("]")
+            if self.semanticContext is not None and self.semanticContext is not SemanticContext.NONE:
+                buf.write(",")
+                buf.write(str(self.semanticContext))
+            if self.reachesIntoOuterContext>0:
+                buf.write(",up=")
+                buf.write(str(self.reachesIntoOuterContext))
+            buf.write(')')
+            return buf.getvalue()
+
+# need a forward declaration
+LexerATNConfig = None
+
+class LexerATNConfig(ATNConfig):
+
+    def __init__(self, state:ATNState, alt:int=None, context:PredictionContext=None, semantic:SemanticContext=SemanticContext.NONE,
+                 lexerActionExecutor:LexerActionExecutor=None, config:LexerATNConfig=None):
+        super().__init__(state=state, alt=alt, context=context, semantic=semantic, config=config)
+        if config is not None:
+            if lexerActionExecutor is None:
+                lexerActionExecutor = config.lexerActionExecutor
+        # This is the backing field for {@link #getLexerActionExecutor}.
+        self.lexerActionExecutor = lexerActionExecutor
+        self.passedThroughNonGreedyDecision = False if config is None else self.checkNonGreedyDecision(config, state)
+
+    def __hash__(self):
+        return hash((self.state.stateNumber, self.alt, self.context,
+                self.semanticContext, self.passedThroughNonGreedyDecision,
+                self.lexerActionExecutor))
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, LexerATNConfig):
+            return False
+        if self.passedThroughNonGreedyDecision != other.passedThroughNonGreedyDecision:
+            return False
+        if not(self.lexerActionExecutor == other.lexerActionExecutor):
+            return False
+        return super().__eq__(other)
+
+    def checkNonGreedyDecision(self, source:LexerATNConfig, target:ATNState):
+        return source.passedThroughNonGreedyDecision \
+            or isinstance(target, DecisionState) and target.nonGreedy
diff --git a/runtime/Python3/src/antlr4/atn/ATNConfigSet.py b/runtime/Python3/src/antlr4/atn/ATNConfigSet.py
new file mode 100755
index 000000000..1649fcb43
--- /dev/null
+++ b/runtime/Python3/src/antlr4/atn/ATNConfigSet.py
@@ -0,0 +1,239 @@
+#
+# [The "BSD license"]
+#  Copyright (c) 2012 Terence Parr
+#  Copyright (c) 2012 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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.
+
+#
+# Specialized {@link Set}{@code <}{@link ATNConfig}{@code >} that can track
+# info about the set, with support for combining similar configurations using a
+# graph-structured stack.
+#/
+from io import StringIO
+from antlr4.PredictionContext import PredictionContext, merge
+from antlr4.Utils import str_list
+from antlr4.atn.ATN import ATN
+from antlr4.atn.ATNConfig import ATNConfig
+from antlr4.atn.SemanticContext import SemanticContext
+from antlr4.error.Errors import UnsupportedOperationException, IllegalStateException
+
+ATNSimulator = None
+
+class ATNConfigSet(object):
+    #
+    # The reason that we need this is because we don't want the hash map to use
+    # the standard hash code and equals. We need all configurations with the same
+    # {@code (s,i,_,semctx)} to be equal. Unfortunately, this key effectively doubles
+    # the number of objects associated with ATNConfigs. The other solution is to
+    # use a hash table that lets us specify the equals/hashcode operation.
+
+    def __init__(self, fullCtx:bool=True):
+        # All configs but hashed by (s, i, _, pi) not including context. Wiped out
+        # when we go readonly as this set becomes a DFA state.
+        self.configLookup = dict()
+        # Indicates that this configuration set is part of a full context
+        #  LL prediction. It will be used to determine how to merge $. With SLL
+        #  it's a wildcard whereas it is not for LL context merge.
+        self.fullCtx = fullCtx
+        # Indicates that the set of configurations is read-only. Do not
+        #  allow any code to manipulate the set; DFA states will point at
+        #  the sets and they must not change. This does not protect the other
+        #  fields; in particular, conflictingAlts is set after
+        #  we've made this readonly.
+        self.readonly = False
+        # Track the elements as they are added to the set; supports get(i)#/
+        self.configs = []
+
+        # TODO: these fields make me pretty uncomfortable but nice to pack up info together, saves recomputation
+        # TODO: can we track conflicts as they are added to save scanning configs later?
+        self.uniqueAlt = 0
+        self.conflictingAlts = None
+
+        # Used in parser and lexer. In lexer, it indicates we hit a pred
+        # while computing a closure operation.  Don't make a DFA state from this.
+        self.hasSemanticContext = False
+        self.dipsIntoOuterContext = False
+
+        self.cachedHashCode = -1
+
+    def __iter__(self):
+        return self.configs.__iter__()
+
+    # Adding a new config means merging contexts with existing configs for
+    # {@code (s, i, pi, _)}, where {@code s} is the
+    # {@link ATNConfig#state}, {@code i} is the {@link ATNConfig#alt}, and
+    # {@code pi} is the {@link ATNConfig#semanticContext}. We use
+    # {@code (s,i,pi)} as key.
+    #
+    # <p>This method updates {@link #dipsIntoOuterContext} and
+    # {@link #hasSemanticContext} when necessary.</p>
+    #/
+    def add(self, config:ATNConfig, mergeCache=None):
+        if self.readonly:
+            raise Exception("This set is readonly")
+        if config.semanticContext is not SemanticContext.NONE:
+            self.hasSemanticContext = True
+        if config.reachesIntoOuterContext > 0:
+            self.dipsIntoOuterContext = True
+        existing = self.getOrAdd(config)
+        if existing is config:
+            self.cachedHashCode = -1
+            self.configs.append(config)  # track order here
+            return True
+        # a previous (s,i,pi,_), merge with it and save result
+        rootIsWildcard = not self.fullCtx
+        merged = merge(existing.context, config.context, rootIsWildcard, mergeCache)
+        # no need to check for existing.context, config.context in cache
+        # since only way to create new graphs is "call rule" and here. We
+        # cache at both places.
+        existing.reachesIntoOuterContext = max(existing.reachesIntoOuterContext, config.reachesIntoOuterContext)
+        # make sure to preserve the precedence filter suppression during the merge
+        if config.precedenceFilterSuppressed:
+            existing.precedenceFilterSuppressed = True
+        existing.context = merged # replace context; no need to alt mapping
+        return True
+
+    def getOrAdd(self, config:ATNConfig):
+        h = hash(config)
+        l = self.configLookup.get(h, None)
+        if l is not None:
+            for c in l:
+                if c==config:
+                    return c
+        if l is None:
+            l = [config]
+            self.configLookup[h] = l
+        else:
+            l.append(config)
+        return config
+
+    def getStates(self):
+        states = set()
+        for c in self.configs:
+            states.add(c.state)
+        return states
+
+    def getPredicates(self):
+        preds = list()
+        for c in self.configs:
+            if c.semanticContext!=SemanticContext.NONE:
+                preds.append(c.semanticContext)
+        return preds
+
+    def get(self, i:int):
+        return self.configs[i]
+
+    def optimizeConfigs(self, interpreter:ATNSimulator):
+        if self.readonly:
+            raise IllegalStateException("This set is readonly")
+        if len(self.configs)==0:
+            return
+        for config in self.configs:
+            config.context = interpreter.getCachedContext(config.context)
+
+    def addAll(self, coll:list):
+        for c in coll:
+            self.add(c)
+        return False
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, ATNConfigSet):
+            return False
+
+        same = self.configs is not None and \
+            self.configs==other.configs and \
+            self.fullCtx == other.fullCtx and \
+            self.uniqueAlt == other.uniqueAlt and \
+            self.conflictingAlts == other.conflictingAlts and \
+            self.hasSemanticContext == other.hasSemanticContext and \
+            self.dipsIntoOuterContext == other.dipsIntoOuterContext
+
+        return same
+
+    def __hash__(self):
+        if self.readonly:
+            if self.cachedHashCode == -1:
+                self.cachedHashCode = self.hashConfigs()
+            return self.cachedHashCode
+        return self.hashConfigs()
+
+    def hashConfigs(self):
+        h = 0
+        for cfg in self.configs:
+            h = hash((h, cfg))
+        return h
+
+    def __len__(self):
+        return len(self.configs)
+
+    def isEmpty(self):
+        return len(self.configs)==0
+
+    def __contains__(self, config):
+        if self.configLookup is None:
+            raise UnsupportedOperationException("This method is not implemented for readonly sets.")
+        h = hash(config)
+        l = self.configLookup.get(h, None)
+        return l is not None and config in l
+
+    def clear(self):
+        if self.readonly:
+            raise IllegalStateException("This set is readonly")
+        self.configs.clear()
+        self.cachedHashCode = -1
+        self.configLookup.clear()
+
+    def setReadonly(self, readonly:bool):
+        self.readonly = readonly
+        self.configLookup = None # can't mod, no need for lookup cache
+
+    def __str__(self):
+        with StringIO() as buf:
+            buf.write(str_list(self.configs))
+            if self.hasSemanticContext:
+                buf.write(",hasSemanticContext=")
+                buf.write(str(self.hasSemanticContext))
+            if self.uniqueAlt!=ATN.INVALID_ALT_NUMBER:
+                buf.write(",uniqueAlt=")
+                buf.write(str(self.uniqueAlt))
+            if self.conflictingAlts is not None:
+                buf.write(",conflictingAlts=")
+                buf.write(str(self.conflictingAlts))
+            if self.dipsIntoOuterContext:
+                buf.write(",dipsIntoOuterContext")
+            return buf.getvalue()
+
+
+class OrderedATNConfigSet(ATNConfigSet):
+
+    def __init__(self):
+        super().__init__()
+
+
+
diff --git a/runtime/Python3/src/antlr4/atn/ATNDeserializationOptions.py b/runtime/Python3/src/antlr4/atn/ATNDeserializationOptions.py
new file mode 100644
index 000000000..cbfdb44d8
--- /dev/null
+++ b/runtime/Python3/src/antlr4/atn/ATNDeserializationOptions.py
@@ -0,0 +1,49 @@
+#[The "BSD license"]
+# Copyright (c) 2013 Terence Parr
+# Copyright (c) 2013 Sam Harwell
+# Copyright (c) 2014 Eric Vergnaud
+# 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.
+
+# need a forward declaration
+ATNDeserializationOptions = None
+
+class ATNDeserializationOptions(object):
+
+    defaultOptions = None
+
+    def __init__(self, copyFrom:ATNDeserializationOptions = None):
+        self.readOnly = False
+        self.verifyATN = True if copyFrom is None else copyFrom.verifyATN
+        self.generateRuleBypassTransitions = False if copyFrom is None else copyFrom.generateRuleBypassTransitions
+
+    def __setattr__(self, key, value):
+        if key!="readOnly" and self.readOnly:
+            raise Exception("The object is read only.")
+        super(type(self), self).__setattr__(key,value)
+
+ATNDeserializationOptions.defaultOptions = ATNDeserializationOptions()
+ATNDeserializationOptions.defaultOptions.readOnly = True
+
diff --git a/runtime/Python3/src/antlr4/atn/ATNDeserializer.py b/runtime/Python3/src/antlr4/atn/ATNDeserializer.py
new file mode 100644
index 000000000..2c225c3ac
--- /dev/null
+++ b/runtime/Python3/src/antlr4/atn/ATNDeserializer.py
@@ -0,0 +1,543 @@
+# [The "BSD license"]
+#  Copyright (c) 2013 Terence Parr
+#  Copyright (c) 2013 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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.
+#/
+from uuid import UUID
+from io import StringIO
+from antlr4.Token import Token
+from antlr4.atn.ATN import ATN
+from antlr4.atn.ATNType import ATNType
+from antlr4.atn.ATNState import *
+from antlr4.atn.Transition import *
+from antlr4.atn.LexerAction import *
+from antlr4.atn.ATNDeserializationOptions import ATNDeserializationOptions
+
+# This is the earliest supported serialized UUID.
+BASE_SERIALIZED_UUID = UUID("AADB8D7E-AEEF-4415-AD2B-8204D6CF042E")
+
+# This list contains all of the currently supported UUIDs, ordered by when
+# the feature first appeared in this branch.
+SUPPORTED_UUIDS = [ BASE_SERIALIZED_UUID ]
+
+SERIALIZED_VERSION = 3
+
+# This is the current serialized UUID.
+SERIALIZED_UUID = BASE_SERIALIZED_UUID
+
+class ATNDeserializer (object):
+
+    def __init__(self, options : ATNDeserializationOptions = None):
+        if options is None:
+            options = ATNDeserializationOptions.defaultOptions
+        self.deserializationOptions = options
+
+    # Determines if a particular serialized representation of an ATN supports
+    # a particular feature, identified by the {@link UUID} used for serializing
+    # the ATN at the time the feature was first introduced.
+    #
+    # @param feature The {@link UUID} marking the first time the feature was
+    # supported in the serialized ATN.
+    # @param actualUuid The {@link UUID} of the actual serialized ATN which is
+    # currently being deserialized.
+    # @return {@code true} if the {@code actualUuid} value represents a
+    # serialized ATN at or after the feature identified by {@code feature} was
+    # introduced; otherwise, {@code false}.
+
+    def isFeatureSupported(self, feature : UUID , actualUuid : UUID ):
+        idx1 = SUPPORTED_UUIDS.index(feature)
+        if idx1<0:
+            return False
+        idx2 = SUPPORTED_UUIDS.index(actualUuid)
+        return idx2 >= idx1
+
+    def deserialize(self, data : str):
+        self.reset(data)
+        self.checkVersion()
+        self.checkUUID()
+        atn = self.readATN()
+        self.readStates(atn)
+        self.readRules(atn)
+        self.readModes(atn)
+        sets = self.readSets(atn)
+        self.readEdges(atn, sets)
+        self.readDecisions(atn)
+        self.readLexerActions(atn)
+        self.markPrecedenceDecisions(atn)
+        self.verifyATN(atn)
+        if self.deserializationOptions.generateRuleBypassTransitions \
+                and atn.grammarType == ATNType.PARSER:
+            self.generateRuleBypassTransitions(atn)
+            # re-verify after modification
+            self.verifyATN(atn)
+        return atn
+
+    def reset(self, data:str):
+        def adjust(c):
+            v = ord(c)
+            return v-2 if v>1 else -1
+        temp = [ adjust(c) for c in data ]
+        # don't adjust the first value since that's the version number
+        temp[0] = ord(data[0])
+        self.data = temp
+        self.pos = 0
+
+    def checkVersion(self):
+        version = self.readInt()
+        if version != SERIALIZED_VERSION:
+            raise Exception("Could not deserialize ATN with version " + str(version) + " (expected " + str(SERIALIZED_VERSION) + ").")
+
+    def checkUUID(self):
+        uuid = self.readUUID()
+        if not uuid in SUPPORTED_UUIDS:
+            raise Exception("Could not deserialize ATN with UUID: " + str(uuid) + \
+                            " (expected " + str(SERIALIZED_UUID) + " or a legacy UUID).", uuid, SERIALIZED_UUID)
+        self.uuid = uuid
+
+    def readATN(self):
+        idx = self.readInt()
+        grammarType = ATNType.fromOrdinal(idx)
+        maxTokenType = self.readInt()
+        return ATN(grammarType, maxTokenType)
+
+    def readStates(self, atn:ATN):
+        loopBackStateNumbers = []
+        endStateNumbers = []
+        nstates = self.readInt()
+        for i in range(0, nstates):
+            stype = self.readInt()
+            # ignore bad type of states
+            if stype==ATNState.INVALID_TYPE:
+                atn.addState(None)
+                continue
+            ruleIndex = self.readInt()
+            if ruleIndex == 0xFFFF:
+                ruleIndex = -1
+
+            s = self.stateFactory(stype, ruleIndex)
+            if stype == ATNState.LOOP_END: # special case
+                loopBackStateNumber = self.readInt()
+                loopBackStateNumbers.append((s, loopBackStateNumber))
+            elif isinstance(s, BlockStartState):
+                endStateNumber = self.readInt()
+                endStateNumbers.append((s, endStateNumber))
+
+            atn.addState(s)
+
+        # delay the assignment of loop back and end states until we know all the state instances have been initialized
+        for pair in loopBackStateNumbers:
+            pair[0].loopBackState = atn.states[pair[1]]
+
+        for pair in endStateNumbers:
+            pair[0].endState = atn.states[pair[1]]
+
+        numNonGreedyStates = self.readInt()
+        for i in range(0, numNonGreedyStates):
+            stateNumber = self.readInt()
+            atn.states[stateNumber].nonGreedy = True
+
+        numPrecedenceStates = self.readInt()
+        for i in range(0, numPrecedenceStates):
+            stateNumber = self.readInt()
+            atn.states[stateNumber].isPrecedenceRule = True
+            
+    def readRules(self, atn:ATN):        
+        nrules = self.readInt()
+        if atn.grammarType == ATNType.LEXER:
+            atn.ruleToTokenType = [0] * nrules
+
+        atn.ruleToStartState = [0] * nrules
+        for i in range(0, nrules):
+            s = self.readInt()
+            startState = atn.states[s]
+            atn.ruleToStartState[i] = startState
+            if atn.grammarType == ATNType.LEXER:
+                tokenType = self.readInt()
+                if tokenType == 0xFFFF:
+                    tokenType = Token.EOF
+
+                atn.ruleToTokenType[i] = tokenType
+
+        atn.ruleToStopState = [0] * nrules
+        for state in atn.states:
+            if not isinstance(state, RuleStopState):
+                continue
+            atn.ruleToStopState[state.ruleIndex] = state
+            atn.ruleToStartState[state.ruleIndex].stopState = state
+
+    def readModes(self, atn:ATN):
+        nmodes = self.readInt()
+        for i in range(0, nmodes):
+            s = self.readInt()
+            atn.modeToStartState.append(atn.states[s])
+
+    def readSets(self, atn:ATN):
+        sets = []
+        m = self.readInt()
+        for i in range(0, m):
+            iset = IntervalSet()
+            sets.append(iset)
+            n = self.readInt()
+            containsEof = self.readInt()
+            if containsEof!=0:
+                iset.addOne(-1)
+            for j in range(0, n):
+                i1 = self.readInt()
+                i2 = self.readInt()
+                iset.addRange(range(i1, i2 + 1)) # range upper limit is exclusive
+        return sets
+
+    def readEdges(self, atn:ATN, sets:list):
+        nedges = self.readInt()
+        for i in range(0, nedges):
+            src = self.readInt()
+            trg = self.readInt()
+            ttype = self.readInt()
+            arg1 = self.readInt()
+            arg2 = self.readInt()
+            arg3 = self.readInt()
+            trans = self.edgeFactory(atn, ttype, src, trg, arg1, arg2, arg3, sets)
+            srcState = atn.states[src]
+            srcState.addTransition(trans)
+
+        # edges for rule stop states can be derived, so they aren't serialized
+        for state in atn.states:
+            for i in range(0, len(state.transitions)):
+                t = state.transitions[i]
+                if not isinstance(t, RuleTransition):
+                    continue
+                outermostPrecedenceReturn = -1
+                if atn.ruleToStartState[t.target.ruleIndex].isPrecedenceRule:
+                    if t.precedence == 0:
+                        outermostPrecedenceReturn = t.target.ruleIndex
+                trans = EpsilonTransition(t.followState, outermostPrecedenceReturn)
+                atn.ruleToStopState[t.target.ruleIndex].addTransition(trans)
+
+        for state in atn.states:
+            if isinstance(state, BlockStartState):
+                # we need to know the end state to set its start state
+                if state.endState is None:
+                    raise Exception("IllegalState")
+                # block end states can only be associated to a single block start state
+                if state.endState.startState is not None:
+                    raise Exception("IllegalState")
+                state.endState.startState = state
+
+            if isinstance(state, PlusLoopbackState):
+                for i in range(0, len(state.transitions)):
+                    target = state.transitions[i].target
+                    if isinstance(target, PlusBlockStartState):
+                        target.loopBackState = state
+            elif isinstance(state, StarLoopbackState):
+                for i in range(0, len(state.transitions)):
+                    target = state.transitions[i].target
+                    if isinstance(target, StarLoopEntryState):
+                        target.loopBackState = state
+
+    def readDecisions(self, atn:ATN):
+        ndecisions = self.readInt()
+        for i in range(0, ndecisions):
+            s = self.readInt()
+            decState = atn.states[s]
+            atn.decisionToState.append(decState)
+            decState.decision = i
+
+    def readLexerActions(self, atn:ATN):
+        if atn.grammarType == ATNType.LEXER:
+            count = self.readInt()
+            atn.lexerActions = [ None ] * count
+            for i in range(0, count):
+                actionType = self.readInt()
+                data1 = self.readInt()
+                if data1 == 0xFFFF:
+                    data1 = -1
+                data2 = self.readInt()
+                if data2 == 0xFFFF:
+                    data2 = -1
+                lexerAction = self.lexerActionFactory(actionType, data1, data2)
+                atn.lexerActions[i] = lexerAction
+
+    def generateRuleBypassTransitions(self, atn:ATN):
+
+        count = len(atn.ruleToStartState)
+        atn.ruleToTokenType = [ 0 ] * count
+        for i in range(0, count):
+            atn.ruleToTokenType[i] = atn.maxTokenType + i + 1
+
+        for i in range(0, count):
+            self.generateRuleBypassTransition(atn, i)
+
+    def generateRuleBypassTransition(self, atn:ATN, idx:int):
+
+        bypassStart = BasicBlockStartState()
+        bypassStart.ruleIndex = idx
+        atn.addState(bypassStart)
+
+        bypassStop = BlockEndState()
+        bypassStop.ruleIndex = idx
+        atn.addState(bypassStop)
+
+        bypassStart.endState = bypassStop
+        atn.defineDecisionState(bypassStart)
+
+        bypassStop.startState = bypassStart
+
+        excludeTransition = None
+
+        if atn.ruleToStartState[idx].isPrecedenceRule:
+            # wrap from the beginning of the rule to the StarLoopEntryState
+            endState = None
+            for state in atn.states:
+                if self.stateIsEndStateFor(state, idx):
+                    endState = state
+                    excludeTransition = state.loopBackState.transitions[0]
+                    break
+
+            if excludeTransition is None:
+                raise Exception("Couldn't identify final state of the precedence rule prefix section.")
+
+        else:
+
+            endState = atn.ruleToStopState[idx]
+
+        # all non-excluded transitions that currently target end state need to target blockEnd instead
+        for state in atn.states:
+            for transition in state.transitions:
+                if transition == excludeTransition:
+                    continue
+                if transition.target == endState:
+                    transition.target = bypassStop
+
+        # all transitions leaving the rule start state need to leave blockStart instead
+        ruleToStartState = atn.ruleToStartState[idx]
+        count = len(ruleToStartState.transitions)
+        while count > 0:
+            bypassStart.addTransition(ruleToStartState.transitions[count-1])
+            del ruleToStartState.transitions[-1]
+
+        # link the new states
+        atn.ruleToStartState[idx].addTransition(EpsilonTransition(bypassStart))
+        bypassStop.addTransition(EpsilonTransition(endState))
+
+        matchState = BasicState()
+        atn.addState(matchState)
+        matchState.addTransition(AtomTransition(bypassStop, atn.ruleToTokenType[idx]))
+        bypassStart.addTransition(EpsilonTransition(matchState))
+
+
+    def stateIsEndStateFor(self, state:ATNState, idx:int):
+        if state.ruleIndex != idx:
+            return None
+        if not isinstance(state, StarLoopEntryState):
+            return None
+
+        maybeLoopEndState = state.transitions[len(state.transitions) - 1].target
+        if not isinstance(maybeLoopEndState, LoopEndState):
+            return None
+
+        if maybeLoopEndState.epsilonOnlyTransitions and \
+                isinstance(maybeLoopEndState.transitions[0].target, RuleStopState):
+            return state
+        else:
+            return None
+
+
+    #
+    # Analyze the {@link StarLoopEntryState} states in the specified ATN to set
+    # the {@link StarLoopEntryState#precedenceRuleDecision} field to the
+    # correct value.
+    #
+    # @param atn The ATN.
+    #
+    def markPrecedenceDecisions(self, atn:ATN):
+        for state in atn.states:
+            if not isinstance(state, StarLoopEntryState):
+                continue
+
+            # We analyze the ATN to determine if this ATN decision state is the
+            # decision for the closure block that determines whether a
+            # precedence rule should continue or complete.
+            #
+            if atn.ruleToStartState[state.ruleIndex].isPrecedenceRule:
+                maybeLoopEndState = state.transitions[len(state.transitions) - 1].target
+                if isinstance(maybeLoopEndState, LoopEndState):
+                    if maybeLoopEndState.epsilonOnlyTransitions and \
+                            isinstance(maybeLoopEndState.transitions[0].target, RuleStopState):
+                        state.precedenceRuleDecision = True
+
+    def verifyATN(self, atn:ATN):
+        if not self.deserializationOptions.verifyATN:
+            return
+        # verify assumptions
+        for state in atn.states:
+            if state is None:
+                continue
+
+            self.checkCondition(state.epsilonOnlyTransitions or len(state.transitions) <= 1)
+
+            if isinstance(state, PlusBlockStartState):
+                self.checkCondition(state.loopBackState is not None)
+
+            if isinstance(state, StarLoopEntryState):
+                self.checkCondition(state.loopBackState is not None)
+                self.checkCondition(len(state.transitions) == 2)
+
+                if isinstance(state.transitions[0].target, StarBlockStartState):
+                    self.checkCondition(isinstance(state.transitions[1].target, LoopEndState))
+                    self.checkCondition(not state.nonGreedy)
+                elif isinstance(state.transitions[0].target, LoopEndState):
+                    self.checkCondition(isinstance(state.transitions[1].target, StarBlockStartState))
+                    self.checkCondition(state.nonGreedy)
+                else:
+                    raise Exception("IllegalState")
+
+            if isinstance(state, StarLoopbackState):
+                self.checkCondition(len(state.transitions) == 1)
+                self.checkCondition(isinstance(state.transitions[0].target, StarLoopEntryState))
+
+            if isinstance(state, LoopEndState):
+                self.checkCondition(state.loopBackState is not None)
+
+            if isinstance(state, RuleStartState):
+                self.checkCondition(state.stopState is not None)
+
+            if isinstance(state, BlockStartState):
+                self.checkCondition(state.endState is not None)
+
+            if isinstance(state, BlockEndState):
+                self.checkCondition(state.startState is not None)
+
+            if isinstance(state, DecisionState):
+                self.checkCondition(len(state.transitions) <= 1 or state.decision >= 0)
+            else:
+                self.checkCondition(len(state.transitions) <= 1 or isinstance(state, RuleStopState))
+
+    def checkCondition(self, condition:bool, message=None):
+        if not condition:
+            if message is None:
+                message = "IllegalState"
+            raise Exception(message)
+
+    def readInt(self):
+        i = self.data[self.pos]
+        self.pos += 1
+        return i
+
+    def readInt32(self):
+        low = self.readInt()
+        high = self.readInt()
+        return low | (high << 16)
+
+    def readLong(self):
+        low = self.readInt32()
+        high = self.readInt32()
+        return (low & 0x00000000FFFFFFFF) | (high << 32)
+
+    def readUUID(self):
+        low = self.readLong()
+        high = self.readLong()
+        allBits = (low & 0xFFFFFFFFFFFFFFFF) | (high << 64)
+        return UUID(int=allBits)
+
+    edgeFactories = [ lambda args : None,
+                      lambda atn, src, trg, arg1, arg2, arg3, sets, target : EpsilonTransition(target),
+                      lambda atn, src, trg, arg1, arg2, arg3, sets, target : \
+                        RangeTransition(target, Token.EOF, arg2) if arg3 != 0 else RangeTransition(target, arg1, arg2),
+                      lambda atn, src, trg, arg1, arg2, arg3, sets, target : \
+                        RuleTransition(atn.states[arg1], arg2, arg3, target),
+                      lambda atn, src, trg, arg1, arg2, arg3, sets, target : \
+                        PredicateTransition(target, arg1, arg2, arg3 != 0),
+                      lambda atn, src, trg, arg1, arg2, arg3, sets, target : \
+                        AtomTransition(target, Token.EOF) if arg3 != 0 else AtomTransition(target, arg1),
+                      lambda atn, src, trg, arg1, arg2, arg3, sets, target : \
+                        ActionTransition(target, arg1, arg2, arg3 != 0),
+                      lambda atn, src, trg, arg1, arg2, arg3, sets, target : \
+                        SetTransition(target, sets[arg1]),
+                      lambda atn, src, trg, arg1, arg2, arg3, sets, target : \
+                        NotSetTransition(target, sets[arg1]),
+                      lambda atn, src, trg, arg1, arg2, arg3, sets, target : \
+                        WildcardTransition(target),
+                      lambda atn, src, trg, arg1, arg2, arg3, sets, target : \
+                        PrecedencePredicateTransition(target, arg1)
+                      ]
+
+    def edgeFactory(self, atn:ATN, type:int, src:int, trg:int, arg1:int, arg2:int, arg3:int, sets:list):
+        target = atn.states[trg]
+        if type > len(self.edgeFactories) or self.edgeFactories[type] is None:
+            raise Exception("The specified transition type: " + str(type) + " is not valid.")
+        else:
+            return self.edgeFactories[type](atn, src, trg, arg1, arg2, arg3, sets, target)
+
+    stateFactories = [  lambda : None,
+                        lambda : BasicState(),
+                        lambda : RuleStartState(),
+                        lambda : BasicBlockStartState(),
+                        lambda : PlusBlockStartState(),
+                        lambda : StarBlockStartState(),
+                        lambda : TokensStartState(),
+                        lambda : RuleStopState(),
+                        lambda : BlockEndState(),
+                        lambda : StarLoopbackState(),
+                        lambda : StarLoopEntryState(),
+                        lambda : PlusLoopbackState(),
+                        lambda : LoopEndState()
+                    ]
+
+    def stateFactory(self, type:int, ruleIndex:int):
+        if type> len(self.stateFactories) or self.stateFactories[type] is None:
+            raise Exception("The specified state type " + str(type) + " is not valid.")
+        else:
+            s = self.stateFactories[type]()
+            if s is not None:
+                s.ruleIndex = ruleIndex
+        return s
+
+    CHANNEL = 0     #The type of a {@link LexerChannelAction} action.
+    CUSTOM = 1      #The type of a {@link LexerCustomAction} action.
+    MODE = 2        #The type of a {@link LexerModeAction} action.
+    MORE = 3        #The type of a {@link LexerMoreAction} action.
+    POP_MODE = 4    #The type of a {@link LexerPopModeAction} action.
+    PUSH_MODE = 5   #The type of a {@link LexerPushModeAction} action.
+    SKIP = 6        #The type of a {@link LexerSkipAction} action.
+    TYPE = 7        #The type of a {@link LexerTypeAction} action.
+
+    actionFactories = [ lambda data1, data2: LexerChannelAction(data1),
+                        lambda data1, data2: LexerCustomAction(data1, data2),
+                        lambda data1, data2: LexerModeAction(data1),
+                        lambda data1, data2: LexerMoreAction.INSTANCE,
+                        lambda data1, data2: LexerPopModeAction.INSTANCE,
+                        lambda data1, data2: LexerPushModeAction(data1),
+                        lambda data1, data2: LexerSkipAction.INSTANCE,
+                        lambda data1, data2: LexerTypeAction(data1)
+                      ]
+
+    def lexerActionFactory(self, type:int, data1:int, data2:int):
+
+        if type > len(self.actionFactories) or self.actionFactories[type] is None:
+            raise Exception("The specified lexer action type " + str(type) + " is not valid.")
+        else:
+            return self.actionFactories[type](data1, data2)
diff --git a/runtime/Python3/src/antlr4/atn/ATNSimulator.py b/runtime/Python3/src/antlr4/atn/ATNSimulator.py
new file mode 100644
index 000000000..ac5328757
--- /dev/null
+++ b/runtime/Python3/src/antlr4/atn/ATNSimulator.py
@@ -0,0 +1,72 @@
+#
+# [The "BSD license"]
+#  Copyright (c) 2013 Terence Parr
+#  Copyright (c) 2013 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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.
+#/
+from antlr4.PredictionContext import PredictionContextCache, PredictionContext, getCachedPredictionContext
+from antlr4.atn.ATN import ATN
+from antlr4.atn.ATNConfigSet import ATNConfigSet
+from antlr4.dfa.DFAState import DFAState
+
+
+class ATNSimulator(object):
+
+    # Must distinguish between missing edge and edge we know leads nowhere#/
+    ERROR = DFAState(ATNConfigSet())
+    ERROR.stateNumber = 0x7FFFFFFF
+
+    # The context cache maps all PredictionContext objects that are ==
+    #  to a single cached copy. This cache is shared across all contexts
+    #  in all ATNConfigs in all DFA states.  We rebuild each ATNConfigSet
+    #  to use only cached nodes/graphs in addDFAState(). We don't want to
+    #  fill this during closure() since there are lots of contexts that
+    #  pop up but are not used ever again. It also greatly slows down closure().
+    #
+    #  <p>This cache makes a huge difference in memory and a little bit in speed.
+    #  For the Java grammar on java.*, it dropped the memory requirements
+    #  at the end from 25M to 16M. We don't store any of the full context
+    #  graphs in the DFA because they are limited to local context only,
+    #  but apparently there's a lot of repetition there as well. We optimize
+    #  the config contexts before storing the config set in the DFA states
+    #  by literally rebuilding them with cached subgraphs only.</p>
+    #
+    #  <p>I tried a cache for use during closure operations, that was
+    #  whacked after each adaptivePredict(). It cost a little bit
+    #  more time I think and doesn't save on the overall footprint
+    #  so it's not worth the complexity.</p>
+    #/
+    def __init__(self, atn:ATN, sharedContextCache:PredictionContextCache):
+        self.atn = atn
+        self.sharedContextCache = sharedContextCache
+
+    def getCachedContext(self, context:PredictionContext):
+        if self.sharedContextCache is None:
+            return context
+        visited = dict()
+        return getCachedPredictionContext(context, self.sharedContextCache, visited)
+
diff --git a/runtime/Python3/src/antlr4/atn/ATNState.py b/runtime/Python3/src/antlr4/atn/ATNState.py
new file mode 100644
index 000000000..446512193
--- /dev/null
+++ b/runtime/Python3/src/antlr4/atn/ATNState.py
@@ -0,0 +1,282 @@
+#
+# [The "BSD license"]
+#  Copyright (c) 2012 Terence Parr
+#  Copyright (c) 2012 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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.
+#
+
+# The following images show the relation of states and
+# {@link ATNState#transitions} for various grammar constructs.
+#
+# <ul>
+#
+# <li>Solid edges marked with an &#0949; indicate a required
+# {@link EpsilonTransition}.</li>
+#
+# <li>Dashed edges indicate locations where any transition derived from
+# {@link Transition} might appear.</li>
+#
+# <li>Dashed nodes are place holders for either a sequence of linked
+# {@link BasicState} states or the inclusion of a block representing a nested
+# construct in one of the forms below.</li>
+#
+# <li>Nodes showing multiple outgoing alternatives with a {@code ...} support
+# any number of alternatives (one or more). Nodes without the {@code ...} only
+# support the exact number of alternatives shown in the diagram.</li>
+#
+# </ul>
+#
+# <h2>Basic Blocks</h2>
+#
+# <h3>Rule</h3>
+#
+# <embed src="images/Rule.svg" type="image/svg+xml"/>
+#
+# <h3>Block of 1 or more alternatives</h3>
+#
+# <embed src="images/Block.svg" type="image/svg+xml"/>
+#
+# <h2>Greedy Loops</h2>
+#
+# <h3>Greedy Closure: {@code (...)*}</h3>
+#
+# <embed src="images/ClosureGreedy.svg" type="image/svg+xml"/>
+#
+# <h3>Greedy Positive Closure: {@code (...)+}</h3>
+#
+# <embed src="images/PositiveClosureGreedy.svg" type="image/svg+xml"/>
+#
+# <h3>Greedy Optional: {@code (...)?}</h3>
+#
+# <embed src="images/OptionalGreedy.svg" type="image/svg+xml"/>
+#
+# <h2>Non-Greedy Loops</h2>
+#
+# <h3>Non-Greedy Closure: {@code (...)*?}</h3>
+#
+# <embed src="images/ClosureNonGreedy.svg" type="image/svg+xml"/>
+#
+# <h3>Non-Greedy Positive Closure: {@code (...)+?}</h3>
+#
+# <embed src="images/PositiveClosureNonGreedy.svg" type="image/svg+xml"/>
+#
+# <h3>Non-Greedy Optional: {@code (...)??}</h3>
+#
+# <embed src="images/OptionalNonGreedy.svg" type="image/svg+xml"/>
+#
+
+from antlr4.atn.Transition import Transition
+
+INITIAL_NUM_TRANSITIONS = 4
+
+class ATNState(object):
+
+    # constants for serialization
+    INVALID_TYPE = 0
+    BASIC = 1
+    RULE_START = 2
+    BLOCK_START = 3
+    PLUS_BLOCK_START = 4
+    STAR_BLOCK_START = 5
+    TOKEN_START = 6
+    RULE_STOP = 7
+    BLOCK_END = 8
+    STAR_LOOP_BACK = 9
+    STAR_LOOP_ENTRY = 10
+    PLUS_LOOP_BACK = 11
+    LOOP_END = 12
+
+    serializationNames = [
+            "INVALID",
+            "BASIC",
+            "RULE_START",
+            "BLOCK_START",
+            "PLUS_BLOCK_START",
+            "STAR_BLOCK_START",
+            "TOKEN_START",
+            "RULE_STOP",
+            "BLOCK_END",
+            "STAR_LOOP_BACK",
+            "STAR_LOOP_ENTRY",
+            "PLUS_LOOP_BACK",
+            "LOOP_END" ]
+
+    INVALID_STATE_NUMBER = -1
+
+    def __init__(self):
+        # Which ATN are we in?
+        self.atn = None
+        self.stateNumber = ATNState.INVALID_STATE_NUMBER
+        self.stateType = None
+        self.ruleIndex = 0 # at runtime, we don't have Rule objects
+        self.epsilonOnlyTransitions = False
+        # Track the transitions emanating from this ATN state.
+        self.transitions = []
+        # Used to cache lookahead during parsing, not used during construction
+        self.nextTokenWithinRule = None
+
+    def __hash__(self):
+        return self.stateNumber
+
+    def __eq__(self, other):
+        if isinstance(other, ATNState):
+            return self.stateNumber==other.stateNumber
+        else:
+            return False
+
+    def onlyHasEpsilonTransitions(self):
+        return self.epsilonOnlyTransitions
+
+    def isNonGreedyExitState(self):
+        return False
+
+    def __str__(self):
+        return str(self.stateNumber)
+
+    def addTransition(self, trans:Transition, index:int=-1):
+        if len(self.transitions)==0:
+            self.epsilonOnlyTransitions = trans.isEpsilon
+        elif self.epsilonOnlyTransitions != trans.isEpsilon:
+            self.epsilonOnlyTransitions = False
+            # TODO System.err.format(Locale.getDefault(), "ATN state %d has both epsilon and non-epsilon transitions.\n", stateNumber);
+        if index==-1:
+            self.transitions.append(trans)
+        else:
+            self.transitions.insert(index, trans)
+
+class BasicState(ATNState):
+
+    def __init__(self):
+        super().__init__()
+        self.stateType = self.BASIC
+
+
+class DecisionState(ATNState):
+
+    def __init__(self):
+        super().__init__()
+        self.decision = -1
+        self.nonGreedy = False
+
+#  The start of a regular {@code (...)} block.
+class BlockStartState(DecisionState):
+
+    def __init__(self):
+        super().__init__()
+        self.endState = None
+
+class BasicBlockStartState(BlockStartState):
+
+    def __init__(self):
+        super().__init__()
+        self.stateType = self.BLOCK_START
+
+# Terminal node of a simple {@code (a|b|c)} block.
+class BlockEndState(ATNState):
+
+    def __init__(self):
+        super().__init__()
+        self.stateType = self.BLOCK_END
+        self.startState = None
+
+# The last node in the ATN for a rule, unless that rule is the start symbol.
+#  In that case, there is one transition to EOF. Later, we might encode
+#  references to all calls to this rule to compute FOLLOW sets for
+#  error handling.
+#
+class RuleStopState(ATNState):
+
+    def __init__(self):
+        super().__init__()
+        self.stateType = self.RULE_STOP
+
+class RuleStartState(ATNState):
+
+    def __init__(self):
+        super().__init__()
+        self.stateType = self.RULE_START
+        self.stopState = None
+        self.isPrecedenceRule = False
+
+# Decision state for {@code A+} and {@code (A|B)+}.  It has two transitions:
+#  one to the loop back to start of the block and one to exit.
+#
+class PlusLoopbackState(DecisionState):
+
+    def __init__(self):
+        super().__init__()
+        self.stateType = self.PLUS_LOOP_BACK
+
+# Start of {@code (A|B|...)+} loop. Technically a decision state, but
+#  we don't use for code generation; somebody might need it, so I'm defining
+#  it for completeness. In reality, the {@link PlusLoopbackState} node is the
+#  real decision-making note for {@code A+}.
+#
+class PlusBlockStartState(BlockStartState):
+
+    def __init__(self):
+        super().__init__()
+        self.stateType = self.PLUS_BLOCK_START
+        self.loopBackState = None
+
+# The block that begins a closure loop.
+class StarBlockStartState(BlockStartState):
+
+    def __init__(self):
+        super().__init__()
+        self.stateType = self.STAR_BLOCK_START
+
+class StarLoopbackState(ATNState):
+
+    def __init__(self):
+        super().__init__()
+        self.stateType = self.STAR_LOOP_BACK
+
+
+class StarLoopEntryState(DecisionState):
+
+    def __init__(self):
+        super().__init__()
+        self.stateType = self.STAR_LOOP_ENTRY
+        self.loopBackState = None
+        # Indicates whether this state can benefit from a precedence DFA during SLL decision making.
+        self.precedenceRuleDecision = None
+
+# Mark the end of a * or + loop.
+class LoopEndState(ATNState):
+
+    def __init__(self):
+        super().__init__()
+        self.stateType = self.LOOP_END
+        self.loopBackState = None
+
+# The Tokens rule start state linking to each lexer rule start state */
+class TokensStartState(DecisionState):
+
+    def __init__(self):
+        super().__init__()
+        self.stateType = self.TOKEN_START
diff --git a/runtime/Python3/src/antlr4/atn/ATNType.py b/runtime/Python3/src/antlr4/atn/ATNType.py
new file mode 100644
index 000000000..7a6d7b95a
--- /dev/null
+++ b/runtime/Python3/src/antlr4/atn/ATNType.py
@@ -0,0 +1,42 @@
+# [The "BSD license"]
+#  Copyright (c) 2013 Terence Parr
+#  Copyright (c) 2013 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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.
+#/
+
+from enum import IntEnum
+
+# Represents the type of recognizer an ATN applies to.
+
+class ATNType(IntEnum):
+
+    LEXER = 0
+    PARSER = 1
+
+    @classmethod
+    def fromOrdinal(cls, i:int):
+        return cls._value2member_map_[i]
diff --git a/runtime/Python3/src/antlr4/atn/LexerATNSimulator.py b/runtime/Python3/src/antlr4/atn/LexerATNSimulator.py
new file mode 100644
index 000000000..490fe9428
--- /dev/null
+++ b/runtime/Python3/src/antlr4/atn/LexerATNSimulator.py
@@ -0,0 +1,595 @@
+#
+# [The "BSD license"]
+#  Copyright (c) 2012 Terence Parr
+#  Copyright (c) 2012 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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.
+#/
+
+# When we hit an accept state in either the DFA or the ATN, we
+#  have to notify the character stream to start buffering characters
+#  via {@link IntStream#mark} and record the current state. The current sim state
+#  includes the current index into the input, the current line,
+#  and current character position in that line. Note that the Lexer is
+#  tracking the starting line and characterization of the token. These
+#  variables track the "state" of the simulator when it hits an accept state.
+#
+#  <p>We track these variables separately for the DFA and ATN simulation
+#  because the DFA simulation often has to fail over to the ATN
+#  simulation. If the ATN simulation fails, we need the DFA to fall
+#  back to its previously accepted state, if any. If the ATN succeeds,
+#  then the ATN does the accept and the DFA simulator that invoked it
+#  can simply return the predicted token type.</p>
+#/
+
+from antlr4.PredictionContext import PredictionContextCache, SingletonPredictionContext, PredictionContext
+from antlr4.InputStream import InputStream
+from antlr4.Token import Token
+from antlr4.atn.ATN import ATN
+from antlr4.atn.ATNConfig import LexerATNConfig
+from antlr4.atn.ATNSimulator import ATNSimulator
+from antlr4.atn.ATNConfigSet import ATNConfigSet, OrderedATNConfigSet
+from antlr4.atn.ATNState import RuleStopState, ATNState
+from antlr4.atn.LexerActionExecutor import LexerActionExecutor
+from antlr4.atn.Transition import Transition
+from antlr4.dfa.DFAState import DFAState
+from antlr4.error.Errors import LexerNoViableAltException, UnsupportedOperationException
+
+class SimState(object):
+
+    def __init__(self):
+        self.reset()
+
+    def reset(self):
+        self.index = -1
+        self.line = 0
+        self.column = -1
+        self.dfaState = None
+
+# need forward declaration
+Lexer = None
+LexerATNSimulator = None
+
+class LexerATNSimulator(ATNSimulator):
+    
+    debug = False
+    dfa_debug = False
+
+    MIN_DFA_EDGE = 0
+    MAX_DFA_EDGE = 127 # forces unicode to stay in ATN
+
+    ERROR = None
+
+    match_calls = 0
+
+    def __init__(self, recog:Lexer, atn:ATN, decisionToDFA:list, sharedContextCache:PredictionContextCache):
+        super().__init__(atn, sharedContextCache)
+        self.decisionToDFA = decisionToDFA
+        self.recog = recog
+        # The current token's starting index into the character stream.
+        #  Shared across DFA to ATN simulation in case the ATN fails and the
+        #  DFA did not have a previous accept state. In this case, we use the
+        #  ATN-generated exception object.
+        self.startIndex = -1
+        # line number 1..n within the input#/
+        self.line = 1
+        # The index of the character relative to the beginning of the line 0..n-1#/
+        self.column = 0
+        from antlr4.Lexer import Lexer
+        self.mode = Lexer.DEFAULT_MODE
+        # Used during DFA/ATN exec to record the most recent accept configuration info
+        self.prevAccept = SimState()
+
+
+    def copyState(self, simulator:LexerATNSimulator ):
+        self.column = simulator.column
+        self.line = simulator.line
+        self.mode = simulator.mode
+        self.startIndex = simulator.startIndex
+
+    def match(self, input:InputStream , mode:int):
+        self.match_calls += 1
+        self.mode = mode
+        mark = input.mark()
+        try:
+            self.startIndex = input.index
+            self.prevAccept.reset()
+            dfa = self.decisionToDFA[mode]
+            if dfa.s0 is None:
+                return self.matchATN(input)
+            else:
+                return self.execATN(input, dfa.s0)
+        finally:
+            input.release(mark)
+
+    def reset(self):
+        self.prevAccept.reset()
+        self.startIndex = -1
+        self.line = 1
+        self.column = 0
+        from antlr4.Lexer import Lexer
+        self.mode = Lexer.DEFAULT_MODE
+
+    def matchATN(self, input:InputStream):
+        startState = self.atn.modeToStartState[self.mode]
+
+        if self.debug:
+            print("matchATN mode " + str(self.mode) + " start: " + str(startState))
+
+        old_mode = self.mode
+        s0_closure = self.computeStartState(input, startState)
+        suppressEdge = s0_closure.hasSemanticContext
+        s0_closure.hasSemanticContext = False
+
+        next = self.addDFAState(s0_closure)
+        if not suppressEdge:
+            self.decisionToDFA[self.mode].s0 = next
+
+        predict = self.execATN(input, next)
+
+        if self.debug:
+            print("DFA after matchATN: " + str(self.decisionToDFA[old_mode].toLexerString()))
+
+        return predict
+
+    def execATN(self, input:InputStream, ds0:DFAState):
+        if self.debug:
+            print("start state closure=" + str(ds0.configs))
+
+        if ds0.isAcceptState:
+            # allow zero-length tokens
+            self.captureSimState(self.prevAccept, input, ds0)
+
+        t = input.LA(1)
+        s = ds0 # s is current/from DFA state
+
+        while True: # while more work
+            if self.debug:
+                print("execATN loop starting closure: %s\n", s.configs)
+
+            # As we move src->trg, src->trg, we keep track of the previous trg to
+            # avoid looking up the DFA state again, which is expensive.
+            # If the previous target was already part of the DFA, we might
+            # be able to avoid doing a reach operation upon t. If s!=null,
+            # it means that semantic predicates didn't prevent us from
+            # creating a DFA state. Once we know s!=null, we check to see if
+            # the DFA state has an edge already for t. If so, we can just reuse
+            # it's configuration set; there's no point in re-computing it.
+            # This is kind of like doing DFA simulation within the ATN
+            # simulation because DFA simulation is really just a way to avoid
+            # computing reach/closure sets. Technically, once we know that
+            # we have a previously added DFA state, we could jump over to
+            # the DFA simulator. But, that would mean popping back and forth
+            # a lot and making things more complicated algorithmically.
+            # This optimization makes a lot of sense for loops within DFA.
+            # A character will take us back to an existing DFA state
+            # that already has lots of edges out of it. e.g., .* in comments.
+            # print("Target for:" + str(s) + " and:" + str(t))
+            target = self.getExistingTargetState(s, t)
+            # print("Existing:" + str(target))
+            if target is None:
+                target = self.computeTargetState(input, s, t)
+                # print("Computed:" + str(target))
+
+            if target == self.ERROR:
+                break
+
+            # If this is a consumable input element, make sure to consume before
+            # capturing the accept state so the input index, line, and char
+            # position accurately reflect the state of the interpreter at the
+            # end of the token.
+            if t != Token.EOF:
+                self.consume(input)
+
+            if target.isAcceptState:
+                self.captureSimState(self.prevAccept, input, target)
+                if t == Token.EOF:
+                    break
+
+            t = input.LA(1)
+
+            s = target # flip; current DFA target becomes new src/from state
+
+        return self.failOrAccept(self.prevAccept, input, s.configs, t)
+
+    # Get an existing target state for an edge in the DFA. If the target state
+    # for the edge has not yet been computed or is otherwise not available,
+    # this method returns {@code null}.
+    #
+    # @param s The current DFA state
+    # @param t The next input symbol
+    # @return The existing target DFA state for the given input symbol
+    # {@code t}, or {@code null} if the target state for this edge is not
+    # already cached
+    def getExistingTargetState(self, s:DFAState, t:int):
+        if s.edges is None or t < self.MIN_DFA_EDGE or t > self.MAX_DFA_EDGE:
+            return None
+
+        target = s.edges[t - self.MIN_DFA_EDGE]
+        if self.debug and target is not None:
+            print("reuse state "+s.stateNumber+ " edge to "+target.stateNumber)
+
+        return target
+
+    # Compute a target state for an edge in the DFA, and attempt to add the
+    # computed state and corresponding edge to the DFA.
+    #
+    # @param input The input stream
+    # @param s The current DFA state
+    # @param t The next input symbol
+    #
+    # @return The computed target DFA state for the given input symbol
+    # {@code t}. If {@code t} does not lead to a valid DFA state, this method
+    # returns {@link #ERROR}.
+    def computeTargetState(self, input:InputStream, s:DFAState, t:int):
+        reach = OrderedATNConfigSet()
+
+        # if we don't find an existing DFA state
+        # Fill reach starting from closure, following t transitions
+        self.getReachableConfigSet(input, s.configs, reach, t)
+
+        if len(reach)==0: # we got nowhere on t from s
+            if not reach.hasSemanticContext:
+                # we got nowhere on t, don't throw out this knowledge; it'd
+                # cause a failover from DFA later.
+               self. addDFAEdge(s, t, self.ERROR)
+
+            # stop when we can't match any more char
+            return self.ERROR
+
+        # Add an edge from s to target DFA found/created for reach
+        return self.addDFAEdge(s, t, cfgs=reach)
+
+    def failOrAccept(self, prevAccept:SimState , input:InputStream, reach:ATNConfigSet, t:int):
+        if self.prevAccept.dfaState is not None:
+            lexerActionExecutor = prevAccept.dfaState.lexerActionExecutor
+            self.accept(input, lexerActionExecutor, self.startIndex, prevAccept.index, prevAccept.line, prevAccept.column)
+            return prevAccept.dfaState.prediction
+        else:
+            # if no accept and EOF is first char, return EOF
+            if t==Token.EOF and input.index==self.startIndex:
+                return Token.EOF
+            raise LexerNoViableAltException(self.recog, input, self.startIndex, reach)
+
+    # Given a starting configuration set, figure out all ATN configurations
+    #  we can reach upon input {@code t}. Parameter {@code reach} is a return
+    #  parameter.
+    def getReachableConfigSet(self, input:InputStream, closure:ATNConfigSet, reach:ATNConfigSet, t:int):
+        # this is used to skip processing for configs which have a lower priority
+        # than a config that already reached an accept state for the same rule
+        skipAlt = ATN.INVALID_ALT_NUMBER
+        for cfg in closure:
+            currentAltReachedAcceptState = ( cfg.alt == skipAlt )
+            if currentAltReachedAcceptState and cfg.passedThroughNonGreedyDecision:
+                continue
+
+            if self.debug:
+                print("testing %s at %s\n", self.getTokenName(t), cfg.toString(self.recog, True))
+
+            for trans in cfg.state.transitions:          # for each transition
+                target = self.getReachableTarget(trans, t)
+                if target is not None:
+                    lexerActionExecutor = cfg.lexerActionExecutor
+                    if lexerActionExecutor is not None:
+                        lexerActionExecutor = lexerActionExecutor.fixOffsetBeforeMatch(input.index - self.startIndex)
+
+                    treatEofAsEpsilon = (t == Token.EOF)
+                    config = LexerATNConfig(state=target, lexerActionExecutor=lexerActionExecutor, config=cfg)
+                    if self.closure(input, config, reach, currentAltReachedAcceptState, True, treatEofAsEpsilon):
+                        # any remaining configs for this alt have a lower priority than
+                        # the one that just reached an accept state.
+                        skipAlt = cfg.alt
+
+    def accept(self, input:InputStream, lexerActionExecutor:LexerActionExecutor, startIndex:int, index:int, line:int, charPos:int):
+        if self.debug:
+            print("ACTION %s\n", lexerActionExecutor)
+
+        # seek to after last char in token
+        input.seek(index)
+        self.line = line
+        self.column = charPos
+
+        if lexerActionExecutor is not None and self.recog is not None:
+            lexerActionExecutor.execute(self.recog, input, startIndex)
+
+    def getReachableTarget(self, trans:Transition, t:int):
+        if trans.matches(t, 0, 0xFFFE):
+            return trans.target
+        else:
+            return None
+
+    def computeStartState(self, input:InputStream, p:ATNState):
+        initialContext = PredictionContext.EMPTY
+        configs = OrderedATNConfigSet()
+        for i in range(0,len(p.transitions)):
+            target = p.transitions[i].target
+            c = LexerATNConfig(state=target, alt=i+1, context=initialContext)
+            self.closure(input, c, configs, False, False, False)
+        return configs
+
+    # Since the alternatives within any lexer decision are ordered by
+    # preference, this method stops pursuing the closure as soon as an accept
+    # state is reached. After the first accept state is reached by depth-first
+    # search from {@code config}, all other (potentially reachable) states for
+    # this rule would have a lower priority.
+    #
+    # @return {@code true} if an accept state is reached, otherwise
+    # {@code false}.
+    def closure(self, input:InputStream, config:LexerATNConfig, configs:ATNConfigSet, currentAltReachedAcceptState:bool,
+                speculative:bool, treatEofAsEpsilon:bool):
+        if self.debug:
+            print("closure("+config.toString(self.recog, True)+")")
+
+        if isinstance( config.state, RuleStopState ):
+            if self.debug:
+                if self.recog is not None:
+                    print("closure at %s rule stop %s\n", self.recog.getRuleNames()[config.state.ruleIndex], config)
+                else:
+                    print("closure at rule stop %s\n", config)
+
+            if config.context is None or config.context.hasEmptyPath():
+                if config.context is None or config.context.isEmpty():
+                    configs.add(config)
+                    return True
+                else:
+                    configs.add(LexerATNConfig(state=config.state, config=config, context=PredictionContext.EMPTY))
+                    currentAltReachedAcceptState = True
+
+            if config.context is not None and not config.context.isEmpty():
+                for i in range(0,len(config.context)):
+                    if config.context.getReturnState(i) != PredictionContext.EMPTY_RETURN_STATE:
+                        newContext = config.context.getParent(i) # "pop" return state
+                        returnState = self.atn.states[config.context.getReturnState(i)]
+                        c = LexerATNConfig(state=returnState, config=config, context=newContext)
+                        currentAltReachedAcceptState = self.closure(input, c, configs,
+                                    currentAltReachedAcceptState, speculative, treatEofAsEpsilon)
+
+            return currentAltReachedAcceptState
+
+        # optimization
+        if not config.state.epsilonOnlyTransitions:
+            if not currentAltReachedAcceptState or not config.passedThroughNonGreedyDecision:
+                configs.add(config)
+
+        for t in config.state.transitions:
+            c = self.getEpsilonTarget(input, config, t, configs, speculative, treatEofAsEpsilon)
+            if c is not None:
+                currentAltReachedAcceptState = self.closure(input, c, configs, currentAltReachedAcceptState, speculative, treatEofAsEpsilon)
+
+        return currentAltReachedAcceptState
+
+    # side-effect: can alter configs.hasSemanticContext
+    def getEpsilonTarget(self, input:InputStream, config:LexerATNConfig, t:Transition, configs:ATNConfigSet,
+                                           speculative:bool, treatEofAsEpsilon:bool):
+        c = None
+        if t.serializationType==Transition.RULE:
+                newContext = SingletonPredictionContext.create(config.context, t.followState.stateNumber)
+                c = LexerATNConfig(state=t.target, config=config, context=newContext)
+
+        elif t.serializationType==Transition.PRECEDENCE:
+                raise UnsupportedOperationException("Precedence predicates are not supported in lexers.")
+
+        elif t.serializationType==Transition.PREDICATE:
+                #  Track traversing semantic predicates. If we traverse,
+                # we cannot add a DFA state for this "reach" computation
+                # because the DFA would not test the predicate again in the
+                # future. Rather than creating collections of semantic predicates
+                # like v3 and testing them on prediction, v4 will test them on the
+                # fly all the time using the ATN not the DFA. This is slower but
+                # semantically it's not used that often. One of the key elements to
+                # this predicate mechanism is not adding DFA states that see
+                # predicates immediately afterwards in the ATN. For example,
+
+                # a : ID {p1}? | ID {p2}? ;
+
+                # should create the start state for rule 'a' (to save start state
+                # competition), but should not create target of ID state. The
+                # collection of ATN states the following ID references includes
+                # states reached by traversing predicates. Since this is when we
+                # test them, we cannot cash the DFA state target of ID.
+
+                if self.debug:
+                    print("EVAL rule "+ str(t.ruleIndex) + ":" + str(t.predIndex))
+                configs.hasSemanticContext = True
+                if self.evaluatePredicate(input, t.ruleIndex, t.predIndex, speculative):
+                    c = LexerATNConfig(state=t.target, config=config)
+
+        elif t.serializationType==Transition.ACTION:
+                if config.context is None or config.context.hasEmptyPath():
+                    # execute actions anywhere in the start rule for a token.
+                    #
+                    # TODO: if the entry rule is invoked recursively, some
+                    # actions may be executed during the recursive call. The
+                    # problem can appear when hasEmptyPath() is true but
+                    # isEmpty() is false. In this case, the config needs to be
+                    # split into two contexts - one with just the empty path
+                    # and another with everything but the empty path.
+                    # Unfortunately, the current algorithm does not allow
+                    # getEpsilonTarget to return two configurations, so
+                    # additional modifications are needed before we can support
+                    # the split operation.
+                    lexerActionExecutor = LexerActionExecutor.append(config.lexerActionExecutor,
+                                    self.atn.lexerActions[t.actionIndex])
+                    c = LexerATNConfig(state=t.target, config=config, lexerActionExecutor=lexerActionExecutor)
+
+                else:
+                    # ignore actions in referenced rules
+                    c = LexerATNConfig(state=t.target, config=config)
+
+        elif t.serializationType==Transition.EPSILON:
+            c = LexerATNConfig(state=t.target, config=config)
+
+        elif t.serializationType in [ Transition.ATOM, Transition.RANGE, Transition.SET ]:
+            if treatEofAsEpsilon:
+                if t.matches(Token.EOF, 0, 0xFFFF):
+                    c = LexerATNConfig(state=t.target, config=config)
+
+        return c
+
+    # Evaluate a predicate specified in the lexer.
+    #
+    # <p>If {@code speculative} is {@code true}, this method was called before
+    # {@link #consume} for the matched character. This method should call
+    # {@link #consume} before evaluating the predicate to ensure position
+    # sensitive values, including {@link Lexer#getText}, {@link Lexer#getLine},
+    # and {@link Lexer#getcolumn}, properly reflect the current
+    # lexer state. This method should restore {@code input} and the simulator
+    # to the original state before returning (i.e. undo the actions made by the
+    # call to {@link #consume}.</p>
+    #
+    # @param input The input stream.
+    # @param ruleIndex The rule containing the predicate.
+    # @param predIndex The index of the predicate within the rule.
+    # @param speculative {@code true} if the current index in {@code input} is
+    # one character before the predicate's location.
+    #
+    # @return {@code true} if the specified predicate evaluates to
+    # {@code true}.
+    #/
+    def evaluatePredicate(self, input:InputStream, ruleIndex:int, predIndex:int, speculative:bool):
+        # assume true if no recognizer was provided
+        if self.recog is None:
+            return True
+
+        if not speculative:
+            return self.recog.sempred(None, ruleIndex, predIndex)
+
+        savedcolumn = self.column
+        savedLine = self.line
+        index = input.index
+        marker = input.mark()
+        try:
+            self.consume(input)
+            return self.recog.sempred(None, ruleIndex, predIndex)
+        finally:
+            self.column = savedcolumn
+            self.line = savedLine
+            input.seek(index)
+            input.release(marker)
+
+    def captureSimState(self, settings:SimState, input:InputStream, dfaState:DFAState):
+        settings.index = input.index
+        settings.line = self.line
+        settings.column = self.column
+        settings.dfaState = dfaState
+
+    def addDFAEdge(self, from_:DFAState, tk:int, to:DFAState=None, cfgs:ATNConfigSet=None) -> DFAState:
+
+        if to is None and cfgs is not None:
+            # leading to this call, ATNConfigSet.hasSemanticContext is used as a
+            # marker indicating dynamic predicate evaluation makes this edge
+            # dependent on the specific input sequence, so the static edge in the
+            # DFA should be omitted. The target DFAState is still created since
+            # execATN has the ability to resynchronize with the DFA state cache
+            # following the predicate evaluation step.
+            #
+            # TJP notes: next time through the DFA, we see a pred again and eval.
+            # If that gets us to a previously created (but dangling) DFA
+            # state, we can continue in pure DFA mode from there.
+            #/
+            suppressEdge = cfgs.hasSemanticContext
+            cfgs.hasSemanticContext = False
+
+            to = self.addDFAState(cfgs)
+
+            if suppressEdge:
+                return to
+
+        # add the edge
+        if tk < self.MIN_DFA_EDGE or tk > self.MAX_DFA_EDGE:
+            # Only track edges within the DFA bounds
+            return to
+
+        if self.debug:
+            print("EDGE " + str(from_) + " -> " + str(to) + " upon "+ chr(tk))
+
+        if from_.edges is None:
+            #  make room for tokens 1..n and -1 masquerading as index 0
+            from_.edges = [ None ] * (self.MAX_DFA_EDGE - self.MIN_DFA_EDGE + 1)
+
+        from_.edges[tk - self.MIN_DFA_EDGE] = to # connect
+
+        return to
+
+
+    # Add a new DFA state if there isn't one with this set of
+    # configurations already. This method also detects the first
+    # configuration containing an ATN rule stop state. Later, when
+    # traversing the DFA, we will know which rule to accept.
+    def addDFAState(self, configs:ATNConfigSet) -> DFAState:
+
+        proposed = DFAState(configs=configs)
+        firstConfigWithRuleStopState = None
+        for c in configs:
+            if isinstance(c.state, RuleStopState):
+                firstConfigWithRuleStopState = c
+                break
+
+        if firstConfigWithRuleStopState is not None:
+            proposed.isAcceptState = True
+            proposed.lexerActionExecutor = firstConfigWithRuleStopState.lexerActionExecutor
+            proposed.prediction = self.atn.ruleToTokenType[firstConfigWithRuleStopState.state.ruleIndex]
+
+        dfa = self.decisionToDFA[self.mode]
+        existing = dfa.states.get(proposed, None)
+        if existing is not None:
+            return existing
+
+        newState = proposed
+
+        newState.stateNumber = len(dfa.states)
+        configs.setReadonly(True)
+        newState.configs = configs
+        dfa.states[newState] = newState
+        return newState
+
+    def getDFA(self, mode:int):
+        return self.decisionToDFA[mode]
+
+    # Get the text matched so far for the current token.
+    def getText(self, input:InputStream):
+        # index is first lookahead char, don't include.
+        return input.getText(self.startIndex, input.index-1)
+
+    def consume(self, input:InputStream):
+        curChar = input.LA(1)
+        if curChar==ord('\n'):
+            self.line += 1
+            self.column = 0
+        else:
+            self.column += 1
+        input.consume()
+
+    def getTokenName(self, t:int):
+        if t==-1:
+            return "EOF"
+        else:
+            return "'" + chr(t) + "'"
+
+
+LexerATNSimulator.ERROR = DFAState(0x7FFFFFFF, ATNConfigSet())
+
+del Lexer
\ No newline at end of file
diff --git a/runtime/Python3/src/antlr4/atn/LexerAction.py b/runtime/Python3/src/antlr4/atn/LexerAction.py
new file mode 100644
index 000000000..7e503c975
--- /dev/null
+++ b/runtime/Python3/src/antlr4/atn/LexerAction.py
@@ -0,0 +1,316 @@
+#
+ #[The "BSD license"]
+ # Copyright (c) 2013 Terence Parr
+ # Copyright (c) 2013 Sam Harwell
+ # Copyright (c) 2014 Eric Vergnaud
+ # 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.
+ #
+
+from enum import IntEnum
+
+# need forward declaration
+Lexer = None
+
+
+class LexerActionType(IntEnum):
+
+    CHANNEL = 0     #The type of a {@link LexerChannelAction} action.
+    CUSTOM = 1      #The type of a {@link LexerCustomAction} action.
+    MODE = 2        #The type of a {@link LexerModeAction} action.
+    MORE = 3        #The type of a {@link LexerMoreAction} action.
+    POP_MODE = 4    #The type of a {@link LexerPopModeAction} action.
+    PUSH_MODE = 5   #The type of a {@link LexerPushModeAction} action.
+    SKIP = 6        #The type of a {@link LexerSkipAction} action.
+    TYPE = 7        #The type of a {@link LexerTypeAction} action.
+
+class LexerAction(object):
+
+    def __init__(self, action:LexerActionType):
+        self.actionType = action
+        self.isPositionDependent = False
+
+    def __hash__(self):
+        return hash(self.actionType)
+
+    def __eq__(self, other):
+        return self is other
+
+
+#
+# Implements the {@code skip} lexer action by calling {@link Lexer#skip}.
+#
+# <p>The {@code skip} command does not have any parameters, so this action is
+# implemented as a singleton instance exposed by {@link #INSTANCE}.</p>
+class LexerSkipAction(LexerAction ):
+
+    # Provides a singleton instance of this parameterless lexer action.
+    INSTANCE = None
+
+    def __init__(self):
+        super().__init__(LexerActionType.SKIP)
+
+    def execute(self, lexer:Lexer):
+        lexer.skip()
+
+    def __str__(self):
+        return "skip"
+
+LexerSkipAction.INSTANCE = LexerSkipAction()
+
+#  Implements the {@code type} lexer action by calling {@link Lexer#setType}
+# with the assigned type.
+class LexerTypeAction(LexerAction):
+
+    def __init__(self, type:int):
+        super().__init__(LexerActionType.TYPE)
+        self.type = type
+
+    def execute(self, lexer:Lexer):
+        lexer.type = self.type
+
+    def __hash__(self):
+        return hash((self.actionType, self.type))
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, LexerTypeAction):
+            return False
+        else:
+            return self.type == other.type
+
+    def __str__(self):
+        return "type(" + str(self.type) + ")"
+
+
+# Implements the {@code pushMode} lexer action by calling
+# {@link Lexer#pushMode} with the assigned mode.
+class LexerPushModeAction(LexerAction):
+
+    def __init__(self, mode:int):
+        super().__init__(LexerActionType.PUSH_MODE)
+        self.mode = mode
+
+    # <p>This action is implemented by calling {@link Lexer#pushMode} with the
+    # value provided by {@link #getMode}.</p>
+    def execute(self, lexer:Lexer):
+        lexer.pushMode(self.mode)
+
+    def __hash__(self):
+        return hash((self.actionType, self.mode))
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, LexerPushModeAction):
+            return False
+        else:
+            return self.mode == other.mode
+
+    def __str__(self):
+        return "pushMode(" + str(self.mode) + ")"
+
+
+# Implements the {@code popMode} lexer action by calling {@link Lexer#popMode}.
+#
+# <p>The {@code popMode} command does not have any parameters, so this action is
+# implemented as a singleton instance exposed by {@link #INSTANCE}.</p>
+class LexerPopModeAction(LexerAction):
+
+    INSTANCE = None
+
+    def __init__(self):
+        super().__init__(LexerActionType.POP_MODE)
+
+    # <p>This action is implemented by calling {@link Lexer#popMode}.</p>
+    def execute(self, lexer:Lexer):
+        lexer.popMode()
+
+    def __str__(self):
+        return "popMode"
+
+LexerPopModeAction.INSTANCE = LexerPopModeAction()
+
+# Implements the {@code more} lexer action by calling {@link Lexer#more}.
+#
+# <p>The {@code more} command does not have any parameters, so this action is
+# implemented as a singleton instance exposed by {@link #INSTANCE}.</p>
+class LexerMoreAction(LexerAction):
+
+    INSTANCE = None
+
+    def __init__(self):
+        super().__init__(LexerActionType.MORE)
+
+    # <p>This action is implemented by calling {@link Lexer#popMode}.</p>
+    def execute(self, lexer:Lexer):
+        lexer.more()
+
+    def __str__(self):
+        return "more"
+
+LexerMoreAction.INSTANCE = LexerMoreAction()
+
+# Implements the {@code mode} lexer action by calling {@link Lexer#mode} with
+# the assigned mode.
+class LexerModeAction(LexerAction):
+
+    def __init__(self, mode:int):
+        super().__init__(LexerActionType.MODE)
+        self.mode = mode
+
+    # <p>This action is implemented by calling {@link Lexer#mode} with the
+    # value provided by {@link #getMode}.</p>
+    def execute(self, lexer:Lexer):
+        lexer.mode(self.mode)
+
+    def __hash__(self):
+        return hash((self.actionType, self.mode))
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, LexerModeAction):
+            return False
+        else:
+            return self.mode == other.mode
+
+    def __str__(self):
+        return "mode(" + str(self.mode) + ")"
+
+# Executes a custom lexer action by calling {@link Recognizer#action} with the
+# rule and action indexes assigned to the custom action. The implementation of
+# a custom action is added to the generated code for the lexer in an override
+# of {@link Recognizer#action} when the grammar is compiled.
+#
+# <p>This class may represent embedded actions created with the <code>{...}</code>
+# syntax in ANTLR 4, as well as actions created for lexer commands where the
+# command argument could not be evaluated when the grammar was compiled.</p>
+
+class LexerCustomAction(LexerAction):
+
+    # Constructs a custom lexer action with the specified rule and action
+    # indexes.
+    #
+    # @param ruleIndex The rule index to use for calls to
+    # {@link Recognizer#action}.
+    # @param actionIndex The action index to use for calls to
+    # {@link Recognizer#action}.
+    #/
+    def __init__(self, ruleIndex:int, actionIndex:int):
+        super().__init__(LexerActionType.CUSTOM)
+        self.ruleIndex = ruleIndex
+        self.actionIndex = actionIndex
+        self.isPositionDependent = True
+
+    # <p>Custom actions are implemented by calling {@link Lexer#action} with the
+    # appropriate rule and action indexes.</p>
+    def execute(self, lexer:Lexer):
+        lexer.action(None, self.ruleIndex, self.actionIndex)
+
+    def __hash__(self):
+        return hash((self.actionType, self.ruleIndex, self.actionIndex))
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, LexerCustomAction):
+            return False
+        else:
+            return self.ruleIndex == other.ruleIndex and self.actionIndex == other.actionIndex
+
+# Implements the {@code channel} lexer action by calling
+# {@link Lexer#setChannel} with the assigned channel.
+class LexerChannelAction(LexerAction):
+
+    # Constructs a new {@code channel} action with the specified channel value.
+    # @param channel The channel value to pass to {@link Lexer#setChannel}.
+    def __init__(self, channel:int):
+        super().__init__(LexerActionType.CHANNEL)
+        self.channel = channel
+
+    # <p>This action is implemented by calling {@link Lexer#setChannel} with the
+    # value provided by {@link #getChannel}.</p>
+    def execute(self, lexer:Lexer):
+        lexer._channel = self.channel
+
+    def __hash__(self):
+        return hash((self.actionType, self.channel))
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, LexerChannelAction):
+            return False
+        else:
+            return self.channel == other.channel
+
+    def __str__(self):
+        return "channel(" + str(self.channel) + ")"
+
+# This implementation of {@link LexerAction} is used for tracking input offsets
+# for position-dependent actions within a {@link LexerActionExecutor}.
+#
+# <p>This action is not serialized as part of the ATN, and is only required for
+# position-dependent lexer actions which appear at a location other than the
+# end of a rule. For more information about DFA optimizations employed for
+# lexer actions, see {@link LexerActionExecutor#append} and
+# {@link LexerActionExecutor#fixOffsetBeforeMatch}.</p>
+class LexerIndexedCustomAction(LexerAction):
+
+    # Constructs a new indexed custom action by associating a character offset
+    # with a {@link LexerAction}.
+    #
+    # <p>Note: This class is only required for lexer actions for which
+    # {@link LexerAction#isPositionDependent} returns {@code true}.</p>
+    #
+    # @param offset The offset into the input {@link CharStream}, relative to
+    # the token start index, at which the specified lexer action should be
+    # executed.
+    # @param action The lexer action to execute at a particular offset in the
+    # input {@link CharStream}.
+    def __init__(self, offset:int, action:LexerAction):
+        super().__init__(action.actionType)
+        self.offset = offset
+        self.action = action
+        self.isPositionDependent = True
+
+    # <p>This method calls {@link #execute} on the result of {@link #getAction}
+    # using the provided {@code lexer}.</p>
+    def execute(self, lexer:Lexer):
+        # assume the input stream position was properly set by the calling code
+        self.action.execute(lexer)
+
+    def __hash__(self):
+        return hash((self.actionType, self.offset, self.action))
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, LexerIndexedCustomAction):
+            return False
+        else:
+            return self.offset == other.offset and self.action == other.action
diff --git a/runtime/Python3/src/antlr4/atn/LexerActionExecutor.py b/runtime/Python3/src/antlr4/atn/LexerActionExecutor.py
new file mode 100644
index 000000000..0c9028954
--- /dev/null
+++ b/runtime/Python3/src/antlr4/atn/LexerActionExecutor.py
@@ -0,0 +1,167 @@
+#
+# [The "BSD license"]
+#  Copyright (c) 2013 Terence Parr
+#  Copyright (c) 2013 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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.
+#/
+
+# Represents an executor for a sequence of lexer actions which traversed during
+# the matching operation of a lexer rule (token).
+#
+# <p>The executor tracks position information for position-dependent lexer actions
+# efficiently, ensuring that actions appearing only at the end of the rule do
+# not cause bloating of the {@link DFA} created for the lexer.</p>
+
+
+from antlr4.InputStream import InputStream
+from antlr4.atn.LexerAction import LexerAction, LexerIndexedCustomAction
+
+# need a forward declaration
+Lexer = None
+LexerActionExecutor = None
+
+class LexerActionExecutor(object):
+
+    def __init__(self, lexerActions:list=list()):
+        self.lexerActions = lexerActions
+        # Caches the result of {@link #hashCode} since the hash code is an element
+        # of the performance-critical {@link LexerATNConfig#hashCode} operation.
+        self.hashCode = hash("".join([str(la) for la in lexerActions]))
+
+
+    # Creates a {@link LexerActionExecutor} which executes the actions for
+    # the input {@code lexerActionExecutor} followed by a specified
+    # {@code lexerAction}.
+    #
+    # @param lexerActionExecutor The executor for actions already traversed by
+    # the lexer while matching a token within a particular
+    # {@link LexerATNConfig}. If this is {@code null}, the method behaves as
+    # though it were an empty executor.
+    # @param lexerAction The lexer action to execute after the actions
+    # specified in {@code lexerActionExecutor}.
+    #
+    # @return A {@link LexerActionExecutor} for executing the combine actions
+    # of {@code lexerActionExecutor} and {@code lexerAction}.
+    @staticmethod
+    def append(lexerActionExecutor:LexerActionExecutor , lexerAction:LexerAction ):
+        if lexerActionExecutor is None:
+            return LexerActionExecutor([ lexerAction ])
+
+        lexerActions = lexerActionExecutor.lexerActions + [ lexerAction ]
+        return LexerActionExecutor(lexerActions)
+
+    # Creates a {@link LexerActionExecutor} which encodes the current offset
+    # for position-dependent lexer actions.
+    #
+    # <p>Normally, when the executor encounters lexer actions where
+    # {@link LexerAction#isPositionDependent} returns {@code true}, it calls
+    # {@link IntStream#seek} on the input {@link CharStream} to set the input
+    # position to the <em>end</em> of the current token. This behavior provides
+    # for efficient DFA representation of lexer actions which appear at the end
+    # of a lexer rule, even when the lexer rule matches a variable number of
+    # characters.</p>
+    #
+    # <p>Prior to traversing a match transition in the ATN, the current offset
+    # from the token start index is assigned to all position-dependent lexer
+    # actions which have not already been assigned a fixed offset. By storing
+    # the offsets relative to the token start index, the DFA representation of
+    # lexer actions which appear in the middle of tokens remains efficient due
+    # to sharing among tokens of the same length, regardless of their absolute
+    # position in the input stream.</p>
+    #
+    # <p>If the current executor already has offsets assigned to all
+    # position-dependent lexer actions, the method returns {@code this}.</p>
+    #
+    # @param offset The current offset to assign to all position-dependent
+    # lexer actions which do not already have offsets assigned.
+    #
+    # @return A {@link LexerActionExecutor} which stores input stream offsets
+    # for all position-dependent lexer actions.
+    #/
+    def fixOffsetBeforeMatch(self, offset:int):
+        updatedLexerActions = None
+        for i in range(0, len(self.lexerActions)):
+            if self.lexerActions[i].isPositionDependent and not isinstance(self.lexerActions[i], LexerIndexedCustomAction):
+                if updatedLexerActions is None:
+                    updatedLexerActions = [ la for la in self.lexerActions ]
+                updatedLexerActions[i] = LexerIndexedCustomAction(offset, self.lexerActions[i])
+
+        if updatedLexerActions is None:
+            return self
+        else:
+            return LexerActionExecutor(updatedLexerActions)
+
+
+    # Execute the actions encapsulated by this executor within the context of a
+    # particular {@link Lexer}.
+    #
+    # <p>This method calls {@link IntStream#seek} to set the position of the
+    # {@code input} {@link CharStream} prior to calling
+    # {@link LexerAction#execute} on a position-dependent action. Before the
+    # method returns, the input position will be restored to the same position
+    # it was in when the method was invoked.</p>
+    #
+    # @param lexer The lexer instance.
+    # @param input The input stream which is the source for the current token.
+    # When this method is called, the current {@link IntStream#index} for
+    # {@code input} should be the start of the following token, i.e. 1
+    # character past the end of the current token.
+    # @param startIndex The token start index. This value may be passed to
+    # {@link IntStream#seek} to set the {@code input} position to the beginning
+    # of the token.
+    #/
+    def execute(self, lexer:Lexer, input:InputStream, startIndex:int):
+        requiresSeek = False
+        stopIndex = input.index
+        try:
+            for lexerAction in self.lexerActions:
+                if isinstance(lexerAction, LexerIndexedCustomAction):
+                    offset = lexerAction.offset
+                    input.seek(startIndex + offset)
+                    lexerAction = lexerAction.action
+                    requiresSeek = (startIndex + offset) != stopIndex
+                elif lexerAction.isPositionDependent:
+                    input.seek(stopIndex)
+                    requiresSeek = False
+                lexerAction.execute(lexer)
+        finally:
+            if requiresSeek:
+                input.seek(stopIndex)
+
+    def __hash__(self):
+        return self.hashCode
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, LexerActionExecutor):
+            return False
+        else:
+            return self.hashCode == other.hashCode \
+                and self.lexerActions == other.lexerActions
+
+del Lexer
\ No newline at end of file
diff --git a/runtime/Python3/src/antlr4/atn/ParserATNSimulator.py b/runtime/Python3/src/antlr4/atn/ParserATNSimulator.py
new file mode 100755
index 000000000..fee18087f
--- /dev/null
+++ b/runtime/Python3/src/antlr4/atn/ParserATNSimulator.py
@@ -0,0 +1,1523 @@
+#
+# [The "BSD license"]
+#  Copyright (c) 2012 Terence Parr
+#  Copyright (c) 2012 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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.
+#
+
+#
+# The embodiment of the adaptive LL(*), ALL(*), parsing strategy.
+#
+# <p>
+# The basic complexity of the adaptive strategy makes it harder to understand.
+# We begin with ATN simulation to build paths in a DFA. Subsequent prediction
+# requests go through the DFA first. If they reach a state without an edge for
+# the current symbol, the algorithm fails over to the ATN simulation to
+# complete the DFA path for the current input (until it finds a conflict state
+# or uniquely predicting state).</p>
+#
+# <p>
+# All of that is done without using the outer context because we want to create
+# a DFA that is not dependent upon the rule invocation stack when we do a
+# prediction. One DFA works in all contexts. We avoid using context not
+# necessarily because it's slower, although it can be, but because of the DFA
+# caching problem. The closure routine only considers the rule invocation stack
+# created during prediction beginning in the decision rule. For example, if
+# prediction occurs without invoking another rule's ATN, there are no context
+# stacks in the configurations. When lack of context leads to a conflict, we
+# don't know if it's an ambiguity or a weakness in the strong LL(*) parsing
+# strategy (versus full LL(*)).</p>
+#
+# <p>
+# When SLL yields a configuration set with conflict, we rewind the input and
+# retry the ATN simulation, this time using full outer context without adding
+# to the DFA. Configuration context stacks will be the full invocation stacks
+# from the start rule. If we get a conflict using full context, then we can
+# definitively say we have a true ambiguity for that input sequence. If we
+# don't get a conflict, it implies that the decision is sensitive to the outer
+# context. (It is not context-sensitive in the sense of context-sensitive
+# grammars.)</p>
+#
+# <p>
+# The next time we reach this DFA state with an SLL conflict, through DFA
+# simulation, we will again retry the ATN simulation using full context mode.
+# This is slow because we can't save the results and have to "interpret" the
+# ATN each time we get that input.</p>
+#
+# <p>
+# <strong>CACHING FULL CONTEXT PREDICTIONS</strong></p>
+#
+# <p>
+# We could cache results from full context to predicted alternative easily and
+# that saves a lot of time but doesn't work in presence of predicates. The set
+# of visible predicates from the ATN start state changes depending on the
+# context, because closure can fall off the end of a rule. I tried to cache
+# tuples (stack context, semantic context, predicted alt) but it was slower
+# than interpreting and much more complicated. Also required a huge amount of
+# memory. The goal is not to create the world's fastest parser anyway. I'd like
+# to keep this algorithm simple. By launching multiple threads, we can improve
+# the speed of parsing across a large number of files.</p>
+#
+# <p>
+# There is no strict ordering between the amount of input used by SLL vs LL,
+# which makes it really hard to build a cache for full context. Let's say that
+# we have input A B C that leads to an SLL conflict with full context X. That
+# implies that using X we might only use A B but we could also use A B C D to
+# resolve conflict. Input A B C D could predict alternative 1 in one position
+# in the input and A B C E could predict alternative 2 in another position in
+# input. The conflicting SLL configurations could still be non-unique in the
+# full context prediction, which would lead us to requiring more input than the
+# original A B C.	To make a	prediction cache work, we have to track	the exact
+# input	used during the previous prediction. That amounts to a cache that maps
+# X to a specific DFA for that context.</p>
+#
+# <p>
+# Something should be done for left-recursive expression predictions. They are
+# likely LL(1) + pred eval. Easier to do the whole SLL unless error and retry
+# with full LL thing Sam does.</p>
+#
+# <p>
+# <strong>AVOIDING FULL CONTEXT PREDICTION</strong></p>
+#
+# <p>
+# We avoid doing full context retry when the outer context is empty, we did not
+# dip into the outer context by falling off the end of the decision state rule,
+# or when we force SLL mode.</p>
+#
+# <p>
+# As an example of the not dip into outer context case, consider as super
+# constructor calls versus function calls. One grammar might look like
+# this:</p>
+#
+# <pre>
+# ctorBody
+#   : '{' superCall? stat* '}'
+#   ;
+# </pre>
+#
+# <p>
+# Or, you might see something like</p>
+#
+# <pre>
+# stat
+#   : superCall ';'
+#   | expression ';'
+#   | ...
+#   ;
+# </pre>
+#
+# <p>
+# In both cases I believe that no closure operations will dip into the outer
+# context. In the first case ctorBody in the worst case will stop at the '}'.
+# In the 2nd case it should stop at the ';'. Both cases should stay within the
+# entry rule and not dip into the outer context.</p>
+#
+# <p>
+# <strong>PREDICATES</strong></p>
+#
+# <p>
+# Predicates are always evaluated if present in either SLL or LL both. SLL and
+# LL simulation deals with predicates differently. SLL collects predicates as
+# it performs closure operations like ANTLR v3 did. It delays predicate
+# evaluation until it reaches and accept state. This allows us to cache the SLL
+# ATN simulation whereas, if we had evaluated predicates on-the-fly during
+# closure, the DFA state configuration sets would be different and we couldn't
+# build up a suitable DFA.</p>
+#
+# <p>
+# When building a DFA accept state during ATN simulation, we evaluate any
+# predicates and return the sole semantically valid alternative. If there is
+# more than 1 alternative, we report an ambiguity. If there are 0 alternatives,
+# we throw an exception. Alternatives without predicates act like they have
+# true predicates. The simple way to think about it is to strip away all
+# alternatives with false predicates and choose the minimum alternative that
+# remains.</p>
+#
+# <p>
+# When we start in the DFA and reach an accept state that's predicated, we test
+# those and return the minimum semantically viable alternative. If no
+# alternatives are viable, we throw an exception.</p>
+#
+# <p>
+# During full LL ATN simulation, closure always evaluates predicates and
+# on-the-fly. This is crucial to reducing the configuration set size during
+# closure. It hits a landmine when parsing with the Java grammar, for example,
+# without this on-the-fly evaluation.</p>
+#
+# <p>
+# <strong>SHARING DFA</strong></p>
+#
+# <p>
+# All instances of the same parser share the same decision DFAs through a
+# static field. Each instance gets its own ATN simulator but they share the
+# same {@link #decisionToDFA} field. They also share a
+# {@link PredictionContextCache} object that makes sure that all
+# {@link PredictionContext} objects are shared among the DFA states. This makes
+# a big size difference.</p>
+#
+# <p>
+# <strong>THREAD SAFETY</strong></p>
+#
+# <p>
+# The {@link ParserATNSimulator} locks on the {@link #decisionToDFA} field when
+# it adds a new DFA object to that array. {@link #addDFAEdge}
+# locks on the DFA for the current decision when setting the
+# {@link DFAState#edges} field. {@link #addDFAState} locks on
+# the DFA for the current decision when looking up a DFA state to see if it
+# already exists. We must make sure that all requests to add DFA states that
+# are equivalent result in the same shared DFA object. This is because lots of
+# threads will be trying to update the DFA at once. The
+# {@link #addDFAState} method also locks inside the DFA lock
+# but this time on the shared context cache when it rebuilds the
+# configurations' {@link PredictionContext} objects using cached
+# subgraphs/nodes. No other locking occurs, even during DFA simulation. This is
+# safe as long as we can guarantee that all threads referencing
+# {@code s.edge[t]} get the same physical target {@link DFAState}, or
+# {@code null}. Once into the DFA, the DFA simulation does not reference the
+# {@link DFA#states} map. It follows the {@link DFAState#edges} field to new
+# targets. The DFA simulator will either find {@link DFAState#edges} to be
+# {@code null}, to be non-{@code null} and {@code dfa.edges[t]} null, or
+# {@code dfa.edges[t]} to be non-null. The
+# {@link #addDFAEdge} method could be racing to set the field
+# but in either case the DFA simulator works; if {@code null}, and requests ATN
+# simulation. It could also race trying to get {@code dfa.edges[t]}, but either
+# way it will work because it's not doing a test and set operation.</p>
+#
+# <p>
+# <strong>Starting with SLL then failing to combined SLL/LL (Two-Stage
+# Parsing)</strong></p>
+#
+# <p>
+# Sam pointed out that if SLL does not give a syntax error, then there is no
+# point in doing full LL, which is slower. We only have to try LL if we get a
+# syntax error. For maximum speed, Sam starts the parser set to pure SLL
+# mode with the {@link BailErrorStrategy}:</p>
+#
+# <pre>
+# parser.{@link Parser#getInterpreter() getInterpreter()}.{@link #setPredictionMode setPredictionMode}{@code (}{@link PredictionMode#SLL}{@code )};
+# parser.{@link Parser#setErrorHandler setErrorHandler}(new {@link BailErrorStrategy}());
+# </pre>
+#
+# <p>
+# If it does not get a syntax error, then we're done. If it does get a syntax
+# error, we need to retry with the combined SLL/LL strategy.</p>
+#
+# <p>
+# The reason this works is as follows. If there are no SLL conflicts, then the
+# grammar is SLL (at least for that input set). If there is an SLL conflict,
+# the full LL analysis must yield a set of viable alternatives which is a
+# subset of the alternatives reported by SLL. If the LL set is a singleton,
+# then the grammar is LL but not SLL. If the LL set is the same size as the SLL
+# set, the decision is SLL. If the LL set has size &gt; 1, then that decision
+# is truly ambiguous on the current input. If the LL set is smaller, then the
+# SLL conflict resolution might choose an alternative that the full LL would
+# rule out as a possibility based upon better context information. If that's
+# the case, then the SLL parse will definitely get an error because the full LL
+# analysis says it's not viable. If SLL conflict resolution chooses an
+# alternative within the LL set, them both SLL and LL would choose the same
+# alternative because they both choose the minimum of multiple conflicting
+# alternatives.</p>
+#
+# <p>
+# Let's say we have a set of SLL conflicting alternatives {@code {1, 2, 3}} and
+# a smaller LL set called <em>s</em>. If <em>s</em> is {@code {2, 3}}, then SLL
+# parsing will get an error because SLL will pursue alternative 1. If
+# <em>s</em> is {@code {1, 2}} or {@code {1, 3}} then both SLL and LL will
+# choose the same alternative because alternative one is the minimum of either
+# set. If <em>s</em> is {@code {2}} or {@code {3}} then SLL will get a syntax
+# error. If <em>s</em> is {@code {1}} then SLL will succeed.</p>
+#
+# <p>
+# Of course, if the input is invalid, then we will get an error for sure in
+# both SLL and LL parsing. Erroneous input will therefore require 2 passes over
+# the input.</p>
+#
+import sys
+from antlr4 import DFA
+from antlr4.PredictionContext import PredictionContextCache, PredictionContext, SingletonPredictionContext, \
+    PredictionContextFromRuleContext
+from antlr4.BufferedTokenStream import TokenStream
+from antlr4.Parser import Parser
+from antlr4.ParserRuleContext import ParserRuleContext
+from antlr4.RuleContext import RuleContext
+from antlr4.Token import Token
+from antlr4.Utils import str_list
+from antlr4.atn.ATN import ATN
+from antlr4.atn.ATNConfig import ATNConfig
+from antlr4.atn.ATNConfigSet import ATNConfigSet
+from antlr4.atn.ATNSimulator import ATNSimulator
+from antlr4.atn.ATNState import StarLoopEntryState, DecisionState, RuleStopState, ATNState
+from antlr4.atn.PredictionMode import PredictionMode
+from antlr4.atn.SemanticContext import SemanticContext, AND, andContext, orContext
+from antlr4.atn.Transition import Transition, RuleTransition, ActionTransition, PrecedencePredicateTransition, \
+    PredicateTransition, AtomTransition, SetTransition, NotSetTransition
+from antlr4.dfa.DFAState import DFAState, PredPrediction
+from antlr4.error.Errors import NoViableAltException
+
+
+class ParserATNSimulator(ATNSimulator):
+
+    debug = False
+    debug_list_atn_decisions = False
+    dfa_debug = False
+    retry_debug = False
+
+
+    def __init__(self, parser:Parser, atn:ATN, decisionToDFA:list, sharedContextCache:PredictionContextCache):
+        super().__init__(atn, sharedContextCache)
+        self.parser = parser
+        self.decisionToDFA = decisionToDFA
+        # SLL, LL, or LL + exact ambig detection?#
+        self.predictionMode = PredictionMode.LL
+        # LAME globals to avoid parameters!!!!! I need these down deep in predTransition
+        self._input = None
+        self._startIndex = 0
+        self._outerContext = None
+        self._dfa = None
+        # Each prediction operation uses a cache for merge of prediction contexts.
+        #  Don't keep around as it wastes huge amounts of memory. DoubleKeyMap
+        #  isn't synchronized but we're ok since two threads shouldn't reuse same
+        #  parser/atnsim object because it can only handle one input at a time.
+        #  This maps graphs a and b to merged result c. (a,b)&rarr;c. We can avoid
+        #  the merge if we ever see a and b again.  Note that (b,a)&rarr;c should
+        #  also be examined during cache lookup.
+        #
+        self.mergeCache = None
+
+
+    def reset(self):
+        pass
+
+    def adaptivePredict(self, input:TokenStream, decision:int, outerContext:ParserRuleContext):
+        if self.debug or self.debug_list_atn_decisions:
+            print("adaptivePredict decision " + str(decision) +
+                                   " exec LA(1)==" + self.getLookaheadName(input) +
+                                   " line " + str(input.LT(1).line) + ":" +
+                                   str(input.LT(1).column))
+        self._input = input
+        self._startIndex = input.index
+        self._outerContext = outerContext
+        
+        dfa = self.decisionToDFA[decision]
+        self._dfa = dfa
+        m = input.mark()
+        index = input.index
+
+        # Now we are certain to have a specific decision's DFA
+        # But, do we still need an initial state?
+        try:
+            if dfa.precedenceDfa:
+                # the start state for a precedence DFA depends on the current
+                # parser precedence, and is provided by a DFA method.
+                s0 = dfa.getPrecedenceStartState(self.parser.getPrecedence())
+            else:
+                # the start state for a "regular" DFA is just s0
+                s0 = dfa.s0
+
+            if s0 is None:
+                if outerContext is None:
+                    outerContext = ParserRuleContext.EMPTY
+                if self.debug or self.debug_list_atn_decisions:
+                    print("predictATN decision " + str(dfa.decision) +
+                                       " exec LA(1)==" + self.getLookaheadName(input) +
+                                       ", outerContext=" + outerContext.toString(self.parser))
+
+                # If this is not a precedence DFA, we check the ATN start state
+                # to determine if this ATN start state is the decision for the
+                # closure block that determines whether a precedence rule
+                # should continue or complete.
+                #
+                if not dfa.precedenceDfa and isinstance(dfa.atnStartState, StarLoopEntryState):
+                    if dfa.atnStartState.precedenceRuleDecision:
+                        dfa.setPrecedenceDfa(True)
+
+                fullCtx = False
+                s0_closure = self.computeStartState(dfa.atnStartState, ParserRuleContext.EMPTY, fullCtx)
+
+                if dfa.precedenceDfa:
+                    # If this is a precedence DFA, we use applyPrecedenceFilter
+                    # to convert the computed start state to a precedence start
+                    # state. We then use DFA.setPrecedenceStartState to set the
+                    # appropriate start state for the precedence level rather
+                    # than simply setting DFA.s0.
+                    #
+                    s0_closure = self.applyPrecedenceFilter(s0_closure)
+                    s0 = self.addDFAState(dfa, DFAState(configs=s0_closure))
+                    dfa.setPrecedenceStartState(self.parser.getPrecedence(), s0)
+                else:
+                    s0 = self.addDFAState(dfa, DFAState(configs=s0_closure))
+                    dfa.s0 = s0
+
+            alt = self.execATN(dfa, s0, input, index, outerContext)
+            if self.debug:
+                print("DFA after predictATN: " + dfa.toString(self.parser.tokenNames))
+            return alt
+        finally:
+            self._dfa = None
+            self.mergeCache = None # wack cache after each prediction
+            input.seek(index)
+            input.release(m)
+
+    # Performs ATN simulation to compute a predicted alternative based
+    #  upon the remaining input, but also updates the DFA cache to avoid
+    #  having to traverse the ATN again for the same input sequence.
+
+    # There are some key conditions we're looking for after computing a new
+    # set of ATN configs (proposed DFA state):
+          # if the set is empty, there is no viable alternative for current symbol
+          # does the state uniquely predict an alternative?
+          # does the state have a conflict that would prevent us from
+          #   putting it on the work list?
+
+    # We also have some key operations to do:
+          # add an edge from previous DFA state to potentially new DFA state, D,
+          #   upon current symbol but only if adding to work list, which means in all
+          #   cases except no viable alternative (and possibly non-greedy decisions?)
+          # collecting predicates and adding semantic context to DFA accept states
+          # adding rule context to context-sensitive DFA accept states
+          # consuming an input symbol
+          # reporting a conflict
+          # reporting an ambiguity
+          # reporting a context sensitivity
+          # reporting insufficient predicates
+
+    # cover these cases:
+    #    dead end
+    #    single alt
+    #    single alt + preds
+    #    conflict
+    #    conflict + preds
+    #
+    def execATN(self, dfa:DFA, s0:DFAState, input:TokenStream, startIndex:int, outerContext:ParserRuleContext ):
+        if self.debug or self.debug_list_atn_decisions:
+            print("execATN decision " + str(dfa.decision) +
+                    " exec LA(1)==" + self.getLookaheadName(input) +
+                    " line " + str(input.LT(1).line) + ":" + str(input.LT(1).column))
+
+        previousD = s0
+
+        if self.debug:
+            print("s0 = " + str(s0))
+
+        t = input.LA(1)
+
+        while True: # while more work
+            D = self.getExistingTargetState(previousD, t)
+            if D is None:
+                D = self.computeTargetState(dfa, previousD, t)
+            if D is self.ERROR:
+                # if any configs in previous dipped into outer context, that
+                # means that input up to t actually finished entry rule
+                # at least for SLL decision. Full LL doesn't dip into outer
+                # so don't need special case.
+                # We will get an error no matter what so delay until after
+                # decision; better error message. Also, no reachable target
+                # ATN states in SLL implies LL will also get nowhere.
+                # If conflict in states that dip out, choose min since we
+                # will get error no matter what.
+                e = self.noViableAlt(input, outerContext, previousD.configs, startIndex)
+                input.seek(startIndex)
+                alt = self.getSynValidOrSemInvalidAltThatFinishedDecisionEntryRule(previousD.configs, outerContext)
+                if alt!=ATN.INVALID_ALT_NUMBER:
+                    return alt
+                raise e
+
+            if D.requiresFullContext and self.predictionMode != PredictionMode.SLL:
+                # IF PREDS, MIGHT RESOLVE TO SINGLE ALT => SLL (or syntax error)
+                conflictingAlts = None
+                if D.predicates is not None:
+                    if self.debug:
+                        print("DFA state has preds in DFA sim LL failover")
+                    conflictIndex = input.index
+                    if conflictIndex != startIndex:
+                        input.seek(startIndex)
+
+                    conflictingAlts = self.evalSemanticContext(D.predicates, outerContext, True)
+                    if len(conflictingAlts)==1:
+                        if self.debug:
+                            print("Full LL avoided")
+                        return min(conflictingAlts)
+
+                    if conflictIndex != startIndex:
+                        # restore the index so reporting the fallback to full
+                        # context occurs with the index at the correct spot
+                        input.seek(conflictIndex)
+
+                if self.dfa_debug:
+                    print("ctx sensitive state " + str(outerContext) +" in " + str(D))
+                fullCtx = True
+                s0_closure = self.computeStartState(dfa.atnStartState, outerContext, fullCtx)
+                self.reportAttemptingFullContext(dfa, conflictingAlts, D.configs, startIndex, input.index)
+                alt = self.execATNWithFullContext(dfa, D, s0_closure, input, startIndex, outerContext)
+                return alt
+
+            if D.isAcceptState:
+                if D.predicates is None:
+                    return D.prediction
+
+                stopIndex = input.index
+                input.seek(startIndex)
+                alts = self.evalSemanticContext(D.predicates, outerContext, True)
+                if len(alts)==0:
+                    raise self.noViableAlt(input, outerContext, D.configs, startIndex)
+                elif len(alts)==1:
+                    return min(alts)
+                else:
+                    # report ambiguity after predicate evaluation to make sure the correct
+                    # set of ambig alts is reported.
+                    self.reportAmbiguity(dfa, D, startIndex, stopIndex, False, alts, D.configs)
+                    return min(alts)
+
+            previousD = D
+
+            if t != Token.EOF:
+                input.consume()
+                t = input.LA(1)
+
+    #
+    # Get an existing target state for an edge in the DFA. If the target state
+    # for the edge has not yet been computed or is otherwise not available,
+    # this method returns {@code null}.
+    #
+    # @param previousD The current DFA state
+    # @param t The next input symbol
+    # @return The existing target DFA state for the given input symbol
+    # {@code t}, or {@code null} if the target state for this edge is not
+    # already cached
+    #
+    def getExistingTargetState(self, previousD:DFAState, t:int):
+        edges = previousD.edges
+        if edges is None or t + 1 < 0 or t + 1 >= len(edges):
+            return None
+        else:
+            return edges[t + 1]
+
+    #
+    # Compute a target state for an edge in the DFA, and attempt to add the
+    # computed state and corresponding edge to the DFA.
+    #
+    # @param dfa The DFA
+    # @param previousD The current DFA state
+    # @param t The next input symbol
+    #
+    # @return The computed target DFA state for the given input symbol
+    # {@code t}. If {@code t} does not lead to a valid DFA state, this method
+    # returns {@link #ERROR}.
+    #
+    def computeTargetState(self, dfa:DFA, previousD:DFAState, t:int):
+        reach = self.computeReachSet(previousD.configs, t, False)
+        if reach is None:
+            self.addDFAEdge(dfa, previousD, t, self.ERROR)
+            return self.ERROR
+
+        # create new target state; we'll add to DFA after it's complete
+        D = DFAState(configs=reach)
+
+        predictedAlt = self.getUniqueAlt(reach)
+
+        if self.debug:
+            altSubSets = PredictionMode.getConflictingAltSubsets(reach)
+            print("SLL altSubSets=" + str(altSubSets) + ", configs=" + str(reach) +
+                        ", predict=" + str(predictedAlt) + ", allSubsetsConflict=" +
+                        str(PredictionMode.allSubsetsConflict(altSubSets)) + ", conflictingAlts=" +
+                        str(self.getConflictingAlts(reach)))
+
+        if predictedAlt!=ATN.INVALID_ALT_NUMBER:
+            # NO CONFLICT, UNIQUELY PREDICTED ALT
+            D.isAcceptState = True
+            D.configs.uniqueAlt = predictedAlt
+            D.prediction = predictedAlt
+        elif PredictionMode.hasSLLConflictTerminatingPrediction(self.predictionMode, reach):
+            # MORE THAN ONE VIABLE ALTERNATIVE
+            D.configs.conflictingAlts = self.getConflictingAlts(reach)
+            D.requiresFullContext = True
+            # in SLL-only mode, we will stop at this state and return the minimum alt
+            D.isAcceptState = True
+            D.prediction = min(D.configs.conflictingAlts)
+
+        if D.isAcceptState and D.configs.hasSemanticContext:
+            self.predicateDFAState(D, self.atn.getDecisionState(dfa.decision))
+            if D.predicates is not None:
+                D.prediction = ATN.INVALID_ALT_NUMBER
+
+        # all adds to dfa are done after we've created full D state
+        D = self.addDFAEdge(dfa, previousD, t, D)
+        return D
+
+    def predicateDFAState(self, dfaState:DFAState, decisionState:DecisionState):
+        # We need to test all predicates, even in DFA states that
+        # uniquely predict alternative.
+        nalts = len(decisionState.transitions)
+        # Update DFA so reach becomes accept state with (predicate,alt)
+        # pairs if preds found for conflicting alts
+        altsToCollectPredsFrom = self.getConflictingAltsOrUniqueAlt(dfaState.configs)
+        altToPred = self.getPredsForAmbigAlts(altsToCollectPredsFrom, dfaState.configs, nalts)
+        if altToPred is not None:
+            dfaState.predicates = self.getPredicatePredictions(altsToCollectPredsFrom, altToPred)
+            dfaState.prediction = ATN.INVALID_ALT_NUMBER # make sure we use preds
+        else:
+            # There are preds in configs but they might go away
+            # when OR'd together like {p}? || NONE == NONE. If neither
+            # alt has preds, resolve to min alt
+            dfaState.prediction = min(altsToCollectPredsFrom)
+
+    # comes back with reach.uniqueAlt set to a valid alt
+    def execATNWithFullContext(self, dfa:DFA, D:DFAState, # how far we got before failing over
+                                         s0:ATNConfigSet,
+                                         input:TokenStream,
+                                         startIndex:int,
+                                         outerContext:ParserRuleContext):
+        if self.debug or self.debug_list_atn_decisions:
+            print("execATNWithFullContext "+s0)
+        fullCtx = True
+        foundExactAmbig = False
+        reach = None
+        previous = s0
+        input.seek(startIndex)
+        t = input.LA(1)
+        predictedAlt = -1
+        while (True): # while more work
+            reach = self.computeReachSet(previous, t, fullCtx)
+            if reach is None:
+                # if any configs in previous dipped into outer context, that
+                # means that input up to t actually finished entry rule
+                # at least for LL decision. Full LL doesn't dip into outer
+                # so don't need special case.
+                # We will get an error no matter what so delay until after
+                # decision; better error message. Also, no reachable target
+                # ATN states in SLL implies LL will also get nowhere.
+                # If conflict in states that dip out, choose min since we
+                # will get error no matter what.
+                e = self.noViableAlt(input, outerContext, previous, startIndex)
+                input.seek(startIndex)
+                alt = self.getSynValidOrSemInvalidAltThatFinishedDecisionEntryRule(previous, outerContext)
+                if alt!=ATN.INVALID_ALT_NUMBER:
+                    return alt
+                else:
+                    raise e
+
+            altSubSets = PredictionMode.getConflictingAltSubsets(reach)
+            if self.debug:
+                print("LL altSubSets=" + str(altSubSets) + ", predict=" +
+                      str(PredictionMode.getUniqueAlt(altSubSets)) + ", resolvesToJustOneViableAlt=" +
+                      str(PredictionMode.resolvesToJustOneViableAlt(altSubSets)))
+
+            reach.uniqueAlt = self.getUniqueAlt(reach)
+            # unique prediction?
+            if reach.uniqueAlt!=ATN.INVALID_ALT_NUMBER:
+                predictedAlt = reach.uniqueAlt
+                break
+            elif self.predictionMode is not PredictionMode.LL_EXACT_AMBIG_DETECTION:
+                predictedAlt = PredictionMode.resolvesToJustOneViableAlt(altSubSets)
+                if predictedAlt != ATN.INVALID_ALT_NUMBER:
+                    break
+            else:
+                # In exact ambiguity mode, we never try to terminate early.
+                # Just keeps scarfing until we know what the conflict is
+                if PredictionMode.allSubsetsConflict(altSubSets) and PredictionMode.allSubsetsEqual(altSubSets):
+                    foundExactAmbig = True
+                    predictedAlt = PredictionMode.getSingleViableAlt(altSubSets)
+                    break
+                # else there are multiple non-conflicting subsets or
+                # we're not sure what the ambiguity is yet.
+                # So, keep going.
+
+            previous = reach
+            if t != Token.EOF:
+                input.consume()
+                t = input.LA(1)
+
+        # If the configuration set uniquely predicts an alternative,
+        # without conflict, then we know that it's a full LL decision
+        # not SLL.
+        if reach.uniqueAlt != ATN.INVALID_ALT_NUMBER :
+            self.reportContextSensitivity(dfa, predictedAlt, reach, startIndex, input.index)
+            return predictedAlt
+
+        # We do not check predicates here because we have checked them
+        # on-the-fly when doing full context prediction.
+
+        #
+        # In non-exact ambiguity detection mode, we might	actually be able to
+        # detect an exact ambiguity, but I'm not going to spend the cycles
+        # needed to check. We only emit ambiguity warnings in exact ambiguity
+        # mode.
+        #
+        # For example, we might know that we have conflicting configurations.
+        # But, that does not mean that there is no way forward without a
+        # conflict. It's possible to have nonconflicting alt subsets as in:
+
+        # altSubSets=[{1, 2}, {1, 2}, {1}, {1, 2}]
+
+        # from
+        #
+        #    [(17,1,[5 $]), (13,1,[5 10 $]), (21,1,[5 10 $]), (11,1,[$]),
+        #     (13,2,[5 10 $]), (21,2,[5 10 $]), (11,2,[$])]
+        #
+        # In this case, (17,1,[5 $]) indicates there is some next sequence that
+        # would resolve this without conflict to alternative 1. Any other viable
+        # next sequence, however, is associated with a conflict.  We stop
+        # looking for input because no amount of further lookahead will alter
+        # the fact that we should predict alternative 1.  We just can't say for
+        # sure that there is an ambiguity without looking further.
+
+        self.reportAmbiguity(dfa, D, startIndex, input.index, foundExactAmbig, None, reach)
+
+        return predictedAlt
+
+    def computeReachSet(self, closure:ATNConfigSet, t:int, fullCtx:bool):
+        if self.debug:
+            print("in computeReachSet, starting closure: " + str(closure))
+
+        if self.mergeCache is None:
+            self.mergeCache = dict()
+
+        intermediate = ATNConfigSet(fullCtx)
+
+        # Configurations already in a rule stop state indicate reaching the end
+        # of the decision rule (local context) or end of the start rule (full
+        # context). Once reached, these configurations are never updated by a
+        # closure operation, so they are handled separately for the performance
+        # advantage of having a smaller intermediate set when calling closure.
+        #
+        # For full-context reach operations, separate handling is required to
+        # ensure that the alternative matching the longest overall sequence is
+        # chosen when multiple such configurations can match the input.
+        
+        skippedStopStates = None
+
+        # First figure out where we can reach on input t
+        for c in closure:
+            if self.debug:
+                print("testing " + self.getTokenName(t) + " at " + str(c))
+
+            if isinstance(c.state, RuleStopState):
+                if fullCtx or t == Token.EOF:
+                    if skippedStopStates is None:
+                        skippedStopStates = list()
+                    skippedStopStates.append(c)
+                continue
+
+            for trans in c.state.transitions:
+                target = self.getReachableTarget(trans, t)
+                if target is not None:
+                    intermediate.add(ATNConfig(state=target, config=c), self.mergeCache)
+
+        # Now figure out where the reach operation can take us...
+
+        reach = None
+
+        # This block optimizes the reach operation for intermediate sets which
+        # trivially indicate a termination state for the overall
+        # adaptivePredict operation.
+        #
+        # The conditions assume that intermediate
+        # contains all configurations relevant to the reach set, but this
+        # condition is not true when one or more configurations have been
+        # withheld in skippedStopStates, or when the current symbol is EOF.
+        #
+        if skippedStopStates is None and t!=Token.EOF:
+            if len(intermediate)==1:
+                # Don't pursue the closure if there is just one state.
+                # It can only have one alternative; just add to result
+                # Also don't pursue the closure if there is unique alternative
+                # among the configurations.
+                reach = intermediate
+            elif self.getUniqueAlt(intermediate)!=ATN.INVALID_ALT_NUMBER:
+                # Also don't pursue the closure if there is unique alternative
+                # among the configurations.
+                reach = intermediate
+
+        # If the reach set could not be trivially determined, perform a closure
+        # operation on the intermediate set to compute its initial value.
+        #
+        if reach is None:
+            reach = ATNConfigSet(fullCtx)
+            closureBusy = set()
+            treatEofAsEpsilon = t == Token.EOF
+            for c in intermediate:
+                self.closure(c, reach, closureBusy, False, fullCtx, treatEofAsEpsilon)
+
+        if t == Token.EOF:
+            # After consuming EOF no additional input is possible, so we are
+            # only interested in configurations which reached the end of the
+            # decision rule (local context) or end of the start rule (full
+            # context). Update reach to contain only these configurations. This
+            # handles both explicit EOF transitions in the grammar and implicit
+            # EOF transitions following the end of the decision or start rule.
+            #
+            # When reach==intermediate, no closure operation was performed. In
+            # this case, removeAllConfigsNotInRuleStopState needs to check for
+            # reachable rule stop states as well as configurations already in
+            # a rule stop state.
+            #
+            # This is handled before the configurations in skippedStopStates,
+            # because any configurations potentially added from that list are
+            # already guaranteed to meet this condition whether or not it's
+            # required.
+            #
+            reach = self.removeAllConfigsNotInRuleStopState(reach, reach is intermediate)
+
+        # If skippedStopStates is not null, then it contains at least one
+        # configuration. For full-context reach operations, these
+        # configurations reached the end of the start rule, in which case we
+        # only add them back to reach if no configuration during the current
+        # closure operation reached such a state. This ensures adaptivePredict
+        # chooses an alternative matching the longest overall sequence when
+        # multiple alternatives are viable.
+        #
+        if skippedStopStates is not None and ( (not fullCtx) or (not PredictionMode.hasConfigInRuleStopState(reach))):
+            for c in skippedStopStates:
+                reach.add(c, self.mergeCache)
+        if len(reach)==0:
+            return None
+        else:
+            return reach
+
+    #
+    # Return a configuration set containing only the configurations from
+    # {@code configs} which are in a {@link RuleStopState}. If all
+    # configurations in {@code configs} are already in a rule stop state, this
+    # method simply returns {@code configs}.
+    #
+    # <p>When {@code lookToEndOfRule} is true, this method uses
+    # {@link ATN#nextTokens} for each configuration in {@code configs} which is
+    # not already in a rule stop state to see if a rule stop state is reachable
+    # from the configuration via epsilon-only transitions.</p>
+    #
+    # @param configs the configuration set to update
+    # @param lookToEndOfRule when true, this method checks for rule stop states
+    # reachable by epsilon-only transitions from each configuration in
+    # {@code configs}.
+    #
+    # @return {@code configs} if all configurations in {@code configs} are in a
+    # rule stop state, otherwise return a new configuration set containing only
+    # the configurations from {@code configs} which are in a rule stop state
+    #
+    def removeAllConfigsNotInRuleStopState(self, configs:ATNConfigSet, lookToEndOfRule:bool):
+        if PredictionMode.allConfigsInRuleStopStates(configs):
+            return configs
+        result = ATNConfigSet(configs.fullCtx)
+        for config in configs:
+            if isinstance(config.state, RuleStopState):
+                result.add(config, self.mergeCache)
+                continue
+            if lookToEndOfRule and config.state.epsilonOnlyTransitions:
+                nextTokens = self.atn.nextTokens(config.state)
+                if Token.EPSILON in nextTokens:
+                    endOfRuleState = self.atn.ruleToStopState[config.state.ruleIndex]
+                    result.add(ATNConfig(state=endOfRuleState, config=config), self.mergeCache)
+        return result
+
+    def computeStartState(self, p:ATNState, ctx:RuleContext, fullCtx:bool):
+        # always at least the implicit call to start rule
+        initialContext = PredictionContextFromRuleContext(self.atn, ctx)
+        configs = ATNConfigSet(fullCtx)
+
+        for i in range(0, len(p.transitions)):
+            target = p.transitions[i].target
+            c = ATNConfig(target, i+1, initialContext)
+            closureBusy = set()
+            self.closure(c, configs, closureBusy, True, fullCtx, False)
+        return configs
+
+    #
+    # This method transforms the start state computed by
+    # {@link #computeStartState} to the special start state used by a
+    # precedence DFA for a particular precedence value. The transformation
+    # process applies the following changes to the start state's configuration
+    # set.
+    #
+    # <ol>
+    # <li>Evaluate the precedence predicates for each configuration using
+    # {@link SemanticContext#evalPrecedence}.</li>
+    # <li>Remove all configurations which predict an alternative greater than
+    # 1, for which another configuration that predicts alternative 1 is in the
+    # same ATN state with the same prediction context. This transformation is
+    # valid for the following reasons:
+    # <ul>
+    # <li>The closure block cannot contain any epsilon transitions which bypass
+    # the body of the closure, so all states reachable via alternative 1 are
+    # part of the precedence alternatives of the transformed left-recursive
+    # rule.</li>
+    # <li>The "primary" portion of a left recursive rule cannot contain an
+    # epsilon transition, so the only way an alternative other than 1 can exist
+    # in a state that is also reachable via alternative 1 is by nesting calls
+    # to the left-recursive rule, with the outer calls not being at the
+    # preferred precedence level.</li>
+    # </ul>
+    # </li>
+    # </ol>
+    #
+    # <p>
+    # The prediction context must be considered by this filter to address
+    # situations like the following.
+    # </p>
+    # <code>
+    # <pre>
+    # grammar TA;
+    # prog: statement* EOF;
+    # statement: letterA | statement letterA 'b' ;
+    # letterA: 'a';
+    # </pre>
+    # </code>
+    # <p>
+    # If the above grammar, the ATN state immediately before the token
+    # reference {@code 'a'} in {@code letterA} is reachable from the left edge
+    # of both the primary and closure blocks of the left-recursive rule
+    # {@code statement}. The prediction context associated with each of these
+    # configurations distinguishes between them, and prevents the alternative
+    # which stepped out to {@code prog} (and then back in to {@code statement}
+    # from being eliminated by the filter.
+    # </p>
+    #
+    # @param configs The configuration set computed by
+    # {@link #computeStartState} as the start state for the DFA.
+    # @return The transformed configuration set representing the start state
+    # for a precedence DFA at a particular precedence level (determined by
+    # calling {@link Parser#getPrecedence}).
+    #
+    def applyPrecedenceFilter(self, configs:ATNConfigSet):
+        statesFromAlt1 = dict()
+        configSet = ATNConfigSet(configs.fullCtx)
+        for config in configs:
+            # handle alt 1 first
+            if config.alt != 1:
+                continue
+            updatedContext = config.semanticContext.evalPrecedence(self.parser, self._outerContext)
+            if updatedContext is None:
+                # the configuration was eliminated
+                continue
+
+            statesFromAlt1[config.state.stateNumber] = config.context
+            if updatedContext is not config.semanticContext:
+                configSet.add(ATNConfig(config=config, semantic=updatedContext), self.mergeCache)
+            else:
+                configSet.add(config, self.mergeCache)
+
+        for config in configs:
+            if config.alt == 1:
+                # already handled
+                continue
+
+            # In the future, this elimination step could be updated to also
+            # filter the prediction context for alternatives predicting alt>1
+            # (basically a graph subtraction algorithm).
+            #
+            if not config.precedenceFilterSuppressed:
+                context = statesFromAlt1.get(config.state.stateNumber, None)
+                if context==config.context:
+                    # eliminated
+                    continue
+
+            configSet.add(config, self.mergeCache)
+
+        return configSet
+
+    def getReachableTarget(self, trans:Transition, ttype:int):
+        if trans.matches(ttype, 0, self.atn.maxTokenType):
+            return trans.target
+        else:
+            return None
+
+    def getPredsForAmbigAlts(self, ambigAlts:set, configs:ATNConfigSet, nalts:int):
+        # REACH=[1|1|[]|0:0, 1|2|[]|0:1]
+        # altToPred starts as an array of all null contexts. The entry at index i
+        # corresponds to alternative i. altToPred[i] may have one of three values:
+        #   1. null: no ATNConfig c is found such that c.alt==i
+        #   2. SemanticContext.NONE: At least one ATNConfig c exists such that
+        #      c.alt==i and c.semanticContext==SemanticContext.NONE. In other words,
+        #      alt i has at least one unpredicated config.
+        #   3. Non-NONE Semantic Context: There exists at least one, and for all
+        #      ATNConfig c such that c.alt==i, c.semanticContext!=SemanticContext.NONE.
+        #
+        # From this, it is clear that NONE||anything==NONE.
+        #
+        altToPred = [None] * (nalts + 1)
+        for c in configs:
+            if c.alt in ambigAlts:
+                altToPred[c.alt] = orContext(altToPred[c.alt], c.semanticContext)
+
+        nPredAlts = 0
+        for i in range(1, nalts+1):
+            if altToPred[i] is None:
+                altToPred[i] = SemanticContext.NONE
+            elif altToPred[i] is not SemanticContext.NONE:
+                nPredAlts += 1
+
+        # nonambig alts are null in altToPred
+        if nPredAlts==0:
+            altToPred = None
+        if self.debug:
+            print("getPredsForAmbigAlts result " + str_list(altToPred))
+        return altToPred
+
+    def getPredicatePredictions(self, ambigAlts:set, altToPred:list):
+        pairs = []
+        containsPredicate = False
+        for i in range(1, len(altToPred)):
+            pred = altToPred[i]
+            # unpredicated is indicated by SemanticContext.NONE
+            if ambigAlts is not None and i in ambigAlts:
+                pairs.append(PredPrediction(pred, i))
+            if pred is not SemanticContext.NONE:
+                containsPredicate = True
+
+        if not containsPredicate:
+            return None
+
+        return pairs
+
+    #
+    # This method is used to improve the localization of error messages by
+    # choosing an alternative rather than throwing a
+    # {@link NoViableAltException} in particular prediction scenarios where the
+    # {@link #ERROR} state was reached during ATN simulation.
+    #
+    # <p>
+    # The default implementation of this method uses the following
+    # algorithm to identify an ATN configuration which successfully parsed the
+    # decision entry rule. Choosing such an alternative ensures that the
+    # {@link ParserRuleContext} returned by the calling rule will be complete
+    # and valid, and the syntax error will be reported later at a more
+    # localized location.</p>
+    #
+    # <ul>
+    # <li>If a syntactically valid path or paths reach the end of the decision rule and
+    # they are semantically valid if predicated, return the min associated alt.</li>
+    # <li>Else, if a semantically invalid but syntactically valid path exist
+    # or paths exist, return the minimum associated alt.
+    # </li>
+    # <li>Otherwise, return {@link ATN#INVALID_ALT_NUMBER}.</li>
+    # </ul>
+    #
+    # <p>
+    # In some scenarios, the algorithm described above could predict an
+    # alternative which will result in a {@link FailedPredicateException} in
+    # the parser. Specifically, this could occur if the <em>only</em> configuration
+    # capable of successfully parsing to the end of the decision rule is
+    # blocked by a semantic predicate. By choosing this alternative within
+    # {@link #adaptivePredict} instead of throwing a
+    # {@link NoViableAltException}, the resulting
+    # {@link FailedPredicateException} in the parser will identify the specific
+    # predicate which is preventing the parser from successfully parsing the
+    # decision rule, which helps developers identify and correct logic errors
+    # in semantic predicates.
+    # </p>
+    #
+    # @param configs The ATN configurations which were valid immediately before
+    # the {@link #ERROR} state was reached
+    # @param outerContext The is the \gamma_0 initial parser context from the paper
+    # or the parser stack at the instant before prediction commences.
+    #
+    # @return The value to return from {@link #adaptivePredict}, or
+    # {@link ATN#INVALID_ALT_NUMBER} if a suitable alternative was not
+    # identified and {@link #adaptivePredict} should report an error instead.
+    #
+    def getSynValidOrSemInvalidAltThatFinishedDecisionEntryRule(self, configs:ATNConfigSet, outerContext:ParserRuleContext):
+        semValidConfigs, semInvalidConfigs = self.splitAccordingToSemanticValidity(configs, outerContext)
+        alt = self.getAltThatFinishedDecisionEntryRule(semValidConfigs)
+        if alt!=ATN.INVALID_ALT_NUMBER: # semantically/syntactically viable path exists
+            return alt
+        # Is there a syntactically valid path with a failed pred?
+        if len(semInvalidConfigs)>0:
+            alt = self.getAltThatFinishedDecisionEntryRule(semInvalidConfigs)
+            if alt!=ATN.INVALID_ALT_NUMBER: # syntactically viable path exists
+                return alt
+        return ATN.INVALID_ALT_NUMBER
+
+    def getAltThatFinishedDecisionEntryRule(self, configs:ATNConfigSet):
+        alts = set()
+        for c in configs:
+            if c.reachesIntoOuterContext>0 or (isinstance(c.state, RuleStopState) and c.context.hasEmptyPath() ):
+                alts.add(c.alt)
+        if len(alts)==0:
+            return ATN.INVALID_ALT_NUMBER
+        else:
+            return min(alts)
+
+    # Walk the list of configurations and split them according to
+    #  those that have preds evaluating to true/false.  If no pred, assume
+    #  true pred and include in succeeded set.  Returns Pair of sets.
+    #
+    #  Create a new set so as not to alter the incoming parameter.
+    #
+    #  Assumption: the input stream has been restored to the starting point
+    #  prediction, which is where predicates need to evaluate.
+    #
+    def splitAccordingToSemanticValidity(self, configs:ATNConfigSet, outerContext:ParserRuleContext):
+        succeeded = ATNConfigSet(configs.fullCtx)
+        failed = ATNConfigSet(configs.fullCtx)
+        for c in configs:
+            if c.semanticContext is not SemanticContext.NONE:
+                predicateEvaluationResult = c.semanticContext.eval(self.parser, outerContext)
+                if predicateEvaluationResult:
+                    succeeded.add(c)
+                else:
+                    failed.add(c)
+            else:
+                succeeded.add(c)
+        return (succeeded,failed)
+
+    # Look through a list of predicate/alt pairs, returning alts for the
+    #  pairs that win. A {@code NONE} predicate indicates an alt containing an
+    #  unpredicated config which behaves as "always true." If !complete
+    #  then we stop at the first predicate that evaluates to true. This
+    #  includes pairs with null predicates.
+    #
+    def evalSemanticContext(self, predPredictions:list, outerContext:ParserRuleContext, complete:bool):
+        predictions = set()
+        for pair in predPredictions:
+            if pair.pred is SemanticContext.NONE:
+                predictions.add(pair.alt)
+                if not complete:
+                    break
+                continue
+            predicateEvaluationResult = pair.pred.eval(self.parser, outerContext)
+            if self.debug or self.dfa_debug:
+                print("eval pred " + str(pair) + "=" + str(predicateEvaluationResult))
+
+            if predicateEvaluationResult:
+                if self.debug or self.dfa_debug:
+                    print("PREDICT " + str(pair.alt))
+                predictions.add(pair.alt)
+                if not complete:
+                    break
+        return predictions
+
+
+    # TODO: If we are doing predicates, there is no point in pursuing
+    #     closure operations if we reach a DFA state that uniquely predicts
+    #     alternative. We will not be caching that DFA state and it is a
+    #     waste to pursue the closure. Might have to advance when we do
+    #     ambig detection thought :(
+    #
+
+    def closure(self, config:ATNConfig, configs:ATNConfigSet, closureBusy:set, collectPredicates:bool, fullCtx:bool, treatEofAsEpsilon:bool):
+        initialDepth = 0
+        self.closureCheckingStopState(config, configs, closureBusy, collectPredicates,
+                                 fullCtx, initialDepth, treatEofAsEpsilon)
+
+
+    def closureCheckingStopState(self, config:ATNConfig, configs:ATNConfigSet, closureBusy:set, collectPredicates:bool, fullCtx:bool, depth:int, treatEofAsEpsilon:bool):
+        if self.debug:
+            print("closure(" + config.toString(self.parser,True) + ")")
+
+        if isinstance(config.state, RuleStopState):
+            # We hit rule end. If we have context info, use it
+            # run thru all possible stack tops in ctx
+            if not config.context.isEmpty():
+                for i in range(0, len(config.context)):
+                    state = config.context.getReturnState(i)
+                    if state is PredictionContext.EMPTY_RETURN_STATE:
+                        if fullCtx:
+                            configs.add(ATNConfig(state=config.state, context=PredictionContext.EMPTY, config=config), self.mergeCache)
+                            continue
+                        else:
+                            # we have no context info, just chase follow links (if greedy)
+                            if self.debug:
+                                print("FALLING off rule " + self.getRuleName(config.state.ruleIndex))
+                            self.closure_(config, configs, closureBusy, collectPredicates,
+                                     fullCtx, depth, treatEofAsEpsilon)
+                        continue
+                    returnState = self.atn.states[state]
+                    newContext = config.context.getParent(i) # "pop" return state
+                    c = ATNConfig(state=returnState, alt=config.alt, context=newContext, semantic=config.semanticContext)
+                    # While we have context to pop back from, we may have
+                    # gotten that context AFTER having falling off a rule.
+                    # Make sure we track that we are now out of context.
+                    c.reachesIntoOuterContext = config.reachesIntoOuterContext
+                    self.closureCheckingStopState(c, configs, closureBusy, collectPredicates, fullCtx, depth - 1, treatEofAsEpsilon)
+                return
+            elif fullCtx:
+                # reached end of start rule
+                configs.add(config, self.mergeCache)
+                return
+            else:
+                # else if we have no context info, just chase follow links (if greedy)
+                if self.debug:
+                    print("FALLING off rule " + self.getRuleName(config.state.ruleIndex))
+
+        self.closure_(config, configs, closureBusy, collectPredicates, fullCtx, depth, treatEofAsEpsilon)
+
+    # Do the actual work of walking epsilon edges#
+    def closure_(self, config:ATNConfig, configs:ATNConfigSet, closureBusy:set, collectPredicates:bool, fullCtx:bool, depth:int, treatEofAsEpsilon:bool):
+        p = config.state
+        # optimization
+        if not p.epsilonOnlyTransitions:
+            configs.add(config, self.mergeCache)
+            # make sure to not return here, because EOF transitions can act as
+            # both epsilon transitions and non-epsilon transitions.
+
+        for t in p.transitions:
+            continueCollecting = collectPredicates and not isinstance(t, ActionTransition)
+            c = self.getEpsilonTarget(config, t, continueCollecting, depth == 0, fullCtx, treatEofAsEpsilon)
+            if c is not None:
+                if not t.isEpsilon:
+                    if c in closureBusy:
+                        # avoid infinite recursion for EOF* and EOF+
+                        continue
+                    closureBusy.add(c)
+                newDepth = depth
+                if isinstance( config.state, RuleStopState):
+                    # target fell off end of rule; mark resulting c as having dipped into outer context
+                    # We can't get here if incoming config was rule stop and we had context
+                    # track how far we dip into outer context.  Might
+                    # come in handy and we avoid evaluating context dependent
+                    # preds if this is > 0.
+
+                    if c in closureBusy:
+                        # avoid infinite recursion for right-recursive rules
+                        continue
+                    closureBusy.add(c)
+
+                    if self._dfa is not None and self._dfa.precedenceDfa:
+                        if t.outermostPrecedenceReturn == self._dfa.atnStartState.ruleIndex:
+                            c.precedenceFilterSuppressed = True
+                    c.reachesIntoOuterContext += 1
+                    configs.dipsIntoOuterContext = True # TODO: can remove? only care when we add to set per middle of this method
+                    newDepth -= 1
+                    if self.debug:
+                        print("dips into outer ctx: " + str(c))
+                elif isinstance(t, RuleTransition):
+                    # latch when newDepth goes negative - once we step out of the entry context we can't return
+                    if newDepth >= 0:
+                        newDepth += 1
+
+                self.closureCheckingStopState(c, configs, closureBusy, continueCollecting, fullCtx, newDepth, treatEofAsEpsilon)
+
+    def getRuleName(self, index:int):
+        if self.parser is not None and index>=0:
+            return self.parser.ruleNames[index]
+        else:
+            return "<rule " + str(index) + ">"
+
+    epsilonTargetMethods = dict()
+    epsilonTargetMethods[Transition.RULE] = lambda sim, config, t, collectPredicates, inContext, fullCtx, treatEofAsEpsilon: \
+        sim.ruleTransition(config, t)
+    epsilonTargetMethods[Transition.PRECEDENCE] = lambda sim, config, t, collectPredicates, inContext, fullCtx, treatEofAsEpsilon: \
+        sim.precedenceTransition(config, t, collectPredicates, inContext, fullCtx)
+    epsilonTargetMethods[Transition.PREDICATE] = lambda sim, config, t, collectPredicates, inContext, fullCtx, treatEofAsEpsilon: \
+        sim.predTransition(config, t, collectPredicates, inContext, fullCtx)
+    epsilonTargetMethods[Transition.ACTION] = lambda sim, config, t, collectPredicates, inContext, fullCtx, treatEofAsEpsilon: \
+        sim.actionTransition(config, t)
+    epsilonTargetMethods[Transition.EPSILON] = lambda sim, config, t, collectPredicates, inContext, fullCtx, treatEofAsEpsilon: \
+        ATNConfig(state=t.target, config=config)
+    epsilonTargetMethods[Transition.ATOM] = lambda sim, config, t, collectPredicates, inContext, fullCtx, treatEofAsEpsilon: \
+        ATNConfig(state=t.target, config=config) if treatEofAsEpsilon and t.matches(Token.EOF, 0, 1) else None
+    epsilonTargetMethods[Transition.RANGE] = lambda sim, config, t, collectPredicates, inContext, fullCtx, treatEofAsEpsilon: \
+        ATNConfig(state=t.target, config=config) if treatEofAsEpsilon and t.matches(Token.EOF, 0, 1) else None
+    epsilonTargetMethods[Transition.SET] = lambda sim, config, t, collectPredicates, inContext, fullCtx, treatEofAsEpsilon: \
+        ATNConfig(state=t.target, config=config) if treatEofAsEpsilon and t.matches(Token.EOF, 0, 1) else None
+
+    def getEpsilonTarget(self, config:ATNConfig, t:Transition, collectPredicates:bool, inContext:bool, fullCtx:bool, treatEofAsEpsilon:bool):
+        m = self.epsilonTargetMethods.get(t.serializationType, None)
+        if m is None:
+            return None
+        else:
+            return m(self, config, t, collectPredicates, inContext, fullCtx, treatEofAsEpsilon)
+
+    def actionTransition(self, config:ATNConfig, t:ActionTransition):
+        if self.debug:
+            print("ACTION edge " + str(t.ruleIndex) + ":" + str(t.actionIndex))
+        return ATNConfig(state=t.target, config=config)
+
+    def precedenceTransition(self, config:ATNConfig, pt:PrecedencePredicateTransition,  collectPredicates:bool, inContext:bool, fullCtx:bool):
+        if self.debug:
+            print("PRED (collectPredicates=" + str(collectPredicates) + ") " +
+                    str(pt.precedence) + ">=_p, ctx dependent=true")
+            if self.parser is not None:
+                print("context surrounding pred is " + str(self.parser.getRuleInvocationStack()))
+
+        c = None
+        if collectPredicates and inContext:
+            if fullCtx:
+                # In full context mode, we can evaluate predicates on-the-fly
+                # during closure, which dramatically reduces the size of
+                # the config sets. It also obviates the need to test predicates
+                # later during conflict resolution.
+                currentPosition = self._input.index
+                self._input.seek(self._startIndex)
+                predSucceeds = pt.getPredicate().eval(self.parser, self._outerContext)
+                self._input.seek(currentPosition)
+                if predSucceeds:
+                    c = ATNConfig(state=pt.target, config=config) # no pred context
+            else:
+                newSemCtx = andContext(config.semanticContext, pt.getPredicate())
+                c = ATNConfig(state=pt.target, semantic=newSemCtx, config=config)
+        else:
+            c = ATNConfig(state=pt.target, config=config)
+
+        if self.debug:
+            print("config from pred transition=" + str(c))
+        return c
+
+    def predTransition(self, config:ATNConfig, pt:PredicateTransition, collectPredicates:bool, inContext:bool, fullCtx:bool):
+        if self.debug:
+            print("PRED (collectPredicates=" + str(collectPredicates) + ") " + str(pt.ruleIndex) +
+                    ":" + str(pt.predIndex) + ", ctx dependent=" + str(pt.isCtxDependent))
+            if self.parser is not None:
+                print("context surrounding pred is " + str(self.parser.getRuleInvocationStack()))
+
+        c = None
+        if collectPredicates and (not pt.isCtxDependent or (pt.isCtxDependent and inContext)):
+            if fullCtx:
+                # In full context mode, we can evaluate predicates on-the-fly
+                # during closure, which dramatically reduces the size of
+                # the config sets. It also obviates the need to test predicates
+                # later during conflict resolution.
+                currentPosition = self._input.index
+                self._input.seek(self._startIndex)
+                predSucceeds = pt.getPredicate().eval(self.parser, self._outerContext)
+                self._input.seek(currentPosition)
+                if predSucceeds:
+                    c = ATNConfig(state=pt.target, config=config) # no pred context
+            else:
+                newSemCtx = andContext(config.semanticContext, pt.getPredicate())
+                c = ATNConfig(state=pt.target, semantic=newSemCtx, config=config)
+        else:
+            c = ATNConfig(state=pt.target, config=config)
+
+        if self.debug:
+            print("config from pred transition=" + str(c))
+        return c
+
+    def ruleTransition(self, config:ATNConfig, t:RuleTransition):
+        if self.debug:
+            print("CALL rule " + self.getRuleName(t.target.ruleIndex) + ", ctx=" + str(config.context))
+        returnState = t.followState
+        newContext = SingletonPredictionContext.create(config.context, returnState.stateNumber)
+        return ATNConfig(state=t.target, context=newContext, config=config )
+
+    def getConflictingAlts(self, configs:ATNConfigSet):
+        altsets = PredictionMode.getConflictingAltSubsets(configs)
+        return PredictionMode.getAlts(altsets)
+
+     # Sam pointed out a problem with the previous definition, v3, of
+     # ambiguous states. If we have another state associated with conflicting
+     # alternatives, we should keep going. For example, the following grammar
+     #
+     # s : (ID | ID ID?) ';' ;
+     #
+     # When the ATN simulation reaches the state before ';', it has a DFA
+     # state that looks like: [12|1|[], 6|2|[], 12|2|[]]. Naturally
+     # 12|1|[] and 12|2|[] conflict, but we cannot stop processing this node
+     # because alternative to has another way to continue, via [6|2|[]].
+     # The key is that we have a single state that has config's only associated
+     # with a single alternative, 2, and crucially the state transitions
+     # among the configurations are all non-epsilon transitions. That means
+     # we don't consider any conflicts that include alternative 2. So, we
+     # ignore the conflict between alts 1 and 2. We ignore a set of
+     # conflicting alts when there is an intersection with an alternative
+     # associated with a single alt state in the state&rarr;config-list map.
+     #
+     # It's also the case that we might have two conflicting configurations but
+     # also a 3rd nonconflicting configuration for a different alternative:
+     # [1|1|[], 1|2|[], 8|3|[]]. This can come about from grammar:
+     #
+     # a : A | A | A B ;
+     #
+     # After matching input A, we reach the stop state for rule A, state 1.
+     # State 8 is the state right before B. Clearly alternatives 1 and 2
+     # conflict and no amount of further lookahead will separate the two.
+     # However, alternative 3 will be able to continue and so we do not
+     # stop working on this state. In the previous example, we're concerned
+     # with states associated with the conflicting alternatives. Here alt
+     # 3 is not associated with the conflicting configs, but since we can continue
+     # looking for input reasonably, I don't declare the state done. We
+     # ignore a set of conflicting alts when we have an alternative
+     # that we still need to pursue.
+    #
+
+    def getConflictingAltsOrUniqueAlt(self, configs:ATNConfigSet):
+        conflictingAlts = None
+        if configs.uniqueAlt!= ATN.INVALID_ALT_NUMBER:
+            conflictingAlts = set()
+            conflictingAlts.add(configs.uniqueAlt)
+        else:
+            conflictingAlts = configs.conflictingAlts
+        return conflictingAlts
+
+    def getTokenName(self, t:int):
+        if t==Token.EOF:
+            return "EOF"
+        if self.parser is not None and self.parser.tokenNames is not None:
+            if t >= len(self.parser.tokenNames):
+                print(str(t) + " ttype out of range: " + str_list(self.parser.tokenNames))
+                print(str_list(self.parser.getInputStream().getTokens()))
+            else:
+                return self.parser.tokensNames[t] + "<" + str(t) + ">"
+        return str(t)
+
+    def getLookaheadName(self, input:TokenStream):
+        return self.getTokenName(input.LA(1))
+
+    # Used for debugging in adaptivePredict around execATN but I cut
+    #  it out for clarity now that alg. works well. We can leave this
+    #  "dead" code for a bit.
+    #
+    def dumpDeadEndConfigs(self, nvae:NoViableAltException):
+        print("dead end configs: ")
+        for c in nvae.getDeadEndConfigs():
+            trans = "no edges"
+            if len(c.state.transitions)>0:
+                t = c.state.transitions[0]
+                if isinstance(t, AtomTransition):
+                    trans = "Atom "+ self.getTokenName(t.label)
+                elif isinstance(t, SetTransition):
+                    neg = isinstance(t, NotSetTransition)
+                    trans = ("~" if neg else "")+"Set "+ str(t.set)
+            print(c.toString(self.parser, True) + ":" + trans, file=sys.stderr)
+
+    def noViableAlt(self, input:TokenStream, outerContext:ParserRuleContext, configs:ATNConfigSet, startIndex:int):
+        return NoViableAltException(self.parser, input, input.get(startIndex), input.LT(1), configs, outerContext)
+
+    def getUniqueAlt(self, configs:ATNConfigSet):
+        alt = ATN.INVALID_ALT_NUMBER
+        for c in configs:
+            if alt == ATN.INVALID_ALT_NUMBER:
+                alt = c.alt # found first alt
+            elif c.alt!=alt:
+                return ATN.INVALID_ALT_NUMBER
+        return alt
+
+    #
+    # Add an edge to the DFA, if possible. This method calls
+    # {@link #addDFAState} to ensure the {@code to} state is present in the
+    # DFA. If {@code from} is {@code null}, or if {@code t} is outside the
+    # range of edges that can be represented in the DFA tables, this method
+    # returns without adding the edge to the DFA.
+    #
+    # <p>If {@code to} is {@code null}, this method returns {@code null}.
+    # Otherwise, this method returns the {@link DFAState} returned by calling
+    # {@link #addDFAState} for the {@code to} state.</p>
+    #
+    # @param dfa The DFA
+    # @param from The source state for the edge
+    # @param t The input symbol
+    # @param to The target state for the edge
+    #
+    # @return If {@code to} is {@code null}, this method returns {@code null};
+    # otherwise this method returns the result of calling {@link #addDFAState}
+    # on {@code to}
+    #
+    def addDFAEdge(self, dfa:DFA, from_:DFAState, t:int, to:DFAState):
+        if self.debug:
+            print("EDGE " + str(from_) + " -> " + str(to) + " upon " + self.getTokenName(t))
+
+        if to is None:
+            return None
+
+        to = self.addDFAState(dfa, to) # used existing if possible not incoming
+        if from_ is None or t < -1 or t > self.atn.maxTokenType:
+            return to
+
+        if from_.edges is None:
+            from_.edges = [None] * (self.atn.maxTokenType + 2)
+        from_.edges[t+1] = to # connect
+
+        if self.debug:
+            names = None if self.parser is None else self.parser.tokenNames
+            print("DFA=\n" + dfa.toString(names))
+
+        return to
+
+    #
+    # Add state {@code D} to the DFA if it is not already present, and return
+    # the actual instance stored in the DFA. If a state equivalent to {@code D}
+    # is already in the DFA, the existing state is returned. Otherwise this
+    # method returns {@code D} after adding it to the DFA.
+    #
+    # <p>If {@code D} is {@link #ERROR}, this method returns {@link #ERROR} and
+    # does not change the DFA.</p>
+    #
+    # @param dfa The dfa
+    # @param D The DFA state to add
+    # @return The state stored in the DFA. This will be either the existing
+    # state if {@code D} is already in the DFA, or {@code D} itself if the
+    # state was not already present.
+    #
+    def addDFAState(self, dfa:DFA, D:DFAState):
+        if D is self.ERROR:
+            return D
+
+
+        existing = dfa.states.get(D, None)
+        if existing is not None:
+            return existing
+
+        D.stateNumber = len(dfa.states)
+        if not D.configs.readonly:
+            D.configs.optimizeConfigs(self)
+            D.configs.setReadonly(True)
+        dfa.states[D] = D
+        if self.debug:
+            print("adding new DFA state: " + str(D))
+        return D
+
+    def reportAttemptingFullContext(self, dfa:DFA, conflictingAlts:set, configs:ATNConfigSet, startIndex:int, stopIndex:int):
+        if self.debug or self.retry_debug:
+            interval = range(startIndex, stopIndex + 1)
+            print("reportAttemptingFullContext decision=" + str(dfa.decision) + ":" + str(configs) +
+                               ", input=" + self.parser.getTokenStream().getText(interval))
+        if self.parser is not None:
+            self.parser.getErrorListenerDispatch().reportAttemptingFullContext(self.parser, dfa, startIndex, stopIndex, conflictingAlts, configs)
+
+    def reportContextSensitivity(self, dfa:DFA, prediction:int, configs:ATNConfigSet, startIndex:int, stopIndex:int):
+        if self.debug or self.retry_debug:
+            interval = range(startIndex, stopIndex + 1)
+            print("reportContextSensitivity decision=" + str(dfa.decision) + ":" + str(configs) +
+                               ", input=" + self.parser.getTokenStream().getText(interval))
+        if self.parser is not None:
+            self.parser.getErrorListenerDispatch().reportContextSensitivity(self.parser, dfa, startIndex, stopIndex, prediction, configs)
+
+    # If context sensitive parsing, we know it's ambiguity not conflict#
+    def reportAmbiguity(self, dfa:DFA, D:DFAState, startIndex:int, stopIndex:int,
+                                   exact:bool, ambigAlts:set, configs:ATNConfigSet ):
+        if self.debug or self.retry_debug:
+#			ParserATNPathFinder finder = new ParserATNPathFinder(parser, atn);
+#			int i = 1;
+#			for (Transition t : dfa.atnStartState.transitions) {
+#				print("ALT "+i+"=");
+#				print(startIndex+".."+stopIndex+", len(input)="+parser.getInputStream().size());
+#				TraceTree path = finder.trace(t.target, parser.getContext(), (TokenStream)parser.getInputStream(),
+#											  startIndex, stopIndex);
+#				if ( path!=null ) {
+#					print("path = "+path.toStringTree());
+#					for (TraceTree leaf : path.leaves) {
+#						List<ATNState> states = path.getPathToNode(leaf);
+#						print("states="+states);
+#					}
+#				}
+#				i++;
+#			}
+            interval = range(startIndex, stopIndex + 1)
+            print("reportAmbiguity " + str(ambigAlts) + ":" + str(configs) +
+                               ", input=" + self.parser.getTokenStream().getText(interval))
+        if self.parser is not None:
+            self.parser.getErrorListenerDispatch().reportAmbiguity(self.parser, dfa, startIndex, stopIndex, exact, ambigAlts, configs)
+
diff --git a/runtime/Python3/src/antlr4/atn/PredictionMode.py b/runtime/Python3/src/antlr4/atn/PredictionMode.py
new file mode 100644
index 000000000..0fba6351f
--- /dev/null
+++ b/runtime/Python3/src/antlr4/atn/PredictionMode.py
@@ -0,0 +1,547 @@
+#
+# [The "BSD license"]
+#  Copyright (c) 2012 Terence Parr
+#  Copyright (c) 2012 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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.
+#
+#
+# This enumeration defines the prediction modes available in ANTLR 4 along with
+# utility methods for analyzing configuration sets for conflicts and/or
+# ambiguities.
+
+
+from enum import Enum
+from antlr4.atn.ATN import ATN
+from antlr4.atn.ATNConfig import ATNConfig
+from antlr4.atn.ATNConfigSet import ATNConfigSet
+from antlr4.atn.ATNState import RuleStopState
+from antlr4.atn.SemanticContext import SemanticContext
+
+PredictionMode = None
+
+class PredictionMode(Enum):
+    #
+    # The SLL(*) prediction mode. This prediction mode ignores the current
+    # parser context when making predictions. This is the fastest prediction
+    # mode, and provides correct results for many grammars. This prediction
+    # mode is more powerful than the prediction mode provided by ANTLR 3, but
+    # may result in syntax errors for grammar and input combinations which are
+    # not SLL.
+    #
+    # <p>
+    # When using this prediction mode, the parser will either return a correct
+    # parse tree (i.e. the same parse tree that would be returned with the
+    # {@link #LL} prediction mode), or it will report a syntax error. If a
+    # syntax error is encountered when using the {@link #SLL} prediction mode,
+    # it may be due to either an actual syntax error in the input or indicate
+    # that the particular combination of grammar and input requires the more
+    # powerful {@link #LL} prediction abilities to complete successfully.</p>
+    #
+    # <p>
+    # This prediction mode does not provide any guarantees for prediction
+    # behavior for syntactically-incorrect inputs.</p>
+    #
+    SLL = 0
+    #
+    # The LL(*) prediction mode. This prediction mode allows the current parser
+    # context to be used for resolving SLL conflicts that occur during
+    # prediction. This is the fastest prediction mode that guarantees correct
+    # parse results for all combinations of grammars with syntactically correct
+    # inputs.
+    #
+    # <p>
+    # When using this prediction mode, the parser will make correct decisions
+    # for all syntactically-correct grammar and input combinations. However, in
+    # cases where the grammar is truly ambiguous this prediction mode might not
+    # report a precise answer for <em>exactly which</em> alternatives are
+    # ambiguous.</p>
+    #
+    # <p>
+    # This prediction mode does not provide any guarantees for prediction
+    # behavior for syntactically-incorrect inputs.</p>
+    #
+    LL = 1
+    #
+    # The LL(*) prediction mode with exact ambiguity detection. In addition to
+    # the correctness guarantees provided by the {@link #LL} prediction mode,
+    # this prediction mode instructs the prediction algorithm to determine the
+    # complete and exact set of ambiguous alternatives for every ambiguous
+    # decision encountered while parsing.
+    #
+    # <p>
+    # This prediction mode may be used for diagnosing ambiguities during
+    # grammar development. Due to the performance overhead of calculating sets
+    # of ambiguous alternatives, this prediction mode should be avoided when
+    # the exact results are not necessary.</p>
+    #
+    # <p>
+    # This prediction mode does not provide any guarantees for prediction
+    # behavior for syntactically-incorrect inputs.</p>
+    #
+    LL_EXACT_AMBIG_DETECTION = 2
+
+
+    #
+    # Computes the SLL prediction termination condition.
+    #
+    # <p>
+    # This method computes the SLL prediction termination condition for both of
+    # the following cases.</p>
+    #
+    # <ul>
+    # <li>The usual SLL+LL fallback upon SLL conflict</li>
+    # <li>Pure SLL without LL fallback</li>
+    # </ul>
+    #
+    # <p><strong>COMBINED SLL+LL PARSING</strong></p>
+    #
+    # <p>When LL-fallback is enabled upon SLL conflict, correct predictions are
+    # ensured regardless of how the termination condition is computed by this
+    # method. Due to the substantially higher cost of LL prediction, the
+    # prediction should only fall back to LL when the additional lookahead
+    # cannot lead to a unique SLL prediction.</p>
+    #
+    # <p>Assuming combined SLL+LL parsing, an SLL configuration set with only
+    # conflicting subsets should fall back to full LL, even if the
+    # configuration sets don't resolve to the same alternative (e.g.
+    # {@code {1,2}} and {@code {3,4}}. If there is at least one non-conflicting
+    # configuration, SLL could continue with the hopes that more lookahead will
+    # resolve via one of those non-conflicting configurations.</p>
+    #
+    # <p>Here's the prediction termination rule them: SLL (for SLL+LL parsing)
+    # stops when it sees only conflicting configuration subsets. In contrast,
+    # full LL keeps going when there is uncertainty.</p>
+    #
+    # <p><strong>HEURISTIC</strong></p>
+    #
+    # <p>As a heuristic, we stop prediction when we see any conflicting subset
+    # unless we see a state that only has one alternative associated with it.
+    # The single-alt-state thing lets prediction continue upon rules like
+    # (otherwise, it would admit defeat too soon):</p>
+    #
+    # <p>{@code [12|1|[], 6|2|[], 12|2|[]]. s : (ID | ID ID?) ';' ;}</p>
+    #
+    # <p>When the ATN simulation reaches the state before {@code ';'}, it has a
+    # DFA state that looks like: {@code [12|1|[], 6|2|[], 12|2|[]]}. Naturally
+    # {@code 12|1|[]} and {@code 12|2|[]} conflict, but we cannot stop
+    # processing this node because alternative to has another way to continue,
+    # via {@code [6|2|[]]}.</p>
+    #
+    # <p>It also let's us continue for this rule:</p>
+    #
+    # <p>{@code [1|1|[], 1|2|[], 8|3|[]] a : A | A | A B ;}</p>
+    #
+    # <p>After matching input A, we reach the stop state for rule A, state 1.
+    # State 8 is the state right before B. Clearly alternatives 1 and 2
+    # conflict and no amount of further lookahead will separate the two.
+    # However, alternative 3 will be able to continue and so we do not stop
+    # working on this state. In the previous example, we're concerned with
+    # states associated with the conflicting alternatives. Here alt 3 is not
+    # associated with the conflicting configs, but since we can continue
+    # looking for input reasonably, don't declare the state done.</p>
+    #
+    # <p><strong>PURE SLL PARSING</strong></p>
+    #
+    # <p>To handle pure SLL parsing, all we have to do is make sure that we
+    # combine stack contexts for configurations that differ only by semantic
+    # predicate. From there, we can do the usual SLL termination heuristic.</p>
+    #
+    # <p><strong>PREDICATES IN SLL+LL PARSING</strong></p>
+    #
+    # <p>SLL decisions don't evaluate predicates until after they reach DFA stop
+    # states because they need to create the DFA cache that works in all
+    # semantic situations. In contrast, full LL evaluates predicates collected
+    # during start state computation so it can ignore predicates thereafter.
+    # This means that SLL termination detection can totally ignore semantic
+    # predicates.</p>
+    #
+    # <p>Implementation-wise, {@link ATNConfigSet} combines stack contexts but not
+    # semantic predicate contexts so we might see two configurations like the
+    # following.</p>
+    #
+    # <p>{@code (s, 1, x, {}), (s, 1, x', {p})}</p>
+    #
+    # <p>Before testing these configurations against others, we have to merge
+    # {@code x} and {@code x'} (without modifying the existing configurations).
+    # For example, we test {@code (x+x')==x''} when looking for conflicts in
+    # the following configurations.</p>
+    #
+    # <p>{@code (s, 1, x, {}), (s, 1, x', {p}), (s, 2, x'', {})}</p>
+    #
+    # <p>If the configuration set has predicates (as indicated by
+    # {@link ATNConfigSet#hasSemanticContext}), this algorithm makes a copy of
+    # the configurations to strip out all of the predicates so that a standard
+    # {@link ATNConfigSet} will merge everything ignoring predicates.</p>
+    #
+    @classmethod
+    def hasSLLConflictTerminatingPrediction(cls, mode:PredictionMode, configs:ATNConfigSet):
+        # Configs in rule stop states indicate reaching the end of the decision
+        # rule (local context) or end of start rule (full context). If all
+        # configs meet this condition, then none of the configurations is able
+        # to match additional input so we terminate prediction.
+        #
+        if cls.allConfigsInRuleStopStates(configs):
+            return True
+
+        # pure SLL mode parsing
+        if mode == PredictionMode.SLL:
+            # Don't bother with combining configs from different semantic
+            # contexts if we can fail over to full LL; costs more time
+            # since we'll often fail over anyway.
+            if configs.hasSemanticContext:
+                # dup configs, tossing out semantic predicates
+                dup = ATNConfigSet()
+                for c in configs:
+                    c = ATNConfig(c,SemanticContext.NONE)
+                    dup.add(c)
+                configs = dup
+            # now we have combined contexts for configs with dissimilar preds
+
+        # pure SLL or combined SLL+LL mode parsing
+        altsets = cls.getConflictingAltSubsets(configs)
+        return cls.hasConflictingAltSet(altsets) and not cls.hasStateAssociatedWithOneAlt(configs)
+
+    # Checks if any configuration in {@code configs} is in a
+    # {@link RuleStopState}. Configurations meeting this condition have reached
+    # the end of the decision rule (local context) or end of start rule (full
+    # context).
+    #
+    # @param configs the configuration set to test
+    # @return {@code true} if any configuration in {@code configs} is in a
+    # {@link RuleStopState}, otherwise {@code false}
+    @classmethod
+    def hasConfigInRuleStopState(cls, configs:ATNConfigSet):
+        for c in configs:
+            if isinstance(c.state, RuleStopState):
+                return True
+        return False
+
+    # Checks if all configurations in {@code configs} are in a
+    # {@link RuleStopState}. Configurations meeting this condition have reached
+    # the end of the decision rule (local context) or end of start rule (full
+    # context).
+    #
+    # @param configs the configuration set to test
+    # @return {@code true} if all configurations in {@code configs} are in a
+    # {@link RuleStopState}, otherwise {@code false}
+    @classmethod
+    def allConfigsInRuleStopStates(cls, configs:ATNConfigSet):
+        for config in configs:
+            if not isinstance(config.state, RuleStopState):
+                return False
+        return True
+
+    #
+    # Full LL prediction termination.
+    #
+    # <p>Can we stop looking ahead during ATN simulation or is there some
+    # uncertainty as to which alternative we will ultimately pick, after
+    # consuming more input? Even if there are partial conflicts, we might know
+    # that everything is going to resolve to the same minimum alternative. That
+    # means we can stop since no more lookahead will change that fact. On the
+    # other hand, there might be multiple conflicts that resolve to different
+    # minimums. That means we need more look ahead to decide which of those
+    # alternatives we should predict.</p>
+    #
+    # <p>The basic idea is to split the set of configurations {@code C}, into
+    # conflicting subsets {@code (s, _, ctx, _)} and singleton subsets with
+    # non-conflicting configurations. Two configurations conflict if they have
+    # identical {@link ATNConfig#state} and {@link ATNConfig#context} values
+    # but different {@link ATNConfig#alt} value, e.g. {@code (s, i, ctx, _)}
+    # and {@code (s, j, ctx, _)} for {@code i!=j}.</p>
+    #
+    # <p>Reduce these configuration subsets to the set of possible alternatives.
+    # You can compute the alternative subsets in one pass as follows:</p>
+    #
+    # <p>{@code A_s,ctx = {i | (s, i, ctx, _)}} for each configuration in
+    # {@code C} holding {@code s} and {@code ctx} fixed.</p>
+    #
+    # <p>Or in pseudo-code, for each configuration {@code c} in {@code C}:</p>
+    #
+    # <pre>
+    # map[c] U= c.{@link ATNConfig#alt alt} # map hash/equals uses s and x, not
+    # alt and not pred
+    # </pre>
+    #
+    # <p>The values in {@code map} are the set of {@code A_s,ctx} sets.</p>
+    #
+    # <p>If {@code |A_s,ctx|=1} then there is no conflict associated with
+    # {@code s} and {@code ctx}.</p>
+    #
+    # <p>Reduce the subsets to singletons by choosing a minimum of each subset. If
+    # the union of these alternative subsets is a singleton, then no amount of
+    # more lookahead will help us. We will always pick that alternative. If,
+    # however, there is more than one alternative, then we are uncertain which
+    # alternative to predict and must continue looking for resolution. We may
+    # or may not discover an ambiguity in the future, even if there are no
+    # conflicting subsets this round.</p>
+    #
+    # <p>The biggest sin is to terminate early because it means we've made a
+    # decision but were uncertain as to the eventual outcome. We haven't used
+    # enough lookahead. On the other hand, announcing a conflict too late is no
+    # big deal; you will still have the conflict. It's just inefficient. It
+    # might even look until the end of file.</p>
+    #
+    # <p>No special consideration for semantic predicates is required because
+    # predicates are evaluated on-the-fly for full LL prediction, ensuring that
+    # no configuration contains a semantic context during the termination
+    # check.</p>
+    #
+    # <p><strong>CONFLICTING CONFIGS</strong></p>
+    #
+    # <p>Two configurations {@code (s, i, x)} and {@code (s, j, x')}, conflict
+    # when {@code i!=j} but {@code x=x'}. Because we merge all
+    # {@code (s, i, _)} configurations together, that means that there are at
+    # most {@code n} configurations associated with state {@code s} for
+    # {@code n} possible alternatives in the decision. The merged stacks
+    # complicate the comparison of configuration contexts {@code x} and
+    # {@code x'}. Sam checks to see if one is a subset of the other by calling
+    # merge and checking to see if the merged result is either {@code x} or
+    # {@code x'}. If the {@code x} associated with lowest alternative {@code i}
+    # is the superset, then {@code i} is the only possible prediction since the
+    # others resolve to {@code min(i)} as well. However, if {@code x} is
+    # associated with {@code j>i} then at least one stack configuration for
+    # {@code j} is not in conflict with alternative {@code i}. The algorithm
+    # should keep going, looking for more lookahead due to the uncertainty.</p>
+    #
+    # <p>For simplicity, I'm doing a equality check between {@code x} and
+    # {@code x'} that lets the algorithm continue to consume lookahead longer
+    # than necessary. The reason I like the equality is of course the
+    # simplicity but also because that is the test you need to detect the
+    # alternatives that are actually in conflict.</p>
+    #
+    # <p><strong>CONTINUE/STOP RULE</strong></p>
+    #
+    # <p>Continue if union of resolved alternative sets from non-conflicting and
+    # conflicting alternative subsets has more than one alternative. We are
+    # uncertain about which alternative to predict.</p>
+    #
+    # <p>The complete set of alternatives, {@code [i for (_,i,_)]}, tells us which
+    # alternatives are still in the running for the amount of input we've
+    # consumed at this point. The conflicting sets let us to strip away
+    # configurations that won't lead to more states because we resolve
+    # conflicts to the configuration with a minimum alternate for the
+    # conflicting set.</p>
+    #
+    # <p><strong>CASES</strong></p>
+    #
+    # <ul>
+    #
+    # <li>no conflicts and more than 1 alternative in set =&gt; continue</li>
+    #
+    # <li> {@code (s, 1, x)}, {@code (s, 2, x)}, {@code (s, 3, z)},
+    # {@code (s', 1, y)}, {@code (s', 2, y)} yields non-conflicting set
+    # {@code {3}} U conflicting sets {@code min({1,2})} U {@code min({1,2})} =
+    # {@code {1,3}} =&gt; continue
+    # </li>
+    #
+    # <li>{@code (s, 1, x)}, {@code (s, 2, x)}, {@code (s', 1, y)},
+    # {@code (s', 2, y)}, {@code (s'', 1, z)} yields non-conflicting set
+    # {@code {1}} U conflicting sets {@code min({1,2})} U {@code min({1,2})} =
+    # {@code {1}} =&gt; stop and predict 1</li>
+    #
+    # <li>{@code (s, 1, x)}, {@code (s, 2, x)}, {@code (s', 1, y)},
+    # {@code (s', 2, y)} yields conflicting, reduced sets {@code {1}} U
+    # {@code {1}} = {@code {1}} =&gt; stop and predict 1, can announce
+    # ambiguity {@code {1,2}}</li>
+    #
+    # <li>{@code (s, 1, x)}, {@code (s, 2, x)}, {@code (s', 2, y)},
+    # {@code (s', 3, y)} yields conflicting, reduced sets {@code {1}} U
+    # {@code {2}} = {@code {1,2}} =&gt; continue</li>
+    #
+    # <li>{@code (s, 1, x)}, {@code (s, 2, x)}, {@code (s', 3, y)},
+    # {@code (s', 4, y)} yields conflicting, reduced sets {@code {1}} U
+    # {@code {3}} = {@code {1,3}} =&gt; continue</li>
+    #
+    # </ul>
+    #
+    # <p><strong>EXACT AMBIGUITY DETECTION</strong></p>
+    #
+    # <p>If all states report the same conflicting set of alternatives, then we
+    # know we have the exact ambiguity set.</p>
+    #
+    # <p><code>|A_<em>i</em>|&gt;1</code> and
+    # <code>A_<em>i</em> = A_<em>j</em></code> for all <em>i</em>, <em>j</em>.</p>
+    #
+    # <p>In other words, we continue examining lookahead until all {@code A_i}
+    # have more than one alternative and all {@code A_i} are the same. If
+    # {@code A={{1,2}, {1,3}}}, then regular LL prediction would terminate
+    # because the resolved set is {@code {1}}. To determine what the real
+    # ambiguity is, we have to know whether the ambiguity is between one and
+    # two or one and three so we keep going. We can only stop prediction when
+    # we need exact ambiguity detection when the sets look like
+    # {@code A={{1,2}}} or {@code {{1,2},{1,2}}}, etc...</p>
+    #
+    @classmethod
+    def resolvesToJustOneViableAlt(cls, altsets:list):
+        return cls.getSingleViableAlt(altsets)
+
+    #
+    # Determines if every alternative subset in {@code altsets} contains more
+    # than one alternative.
+    #
+    # @param altsets a collection of alternative subsets
+    # @return {@code true} if every {@link BitSet} in {@code altsets} has
+    # {@link BitSet#cardinality cardinality} &gt; 1, otherwise {@code false}
+    #
+    @classmethod
+    def allSubsetsConflict(cls, altsets:list):
+        return not cls.hasNonConflictingAltSet(altsets)
+
+    #
+    # Determines if any single alternative subset in {@code altsets} contains
+    # exactly one alternative.
+    #
+    # @param altsets a collection of alternative subsets
+    # @return {@code true} if {@code altsets} contains a {@link BitSet} with
+    # {@link BitSet#cardinality cardinality} 1, otherwise {@code false}
+    #
+    @classmethod
+    def hasNonConflictingAltSet(cls, altsets:list):
+        for alts in altsets:
+            if len(alts)==1:
+                return True
+        return False
+
+    #
+    # Determines if any single alternative subset in {@code altsets} contains
+    # more than one alternative.
+    #
+    # @param altsets a collection of alternative subsets
+    # @return {@code true} if {@code altsets} contains a {@link BitSet} with
+    # {@link BitSet#cardinality cardinality} &gt; 1, otherwise {@code false}
+    #
+    @classmethod
+    def hasConflictingAltSet(cls, altsets:list):
+        for alts in altsets:
+            if len(alts)>1:
+                return True
+        return False
+
+    #
+    # Determines if every alternative subset in {@code altsets} is equivalent.
+    #
+    # @param altsets a collection of alternative subsets
+    # @return {@code true} if every member of {@code altsets} is equal to the
+    # others, otherwise {@code false}
+    #
+    @classmethod
+    def allSubsetsEqual(cls, altsets:list):
+        first = None
+        for alts in altsets:
+            if first is None:
+                first = alts
+            elif not alts==first:
+                return False
+        return True
+
+    #
+    # Returns the unique alternative predicted by all alternative subsets in
+    # {@code altsets}. If no such alternative exists, this method returns
+    # {@link ATN#INVALID_ALT_NUMBER}.
+    #
+    # @param altsets a collection of alternative subsets
+    #
+    @classmethod
+    def getUniqueAlt(cls, altsets:list):
+        all = cls.getAlts(altsets)
+        if len(all)==1:
+            return all[0]
+        else:
+            return ATN.INVALID_ALT_NUMBER
+
+    # Gets the complete set of represented alternatives for a collection of
+    # alternative subsets. This method returns the union of each {@link BitSet}
+    # in {@code altsets}.
+    #
+    # @param altsets a collection of alternative subsets
+    # @return the set of represented alternatives in {@code altsets}
+    #
+    @classmethod
+    def getAlts(cls, altsets:list):
+        all = set()
+        for alts in altsets:
+            all = all | alts
+        return all
+
+    #
+    # This function gets the conflicting alt subsets from a configuration set.
+    # For each configuration {@code c} in {@code configs}:
+    #
+    # <pre>
+    # map[c] U= c.{@link ATNConfig#alt alt} # map hash/equals uses s and x, not
+    # alt and not pred
+    # </pre>
+    #
+    @classmethod
+    def getConflictingAltSubsets(cls, configs:ATNConfigSet):
+        configToAlts = dict()
+        for c in configs:
+            h = hash((c.state.stateNumber, c.context))
+            alts = configToAlts.get(h, None)
+            if alts is None:
+                alts = set()
+                configToAlts[h] = alts
+            alts.add(c.alt)
+        return configToAlts.values()
+
+    #
+    # Get a map from state to alt subset from a configuration set. For each
+    # configuration {@code c} in {@code configs}:
+    #
+    # <pre>
+    # map[c.{@link ATNConfig#state state}] U= c.{@link ATNConfig#alt alt}
+    # </pre>
+    #
+    @classmethod
+    def getStateToAltMap(cls, configs:ATNConfigSet):
+        m = dict()
+        for c in configs:
+            alts = m.get(c.state, None)
+            if alts is None:
+                alts = set()
+                m[c.state] = alts
+            alts.add(c.alt)
+        return m
+
+    @classmethod
+    def hasStateAssociatedWithOneAlt(cls, configs:ATNConfigSet):
+        x = cls.getStateToAltMap(configs)
+        for alts in x.values():
+            if len(alts)==1:
+                return True
+        return False
+
+    @classmethod
+    def getSingleViableAlt(cls, altsets:list):
+        viableAlts = set()
+        for alts in altsets:
+            minAlt = min(alts)
+            viableAlts.add(minAlt)
+            if len(viableAlts)>1 : # more than 1 viable alt
+                return ATN.INVALID_ALT_NUMBER
+        return min(viableAlts)
diff --git a/runtime/Python3/src/antlr4/atn/SemanticContext.py b/runtime/Python3/src/antlr4/atn/SemanticContext.py
new file mode 100644
index 000000000..c012e35c2
--- /dev/null
+++ b/runtime/Python3/src/antlr4/atn/SemanticContext.py
@@ -0,0 +1,361 @@
+#
+# [The "BSD license"]
+#  Copyright (c) 2012 Terence Parr
+#  Copyright (c) 2012 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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 tree structure used to record the semantic context in which
+#  an ATN configuration is valid.  It's either a single predicate,
+#  a conjunction {@code p1&&p2}, or a sum of products {@code p1||p2}.
+#
+#  <p>I have scoped the {@link AND}, {@link OR}, and {@link Predicate} subclasses of
+#  {@link SemanticContext} within the scope of this outer class.</p>
+#
+from io import StringIO
+from antlr4.Recognizer import Recognizer
+from antlr4.RuleContext import RuleContext
+
+
+class SemanticContext(object):
+    #
+    # The default {@link SemanticContext}, which is semantically equivalent to
+    # a predicate of the form {@code {true}?}.
+    #
+    NONE = None
+
+    #
+    # For context independent predicates, we evaluate them without a local
+    # context (i.e., null context). That way, we can evaluate them without
+    # having to create proper rule-specific context during prediction (as
+    # opposed to the parser, which creates them naturally). In a practical
+    # sense, this avoids a cast exception from RuleContext to myruleContext.
+    #
+    # <p>For context dependent predicates, we must pass in a local context so that
+    # references such as $arg evaluate properly as _localctx.arg. We only
+    # capture context dependent predicates in the context in which we begin
+    # prediction, so we passed in the outer context here in case of context
+    # dependent predicate evaluation.</p>
+    #
+    def eval(self, parser:Recognizer , outerContext:RuleContext ):
+        pass
+
+    #
+    # Evaluate the precedence predicates for the context and reduce the result.
+    #
+    # @param parser The parser instance.
+    # @param outerContext The current parser context object.
+    # @return The simplified semantic context after precedence predicates are
+    # evaluated, which will be one of the following values.
+    # <ul>
+    # <li>{@link #NONE}: if the predicate simplifies to {@code true} after
+    # precedence predicates are evaluated.</li>
+    # <li>{@code null}: if the predicate simplifies to {@code false} after
+    # precedence predicates are evaluated.</li>
+    # <li>{@code this}: if the semantic context is not changed as a result of
+    # precedence predicate evaluation.</li>
+    # <li>A non-{@code null} {@link SemanticContext}: the new simplified
+    # semantic context after precedence predicates are evaluated.</li>
+    # </ul>
+    #
+    def evalPrecedence(self, parser:Recognizer, outerContext:RuleContext):
+        return self
+
+# need forward declaration
+AND = None
+
+def andContext(a:SemanticContext, b:SemanticContext):
+    if a is None or a is SemanticContext.NONE:
+        return b
+    if b is None or b is SemanticContext.NONE:
+        return a
+    result = AND(a, b)
+    if len(result.opnds) == 1:
+        return result.opnds[0]
+    else:
+        return result
+
+# need forward declaration
+OR = None
+
+def orContext(a:SemanticContext, b:SemanticContext):
+    if a is None:
+        return b
+    if b is None:
+        return a
+    if a is SemanticContext.NONE or b is SemanticContext.NONE:
+        return SemanticContext.NONE
+    result = OR(a, b)
+    if len(result.opnds) == 1:
+        return result.opnds[0]
+    else:
+        return result
+
+def filterPrecedencePredicates(collection:list):
+    result = []
+    for context in collection:
+        if isinstance(context, PrecedencePredicate):
+            if result is None:
+                result = []
+            result.append(context)
+    return result
+
+
+class Predicate(SemanticContext):
+
+    def __init__(self, ruleIndex:int=-1, predIndex:int=-1, isCtxDependent:bool=False):
+        self.ruleIndex = ruleIndex
+        self.predIndex = predIndex
+        self.isCtxDependent = isCtxDependent # e.g., $i ref in pred
+
+    def eval(self, parser:Recognizer , outerContext:RuleContext ):
+        localctx = outerContext if self.isCtxDependent else None
+        return parser.sempred(localctx, self.ruleIndex, self.predIndex)
+
+    def __hash__(self):
+        return hash((self.ruleIndex, self.predIndex, self.isCtxDependent))
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, Predicate):
+            return False
+        return self.ruleIndex == other.ruleIndex and \
+               self.predIndex == other.predIndex and \
+               self.isCtxDependent == other.isCtxDependent
+
+    def __str__(self):
+        return "{" + str(self.ruleIndex) + ":" + str(self.predIndex) + "}?"
+
+
+class PrecedencePredicate(SemanticContext):
+
+    def __init__(self, precedence:int=0):
+        self.precedence = precedence
+
+    def eval(self, parser:Recognizer , outerContext:RuleContext ):
+        return parser.precpred(outerContext, self.precedence)
+
+    def evalPrecedence(self, parser:Recognizer, outerContext:RuleContext):
+        if parser.precpred(outerContext, self.precedence):
+            return SemanticContext.NONE
+        else:
+            return None
+
+    def __cmp__(self, other):
+        return self.precedence - other.precedence
+
+    def __hash__(self):
+        return 31
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, PrecedencePredicate):
+            return False
+        else:
+            return self.precedence == other.precedence
+
+# A semantic context which is true whenever none of the contained contexts
+# is false.
+del AND
+class AND(SemanticContext):
+
+    def __init__(self, a:SemanticContext, b:SemanticContext):
+        operands = set()
+        if isinstance( a, AND ):
+            for o in a.opnds:
+                operands.add(o)
+        else:
+            operands.add(a)
+        if isinstance( b, AND ):
+            for o in b.opnds:
+                operands.add(o)
+        else:
+            operands.add(b)
+
+        precedencePredicates = filterPrecedencePredicates(operands)
+        if len(precedencePredicates)>0:
+            # interested in the transition with the lowest precedence
+            reduced = min(precedencePredicates)
+            operands.add(reduced)
+
+        self.opnds = [ o for o in operands ]
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, AND):
+            return False
+        else:
+            return self.opnds == other.opnds
+
+    def __hash__(self):
+        h = 0
+        for o in self.opnds:
+            h = hash((h, o))
+        return hash((h, "AND"))
+
+    #
+    # {@inheritDoc}
+    #
+    # <p>
+    # The evaluation of predicates by this context is short-circuiting, but
+    # unordered.</p>
+    #
+    def eval(self, parser:Recognizer , outerContext:RuleContext ):
+        for opnd in self.opnds:
+            if not opnd.eval(parser, outerContext):
+                return False
+        return True
+
+    def evalPrecedence(self, parser:Recognizer, outerContext:RuleContext):
+        differs = False
+        operands = []
+        for context in self.opnds:
+            evaluated = context.evalPrecedence(parser, outerContext)
+            differs |= evaluated is not context
+            if evaluated is None:
+                # The AND context is false if any element is false
+                return None
+            elif evaluated is not SemanticContext.NONE:
+                # Reduce the result by skipping true elements
+                operands.append(evaluated)
+
+        if not differs:
+            return self
+
+        if len(operands)==0:
+            # all elements were true, so the AND context is true
+            return SemanticContext.NONE
+
+        result = None
+        for o in operands:
+            result = o if result is None else andContext(result, o)
+
+        return result
+
+    def __str__(self):
+        with StringIO() as buf:
+            first = True
+            for o in self.opnds:
+                if not first:
+                    buf.write("&&")
+                buf.write(str(o))
+                first = False
+            return buf.getvalue()
+
+#
+# A semantic context which is true whenever at least one of the contained
+# contexts is true.
+del OR
+class OR (SemanticContext):
+
+    def __init__(self, a:SemanticContext, b:SemanticContext):
+        operands = set()
+        if isinstance( a, OR ):
+            for o in a.opnds:
+                operands.add(o)
+        else:
+            operands.add(a)
+        if isinstance( b, OR ):
+            for o in b.opnds:
+                operands.add(o)
+        else:
+            operands.add(b)
+
+        precedencePredicates = filterPrecedencePredicates(operands)
+        if len(precedencePredicates)>0:
+            # interested in the transition with the highest precedence
+            s = sorted(precedencePredicates)
+            reduced = s[len(s)-1]
+            operands.add(reduced)
+
+        self.opnds = [ o for o in operands ]
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, OR):
+            return False
+        else:
+            return self.opnds == other.opnds
+
+    def __hash__(self):
+        h = 0
+        for o in self.opnds:
+            h = hash((h, o))
+        return hash((h, "OR"))
+
+    # <p>
+    # The evaluation of predicates by this context is short-circuiting, but
+    # unordered.</p>
+    #
+    def eval(self, parser:Recognizer, outerContext:RuleContext):
+        for opnd in self.opnds:
+            if opnd.eval(parser, outerContext):
+                return True
+        return False
+
+    def evalPrecedence(self, parser:Recognizer, outerContext:RuleContext):
+        differs = False
+        operands = []
+        for context in self.opnds:
+            evaluated = context.evalPrecedence(parser, outerContext)
+            differs |= evaluated is not context
+            if evaluated is SemanticContext.NONE:
+                # The OR context is true if any element is true
+                return SemanticContext.NONE
+            elif evaluated is not None:
+                # Reduce the result by skipping false elements
+                operands.append(evaluated)
+
+        if not differs:
+            return self
+
+        if len(operands)==0:
+            # all elements were false, so the OR context is false
+            return None
+
+        result = None
+        for o in operands:
+            result = o if result is None else orContext(result, o)
+
+        return result
+
+    def __str__(self):
+        with StringIO() as buf:
+            first = True
+            for o in self.opnds:
+                if not first:
+                    buf.write("||")
+                buf.write(str(o))
+                first = False
+            return buf.getvalue()
+
+
+SemanticContext.NONE = Predicate()
\ No newline at end of file
diff --git a/runtime/Python3/src/antlr4/atn/Transition.py b/runtime/Python3/src/antlr4/atn/Transition.py
new file mode 100644
index 000000000..79698ba2f
--- /dev/null
+++ b/runtime/Python3/src/antlr4/atn/Transition.py
@@ -0,0 +1,282 @@
+#
+# [The "BSD license"]
+#  Copyright (c) 2012 Terence Parr
+#  Copyright (c) 2012 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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.
+#
+
+#  An ATN transition between any two ATN states.  Subclasses define
+#  atom, set, epsilon, action, predicate, rule transitions.
+#
+#  <p>This is a one way link.  It emanates from a state (usually via a list of
+#  transitions) and has a target state.</p>
+#
+#  <p>Since we never have to change the ATN transitions once we construct it,
+#  we can fix these transitions as specific classes. The DFA transitions
+#  on the other hand need to update the labels as it adds transitions to
+#  the states. We'll use the term Edge for the DFA to distinguish them from
+#  ATN transitions.</p>
+#
+from antlr4.IntervalSet import IntervalSet
+from antlr4.Token import Token
+
+# need forward declarations
+from antlr4.atn.SemanticContext import Predicate, PrecedencePredicate
+
+ATNState = None
+RuleStartState = None
+
+class Transition (object):
+    # constants for serialization
+    EPSILON			= 1
+    RANGE			= 2
+    RULE			= 3
+    PREDICATE		= 4 # e.g., {isType(input.LT(1))}?
+    ATOM			= 5
+    ACTION			= 6
+    SET				= 7 # ~(A|B) or ~atom, wildcard, which convert to next 2
+    NOT_SET			= 8
+    WILDCARD		= 9
+    PRECEDENCE		= 10
+
+    serializationNames = [
+            "INVALID",
+            "EPSILON",
+            "RANGE",
+            "RULE",
+            "PREDICATE",
+            "ATOM",
+            "ACTION",
+            "SET",
+            "NOT_SET",
+            "WILDCARD",
+            "PRECEDENCE"
+        ]
+
+    serializationTypes = dict()
+
+    def __init__(self, target:ATNState):
+        # The target of this transition.
+        if target is None:
+            raise Exception("target cannot be null.")
+        self.target = target
+        # Are we epsilon, action, sempred?
+        self.isEpsilon = False
+        self.label = None
+
+
+# TODO: make all transitions sets? no, should remove set edges
+class AtomTransition(Transition):
+
+    def __init__(self, target:ATNState, label:int):
+        super().__init__(target)
+        self.label_ = label # The token type or character value; or, signifies special label.
+        self.label = self.makeLabel()
+        self.serializationType = self.ATOM
+
+    def makeLabel(self):
+        s = IntervalSet()
+        s.addOne(self.label_)
+        return s
+
+    def matches( self, symbol:int, minVocabSymbol:int,  maxVocabSymbol:int):
+        return self.label_ == symbol
+
+    def __str__(self):
+        return str(self.label_)
+
+class RuleTransition(Transition):
+
+    def __init__(self, ruleStart:RuleStartState, ruleIndex:int, precedence:int, followState:ATNState):
+        super().__init__(ruleStart)
+        self.ruleIndex = ruleIndex # ptr to the rule definition object for this rule ref
+        self.precedence = precedence
+        self.followState = followState # what node to begin computations following ref to rule
+        self.serializationType = self.RULE
+        self.isEpsilon = True
+
+    def matches( self, symbol:int, minVocabSymbol:int,  maxVocabSymbol:int):
+        return False
+
+
+class EpsilonTransition(Transition):
+
+    def __init__(self, target, outermostPrecedenceReturn=-1):
+        super(EpsilonTransition, self).__init__(target)
+        self.serializationType = self.EPSILON
+        self.isEpsilon = True
+        self.outermostPrecedenceReturn = outermostPrecedenceReturn
+
+    def matches( self, symbol:int, minVocabSymbol:int,  maxVocabSymbol:int):
+        return False
+
+    def __str__(self):
+        return "epsilon"
+
+class RangeTransition(Transition):
+
+    def __init__(self, target:ATNState, start:int, stop:int):
+        super().__init__(target)
+        self.serializationType = self.RANGE
+        self.start = start
+        self.stop = stop
+        self.label = self.makeLabel()
+
+    def makeLabel(self):
+        s = IntervalSet()
+        s.addRange(range(self.start, self.stop + 1))
+        return s
+
+    def matches( self, symbol:int, minVocabSymbol:int,  maxVocabSymbol:int):
+        return symbol >= self.start and symbol <= self.stop
+
+    def __str__(self):
+        return "'" + chr(self.start) + "'..'" + chr(self.stop) + "'"
+
+class AbstractPredicateTransition(Transition):
+
+    def __init__(self, target:ATNState):
+        super().__init__(target)
+
+
+class PredicateTransition(AbstractPredicateTransition):
+
+    def __init__(self, target:ATNState, ruleIndex:int, predIndex:int, isCtxDependent:bool):
+        super().__init__(target)
+        self.serializationType = self.PREDICATE
+        self.ruleIndex = ruleIndex
+        self.predIndex = predIndex
+        self.isCtxDependent = isCtxDependent # e.g., $i ref in pred
+        self.isEpsilon = True
+
+    def matches( self, symbol:int, minVocabSymbol:int,  maxVocabSymbol:int):
+        return False
+
+    def getPredicate(self):
+        return Predicate(self.ruleIndex, self.predIndex, self.isCtxDependent)
+
+    def __str__(self):
+        return "pred_" + str(self.ruleIndex) + ":" + str(self.predIndex)
+
+class ActionTransition(Transition):
+
+    def __init__(self, target:ATNState, ruleIndex:int, actionIndex:int=-1, isCtxDependent:bool=False):
+        super().__init__(target)
+        self.serializationType = self.ACTION
+        self.ruleIndex = ruleIndex
+        self.actionIndex = actionIndex
+        self.isCtxDependent = isCtxDependent # e.g., $i ref in pred
+        self.isEpsilon = True
+
+    def matches( self, symbol:int, minVocabSymbol:int,  maxVocabSymbol:int):
+        return False
+
+    def __str__(self):
+        return "action_"+self.ruleIndex+":"+self.actionIndex
+
+# A transition containing a set of values.
+class SetTransition(Transition):
+
+    def __init__(self, target:ATNState, set:IntervalSet):
+        super().__init__(target)
+        self.serializationType = self.SET
+        if set is not None:
+            self.label = set
+        else:
+            self.label = IntervalSet()
+            self.label.addRange(range(Token.INVALID_TYPE, Token.INVALID_TYPE + 1))
+
+    def matches( self, symbol:int, minVocabSymbol:int,  maxVocabSymbol:int):
+        return symbol in self.label
+
+    def __str__(self):
+        return str(self.label)
+
+class NotSetTransition(SetTransition):
+
+    def __init__(self, target:ATNState, set:IntervalSet):
+        super().__init__(target, set)
+        self.serializationType = self.NOT_SET
+
+    def matches( self, symbol:int, minVocabSymbol:int,  maxVocabSymbol:int):
+        return symbol >= minVocabSymbol \
+            and symbol <= maxVocabSymbol \
+            and not super(type(self), self).matches(symbol, minVocabSymbol, maxVocabSymbol)
+
+    def __str__(self):
+        return '~' + super(type(self), self).__str__()
+
+
+class WildcardTransition(Transition):
+
+    def __init__(self, target:ATNState):
+        super().__init__(target)
+        self.serializationType = self.WILDCARD
+
+    def matches( self, symbol:int, minVocabSymbol:int,  maxVocabSymbol:int):
+        return symbol >= minVocabSymbol and symbol <= maxVocabSymbol
+
+    def __str__(self):
+        return "."
+
+
+class PrecedencePredicateTransition(AbstractPredicateTransition):
+
+    def __init__(self, target:ATNState, precedence:int):
+        super().__init__(target)
+        self.serializationType = self.PRECEDENCE
+        self.precedence = precedence
+        self.isEpsilon = True
+
+    def matches( self, symbol:int, minVocabSymbol:int,  maxVocabSymbol:int):
+        return False
+
+
+    def getPredicate(self):
+        return PrecedencePredicate(self.precedence)
+
+    def __str__(self):
+        return self.precedence + " >= _p"
+
+
+Transition.serializationTypes = {
+             EpsilonTransition: Transition.EPSILON,
+             RangeTransition: Transition.RANGE,
+             RuleTransition: Transition.RULE,
+             PredicateTransition: Transition.PREDICATE,
+             AtomTransition: Transition.ATOM,
+             ActionTransition: Transition.ACTION,
+             SetTransition: Transition.SET,
+             NotSetTransition: Transition.NOT_SET,
+             WildcardTransition: Transition.WILDCARD,
+             PrecedencePredicateTransition: Transition.PRECEDENCE
+         }
+
+del ATNState
+del RuleStartState
+
+from antlr4.atn.ATNState import *
\ No newline at end of file
diff --git a/runtime/Python3/src/antlr4/atn/__init__.py b/runtime/Python3/src/antlr4/atn/__init__.py
new file mode 100644
index 000000000..216c000dc
--- /dev/null
+++ b/runtime/Python3/src/antlr4/atn/__init__.py
@@ -0,0 +1 @@
+__author__ = 'ericvergnaud'
diff --git a/runtime/Python3/src/antlr4/dfa/DFA.py b/runtime/Python3/src/antlr4/dfa/DFA.py
new file mode 100644
index 000000000..80a48b56e
--- /dev/null
+++ b/runtime/Python3/src/antlr4/dfa/DFA.py
@@ -0,0 +1,148 @@
+#
+# [The "BSD license"]
+#  Copyright (c) 2012 Terence Parr
+#  Copyright (c) 2012 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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.
+
+from antlr4.atn.ATNConfigSet import ATNConfigSet
+from antlr4.atn.ATNState import DecisionState
+from antlr4.dfa.DFAState import DFAState
+from antlr4.error.Errors import IllegalStateException
+
+
+class DFA(object):
+
+    def __init__(self, atnStartState:DecisionState, decision:int=0):
+        # From which ATN state did we create this DFA?
+        self.atnStartState = atnStartState
+        self.decision = decision
+        # A set of all DFA states. Use {@link Map} so we can get old state back
+        #  ({@link Set} only allows you to see if it's there).
+        self._states = dict()
+        self.s0 = None
+        # {@code true} if this DFA is for a precedence decision; otherwise,
+        # {@code false}. This is the backing field for {@link #isPrecedenceDfa},
+        # {@link #setPrecedenceDfa}.
+        self.precedenceDfa = False
+
+
+    # Get the start state for a specific precedence value.
+    #
+    # @param precedence The current precedence.
+    # @return The start state corresponding to the specified precedence, or
+    # {@code null} if no start state exists for the specified precedence.
+    #
+    # @throws IllegalStateException if this is not a precedence DFA.
+    # @see #isPrecedenceDfa()
+
+    def getPrecedenceStartState(self, precedence:int):
+        if not self.precedenceDfa:
+            raise IllegalStateException("Only precedence DFAs may contain a precedence start state.")
+
+        # s0.edges is never null for a precedence DFA
+        if precedence < 0 or precedence >= len(self.s0.edges):
+            return None
+        return self.s0.edges[precedence]
+
+    # Set the start state for a specific precedence value.
+    #
+    # @param precedence The current precedence.
+    # @param startState The start state corresponding to the specified
+    # precedence.
+    #
+    # @throws IllegalStateException if this is not a precedence DFA.
+    # @see #isPrecedenceDfa()
+    #
+    def setPrecedenceStartState(self, precedence:int, startState:DFAState):
+        if not self.precedenceDfa:
+            raise IllegalStateException("Only precedence DFAs may contain a precedence start state.")
+
+        if precedence < 0:
+            return
+
+        # synchronization on s0 here is ok. when the DFA is turned into a
+        # precedence DFA, s0 will be initialized once and not updated again
+        # s0.edges is never null for a precedence DFA
+        if precedence >= len(self.s0.edges):
+            ext = [None] * (precedence + 1 - len(self.s0.edges))
+            self.s0.edges.extend(ext)
+        self.s0.edges[precedence] = startState
+    #
+    # Sets whether this is a precedence DFA. If the specified value differs
+    # from the current DFA configuration, the following actions are taken;
+    # otherwise no changes are made to the current DFA.
+    #
+    # <ul>
+    # <li>The {@link #states} map is cleared</li>
+    # <li>If {@code precedenceDfa} is {@code false}, the initial state
+    # {@link #s0} is set to {@code null}; otherwise, it is initialized to a new
+    # {@link DFAState} with an empty outgoing {@link DFAState#edges} array to
+    # store the start states for individual precedence values.</li>
+    # <li>The {@link #precedenceDfa} field is updated</li>
+    # </ul>
+    #
+    # @param precedenceDfa {@code true} if this is a precedence DFA; otherwise,
+    # {@code false}
+
+    def setPrecedenceDfa(self, precedenceDfa:bool):
+        if self.precedenceDfa != precedenceDfa:
+            self._states = dict()
+            if precedenceDfa:
+                precedenceState = DFAState(ATNConfigSet())
+                precedenceState.edges = []
+                precedenceState.isAcceptState = False
+                precedenceState.requiresFullContext = False
+                self.s0 = precedenceState
+            else:
+                self.s0 = None
+            self.precedenceDfa = precedenceDfa
+
+    @property
+    def states(self):
+        return self._states
+
+    # Return a list of all states in this DFA, ordered by state number.
+    def sortedStates(self):
+        return sorted(self._states.keys(), key=lambda state: state.stateNumber)
+
+    def __str__(self):
+        return self.toString(None)
+
+    def toString(self, literalNames:list=None, symbolicNames:list=None):
+        if self.s0 is None:
+            return ""
+        from antlr4.dfa.DFASerializer import DFASerializer
+        serializer = DFASerializer(self,literalNames,symbolicNames)
+        return str(serializer)
+
+    def toLexerString(self):
+        if self.s0 is None:
+            return ""
+        from antlr4.dfa.DFASerializer import LexerDFASerializer
+        serializer = LexerDFASerializer(self)
+        return str(serializer)
+
diff --git a/runtime/Python3/src/antlr4/dfa/DFASerializer.py b/runtime/Python3/src/antlr4/dfa/DFASerializer.py
new file mode 100644
index 000000000..de87f313c
--- /dev/null
+++ b/runtime/Python3/src/antlr4/dfa/DFASerializer.py
@@ -0,0 +1,97 @@
+#
+# [The "BSD license"]
+#  Copyright (c) 2012 Terence Parr
+#  Copyright (c) 2012 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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 DFA walker that knows how to dump them to serialized strings.#/
+from io import StringIO
+from antlr4 import DFA
+from antlr4.Utils import str_list
+from antlr4.dfa.DFAState import DFAState
+
+
+class DFASerializer(object):
+
+    def __init__(self, dfa:DFA, literalNames:list=None, symbolicNames:list=None):
+        self.dfa = dfa
+        self.literalNames = literalNames
+        self.symbolicNames = symbolicNames
+
+    def __str__(self):
+        if self.dfa.s0 is None:
+            return None
+        with StringIO() as buf:
+            for s in self.dfa.sortedStates():
+                n = 0
+                if s.edges is not None:
+                    n = len(s.edges)
+                for i in range(0, n):
+                    t = s.edges[i]
+                    if t is not None and t.stateNumber != 0x7FFFFFFF:
+                        buf.write(self.getStateString(s))
+                        label = self.getEdgeLabel(i)
+                        buf.write("-")
+                        buf.write(label)
+                        buf.write("->")
+                        buf.write(self.getStateString(t))
+                        buf.write('\n')
+            output = buf.getvalue()
+            if len(output)==0:
+                return None
+            else:
+                return output
+
+    def getEdgeLabel(self, i:int):
+        if i==0:
+            return "EOF"
+        if self.literalNames is not None and i<=len(self.literalNames):
+            return self.literalNames[i-1]
+        elif self.symbolicNames is not None and i<=len(self.symbolicNames):
+            return self.symbolicNames[i-1]
+        else:
+            return str(i-1)
+
+    def getStateString(self, s:DFAState):
+        n = s.stateNumber
+        baseStateStr = ( ":" if s.isAcceptState else "") + "s" + str(n) + ( "^" if s.requiresFullContext else "")
+        if s.isAcceptState:
+            if s.predicates is not None:
+                return baseStateStr + "=>" + str_list(s.predicates)
+            else:
+                return baseStateStr + "=>" + str(s.prediction)
+        else:
+            return baseStateStr
+
+class LexerDFASerializer(DFASerializer):
+
+    def __init__(self, dfa:DFA):
+        super().__init__(dfa, None)
+
+    def getEdgeLabel(self, i:int):
+        return "'" + chr(i) + "'"
diff --git a/runtime/Python3/src/antlr4/dfa/DFAState.py b/runtime/Python3/src/antlr4/dfa/DFAState.py
new file mode 100644
index 000000000..1ab5a0e77
--- /dev/null
+++ b/runtime/Python3/src/antlr4/dfa/DFAState.py
@@ -0,0 +1,150 @@
+#
+# [The "BSD license"]
+#  Copyright (c) 2012 Terence Parr
+#  Copyright (c) 2012 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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.
+#/
+
+# Map a predicate to a predicted alternative.#/
+from io import StringIO
+from antlr4.atn.ATNConfigSet import ATNConfigSet
+from antlr4.atn.SemanticContext import SemanticContext
+
+
+class PredPrediction(object):
+    def __init__(self, pred:SemanticContext, alt:int):
+        self.alt = alt
+        self.pred = pred
+
+    def __str__(self):
+        return "(" + str(self.pred) + ", " + str(self.alt) +  ")"
+
+# A DFA state represents a set of possible ATN configurations.
+#  As Aho, Sethi, Ullman p. 117 says "The DFA uses its state
+#  to keep track of all possible states the ATN can be in after
+#  reading each input symbol.  That is to say, after reading
+#  input a1a2..an, the DFA is in a state that represents the
+#  subset T of the states of the ATN that are reachable from the
+#  ATN's start state along some path labeled a1a2..an."
+#  In conventional NFA&rarr;DFA conversion, therefore, the subset T
+#  would be a bitset representing the set of states the
+#  ATN could be in.  We need to track the alt predicted by each
+#  state as well, however.  More importantly, we need to maintain
+#  a stack of states, tracking the closure operations as they
+#  jump from rule to rule, emulating rule invocations (method calls).
+#  I have to add a stack to simulate the proper lookahead sequences for
+#  the underlying LL grammar from which the ATN was derived.
+#
+#  <p>I use a set of ATNConfig objects not simple states.  An ATNConfig
+#  is both a state (ala normal conversion) and a RuleContext describing
+#  the chain of rules (if any) followed to arrive at that state.</p>
+#
+#  <p>A DFA state may have multiple references to a particular state,
+#  but with different ATN contexts (with same or different alts)
+#  meaning that state was reached via a different set of rule invocations.</p>
+#/
+class DFAState(object):
+
+    def __init__(self, stateNumber:int=-1, configs:ATNConfigSet=ATNConfigSet()):
+        self.stateNumber = stateNumber
+        self.configs = configs
+        # {@code edges[symbol]} points to target of symbol. Shift up by 1 so (-1)
+        #  {@link Token#EOF} maps to {@code edges[0]}.
+        self.edges = None
+        self.isAcceptState = False
+        # if accept state, what ttype do we match or alt do we predict?
+        #  This is set to {@link ATN#INVALID_ALT_NUMBER} when {@link #predicates}{@code !=null} or
+        #  {@link #requiresFullContext}.
+        self.prediction = 0
+        self.lexerActionExecutor = None
+        # Indicates that this state was created during SLL prediction that
+        # discovered a conflict between the configurations in the state. Future
+        # {@link ParserATNSimulator#execATN} invocations immediately jumped doing
+        # full context prediction if this field is true.
+        self.requiresFullContext = False
+        # During SLL parsing, this is a list of predicates associated with the
+        #  ATN configurations of the DFA state. When we have predicates,
+        #  {@link #requiresFullContext} is {@code false} since full context prediction evaluates predicates
+        #  on-the-fly. If this is not null, then {@link #prediction} is
+        #  {@link ATN#INVALID_ALT_NUMBER}.
+        #
+        #  <p>We only use these for non-{@link #requiresFullContext} but conflicting states. That
+        #  means we know from the context (it's $ or we don't dip into outer
+        #  context) that it's an ambiguity not a conflict.</p>
+        #
+        #  <p>This list is computed by {@link ParserATNSimulator#predicateDFAState}.</p>
+        self.predicates = None
+
+
+
+    # Get the set of all alts mentioned by all ATN configurations in this
+    #  DFA state.
+    def getAltSet(self):
+        alts = set()
+        if self.configs is not None:
+            for c in self.configs:
+                alts.add(c.alt)
+        if len(alts)==0:
+            return None
+        else:
+            return alts
+
+    def __hash__(self):
+        return hash(self.configs)
+
+    # Two {@link DFAState} instances are equal if their ATN configuration sets
+    # are the same. This method is used to see if a state already exists.
+    #
+    # <p>Because the number of alternatives and number of ATN configurations are
+    # finite, there is a finite number of DFA states that can be processed.
+    # This is necessary to show that the algorithm terminates.</p>
+    #
+    # <p>Cannot test the DFA state numbers here because in
+    # {@link ParserATNSimulator#addDFAState} we need to know if any other state
+    # exists that has this exact set of ATN configurations. The
+    # {@link #stateNumber} is irrelevant.</p>
+    def __eq__(self, other):
+        # compare set of ATN configurations in this set with other
+        if self is other:
+            return True
+        elif not isinstance(other, DFAState):
+            return False
+        else:
+            return self.configs==other.configs
+
+    def __str__(self):
+        with StringIO() as buf:
+            buf.write(str(self.stateNumber))
+            buf.write(":")
+            buf.write(str(self.configs))
+            if self.isAcceptState:
+                buf.write("=>")
+                if self.predicates is not None:
+                    buf.write(str(self.predicates))
+                else:
+                    buf.write(str(self.prediction))
+            return buf.getvalue()
diff --git a/runtime/Python3/src/antlr4/dfa/__init__.py b/runtime/Python3/src/antlr4/dfa/__init__.py
new file mode 100644
index 000000000..216c000dc
--- /dev/null
+++ b/runtime/Python3/src/antlr4/dfa/__init__.py
@@ -0,0 +1 @@
+__author__ = 'ericvergnaud'
diff --git a/runtime/Python3/src/antlr4/error/DiagnosticErrorListener.py b/runtime/Python3/src/antlr4/error/DiagnosticErrorListener.py
new file mode 100644
index 000000000..50bc841f9
--- /dev/null
+++ b/runtime/Python3/src/antlr4/error/DiagnosticErrorListener.py
@@ -0,0 +1,132 @@
+#
+# [The "BSD license"]
+#  Copyright (c) 2012 Terence Parr
+#  Copyright (c) 2012 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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.
+#
+
+
+#
+# This implementation of {@link ANTLRErrorListener} can be used to identify
+# certain potential correctness and performance problems in grammars. "Reports"
+# are made by calling {@link Parser#notifyErrorListeners} with the appropriate
+# message.
+#
+# <ul>
+# <li><b>Ambiguities</b>: These are cases where more than one path through the
+# grammar can match the input.</li>
+# <li><b>Weak context sensitivity</b>: These are cases where full-context
+# prediction resolved an SLL conflict to a unique alternative which equaled the
+# minimum alternative of the SLL conflict.</li>
+# <li><b>Strong (forced) context sensitivity</b>: These are cases where the
+# full-context prediction resolved an SLL conflict to a unique alternative,
+# <em>and</em> the minimum alternative of the SLL conflict was found to not be
+# a truly viable alternative. Two-stage parsing cannot be used for inputs where
+# this situation occurs.</li>
+# </ul>
+
+from io import StringIO
+from antlr4 import Parser, DFA
+from antlr4.atn.ATNConfigSet import ATNConfigSet
+from antlr4.error.ErrorListener import ErrorListener
+
+class DiagnosticErrorListener(ErrorListener):
+
+    def __init__(self, exactOnly:bool=True):
+        # whether all ambiguities or only exact ambiguities are reported.
+        self.exactOnly = exactOnly
+
+    def reportAmbiguity(self, recognizer:Parser, dfa:DFA, startIndex:int,
+                       stopIndex:int, exact:bool, ambigAlts:set, configs:ATNConfigSet):
+        if self.exactOnly and not exact:
+            return
+
+        with StringIO() as buf:
+            buf.write("reportAmbiguity d=")
+            buf.write(self.getDecisionDescription(recognizer, dfa))
+            buf.write(": ambigAlts=")
+            buf.write(str(self.getConflictingAlts(ambigAlts, configs)))
+            buf.write(", input='")
+            buf.write(recognizer.getTokenStream().getText((startIndex, stopIndex)))
+            buf.write("'")
+            recognizer.notifyErrorListeners(buf.getvalue())
+
+
+    def reportAttemptingFullContext(self, recognizer:Parser, dfa:DFA, startIndex:int,
+                       stopIndex:int, conflictingAlts:set, configs:ATNConfigSet):
+        with StringIO() as buf:
+            buf.write("reportAttemptingFullContext d=")
+            buf.write(self.getDecisionDescription(recognizer, dfa))
+            buf.write(", input='")
+            buf.write(recognizer.getTokenStream().getText((startIndex, stopIndex)))
+            buf.write("'")
+            recognizer.notifyErrorListeners(buf.getvalue())
+
+    def reportContextSensitivity(self, recognizer:Parser, dfa:DFA, startIndex:int,
+                       stopIndex:int, prediction:int, configs:ATNConfigSet):
+        with StringIO() as buf:
+            buf.write("reportContextSensitivity d=")
+            buf.write(self.getDecisionDescription(recognizer, dfa))
+            buf.write(", input='")
+            buf.write(recognizer.getTokenStream().getText((startIndex, stopIndex)))
+            buf.write("'")
+            recognizer.notifyErrorListeners(buf.getvalue())
+
+    def getDecisionDescription(self, recognizer:Parser, dfa:DFA):
+        decision = dfa.decision
+        ruleIndex = dfa.atnStartState.ruleIndex
+
+        ruleNames = recognizer.ruleNames
+        if ruleIndex < 0 or ruleIndex >= len(ruleNames):
+            return str(decision)
+
+        ruleName = ruleNames[ruleIndex]
+        if ruleName is None or len(ruleName)==0:
+            return str(decision)
+
+        return str(decision) + " (" + ruleName + ")"
+
+    #
+    # Computes the set of conflicting or ambiguous alternatives from a
+    # configuration set, if that information was not already provided by the
+    # parser.
+    #
+    # @param reportedAlts The set of conflicting or ambiguous alternatives, as
+    # reported by the parser.
+    # @param configs The conflicting or ambiguous configuration set.
+    # @return Returns {@code reportedAlts} if it is not {@code null}, otherwise
+    # returns the set of alternatives represented in {@code configs}.
+    #
+    def getConflictingAlts(self, reportedAlts:set, configs:ATNConfigSet):
+        if reportedAlts is not None:
+            return reportedAlts
+
+        result = set()
+        for config in configs:
+            result.add(config.alt)
+
+        return result
diff --git a/runtime/Python3/src/antlr4/error/ErrorListener.py b/runtime/Python3/src/antlr4/error/ErrorListener.py
new file mode 100644
index 000000000..d1c1451ec
--- /dev/null
+++ b/runtime/Python3/src/antlr4/error/ErrorListener.py
@@ -0,0 +1,97 @@
+#
+# [The "BSD license"]
+#  Copyright (c) 2012 Terence Parr
+#  Copyright (c) 2012 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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.
+
+# Provides an empty default implementation of {@link ANTLRErrorListener}. The
+# default implementation of each method does nothing, but can be overridden as
+# necessary.
+
+
+import sys
+
+class ErrorListener(object):
+
+    def syntaxError(self, recognizer, offendingSymbol, line, column, msg, e):
+        pass
+
+    def reportAmbiguity(self, recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs):
+        pass
+
+    def reportAttemptingFullContext(self, recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs):
+        pass
+
+    def reportContextSensitivity(self, recognizer, dfa, startIndex, stopIndex, prediction, configs):
+        pass
+
+class ConsoleErrorListener(ErrorListener):
+    #
+    # Provides a default instance of {@link ConsoleErrorListener}.
+    #
+    INSTANCE = None
+
+    #
+    # {@inheritDoc}
+    #
+    # <p>
+    # This implementation prints messages to {@link System#err} containing the
+    # values of {@code line}, {@code charPositionInLine}, and {@code msg} using
+    # the following format.</p>
+    #
+    # <pre>
+    # line <em>line</em>:<em>charPositionInLine</em> <em>msg</em>
+    # </pre>
+    #
+    def syntaxError(self, recognizer, offendingSymbol, line, column, msg, e):
+        print("line " + str(line) + ":" + str(column) + " " + msg, file=sys.stderr)
+
+ConsoleErrorListener.INSTANCE = ConsoleErrorListener()
+
+class ProxyErrorListener(ErrorListener):
+
+    def __init__(self, delegates):
+        super().__init__()
+        if delegates is None:
+            raise ReferenceError("delegates")
+        self.delegates = delegates
+
+    def syntaxError(self, recognizer, offendingSymbol, line, column, msg, e):
+        for delegate in self.delegates:
+            delegate.syntaxError(recognizer, offendingSymbol, line, column, msg, e)
+
+    def reportAmbiguity(self, recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs):
+        for delegate in self.delegates:
+            delegate.reportAmbiguity(recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs)
+
+    def reportAttemptingFullContext(self, recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs):
+        for delegate in self.delegates:
+            delegate.reportAttemptingFullContext(recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs)
+
+    def reportContextSensitivity(self, recognizer, dfa, startIndex, stopIndex, prediction, configs):
+        for delegate in self.delegates:
+            delegate.reportContextSensitivity(recognizer, dfa, startIndex, stopIndex, prediction, configs)
diff --git a/runtime/Python3/src/antlr4/error/ErrorStrategy.py b/runtime/Python3/src/antlr4/error/ErrorStrategy.py
new file mode 100644
index 000000000..9df8464d9
--- /dev/null
+++ b/runtime/Python3/src/antlr4/error/ErrorStrategy.py
@@ -0,0 +1,726 @@
+#
+# [The "BSD license"]
+#  Copyright (c) 2012 Terence Parr
+#  Copyright (c) 2012 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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.
+#
+import sys
+from antlr4.IntervalSet import IntervalSet
+
+from antlr4.Token import Token
+from antlr4.atn.ATNState import ATNState
+from antlr4.error.Errors import RecognitionException, NoViableAltException, InputMismatchException, \
+    FailedPredicateException, ParseCancellationException
+
+# need forward declaration
+Parser = None
+
+class ErrorStrategy(object):
+
+    def reset(self, recognizer:Parser):
+        pass
+
+    def recoverInline(self, recognizer:Parser):
+        pass
+
+    def recover(self, recognizer:Parser, e:RecognitionException):
+        pass
+
+    def sync(self, recognizer:Parser):
+        pass
+
+    def inErrorRecoveryMode(self, recognizer:Parser):
+        pass
+
+    def reportError(self, recognizer:Parser, e:RecognitionException):
+        pass
+
+
+# This is the default implementation of {@link ANTLRErrorStrategy} used for
+# error reporting and recovery in ANTLR parsers.
+#
+class DefaultErrorStrategy(ErrorStrategy):
+
+    def __init__(self):
+        super().__init__()
+        # Indicates whether the error strategy is currently "recovering from an
+        # error". This is used to suppress reporting multiple error messages while
+        # attempting to recover from a detected syntax error.
+        #
+        # @see #inErrorRecoveryMode
+        #
+        self.errorRecoveryMode = False
+
+        # The index into the input stream where the last error occurred.
+        # 	This is used to prevent infinite loops where an error is found
+        #  but no token is consumed during recovery...another error is found,
+        #  ad nauseum.  This is a failsafe mechanism to guarantee that at least
+        #  one token/tree node is consumed for two errors.
+        #
+        self.lastErrorIndex = -1
+        self.lastErrorStates = None
+
+    # <p>The default implementation simply calls {@link #endErrorCondition} to
+    # ensure that the handler is not in error recovery mode.</p>
+    def reset(self, recognizer:Parser):
+        self.endErrorCondition(recognizer)
+
+    #
+    # This method is called to enter error recovery mode when a recognition
+    # exception is reported.
+    #
+    # @param recognizer the parser instance
+    #
+    def beginErrorCondition(self, recognizer:Parser):
+        self.errorRecoveryMode = True
+
+    def inErrorRecoveryMode(self, recognizer:Parser):
+        return self.errorRecoveryMode
+
+    #
+    # This method is called to leave error recovery mode after recovering from
+    # a recognition exception.
+    #
+    # @param recognizer
+    #
+    def endErrorCondition(self, recognizer:Parser):
+        self.errorRecoveryMode = False
+        self.lastErrorStates = None
+        self.lastErrorIndex = -1
+
+    #
+    # {@inheritDoc}
+    #
+    # <p>The default implementation simply calls {@link #endErrorCondition}.</p>
+    #
+    def reportMatch(self, recognizer:Parser):
+        self.endErrorCondition(recognizer)
+
+    #
+    # {@inheritDoc}
+    #
+    # <p>The default implementation returns immediately if the handler is already
+    # in error recovery mode. Otherwise, it calls {@link #beginErrorCondition}
+    # and dispatches the reporting task based on the runtime type of {@code e}
+    # according to the following table.</p>
+    #
+    # <ul>
+    # <li>{@link NoViableAltException}: Dispatches the call to
+    # {@link #reportNoViableAlternative}</li>
+    # <li>{@link InputMismatchException}: Dispatches the call to
+    # {@link #reportInputMismatch}</li>
+    # <li>{@link FailedPredicateException}: Dispatches the call to
+    # {@link #reportFailedPredicate}</li>
+    # <li>All other types: calls {@link Parser#notifyErrorListeners} to report
+    # the exception</li>
+    # </ul>
+    #
+    def reportError(self, recognizer:Parser, e:RecognitionException):
+       # if we've already reported an error and have not matched a token
+       # yet successfully, don't report any errors.
+        if self.inErrorRecoveryMode(recognizer):
+            return # don't report spurious errors
+        self.beginErrorCondition(recognizer)
+        if isinstance( e, NoViableAltException ):
+            self.reportNoViableAlternative(recognizer, e)
+        elif isinstance( e, InputMismatchException ):
+            self.reportInputMismatch(recognizer, e)
+        elif isinstance( e, FailedPredicateException ):
+            self.reportFailedPredicate(recognizer, e)
+        else:
+            print("unknown recognition error type: " + type(e).__name__)
+            recognizer.notifyErrorListeners(e.message, e.offendingToken, e)
+
+    #
+    # {@inheritDoc}
+    #
+    # <p>The default implementation resynchronizes the parser by consuming tokens
+    # until we find one in the resynchronization set--loosely the set of tokens
+    # that can follow the current rule.</p>
+    #
+    def recover(self, recognizer:Parser, e:RecognitionException):
+        if self.lastErrorIndex==recognizer.getInputStream().index \
+            and self.lastErrorStates is not None \
+            and recognizer.state in self.lastErrorStates:
+           # uh oh, another error at same token index and previously-visited
+           # state in ATN; must be a case where LT(1) is in the recovery
+           # token set so nothing got consumed. Consume a single token
+           # at least to prevent an infinite loop; this is a failsafe.
+            recognizer.consume()
+
+        self.lastErrorIndex = recognizer._input.index
+        if self.lastErrorStates is None:
+            self.lastErrorStates = []
+        self.lastErrorStates.append(recognizer.state)
+        followSet = self.getErrorRecoverySet(recognizer)
+        self.consumeUntil(recognizer, followSet)
+
+    # The default implementation of {@link ANTLRErrorStrategy#sync} makes sure
+    # that the current lookahead symbol is consistent with what were expecting
+    # at this point in the ATN. You can call this anytime but ANTLR only
+    # generates code to check before subrules/loops and each iteration.
+    #
+    # <p>Implements Jim Idle's magic sync mechanism in closures and optional
+    # subrules. E.g.,</p>
+    #
+    # <pre>
+    # a : sync ( stuff sync )* ;
+    # sync : {consume to what can follow sync} ;
+    # </pre>
+    #
+    # At the start of a sub rule upon error, {@link #sync} performs single
+    # token deletion, if possible. If it can't do that, it bails on the current
+    # rule and uses the default error recovery, which consumes until the
+    # resynchronization set of the current rule.
+    #
+    # <p>If the sub rule is optional ({@code (...)?}, {@code (...)*}, or block
+    # with an empty alternative), then the expected set includes what follows
+    # the subrule.</p>
+    #
+    # <p>During loop iteration, it consumes until it sees a token that can start a
+    # sub rule or what follows loop. Yes, that is pretty aggressive. We opt to
+    # stay in the loop as long as possible.</p>
+    #
+    # <p><strong>ORIGINS</strong></p>
+    #
+    # <p>Previous versions of ANTLR did a poor job of their recovery within loops.
+    # A single mismatch token or missing token would force the parser to bail
+    # out of the entire rules surrounding the loop. So, for rule</p>
+    #
+    # <pre>
+    # classDef : 'class' ID '{' member* '}'
+    # </pre>
+    #
+    # input with an extra token between members would force the parser to
+    # consume until it found the next class definition rather than the next
+    # member definition of the current class.
+    #
+    # <p>This functionality cost a little bit of effort because the parser has to
+    # compare token set at the start of the loop and at each iteration. If for
+    # some reason speed is suffering for you, you can turn off this
+    # functionality by simply overriding this method as a blank { }.</p>
+    #
+    def sync(self, recognizer:Parser):
+        # If already recovering, don't try to sync
+        if self.inErrorRecoveryMode(recognizer):
+            return
+
+        s = recognizer._interp.atn.states[recognizer.state]
+        la = recognizer.getTokenStream().LA(1)
+        # try cheaper subset first; might get lucky. seems to shave a wee bit off
+        if la==Token.EOF or la in recognizer.atn.nextTokens(s):
+            return
+
+        # Return but don't end recovery. only do that upon valid token match
+        if recognizer.isExpectedToken(la):
+            return
+
+        if s.stateType in [ATNState.BLOCK_START, ATNState.STAR_BLOCK_START,
+                                ATNState.PLUS_BLOCK_START, ATNState.STAR_LOOP_ENTRY]:
+           # report error and recover if possible
+            if self.singleTokenDeletion(recognizer)is not None:
+                return
+            else:
+                raise InputMismatchException(recognizer)
+
+        elif s.stateType in [ATNState.PLUS_LOOP_BACK, ATNState.STAR_LOOP_BACK]:
+            self.reportUnwantedToken(recognizer)
+            expecting = recognizer.getExpectedTokens()
+            whatFollowsLoopIterationOrRule = expecting.addSet(self.getErrorRecoverySet(recognizer))
+            self.consumeUntil(recognizer, whatFollowsLoopIterationOrRule)
+
+        else:
+           # do nothing if we can't identify the exact kind of ATN state
+           pass
+
+    # This is called by {@link #reportError} when the exception is a
+    # {@link NoViableAltException}.
+    #
+    # @see #reportError
+    #
+    # @param recognizer the parser instance
+    # @param e the recognition exception
+    #
+    def reportNoViableAlternative(self, recognizer:Parser, e:NoViableAltException):
+        tokens = recognizer.getTokenStream()
+        if tokens is not None:
+            if e.startToken.type==Token.EOF:
+                input = "<EOF>"
+            else:
+                input = tokens.getText((e.startToken, e.offendingToken))
+        else:
+            input = "<unknown input>"
+        msg = "no viable alternative at input " + self.escapeWSAndQuote(input)
+        recognizer.notifyErrorListeners(msg, e.offendingToken, e)
+
+    #
+    # This is called by {@link #reportError} when the exception is an
+    # {@link InputMismatchException}.
+    #
+    # @see #reportError
+    #
+    # @param recognizer the parser instance
+    # @param e the recognition exception
+    #
+    def reportInputMismatch(self, recognizer:Parser, e:InputMismatchException):
+        msg = "mismatched input " + self.getTokenErrorDisplay(e.offendingToken) \
+              + " expecting " + e.getExpectedTokens().toString(recognizer.literalNames, recognizer.symbolicNames)
+        recognizer.notifyErrorListeners(msg, e.offendingToken, e)
+
+    #
+    # This is called by {@link #reportError} when the exception is a
+    # {@link FailedPredicateException}.
+    #
+    # @see #reportError
+    #
+    # @param recognizer the parser instance
+    # @param e the recognition exception
+    #
+    def reportFailedPredicate(self, recognizer, e):
+        ruleName = recognizer.ruleNames[recognizer._ctx.getRuleIndex()]
+        msg = "rule " + ruleName + " " + e.message
+        recognizer.notifyErrorListeners(msg, e.offendingToken, e)
+
+    # This method is called to report a syntax error which requires the removal
+    # of a token from the input stream. At the time this method is called, the
+    # erroneous symbol is current {@code LT(1)} symbol and has not yet been
+    # removed from the input stream. When this method returns,
+    # {@code recognizer} is in error recovery mode.
+    #
+    # <p>This method is called when {@link #singleTokenDeletion} identifies
+    # single-token deletion as a viable recovery strategy for a mismatched
+    # input error.</p>
+    #
+    # <p>The default implementation simply returns if the handler is already in
+    # error recovery mode. Otherwise, it calls {@link #beginErrorCondition} to
+    # enter error recovery mode, followed by calling
+    # {@link Parser#notifyErrorListeners}.</p>
+    #
+    # @param recognizer the parser instance
+    #
+    def reportUnwantedToken(self, recognizer:Parser):
+        if self.inErrorRecoveryMode(recognizer):
+            return
+
+        self.beginErrorCondition(recognizer)
+        t = recognizer.getCurrentToken()
+        tokenName = self.getTokenErrorDisplay(t)
+        expecting = self.getExpectedTokens(recognizer)
+        msg = "extraneous input " + tokenName + " expecting " \
+            + expecting.toString(recognizer.literalNames, recognizer.symbolicNames)
+        recognizer.notifyErrorListeners(msg, t, None)
+
+    # This method is called to report a syntax error which requires the
+    # insertion of a missing token into the input stream. At the time this
+    # method is called, the missing token has not yet been inserted. When this
+    # method returns, {@code recognizer} is in error recovery mode.
+    #
+    # <p>This method is called when {@link #singleTokenInsertion} identifies
+    # single-token insertion as a viable recovery strategy for a mismatched
+    # input error.</p>
+    #
+    # <p>The default implementation simply returns if the handler is already in
+    # error recovery mode. Otherwise, it calls {@link #beginErrorCondition} to
+    # enter error recovery mode, followed by calling
+    # {@link Parser#notifyErrorListeners}.</p>
+    #
+    # @param recognizer the parser instance
+    #
+    def reportMissingToken(self, recognizer:Parser):
+        if self.inErrorRecoveryMode(recognizer):
+            return
+        self.beginErrorCondition(recognizer)
+        t = recognizer.getCurrentToken()
+        expecting = self.getExpectedTokens(recognizer)
+        msg = "missing " + expecting.toString(recognizer.literalNames, recognizer.symbolicNames) \
+              + " at " + self.getTokenErrorDisplay(t)
+        recognizer.notifyErrorListeners(msg, t, None)
+
+    # <p>The default implementation attempts to recover from the mismatched input
+    # by using single token insertion and deletion as described below. If the
+    # recovery attempt fails, this method throws an
+    # {@link InputMismatchException}.</p>
+    #
+    # <p><strong>EXTRA TOKEN</strong> (single token deletion)</p>
+    #
+    # <p>{@code LA(1)} is not what we are looking for. If {@code LA(2)} has the
+    # right token, however, then assume {@code LA(1)} is some extra spurious
+    # token and delete it. Then consume and return the next token (which was
+    # the {@code LA(2)} token) as the successful result of the match operation.</p>
+    #
+    # <p>This recovery strategy is implemented by {@link #singleTokenDeletion}.</p>
+    #
+    # <p><strong>MISSING TOKEN</strong> (single token insertion)</p>
+    #
+    # <p>If current token (at {@code LA(1)}) is consistent with what could come
+    # after the expected {@code LA(1)} token, then assume the token is missing
+    # and use the parser's {@link TokenFactory} to create it on the fly. The
+    # "insertion" is performed by returning the created token as the successful
+    # result of the match operation.</p>
+    #
+    # <p>This recovery strategy is implemented by {@link #singleTokenInsertion}.</p>
+    #
+    # <p><strong>EXAMPLE</strong></p>
+    #
+    # <p>For example, Input {@code i=(3;} is clearly missing the {@code ')'}. When
+    # the parser returns from the nested call to {@code expr}, it will have
+    # call chain:</p>
+    #
+    # <pre>
+    # stat &rarr; expr &rarr; atom
+    # </pre>
+    #
+    # and it will be trying to match the {@code ')'} at this point in the
+    # derivation:
+    #
+    # <pre>
+    # =&gt; ID '=' '(' INT ')' ('+' atom)* ';'
+    #                    ^
+    # </pre>
+    #
+    # The attempt to match {@code ')'} will fail when it sees {@code ';'} and
+    # call {@link #recoverInline}. To recover, it sees that {@code LA(1)==';'}
+    # is in the set of tokens that can follow the {@code ')'} token reference
+    # in rule {@code atom}. It can assume that you forgot the {@code ')'}.
+    #
+    def recoverInline(self, recognizer:Parser):
+        # SINGLE TOKEN DELETION
+        matchedSymbol = self.singleTokenDeletion(recognizer)
+        if matchedSymbol is not None:
+            # we have deleted the extra token.
+            # now, move past ttype token as if all were ok
+            recognizer.consume()
+            return matchedSymbol
+
+        # SINGLE TOKEN INSERTION
+        if self.singleTokenInsertion(recognizer):
+            return self.getMissingSymbol(recognizer)
+
+        # even that didn't work; must throw the exception
+        raise InputMismatchException(recognizer)
+
+    #
+    # This method implements the single-token insertion inline error recovery
+    # strategy. It is called by {@link #recoverInline} if the single-token
+    # deletion strategy fails to recover from the mismatched input. If this
+    # method returns {@code true}, {@code recognizer} will be in error recovery
+    # mode.
+    #
+    # <p>This method determines whether or not single-token insertion is viable by
+    # checking if the {@code LA(1)} input symbol could be successfully matched
+    # if it were instead the {@code LA(2)} symbol. If this method returns
+    # {@code true}, the caller is responsible for creating and inserting a
+    # token with the correct type to produce this behavior.</p>
+    #
+    # @param recognizer the parser instance
+    # @return {@code true} if single-token insertion is a viable recovery
+    # strategy for the current mismatched input, otherwise {@code false}
+    #
+    def singleTokenInsertion(self, recognizer:Parser):
+        currentSymbolType = recognizer.getTokenStream().LA(1)
+        # if current token is consistent with what could come after current
+        # ATN state, then we know we're missing a token; error recovery
+        # is free to conjure up and insert the missing token
+        atn = recognizer._interp.atn
+        currentState = atn.states[recognizer.state]
+        next = currentState.transitions[0].target
+        expectingAtLL2 = atn.nextTokens(next, recognizer._ctx)
+        if currentSymbolType in expectingAtLL2:
+            self.reportMissingToken(recognizer)
+            return True
+        else:
+            return False
+
+    # This method implements the single-token deletion inline error recovery
+    # strategy. It is called by {@link #recoverInline} to attempt to recover
+    # from mismatched input. If this method returns null, the parser and error
+    # handler state will not have changed. If this method returns non-null,
+    # {@code recognizer} will <em>not</em> be in error recovery mode since the
+    # returned token was a successful match.
+    #
+    # <p>If the single-token deletion is successful, this method calls
+    # {@link #reportUnwantedToken} to report the error, followed by
+    # {@link Parser#consume} to actually "delete" the extraneous token. Then,
+    # before returning {@link #reportMatch} is called to signal a successful
+    # match.</p>
+    #
+    # @param recognizer the parser instance
+    # @return the successfully matched {@link Token} instance if single-token
+    # deletion successfully recovers from the mismatched input, otherwise
+    # {@code null}
+    #
+    def singleTokenDeletion(self, recognizer:Parser):
+        nextTokenType = recognizer.getTokenStream().LA(2)
+        expecting = self.getExpectedTokens(recognizer)
+        if nextTokenType in expecting:
+            self.reportUnwantedToken(recognizer)
+            # print("recoverFromMismatchedToken deleting " \
+            #     + str(recognizer.getTokenStream().LT(1)) \
+            #     + " since " + str(recognizer.getTokenStream().LT(2)) \
+            #     + " is what we want", file=sys.stderr)
+            recognizer.consume() # simply delete extra token
+            # we want to return the token we're actually matching
+            matchedSymbol = recognizer.getCurrentToken()
+            self.reportMatch(recognizer) # we know current token is correct
+            return matchedSymbol
+        else:
+            return None
+
+    # Conjure up a missing token during error recovery.
+    #
+    #  The recognizer attempts to recover from single missing
+    #  symbols. But, actions might refer to that missing symbol.
+    #  For example, x=ID {f($x);}. The action clearly assumes
+    #  that there has been an identifier matched previously and that
+    #  $x points at that token. If that token is missing, but
+    #  the next token in the stream is what we want we assume that
+    #  this token is missing and we keep going. Because we
+    #  have to return some token to replace the missing token,
+    #  we have to conjure one up. This method gives the user control
+    #  over the tokens returned for missing tokens. Mostly,
+    #  you will want to create something special for identifier
+    #  tokens. For literals such as '{' and ',', the default
+    #  action in the parser or tree parser works. It simply creates
+    #  a CommonToken of the appropriate type. The text will be the token.
+    #  If you change what tokens must be created by the lexer,
+    #  override this method to create the appropriate tokens.
+    #
+    def getMissingSymbol(self, recognizer:Parser):
+        currentSymbol = recognizer.getCurrentToken()
+        expecting = self.getExpectedTokens(recognizer)
+        expectedTokenType = expecting[0] # get any element
+        if expectedTokenType==Token.EOF:
+            tokenText = "<missing EOF>"
+        else:
+            name = None
+            if expectedTokenType < len(recognizer.literalNames):
+                name = recognizer.literalNames[expectedTokenType]
+            if name is None and expectedTokenType < len(recognizer.symbolicNames):
+                name = recognizer.symbolicNames[expectedTokenType]
+            tokenText = "<missing " + str(name) + ">"
+        current = currentSymbol
+        lookback = recognizer.getTokenStream().LT(-1)
+        if current.type==Token.EOF and lookback is not None:
+            current = lookback
+        return recognizer.getTokenFactory().create(current.source,
+            expectedTokenType, tokenText, Token.DEFAULT_CHANNEL,
+            -1, -1, current.line, current.column)
+
+    def getExpectedTokens(self, recognizer:Parser):
+        return recognizer.getExpectedTokens()
+
+    # How should a token be displayed in an error message? The default
+    #  is to display just the text, but during development you might
+    #  want to have a lot of information spit out.  Override in that case
+    #  to use t.toString() (which, for CommonToken, dumps everything about
+    #  the token). This is better than forcing you to override a method in
+    #  your token objects because you don't have to go modify your lexer
+    #  so that it creates a new Java type.
+    #
+    def getTokenErrorDisplay(self, t:Token):
+        if t is None:
+            return "<no token>"
+        s = t.text
+        if s is None:
+            if t.type==Token.EOF:
+                s = "<EOF>"
+            else:
+                s = "<" + str(t.type) + ">"
+        return self.escapeWSAndQuote(s)
+
+    def escapeWSAndQuote(self, s:str):
+        s = s.replace("\n","\\n")
+        s = s.replace("\r","\\r")
+        s = s.replace("\t","\\t")
+        return "'" + s + "'"
+
+    #  Compute the error recovery set for the current rule.  During
+    #  rule invocation, the parser pushes the set of tokens that can
+    #  follow that rule reference on the stack; this amounts to
+    #  computing FIRST of what follows the rule reference in the
+    #  enclosing rule. See LinearApproximator.FIRST().
+    #  This local follow set only includes tokens
+    #  from within the rule; i.e., the FIRST computation done by
+    #  ANTLR stops at the end of a rule.
+    #
+    #  EXAMPLE
+    #
+    #  When you find a "no viable alt exception", the input is not
+    #  consistent with any of the alternatives for rule r.  The best
+    #  thing to do is to consume tokens until you see something that
+    #  can legally follow a call to r#or* any rule that called r.
+    #  You don't want the exact set of viable next tokens because the
+    #  input might just be missing a token--you might consume the
+    #  rest of the input looking for one of the missing tokens.
+    #
+    #  Consider grammar:
+    #
+    #  a : '[' b ']'
+    #    | '(' b ')'
+    #    ;
+    #  b : c '^' INT ;
+    #  c : ID
+    #    | INT
+    #    ;
+    #
+    #  At each rule invocation, the set of tokens that could follow
+    #  that rule is pushed on a stack.  Here are the various
+    #  context-sensitive follow sets:
+    #
+    #  FOLLOW(b1_in_a) = FIRST(']') = ']'
+    #  FOLLOW(b2_in_a) = FIRST(')') = ')'
+    #  FOLLOW(c_in_b) = FIRST('^') = '^'
+    #
+    #  Upon erroneous input "[]", the call chain is
+    #
+    #  a -> b -> c
+    #
+    #  and, hence, the follow context stack is:
+    #
+    #  depth     follow set       start of rule execution
+    #    0         <EOF>                    a (from main())
+    #    1          ']'                     b
+    #    2          '^'                     c
+    #
+    #  Notice that ')' is not included, because b would have to have
+    #  been called from a different context in rule a for ')' to be
+    #  included.
+    #
+    #  For error recovery, we cannot consider FOLLOW(c)
+    #  (context-sensitive or otherwise).  We need the combined set of
+    #  all context-sensitive FOLLOW sets--the set of all tokens that
+    #  could follow any reference in the call chain.  We need to
+    #  resync to one of those tokens.  Note that FOLLOW(c)='^' and if
+    #  we resync'd to that token, we'd consume until EOF.  We need to
+    #  sync to context-sensitive FOLLOWs for a, b, and c: {']','^'}.
+    #  In this case, for input "[]", LA(1) is ']' and in the set, so we would
+    #  not consume anything. After printing an error, rule c would
+    #  return normally.  Rule b would not find the required '^' though.
+    #  At this point, it gets a mismatched token error and throws an
+    #  exception (since LA(1) is not in the viable following token
+    #  set).  The rule exception handler tries to recover, but finds
+    #  the same recovery set and doesn't consume anything.  Rule b
+    #  exits normally returning to rule a.  Now it finds the ']' (and
+    #  with the successful match exits errorRecovery mode).
+    #
+    #  So, you can see that the parser walks up the call chain looking
+    #  for the token that was a member of the recovery set.
+    #
+    #  Errors are not generated in errorRecovery mode.
+    #
+    #  ANTLR's error recovery mechanism is based upon original ideas:
+    #
+    #  "Algorithms + Data Structures = Programs" by Niklaus Wirth
+    #
+    #  and
+    #
+    #  "A note on error recovery in recursive descent parsers":
+    #  http:#portal.acm.org/citation.cfm?id=947902.947905
+    #
+    #  Later, Josef Grosch had some good ideas:
+    #
+    #  "Efficient and Comfortable Error Recovery in Recursive Descent
+    #  Parsers":
+    #  ftp:#www.cocolab.com/products/cocktail/doca4.ps/ell.ps.zip
+    #
+    #  Like Grosch I implement context-sensitive FOLLOW sets that are combined
+    #  at run-time upon error to avoid overhead during parsing.
+    #
+    def getErrorRecoverySet(self, recognizer:Parser):
+        atn = recognizer._interp.atn
+        ctx = recognizer._ctx
+        recoverSet = IntervalSet()
+        while ctx is not None and ctx.invokingState>=0:
+            # compute what follows who invoked us
+            invokingState = atn.states[ctx.invokingState]
+            rt = invokingState.transitions[0]
+            follow = atn.nextTokens(rt.followState)
+            recoverSet.addSet(follow)
+            ctx = ctx.parentCtx
+        recoverSet.removeOne(Token.EPSILON)
+        return recoverSet
+
+    # Consume tokens until one matches the given token set.#
+    def consumeUntil(self, recognizer:Parser, set_:set):
+        ttype = recognizer.getTokenStream().LA(1)
+        while ttype != Token.EOF and not ttype in set_:
+            recognizer.consume()
+            ttype = recognizer.getTokenStream().LA(1)
+
+
+#
+# This implementation of {@link ANTLRErrorStrategy} responds to syntax errors
+# by immediately canceling the parse operation with a
+# {@link ParseCancellationException}. The implementation ensures that the
+# {@link ParserRuleContext#exception} field is set for all parse tree nodes
+# that were not completed prior to encountering the error.
+#
+# <p>
+# This error strategy is useful in the following scenarios.</p>
+#
+# <ul>
+# <li><strong>Two-stage parsing:</strong> This error strategy allows the first
+# stage of two-stage parsing to immediately terminate if an error is
+# encountered, and immediately fall back to the second stage. In addition to
+# avoiding wasted work by attempting to recover from errors here, the empty
+# implementation of {@link BailErrorStrategy#sync} improves the performance of
+# the first stage.</li>
+# <li><strong>Silent validation:</strong> When syntax errors are not being
+# reported or logged, and the parse result is simply ignored if errors occur,
+# the {@link BailErrorStrategy} avoids wasting work on recovering from errors
+# when the result will be ignored either way.</li>
+# </ul>
+#
+# <p>
+# {@code myparser.setErrorHandler(new BailErrorStrategy());}</p>
+#
+# @see Parser#setErrorHandler(ANTLRErrorStrategy)
+#
+class BailErrorStrategy(DefaultErrorStrategy):
+    # Instead of recovering from exception {@code e}, re-throw it wrapped
+    #  in a {@link ParseCancellationException} so it is not caught by the
+    #  rule function catches.  Use {@link Exception#getCause()} to get the
+    #  original {@link RecognitionException}.
+    #
+    def recover(self, recognizer:Parser, e:RecognitionException):
+        context = recognizer._ctx
+        while context is not None:
+            context.exception = e
+            context = context.parentCtx
+        raise ParseCancellationException(e)
+
+    # Make sure we don't attempt to recover inline; if the parser
+    #  successfully recovers, it won't throw an exception.
+    #
+    def recoverInline(self, recognizer:Parser):
+        self.recover(recognizer, InputMismatchException(recognizer))
+
+    # Make sure we don't attempt to recover from problems in subrules.#
+    def sync(self, recognizer:Parser):
+        pass
+
+del Parser
\ No newline at end of file
diff --git a/runtime/Python3/src/antlr4/error/Errors.py b/runtime/Python3/src/antlr4/error/Errors.py
new file mode 100644
index 000000000..90f46dc3e
--- /dev/null
+++ b/runtime/Python3/src/antlr4/error/Errors.py
@@ -0,0 +1,197 @@
+# [The "BSD license"]
+#  Copyright (c) 2012 Terence Parr
+#  Copyright (c) 2012 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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.
+#/
+
+# need forward declaration
+Token = None
+Lexer = None
+Parser = None
+TokenStream = None
+ATNConfigSet = None
+ParserRulecontext = None
+PredicateTransition = None
+BufferedTokenStream = None
+
+class UnsupportedOperationException(Exception):
+
+    def __init__(self, msg:str):
+        super().__init__(msg)
+
+class IllegalStateException(Exception):
+
+    def __init__(self, msg:str):
+        super().__init__(msg)
+
+class CancellationException(IllegalStateException):
+
+    def __init__(self, msg:str):
+        super().__init__(msg)
+
+# The root of the ANTLR exception hierarchy. In general, ANTLR tracks just
+#  3 kinds of errors: prediction errors, failed predicate errors, and
+#  mismatched input errors. In each case, the parser knows where it is
+#  in the input, where it is in the ATN, the rule invocation stack,
+#  and what kind of problem occurred.
+
+from antlr4.InputStream import InputStream
+from antlr4.ParserRuleContext import ParserRuleContext
+from antlr4.Recognizer import Recognizer
+
+class RecognitionException(Exception):
+
+
+    def __init__(self, message:str=None, recognizer:Recognizer=None, input:InputStream=None, ctx:ParserRulecontext=None):
+        super().__init__(message)
+        self.message = message
+        self.recognizer = recognizer
+        self.input = input
+        self.ctx = ctx
+        # The current {@link Token} when an error occurred. Since not all streams
+        # support accessing symbols by index, we have to track the {@link Token}
+        # instance itself.
+        self.offendingToken = None
+        # Get the ATN state number the parser was in at the time the error
+        # occurred. For {@link NoViableAltException} and
+        # {@link LexerNoViableAltException} exceptions, this is the
+        # {@link DecisionState} number. For others, it is the state whose outgoing
+        # edge we couldn't match.
+        self.offendingState = -1
+        if recognizer is not None:
+            self.offendingState = recognizer.state
+
+    # <p>If the state number is not known, this method returns -1.</p>
+
+    #
+    # Gets the set of input symbols which could potentially follow the
+    # previously matched symbol at the time this exception was thrown.
+    #
+    # <p>If the set of expected tokens is not known and could not be computed,
+    # this method returns {@code null}.</p>
+    #
+    # @return The set of token types that could potentially follow the current
+    # state in the ATN, or {@code null} if the information is not available.
+    #/
+    def getExpectedTokens(self):
+        if self.recognizer is not None:
+            return self.recognizer.atn.getExpectedTokens(self.offendingState, self.ctx)
+        else:
+            return None
+
+
+class LexerNoViableAltException(RecognitionException):
+
+    def __init__(self, lexer:Lexer, input:InputStream, startIndex:int, deadEndConfigs:ATNConfigSet):
+        super().__init__(message=None, recognizer=lexer, input=input, ctx=None)
+        self.startIndex = startIndex
+        self.deadEndConfigs = deadEndConfigs
+
+    def __str__(self):
+        symbol = ""
+        if self.startIndex >= 0 and self.startIndex < self.input.size:
+            symbol = self.input.getText(self.startIndex, self.startIndex)
+            # TODO symbol = Utils.escapeWhitespace(symbol, false);
+        return "LexerNoViableAltException('" + symbol + "')"
+
+# Indicates that the parser could not decide which of two or more paths
+#  to take based upon the remaining input. It tracks the starting token
+#  of the offending input and also knows where the parser was
+#  in the various paths when the error. Reported by reportNoViableAlternative()
+#
+class NoViableAltException(RecognitionException):
+
+    def __init__(self, recognizer:Parser, input:TokenStream=None, startToken:Token=None,
+                    offendingToken:Token=None, deadEndConfigs:ATNConfigSet=None, ctx:ParserRuleContext=None):
+        if ctx is None:
+            ctx = recognizer._ctx
+        if offendingToken is None:
+            offendingToken = recognizer.getCurrentToken()
+        if startToken is None:
+            startToken = recognizer.getCurrentToken()
+        if input is None:
+            input = recognizer.getInputStream()
+        super().__init__(recognizer=recognizer, input=input, ctx=ctx)
+        # Which configurations did we try at input.index() that couldn't match input.LT(1)?#
+        self.deadEndConfigs = deadEndConfigs
+        # The token object at the start index; the input stream might
+        # 	not be buffering tokens so get a reference to it. (At the
+        #  time the error occurred, of course the stream needs to keep a
+        #  buffer all of the tokens but later we might not have access to those.)
+        self.startToken = startToken
+        self.offendingToken = offendingToken
+
+# This signifies any kind of mismatched input exceptions such as
+#  when the current input does not match the expected token.
+#
+class InputMismatchException(RecognitionException):
+
+    def __init__(self, recognizer:Parser):
+        super().__init__(recognizer=recognizer, input=recognizer.getInputStream(), ctx=recognizer._ctx)
+        self.offendingToken = recognizer.getCurrentToken()
+
+
+# A semantic predicate failed during validation.  Validation of predicates
+#  occurs when normally parsing the alternative just like matching a token.
+#  Disambiguating predicate evaluation occurs when we test a predicate during
+#  prediction.
+
+class FailedPredicateException(RecognitionException):
+
+    def __init__(self, recognizer:Parser, predicate:str=None, message:str=None):
+        super().__init__(message=self.formatMessage(predicate,message), recognizer=recognizer,
+                         input=recognizer.getInputStream(), ctx=recognizer._ctx)
+        s = recognizer._interp.atn.states[recognizer.state]
+        trans = s.transitions[0]
+        from antlr4.atn.Transition import PredicateTransition
+        if isinstance(trans, PredicateTransition):
+            self.ruleIndex = trans.ruleIndex
+            self.predicateIndex = trans.predIndex
+        else:
+            self.ruleIndex = 0
+            self.predicateIndex = 0
+        self.predicate = predicate
+        self.offendingToken = recognizer.getCurrentToken()
+
+    def formatMessage(self, predicate:str, message:str):
+        if message is not None:
+            return message
+        else:
+            return "failed predicate: {" + predicate + "}?"
+
+class ParseCancellationException(CancellationException):
+
+    pass
+
+del Token
+del Lexer
+del Parser
+del TokenStream
+del ATNConfigSet
+del ParserRulecontext
+del PredicateTransition
+del BufferedTokenStream
diff --git a/runtime/Python3/src/antlr4/error/__init__.py b/runtime/Python3/src/antlr4/error/__init__.py
new file mode 100644
index 000000000..216c000dc
--- /dev/null
+++ b/runtime/Python3/src/antlr4/error/__init__.py
@@ -0,0 +1 @@
+__author__ = 'ericvergnaud'
diff --git a/runtime/Python3/src/antlr4/tree/Chunk.py b/runtime/Python3/src/antlr4/tree/Chunk.py
new file mode 100644
index 000000000..bd110995d
--- /dev/null
+++ b/runtime/Python3/src/antlr4/tree/Chunk.py
@@ -0,0 +1,23 @@
+class Chunk(object):
+    pass
+
+class TagChunk(Chunk):
+
+    def __init__(self, tag:str, label:str=None):
+        self.tag = tag
+        self.label = label
+
+    def __str__(self):
+        if self.label is None:
+            return self.tag
+        else:
+            return self.label + ":" + self.tag
+
+class TextChunk(Chunk):
+
+    def __init__(self, text:str):
+        self.text = text
+
+    def __str__(self):
+        return "'" + self.text + "'"
+
diff --git a/runtime/Python3/src/antlr4/tree/ParseTreeMatch.py b/runtime/Python3/src/antlr4/tree/ParseTreeMatch.py
new file mode 100644
index 000000000..9b1f2cb61
--- /dev/null
+++ b/runtime/Python3/src/antlr4/tree/ParseTreeMatch.py
@@ -0,0 +1,143 @@
+#
+# [The "BSD license"]
+# Copyright (c) 2013 Terence Parr
+# Copyright (c) 2013 Sam Harwell
+# Copyright (c) 2014 Eric Vergnaud
+# 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.
+#
+
+
+#
+# Represents the result of matching a {@link ParseTree} against a tree pattern.
+#
+from io import StringIO
+from antlr4.tree.ParseTreePattern import ParseTreePattern
+from antlr4.tree.Tree import ParseTree
+
+
+class ParseTreeMatch(object):
+
+    #
+    # Constructs a new instance of {@link ParseTreeMatch} from the specified
+    # parse tree and pattern.
+    #
+    # @param tree The parse tree to match against the pattern.
+    # @param pattern The parse tree pattern.
+    # @param labels A mapping from label names to collections of
+    # {@link ParseTree} objects located by the tree pattern matching process.
+    # @param mismatchedNode The first node which failed to match the tree
+    # pattern during the matching process.
+    #
+    # @exception IllegalArgumentException if {@code tree} is {@code null}
+    # @exception IllegalArgumentException if {@code pattern} is {@code null}
+    # @exception IllegalArgumentException if {@code labels} is {@code null}
+    #
+    def __init__(self, tree:ParseTree, pattern:ParseTreePattern, labels:dict, mismatchedNode:ParseTree):
+        if tree is None:
+            raise Exception("tree cannot be null")
+        if pattern is None:
+            raise Exception("pattern cannot be null")
+        if labels is None:
+            raise Exception("labels cannot be null")
+        self.tree = tree
+        self.pattern = pattern
+        self.labels = labels
+        self.mismatchedNode = mismatchedNode
+
+    #
+    # Get the last node associated with a specific {@code label}.
+    #
+    # <p>For example, for pattern {@code <id:ID>}, {@code get("id")} returns the
+    # node matched for that {@code ID}. If more than one node
+    # matched the specified label, only the last is returned. If there is
+    # no node associated with the label, this returns {@code null}.</p>
+    #
+    # <p>Pattern tags like {@code <ID>} and {@code <expr>} without labels are
+    # considered to be labeled with {@code ID} and {@code expr}, respectively.</p>
+    #
+    # @param label The label to check.
+    #
+    # @return The last {@link ParseTree} to match a tag with the specified
+    # label, or {@code null} if no parse tree matched a tag with the label.
+    #
+    def get(self, label:str):
+        parseTrees = self.labels.get(label, None)
+        if parseTrees is None or len(parseTrees)==0:
+            return None
+        else:
+            return parseTrees[len(parseTrees)-1]
+
+    #
+    # Return all nodes matching a rule or token tag with the specified label.
+    #
+    # <p>If the {@code label} is the name of a parser rule or token in the
+    # grammar, the resulting list will contain both the parse trees matching
+    # rule or tags explicitly labeled with the label and the complete set of
+    # parse trees matching the labeled and unlabeled tags in the pattern for
+    # the parser rule or token. For example, if {@code label} is {@code "foo"},
+    # the result will contain <em>all</em> of the following.</p>
+    #
+    # <ul>
+    # <li>Parse tree nodes matching tags of the form {@code <foo:anyRuleName>} and
+    # {@code <foo:AnyTokenName>}.</li>
+    # <li>Parse tree nodes matching tags of the form {@code <anyLabel:foo>}.</li>
+    # <li>Parse tree nodes matching tags of the form {@code <foo>}.</li>
+    # </ul>
+    #
+    # @param label The label.
+    #
+    # @return A collection of all {@link ParseTree} nodes matching tags with
+    # the specified {@code label}. If no nodes matched the label, an empty list
+    # is returned.
+    #
+    def getAll(self, label:str):
+        nodes = self.labels.get(label, None)
+        if nodes is None:
+            return list()
+        else:
+            return nodes
+
+
+    #
+    # Gets a value indicating whether the match operation succeeded.
+    #
+    # @return {@code true} if the match operation succeeded; otherwise,
+    # {@code false}.
+    #
+    def succeeded(self):
+        return self.mismatchedNode is None
+
+    #
+    # {@inheritDoc}
+    #
+    def __str__(self):
+        with StringIO() as buf:
+            buf.write("Match ")
+            buf.write("succeeded" if self.succeeded() else "failed")
+            buf.write("; found ")
+            buf.write(str(len(self.labels)))
+            buf.write(" labels")
+            return buf.getvalue()
diff --git a/runtime/Python3/src/antlr4/tree/ParseTreePattern.py b/runtime/Python3/src/antlr4/tree/ParseTreePattern.py
new file mode 100644
index 000000000..57063e34c
--- /dev/null
+++ b/runtime/Python3/src/antlr4/tree/ParseTreePattern.py
@@ -0,0 +1,96 @@
+#
+# [The "BSD license"]
+# Copyright (c) 2013 Terence Parr
+# Copyright (c) 2013 Sam Harwell
+# Copyright (c) 2014 Eric Vergnaud
+# 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 pattern like {@code <ID> = <expr>;} converted to a {@link ParseTree} by
+# {@link ParseTreePatternMatcher#compile(String, int)}.
+#
+from antlr4.tree.ParseTreePatternMatcher import ParseTreePatternMatcher
+from antlr4.tree.Tree import ParseTree
+from antlr4.xpath.XPath import XPath
+
+
+class ParseTreePattern(object):
+
+    # Construct a new instance of the {@link ParseTreePattern} class.
+    #
+    # @param matcher The {@link ParseTreePatternMatcher} which created this
+    # tree pattern.
+    # @param pattern The tree pattern in concrete syntax form.
+    # @param patternRuleIndex The parser rule which serves as the root of the
+    # tree pattern.
+    # @param patternTree The tree pattern in {@link ParseTree} form.
+    #
+    def __init__(self, matcher:ParseTreePatternMatcher, pattern:str, patternRuleIndex:int , patternTree:ParseTree):
+        self.matcher = matcher
+        self.patternRuleIndex = patternRuleIndex
+        self.pattern = pattern
+        self.patternTree = patternTree
+
+    #
+    # Match a specific parse tree against this tree pattern.
+    #
+    # @param tree The parse tree to match against this tree pattern.
+    # @return A {@link ParseTreeMatch} object describing the result of the
+    # match operation. The {@link ParseTreeMatch#succeeded()} method can be
+    # used to determine whether or not the match was successful.
+    #
+    def match(self, tree:ParseTree):
+        return self.matcher.match(tree, self)
+
+    #
+    # Determine whether or not a parse tree matches this tree pattern.
+    #
+    # @param tree The parse tree to match against this tree pattern.
+    # @return {@code true} if {@code tree} is a match for the current tree
+    # pattern; otherwise, {@code false}.
+    #
+    def matches(self, tree:ParseTree):
+        return self.matcher.match(tree, self).succeeded()
+
+    # Find all nodes using XPath and then try to match those subtrees against
+    # this tree pattern.
+    #
+    # @param tree The {@link ParseTree} to match against this pattern.
+    # @param xpath An expression matching the nodes
+    #
+    # @return A collection of {@link ParseTreeMatch} objects describing the
+    # successful matches. Unsuccessful matches are omitted from the result,
+    # regardless of the reason for the failure.
+    #
+    def findAll(self, tree:ParseTree, xpath:str):
+        subtrees = XPath.findAll(tree, xpath, self.matcher.parser)
+        matches = list()
+        for t in subtrees:
+            match = self.match(t)
+            if match.succeeded():
+                matches.append(match)
+        return matches
diff --git a/runtime/Python3/src/antlr4/tree/ParseTreePatternMatcher.py b/runtime/Python3/src/antlr4/tree/ParseTreePatternMatcher.py
new file mode 100644
index 000000000..25611c434
--- /dev/null
+++ b/runtime/Python3/src/antlr4/tree/ParseTreePatternMatcher.py
@@ -0,0 +1,398 @@
+#
+# [The "BSD license"]
+# Copyright (c) 2013 Terence Parr
+# Copyright (c) 2013 Sam Harwell
+# Copyright (c) 2014 Eric Vergnaud
+# 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 tree pattern matching mechanism for ANTLR {@link ParseTree}s.
+#
+# <p>Patterns are strings of source input text with special tags representing
+# token or rule references such as:</p>
+#
+# <p>{@code <ID> = <expr>;}</p>
+#
+# <p>Given a pattern start rule such as {@code statement}, this object constructs
+# a {@link ParseTree} with placeholders for the {@code ID} and {@code expr}
+# subtree. Then the {@link #match} routines can compare an actual
+# {@link ParseTree} from a parse with this pattern. Tag {@code <ID>} matches
+# any {@code ID} token and tag {@code <expr>} references the result of the
+# {@code expr} rule (generally an instance of {@code ExprContext}.</p>
+#
+# <p>Pattern {@code x = 0;} is a similar pattern that matches the same pattern
+# except that it requires the identifier to be {@code x} and the expression to
+# be {@code 0}.</p>
+#
+# <p>The {@link #matches} routines return {@code true} or {@code false} based
+# upon a match for the tree rooted at the parameter sent in. The
+# {@link #match} routines return a {@link ParseTreeMatch} object that
+# contains the parse tree, the parse tree pattern, and a map from tag name to
+# matched nodes (more below). A subtree that fails to match, returns with
+# {@link ParseTreeMatch#mismatchedNode} set to the first tree node that did not
+# match.</p>
+#
+# <p>For efficiency, you can compile a tree pattern in string form to a
+# {@link ParseTreePattern} object.</p>
+#
+# <p>See {@code TestParseTreeMatcher} for lots of examples.
+# {@link ParseTreePattern} has two static helper methods:
+# {@link ParseTreePattern#findAll} and {@link ParseTreePattern#match} that
+# are easy to use but not super efficient because they create new
+# {@link ParseTreePatternMatcher} objects each time and have to compile the
+# pattern in string form before using it.</p>
+#
+# <p>The lexer and parser that you pass into the {@link ParseTreePatternMatcher}
+# constructor are used to parse the pattern in string form. The lexer converts
+# the {@code <ID> = <expr>;} into a sequence of four tokens (assuming lexer
+# throws out whitespace or puts it on a hidden channel). Be aware that the
+# input stream is reset for the lexer (but not the parser; a
+# {@link ParserInterpreter} is created to parse the input.). Any user-defined
+# fields you have put into the lexer might get changed when this mechanism asks
+# it to scan the pattern string.</p>
+#
+# <p>Normally a parser does not accept token {@code <expr>} as a valid
+# {@code expr} but, from the parser passed in, we create a special version of
+# the underlying grammar representation (an {@link ATN}) that allows imaginary
+# tokens representing rules ({@code <expr>}) to match entire rules. We call
+# these <em>bypass alternatives</em>.</p>
+#
+# <p>Delimiters are {@code <} and {@code >}, with {@code \} as the escape string
+# by default, but you can set them to whatever you want using
+# {@link #setDelimiters}. You must escape both start and stop strings
+# {@code \<} and {@code \>}.</p>
+#
+from antlr4.CommonTokenStream import CommonTokenStream
+from antlr4.InputStream import InputStream
+from antlr4.ParserRuleContext import ParserRuleContext
+from antlr4.Lexer import Lexer
+from antlr4.ListTokenSource import ListTokenSource
+from antlr4.Token import Token
+from antlr4.error.ErrorStrategy import BailErrorStrategy
+from antlr4.error.Errors import RecognitionException, ParseCancellationException
+from antlr4.tree.Chunk import TagChunk, TextChunk
+from antlr4.tree.RuleTagToken import RuleTagToken
+from antlr4.tree.TokenTagToken import TokenTagToken
+from antlr4.tree.Tree import ParseTree, TerminalNode, RuleNode
+
+# need forward declaration
+Parser = None
+ParseTreePattern = None
+
+class CannotInvokeStartRule(Exception):
+
+    def __init__(self, e:Exception):
+        super().__init__(e)
+
+class StartRuleDoesNotConsumeFullPattern(Exception):
+
+    pass
+
+
+class ParseTreePatternMatcher(object):
+
+    # Constructs a {@link ParseTreePatternMatcher} or from a {@link Lexer} and
+    # {@link Parser} object. The lexer input stream is altered for tokenizing
+    # the tree patterns. The parser is used as a convenient mechanism to get
+    # the grammar name, plus token, rule names.
+    def __init__(self, lexer:Lexer, parser:Parser):
+        self.lexer = lexer
+        self.parser = parser
+        self.start = "<"
+        self.stop = ">"
+        self.escape = "\\"  # e.g., \< and \> must escape BOTH!
+
+    # Set the delimiters used for marking rule and token tags within concrete
+    # syntax used by the tree pattern parser.
+    #
+    # @param start The start delimiter.
+    # @param stop The stop delimiter.
+    # @param escapeLeft The escape sequence to use for escaping a start or stop delimiter.
+    #
+    # @exception IllegalArgumentException if {@code start} is {@code null} or empty.
+    # @exception IllegalArgumentException if {@code stop} is {@code null} or empty.
+    #
+    def setDelimiters(self, start:str, stop:str, escapeLeft:str):
+        if start is None or len(start)==0:
+            raise Exception("start cannot be null or empty")
+        if stop is None or len(stop)==0:
+            raise Exception("stop cannot be null or empty")
+        self.start = start
+        self.stop = stop
+        self.escape = escapeLeft
+
+    # Does {@code pattern} matched as rule {@code patternRuleIndex} match {@code tree}?#
+    def matchesRuleIndex(self, tree:ParseTree, pattern:str, patternRuleIndex:int):
+        p = self.compileTreePattern(pattern, patternRuleIndex)
+        return self.matches(tree, p)
+
+    # Does {@code pattern} matched as rule patternRuleIndex match tree? Pass in a
+    #  compiled pattern instead of a string representation of a tree pattern.
+    #
+    def matchesPattern(self, tree:ParseTree, pattern:ParseTreePattern):
+        mismatchedNode = self.matchImpl(tree, pattern.patternTree, dict())
+        return mismatchedNode is None
+
+    #
+    # Compare {@code pattern} matched as rule {@code patternRuleIndex} against
+    # {@code tree} and return a {@link ParseTreeMatch} object that contains the
+    # matched elements, or the node at which the match failed.
+    #
+    def matchRuleIndex(self, tree:ParseTree, pattern:str, patternRuleIndex:int):
+        p = self.compileTreePattern(pattern, patternRuleIndex)
+        return self.matchPattern(tree, p)
+
+    #
+    # Compare {@code pattern} matched against {@code tree} and return a
+    # {@link ParseTreeMatch} object that contains the matched elements, or the
+    # node at which the match failed. Pass in a compiled pattern instead of a
+    # string representation of a tree pattern.
+    #
+    def matchPattern(self, tree:ParseTree, pattern:ParseTreePattern):
+        labels = dict()
+        mismatchedNode = self.matchImpl(tree, pattern.patternTree, labels)
+        from antlr4.tree.ParseTreeMatch import ParseTreeMatch
+        return ParseTreeMatch(tree, pattern, labels, mismatchedNode)
+
+    #
+    # For repeated use of a tree pattern, compile it to a
+    # {@link ParseTreePattern} using this method.
+    #
+    def compileTreePattern(self, pattern:str, patternRuleIndex:int):
+        tokenList = self.tokenize(pattern)
+        tokenSrc = ListTokenSource(tokenList)
+        tokens = CommonTokenStream(tokenSrc)
+        from antlr4.ParserInterpreter import ParserInterpreter
+        parserInterp = ParserInterpreter(self.parser.grammarFileName, self.parser.tokenNames,
+                                self.parser.ruleNames, self.parser.getATNWithBypassAlts(),tokens)
+        tree = None
+        try:
+            parserInterp.setErrorHandler(BailErrorStrategy())
+            tree = parserInterp.parse(patternRuleIndex)
+        except ParseCancellationException as e:
+            raise e.cause
+        except RecognitionException as e:
+            raise e
+        except Exception as e:
+            raise CannotInvokeStartRule(e)
+
+        # Make sure tree pattern compilation checks for a complete parse
+        if tokens.LA(1)!=Token.EOF:
+            raise StartRuleDoesNotConsumeFullPattern()
+
+        from antlr4.tree.ParseTreePattern import ParseTreePattern
+        return ParseTreePattern(self, pattern, patternRuleIndex, tree)
+
+    #
+    # Recursively walk {@code tree} against {@code patternTree}, filling
+    # {@code match.}{@link ParseTreeMatch#labels labels}.
+    #
+    # @return the first node encountered in {@code tree} which does not match
+    # a corresponding node in {@code patternTree}, or {@code null} if the match
+    # was successful. The specific node returned depends on the matching
+    # algorithm used by the implementation, and may be overridden.
+    #
+    def matchImpl(self, tree:ParseTree, patternTree:ParseTree, labels:dict):
+        if tree is None:
+            raise Exception("tree cannot be null")
+        if patternTree is None:
+            raise Exception("patternTree cannot be null")
+
+        # x and <ID>, x and y, or x and x; or could be mismatched types
+        if isinstance(tree, TerminalNode) and isinstance(patternTree, TerminalNode ):
+            mismatchedNode = None
+            # both are tokens and they have same type
+            if tree.symbol.type == patternTree.symbol.type:
+                if isinstance( patternTree.symbol, TokenTagToken ): # x and <ID>
+                    tokenTagToken = patternTree.symbol
+                    # track label->list-of-nodes for both token name and label (if any)
+                    self.map(labels, tokenTagToken.tokenName, tree)
+                    if tokenTagToken.label is not None:
+                        self.map(labels, tokenTagToken.label, tree)
+                elif tree.getText()==patternTree.getText():
+                    # x and x
+                    pass
+                else:
+                    # x and y
+                    if mismatchedNode is None:
+                        mismatchedNode = tree
+            else:
+                if mismatchedNode is None:
+                    mismatchedNode = tree
+
+            return mismatchedNode
+
+        if isinstance(tree, ParserRuleContext) and isinstance(patternTree, ParserRuleContext):
+            mismatchedNode = None
+            # (expr ...) and <expr>
+            ruleTagToken = self.getRuleTagToken(patternTree)
+            if ruleTagToken is not None:
+                m = None
+                if tree.ruleContext.ruleIndex == patternTree.ruleContext.ruleIndex:
+                    # track label->list-of-nodes for both rule name and label (if any)
+                    self.map(labels, ruleTagToken.ruleName, tree)
+                    if ruleTagToken.label is not None:
+                        self.map(labels, ruleTagToken.label, tree)
+                else:
+                    if mismatchedNode is None:
+                        mismatchedNode = tree
+
+                return mismatchedNode
+
+            # (expr ...) and (expr ...)
+            if tree.getChildCount()!=patternTree.getChildCount():
+                if mismatchedNode is None:
+                    mismatchedNode = tree
+                return mismatchedNode
+
+            n = tree.getChildCount()
+            for i in range(0, n):
+                childMatch = self.matchImpl(tree.getChild(i), patternTree.getChild(i), labels)
+                if childMatch is not None:
+                    return childMatch
+
+            return mismatchedNode
+
+        # if nodes aren't both tokens or both rule nodes, can't match
+        return tree
+
+    def map(self, labels, label, tree):
+        v = labels.get(label, None)
+        if v is None:
+            v = list()
+            labels[label] = v
+        v.append(tree)
+
+    # Is {@code t} {@code (expr <expr>)} subtree?#
+    def getRuleTagToken(self, tree:ParseTree):
+        if isinstance( tree, RuleNode ):
+            if tree.getChildCount()==1 and isinstance(tree.getChild(0), TerminalNode ):
+                c = tree.getChild(0)
+                if isinstance( c.symbol, RuleTagToken ):
+                    return c.symbol
+        return None
+
+    def tokenize(self, pattern:str):
+        # split pattern into chunks: sea (raw input) and islands (<ID>, <expr>)
+        chunks = self.split(pattern)
+
+        # create token stream from text and tags
+        tokens = list()
+        for chunk in chunks:
+            if isinstance( chunk, TagChunk ):
+                # add special rule token or conjure up new token from name
+                if chunk.tag[0].isupper():
+                    ttype = self.parser.getTokenType(chunk.tag)
+                    if ttype==Token.INVALID_TYPE:
+                        raise Exception("Unknown token " + str(chunk.tag) + " in pattern: " + pattern)
+                    tokens.append(TokenTagToken(chunk.tag, ttype, chunk.label))
+                elif chunk.tag[0].islower():
+                    ruleIndex = self.parser.getRuleIndex(chunk.tag)
+                    if ruleIndex==-1:
+                        raise Exception("Unknown rule " + str(chunk.tag) + " in pattern: " + pattern)
+                    ruleImaginaryTokenType = self.parser.getATNWithBypassAlts().ruleToTokenType[ruleIndex]
+                    tokens.append(RuleTagToken(chunk.tag, ruleImaginaryTokenType, chunk.label))
+                else:
+                    raise Exception("invalid tag: " + str(chunk.tag) + " in pattern: " + pattern)
+            else:
+                self.lexer.setInputStream(InputStream(chunk.text))
+                t = self.lexer.nextToken()
+                while t.type!=Token.EOF:
+                    tokens.append(t)
+                    t = self.lexer.nextToken()
+        return tokens
+
+    # Split {@code <ID> = <e:expr> ;} into 4 chunks for tokenizing by {@link #tokenize}.#
+    def split(self, pattern:str):
+        p = 0
+        n = len(pattern)
+        chunks = list()
+        # find all start and stop indexes first, then collect
+        starts = list()
+        stops = list()
+        while p < n :
+            if p == pattern.find(self.escape + self.start, p):
+                p += len(self.escape) + len(self.start)
+            elif p == pattern.find(self.escape + self.stop, p):
+                p += len(self.escape) + len(self.stop)
+            elif p == pattern.find(self.start, p):
+                starts.append(p)
+                p += len(self.start)
+            elif p == pattern.find(self.stop, p):
+                stops.append(p)
+                p += len(self.stop)
+            else:
+                p += 1
+
+        nt = len(starts)
+
+        if nt > len(stops):
+            raise Exception("unterminated tag in pattern: " + pattern)
+        if nt < len(stops):
+            raise Exception("missing start tag in pattern: " + pattern)
+
+        for i in range(0, nt):
+            if starts[i] >= stops[i]:
+                raise Exception("tag delimiters out of order in pattern: " + pattern)
+
+        # collect into chunks now
+        if nt==0:
+            chunks.append(TextChunk(pattern))
+
+        if nt>0 and starts[0]>0: # copy text up to first tag into chunks
+            text = pattern[0:starts[0]]
+            chunks.add(TextChunk(text))
+
+        for i in range(0, nt):
+            # copy inside of <tag>
+            tag = pattern[starts[i] + len(self.start) : stops[i]]
+            ruleOrToken = tag
+            label = None
+            colon = tag.find(':')
+            if colon >= 0:
+                label = tag[0:colon]
+                ruleOrToken = tag[colon+1 : len(tag)]
+            chunks.append(TagChunk(label, ruleOrToken))
+            if i+1 < len(starts):
+                # copy from end of <tag> to start of next
+                text = pattern[stops[i] + len(self.stop) : starts[i + 1]]
+                chunks.append(TextChunk(text))
+
+        if nt > 0 :
+            afterLastTag = stops[nt - 1] + len(self.stop)
+            if afterLastTag < n : # copy text from end of last tag to end
+                text = pattern[afterLastTag : n]
+                chunks.append(TextChunk(text))
+
+        # strip out the escape sequences from text chunks but not tags
+        for i in range(0, len(chunks)):
+            c = chunks[i]
+            if isinstance( c, TextChunk ):
+                unescaped = c.text.replace(self.escape, "")
+                if len(unescaped) < len(c.text):
+                    chunks[i] = TextChunk(unescaped)
+        return chunks
diff --git a/runtime/Python3/src/antlr4/tree/RuleTagToken.py b/runtime/Python3/src/antlr4/tree/RuleTagToken.py
new file mode 100644
index 000000000..a0a1eb5d7
--- /dev/null
+++ b/runtime/Python3/src/antlr4/tree/RuleTagToken.py
@@ -0,0 +1,74 @@
+#
+# [The "BSD license"]
+# Copyright (c) 2013 Terence Parr
+# Copyright (c) 2013 Sam Harwell
+# Copyright (c) 2014 Eric Vergnaud
+# 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 {@link Token} object representing an entire subtree matched by a parser
+# rule; e.g., {@code <expr>}. These tokens are created for {@link TagChunk}
+# chunks where the tag corresponds to a parser rule.
+#
+from antlr4.Token import Token
+
+
+class RuleTagToken(Token):
+   #
+    # Constructs a new instance of {@link RuleTagToken} with the specified rule
+    # name, bypass token type, and label.
+    #
+    # @param ruleName The name of the parser rule this rule tag matches.
+    # @param bypassTokenType The bypass token type assigned to the parser rule.
+    # @param label The label associated with the rule tag, or {@code null} if
+    # the rule tag is unlabeled.
+    #
+    # @exception IllegalArgumentException if {@code ruleName} is {@code null}
+    # or empty.
+
+    def __init__(self, ruleName:str, bypassTokenType:int, label:str=None):
+        if ruleName is None or len(ruleName)==0:
+            raise Exception("ruleName cannot be null or empty.")
+        self.source = None
+        self.type = bypassTokenType # token type of the token
+        self.channel = Token.DEFAULT_CHANNEL # The parser ignores everything not on DEFAULT_CHANNEL
+        self.start = -1 # optional; return -1 if not implemented.
+        self.stop = -1  # optional; return -1 if not implemented.
+        self.tokenIndex = -1 # from 0..n-1 of the token object in the input stream
+        self.line = 0 # line=1..n of the 1st character
+        self.column = -1 # beginning of the line at which it occurs, 0..n-1
+        self.label = label
+        self._text = self.getText() # text of the token.
+
+        self.ruleName = ruleName
+
+
+    def getText(self):
+        if self.label is None:
+            return "<" + self.ruleName + ">"
+        else:
+            return "<" + self.label + ":" + self.ruleName + ">"
diff --git a/runtime/Python3/src/antlr4/tree/TokenTagToken.py b/runtime/Python3/src/antlr4/tree/TokenTagToken.py
new file mode 100644
index 000000000..1fe3bf0f8
--- /dev/null
+++ b/runtime/Python3/src/antlr4/tree/TokenTagToken.py
@@ -0,0 +1,72 @@
+#
+# [The "BSD license"]
+# Copyright (c) 2013 Terence Parr
+# Copyright (c) 2013 Sam Harwell
+# Copyright (c) 2014 Eric Vergnaud
+# 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 {@link Token} object representing a token of a particular type; e.g.,
+# {@code <ID>}. These tokens are created for {@link TagChunk} chunks where the
+# tag corresponds to a lexer rule or token type.
+#
+from antlr4.Token import CommonToken
+
+
+class TokenTagToken(CommonToken):
+
+    # Constructs a new instance of {@link TokenTagToken} with the specified
+    # token name, type, and label.
+    #
+    # @param tokenName The token name.
+    # @param type The token type.
+    # @param label The label associated with the token tag, or {@code null} if
+    # the token tag is unlabeled.
+    #
+    def __init__(self, tokenName:str, type:int, label:str=None):
+        super().__init__(type=type)
+        self.tokenName = tokenName
+        self.label = label
+        self._text = self.getText()
+
+    #
+    # {@inheritDoc}
+    #
+    # <p>The implementation for {@link TokenTagToken} returns the token tag
+    # formatted with {@code <} and {@code >} delimiters.</p>
+    #
+    def getText(self):
+        if self.label is None:
+            return "<" + self.tokenName + ">"
+        else:
+            return "<" + self.label + ":" + self.tokenName + ">"
+
+    # <p>The implementation for {@link TokenTagToken} returns a string of the form
+    # {@code tokenName:type}.</p>
+    #
+    def __str__(self):
+        return self.tokenName + ":" + str(self.type)
diff --git a/runtime/Python3/src/antlr4/tree/Tree.py b/runtime/Python3/src/antlr4/tree/Tree.py
new file mode 100644
index 000000000..b26aeb1dc
--- /dev/null
+++ b/runtime/Python3/src/antlr4/tree/Tree.py
@@ -0,0 +1,195 @@
+# [The "BSD license"]
+#  Copyright (c) 2012 Terence Parr
+#  Copyright (c) 2012 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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.
+#/
+
+
+# The basic notion of a tree has a parent, a payload, and a list of children.
+#  It is the most abstract interface for all the trees used by ANTLR.
+#/
+from antlr4.Token import Token
+
+INVALID_INTERVAL = (-1, -2)
+
+class Tree(object):
+    pass
+
+class SyntaxTree(Tree):
+    pass
+
+class ParseTree(SyntaxTree):
+    pass
+
+class RuleNode(ParseTree):
+    pass
+
+class TerminalNode(ParseTree):
+    pass
+
+class ErrorNode(TerminalNode):
+    pass
+
+class ParseTreeVisitor(object):
+    def visit(self, tree):
+        return tree.accept(self)
+
+    def visitChildren(self, node):
+        result = self.defaultResult()
+        n = node.getChildCount()
+        for i in range(n):
+            if not self.shouldVisitNextChild(node, result):
+                return
+
+            c = node.getChild(i)
+            childResult = c.accept(self)
+            result = self.aggregateResult(result, childResult)
+
+        return result
+
+    def visitTerminal(self, node):
+        return self.defaultResult()
+
+    def visitErrorNode(self, node):
+        return self.defaultResult()
+
+    def defaultResult(self):
+        return None
+
+    def aggregateResult(self, aggregate, nextResult):
+        return nextResult
+
+    def shouldVisitNextChild(self, node, currentResult):
+        return True
+
+ParserRuleContext = None
+
+class ParseTreeListener(object):
+
+    def visitTerminal(self, node:TerminalNode):
+        pass
+
+    def visitErrorNode(self, node:ErrorNode):
+        pass
+
+    def enterEveryRule(self, ctx:ParserRuleContext):
+        pass
+
+    def exitEveryRule(self, ctx:ParserRuleContext):
+        pass
+
+del ParserRuleContext
+
+class TerminalNodeImpl(TerminalNode):
+
+    def __init__(self, symbol:Token):
+        self.parentCtx = None
+        self.symbol = symbol
+    def __setattr__(self, key, value):
+        super().__setattr__(key, value)
+
+    def getChild(self, i:int):
+        return None
+
+    def getSymbol(self):
+        return self.symbol
+
+    def getParent(self):
+        return self.parentCtx
+
+    def getPayload(self):
+        return self.symbol
+
+    def getSourceInterval(self):
+        if self.symbol is None:
+            return INVALID_INTERVAL
+        tokenIndex = self.symbol.tokenIndex
+        return (tokenIndex, tokenIndex)
+
+    def getChildCount(self):
+        return 0
+
+    def accept(self, visitor:ParseTreeVisitor):
+        return visitor.visitTerminal(self)
+
+    def getText(self):
+        return self.symbol.text
+
+    def __str__(self):
+        if self.symbol.type == Token.EOF:
+            return "<EOF>"
+        else:
+            return self.symbol.text
+
+# Represents a token that was consumed during resynchronization
+#  rather than during a valid match operation. For example,
+#  we will create this kind of a node during single token insertion
+#  and deletion as well as during "consume until error recovery set"
+#  upon no viable alternative exceptions.
+
+class ErrorNodeImpl(TerminalNodeImpl,ErrorNode):
+
+    def __init__(self, token:Token):
+        super().__init__(token)
+
+    def accept(self, visitor:ParseTreeVisitor):
+        return visitor.visitErrorNode(self)
+
+
+class ParseTreeWalker(object):
+
+    DEFAULT = None
+
+    def walk(self, listener:ParseTreeListener, t:ParseTree):
+        if isinstance(t, ErrorNode):
+            listener.visitErrorNode(t)
+            return
+        elif isinstance(t, TerminalNode):
+            listener.visitTerminal(t)
+            return
+        self.enterRule(listener, t)
+        for child in t.getChildren():
+            self.walk(listener, child)
+        self.exitRule(listener, t)
+
+    #
+    # The discovery of a rule node, involves sending two events: the generic
+    # {@link ParseTreeListener#enterEveryRule} and a
+    # {@link RuleContext}-specific event. First we trigger the generic and then
+    # the rule specific. We to them in reverse order upon finishing the node.
+    #
+    def enterRule(self, listener:ParseTreeListener, r:RuleNode):
+        ctx = r.getRuleContext()
+        listener.enterEveryRule(ctx)
+        ctx.enterRule(listener)
+
+    def exitRule(self, listener:ParseTreeListener, r:RuleNode):
+        ctx = r.getRuleContext()
+        ctx.exitRule(listener)
+        listener.exitEveryRule(ctx)
+
+ParseTreeWalker.DEFAULT = ParseTreeWalker()
\ No newline at end of file
diff --git a/runtime/Python3/src/antlr4/tree/Trees.py b/runtime/Python3/src/antlr4/tree/Trees.py
new file mode 100644
index 000000000..101df6d9a
--- /dev/null
+++ b/runtime/Python3/src/antlr4/tree/Trees.py
@@ -0,0 +1,137 @@
+#
+# [The "BSD license"]
+#  Copyright (c) 2012 Terence Parr
+#  Copyright (c) 2012 Sam Harwell
+#  Copyright (c) 2014 Eric Vergnaud
+#  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 set of utility routines useful for all kinds of ANTLR trees.#
+from io import StringIO
+from antlr4.Token import Token
+from antlr4.Utils import escapeWhitespace
+from antlr4.tree.Tree import RuleNode, ErrorNode, TerminalNode, Tree, ParseTree
+
+# need forward declaration
+Parser  = None
+
+class Trees(object):
+
+     # Print out a whole tree in LISP form. {@link #getNodeText} is used on the
+    #  node payloads to get the text for the nodes.  Detect
+    #  parse trees and extract data appropriately.
+    @classmethod
+    def toStringTree(cls, t:Tree, ruleNames:list=None, recog:Parser=None):
+        if recog is not None:
+            ruleNames = recog.ruleNames
+        s = escapeWhitespace(cls.getNodeText(t, ruleNames), False)
+        if t.getChildCount()==0:
+            return s
+        with StringIO() as buf:
+            buf.write("(")
+            buf.write(s)
+            buf.write(' ')
+            for i in range(0, t.getChildCount()):
+                if i > 0:
+                    buf.write(' ')
+                buf.write(cls.toStringTree(t.getChild(i), ruleNames))
+            buf.write(")")
+            return buf.getvalue()
+
+    @classmethod
+    def getNodeText(cls, t:Tree, ruleNames:list=None, recog:Parser=None):
+        if recog is not None:
+            ruleNames = recog.ruleNames
+        if ruleNames is not None:
+            if isinstance(t, RuleNode):
+                if t.getAltNumber()!=0: # should use ATN.INVALID_ALT_NUMBER but won't compile
+                    return ruleNames[t.getRuleIndex()]+":"+str(t.getAltNumber())
+                return ruleNames[t.getRuleIndex()]
+            elif isinstance( t, ErrorNode):
+                return str(t)
+            elif isinstance(t, TerminalNode):
+                if t.symbol is not None:
+                    return t.symbol.text
+        # no recog for rule names
+        payload = t.getPayload()
+        if isinstance(payload, Token ):
+            return payload.text
+        return str(t.getPayload())
+
+
+    # Return ordered list of all children of this node
+    @classmethod
+    def getChildren(cls, t:Tree):
+        return [ t.getChild(i) for i in range(0, t.getChildCount()) ]
+
+    # Return a list of all ancestors of this node.  The first node of
+    #  list is the root and the last is the parent of this node.
+    #
+    @classmethod
+    def getAncestors(cls, t:Tree):
+        ancestors = []
+        t = t.getParent()
+        while t is not None:
+            ancestors.insert(0, t) # insert at start
+            t = t.getParent()
+        return ancestors
+
+    @classmethod
+    def findAllTokenNodes(cls, t:ParseTree, ttype:int):
+        return cls.findAllNodes(t, ttype, True)
+
+    @classmethod
+    def findAllRuleNodes(cls, t:ParseTree, ruleIndex:int):
+        return cls.findAllNodes(t, ruleIndex, False)
+
+    @classmethod
+    def findAllNodes(cls, t:ParseTree, index:int, findTokens:bool):
+        nodes = []
+        cls._findAllNodes(t, index, findTokens, nodes)
+        return nodes
+
+    @classmethod
+    def _findAllNodes(cls, t:ParseTree, index:int, findTokens:bool, nodes:list):
+        from antlr4.ParserRuleContext import ParserRuleContext
+        # check this node (the root) first
+        if findTokens and isinstance(t, TerminalNode):
+            if t.symbol.type==index:
+                nodes.append(t)
+        elif not findTokens and isinstance(t, ParserRuleContext):
+            if t.ruleIndex == index:
+                nodes.append(t)
+        # check children
+        for i in range(0, t.getChildCount()):
+            cls._findAllNodes(t.getChild(i), index, findTokens, nodes)
+
+    @classmethod
+    def descendants(cls, t:ParseTree):
+        nodes = []
+        nodes.append(t)
+        for i in range(0, t.getChildCount()):
+            nodes.extend(cls.descendants(t.getChild(i)))
+        return nodes
diff --git a/runtime/Python3/src/antlr4/tree/__init__.py b/runtime/Python3/src/antlr4/tree/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/runtime/Python3/src/antlr4/xpath/XPath.py b/runtime/Python3/src/antlr4/xpath/XPath.py
new file mode 100644
index 000000000..6b41a943a
--- /dev/null
+++ b/runtime/Python3/src/antlr4/xpath/XPath.py
@@ -0,0 +1,347 @@
+
+#
+# Represent a subset of XPath XML path syntax for use in identifying nodes in
+# parse trees.
+#
+# <p>
+# Split path into words and separators {@code /} and {@code //} via ANTLR
+# itself then walk path elements from left to right. At each separator-word
+# pair, find set of nodes. Next stage uses those as work list.</p>
+#
+# <p>
+# The basic interface is
+# {@link XPath#findAll ParseTree.findAll}{@code (tree, pathString, parser)}.
+# But that is just shorthand for:</p>
+#
+# <pre>
+# {@link XPath} p = new {@link XPath#XPath XPath}(parser, pathString);
+# return p.{@link #evaluate evaluate}(tree);
+# </pre>
+#
+# <p>
+# See {@code org.antlr.v4.test.TestXPath} for descriptions. In short, this
+# allows operators:</p>
+#
+# <dl>
+# <dt>/</dt> <dd>root</dd>
+# <dt>//</dt> <dd>anywhere</dd>
+# <dt>!</dt> <dd>invert; this must appear directly after root or anywhere
+# operator</dd>
+# </dl>
+#
+# <p>
+# and path elements:</p>
+#
+# <dl>
+# <dt>ID</dt> <dd>token name</dd>
+# <dt>'string'</dt> <dd>any string literal token from the grammar</dd>
+# <dt>expr</dt> <dd>rule name</dd>
+# <dt>*</dt> <dd>wildcard matching any node</dd>
+# </dl>
+#
+# <p>
+# Whitespace is not allowed.</p>
+#
+from xmlrpc.client import boolean
+from antlr4 import CommonTokenStream, DFA, PredictionContextCache, Lexer, LexerATNSimulator, ParserRuleContext, TerminalNode
+from antlr4.InputStream import InputStream
+from antlr4.Parser import Parser
+from antlr4.RuleContext import RuleContext
+from antlr4.Token import Token
+from antlr4.error.ErrorListener import ErrorListener
+from antlr4.error.Errors import LexerNoViableAltException
+from antlr4.tree.Tree import ParseTree
+from antlr4.tree.Trees import Trees
+from antlr4.atn.ATNDeserializer import ATNDeserializer
+
+from io import StringIO
+
+def serializedATN():
+    with StringIO() as buf:
+        buf.write("\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\2\n")
+        buf.write("\64\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")
+        buf.write("\7\4\b\t\b\4\t\t\t\3\2\3\2\3\2\3\3\3\3\3\4\3\4\3\5\3\5")
+        buf.write("\3\6\3\6\7\6\37\n\6\f\6\16\6\"\13\6\3\6\3\6\3\7\3\7\5")
+        buf.write("\7(\n\7\3\b\3\b\3\t\3\t\7\t.\n\t\f\t\16\t\61\13\t\3\t")
+        buf.write("\3\t\3/\2\n\3\5\5\6\7\7\t\b\13\t\r\2\17\2\21\n\3\2\4\7")
+        buf.write("\2\62;aa\u00b9\u00b9\u0302\u0371\u2041\u2042\17\2C\\c")
+        buf.write("|\u00c2\u00d8\u00da\u00f8\u00fa\u0301\u0372\u037f\u0381")
+        buf.write("\u2001\u200e\u200f\u2072\u2191\u2c02\u2ff1\u3003\ud801")
+        buf.write("\uf902\ufdd1\ufdf2\uffff\64\2\3\3\2\2\2\2\5\3\2\2\2\2")
+        buf.write("\7\3\2\2\2\2\t\3\2\2\2\2\13\3\2\2\2\2\21\3\2\2\2\3\23")
+        buf.write("\3\2\2\2\5\26\3\2\2\2\7\30\3\2\2\2\t\32\3\2\2\2\13\34")
+        buf.write("\3\2\2\2\r\'\3\2\2\2\17)\3\2\2\2\21+\3\2\2\2\23\24\7\61")
+        buf.write("\2\2\24\25\7\61\2\2\25\4\3\2\2\2\26\27\7\61\2\2\27\6\3")
+        buf.write("\2\2\2\30\31\7,\2\2\31\b\3\2\2\2\32\33\7#\2\2\33\n\3\2")
+        buf.write("\2\2\34 \5\17\b\2\35\37\5\r\7\2\36\35\3\2\2\2\37\"\3\2")
+        buf.write("\2\2 \36\3\2\2\2 !\3\2\2\2!#\3\2\2\2\" \3\2\2\2#$\b\6")
+        buf.write("\2\2$\f\3\2\2\2%(\5\17\b\2&(\t\2\2\2\'%\3\2\2\2\'&\3\2")
+        buf.write("\2\2(\16\3\2\2\2)*\t\3\2\2*\20\3\2\2\2+/\7)\2\2,.\13\2")
+        buf.write("\2\2-,\3\2\2\2.\61\3\2\2\2/\60\3\2\2\2/-\3\2\2\2\60\62")
+        buf.write("\3\2\2\2\61/\3\2\2\2\62\63\7)\2\2\63\22\3\2\2\2\6\2 \'")
+        buf.write("/\3\3\6\2")
+        return buf.getvalue()
+
+
+class XPathLexer(Lexer):
+
+    atn = ATNDeserializer().deserialize(serializedATN())
+
+    decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
+
+
+    TOKEN_REF = 1
+    RULE_REF = 2
+    ANYWHERE = 3
+    ROOT = 4
+    WILDCARD = 5
+    BANG = 6
+    ID = 7
+    STRING = 8
+
+    modeNames = [ "DEFAULT_MODE" ]
+
+    literalNames = [ "<INVALID>",
+            "'//'", "'/'", "'*'", "'!'" ]
+
+    symbolicNames = [ "<INVALID>",
+            "TOKEN_REF", "RULE_REF", "ANYWHERE", "ROOT", "WILDCARD", "BANG",
+            "ID", "STRING" ]
+
+    ruleNames = [ "ANYWHERE", "ROOT", "WILDCARD", "BANG", "ID", "NameChar",
+                  "NameStartChar", "STRING" ]
+
+    grammarFileName = "XPathLexer.g4"
+
+    def __init__(self, input=None):
+        super().__init__(input)
+        self.checkVersion("4.5")
+        self._interp = LexerATNSimulator(self, self.atn, self.decisionsToDFA, PredictionContextCache())
+        self._actions = None
+        self._predicates = None
+
+
+    def action(self, localctx:RuleContext, ruleIndex:int, actionIndex:int):
+        if self._actions is None:
+            actions = dict()
+            actions[4] = self.ID_action
+            self._actions = actions
+        _action = self._actions.get(ruleIndex, None)
+        if _action is not None:
+            _action(localctx, actionIndex)
+        else:
+            raise Exception("No registered action for:" + str(ruleIndex))
+
+    def ID_action(self, localctx:RuleContext , actionIndex:int):
+        if actionIndex == 0:
+            char = self.text[0]
+            if char.isupper():
+                self.type = XPathLexer.TOKEN_REF
+            else:
+                self.type = XPathLexer.RULE_REF
+
+class XPath(object):
+
+    WILDCARD = "*" # word not operator/separator
+    NOT = "!" # word for invert operator
+
+    def __init__(self, parser:Parser, path:str):
+        self.parser = parser
+        self.path = path
+        self.elements = self.split(path)
+
+    def split(self, path:str):
+        input = InputStream(path)
+        lexer = XPathLexer(input)
+        def recover(self, e):
+            raise e
+        lexer.recover = recover
+        lexer.removeErrorListeners()
+        lexer.addErrorListener(ErrorListener()) # XPathErrorListener does no more
+        tokenStream = CommonTokenStream(lexer)
+        try:
+            tokenStream.fill()
+        except LexerNoViableAltException as e:
+            pos = lexer.getColumn()
+            msg = "Invalid tokens or characters at index " + str(pos) + " in path '" + path + "'"
+            raise Exception(msg, e)
+
+        tokens = tokenStream.getTokens()
+        elements = list()
+        n = len(tokens)
+        i=0
+        while i < n :
+            el = tokens[i]
+            next = None
+            if el.type in [XPathLexer.ROOT, XPathLexer.ANYWHERE]:
+                    anywhere = el.type == XPathLexer.ANYWHERE
+                    i += 1
+                    next = tokens[i]
+                    invert = next.type==XPathLexer.BANG
+                    if invert:
+                        i += 1
+                        next = tokens[i]
+                    pathElement = self.getXPathElement(next, anywhere)
+                    pathElement.invert = invert
+                    elements.append(pathElement)
+                    i += 1
+
+            elif el.type in [XPathLexer.TOKEN_REF, XPathLexer.RULE_REF, XPathLexer.WILDCARD] :
+                    elements.append( self.getXPathElement(el, False) )
+                    i += 1
+
+            elif el.type==Token.EOF :
+                    break
+
+            else:
+                    raise Exception("Unknown path element " + str(el))
+
+        return elements
+
+    #
+    # Convert word like {@code#} or {@code ID} or {@code expr} to a path
+    # element. {@code anywhere} is {@code true} if {@code //} precedes the
+    # word.
+    #
+    def getXPathElement(self, wordToken:Token, anywhere:bool):
+        if wordToken.type==Token.EOF:
+            raise Exception("Missing path element at end of path")
+        word = wordToken.text
+        ttype = self.parser.getTokenType(word)
+        ruleIndex = self.parser.getRuleIndex(word)
+
+        if wordToken.type==XPathLexer.WILDCARD :
+
+            return XPathWildcardAnywhereElement() if anywhere else XPathWildcardElement()
+
+        elif wordToken.type in [XPathLexer.TOKEN_REF, XPathLexer.STRING]:
+
+            if ttype==Token.INVALID_TYPE:
+                raise Exception( word + " at index " + str(wordToken.startIndex) + " isn't a valid token name")
+            return XPathTokenAnywhereElement(word, ttype) if anywhere else XPathTokenElement(word, ttype)
+
+        else:
+
+            if ruleIndex==-1:
+                raise Exception( word + " at index " + str(wordToken.getStartIndex()) + " isn't a valid rule name")
+            return XPathRuleAnywhereElement(word, ruleIndex) if anywhere else XPathRuleElement(word, ruleIndex)
+
+
+    @staticmethod
+    def findAll(tree:ParseTree, xpath:str, parser:Parser):
+        p = XPath(parser, xpath)
+        return p.evaluate(tree)
+
+    #
+    # Return a list of all nodes starting at {@code t} as root that satisfy the
+    # path. The root {@code /} is relative to the node passed to
+    # {@link #evaluate}.
+    #
+    def evaluate(self, t:ParseTree):
+        dummyRoot = ParserRuleContext()
+        dummyRoot.children = [t] # don't set t's parent.
+
+        work = [dummyRoot]
+
+        for i in range(0, len(self.elements)):
+            next = set()
+            for node in work:
+                if len( node.children) > 0 :
+                    # only try to match next element if it has children
+                    # e.g., //func/*/stat might have a token node for which
+                    # we can't go looking for stat nodes.
+                    matching = self.elements[i].evaluate(node)
+                    next |= matching
+            i += 1
+            work = next
+
+        return work
+
+
+class XPathElement(object):
+
+    def __init__(self, nodeName:str):
+        self.nodeName = nodeName
+        self.invert = False
+
+    def __str__(self):
+        return type(self).__name__ + "[" + ("!" if self.invert else "") + self.nodeName + "]"
+
+
+
+#
+# Either {@code ID} at start of path or {@code ...//ID} in middle of path.
+#
+class XPathRuleAnywhereElement(XPathElement):
+
+    def __init__(self, ruleName:str, ruleIndex:int):
+        super().__init__(ruleName)
+        self.ruleIndex = ruleIndex
+
+    def evaluate(self, t:ParseTree):
+        return Trees.findAllRuleNodes(t, self.ruleIndex)
+
+
+class XPathRuleElement(XPathElement):
+
+    def __init__(self, ruleName:str, ruleIndex:int):
+        super().__init__(ruleName)
+        self.ruleIndex = ruleIndex
+
+    def evaluate(self, t:ParseTree):
+        # return all children of t that match nodeName
+        nodes = []
+        for c in Trees.getChildren(t):
+            if isinstance(c, ParserRuleContext ):
+                if (c.ruleIndex == self.ruleIndex ) == (not self.invert):
+                    nodes.append(c)
+        return nodes
+
+class XPathTokenAnywhereElement(XPathElement):
+
+    def __init__(self, ruleName:str, tokenType:int):
+        super().__init__(ruleName)
+        self.tokenType = tokenType
+
+    def evaluate(self, t:ParseTree):
+        return Trees.findAllTokenNodes(t, self.tokenType)
+
+
+class XPathTokenElement(XPathElement):
+
+    def __init__(self, ruleName:str, tokenType:int):
+        super().__init__(ruleName)
+        self.tokenType = tokenType
+
+    def evaluate(self, t:ParseTree):
+        # return all children of t that match nodeName
+        nodes = []
+        for c in Trees.getChildren(t):
+            if isinstance(c, TerminalNode):
+                if (c.symbol.type == self.tokenType ) == (not self.invert):
+                    nodes.append(c)
+        return nodes
+
+class XPathWildcardAnywhereElement(XPathElement):
+
+    def __init__(self):
+        super().__init__(XPath.WILDCARD)
+
+    def evaluate(self, t:ParseTree):
+        if self.invert:
+            return list() # !* is weird but valid (empty)
+        else:
+            return Trees.descendants(t)
+
+
+class XPathWildcardElement(XPathElement):
+
+    def __init__(self):
+        super().__init__(XPath.WILDCARD)
+
+
+    def evaluate(self, t:ParseTree):
+        if self.invert:
+            return list() # !* is weird but valid (empty)
+        else:
+            return Trees.getChildren(t)
\ No newline at end of file
diff --git a/runtime/Python3/src/antlr4/xpath/__init__.py b/runtime/Python3/src/antlr4/xpath/__init__.py
new file mode 100644
index 000000000..216c000dc
--- /dev/null
+++ b/runtime/Python3/src/antlr4/xpath/__init__.py
@@ -0,0 +1 @@
+__author__ = 'ericvergnaud'
diff --git a/runtime/Python3/test/__init__.py b/runtime/Python3/test/__init__.py
new file mode 100644
index 000000000..216c000dc
--- /dev/null
+++ b/runtime/Python3/test/__init__.py
@@ -0,0 +1 @@
+__author__ = 'ericvergnaud'
diff --git a/runtime/Python3/test/c.c b/runtime/Python3/test/c.c
new file mode 100644
index 000000000..f4ada7a8d
--- /dev/null
+++ b/runtime/Python3/test/c.c
@@ -0,0 +1,777 @@
+void main()
+{
+    int a=0;
+    if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        a++;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        a++;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        a++;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        a++;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        a++;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        a++;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        a++;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        a++;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+    else if( 3 > 4){
+        ;
+    }
+}
\ No newline at end of file
diff --git a/runtime/Python3/test/ctest.py b/runtime/Python3/test/ctest.py
new file mode 100644
index 000000000..19301a0e2
--- /dev/null
+++ b/runtime/Python3/test/ctest.py
@@ -0,0 +1,44 @@
+import sys
+sys.setrecursionlimit(4000)
+import antlr4
+from parser.cparser import CParser
+from parser.clexer import CLexer
+from datetime import datetime
+import cProfile
+
+class ErrorListener(antlr4.error.ErrorListener.ErrorListener):
+
+    def __init__(self):
+        super(ErrorListener, self).__init__()
+        self.errored_out = False
+
+    def syntaxError(self, recognizer, offendingSymbol, line, column, msg, e):
+        self.errored_out = True
+
+
+def sub():
+    # Parse the input file
+    input_stream = antlr4.FileStream("c.c")
+
+    lexer = CLexer(input_stream)
+    token_stream = antlr4.CommonTokenStream(lexer)
+
+    parser = CParser(token_stream)
+
+
+    errors = ErrorListener()
+    parser.addErrorListener(errors)
+    tree = parser.compilationUnit()
+
+def main():
+    before = datetime.now()
+    sub()
+    after = datetime.now()
+    print(str(after-before))
+    # before = after
+    # sub()
+    # after = datetime.now()
+    # print(str(after-before))
+
+if __name__ == '__main__':
+    cProfile.run("main()", sort='tottime')
\ No newline at end of file
diff --git a/runtime/Python3/test/parser/__init__.py b/runtime/Python3/test/parser/__init__.py
new file mode 100644
index 000000000..216c000dc
--- /dev/null
+++ b/runtime/Python3/test/parser/__init__.py
@@ -0,0 +1 @@
+__author__ = 'ericvergnaud'
diff --git a/runtime/Python3/test/parser/clexer.py b/runtime/Python3/test/parser/clexer.py
new file mode 100644
index 000000000..6ba88c214
--- /dev/null
+++ b/runtime/Python3/test/parser/clexer.py
@@ -0,0 +1,799 @@
+# Generated from C.bnf by ANTLR 4.5.1
+from antlr4 import *
+from io import StringIO
+
+
+def serializedATN():
+    with StringIO() as buf:
+        buf.write("\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\2s")
+        buf.write("\u04e7\b\1\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7")
+        buf.write("\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")
+        buf.write("\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23")
+        buf.write("\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30")
+        buf.write("\4\31\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36")
+        buf.write("\t\36\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%")
+        buf.write("\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.")
+        buf.write("\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64")
+        buf.write("\t\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:")
+        buf.write("\4;\t;\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\t")
+        buf.write("C\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I\tI\4J\tJ\4K\tK\4L\t")
+        buf.write("L\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT\4U\t")
+        buf.write("U\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4")
+        buf.write("^\t^\4_\t_\4`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4")
+        buf.write("g\tg\4h\th\4i\ti\4j\tj\4k\tk\4l\tl\4m\tm\4n\tn\4o\to\4")
+        buf.write("p\tp\4q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4w\tw\4x\tx\4")
+        buf.write("y\ty\4z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080")
+        buf.write("\t\u0080\4\u0081\t\u0081\4\u0082\t\u0082\4\u0083\t\u0083")
+        buf.write("\4\u0084\t\u0084\4\u0085\t\u0085\4\u0086\t\u0086\4\u0087")
+        buf.write("\t\u0087\4\u0088\t\u0088\4\u0089\t\u0089\4\u008a\t\u008a")
+        buf.write("\4\u008b\t\u008b\4\u008c\t\u008c\4\u008d\t\u008d\4\u008e")
+        buf.write("\t\u008e\4\u008f\t\u008f\4\u0090\t\u0090\4\u0091\t\u0091")
+        buf.write("\4\u0092\t\u0092\4\u0093\t\u0093\4\u0094\t\u0094\4\u0095")
+        buf.write("\t\u0095\4\u0096\t\u0096\4\u0097\t\u0097\4\u0098\t\u0098")
+        buf.write("\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3")
+        buf.write("\2\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")
+        buf.write("\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\4\3")
+        buf.write("\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\5\3\5\3\5\3\5")
+        buf.write("\3\5\3\5\3\5\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\7\3\7\3")
+        buf.write("\7\3\7\3\7\3\7\3\7\3\7\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b")
+        buf.write("\3\b\3\b\3\b\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3")
+        buf.write("\t\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\13\3\13\3")
+        buf.write("\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\f\3\f\3")
+        buf.write("\f\3\f\3\f\3\f\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r")
+        buf.write("\3\r\3\r\3\r\3\r\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3")
+        buf.write("\16\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17")
+        buf.write("\3\17\3\17\3\17\3\20\3\20\3\20\3\20\3\20\3\21\3\21\3\21")
+        buf.write("\3\21\3\21\3\21\3\22\3\22\3\22\3\22\3\22\3\23\3\23\3\23")
+        buf.write("\3\23\3\23\3\24\3\24\3\24\3\24\3\24\3\24\3\25\3\25\3\25")
+        buf.write("\3\25\3\25\3\25\3\25\3\25\3\25\3\26\3\26\3\26\3\26\3\26")
+        buf.write("\3\26\3\26\3\26\3\27\3\27\3\27\3\30\3\30\3\30\3\30\3\30")
+        buf.write("\3\30\3\30\3\31\3\31\3\31\3\31\3\31\3\32\3\32\3\32\3\32")
+        buf.write("\3\32\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\34\3\34\3\34")
+        buf.write("\3\34\3\34\3\34\3\35\3\35\3\35\3\35\3\36\3\36\3\36\3\36")
+        buf.write("\3\36\3\37\3\37\3\37\3 \3 \3 \3 \3 \3 \3 \3!\3!\3!\3!")
+        buf.write("\3\"\3\"\3\"\3\"\3\"\3#\3#\3#\3#\3#\3#\3#\3#\3#\3$\3$")
+        buf.write("\3$\3$\3$\3$\3$\3$\3$\3%\3%\3%\3%\3%\3%\3%\3&\3&\3&\3")
+        buf.write("&\3&\3&\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3(\3(\3(\3(\3(\3(")
+        buf.write("\3(\3)\3)\3)\3)\3)\3)\3)\3*\3*\3*\3*\3*\3*\3*\3+\3+\3")
+        buf.write("+\3+\3+\3+\3+\3,\3,\3,\3,\3,\3,\3,\3,\3-\3-\3-\3-\3-\3")
+        buf.write("-\3.\3.\3.\3.\3.\3.\3.\3.\3.\3/\3/\3/\3/\3/\3\60\3\60")
+        buf.write("\3\60\3\60\3\60\3\60\3\60\3\60\3\60\3\61\3\61\3\61\3\61")
+        buf.write("\3\61\3\61\3\62\3\62\3\62\3\62\3\62\3\62\3\62\3\62\3\62")
+        buf.write("\3\63\3\63\3\63\3\63\3\63\3\63\3\63\3\63\3\63\3\64\3\64")
+        buf.write("\3\64\3\64\3\64\3\64\3\64\3\64\3\65\3\65\3\65\3\65\3\65")
+        buf.write("\3\65\3\66\3\66\3\66\3\66\3\66\3\66\3\66\3\66\3\66\3\67")
+        buf.write("\3\67\3\67\3\67\3\67\3\67\3\67\3\67\3\67\38\38\38\38\3")
+        buf.write("8\38\38\38\38\38\38\39\39\39\39\39\39\39\39\39\39\3:\3")
+        buf.write(":\3:\3:\3:\3:\3:\3:\3:\3:\3:\3:\3:\3:\3:\3;\3;\3;\3;\3")
+        buf.write(";\3;\3;\3;\3;\3;\3;\3;\3;\3;\3<\3<\3=\3=\3>\3>\3?\3?\3")
+        buf.write("@\3@\3A\3A\3B\3B\3C\3C\3C\3D\3D\3E\3E\3E\3F\3F\3F\3G\3")
+        buf.write("G\3G\3H\3H\3I\3I\3I\3J\3J\3K\3K\3K\3L\3L\3M\3M\3N\3N\3")
+        buf.write("O\3O\3P\3P\3Q\3Q\3Q\3R\3R\3R\3S\3S\3T\3T\3U\3U\3V\3V\3")
+        buf.write("W\3W\3X\3X\3Y\3Y\3Z\3Z\3[\3[\3[\3\\\3\\\3\\\3]\3]\3]\3")
+        buf.write("^\3^\3^\3_\3_\3_\3`\3`\3`\3`\3a\3a\3a\3a\3b\3b\3b\3c\3")
+        buf.write("c\3c\3d\3d\3d\3e\3e\3e\3f\3f\3f\3g\3g\3g\3h\3h\3i\3i\3")
+        buf.write("i\3i\3j\3j\3j\7j\u0381\nj\fj\16j\u0384\13j\3k\3k\5k\u0388")
+        buf.write("\nk\3l\3l\3m\3m\3n\3n\3n\3n\3n\3n\3n\3n\3n\3n\5n\u0398")
+        buf.write("\nn\3o\3o\3o\3o\3o\3p\3p\3p\5p\u03a2\np\3q\3q\5q\u03a6")
+        buf.write("\nq\3q\3q\5q\u03aa\nq\3q\3q\5q\u03ae\nq\5q\u03b0\nq\3")
+        buf.write("r\3r\7r\u03b4\nr\fr\16r\u03b7\13r\3s\3s\7s\u03bb\ns\f")
+        buf.write("s\16s\u03be\13s\3t\3t\6t\u03c2\nt\rt\16t\u03c3\3u\3u\3")
+        buf.write("u\3v\3v\3w\3w\3x\3x\3y\3y\5y\u03d1\ny\3y\3y\3y\3y\3y\5")
+        buf.write("y\u03d8\ny\3y\3y\5y\u03dc\ny\5y\u03de\ny\3z\3z\3{\3{\3")
+        buf.write("|\3|\3|\3|\5|\u03e8\n|\3}\3}\5}\u03ec\n}\3~\3~\5~\u03f0")
+        buf.write("\n~\3~\5~\u03f3\n~\3~\3~\3~\5~\u03f8\n~\5~\u03fa\n~\3")
+        buf.write("\177\3\177\3\177\3\177\5\177\u0400\n\177\3\177\3\177\3")
+        buf.write("\177\3\177\5\177\u0406\n\177\5\177\u0408\n\177\3\u0080")
+        buf.write("\5\u0080\u040b\n\u0080\3\u0080\3\u0080\3\u0080\3\u0080")
+        buf.write("\3\u0080\5\u0080\u0412\n\u0080\3\u0081\3\u0081\5\u0081")
+        buf.write("\u0416\n\u0081\3\u0081\3\u0081\3\u0081\5\u0081\u041b\n")
+        buf.write("\u0081\3\u0081\5\u0081\u041e\n\u0081\3\u0082\3\u0082\3")
+        buf.write("\u0083\6\u0083\u0423\n\u0083\r\u0083\16\u0083\u0424\3")
+        buf.write("\u0084\5\u0084\u0428\n\u0084\3\u0084\3\u0084\3\u0084\3")
+        buf.write("\u0084\3\u0084\5\u0084\u042f\n\u0084\3\u0085\3\u0085\5")
+        buf.write("\u0085\u0433\n\u0085\3\u0085\3\u0085\3\u0085\5\u0085\u0438")
+        buf.write("\n\u0085\3\u0085\5\u0085\u043b\n\u0085\3\u0086\6\u0086")
+        buf.write("\u043e\n\u0086\r\u0086\16\u0086\u043f\3\u0087\3\u0087")
+        buf.write("\3\u0088\3\u0088\3\u0088\3\u0088\3\u0088\3\u0088\3\u0088")
+        buf.write("\3\u0088\3\u0088\3\u0088\3\u0088\3\u0088\3\u0088\3\u0088")
+        buf.write("\3\u0088\3\u0088\3\u0088\3\u0088\3\u0088\3\u0088\3\u0088")
+        buf.write("\3\u0088\5\u0088\u045a\n\u0088\3\u0089\6\u0089\u045d\n")
+        buf.write("\u0089\r\u0089\16\u0089\u045e\3\u008a\3\u008a\5\u008a")
+        buf.write("\u0463\n\u008a\3\u008b\3\u008b\3\u008b\3\u008b\5\u008b")
+        buf.write("\u0469\n\u008b\3\u008c\3\u008c\3\u008c\3\u008d\3\u008d")
+        buf.write("\3\u008d\3\u008d\3\u008d\3\u008d\3\u008d\3\u008d\3\u008d")
+        buf.write("\3\u008d\3\u008d\5\u008d\u0479\n\u008d\3\u008e\3\u008e")
+        buf.write("\3\u008e\3\u008e\6\u008e\u047f\n\u008e\r\u008e\16\u008e")
+        buf.write("\u0480\3\u008f\5\u008f\u0484\n\u008f\3\u008f\3\u008f\5")
+        buf.write("\u008f\u0488\n\u008f\3\u008f\3\u008f\3\u0090\3\u0090\3")
+        buf.write("\u0090\5\u0090\u048f\n\u0090\3\u0091\6\u0091\u0492\n\u0091")
+        buf.write("\r\u0091\16\u0091\u0493\3\u0092\3\u0092\5\u0092\u0498")
+        buf.write("\n\u0092\3\u0093\3\u0093\5\u0093\u049c\n\u0093\3\u0093")
+        buf.write("\3\u0093\5\u0093\u04a0\n\u0093\3\u0093\3\u0093\7\u0093")
+        buf.write("\u04a4\n\u0093\f\u0093\16\u0093\u04a7\13\u0093\3\u0093")
+        buf.write("\3\u0093\3\u0094\3\u0094\5\u0094\u04ad\n\u0094\3\u0094")
+        buf.write("\3\u0094\3\u0094\3\u0094\3\u0094\3\u0094\3\u0094\3\u0094")
+        buf.write("\3\u0094\7\u0094\u04b8\n\u0094\f\u0094\16\u0094\u04bb")
+        buf.write("\13\u0094\3\u0094\3\u0094\3\u0095\6\u0095\u04c0\n\u0095")
+        buf.write("\r\u0095\16\u0095\u04c1\3\u0095\3\u0095\3\u0096\3\u0096")
+        buf.write("\5\u0096\u04c8\n\u0096\3\u0096\5\u0096\u04cb\n\u0096\3")
+        buf.write("\u0096\3\u0096\3\u0097\3\u0097\3\u0097\3\u0097\7\u0097")
+        buf.write("\u04d3\n\u0097\f\u0097\16\u0097\u04d6\13\u0097\3\u0097")
+        buf.write("\3\u0097\3\u0097\3\u0097\3\u0097\3\u0098\3\u0098\3\u0098")
+        buf.write("\3\u0098\7\u0098\u04e1\n\u0098\f\u0098\16\u0098\u04e4")
+        buf.write("\13\u0098\3\u0098\3\u0098\3\u04d4\2\u0099\3\3\5\4\7\5")
+        buf.write("\t\6\13\7\r\b\17\t\21\n\23\13\25\f\27\r\31\16\33\17\35")
+        buf.write("\20\37\21!\22#\23%\24\'\25)\26+\27-\30/\31\61\32\63\33")
+        buf.write("\65\34\67\359\36;\37= ?!A\"C#E$G%I&K\'M(O)Q*S+U,W-Y.[")
+        buf.write("/]\60_\61a\62c\63e\64g\65i\66k\67m8o9q:s;u<w=y>{?}@\177")
+        buf.write("A\u0081B\u0083C\u0085D\u0087E\u0089F\u008bG\u008dH\u008f")
+        buf.write("I\u0091J\u0093K\u0095L\u0097M\u0099N\u009bO\u009dP\u009f")
+        buf.write("Q\u00a1R\u00a3S\u00a5T\u00a7U\u00a9V\u00abW\u00adX\u00af")
+        buf.write("Y\u00b1Z\u00b3[\u00b5\\\u00b7]\u00b9^\u00bb_\u00bd`\u00bf")
+        buf.write("a\u00c1b\u00c3c\u00c5d\u00c7e\u00c9f\u00cbg\u00cdh\u00cf")
+        buf.write("i\u00d1j\u00d3k\u00d5\2\u00d7\2\u00d9\2\u00db\2\u00dd")
+        buf.write("\2\u00dfl\u00e1\2\u00e3\2\u00e5\2\u00e7\2\u00e9\2\u00eb")
+        buf.write("\2\u00ed\2\u00ef\2\u00f1\2\u00f3\2\u00f5\2\u00f7\2\u00f9")
+        buf.write("\2\u00fb\2\u00fd\2\u00ff\2\u0101\2\u0103\2\u0105\2\u0107")
+        buf.write("\2\u0109\2\u010b\2\u010d\2\u010f\2\u0111\2\u0113\2\u0115")
+        buf.write("\2\u0117\2\u0119\2\u011b\2\u011dm\u011f\2\u0121\2\u0123")
+        buf.write("\2\u0125n\u0127o\u0129p\u012bq\u012dr\u012fs\3\2\22\5")
+        buf.write("\2C\\aac|\3\2\62;\4\2ZZzz\3\2\63;\3\2\629\5\2\62;CHch")
+        buf.write("\4\2WWww\4\2NNnn\4\2--//\6\2HHNNhhnn\6\2\f\f\17\17))^")
+        buf.write("^\f\2$$))AA^^cdhhppttvvxx\5\2NNWWww\6\2\f\f\17\17$$^^")
+        buf.write("\4\2\f\f\17\17\4\2\13\13\"\"\u0503\2\3\3\2\2\2\2\5\3\2")
+        buf.write("\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")
+        buf.write("\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")
+        buf.write("\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")
+        buf.write("\3\2\2\2\2!\3\2\2\2\2#\3\2\2\2\2%\3\2\2\2\2\'\3\2\2\2")
+        buf.write("\2)\3\2\2\2\2+\3\2\2\2\2-\3\2\2\2\2/\3\2\2\2\2\61\3\2")
+        buf.write("\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")
+        buf.write("\2;\3\2\2\2\2=\3\2\2\2\2?\3\2\2\2\2A\3\2\2\2\2C\3\2\2")
+        buf.write("\2\2E\3\2\2\2\2G\3\2\2\2\2I\3\2\2\2\2K\3\2\2\2\2M\3\2")
+        buf.write("\2\2\2O\3\2\2\2\2Q\3\2\2\2\2S\3\2\2\2\2U\3\2\2\2\2W\3")
+        buf.write("\2\2\2\2Y\3\2\2\2\2[\3\2\2\2\2]\3\2\2\2\2_\3\2\2\2\2a")
+        buf.write("\3\2\2\2\2c\3\2\2\2\2e\3\2\2\2\2g\3\2\2\2\2i\3\2\2\2\2")
+        buf.write("k\3\2\2\2\2m\3\2\2\2\2o\3\2\2\2\2q\3\2\2\2\2s\3\2\2\2")
+        buf.write("\2u\3\2\2\2\2w\3\2\2\2\2y\3\2\2\2\2{\3\2\2\2\2}\3\2\2")
+        buf.write("\2\2\177\3\2\2\2\2\u0081\3\2\2\2\2\u0083\3\2\2\2\2\u0085")
+        buf.write("\3\2\2\2\2\u0087\3\2\2\2\2\u0089\3\2\2\2\2\u008b\3\2\2")
+        buf.write("\2\2\u008d\3\2\2\2\2\u008f\3\2\2\2\2\u0091\3\2\2\2\2\u0093")
+        buf.write("\3\2\2\2\2\u0095\3\2\2\2\2\u0097\3\2\2\2\2\u0099\3\2\2")
+        buf.write("\2\2\u009b\3\2\2\2\2\u009d\3\2\2\2\2\u009f\3\2\2\2\2\u00a1")
+        buf.write("\3\2\2\2\2\u00a3\3\2\2\2\2\u00a5\3\2\2\2\2\u00a7\3\2\2")
+        buf.write("\2\2\u00a9\3\2\2\2\2\u00ab\3\2\2\2\2\u00ad\3\2\2\2\2\u00af")
+        buf.write("\3\2\2\2\2\u00b1\3\2\2\2\2\u00b3\3\2\2\2\2\u00b5\3\2\2")
+        buf.write("\2\2\u00b7\3\2\2\2\2\u00b9\3\2\2\2\2\u00bb\3\2\2\2\2\u00bd")
+        buf.write("\3\2\2\2\2\u00bf\3\2\2\2\2\u00c1\3\2\2\2\2\u00c3\3\2\2")
+        buf.write("\2\2\u00c5\3\2\2\2\2\u00c7\3\2\2\2\2\u00c9\3\2\2\2\2\u00cb")
+        buf.write("\3\2\2\2\2\u00cd\3\2\2\2\2\u00cf\3\2\2\2\2\u00d1\3\2\2")
+        buf.write("\2\2\u00d3\3\2\2\2\2\u00df\3\2\2\2\2\u011d\3\2\2\2\2\u0125")
+        buf.write("\3\2\2\2\2\u0127\3\2\2\2\2\u0129\3\2\2\2\2\u012b\3\2\2")
+        buf.write("\2\2\u012d\3\2\2\2\2\u012f\3\2\2\2\3\u0131\3\2\2\2\5\u013f")
+        buf.write("\3\2\2\2\7\u0150\3\2\2\2\t\u0163\3\2\2\2\13\u016a\3\2")
+        buf.write("\2\2\r\u0172\3\2\2\2\17\u017a\3\2\2\2\21\u0185\3\2\2\2")
+        buf.write("\23\u0190\3\2\2\2\25\u019a\3\2\2\2\27\u01a5\3\2\2\2\31")
+        buf.write("\u01ab\3\2\2\2\33\u01b9\3\2\2\2\35\u01c1\3\2\2\2\37\u01ce")
+        buf.write("\3\2\2\2!\u01d3\3\2\2\2#\u01d9\3\2\2\2%\u01de\3\2\2\2")
+        buf.write("\'\u01e3\3\2\2\2)\u01e9\3\2\2\2+\u01f2\3\2\2\2-\u01fa")
+        buf.write("\3\2\2\2/\u01fd\3\2\2\2\61\u0204\3\2\2\2\63\u0209\3\2")
+        buf.write("\2\2\65\u020e\3\2\2\2\67\u0215\3\2\2\29\u021b\3\2\2\2")
+        buf.write(";\u021f\3\2\2\2=\u0224\3\2\2\2?\u0227\3\2\2\2A\u022e\3")
+        buf.write("\2\2\2C\u0232\3\2\2\2E\u0237\3\2\2\2G\u0240\3\2\2\2I\u0249")
+        buf.write("\3\2\2\2K\u0250\3\2\2\2M\u0256\3\2\2\2O\u025d\3\2\2\2")
+        buf.write("Q\u0264\3\2\2\2S\u026b\3\2\2\2U\u0272\3\2\2\2W\u0279\3")
+        buf.write("\2\2\2Y\u0281\3\2\2\2[\u0287\3\2\2\2]\u0290\3\2\2\2_\u0295")
+        buf.write("\3\2\2\2a\u029e\3\2\2\2c\u02a4\3\2\2\2e\u02ad\3\2\2\2")
+        buf.write("g\u02b6\3\2\2\2i\u02be\3\2\2\2k\u02c4\3\2\2\2m\u02cd\3")
+        buf.write("\2\2\2o\u02d6\3\2\2\2q\u02e1\3\2\2\2s\u02eb\3\2\2\2u\u02fa")
+        buf.write("\3\2\2\2w\u0308\3\2\2\2y\u030a\3\2\2\2{\u030c\3\2\2\2")
+        buf.write("}\u030e\3\2\2\2\177\u0310\3\2\2\2\u0081\u0312\3\2\2\2")
+        buf.write("\u0083\u0314\3\2\2\2\u0085\u0316\3\2\2\2\u0087\u0319\3")
+        buf.write("\2\2\2\u0089\u031b\3\2\2\2\u008b\u031e\3\2\2\2\u008d\u0321")
+        buf.write("\3\2\2\2\u008f\u0324\3\2\2\2\u0091\u0326\3\2\2\2\u0093")
+        buf.write("\u0329\3\2\2\2\u0095\u032b\3\2\2\2\u0097\u032e\3\2\2\2")
+        buf.write("\u0099\u0330\3\2\2\2\u009b\u0332\3\2\2\2\u009d\u0334\3")
+        buf.write("\2\2\2\u009f\u0336\3\2\2\2\u00a1\u0338\3\2\2\2\u00a3\u033b")
+        buf.write("\3\2\2\2\u00a5\u033e\3\2\2\2\u00a7\u0340\3\2\2\2\u00a9")
+        buf.write("\u0342\3\2\2\2\u00ab\u0344\3\2\2\2\u00ad\u0346\3\2\2\2")
+        buf.write("\u00af\u0348\3\2\2\2\u00b1\u034a\3\2\2\2\u00b3\u034c\3")
+        buf.write("\2\2\2\u00b5\u034e\3\2\2\2\u00b7\u0351\3\2\2\2\u00b9\u0354")
+        buf.write("\3\2\2\2\u00bb\u0357\3\2\2\2\u00bd\u035a\3\2\2\2\u00bf")
+        buf.write("\u035d\3\2\2\2\u00c1\u0361\3\2\2\2\u00c3\u0365\3\2\2\2")
+        buf.write("\u00c5\u0368\3\2\2\2\u00c7\u036b\3\2\2\2\u00c9\u036e\3")
+        buf.write("\2\2\2\u00cb\u0371\3\2\2\2\u00cd\u0374\3\2\2\2\u00cf\u0377")
+        buf.write("\3\2\2\2\u00d1\u0379\3\2\2\2\u00d3\u037d\3\2\2\2\u00d5")
+        buf.write("\u0387\3\2\2\2\u00d7\u0389\3\2\2\2\u00d9\u038b\3\2\2\2")
+        buf.write("\u00db\u0397\3\2\2\2\u00dd\u0399\3\2\2\2\u00df\u03a1\3")
+        buf.write("\2\2\2\u00e1\u03af\3\2\2\2\u00e3\u03b1\3\2\2\2\u00e5\u03b8")
+        buf.write("\3\2\2\2\u00e7\u03bf\3\2\2\2\u00e9\u03c5\3\2\2\2\u00eb")
+        buf.write("\u03c8\3\2\2\2\u00ed\u03ca\3\2\2\2\u00ef\u03cc\3\2\2\2")
+        buf.write("\u00f1\u03dd\3\2\2\2\u00f3\u03df\3\2\2\2\u00f5\u03e1\3")
+        buf.write("\2\2\2\u00f7\u03e7\3\2\2\2\u00f9\u03eb\3\2\2\2\u00fb\u03f9")
+        buf.write("\3\2\2\2\u00fd\u0407\3\2\2\2\u00ff\u0411\3\2\2\2\u0101")
+        buf.write("\u041d\3\2\2\2\u0103\u041f\3\2\2\2\u0105\u0422\3\2\2\2")
+        buf.write("\u0107\u042e\3\2\2\2\u0109\u043a\3\2\2\2\u010b\u043d\3")
+        buf.write("\2\2\2\u010d\u0441\3\2\2\2\u010f\u0459\3\2\2\2\u0111\u045c")
+        buf.write("\3\2\2\2\u0113\u0462\3\2\2\2\u0115\u0468\3\2\2\2\u0117")
+        buf.write("\u046a\3\2\2\2\u0119\u0478\3\2\2\2\u011b\u047a\3\2\2\2")
+        buf.write("\u011d\u0483\3\2\2\2\u011f\u048e\3\2\2\2\u0121\u0491\3")
+        buf.write("\2\2\2\u0123\u0497\3\2\2\2\u0125\u0499\3\2\2\2\u0127\u04aa")
+        buf.write("\3\2\2\2\u0129\u04bf\3\2\2\2\u012b\u04ca\3\2\2\2\u012d")
+        buf.write("\u04ce\3\2\2\2\u012f\u04dc\3\2\2\2\u0131\u0132\7a\2\2")
+        buf.write("\u0132\u0133\7a\2\2\u0133\u0134\7g\2\2\u0134\u0135\7z")
+        buf.write("\2\2\u0135\u0136\7v\2\2\u0136\u0137\7g\2\2\u0137\u0138")
+        buf.write("\7p\2\2\u0138\u0139\7u\2\2\u0139\u013a\7k\2\2\u013a\u013b")
+        buf.write("\7q\2\2\u013b\u013c\7p\2\2\u013c\u013d\7a\2\2\u013d\u013e")
+        buf.write("\7a\2\2\u013e\4\3\2\2\2\u013f\u0140\7a\2\2\u0140\u0141")
+        buf.write("\7a\2\2\u0141\u0142\7d\2\2\u0142\u0143\7w\2\2\u0143\u0144")
+        buf.write("\7k\2\2\u0144\u0145\7n\2\2\u0145\u0146\7v\2\2\u0146\u0147")
+        buf.write("\7k\2\2\u0147\u0148\7p\2\2\u0148\u0149\7a\2\2\u0149\u014a")
+        buf.write("\7x\2\2\u014a\u014b\7c\2\2\u014b\u014c\7a\2\2\u014c\u014d")
+        buf.write("\7c\2\2\u014d\u014e\7t\2\2\u014e\u014f\7i\2\2\u014f\6")
+        buf.write("\3\2\2\2\u0150\u0151\7a\2\2\u0151\u0152\7a\2\2\u0152\u0153")
+        buf.write("\7d\2\2\u0153\u0154\7w\2\2\u0154\u0155\7k\2\2\u0155\u0156")
+        buf.write("\7n\2\2\u0156\u0157\7v\2\2\u0157\u0158\7k\2\2\u0158\u0159")
+        buf.write("\7p\2\2\u0159\u015a\7a\2\2\u015a\u015b\7q\2\2\u015b\u015c")
+        buf.write("\7h\2\2\u015c\u015d\7h\2\2\u015d\u015e\7u\2\2\u015e\u015f")
+        buf.write("\7g\2\2\u015f\u0160\7v\2\2\u0160\u0161\7q\2\2\u0161\u0162")
+        buf.write("\7h\2\2\u0162\b\3\2\2\2\u0163\u0164\7a\2\2\u0164\u0165")
+        buf.write("\7a\2\2\u0165\u0166\7o\2\2\u0166\u0167\7\63\2\2\u0167")
+        buf.write("\u0168\7\64\2\2\u0168\u0169\7:\2\2\u0169\n\3\2\2\2\u016a")
+        buf.write("\u016b\7a\2\2\u016b\u016c\7a\2\2\u016c\u016d\7o\2\2\u016d")
+        buf.write("\u016e\7\63\2\2\u016e\u016f\7\64\2\2\u016f\u0170\7:\2")
+        buf.write("\2\u0170\u0171\7f\2\2\u0171\f\3\2\2\2\u0172\u0173\7a\2")
+        buf.write("\2\u0173\u0174\7a\2\2\u0174\u0175\7o\2\2\u0175\u0176\7")
+        buf.write("\63\2\2\u0176\u0177\7\64\2\2\u0177\u0178\7:\2\2\u0178")
+        buf.write("\u0179\7k\2\2\u0179\16\3\2\2\2\u017a\u017b\7a\2\2\u017b")
+        buf.write("\u017c\7a\2\2\u017c\u017d\7v\2\2\u017d\u017e\7{\2\2\u017e")
+        buf.write("\u017f\7r\2\2\u017f\u0180\7g\2\2\u0180\u0181\7q\2\2\u0181")
+        buf.write("\u0182\7h\2\2\u0182\u0183\7a\2\2\u0183\u0184\7a\2\2\u0184")
+        buf.write("\20\3\2\2\2\u0185\u0186\7a\2\2\u0186\u0187\7a\2\2\u0187")
+        buf.write("\u0188\7k\2\2\u0188\u0189\7p\2\2\u0189\u018a\7n\2\2\u018a")
+        buf.write("\u018b\7k\2\2\u018b\u018c\7p\2\2\u018c\u018d\7g\2\2\u018d")
+        buf.write("\u018e\7a\2\2\u018e\u018f\7a\2\2\u018f\22\3\2\2\2\u0190")
+        buf.write("\u0191\7a\2\2\u0191\u0192\7a\2\2\u0192\u0193\7u\2\2\u0193")
+        buf.write("\u0194\7v\2\2\u0194\u0195\7f\2\2\u0195\u0196\7e\2\2\u0196")
+        buf.write("\u0197\7c\2\2\u0197\u0198\7n\2\2\u0198\u0199\7n\2\2\u0199")
+        buf.write("\24\3\2\2\2\u019a\u019b\7a\2\2\u019b\u019c\7a\2\2\u019c")
+        buf.write("\u019d\7f\2\2\u019d\u019e\7g\2\2\u019e\u019f\7e\2\2\u019f")
+        buf.write("\u01a0\7n\2\2\u01a0\u01a1\7u\2\2\u01a1\u01a2\7r\2\2\u01a2")
+        buf.write("\u01a3\7g\2\2\u01a3\u01a4\7e\2\2\u01a4\26\3\2\2\2\u01a5")
+        buf.write("\u01a6\7a\2\2\u01a6\u01a7\7a\2\2\u01a7\u01a8\7c\2\2\u01a8")
+        buf.write("\u01a9\7u\2\2\u01a9\u01aa\7o\2\2\u01aa\30\3\2\2\2\u01ab")
+        buf.write("\u01ac\7a\2\2\u01ac\u01ad\7a\2\2\u01ad\u01ae\7c\2\2\u01ae")
+        buf.write("\u01af\7v\2\2\u01af\u01b0\7v\2\2\u01b0\u01b1\7t\2\2\u01b1")
+        buf.write("\u01b2\7k\2\2\u01b2\u01b3\7d\2\2\u01b3\u01b4\7w\2\2\u01b4")
+        buf.write("\u01b5\7v\2\2\u01b5\u01b6\7g\2\2\u01b6\u01b7\7a\2\2\u01b7")
+        buf.write("\u01b8\7a\2\2\u01b8\32\3\2\2\2\u01b9\u01ba\7a\2\2\u01ba")
+        buf.write("\u01bb\7a\2\2\u01bb\u01bc\7c\2\2\u01bc\u01bd\7u\2\2\u01bd")
+        buf.write("\u01be\7o\2\2\u01be\u01bf\7a\2\2\u01bf\u01c0\7a\2\2\u01c0")
+        buf.write("\34\3\2\2\2\u01c1\u01c2\7a\2\2\u01c2\u01c3\7a\2\2\u01c3")
+        buf.write("\u01c4\7x\2\2\u01c4\u01c5\7q\2\2\u01c5\u01c6\7n\2\2\u01c6")
+        buf.write("\u01c7\7c\2\2\u01c7\u01c8\7v\2\2\u01c8\u01c9\7k\2\2\u01c9")
+        buf.write("\u01ca\7n\2\2\u01ca\u01cb\7g\2\2\u01cb\u01cc\7a\2\2\u01cc")
+        buf.write("\u01cd\7a\2\2\u01cd\36\3\2\2\2\u01ce\u01cf\7c\2\2\u01cf")
+        buf.write("\u01d0\7w\2\2\u01d0\u01d1\7v\2\2\u01d1\u01d2\7q\2\2\u01d2")
+        buf.write(" \3\2\2\2\u01d3\u01d4\7d\2\2\u01d4\u01d5\7t\2\2\u01d5")
+        buf.write("\u01d6\7g\2\2\u01d6\u01d7\7c\2\2\u01d7\u01d8\7m\2\2\u01d8")
+        buf.write("\"\3\2\2\2\u01d9\u01da\7e\2\2\u01da\u01db\7c\2\2\u01db")
+        buf.write("\u01dc\7u\2\2\u01dc\u01dd\7g\2\2\u01dd$\3\2\2\2\u01de")
+        buf.write("\u01df\7e\2\2\u01df\u01e0\7j\2\2\u01e0\u01e1\7c\2\2\u01e1")
+        buf.write("\u01e2\7t\2\2\u01e2&\3\2\2\2\u01e3\u01e4\7e\2\2\u01e4")
+        buf.write("\u01e5\7q\2\2\u01e5\u01e6\7p\2\2\u01e6\u01e7\7u\2\2\u01e7")
+        buf.write("\u01e8\7v\2\2\u01e8(\3\2\2\2\u01e9\u01ea\7e\2\2\u01ea")
+        buf.write("\u01eb\7q\2\2\u01eb\u01ec\7p\2\2\u01ec\u01ed\7v\2\2\u01ed")
+        buf.write("\u01ee\7k\2\2\u01ee\u01ef\7p\2\2\u01ef\u01f0\7w\2\2\u01f0")
+        buf.write("\u01f1\7g\2\2\u01f1*\3\2\2\2\u01f2\u01f3\7f\2\2\u01f3")
+        buf.write("\u01f4\7g\2\2\u01f4\u01f5\7h\2\2\u01f5\u01f6\7c\2\2\u01f6")
+        buf.write("\u01f7\7w\2\2\u01f7\u01f8\7n\2\2\u01f8\u01f9\7v\2\2\u01f9")
+        buf.write(",\3\2\2\2\u01fa\u01fb\7f\2\2\u01fb\u01fc\7q\2\2\u01fc")
+        buf.write(".\3\2\2\2\u01fd\u01fe\7f\2\2\u01fe\u01ff\7q\2\2\u01ff")
+        buf.write("\u0200\7w\2\2\u0200\u0201\7d\2\2\u0201\u0202\7n\2\2\u0202")
+        buf.write("\u0203\7g\2\2\u0203\60\3\2\2\2\u0204\u0205\7g\2\2\u0205")
+        buf.write("\u0206\7n\2\2\u0206\u0207\7u\2\2\u0207\u0208\7g\2\2\u0208")
+        buf.write("\62\3\2\2\2\u0209\u020a\7g\2\2\u020a\u020b\7p\2\2\u020b")
+        buf.write("\u020c\7w\2\2\u020c\u020d\7o\2\2\u020d\64\3\2\2\2\u020e")
+        buf.write("\u020f\7g\2\2\u020f\u0210\7z\2\2\u0210\u0211\7v\2\2\u0211")
+        buf.write("\u0212\7g\2\2\u0212\u0213\7t\2\2\u0213\u0214\7p\2\2\u0214")
+        buf.write("\66\3\2\2\2\u0215\u0216\7h\2\2\u0216\u0217\7n\2\2\u0217")
+        buf.write("\u0218\7q\2\2\u0218\u0219\7c\2\2\u0219\u021a\7v\2\2\u021a")
+        buf.write("8\3\2\2\2\u021b\u021c\7h\2\2\u021c\u021d\7q\2\2\u021d")
+        buf.write("\u021e\7t\2\2\u021e:\3\2\2\2\u021f\u0220\7i\2\2\u0220")
+        buf.write("\u0221\7q\2\2\u0221\u0222\7v\2\2\u0222\u0223\7q\2\2\u0223")
+        buf.write("<\3\2\2\2\u0224\u0225\7k\2\2\u0225\u0226\7h\2\2\u0226")
+        buf.write(">\3\2\2\2\u0227\u0228\7k\2\2\u0228\u0229\7p\2\2\u0229")
+        buf.write("\u022a\7n\2\2\u022a\u022b\7k\2\2\u022b\u022c\7p\2\2\u022c")
+        buf.write("\u022d\7g\2\2\u022d@\3\2\2\2\u022e\u022f\7k\2\2\u022f")
+        buf.write("\u0230\7p\2\2\u0230\u0231\7v\2\2\u0231B\3\2\2\2\u0232")
+        buf.write("\u0233\7n\2\2\u0233\u0234\7q\2\2\u0234\u0235\7p\2\2\u0235")
+        buf.write("\u0236\7i\2\2\u0236D\3\2\2\2\u0237\u0238\7t\2\2\u0238")
+        buf.write("\u0239\7g\2\2\u0239\u023a\7i\2\2\u023a\u023b\7k\2\2\u023b")
+        buf.write("\u023c\7u\2\2\u023c\u023d\7v\2\2\u023d\u023e\7g\2\2\u023e")
+        buf.write("\u023f\7t\2\2\u023fF\3\2\2\2\u0240\u0241\7t\2\2\u0241")
+        buf.write("\u0242\7g\2\2\u0242\u0243\7u\2\2\u0243\u0244\7v\2\2\u0244")
+        buf.write("\u0245\7t\2\2\u0245\u0246\7k\2\2\u0246\u0247\7e\2\2\u0247")
+        buf.write("\u0248\7v\2\2\u0248H\3\2\2\2\u0249\u024a\7t\2\2\u024a")
+        buf.write("\u024b\7g\2\2\u024b\u024c\7v\2\2\u024c\u024d\7w\2\2\u024d")
+        buf.write("\u024e\7t\2\2\u024e\u024f\7p\2\2\u024fJ\3\2\2\2\u0250")
+        buf.write("\u0251\7u\2\2\u0251\u0252\7j\2\2\u0252\u0253\7q\2\2\u0253")
+        buf.write("\u0254\7t\2\2\u0254\u0255\7v\2\2\u0255L\3\2\2\2\u0256")
+        buf.write("\u0257\7u\2\2\u0257\u0258\7k\2\2\u0258\u0259\7i\2\2\u0259")
+        buf.write("\u025a\7p\2\2\u025a\u025b\7g\2\2\u025b\u025c\7f\2\2\u025c")
+        buf.write("N\3\2\2\2\u025d\u025e\7u\2\2\u025e\u025f\7k\2\2\u025f")
+        buf.write("\u0260\7|\2\2\u0260\u0261\7g\2\2\u0261\u0262\7q\2\2\u0262")
+        buf.write("\u0263\7h\2\2\u0263P\3\2\2\2\u0264\u0265\7u\2\2\u0265")
+        buf.write("\u0266\7v\2\2\u0266\u0267\7c\2\2\u0267\u0268\7v\2\2\u0268")
+        buf.write("\u0269\7k\2\2\u0269\u026a\7e\2\2\u026aR\3\2\2\2\u026b")
+        buf.write("\u026c\7u\2\2\u026c\u026d\7v\2\2\u026d\u026e\7t\2\2\u026e")
+        buf.write("\u026f\7w\2\2\u026f\u0270\7e\2\2\u0270\u0271\7v\2\2\u0271")
+        buf.write("T\3\2\2\2\u0272\u0273\7u\2\2\u0273\u0274\7y\2\2\u0274")
+        buf.write("\u0275\7k\2\2\u0275\u0276\7v\2\2\u0276\u0277\7e\2\2\u0277")
+        buf.write("\u0278\7j\2\2\u0278V\3\2\2\2\u0279\u027a\7v\2\2\u027a")
+        buf.write("\u027b\7{\2\2\u027b\u027c\7r\2\2\u027c\u027d\7g\2\2\u027d")
+        buf.write("\u027e\7f\2\2\u027e\u027f\7g\2\2\u027f\u0280\7h\2\2\u0280")
+        buf.write("X\3\2\2\2\u0281\u0282\7w\2\2\u0282\u0283\7p\2\2\u0283")
+        buf.write("\u0284\7k\2\2\u0284\u0285\7q\2\2\u0285\u0286\7p\2\2\u0286")
+        buf.write("Z\3\2\2\2\u0287\u0288\7w\2\2\u0288\u0289\7p\2\2\u0289")
+        buf.write("\u028a\7u\2\2\u028a\u028b\7k\2\2\u028b\u028c\7i\2\2\u028c")
+        buf.write("\u028d\7p\2\2\u028d\u028e\7g\2\2\u028e\u028f\7f\2\2\u028f")
+        buf.write("\\\3\2\2\2\u0290\u0291\7x\2\2\u0291\u0292\7q\2\2\u0292")
+        buf.write("\u0293\7k\2\2\u0293\u0294\7f\2\2\u0294^\3\2\2\2\u0295")
+        buf.write("\u0296\7x\2\2\u0296\u0297\7q\2\2\u0297\u0298\7n\2\2\u0298")
+        buf.write("\u0299\7c\2\2\u0299\u029a\7v\2\2\u029a\u029b\7k\2\2\u029b")
+        buf.write("\u029c\7n\2\2\u029c\u029d\7g\2\2\u029d`\3\2\2\2\u029e")
+        buf.write("\u029f\7y\2\2\u029f\u02a0\7j\2\2\u02a0\u02a1\7k\2\2\u02a1")
+        buf.write("\u02a2\7n\2\2\u02a2\u02a3\7g\2\2\u02a3b\3\2\2\2\u02a4")
+        buf.write("\u02a5\7a\2\2\u02a5\u02a6\7C\2\2\u02a6\u02a7\7n\2\2\u02a7")
+        buf.write("\u02a8\7k\2\2\u02a8\u02a9\7i\2\2\u02a9\u02aa\7p\2\2\u02aa")
+        buf.write("\u02ab\7c\2\2\u02ab\u02ac\7u\2\2\u02acd\3\2\2\2\u02ad")
+        buf.write("\u02ae\7a\2\2\u02ae\u02af\7C\2\2\u02af\u02b0\7n\2\2\u02b0")
+        buf.write("\u02b1\7k\2\2\u02b1\u02b2\7i\2\2\u02b2\u02b3\7p\2\2\u02b3")
+        buf.write("\u02b4\7q\2\2\u02b4\u02b5\7h\2\2\u02b5f\3\2\2\2\u02b6")
+        buf.write("\u02b7\7a\2\2\u02b7\u02b8\7C\2\2\u02b8\u02b9\7v\2\2\u02b9")
+        buf.write("\u02ba\7q\2\2\u02ba\u02bb\7o\2\2\u02bb\u02bc\7k\2\2\u02bc")
+        buf.write("\u02bd\7e\2\2\u02bdh\3\2\2\2\u02be\u02bf\7a\2\2\u02bf")
+        buf.write("\u02c0\7D\2\2\u02c0\u02c1\7q\2\2\u02c1\u02c2\7q\2\2\u02c2")
+        buf.write("\u02c3\7n\2\2\u02c3j\3\2\2\2\u02c4\u02c5\7a\2\2\u02c5")
+        buf.write("\u02c6\7E\2\2\u02c6\u02c7\7q\2\2\u02c7\u02c8\7o\2\2\u02c8")
+        buf.write("\u02c9\7r\2\2\u02c9\u02ca\7n\2\2\u02ca\u02cb\7g\2\2\u02cb")
+        buf.write("\u02cc\7z\2\2\u02ccl\3\2\2\2\u02cd\u02ce\7a\2\2\u02ce")
+        buf.write("\u02cf\7I\2\2\u02cf\u02d0\7g\2\2\u02d0\u02d1\7p\2\2\u02d1")
+        buf.write("\u02d2\7g\2\2\u02d2\u02d3\7t\2\2\u02d3\u02d4\7k\2\2\u02d4")
+        buf.write("\u02d5\7e\2\2\u02d5n\3\2\2\2\u02d6\u02d7\7a\2\2\u02d7")
+        buf.write("\u02d8\7K\2\2\u02d8\u02d9\7o\2\2\u02d9\u02da\7c\2\2\u02da")
+        buf.write("\u02db\7i\2\2\u02db\u02dc\7k\2\2\u02dc\u02dd\7p\2\2\u02dd")
+        buf.write("\u02de\7c\2\2\u02de\u02df\7t\2\2\u02df\u02e0\7{\2\2\u02e0")
+        buf.write("p\3\2\2\2\u02e1\u02e2\7a\2\2\u02e2\u02e3\7P\2\2\u02e3")
+        buf.write("\u02e4\7q\2\2\u02e4\u02e5\7t\2\2\u02e5\u02e6\7g\2\2\u02e6")
+        buf.write("\u02e7\7v\2\2\u02e7\u02e8\7w\2\2\u02e8\u02e9\7t\2\2\u02e9")
+        buf.write("\u02ea\7p\2\2\u02ear\3\2\2\2\u02eb\u02ec\7a\2\2\u02ec")
+        buf.write("\u02ed\7U\2\2\u02ed\u02ee\7v\2\2\u02ee\u02ef\7c\2\2\u02ef")
+        buf.write("\u02f0\7v\2\2\u02f0\u02f1\7k\2\2\u02f1\u02f2\7e\2\2\u02f2")
+        buf.write("\u02f3\7a\2\2\u02f3\u02f4\7c\2\2\u02f4\u02f5\7u\2\2\u02f5")
+        buf.write("\u02f6\7u\2\2\u02f6\u02f7\7g\2\2\u02f7\u02f8\7t\2\2\u02f8")
+        buf.write("\u02f9\7v\2\2\u02f9t\3\2\2\2\u02fa\u02fb\7a\2\2\u02fb")
+        buf.write("\u02fc\7V\2\2\u02fc\u02fd\7j\2\2\u02fd\u02fe\7t\2\2\u02fe")
+        buf.write("\u02ff\7g\2\2\u02ff\u0300\7c\2\2\u0300\u0301\7f\2\2\u0301")
+        buf.write("\u0302\7a\2\2\u0302\u0303\7n\2\2\u0303\u0304\7q\2\2\u0304")
+        buf.write("\u0305\7e\2\2\u0305\u0306\7c\2\2\u0306\u0307\7n\2\2\u0307")
+        buf.write("v\3\2\2\2\u0308\u0309\7*\2\2\u0309x\3\2\2\2\u030a\u030b")
+        buf.write("\7+\2\2\u030bz\3\2\2\2\u030c\u030d\7]\2\2\u030d|\3\2\2")
+        buf.write("\2\u030e\u030f\7_\2\2\u030f~\3\2\2\2\u0310\u0311\7}\2")
+        buf.write("\2\u0311\u0080\3\2\2\2\u0312\u0313\7\177\2\2\u0313\u0082")
+        buf.write("\3\2\2\2\u0314\u0315\7>\2\2\u0315\u0084\3\2\2\2\u0316")
+        buf.write("\u0317\7>\2\2\u0317\u0318\7?\2\2\u0318\u0086\3\2\2\2\u0319")
+        buf.write("\u031a\7@\2\2\u031a\u0088\3\2\2\2\u031b\u031c\7@\2\2\u031c")
+        buf.write("\u031d\7?\2\2\u031d\u008a\3\2\2\2\u031e\u031f\7>\2\2\u031f")
+        buf.write("\u0320\7>\2\2\u0320\u008c\3\2\2\2\u0321\u0322\7@\2\2\u0322")
+        buf.write("\u0323\7@\2\2\u0323\u008e\3\2\2\2\u0324\u0325\7-\2\2\u0325")
+        buf.write("\u0090\3\2\2\2\u0326\u0327\7-\2\2\u0327\u0328\7-\2\2\u0328")
+        buf.write("\u0092\3\2\2\2\u0329\u032a\7/\2\2\u032a\u0094\3\2\2\2")
+        buf.write("\u032b\u032c\7/\2\2\u032c\u032d\7/\2\2\u032d\u0096\3\2")
+        buf.write("\2\2\u032e\u032f\7,\2\2\u032f\u0098\3\2\2\2\u0330\u0331")
+        buf.write("\7\61\2\2\u0331\u009a\3\2\2\2\u0332\u0333\7\'\2\2\u0333")
+        buf.write("\u009c\3\2\2\2\u0334\u0335\7(\2\2\u0335\u009e\3\2\2\2")
+        buf.write("\u0336\u0337\7~\2\2\u0337\u00a0\3\2\2\2\u0338\u0339\7")
+        buf.write("(\2\2\u0339\u033a\7(\2\2\u033a\u00a2\3\2\2\2\u033b\u033c")
+        buf.write("\7~\2\2\u033c\u033d\7~\2\2\u033d\u00a4\3\2\2\2\u033e\u033f")
+        buf.write("\7`\2\2\u033f\u00a6\3\2\2\2\u0340\u0341\7#\2\2\u0341\u00a8")
+        buf.write("\3\2\2\2\u0342\u0343\7\u0080\2\2\u0343\u00aa\3\2\2\2\u0344")
+        buf.write("\u0345\7A\2\2\u0345\u00ac\3\2\2\2\u0346\u0347\7<\2\2\u0347")
+        buf.write("\u00ae\3\2\2\2\u0348\u0349\7=\2\2\u0349\u00b0\3\2\2\2")
+        buf.write("\u034a\u034b\7.\2\2\u034b\u00b2\3\2\2\2\u034c\u034d\7")
+        buf.write("?\2\2\u034d\u00b4\3\2\2\2\u034e\u034f\7,\2\2\u034f\u0350")
+        buf.write("\7?\2\2\u0350\u00b6\3\2\2\2\u0351\u0352\7\61\2\2\u0352")
+        buf.write("\u0353\7?\2\2\u0353\u00b8\3\2\2\2\u0354\u0355\7\'\2\2")
+        buf.write("\u0355\u0356\7?\2\2\u0356\u00ba\3\2\2\2\u0357\u0358\7")
+        buf.write("-\2\2\u0358\u0359\7?\2\2\u0359\u00bc\3\2\2\2\u035a\u035b")
+        buf.write("\7/\2\2\u035b\u035c\7?\2\2\u035c\u00be\3\2\2\2\u035d\u035e")
+        buf.write("\7>\2\2\u035e\u035f\7>\2\2\u035f\u0360\7?\2\2\u0360\u00c0")
+        buf.write("\3\2\2\2\u0361\u0362\7@\2\2\u0362\u0363\7@\2\2\u0363\u0364")
+        buf.write("\7?\2\2\u0364\u00c2\3\2\2\2\u0365\u0366\7(\2\2\u0366\u0367")
+        buf.write("\7?\2\2\u0367\u00c4\3\2\2\2\u0368\u0369\7`\2\2\u0369\u036a")
+        buf.write("\7?\2\2\u036a\u00c6\3\2\2\2\u036b\u036c\7~\2\2\u036c\u036d")
+        buf.write("\7?\2\2\u036d\u00c8\3\2\2\2\u036e\u036f\7?\2\2\u036f\u0370")
+        buf.write("\7?\2\2\u0370\u00ca\3\2\2\2\u0371\u0372\7#\2\2\u0372\u0373")
+        buf.write("\7?\2\2\u0373\u00cc\3\2\2\2\u0374\u0375\7/\2\2\u0375\u0376")
+        buf.write("\7@\2\2\u0376\u00ce\3\2\2\2\u0377\u0378\7\60\2\2\u0378")
+        buf.write("\u00d0\3\2\2\2\u0379\u037a\7\60\2\2\u037a\u037b\7\60\2")
+        buf.write("\2\u037b\u037c\7\60\2\2\u037c\u00d2\3\2\2\2\u037d\u0382")
+        buf.write("\5\u00d5k\2\u037e\u0381\5\u00d5k\2\u037f\u0381\5\u00d9")
+        buf.write("m\2\u0380\u037e\3\2\2\2\u0380\u037f\3\2\2\2\u0381\u0384")
+        buf.write("\3\2\2\2\u0382\u0380\3\2\2\2\u0382\u0383\3\2\2\2\u0383")
+        buf.write("\u00d4\3\2\2\2\u0384\u0382\3\2\2\2\u0385\u0388\5\u00d7")
+        buf.write("l\2\u0386\u0388\5\u00dbn\2\u0387\u0385\3\2\2\2\u0387\u0386")
+        buf.write("\3\2\2\2\u0388\u00d6\3\2\2\2\u0389\u038a\t\2\2\2\u038a")
+        buf.write("\u00d8\3\2\2\2\u038b\u038c\t\3\2\2\u038c\u00da\3\2\2\2")
+        buf.write("\u038d\u038e\7^\2\2\u038e\u038f\7w\2\2\u038f\u0390\3\2")
+        buf.write("\2\2\u0390\u0398\5\u00ddo\2\u0391\u0392\7^\2\2\u0392\u0393")
+        buf.write("\7W\2\2\u0393\u0394\3\2\2\2\u0394\u0395\5\u00ddo\2\u0395")
+        buf.write("\u0396\5\u00ddo\2\u0396\u0398\3\2\2\2\u0397\u038d\3\2")
+        buf.write("\2\2\u0397\u0391\3\2\2\2\u0398\u00dc\3\2\2\2\u0399\u039a")
+        buf.write("\5\u00efx\2\u039a\u039b\5\u00efx\2\u039b\u039c\5\u00ef")
+        buf.write("x\2\u039c\u039d\5\u00efx\2\u039d\u00de\3\2\2\2\u039e\u03a2")
+        buf.write("\5\u00e1q\2\u039f\u03a2\5\u00f9}\2\u03a0\u03a2\5\u010f")
+        buf.write("\u0088\2\u03a1\u039e\3\2\2\2\u03a1\u039f\3\2\2\2\u03a1")
+        buf.write("\u03a0\3\2\2\2\u03a2\u00e0\3\2\2\2\u03a3\u03a5\5\u00e3")
+        buf.write("r\2\u03a4\u03a6\5\u00f1y\2\u03a5\u03a4\3\2\2\2\u03a5\u03a6")
+        buf.write("\3\2\2\2\u03a6\u03b0\3\2\2\2\u03a7\u03a9\5\u00e5s\2\u03a8")
+        buf.write("\u03aa\5\u00f1y\2\u03a9\u03a8\3\2\2\2\u03a9\u03aa\3\2")
+        buf.write("\2\2\u03aa\u03b0\3\2\2\2\u03ab\u03ad\5\u00e7t\2\u03ac")
+        buf.write("\u03ae\5\u00f1y\2\u03ad\u03ac\3\2\2\2\u03ad\u03ae\3\2")
+        buf.write("\2\2\u03ae\u03b0\3\2\2\2\u03af\u03a3\3\2\2\2\u03af\u03a7")
+        buf.write("\3\2\2\2\u03af\u03ab\3\2\2\2\u03b0\u00e2\3\2\2\2\u03b1")
+        buf.write("\u03b5\5\u00ebv\2\u03b2\u03b4\5\u00d9m\2\u03b3\u03b2\3")
+        buf.write("\2\2\2\u03b4\u03b7\3\2\2\2\u03b5\u03b3\3\2\2\2\u03b5\u03b6")
+        buf.write("\3\2\2\2\u03b6\u00e4\3\2\2\2\u03b7\u03b5\3\2\2\2\u03b8")
+        buf.write("\u03bc\7\62\2\2\u03b9\u03bb\5\u00edw\2\u03ba\u03b9\3\2")
+        buf.write("\2\2\u03bb\u03be\3\2\2\2\u03bc\u03ba\3\2\2\2\u03bc\u03bd")
+        buf.write("\3\2\2\2\u03bd\u00e6\3\2\2\2\u03be\u03bc\3\2\2\2\u03bf")
+        buf.write("\u03c1\5\u00e9u\2\u03c0\u03c2\5\u00efx\2\u03c1\u03c0\3")
+        buf.write("\2\2\2\u03c2\u03c3\3\2\2\2\u03c3\u03c1\3\2\2\2\u03c3\u03c4")
+        buf.write("\3\2\2\2\u03c4\u00e8\3\2\2\2\u03c5\u03c6\7\62\2\2\u03c6")
+        buf.write("\u03c7\t\4\2\2\u03c7\u00ea\3\2\2\2\u03c8\u03c9\t\5\2\2")
+        buf.write("\u03c9\u00ec\3\2\2\2\u03ca\u03cb\t\6\2\2\u03cb\u00ee\3")
+        buf.write("\2\2\2\u03cc\u03cd\t\7\2\2\u03cd\u00f0\3\2\2\2\u03ce\u03d0")
+        buf.write("\5\u00f3z\2\u03cf\u03d1\5\u00f5{\2\u03d0\u03cf\3\2\2\2")
+        buf.write("\u03d0\u03d1\3\2\2\2\u03d1\u03de\3\2\2\2\u03d2\u03d3\5")
+        buf.write("\u00f3z\2\u03d3\u03d4\5\u00f7|\2\u03d4\u03de\3\2\2\2\u03d5")
+        buf.write("\u03d7\5\u00f5{\2\u03d6\u03d8\5\u00f3z\2\u03d7\u03d6\3")
+        buf.write("\2\2\2\u03d7\u03d8\3\2\2\2\u03d8\u03de\3\2\2\2\u03d9\u03db")
+        buf.write("\5\u00f7|\2\u03da\u03dc\5\u00f3z\2\u03db\u03da\3\2\2\2")
+        buf.write("\u03db\u03dc\3\2\2\2\u03dc\u03de\3\2\2\2\u03dd\u03ce\3")
+        buf.write("\2\2\2\u03dd\u03d2\3\2\2\2\u03dd\u03d5\3\2\2\2\u03dd\u03d9")
+        buf.write("\3\2\2\2\u03de\u00f2\3\2\2\2\u03df\u03e0\t\b\2\2\u03e0")
+        buf.write("\u00f4\3\2\2\2\u03e1\u03e2\t\t\2\2\u03e2\u00f6\3\2\2\2")
+        buf.write("\u03e3\u03e4\7n\2\2\u03e4\u03e8\7n\2\2\u03e5\u03e6\7N")
+        buf.write("\2\2\u03e6\u03e8\7N\2\2\u03e7\u03e3\3\2\2\2\u03e7\u03e5")
+        buf.write("\3\2\2\2\u03e8\u00f8\3\2\2\2\u03e9\u03ec\5\u00fb~\2\u03ea")
+        buf.write("\u03ec\5\u00fd\177\2\u03eb\u03e9\3\2\2\2\u03eb\u03ea\3")
+        buf.write("\2\2\2\u03ec\u00fa\3\2\2\2\u03ed\u03ef\5\u00ff\u0080\2")
+        buf.write("\u03ee\u03f0\5\u0101\u0081\2\u03ef\u03ee\3\2\2\2\u03ef")
+        buf.write("\u03f0\3\2\2\2\u03f0\u03f2\3\2\2\2\u03f1\u03f3\5\u010d")
+        buf.write("\u0087\2\u03f2\u03f1\3\2\2\2\u03f2\u03f3\3\2\2\2\u03f3")
+        buf.write("\u03fa\3\2\2\2\u03f4\u03f5\5\u0105\u0083\2\u03f5\u03f7")
+        buf.write("\5\u0101\u0081\2\u03f6\u03f8\5\u010d\u0087\2\u03f7\u03f6")
+        buf.write("\3\2\2\2\u03f7\u03f8\3\2\2\2\u03f8\u03fa\3\2\2\2\u03f9")
+        buf.write("\u03ed\3\2\2\2\u03f9\u03f4\3\2\2\2\u03fa\u00fc\3\2\2\2")
+        buf.write("\u03fb\u03fc\5\u00e9u\2\u03fc\u03fd\5\u0107\u0084\2\u03fd")
+        buf.write("\u03ff\5\u0109\u0085\2\u03fe\u0400\5\u010d\u0087\2\u03ff")
+        buf.write("\u03fe\3\2\2\2\u03ff\u0400\3\2\2\2\u0400\u0408\3\2\2\2")
+        buf.write("\u0401\u0402\5\u00e9u\2\u0402\u0403\5\u010b\u0086\2\u0403")
+        buf.write("\u0405\5\u0109\u0085\2\u0404\u0406\5\u010d\u0087\2\u0405")
+        buf.write("\u0404\3\2\2\2\u0405\u0406\3\2\2\2\u0406\u0408\3\2\2\2")
+        buf.write("\u0407\u03fb\3\2\2\2\u0407\u0401\3\2\2\2\u0408\u00fe\3")
+        buf.write("\2\2\2\u0409\u040b\5\u0105\u0083\2\u040a\u0409\3\2\2\2")
+        buf.write("\u040a\u040b\3\2\2\2\u040b\u040c\3\2\2\2\u040c\u040d\7")
+        buf.write("\60\2\2\u040d\u0412\5\u0105\u0083\2\u040e\u040f\5\u0105")
+        buf.write("\u0083\2\u040f\u0410\7\60\2\2\u0410\u0412\3\2\2\2\u0411")
+        buf.write("\u040a\3\2\2\2\u0411\u040e\3\2\2\2\u0412\u0100\3\2\2\2")
+        buf.write("\u0413\u0415\7g\2\2\u0414\u0416\5\u0103\u0082\2\u0415")
+        buf.write("\u0414\3\2\2\2\u0415\u0416\3\2\2\2\u0416\u0417\3\2\2\2")
+        buf.write("\u0417\u041e\5\u0105\u0083\2\u0418\u041a\7G\2\2\u0419")
+        buf.write("\u041b\5\u0103\u0082\2\u041a\u0419\3\2\2\2\u041a\u041b")
+        buf.write("\3\2\2\2\u041b\u041c\3\2\2\2\u041c\u041e\5\u0105\u0083")
+        buf.write("\2\u041d\u0413\3\2\2\2\u041d\u0418\3\2\2\2\u041e\u0102")
+        buf.write("\3\2\2\2\u041f\u0420\t\n\2\2\u0420\u0104\3\2\2\2\u0421")
+        buf.write("\u0423\5\u00d9m\2\u0422\u0421\3\2\2\2\u0423\u0424\3\2")
+        buf.write("\2\2\u0424\u0422\3\2\2\2\u0424\u0425\3\2\2\2\u0425\u0106")
+        buf.write("\3\2\2\2\u0426\u0428\5\u010b\u0086\2\u0427\u0426\3\2\2")
+        buf.write("\2\u0427\u0428\3\2\2\2\u0428\u0429\3\2\2\2\u0429\u042a")
+        buf.write("\7\60\2\2\u042a\u042f\5\u010b\u0086\2\u042b\u042c\5\u010b")
+        buf.write("\u0086\2\u042c\u042d\7\60\2\2\u042d\u042f\3\2\2\2\u042e")
+        buf.write("\u0427\3\2\2\2\u042e\u042b\3\2\2\2\u042f\u0108\3\2\2\2")
+        buf.write("\u0430\u0432\7r\2\2\u0431\u0433\5\u0103\u0082\2\u0432")
+        buf.write("\u0431\3\2\2\2\u0432\u0433\3\2\2\2\u0433\u0434\3\2\2\2")
+        buf.write("\u0434\u043b\5\u0105\u0083\2\u0435\u0437\7R\2\2\u0436")
+        buf.write("\u0438\5\u0103\u0082\2\u0437\u0436\3\2\2\2\u0437\u0438")
+        buf.write("\3\2\2\2\u0438\u0439\3\2\2\2\u0439\u043b\5\u0105\u0083")
+        buf.write("\2\u043a\u0430\3\2\2\2\u043a\u0435\3\2\2\2\u043b\u010a")
+        buf.write("\3\2\2\2\u043c\u043e\5\u00efx\2\u043d\u043c\3\2\2\2\u043e")
+        buf.write("\u043f\3\2\2\2\u043f\u043d\3\2\2\2\u043f\u0440\3\2\2\2")
+        buf.write("\u0440\u010c\3\2\2\2\u0441\u0442\t\13\2\2\u0442\u010e")
+        buf.write("\3\2\2\2\u0443\u0444\7)\2\2\u0444\u0445\5\u0111\u0089")
+        buf.write("\2\u0445\u0446\7)\2\2\u0446\u045a\3\2\2\2\u0447\u0448")
+        buf.write("\7N\2\2\u0448\u0449\7)\2\2\u0449\u044a\3\2\2\2\u044a\u044b")
+        buf.write("\5\u0111\u0089\2\u044b\u044c\7)\2\2\u044c\u045a\3\2\2")
+        buf.write("\2\u044d\u044e\7w\2\2\u044e\u044f\7)\2\2\u044f\u0450\3")
+        buf.write("\2\2\2\u0450\u0451\5\u0111\u0089\2\u0451\u0452\7)\2\2")
+        buf.write("\u0452\u045a\3\2\2\2\u0453\u0454\7W\2\2\u0454\u0455\7")
+        buf.write(")\2\2\u0455\u0456\3\2\2\2\u0456\u0457\5\u0111\u0089\2")
+        buf.write("\u0457\u0458\7)\2\2\u0458\u045a\3\2\2\2\u0459\u0443\3")
+        buf.write("\2\2\2\u0459\u0447\3\2\2\2\u0459\u044d\3\2\2\2\u0459\u0453")
+        buf.write("\3\2\2\2\u045a\u0110\3\2\2\2\u045b\u045d\5\u0113\u008a")
+        buf.write("\2\u045c\u045b\3\2\2\2\u045d\u045e\3\2\2\2\u045e\u045c")
+        buf.write("\3\2\2\2\u045e\u045f\3\2\2\2\u045f\u0112\3\2\2\2\u0460")
+        buf.write("\u0463\n\f\2\2\u0461\u0463\5\u0115\u008b\2\u0462\u0460")
+        buf.write("\3\2\2\2\u0462\u0461\3\2\2\2\u0463\u0114\3\2\2\2\u0464")
+        buf.write("\u0469\5\u0117\u008c\2\u0465\u0469\5\u0119\u008d\2\u0466")
+        buf.write("\u0469\5\u011b\u008e\2\u0467\u0469\5\u00dbn\2\u0468\u0464")
+        buf.write("\3\2\2\2\u0468\u0465\3\2\2\2\u0468\u0466\3\2\2\2\u0468")
+        buf.write("\u0467\3\2\2\2\u0469\u0116\3\2\2\2\u046a\u046b\7^\2\2")
+        buf.write("\u046b\u046c\t\r\2\2\u046c\u0118\3\2\2\2\u046d\u046e\7")
+        buf.write("^\2\2\u046e\u0479\5\u00edw\2\u046f\u0470\7^\2\2\u0470")
+        buf.write("\u0471\5\u00edw\2\u0471\u0472\5\u00edw\2\u0472\u0479\3")
+        buf.write("\2\2\2\u0473\u0474\7^\2\2\u0474\u0475\5\u00edw\2\u0475")
+        buf.write("\u0476\5\u00edw\2\u0476\u0477\5\u00edw\2\u0477\u0479\3")
+        buf.write("\2\2\2\u0478\u046d\3\2\2\2\u0478\u046f\3\2\2\2\u0478\u0473")
+        buf.write("\3\2\2\2\u0479\u011a\3\2\2\2\u047a\u047b\7^\2\2\u047b")
+        buf.write("\u047c\7z\2\2\u047c\u047e\3\2\2\2\u047d\u047f\5\u00ef")
+        buf.write("x\2\u047e\u047d\3\2\2\2\u047f\u0480\3\2\2\2\u0480\u047e")
+        buf.write("\3\2\2\2\u0480\u0481\3\2\2\2\u0481\u011c\3\2\2\2\u0482")
+        buf.write("\u0484\5\u011f\u0090\2\u0483\u0482\3\2\2\2\u0483\u0484")
+        buf.write("\3\2\2\2\u0484\u0485\3\2\2\2\u0485\u0487\7$\2\2\u0486")
+        buf.write("\u0488\5\u0121\u0091\2\u0487\u0486\3\2\2\2\u0487\u0488")
+        buf.write("\3\2\2\2\u0488\u0489\3\2\2\2\u0489\u048a\7$\2\2\u048a")
+        buf.write("\u011e\3\2\2\2\u048b\u048c\7w\2\2\u048c\u048f\7:\2\2\u048d")
+        buf.write("\u048f\t\16\2\2\u048e\u048b\3\2\2\2\u048e\u048d\3\2\2")
+        buf.write("\2\u048f\u0120\3\2\2\2\u0490\u0492\5\u0123\u0092\2\u0491")
+        buf.write("\u0490\3\2\2\2\u0492\u0493\3\2\2\2\u0493\u0491\3\2\2\2")
+        buf.write("\u0493\u0494\3\2\2\2\u0494\u0122\3\2\2\2\u0495\u0498\n")
+        buf.write("\17\2\2\u0496\u0498\5\u0115\u008b\2\u0497\u0495\3\2\2")
+        buf.write("\2\u0497\u0496\3\2\2\2\u0498\u0124\3\2\2\2\u0499\u049b")
+        buf.write("\7%\2\2\u049a\u049c\5\u0129\u0095\2\u049b\u049a\3\2\2")
+        buf.write("\2\u049b\u049c\3\2\2\2\u049c\u049d\3\2\2\2\u049d\u049f")
+        buf.write("\5\u00e3r\2\u049e\u04a0\5\u0129\u0095\2\u049f\u049e\3")
+        buf.write("\2\2\2\u049f\u04a0\3\2\2\2\u04a0\u04a1\3\2\2\2\u04a1\u04a5")
+        buf.write("\5\u011d\u008f\2\u04a2\u04a4\n\20\2\2\u04a3\u04a2\3\2")
+        buf.write("\2\2\u04a4\u04a7\3\2\2\2\u04a5\u04a3\3\2\2\2\u04a5\u04a6")
+        buf.write("\3\2\2\2\u04a6\u04a8\3\2\2\2\u04a7\u04a5\3\2\2\2\u04a8")
+        buf.write("\u04a9\b\u0093\2\2\u04a9\u0126\3\2\2\2\u04aa\u04ac\7%")
+        buf.write("\2\2\u04ab\u04ad\5\u0129\u0095\2\u04ac\u04ab\3\2\2\2\u04ac")
+        buf.write("\u04ad\3\2\2\2\u04ad\u04ae\3\2\2\2\u04ae\u04af\7r\2\2")
+        buf.write("\u04af\u04b0\7t\2\2\u04b0\u04b1\7c\2\2\u04b1\u04b2\7i")
+        buf.write("\2\2\u04b2\u04b3\7o\2\2\u04b3\u04b4\7c\2\2\u04b4\u04b5")
+        buf.write("\3\2\2\2\u04b5\u04b9\5\u0129\u0095\2\u04b6\u04b8\n\20")
+        buf.write("\2\2\u04b7\u04b6\3\2\2\2\u04b8\u04bb\3\2\2\2\u04b9\u04b7")
+        buf.write("\3\2\2\2\u04b9\u04ba\3\2\2\2\u04ba\u04bc\3\2\2\2\u04bb")
+        buf.write("\u04b9\3\2\2\2\u04bc\u04bd\b\u0094\2\2\u04bd\u0128\3\2")
+        buf.write("\2\2\u04be\u04c0\t\21\2\2\u04bf\u04be\3\2\2\2\u04c0\u04c1")
+        buf.write("\3\2\2\2\u04c1\u04bf\3\2\2\2\u04c1\u04c2\3\2\2\2\u04c2")
+        buf.write("\u04c3\3\2\2\2\u04c3\u04c4\b\u0095\2\2\u04c4\u012a\3\2")
+        buf.write("\2\2\u04c5\u04c7\7\17\2\2\u04c6\u04c8\7\f\2\2\u04c7\u04c6")
+        buf.write("\3\2\2\2\u04c7\u04c8\3\2\2\2\u04c8\u04cb\3\2\2\2\u04c9")
+        buf.write("\u04cb\7\f\2\2\u04ca\u04c5\3\2\2\2\u04ca\u04c9\3\2\2\2")
+        buf.write("\u04cb\u04cc\3\2\2\2\u04cc\u04cd\b\u0096\2\2\u04cd\u012c")
+        buf.write("\3\2\2\2\u04ce\u04cf\7\61\2\2\u04cf\u04d0\7,\2\2\u04d0")
+        buf.write("\u04d4\3\2\2\2\u04d1\u04d3\13\2\2\2\u04d2\u04d1\3\2\2")
+        buf.write("\2\u04d3\u04d6\3\2\2\2\u04d4\u04d5\3\2\2\2\u04d4\u04d2")
+        buf.write("\3\2\2\2\u04d5\u04d7\3\2\2\2\u04d6\u04d4\3\2\2\2\u04d7")
+        buf.write("\u04d8\7,\2\2\u04d8\u04d9\7\61\2\2\u04d9\u04da\3\2\2\2")
+        buf.write("\u04da\u04db\b\u0097\2\2\u04db\u012e\3\2\2\2\u04dc\u04dd")
+        buf.write("\7\61\2\2\u04dd\u04de\7\61\2\2\u04de\u04e2\3\2\2\2\u04df")
+        buf.write("\u04e1\n\20\2\2\u04e0\u04df\3\2\2\2\u04e1\u04e4\3\2\2")
+        buf.write("\2\u04e2\u04e0\3\2\2\2\u04e2\u04e3\3\2\2\2\u04e3\u04e5")
+        buf.write("\3\2\2\2\u04e4\u04e2\3\2\2\2\u04e5\u04e6\b\u0098\2\2\u04e6")
+        buf.write("\u0130\3\2\2\2=\2\u0380\u0382\u0387\u0397\u03a1\u03a5")
+        buf.write("\u03a9\u03ad\u03af\u03b5\u03bc\u03c3\u03d0\u03d7\u03db")
+        buf.write("\u03dd\u03e7\u03eb\u03ef\u03f2\u03f7\u03f9\u03ff\u0405")
+        buf.write("\u0407\u040a\u0411\u0415\u041a\u041d\u0424\u0427\u042e")
+        buf.write("\u0432\u0437\u043a\u043f\u0459\u045e\u0462\u0468\u0478")
+        buf.write("\u0480\u0483\u0487\u048e\u0493\u0497\u049b\u049f\u04a5")
+        buf.write("\u04ac\u04b9\u04c1\u04c7\u04ca\u04d4\u04e2\3\b\2\2")
+        return buf.getvalue()
+
+
+class CLexer(Lexer):
+
+    atn = ATNDeserializer().deserialize(serializedATN())
+
+    decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
+
+
+    T__0 = 1
+    T__1 = 2
+    T__2 = 3
+    T__3 = 4
+    T__4 = 5
+    T__5 = 6
+    T__6 = 7
+    T__7 = 8
+    T__8 = 9
+    T__9 = 10
+    T__10 = 11
+    T__11 = 12
+    T__12 = 13
+    T__13 = 14
+    Auto = 15
+    Break = 16
+    Case = 17
+    Char = 18
+    Const = 19
+    Continue = 20
+    Default = 21
+    Do = 22
+    Double = 23
+    Else = 24
+    Enum = 25
+    Extern = 26
+    Float = 27
+    For = 28
+    Goto = 29
+    If = 30
+    Inline = 31
+    Int = 32
+    Long = 33
+    Register = 34
+    Restrict = 35
+    Return = 36
+    Short = 37
+    Signed = 38
+    Sizeof = 39
+    Static = 40
+    Struct = 41
+    Switch = 42
+    Typedef = 43
+    Union = 44
+    Unsigned = 45
+    Void = 46
+    Volatile = 47
+    While = 48
+    Alignas = 49
+    Alignof = 50
+    Atomic = 51
+    Bool = 52
+    Complex = 53
+    Generic = 54
+    Imaginary = 55
+    Noreturn = 56
+    StaticAssert = 57
+    ThreadLocal = 58
+    LeftParen = 59
+    RightParen = 60
+    LeftBracket = 61
+    RightBracket = 62
+    LeftBrace = 63
+    RightBrace = 64
+    Less = 65
+    LessEqual = 66
+    Greater = 67
+    GreaterEqual = 68
+    LeftShift = 69
+    RightShift = 70
+    Plus = 71
+    PlusPlus = 72
+    Minus = 73
+    MinusMinus = 74
+    Star = 75
+    Div = 76
+    Mod = 77
+    And = 78
+    Or = 79
+    AndAnd = 80
+    OrOr = 81
+    Caret = 82
+    Not = 83
+    Tilde = 84
+    Question = 85
+    Colon = 86
+    Semi = 87
+    Comma = 88
+    Assign = 89
+    StarAssign = 90
+    DivAssign = 91
+    ModAssign = 92
+    PlusAssign = 93
+    MinusAssign = 94
+    LeftShiftAssign = 95
+    RightShiftAssign = 96
+    AndAssign = 97
+    XorAssign = 98
+    OrAssign = 99
+    Equal = 100
+    NotEqual = 101
+    Arrow = 102
+    Dot = 103
+    Ellipsis = 104
+    Identifier = 105
+    Constant = 106
+    StringLiteral = 107
+    LineDirective = 108
+    PragmaDirective = 109
+    Whitespace = 110
+    Newline = 111
+    BlockComment = 112
+    LineComment = 113
+
+    modeNames = [ "DEFAULT_MODE" ]
+
+    literalNames = [ "<INVALID>",
+            "'__extension__'", "'__builtin_va_arg'", "'__builtin_offsetof'", 
+            "'__m128'", "'__m128d'", "'__m128i'", "'__typeof__'", "'__inline__'", 
+            "'__stdcall'", "'__declspec'", "'__asm'", "'__attribute__'", 
+            "'__asm__'", "'__volatile__'", "'auto'", "'break'", "'case'", 
+            "'char'", "'const'", "'continue'", "'default'", "'do'", "'double'", 
+            "'else'", "'enum'", "'extern'", "'float'", "'for'", "'goto'", 
+            "'if'", "'inline'", "'int'", "'long'", "'register'", "'restrict'", 
+            "'return'", "'short'", "'signed'", "'sizeof'", "'static'", "'struct'", 
+            "'switch'", "'typedef'", "'union'", "'unsigned'", "'void'", 
+            "'volatile'", "'while'", "'_Alignas'", "'_Alignof'", "'_Atomic'", 
+            "'_Bool'", "'_Complex'", "'_Generic'", "'_Imaginary'", "'_Noreturn'", 
+            "'_Static_assert'", "'_Thread_local'", "'('", "')'", "'['", 
+            "']'", "'{'", "'}'", "'<'", "'<='", "'>'", "'>='", "'<<'", "'>>'", 
+            "'+'", "'++'", "'-'", "'--'", "'*'", "'/'", "'%'", "'&'", "'|'", 
+            "'&&'", "'||'", "'^'", "'!'", "'~'", "'?'", "':'", "';'", "','", 
+            "'='", "'*='", "'/='", "'%='", "'+='", "'-='", "'<<='", "'>>='", 
+            "'&='", "'^='", "'|='", "'=='", "'!='", "'->'", "'.'", "'...'" ]
+
+    symbolicNames = [ "<INVALID>",
+            "Auto", "Break", "Case", "Char", "Const", "Continue", "Default", 
+            "Do", "Double", "Else", "Enum", "Extern", "Float", "For", "Goto", 
+            "If", "Inline", "Int", "Long", "Register", "Restrict", "Return", 
+            "Short", "Signed", "Sizeof", "Static", "Struct", "Switch", "Typedef", 
+            "Union", "Unsigned", "Void", "Volatile", "While", "Alignas", 
+            "Alignof", "Atomic", "Bool", "Complex", "Generic", "Imaginary", 
+            "Noreturn", "StaticAssert", "ThreadLocal", "LeftParen", "RightParen", 
+            "LeftBracket", "RightBracket", "LeftBrace", "RightBrace", "Less", 
+            "LessEqual", "Greater", "GreaterEqual", "LeftShift", "RightShift", 
+            "Plus", "PlusPlus", "Minus", "MinusMinus", "Star", "Div", "Mod", 
+            "And", "Or", "AndAnd", "OrOr", "Caret", "Not", "Tilde", "Question", 
+            "Colon", "Semi", "Comma", "Assign", "StarAssign", "DivAssign", 
+            "ModAssign", "PlusAssign", "MinusAssign", "LeftShiftAssign", 
+            "RightShiftAssign", "AndAssign", "XorAssign", "OrAssign", "Equal", 
+            "NotEqual", "Arrow", "Dot", "Ellipsis", "Identifier", "Constant", 
+            "StringLiteral", "LineDirective", "PragmaDirective", "Whitespace", 
+            "Newline", "BlockComment", "LineComment" ]
+
+    ruleNames = [ "T__0", "T__1", "T__2", "T__3", "T__4", "T__5", "T__6", 
+                  "T__7", "T__8", "T__9", "T__10", "T__11", "T__12", "T__13", 
+                  "Auto", "Break", "Case", "Char", "Const", "Continue", 
+                  "Default", "Do", "Double", "Else", "Enum", "Extern", "Float", 
+                  "For", "Goto", "If", "Inline", "Int", "Long", "Register", 
+                  "Restrict", "Return", "Short", "Signed", "Sizeof", "Static", 
+                  "Struct", "Switch", "Typedef", "Union", "Unsigned", "Void", 
+                  "Volatile", "While", "Alignas", "Alignof", "Atomic", "Bool", 
+                  "Complex", "Generic", "Imaginary", "Noreturn", "StaticAssert", 
+                  "ThreadLocal", "LeftParen", "RightParen", "LeftBracket", 
+                  "RightBracket", "LeftBrace", "RightBrace", "Less", "LessEqual", 
+                  "Greater", "GreaterEqual", "LeftShift", "RightShift", 
+                  "Plus", "PlusPlus", "Minus", "MinusMinus", "Star", "Div", 
+                  "Mod", "And", "Or", "AndAnd", "OrOr", "Caret", "Not", 
+                  "Tilde", "Question", "Colon", "Semi", "Comma", "Assign", 
+                  "StarAssign", "DivAssign", "ModAssign", "PlusAssign", 
+                  "MinusAssign", "LeftShiftAssign", "RightShiftAssign", 
+                  "AndAssign", "XorAssign", "OrAssign", "Equal", "NotEqual", 
+                  "Arrow", "Dot", "Ellipsis", "Identifier", "IdentifierNondigit", 
+                  "Nondigit", "Digit", "UniversalCharacterName", "HexQuad", 
+                  "Constant", "IntegerConstant", "DecimalConstant", "OctalConstant", 
+                  "HexadecimalConstant", "HexadecimalPrefix", "NonzeroDigit", 
+                  "OctalDigit", "HexadecimalDigit", "IntegerSuffix", "UnsignedSuffix", 
+                  "LongSuffix", "LongLongSuffix", "FloatingConstant", "DecimalFloatingConstant", 
+                  "HexadecimalFloatingConstant", "FractionalConstant", "ExponentPart", 
+                  "Sign", "DigitSequence", "HexadecimalFractionalConstant", 
+                  "BinaryExponentPart", "HexadecimalDigitSequence", "FloatingSuffix", 
+                  "CharacterConstant", "CCharSequence", "CChar", "EscapeSequence", 
+                  "SimpleEscapeSequence", "OctalEscapeSequence", "HexadecimalEscapeSequence", 
+                  "StringLiteral", "EncodingPrefix", "SCharSequence", "SChar", 
+                  "LineDirective", "PragmaDirective", "Whitespace", "Newline", 
+                  "BlockComment", "LineComment" ]
+
+    grammarFileName = "C.bnf"
+
+    def __init__(self, input=None):
+        super().__init__(input)
+        self.checkVersion("4.5.1")
+        self._interp = LexerATNSimulator(self, self.atn, self.decisionsToDFA, PredictionContextCache())
+        self._actions = None
+        self._predicates = None
+
diff --git a/runtime/Python3/test/parser/cparser.py b/runtime/Python3/test/parser/cparser.py
new file mode 100644
index 000000000..72864a7cf
--- /dev/null
+++ b/runtime/Python3/test/parser/cparser.py
@@ -0,0 +1,8271 @@
+# Generated from C.bnf by ANTLR 4.5.1
+# encoding: utf-8
+from antlr4 import *
+from io import StringIO
+
+def serializedATN():
+    with StringIO() as buf:
+        buf.write("\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3s")
+        buf.write("\u04e9\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
+        buf.write("\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")
+        buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23")
+        buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31")
+        buf.write("\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36")
+        buf.write("\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t")
+        buf.write("&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.\t.\4")
+        buf.write("/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t\64")
+        buf.write("\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t")
+        buf.write(";\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\t")
+        buf.write("D\4E\tE\4F\tF\4G\tG\4H\tH\4I\tI\4J\tJ\4K\tK\4L\tL\4M\t")
+        buf.write("M\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT\4U\tU\3\2")
+        buf.write("\3\2\3\2\6\2\u00ae\n\2\r\2\16\2\u00af\3\2\3\2\3\2\3\2")
+        buf.write("\3\2\3\2\5\2\u00b8\n\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2")
+        buf.write("\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\5\2\u00cc\n\2")
+        buf.write("\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\7")
+        buf.write("\4\u00db\n\4\f\4\16\4\u00de\13\4\3\5\3\5\3\5\3\5\3\5\3")
+        buf.write("\5\3\5\5\5\u00e7\n\5\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3")
+        buf.write("\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6")
+        buf.write("\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\5\6\u010b")
+        buf.write("\n\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\5\6\u0115\n\6\3\6")
+        buf.write("\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\7\6\u0122\n\6")
+        buf.write("\f\6\16\6\u0125\13\6\3\7\3\7\3\7\3\7\3\7\3\7\7\7\u012d")
+        buf.write("\n\7\f\7\16\7\u0130\13\7\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3")
+        buf.write("\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b")
+        buf.write("\3\b\5\b\u0148\n\b\3\t\3\t\3\n\3\n\3\n\3\n\3\n\3\n\3\n")
+        buf.write("\3\n\3\n\3\n\3\n\3\n\5\n\u0158\n\n\3\13\3\13\3\13\3\13")
+        buf.write("\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\7\13\u0166\n")
+        buf.write("\13\f\13\16\13\u0169\13\13\3\f\3\f\3\f\3\f\3\f\3\f\3\f")
+        buf.write("\3\f\3\f\7\f\u0174\n\f\f\f\16\f\u0177\13\f\3\r\3\r\3\r")
+        buf.write("\3\r\3\r\3\r\3\r\3\r\3\r\7\r\u0182\n\r\f\r\16\r\u0185")
+        buf.write("\13\r\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16")
+        buf.write("\3\16\3\16\3\16\3\16\3\16\7\16\u0196\n\16\f\16\16\16\u0199")
+        buf.write("\13\16\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\7")
+        buf.write("\17\u01a4\n\17\f\17\16\17\u01a7\13\17\3\20\3\20\3\20\3")
+        buf.write("\20\3\20\3\20\7\20\u01af\n\20\f\20\16\20\u01b2\13\20\3")
+        buf.write("\21\3\21\3\21\3\21\3\21\3\21\7\21\u01ba\n\21\f\21\16\21")
+        buf.write("\u01bd\13\21\3\22\3\22\3\22\3\22\3\22\3\22\7\22\u01c5")
+        buf.write("\n\22\f\22\16\22\u01c8\13\22\3\23\3\23\3\23\3\23\3\23")
+        buf.write("\3\23\7\23\u01d0\n\23\f\23\16\23\u01d3\13\23\3\24\3\24")
+        buf.write("\3\24\3\24\3\24\3\24\7\24\u01db\n\24\f\24\16\24\u01de")
+        buf.write("\13\24\3\25\3\25\3\25\3\25\3\25\3\25\5\25\u01e6\n\25\3")
+        buf.write("\26\3\26\3\26\3\26\3\26\5\26\u01ed\n\26\3\27\3\27\3\30")
+        buf.write("\3\30\3\30\3\30\3\30\3\30\7\30\u01f7\n\30\f\30\16\30\u01fa")
+        buf.write("\13\30\3\31\3\31\3\32\3\32\5\32\u0200\n\32\3\32\3\32\3")
+        buf.write("\32\5\32\u0205\n\32\3\33\6\33\u0208\n\33\r\33\16\33\u0209")
+        buf.write("\3\34\6\34\u020d\n\34\r\34\16\34\u020e\3\35\3\35\3\35")
+        buf.write("\3\35\3\35\5\35\u0216\n\35\3\36\3\36\3\36\3\36\3\36\3")
+        buf.write("\36\7\36\u021e\n\36\f\36\16\36\u0221\13\36\3\37\3\37\3")
+        buf.write("\37\3\37\3\37\5\37\u0228\n\37\3 \3 \3!\3!\3!\3!\3!\3!")
+        buf.write("\3!\3!\3!\3!\3!\3!\3!\3!\5!\u023a\n!\3\"\3\"\5\"\u023e")
+        buf.write("\n\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\5\"\u0247\n\"\3#\3#\3")
+        buf.write("$\3$\3$\3$\3$\7$\u0250\n$\f$\16$\u0253\13$\3%\3%\5%\u0257")
+        buf.write("\n%\3%\3%\3%\5%\u025c\n%\3&\3&\5&\u0260\n&\3&\3&\5&\u0264")
+        buf.write("\n&\5&\u0266\n&\3\'\3\'\3\'\3\'\3\'\3\'\7\'\u026e\n\'")
+        buf.write("\f\'\16\'\u0271\13\'\3(\3(\5(\u0275\n(\3(\3(\5(\u0279")
+        buf.write("\n(\3)\3)\5)\u027d\n)\3)\3)\3)\3)\3)\3)\5)\u0285\n)\3")
+        buf.write(")\3)\3)\3)\3)\3)\3)\5)\u028e\n)\3*\3*\3*\3*\3*\3*\7*\u0296")
+        buf.write("\n*\f*\16*\u0299\13*\3+\3+\3+\3+\3+\5+\u02a0\n+\3,\3,")
+        buf.write("\3-\3-\3-\3-\3-\3.\3.\3/\3/\3/\3/\3/\3/\5/\u02b1\n/\3")
+        buf.write("\60\3\60\3\60\3\60\3\60\3\60\3\60\3\60\3\60\3\60\5\60")
+        buf.write("\u02bd\n\60\3\61\5\61\u02c0\n\61\3\61\3\61\7\61\u02c4")
+        buf.write("\n\61\f\61\16\61\u02c7\13\61\3\62\3\62\3\62\3\62\3\62")
+        buf.write("\3\62\5\62\u02cf\n\62\3\62\3\62\3\62\5\62\u02d4\n\62\3")
+        buf.write("\62\5\62\u02d7\n\62\3\62\3\62\3\62\3\62\3\62\5\62\u02de")
+        buf.write("\n\62\3\62\3\62\3\62\3\62\3\62\3\62\3\62\3\62\3\62\3\62")
+        buf.write("\3\62\3\62\3\62\5\62\u02ed\n\62\3\62\3\62\3\62\3\62\3")
+        buf.write("\62\3\62\3\62\3\62\3\62\3\62\5\62\u02f9\n\62\3\62\7\62")
+        buf.write("\u02fc\n\62\f\62\16\62\u02ff\13\62\3\63\3\63\3\63\6\63")
+        buf.write("\u0304\n\63\r\63\16\63\u0305\3\63\3\63\5\63\u030a\n\63")
+        buf.write("\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\65\3\65\3\65\7\65")
+        buf.write("\u0316\n\65\f\65\16\65\u0319\13\65\3\65\5\65\u031c\n\65")
+        buf.write("\3\66\3\66\3\66\5\66\u0321\n\66\3\66\5\66\u0324\n\66\3")
+        buf.write("\66\5\66\u0327\n\66\3\67\3\67\3\67\3\67\3\67\7\67\u032e")
+        buf.write("\n\67\f\67\16\67\u0331\13\67\38\38\58\u0335\n8\38\38\5")
+        buf.write("8\u0339\n8\38\38\38\58\u033e\n8\38\38\58\u0342\n8\38\5")
+        buf.write("8\u0345\n8\39\39\39\39\39\79\u034c\n9\f9\169\u034f\13")
+        buf.write("9\3:\3:\3:\3:\3:\5:\u0356\n:\3;\3;\3;\3;\3;\3;\7;\u035e")
+        buf.write("\n;\f;\16;\u0361\13;\3<\3<\3<\3<\3<\5<\u0368\n<\5<\u036a")
+        buf.write("\n<\3=\3=\3=\3=\3=\3=\7=\u0372\n=\f=\16=\u0375\13=\3>")
+        buf.write("\3>\5>\u0379\n>\3?\3?\5?\u037d\n?\3?\3?\7?\u0381\n?\f")
+        buf.write("?\16?\u0384\13?\5?\u0386\n?\3@\3@\3@\3@\3@\7@\u038d\n")
+        buf.write("@\f@\16@\u0390\13@\3@\3@\5@\u0394\n@\3@\5@\u0397\n@\3")
+        buf.write("@\3@\3@\3@\5@\u039d\n@\3@\3@\3@\3@\3@\3@\3@\3@\3@\3@\3")
+        buf.write("@\3@\3@\3@\5@\u03ad\n@\3@\3@\7@\u03b1\n@\f@\16@\u03b4")
+        buf.write("\13@\5@\u03b6\n@\3@\3@\3@\5@\u03bb\n@\3@\5@\u03be\n@\3")
+        buf.write("@\3@\3@\3@\3@\5@\u03c5\n@\3@\3@\3@\3@\3@\3@\3@\3@\3@\3")
+        buf.write("@\3@\3@\3@\3@\3@\3@\3@\5@\u03d8\n@\3@\3@\7@\u03dc\n@\f")
+        buf.write("@\16@\u03df\13@\7@\u03e1\n@\f@\16@\u03e4\13@\3A\3A\3B")
+        buf.write("\3B\3B\3B\3B\3B\3B\3B\3B\3B\5B\u03f2\nB\3C\3C\5C\u03f6")
+        buf.write("\nC\3C\3C\3C\3C\3C\5C\u03fd\nC\3C\7C\u0400\nC\fC\16C\u0403")
+        buf.write("\13C\3D\3D\3D\3E\3E\3E\3E\3E\7E\u040d\nE\fE\16E\u0410")
+        buf.write("\13E\3F\3F\3F\3F\3F\3F\5F\u0418\nF\3G\3G\3G\3G\3G\6G\u041f")
+        buf.write("\nG\rG\16G\u0420\3G\3G\3G\3H\3H\3H\3H\3H\3H\3H\3H\3H\3")
+        buf.write("H\3H\3H\7H\u0432\nH\fH\16H\u0435\13H\5H\u0437\nH\3H\3")
+        buf.write("H\3H\3H\7H\u043d\nH\fH\16H\u0440\13H\5H\u0442\nH\7H\u0444")
+        buf.write("\nH\fH\16H\u0447\13H\3H\3H\5H\u044b\nH\3I\3I\3I\3I\3I")
+        buf.write("\3I\3I\3I\3I\3I\3I\5I\u0458\nI\3J\3J\5J\u045c\nJ\3J\3")
+        buf.write("J\3K\3K\3K\3K\3K\7K\u0465\nK\fK\16K\u0468\13K\3L\3L\5")
+        buf.write("L\u046c\nL\3M\5M\u046f\nM\3M\3M\3N\3N\3N\3N\3N\3N\3N\5")
+        buf.write("N\u047a\nN\3N\3N\3N\3N\3N\3N\5N\u0482\nN\3O\3O\3O\3O\3")
+        buf.write("O\3O\3O\3O\3O\3O\3O\3O\3O\3O\3O\3O\3O\5O\u0495\nO\3O\3")
+        buf.write("O\5O\u0499\nO\3O\3O\5O\u049d\nO\3O\3O\3O\3O\3O\3O\5O\u04a5")
+        buf.write("\nO\3O\3O\5O\u04a9\nO\3O\3O\3O\5O\u04ae\nO\3P\3P\3P\3")
+        buf.write("P\3P\3P\3P\3P\3P\5P\u04b9\nP\3P\3P\3P\3P\3P\5P\u04c0\n")
+        buf.write("P\3Q\5Q\u04c3\nQ\3Q\3Q\3R\3R\3R\3R\3R\7R\u04cc\nR\fR\16")
+        buf.write("R\u04cf\13R\3S\3S\3S\5S\u04d4\nS\3T\5T\u04d7\nT\3T\3T")
+        buf.write("\5T\u04db\nT\3T\3T\3U\3U\3U\3U\3U\7U\u04e4\nU\fU\16U\u04e7")
+        buf.write("\13U\3U\2\36\6\n\f\24\26\30\32\34\36 \"$&.:FLRbptx~\u0084")
+        buf.write("\u0088\u0094\u00a2\u00a8V\2\4\6\b\n\f\16\20\22\24\26\30")
+        buf.write("\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`b")
+        buf.write("dfhjlnprtvxz|~\u0080\u0082\u0084\u0086\u0088\u008a\u008c")
+        buf.write("\u008e\u0090\u0092\u0094\u0096\u0098\u009a\u009c\u009e")
+        buf.write("\u00a0\u00a2\u00a4\u00a6\u00a8\2\16\7\2IIKKMMPPUV\3\2")
+        buf.write("[e\b\2\21\21\34\34$$**--<<\n\2\6\b\24\24\31\31\35\35\"")
+        buf.write("#\'(/\60\66\67\3\2\6\b\4\2++..\6\2\25\25%%\61\61\65\65")
+        buf.write("\5\2\n\13!!::\4\2=>ZZ\3\2=>\4\2\r\r\17\17\4\2\20\20\61")
+        buf.write("\61\u0559\2\u00cb\3\2\2\2\4\u00cd\3\2\2\2\6\u00d4\3\2")
+        buf.write("\2\2\b\u00e6\3\2\2\2\n\u010a\3\2\2\2\f\u0126\3\2\2\2\16")
+        buf.write("\u0147\3\2\2\2\20\u0149\3\2\2\2\22\u0157\3\2\2\2\24\u0159")
+        buf.write("\3\2\2\2\26\u016a\3\2\2\2\30\u0178\3\2\2\2\32\u0186\3")
+        buf.write("\2\2\2\34\u019a\3\2\2\2\36\u01a8\3\2\2\2 \u01b3\3\2\2")
+        buf.write("\2\"\u01be\3\2\2\2$\u01c9\3\2\2\2&\u01d4\3\2\2\2(\u01df")
+        buf.write("\3\2\2\2*\u01ec\3\2\2\2,\u01ee\3\2\2\2.\u01f0\3\2\2\2")
+        buf.write("\60\u01fb\3\2\2\2\62\u0204\3\2\2\2\64\u0207\3\2\2\2\66")
+        buf.write("\u020c\3\2\2\28\u0215\3\2\2\2:\u0217\3\2\2\2<\u0227\3")
+        buf.write("\2\2\2>\u0229\3\2\2\2@\u0239\3\2\2\2B\u0246\3\2\2\2D\u0248")
+        buf.write("\3\2\2\2F\u024a\3\2\2\2H\u025b\3\2\2\2J\u0265\3\2\2\2")
+        buf.write("L\u0267\3\2\2\2N\u0278\3\2\2\2P\u028d\3\2\2\2R\u028f\3")
+        buf.write("\2\2\2T\u029f\3\2\2\2V\u02a1\3\2\2\2X\u02a3\3\2\2\2Z\u02a8")
+        buf.write("\3\2\2\2\\\u02b0\3\2\2\2^\u02bc\3\2\2\2`\u02bf\3\2\2\2")
+        buf.write("b\u02ce\3\2\2\2d\u0309\3\2\2\2f\u030b\3\2\2\2h\u031b\3")
+        buf.write("\2\2\2j\u0326\3\2\2\2l\u032f\3\2\2\2n\u0344\3\2\2\2p\u0346")
+        buf.write("\3\2\2\2r\u0355\3\2\2\2t\u0357\3\2\2\2v\u0369\3\2\2\2")
+        buf.write("x\u036b\3\2\2\2z\u0376\3\2\2\2|\u0385\3\2\2\2~\u03b5\3")
+        buf.write("\2\2\2\u0080\u03e5\3\2\2\2\u0082\u03f1\3\2\2\2\u0084\u03f3")
+        buf.write("\3\2\2\2\u0086\u0404\3\2\2\2\u0088\u0407\3\2\2\2\u008a")
+        buf.write("\u0417\3\2\2\2\u008c\u0419\3\2\2\2\u008e\u044a\3\2\2\2")
+        buf.write("\u0090\u0457\3\2\2\2\u0092\u0459\3\2\2\2\u0094\u045f\3")
+        buf.write("\2\2\2\u0096\u046b\3\2\2\2\u0098\u046e\3\2\2\2\u009a\u0481")
+        buf.write("\3\2\2\2\u009c\u04ad\3\2\2\2\u009e\u04bf\3\2\2\2\u00a0")
+        buf.write("\u04c2\3\2\2\2\u00a2\u04c6\3\2\2\2\u00a4\u04d3\3\2\2\2")
+        buf.write("\u00a6\u04d6\3\2\2\2\u00a8\u04de\3\2\2\2\u00aa\u00cc\7")
+        buf.write("k\2\2\u00ab\u00cc\7l\2\2\u00ac\u00ae\7m\2\2\u00ad\u00ac")
+        buf.write("\3\2\2\2\u00ae\u00af\3\2\2\2\u00af\u00ad\3\2\2\2\u00af")
+        buf.write("\u00b0\3\2\2\2\u00b0\u00cc\3\2\2\2\u00b1\u00b2\7=\2\2")
+        buf.write("\u00b2\u00b3\5.\30\2\u00b3\u00b4\7>\2\2\u00b4\u00cc\3")
+        buf.write("\2\2\2\u00b5\u00cc\5\4\3\2\u00b6\u00b8\7\3\2\2\u00b7\u00b6")
+        buf.write("\3\2\2\2\u00b7\u00b8\3\2\2\2\u00b8\u00b9\3\2\2\2\u00b9")
+        buf.write("\u00ba\7=\2\2\u00ba\u00bb\5\u0092J\2\u00bb\u00bc\7>\2")
+        buf.write("\2\u00bc\u00cc\3\2\2\2\u00bd\u00be\7\4\2\2\u00be\u00bf")
+        buf.write("\7=\2\2\u00bf\u00c0\5\16\b\2\u00c0\u00c1\7Z\2\2\u00c1")
+        buf.write("\u00c2\5z>\2\u00c2\u00c3\7>\2\2\u00c3\u00cc\3\2\2\2\u00c4")
+        buf.write("\u00c5\7\5\2\2\u00c5\u00c6\7=\2\2\u00c6\u00c7\5z>\2\u00c7")
+        buf.write("\u00c8\7Z\2\2\u00c8\u00c9\5\16\b\2\u00c9\u00ca\7>\2\2")
+        buf.write("\u00ca\u00cc\3\2\2\2\u00cb\u00aa\3\2\2\2\u00cb\u00ab\3")
+        buf.write("\2\2\2\u00cb\u00ad\3\2\2\2\u00cb\u00b1\3\2\2\2\u00cb\u00b5")
+        buf.write("\3\2\2\2\u00cb\u00b7\3\2\2\2\u00cb\u00bd\3\2\2\2\u00cb")
+        buf.write("\u00c4\3\2\2\2\u00cc\3\3\2\2\2\u00cd\u00ce\78\2\2\u00ce")
+        buf.write("\u00cf\7=\2\2\u00cf\u00d0\5*\26\2\u00d0\u00d1\7Z\2\2\u00d1")
+        buf.write("\u00d2\5\6\4\2\u00d2\u00d3\7>\2\2\u00d3\5\3\2\2\2\u00d4")
+        buf.write("\u00d5\b\4\1\2\u00d5\u00d6\5\b\5\2\u00d6\u00dc\3\2\2\2")
+        buf.write("\u00d7\u00d8\f\3\2\2\u00d8\u00d9\7Z\2\2\u00d9\u00db\5")
+        buf.write("\b\5\2\u00da\u00d7\3\2\2\2\u00db\u00de\3\2\2\2\u00dc\u00da")
+        buf.write("\3\2\2\2\u00dc\u00dd\3\2\2\2\u00dd\7\3\2\2\2\u00de\u00dc")
+        buf.write("\3\2\2\2\u00df\u00e0\5z>\2\u00e0\u00e1\7X\2\2\u00e1\u00e2")
+        buf.write("\5*\26\2\u00e2\u00e7\3\2\2\2\u00e3\u00e4\7\27\2\2\u00e4")
+        buf.write("\u00e5\7X\2\2\u00e5\u00e7\5*\26\2\u00e6\u00df\3\2\2\2")
+        buf.write("\u00e6\u00e3\3\2\2\2\u00e7\t\3\2\2\2\u00e8\u00e9\b\6\1")
+        buf.write("\2\u00e9\u010b\5\2\2\2\u00ea\u00eb\7=\2\2\u00eb\u00ec")
+        buf.write("\5z>\2\u00ec\u00ed\7>\2\2\u00ed\u00ee\7A\2\2\u00ee\u00ef")
+        buf.write("\5\u0084C\2\u00ef\u00f0\7B\2\2\u00f0\u010b\3\2\2\2\u00f1")
+        buf.write("\u00f2\7=\2\2\u00f2\u00f3\5z>\2\u00f3\u00f4\7>\2\2\u00f4")
+        buf.write("\u00f5\7A\2\2\u00f5\u00f6\5\u0084C\2\u00f6\u00f7\7Z\2")
+        buf.write("\2\u00f7\u00f8\7B\2\2\u00f8\u010b\3\2\2\2\u00f9\u00fa")
+        buf.write("\7\3\2\2\u00fa\u00fb\7=\2\2\u00fb\u00fc\5z>\2\u00fc\u00fd")
+        buf.write("\7>\2\2\u00fd\u00fe\7A\2\2\u00fe\u00ff\5\u0084C\2\u00ff")
+        buf.write("\u0100\7B\2\2\u0100\u010b\3\2\2\2\u0101\u0102\7\3\2\2")
+        buf.write("\u0102\u0103\7=\2\2\u0103\u0104\5z>\2\u0104\u0105\7>\2")
+        buf.write("\2\u0105\u0106\7A\2\2\u0106\u0107\5\u0084C\2\u0107\u0108")
+        buf.write("\7Z\2\2\u0108\u0109\7B\2\2\u0109\u010b\3\2\2\2\u010a\u00e8")
+        buf.write("\3\2\2\2\u010a\u00ea\3\2\2\2\u010a\u00f1\3\2\2\2\u010a")
+        buf.write("\u00f9\3\2\2\2\u010a\u0101\3\2\2\2\u010b\u0123\3\2\2\2")
+        buf.write("\u010c\u010d\f\f\2\2\u010d\u010e\7?\2\2\u010e\u010f\5")
+        buf.write(".\30\2\u010f\u0110\7@\2\2\u0110\u0122\3\2\2\2\u0111\u0112")
+        buf.write("\f\13\2\2\u0112\u0114\7=\2\2\u0113\u0115\5\f\7\2\u0114")
+        buf.write("\u0113\3\2\2\2\u0114\u0115\3\2\2\2\u0115\u0116\3\2\2\2")
+        buf.write("\u0116\u0122\7>\2\2\u0117\u0118\f\n\2\2\u0118\u0119\7")
+        buf.write("i\2\2\u0119\u0122\7k\2\2\u011a\u011b\f\t\2\2\u011b\u011c")
+        buf.write("\7h\2\2\u011c\u0122\7k\2\2\u011d\u011e\f\b\2\2\u011e\u0122")
+        buf.write("\7J\2\2\u011f\u0120\f\7\2\2\u0120\u0122\7L\2\2\u0121\u010c")
+        buf.write("\3\2\2\2\u0121\u0111\3\2\2\2\u0121\u0117\3\2\2\2\u0121")
+        buf.write("\u011a\3\2\2\2\u0121\u011d\3\2\2\2\u0121\u011f\3\2\2\2")
+        buf.write("\u0122\u0125\3\2\2\2\u0123\u0121\3\2\2\2\u0123\u0124\3")
+        buf.write("\2\2\2\u0124\13\3\2\2\2\u0125\u0123\3\2\2\2\u0126\u0127")
+        buf.write("\b\7\1\2\u0127\u0128\5*\26\2\u0128\u012e\3\2\2\2\u0129")
+        buf.write("\u012a\f\3\2\2\u012a\u012b\7Z\2\2\u012b\u012d\5*\26\2")
+        buf.write("\u012c\u0129\3\2\2\2\u012d\u0130\3\2\2\2\u012e\u012c\3")
+        buf.write("\2\2\2\u012e\u012f\3\2\2\2\u012f\r\3\2\2\2\u0130\u012e")
+        buf.write("\3\2\2\2\u0131\u0148\5\n\6\2\u0132\u0133\7J\2\2\u0133")
+        buf.write("\u0148\5\16\b\2\u0134\u0135\7L\2\2\u0135\u0148\5\16\b")
+        buf.write("\2\u0136\u0137\5\20\t\2\u0137\u0138\5\22\n\2\u0138\u0148")
+        buf.write("\3\2\2\2\u0139\u013a\7)\2\2\u013a\u0148\5\16\b\2\u013b")
+        buf.write("\u013c\7)\2\2\u013c\u013d\7=\2\2\u013d\u013e\5z>\2\u013e")
+        buf.write("\u013f\7>\2\2\u013f\u0148\3\2\2\2\u0140\u0141\7\64\2\2")
+        buf.write("\u0141\u0142\7=\2\2\u0142\u0143\5z>\2\u0143\u0144\7>\2")
+        buf.write("\2\u0144\u0148\3\2\2\2\u0145\u0146\7R\2\2\u0146\u0148")
+        buf.write("\7k\2\2\u0147\u0131\3\2\2\2\u0147\u0132\3\2\2\2\u0147")
+        buf.write("\u0134\3\2\2\2\u0147\u0136\3\2\2\2\u0147\u0139\3\2\2\2")
+        buf.write("\u0147\u013b\3\2\2\2\u0147\u0140\3\2\2\2\u0147\u0145\3")
+        buf.write("\2\2\2\u0148\17\3\2\2\2\u0149\u014a\t\2\2\2\u014a\21\3")
+        buf.write("\2\2\2\u014b\u0158\5\16\b\2\u014c\u014d\7=\2\2\u014d\u014e")
+        buf.write("\5z>\2\u014e\u014f\7>\2\2\u014f\u0150\5\22\n\2\u0150\u0158")
+        buf.write("\3\2\2\2\u0151\u0152\7\3\2\2\u0152\u0153\7=\2\2\u0153")
+        buf.write("\u0154\5z>\2\u0154\u0155\7>\2\2\u0155\u0156\5\22\n\2\u0156")
+        buf.write("\u0158\3\2\2\2\u0157\u014b\3\2\2\2\u0157\u014c\3\2\2\2")
+        buf.write("\u0157\u0151\3\2\2\2\u0158\23\3\2\2\2\u0159\u015a\b\13")
+        buf.write("\1\2\u015a\u015b\5\22\n\2\u015b\u0167\3\2\2\2\u015c\u015d")
+        buf.write("\f\5\2\2\u015d\u015e\7M\2\2\u015e\u0166\5\22\n\2\u015f")
+        buf.write("\u0160\f\4\2\2\u0160\u0161\7N\2\2\u0161\u0166\5\22\n\2")
+        buf.write("\u0162\u0163\f\3\2\2\u0163\u0164\7O\2\2\u0164\u0166\5")
+        buf.write("\22\n\2\u0165\u015c\3\2\2\2\u0165\u015f\3\2\2\2\u0165")
+        buf.write("\u0162\3\2\2\2\u0166\u0169\3\2\2\2\u0167\u0165\3\2\2\2")
+        buf.write("\u0167\u0168\3\2\2\2\u0168\25\3\2\2\2\u0169\u0167\3\2")
+        buf.write("\2\2\u016a\u016b\b\f\1\2\u016b\u016c\5\24\13\2\u016c\u0175")
+        buf.write("\3\2\2\2\u016d\u016e\f\4\2\2\u016e\u016f\7I\2\2\u016f")
+        buf.write("\u0174\5\24\13\2\u0170\u0171\f\3\2\2\u0171\u0172\7K\2")
+        buf.write("\2\u0172\u0174\5\24\13\2\u0173\u016d\3\2\2\2\u0173\u0170")
+        buf.write("\3\2\2\2\u0174\u0177\3\2\2\2\u0175\u0173\3\2\2\2\u0175")
+        buf.write("\u0176\3\2\2\2\u0176\27\3\2\2\2\u0177\u0175\3\2\2\2\u0178")
+        buf.write("\u0179\b\r\1\2\u0179\u017a\5\26\f\2\u017a\u0183\3\2\2")
+        buf.write("\2\u017b\u017c\f\4\2\2\u017c\u017d\7G\2\2\u017d\u0182")
+        buf.write("\5\26\f\2\u017e\u017f\f\3\2\2\u017f\u0180\7H\2\2\u0180")
+        buf.write("\u0182\5\26\f\2\u0181\u017b\3\2\2\2\u0181\u017e\3\2\2")
+        buf.write("\2\u0182\u0185\3\2\2\2\u0183\u0181\3\2\2\2\u0183\u0184")
+        buf.write("\3\2\2\2\u0184\31\3\2\2\2\u0185\u0183\3\2\2\2\u0186\u0187")
+        buf.write("\b\16\1\2\u0187\u0188\5\30\r\2\u0188\u0197\3\2\2\2\u0189")
+        buf.write("\u018a\f\6\2\2\u018a\u018b\7C\2\2\u018b\u0196\5\30\r\2")
+        buf.write("\u018c\u018d\f\5\2\2\u018d\u018e\7E\2\2\u018e\u0196\5")
+        buf.write("\30\r\2\u018f\u0190\f\4\2\2\u0190\u0191\7D\2\2\u0191\u0196")
+        buf.write("\5\30\r\2\u0192\u0193\f\3\2\2\u0193\u0194\7F\2\2\u0194")
+        buf.write("\u0196\5\30\r\2\u0195\u0189\3\2\2\2\u0195\u018c\3\2\2")
+        buf.write("\2\u0195\u018f\3\2\2\2\u0195\u0192\3\2\2\2\u0196\u0199")
+        buf.write("\3\2\2\2\u0197\u0195\3\2\2\2\u0197\u0198\3\2\2\2\u0198")
+        buf.write("\33\3\2\2\2\u0199\u0197\3\2\2\2\u019a\u019b\b\17\1\2\u019b")
+        buf.write("\u019c\5\32\16\2\u019c\u01a5\3\2\2\2\u019d\u019e\f\4\2")
+        buf.write("\2\u019e\u019f\7f\2\2\u019f\u01a4\5\32\16\2\u01a0\u01a1")
+        buf.write("\f\3\2\2\u01a1\u01a2\7g\2\2\u01a2\u01a4\5\32\16\2\u01a3")
+        buf.write("\u019d\3\2\2\2\u01a3\u01a0\3\2\2\2\u01a4\u01a7\3\2\2\2")
+        buf.write("\u01a5\u01a3\3\2\2\2\u01a5\u01a6\3\2\2\2\u01a6\35\3\2")
+        buf.write("\2\2\u01a7\u01a5\3\2\2\2\u01a8\u01a9\b\20\1\2\u01a9\u01aa")
+        buf.write("\5\34\17\2\u01aa\u01b0\3\2\2\2\u01ab\u01ac\f\3\2\2\u01ac")
+        buf.write("\u01ad\7P\2\2\u01ad\u01af\5\34\17\2\u01ae\u01ab\3\2\2")
+        buf.write("\2\u01af\u01b2\3\2\2\2\u01b0\u01ae\3\2\2\2\u01b0\u01b1")
+        buf.write("\3\2\2\2\u01b1\37\3\2\2\2\u01b2\u01b0\3\2\2\2\u01b3\u01b4")
+        buf.write("\b\21\1\2\u01b4\u01b5\5\36\20\2\u01b5\u01bb\3\2\2\2\u01b6")
+        buf.write("\u01b7\f\3\2\2\u01b7\u01b8\7T\2\2\u01b8\u01ba\5\36\20")
+        buf.write("\2\u01b9\u01b6\3\2\2\2\u01ba\u01bd\3\2\2\2\u01bb\u01b9")
+        buf.write("\3\2\2\2\u01bb\u01bc\3\2\2\2\u01bc!\3\2\2\2\u01bd\u01bb")
+        buf.write("\3\2\2\2\u01be\u01bf\b\22\1\2\u01bf\u01c0\5 \21\2\u01c0")
+        buf.write("\u01c6\3\2\2\2\u01c1\u01c2\f\3\2\2\u01c2\u01c3\7Q\2\2")
+        buf.write("\u01c3\u01c5\5 \21\2\u01c4\u01c1\3\2\2\2\u01c5\u01c8\3")
+        buf.write("\2\2\2\u01c6\u01c4\3\2\2\2\u01c6\u01c7\3\2\2\2\u01c7#")
+        buf.write("\3\2\2\2\u01c8\u01c6\3\2\2\2\u01c9\u01ca\b\23\1\2\u01ca")
+        buf.write("\u01cb\5\"\22\2\u01cb\u01d1\3\2\2\2\u01cc\u01cd\f\3\2")
+        buf.write("\2\u01cd\u01ce\7R\2\2\u01ce\u01d0\5\"\22\2\u01cf\u01cc")
+        buf.write("\3\2\2\2\u01d0\u01d3\3\2\2\2\u01d1\u01cf\3\2\2\2\u01d1")
+        buf.write("\u01d2\3\2\2\2\u01d2%\3\2\2\2\u01d3\u01d1\3\2\2\2\u01d4")
+        buf.write("\u01d5\b\24\1\2\u01d5\u01d6\5$\23\2\u01d6\u01dc\3\2\2")
+        buf.write("\2\u01d7\u01d8\f\3\2\2\u01d8\u01d9\7S\2\2\u01d9\u01db")
+        buf.write("\5$\23\2\u01da\u01d7\3\2\2\2\u01db\u01de\3\2\2\2\u01dc")
+        buf.write("\u01da\3\2\2\2\u01dc\u01dd\3\2\2\2\u01dd\'\3\2\2\2\u01de")
+        buf.write("\u01dc\3\2\2\2\u01df\u01e5\5&\24\2\u01e0\u01e1\7W\2\2")
+        buf.write("\u01e1\u01e2\5.\30\2\u01e2\u01e3\7X\2\2\u01e3\u01e4\5")
+        buf.write("(\25\2\u01e4\u01e6\3\2\2\2\u01e5\u01e0\3\2\2\2\u01e5\u01e6")
+        buf.write("\3\2\2\2\u01e6)\3\2\2\2\u01e7\u01ed\5(\25\2\u01e8\u01e9")
+        buf.write("\5\16\b\2\u01e9\u01ea\5,\27\2\u01ea\u01eb\5*\26\2\u01eb")
+        buf.write("\u01ed\3\2\2\2\u01ec\u01e7\3\2\2\2\u01ec\u01e8\3\2\2\2")
+        buf.write("\u01ed+\3\2\2\2\u01ee\u01ef\t\3\2\2\u01ef-\3\2\2\2\u01f0")
+        buf.write("\u01f1\b\30\1\2\u01f1\u01f2\5*\26\2\u01f2\u01f8\3\2\2")
+        buf.write("\2\u01f3\u01f4\f\3\2\2\u01f4\u01f5\7Z\2\2\u01f5\u01f7")
+        buf.write("\5*\26\2\u01f6\u01f3\3\2\2\2\u01f7\u01fa\3\2\2\2\u01f8")
+        buf.write("\u01f6\3\2\2\2\u01f8\u01f9\3\2\2\2\u01f9/\3\2\2\2\u01fa")
+        buf.write("\u01f8\3\2\2\2\u01fb\u01fc\5(\25\2\u01fc\61\3\2\2\2\u01fd")
+        buf.write("\u01ff\5\64\33\2\u01fe\u0200\5:\36\2\u01ff\u01fe\3\2\2")
+        buf.write("\2\u01ff\u0200\3\2\2\2\u0200\u0201\3\2\2\2\u0201\u0202")
+        buf.write("\7Y\2\2\u0202\u0205\3\2\2\2\u0203\u0205\5\u008cG\2\u0204")
+        buf.write("\u01fd\3\2\2\2\u0204\u0203\3\2\2\2\u0205\63\3\2\2\2\u0206")
+        buf.write("\u0208\58\35\2\u0207\u0206\3\2\2\2\u0208\u0209\3\2\2\2")
+        buf.write("\u0209\u0207\3\2\2\2\u0209\u020a\3\2\2\2\u020a\65\3\2")
+        buf.write("\2\2\u020b\u020d\58\35\2\u020c\u020b\3\2\2\2\u020d\u020e")
+        buf.write("\3\2\2\2\u020e\u020c\3\2\2\2\u020e\u020f\3\2\2\2\u020f")
+        buf.write("\67\3\2\2\2\u0210\u0216\5> \2\u0211\u0216\5@!\2\u0212")
+        buf.write("\u0216\5Z.\2\u0213\u0216\5\\/\2\u0214\u0216\5^\60\2\u0215")
+        buf.write("\u0210\3\2\2\2\u0215\u0211\3\2\2\2\u0215\u0212\3\2\2\2")
+        buf.write("\u0215\u0213\3\2\2\2\u0215\u0214\3\2\2\2\u02169\3\2\2")
+        buf.write("\2\u0217\u0218\b\36\1\2\u0218\u0219\5<\37\2\u0219\u021f")
+        buf.write("\3\2\2\2\u021a\u021b\f\3\2\2\u021b\u021c\7Z\2\2\u021c")
+        buf.write("\u021e\5<\37\2\u021d\u021a\3\2\2\2\u021e\u0221\3\2\2\2")
+        buf.write("\u021f\u021d\3\2\2\2\u021f\u0220\3\2\2\2\u0220;\3\2\2")
+        buf.write("\2\u0221\u021f\3\2\2\2\u0222\u0228\5`\61\2\u0223\u0224")
+        buf.write("\5`\61\2\u0224\u0225\7[\2\2\u0225\u0226\5\u0082B\2\u0226")
+        buf.write("\u0228\3\2\2\2\u0227\u0222\3\2\2\2\u0227\u0223\3\2\2\2")
+        buf.write("\u0228=\3\2\2\2\u0229\u022a\t\4\2\2\u022a?\3\2\2\2\u022b")
+        buf.write("\u023a\t\5\2\2\u022c\u022d\7\3\2\2\u022d\u022e\7=\2\2")
+        buf.write("\u022e\u022f\t\6\2\2\u022f\u023a\7>\2\2\u0230\u023a\5")
+        buf.write("X-\2\u0231\u023a\5B\"\2\u0232\u023a\5P)\2\u0233\u023a")
+        buf.write("\5\u0080A\2\u0234\u0235\7\t\2\2\u0235\u0236\7=\2\2\u0236")
+        buf.write("\u0237\5\60\31\2\u0237\u0238\7>\2\2\u0238\u023a\3\2\2")
+        buf.write("\2\u0239\u022b\3\2\2\2\u0239\u022c\3\2\2\2\u0239\u0230")
+        buf.write("\3\2\2\2\u0239\u0231\3\2\2\2\u0239\u0232\3\2\2\2\u0239")
+        buf.write("\u0233\3\2\2\2\u0239\u0234\3\2\2\2\u023aA\3\2\2\2\u023b")
+        buf.write("\u023d\5D#\2\u023c\u023e\7k\2\2\u023d\u023c\3\2\2\2\u023d")
+        buf.write("\u023e\3\2\2\2\u023e\u023f\3\2\2\2\u023f\u0240\7A\2\2")
+        buf.write("\u0240\u0241\5F$\2\u0241\u0242\7B\2\2\u0242\u0247\3\2")
+        buf.write("\2\2\u0243\u0244\5D#\2\u0244\u0245\7k\2\2\u0245\u0247")
+        buf.write("\3\2\2\2\u0246\u023b\3\2\2\2\u0246\u0243\3\2\2\2\u0247")
+        buf.write("C\3\2\2\2\u0248\u0249\t\7\2\2\u0249E\3\2\2\2\u024a\u024b")
+        buf.write("\b$\1\2\u024b\u024c\5H%\2\u024c\u0251\3\2\2\2\u024d\u024e")
+        buf.write("\f\3\2\2\u024e\u0250\5H%\2\u024f\u024d\3\2\2\2\u0250\u0253")
+        buf.write("\3\2\2\2\u0251\u024f\3\2\2\2\u0251\u0252\3\2\2\2\u0252")
+        buf.write("G\3\2\2\2\u0253\u0251\3\2\2\2\u0254\u0256\5J&\2\u0255")
+        buf.write("\u0257\5L\'\2\u0256\u0255\3\2\2\2\u0256\u0257\3\2\2\2")
+        buf.write("\u0257\u0258\3\2\2\2\u0258\u0259\7Y\2\2\u0259\u025c\3")
+        buf.write("\2\2\2\u025a\u025c\5\u008cG\2\u025b\u0254\3\2\2\2\u025b")
+        buf.write("\u025a\3\2\2\2\u025cI\3\2\2\2\u025d\u025f\5@!\2\u025e")
+        buf.write("\u0260\5J&\2\u025f\u025e\3\2\2\2\u025f\u0260\3\2\2\2\u0260")
+        buf.write("\u0266\3\2\2\2\u0261\u0263\5Z.\2\u0262\u0264\5J&\2\u0263")
+        buf.write("\u0262\3\2\2\2\u0263\u0264\3\2\2\2\u0264\u0266\3\2\2\2")
+        buf.write("\u0265\u025d\3\2\2\2\u0265\u0261\3\2\2\2\u0266K\3\2\2")
+        buf.write("\2\u0267\u0268\b\'\1\2\u0268\u0269\5N(\2\u0269\u026f\3")
+        buf.write("\2\2\2\u026a\u026b\f\3\2\2\u026b\u026c\7Z\2\2\u026c\u026e")
+        buf.write("\5N(\2\u026d\u026a\3\2\2\2\u026e\u0271\3\2\2\2\u026f\u026d")
+        buf.write("\3\2\2\2\u026f\u0270\3\2\2\2\u0270M\3\2\2\2\u0271\u026f")
+        buf.write("\3\2\2\2\u0272\u0279\5`\61\2\u0273\u0275\5`\61\2\u0274")
+        buf.write("\u0273\3\2\2\2\u0274\u0275\3\2\2\2\u0275\u0276\3\2\2\2")
+        buf.write("\u0276\u0277\7X\2\2\u0277\u0279\5\60\31\2\u0278\u0272")
+        buf.write("\3\2\2\2\u0278\u0274\3\2\2\2\u0279O\3\2\2\2\u027a\u027c")
+        buf.write("\7\33\2\2\u027b\u027d\7k\2\2\u027c\u027b\3\2\2\2\u027c")
+        buf.write("\u027d\3\2\2\2\u027d\u027e\3\2\2\2\u027e\u027f\7A\2\2")
+        buf.write("\u027f\u0280\5R*\2\u0280\u0281\7B\2\2\u0281\u028e\3\2")
+        buf.write("\2\2\u0282\u0284\7\33\2\2\u0283\u0285\7k\2\2\u0284\u0283")
+        buf.write("\3\2\2\2\u0284\u0285\3\2\2\2\u0285\u0286\3\2\2\2\u0286")
+        buf.write("\u0287\7A\2\2\u0287\u0288\5R*\2\u0288\u0289\7Z\2\2\u0289")
+        buf.write("\u028a\7B\2\2\u028a\u028e\3\2\2\2\u028b\u028c\7\33\2\2")
+        buf.write("\u028c\u028e\7k\2\2\u028d\u027a\3\2\2\2\u028d\u0282\3")
+        buf.write("\2\2\2\u028d\u028b\3\2\2\2\u028eQ\3\2\2\2\u028f\u0290")
+        buf.write("\b*\1\2\u0290\u0291\5T+\2\u0291\u0297\3\2\2\2\u0292\u0293")
+        buf.write("\f\3\2\2\u0293\u0294\7Z\2\2\u0294\u0296\5T+\2\u0295\u0292")
+        buf.write("\3\2\2\2\u0296\u0299\3\2\2\2\u0297\u0295\3\2\2\2\u0297")
+        buf.write("\u0298\3\2\2\2\u0298S\3\2\2\2\u0299\u0297\3\2\2\2\u029a")
+        buf.write("\u02a0\5V,\2\u029b\u029c\5V,\2\u029c\u029d\7[\2\2\u029d")
+        buf.write("\u029e\5\60\31\2\u029e\u02a0\3\2\2\2\u029f\u029a\3\2\2")
+        buf.write("\2\u029f\u029b\3\2\2\2\u02a0U\3\2\2\2\u02a1\u02a2\7k\2")
+        buf.write("\2\u02a2W\3\2\2\2\u02a3\u02a4\7\65\2\2\u02a4\u02a5\7=")
+        buf.write("\2\2\u02a5\u02a6\5z>\2\u02a6\u02a7\7>\2\2\u02a7Y\3\2\2")
+        buf.write("\2\u02a8\u02a9\t\b\2\2\u02a9[\3\2\2\2\u02aa\u02b1\t\t")
+        buf.write("\2\2\u02ab\u02b1\5f\64\2\u02ac\u02ad\7\f\2\2\u02ad\u02ae")
+        buf.write("\7=\2\2\u02ae\u02af\7k\2\2\u02af\u02b1\7>\2\2\u02b0\u02aa")
+        buf.write("\3\2\2\2\u02b0\u02ab\3\2\2\2\u02b0\u02ac\3\2\2\2\u02b1")
+        buf.write("]\3\2\2\2\u02b2\u02b3\7\63\2\2\u02b3\u02b4\7=\2\2\u02b4")
+        buf.write("\u02b5\5z>\2\u02b5\u02b6\7>\2\2\u02b6\u02bd\3\2\2\2\u02b7")
+        buf.write("\u02b8\7\63\2\2\u02b8\u02b9\7=\2\2\u02b9\u02ba\5\60\31")
+        buf.write("\2\u02ba\u02bb\7>\2\2\u02bb\u02bd\3\2\2\2\u02bc\u02b2")
+        buf.write("\3\2\2\2\u02bc\u02b7\3\2\2\2\u02bd_\3\2\2\2\u02be\u02c0")
+        buf.write("\5n8\2\u02bf\u02be\3\2\2\2\u02bf\u02c0\3\2\2\2\u02c0\u02c1")
+        buf.write("\3\2\2\2\u02c1\u02c5\5b\62\2\u02c2\u02c4\5d\63\2\u02c3")
+        buf.write("\u02c2\3\2\2\2\u02c4\u02c7\3\2\2\2\u02c5\u02c3\3\2\2\2")
+        buf.write("\u02c5\u02c6\3\2\2\2\u02c6a\3\2\2\2\u02c7\u02c5\3\2\2")
+        buf.write("\2\u02c8\u02c9\b\62\1\2\u02c9\u02cf\7k\2\2\u02ca\u02cb")
+        buf.write("\7=\2\2\u02cb\u02cc\5`\61\2\u02cc\u02cd\7>\2\2\u02cd\u02cf")
+        buf.write("\3\2\2\2\u02ce\u02c8\3\2\2\2\u02ce\u02ca\3\2\2\2\u02cf")
+        buf.write("\u02fd\3\2\2\2\u02d0\u02d1\f\b\2\2\u02d1\u02d3\7?\2\2")
+        buf.write("\u02d2\u02d4\5p9\2\u02d3\u02d2\3\2\2\2\u02d3\u02d4\3\2")
+        buf.write("\2\2\u02d4\u02d6\3\2\2\2\u02d5\u02d7\5*\26\2\u02d6\u02d5")
+        buf.write("\3\2\2\2\u02d6\u02d7\3\2\2\2\u02d7\u02d8\3\2\2\2\u02d8")
+        buf.write("\u02fc\7@\2\2\u02d9\u02da\f\7\2\2\u02da\u02db\7?\2\2\u02db")
+        buf.write("\u02dd\7*\2\2\u02dc\u02de\5p9\2\u02dd\u02dc\3\2\2\2\u02dd")
+        buf.write("\u02de\3\2\2\2\u02de\u02df\3\2\2\2\u02df\u02e0\5*\26\2")
+        buf.write("\u02e0\u02e1\7@\2\2\u02e1\u02fc\3\2\2\2\u02e2\u02e3\f")
+        buf.write("\6\2\2\u02e3\u02e4\7?\2\2\u02e4\u02e5\5p9\2\u02e5\u02e6")
+        buf.write("\7*\2\2\u02e6\u02e7\5*\26\2\u02e7\u02e8\7@\2\2\u02e8\u02fc")
+        buf.write("\3\2\2\2\u02e9\u02ea\f\5\2\2\u02ea\u02ec\7?\2\2\u02eb")
+        buf.write("\u02ed\5p9\2\u02ec\u02eb\3\2\2\2\u02ec\u02ed\3\2\2\2\u02ed")
+        buf.write("\u02ee\3\2\2\2\u02ee\u02ef\7M\2\2\u02ef\u02fc\7@\2\2\u02f0")
+        buf.write("\u02f1\f\4\2\2\u02f1\u02f2\7=\2\2\u02f2\u02f3\5r:\2\u02f3")
+        buf.write("\u02f4\7>\2\2\u02f4\u02fc\3\2\2\2\u02f5\u02f6\f\3\2\2")
+        buf.write("\u02f6\u02f8\7=\2\2\u02f7\u02f9\5x=\2\u02f8\u02f7\3\2")
+        buf.write("\2\2\u02f8\u02f9\3\2\2\2\u02f9\u02fa\3\2\2\2\u02fa\u02fc")
+        buf.write("\7>\2\2\u02fb\u02d0\3\2\2\2\u02fb\u02d9\3\2\2\2\u02fb")
+        buf.write("\u02e2\3\2\2\2\u02fb\u02e9\3\2\2\2\u02fb\u02f0\3\2\2\2")
+        buf.write("\u02fb\u02f5\3\2\2\2\u02fc\u02ff\3\2\2\2\u02fd\u02fb\3")
+        buf.write("\2\2\2\u02fd\u02fe\3\2\2\2\u02fec\3\2\2\2\u02ff\u02fd")
+        buf.write("\3\2\2\2\u0300\u0301\7\r\2\2\u0301\u0303\7=\2\2\u0302")
+        buf.write("\u0304\7m\2\2\u0303\u0302\3\2\2\2\u0304\u0305\3\2\2\2")
+        buf.write("\u0305\u0303\3\2\2\2\u0305\u0306\3\2\2\2\u0306\u0307\3")
+        buf.write("\2\2\2\u0307\u030a\7>\2\2\u0308\u030a\5f\64\2\u0309\u0300")
+        buf.write("\3\2\2\2\u0309\u0308\3\2\2\2\u030ae\3\2\2\2\u030b\u030c")
+        buf.write("\7\16\2\2\u030c\u030d\7=\2\2\u030d\u030e\7=\2\2\u030e")
+        buf.write("\u030f\5h\65\2\u030f\u0310\7>\2\2\u0310\u0311\7>\2\2\u0311")
+        buf.write("g\3\2\2\2\u0312\u0317\5j\66\2\u0313\u0314\7Z\2\2\u0314")
+        buf.write("\u0316\5j\66\2\u0315\u0313\3\2\2\2\u0316\u0319\3\2\2\2")
+        buf.write("\u0317\u0315\3\2\2\2\u0317\u0318\3\2\2\2\u0318\u031c\3")
+        buf.write("\2\2\2\u0319\u0317\3\2\2\2\u031a\u031c\3\2\2\2\u031b\u0312")
+        buf.write("\3\2\2\2\u031b\u031a\3\2\2\2\u031ci\3\2\2\2\u031d\u0323")
+        buf.write("\n\n\2\2\u031e\u0320\7=\2\2\u031f\u0321\5\f\7\2\u0320")
+        buf.write("\u031f\3\2\2\2\u0320\u0321\3\2\2\2\u0321\u0322\3\2\2\2")
+        buf.write("\u0322\u0324\7>\2\2\u0323\u031e\3\2\2\2\u0323\u0324\3")
+        buf.write("\2\2\2\u0324\u0327\3\2\2\2\u0325\u0327\3\2\2\2\u0326\u031d")
+        buf.write("\3\2\2\2\u0326\u0325\3\2\2\2\u0327k\3\2\2\2\u0328\u032e")
+        buf.write("\n\13\2\2\u0329\u032a\7=\2\2\u032a\u032b\5l\67\2\u032b")
+        buf.write("\u032c\7>\2\2\u032c\u032e\3\2\2\2\u032d\u0328\3\2\2\2")
+        buf.write("\u032d\u0329\3\2\2\2\u032e\u0331\3\2\2\2\u032f\u032d\3")
+        buf.write("\2\2\2\u032f\u0330\3\2\2\2\u0330m\3\2\2\2\u0331\u032f")
+        buf.write("\3\2\2\2\u0332\u0334\7M\2\2\u0333\u0335\5p9\2\u0334\u0333")
+        buf.write("\3\2\2\2\u0334\u0335\3\2\2\2\u0335\u0345\3\2\2\2\u0336")
+        buf.write("\u0338\7M\2\2\u0337\u0339\5p9\2\u0338\u0337\3\2\2\2\u0338")
+        buf.write("\u0339\3\2\2\2\u0339\u033a\3\2\2\2\u033a\u0345\5n8\2\u033b")
+        buf.write("\u033d\7T\2\2\u033c\u033e\5p9\2\u033d\u033c\3\2\2\2\u033d")
+        buf.write("\u033e\3\2\2\2\u033e\u0345\3\2\2\2\u033f\u0341\7T\2\2")
+        buf.write("\u0340\u0342\5p9\2\u0341\u0340\3\2\2\2\u0341\u0342\3\2")
+        buf.write("\2\2\u0342\u0343\3\2\2\2\u0343\u0345\5n8\2\u0344\u0332")
+        buf.write("\3\2\2\2\u0344\u0336\3\2\2\2\u0344\u033b\3\2\2\2\u0344")
+        buf.write("\u033f\3\2\2\2\u0345o\3\2\2\2\u0346\u0347\b9\1\2\u0347")
+        buf.write("\u0348\5Z.\2\u0348\u034d\3\2\2\2\u0349\u034a\f\3\2\2\u034a")
+        buf.write("\u034c\5Z.\2\u034b\u0349\3\2\2\2\u034c\u034f\3\2\2\2\u034d")
+        buf.write("\u034b\3\2\2\2\u034d\u034e\3\2\2\2\u034eq\3\2\2\2\u034f")
+        buf.write("\u034d\3\2\2\2\u0350\u0356\5t;\2\u0351\u0352\5t;\2\u0352")
+        buf.write("\u0353\7Z\2\2\u0353\u0354\7j\2\2\u0354\u0356\3\2\2\2\u0355")
+        buf.write("\u0350\3\2\2\2\u0355\u0351\3\2\2\2\u0356s\3\2\2\2\u0357")
+        buf.write("\u0358\b;\1\2\u0358\u0359\5v<\2\u0359\u035f\3\2\2\2\u035a")
+        buf.write("\u035b\f\3\2\2\u035b\u035c\7Z\2\2\u035c\u035e\5v<\2\u035d")
+        buf.write("\u035a\3\2\2\2\u035e\u0361\3\2\2\2\u035f\u035d\3\2\2\2")
+        buf.write("\u035f\u0360\3\2\2\2\u0360u\3\2\2\2\u0361\u035f\3\2\2")
+        buf.write("\2\u0362\u0363\5\64\33\2\u0363\u0364\5`\61\2\u0364\u036a")
+        buf.write("\3\2\2\2\u0365\u0367\5\66\34\2\u0366\u0368\5|?\2\u0367")
+        buf.write("\u0366\3\2\2\2\u0367\u0368\3\2\2\2\u0368\u036a\3\2\2\2")
+        buf.write("\u0369\u0362\3\2\2\2\u0369\u0365\3\2\2\2\u036aw\3\2\2")
+        buf.write("\2\u036b\u036c\b=\1\2\u036c\u036d\7k\2\2\u036d\u0373\3")
+        buf.write("\2\2\2\u036e\u036f\f\3\2\2\u036f\u0370\7Z\2\2\u0370\u0372")
+        buf.write("\7k\2\2\u0371\u036e\3\2\2\2\u0372\u0375\3\2\2\2\u0373")
+        buf.write("\u0371\3\2\2\2\u0373\u0374\3\2\2\2\u0374y\3\2\2\2\u0375")
+        buf.write("\u0373\3\2\2\2\u0376\u0378\5J&\2\u0377\u0379\5|?\2\u0378")
+        buf.write("\u0377\3\2\2\2\u0378\u0379\3\2\2\2\u0379{\3\2\2\2\u037a")
+        buf.write("\u0386\5n8\2\u037b\u037d\5n8\2\u037c\u037b\3\2\2\2\u037c")
+        buf.write("\u037d\3\2\2\2\u037d\u037e\3\2\2\2\u037e\u0382\5~@\2\u037f")
+        buf.write("\u0381\5d\63\2\u0380\u037f\3\2\2\2\u0381\u0384\3\2\2\2")
+        buf.write("\u0382\u0380\3\2\2\2\u0382\u0383\3\2\2\2\u0383\u0386\3")
+        buf.write("\2\2\2\u0384\u0382\3\2\2\2\u0385\u037a\3\2\2\2\u0385\u037c")
+        buf.write("\3\2\2\2\u0386}\3\2\2\2\u0387\u0388\b@\1\2\u0388\u0389")
+        buf.write("\7=\2\2\u0389\u038a\5|?\2\u038a\u038e\7>\2\2\u038b\u038d")
+        buf.write("\5d\63\2\u038c\u038b\3\2\2\2\u038d\u0390\3\2\2\2\u038e")
+        buf.write("\u038c\3\2\2\2\u038e\u038f\3\2\2\2\u038f\u03b6\3\2\2\2")
+        buf.write("\u0390\u038e\3\2\2\2\u0391\u0393\7?\2\2\u0392\u0394\5")
+        buf.write("p9\2\u0393\u0392\3\2\2\2\u0393\u0394\3\2\2\2\u0394\u0396")
+        buf.write("\3\2\2\2\u0395\u0397\5*\26\2\u0396\u0395\3\2\2\2\u0396")
+        buf.write("\u0397\3\2\2\2\u0397\u0398\3\2\2\2\u0398\u03b6\7@\2\2")
+        buf.write("\u0399\u039a\7?\2\2\u039a\u039c\7*\2\2\u039b\u039d\5p")
+        buf.write("9\2\u039c\u039b\3\2\2\2\u039c\u039d\3\2\2\2\u039d\u039e")
+        buf.write("\3\2\2\2\u039e\u039f\5*\26\2\u039f\u03a0\7@\2\2\u03a0")
+        buf.write("\u03b6\3\2\2\2\u03a1\u03a2\7?\2\2\u03a2\u03a3\5p9\2\u03a3")
+        buf.write("\u03a4\7*\2\2\u03a4\u03a5\5*\26\2\u03a5\u03a6\7@\2\2\u03a6")
+        buf.write("\u03b6\3\2\2\2\u03a7\u03a8\7?\2\2\u03a8\u03a9\7M\2\2\u03a9")
+        buf.write("\u03b6\7@\2\2\u03aa\u03ac\7=\2\2\u03ab\u03ad\5r:\2\u03ac")
+        buf.write("\u03ab\3\2\2\2\u03ac\u03ad\3\2\2\2\u03ad\u03ae\3\2\2\2")
+        buf.write("\u03ae\u03b2\7>\2\2\u03af\u03b1\5d\63\2\u03b0\u03af\3")
+        buf.write("\2\2\2\u03b1\u03b4\3\2\2\2\u03b2\u03b0\3\2\2\2\u03b2\u03b3")
+        buf.write("\3\2\2\2\u03b3\u03b6\3\2\2\2\u03b4\u03b2\3\2\2\2\u03b5")
+        buf.write("\u0387\3\2\2\2\u03b5\u0391\3\2\2\2\u03b5\u0399\3\2\2\2")
+        buf.write("\u03b5\u03a1\3\2\2\2\u03b5\u03a7\3\2\2\2\u03b5\u03aa\3")
+        buf.write("\2\2\2\u03b6\u03e2\3\2\2\2\u03b7\u03b8\f\7\2\2\u03b8\u03ba")
+        buf.write("\7?\2\2\u03b9\u03bb\5p9\2\u03ba\u03b9\3\2\2\2\u03ba\u03bb")
+        buf.write("\3\2\2\2\u03bb\u03bd\3\2\2\2\u03bc\u03be\5*\26\2\u03bd")
+        buf.write("\u03bc\3\2\2\2\u03bd\u03be\3\2\2\2\u03be\u03bf\3\2\2\2")
+        buf.write("\u03bf\u03e1\7@\2\2\u03c0\u03c1\f\6\2\2\u03c1\u03c2\7")
+        buf.write("?\2\2\u03c2\u03c4\7*\2\2\u03c3\u03c5\5p9\2\u03c4\u03c3")
+        buf.write("\3\2\2\2\u03c4\u03c5\3\2\2\2\u03c5\u03c6\3\2\2\2\u03c6")
+        buf.write("\u03c7\5*\26\2\u03c7\u03c8\7@\2\2\u03c8\u03e1\3\2\2\2")
+        buf.write("\u03c9\u03ca\f\5\2\2\u03ca\u03cb\7?\2\2\u03cb\u03cc\5")
+        buf.write("p9\2\u03cc\u03cd\7*\2\2\u03cd\u03ce\5*\26\2\u03ce\u03cf")
+        buf.write("\7@\2\2\u03cf\u03e1\3\2\2\2\u03d0\u03d1\f\4\2\2\u03d1")
+        buf.write("\u03d2\7?\2\2\u03d2\u03d3\7M\2\2\u03d3\u03e1\7@\2\2\u03d4")
+        buf.write("\u03d5\f\3\2\2\u03d5\u03d7\7=\2\2\u03d6\u03d8\5r:\2\u03d7")
+        buf.write("\u03d6\3\2\2\2\u03d7\u03d8\3\2\2\2\u03d8\u03d9\3\2\2\2")
+        buf.write("\u03d9\u03dd\7>\2\2\u03da\u03dc\5d\63\2\u03db\u03da\3")
+        buf.write("\2\2\2\u03dc\u03df\3\2\2\2\u03dd\u03db\3\2\2\2\u03dd\u03de")
+        buf.write("\3\2\2\2\u03de\u03e1\3\2\2\2\u03df\u03dd\3\2\2\2\u03e0")
+        buf.write("\u03b7\3\2\2\2\u03e0\u03c0\3\2\2\2\u03e0\u03c9\3\2\2\2")
+        buf.write("\u03e0\u03d0\3\2\2\2\u03e0\u03d4\3\2\2\2\u03e1\u03e4\3")
+        buf.write("\2\2\2\u03e2\u03e0\3\2\2\2\u03e2\u03e3\3\2\2\2\u03e3\177")
+        buf.write("\3\2\2\2\u03e4\u03e2\3\2\2\2\u03e5\u03e6\7k\2\2\u03e6")
+        buf.write("\u0081\3\2\2\2\u03e7\u03f2\5*\26\2\u03e8\u03e9\7A\2\2")
+        buf.write("\u03e9\u03ea\5\u0084C\2\u03ea\u03eb\7B\2\2\u03eb\u03f2")
+        buf.write("\3\2\2\2\u03ec\u03ed\7A\2\2\u03ed\u03ee\5\u0084C\2\u03ee")
+        buf.write("\u03ef\7Z\2\2\u03ef\u03f0\7B\2\2\u03f0\u03f2\3\2\2\2\u03f1")
+        buf.write("\u03e7\3\2\2\2\u03f1\u03e8\3\2\2\2\u03f1\u03ec\3\2\2\2")
+        buf.write("\u03f2\u0083\3\2\2\2\u03f3\u03f5\bC\1\2\u03f4\u03f6\5")
+        buf.write("\u0086D\2\u03f5\u03f4\3\2\2\2\u03f5\u03f6\3\2\2\2\u03f6")
+        buf.write("\u03f7\3\2\2\2\u03f7\u03f8\5\u0082B\2\u03f8\u0401\3\2")
+        buf.write("\2\2\u03f9\u03fa\f\3\2\2\u03fa\u03fc\7Z\2\2\u03fb\u03fd")
+        buf.write("\5\u0086D\2\u03fc\u03fb\3\2\2\2\u03fc\u03fd\3\2\2\2\u03fd")
+        buf.write("\u03fe\3\2\2\2\u03fe\u0400\5\u0082B\2\u03ff\u03f9\3\2")
+        buf.write("\2\2\u0400\u0403\3\2\2\2\u0401\u03ff\3\2\2\2\u0401\u0402")
+        buf.write("\3\2\2\2\u0402\u0085\3\2\2\2\u0403\u0401\3\2\2\2\u0404")
+        buf.write("\u0405\5\u0088E\2\u0405\u0406\7[\2\2\u0406\u0087\3\2\2")
+        buf.write("\2\u0407\u0408\bE\1\2\u0408\u0409\5\u008aF\2\u0409\u040e")
+        buf.write("\3\2\2\2\u040a\u040b\f\3\2\2\u040b\u040d\5\u008aF\2\u040c")
+        buf.write("\u040a\3\2\2\2\u040d\u0410\3\2\2\2\u040e\u040c\3\2\2\2")
+        buf.write("\u040e\u040f\3\2\2\2\u040f\u0089\3\2\2\2\u0410\u040e\3")
+        buf.write("\2\2\2\u0411\u0412\7?\2\2\u0412\u0413\5\60\31\2\u0413")
+        buf.write("\u0414\7@\2\2\u0414\u0418\3\2\2\2\u0415\u0416\7i\2\2\u0416")
+        buf.write("\u0418\7k\2\2\u0417\u0411\3\2\2\2\u0417\u0415\3\2\2\2")
+        buf.write("\u0418\u008b\3\2\2\2\u0419\u041a\7;\2\2\u041a\u041b\7")
+        buf.write("=\2\2\u041b\u041c\5\60\31\2\u041c\u041e\7Z\2\2\u041d\u041f")
+        buf.write("\7m\2\2\u041e\u041d\3\2\2\2\u041f\u0420\3\2\2\2\u0420")
+        buf.write("\u041e\3\2\2\2\u0420\u0421\3\2\2\2\u0421\u0422\3\2\2\2")
+        buf.write("\u0422\u0423\7>\2\2\u0423\u0424\7Y\2\2\u0424\u008d\3\2")
+        buf.write("\2\2\u0425\u044b\5\u0090I\2\u0426\u044b\5\u0092J\2\u0427")
+        buf.write("\u044b\5\u0098M\2\u0428\u044b\5\u009aN\2\u0429\u044b\5")
+        buf.write("\u009cO\2\u042a\u044b\5\u009eP\2\u042b\u042c\t\f\2\2\u042c")
+        buf.write("\u042d\t\r\2\2\u042d\u0436\7=\2\2\u042e\u0433\5&\24\2")
+        buf.write("\u042f\u0430\7Z\2\2\u0430\u0432\5&\24\2\u0431\u042f\3")
+        buf.write("\2\2\2\u0432\u0435\3\2\2\2\u0433\u0431\3\2\2\2\u0433\u0434")
+        buf.write("\3\2\2\2\u0434\u0437\3\2\2\2\u0435\u0433\3\2\2\2\u0436")
+        buf.write("\u042e\3\2\2\2\u0436\u0437\3\2\2\2\u0437\u0445\3\2\2\2")
+        buf.write("\u0438\u0441\7X\2\2\u0439\u043e\5&\24\2\u043a\u043b\7")
+        buf.write("Z\2\2\u043b\u043d\5&\24\2\u043c\u043a\3\2\2\2\u043d\u0440")
+        buf.write("\3\2\2\2\u043e\u043c\3\2\2\2\u043e\u043f\3\2\2\2\u043f")
+        buf.write("\u0442\3\2\2\2\u0440\u043e\3\2\2\2\u0441\u0439\3\2\2\2")
+        buf.write("\u0441\u0442\3\2\2\2\u0442\u0444\3\2\2\2\u0443\u0438\3")
+        buf.write("\2\2\2\u0444\u0447\3\2\2\2\u0445\u0443\3\2\2\2\u0445\u0446")
+        buf.write("\3\2\2\2\u0446\u0448\3\2\2\2\u0447\u0445\3\2\2\2\u0448")
+        buf.write("\u0449\7>\2\2\u0449\u044b\7Y\2\2\u044a\u0425\3\2\2\2\u044a")
+        buf.write("\u0426\3\2\2\2\u044a\u0427\3\2\2\2\u044a\u0428\3\2\2\2")
+        buf.write("\u044a\u0429\3\2\2\2\u044a\u042a\3\2\2\2\u044a\u042b\3")
+        buf.write("\2\2\2\u044b\u008f\3\2\2\2\u044c\u044d\7k\2\2\u044d\u044e")
+        buf.write("\7X\2\2\u044e\u0458\5\u008eH\2\u044f\u0450\7\23\2\2\u0450")
+        buf.write("\u0451\5\60\31\2\u0451\u0452\7X\2\2\u0452\u0453\5\u008e")
+        buf.write("H\2\u0453\u0458\3\2\2\2\u0454\u0455\7\27\2\2\u0455\u0456")
+        buf.write("\7X\2\2\u0456\u0458\5\u008eH\2\u0457\u044c\3\2\2\2\u0457")
+        buf.write("\u044f\3\2\2\2\u0457\u0454\3\2\2\2\u0458\u0091\3\2\2\2")
+        buf.write("\u0459\u045b\7A\2\2\u045a\u045c\5\u0094K\2\u045b\u045a")
+        buf.write("\3\2\2\2\u045b\u045c\3\2\2\2\u045c\u045d\3\2\2\2\u045d")
+        buf.write("\u045e\7B\2\2\u045e\u0093\3\2\2\2\u045f\u0460\bK\1\2\u0460")
+        buf.write("\u0461\5\u0096L\2\u0461\u0466\3\2\2\2\u0462\u0463\f\3")
+        buf.write("\2\2\u0463\u0465\5\u0096L\2\u0464\u0462\3\2\2\2\u0465")
+        buf.write("\u0468\3\2\2\2\u0466\u0464\3\2\2\2\u0466\u0467\3\2\2\2")
+        buf.write("\u0467\u0095\3\2\2\2\u0468\u0466\3\2\2\2\u0469\u046c\5")
+        buf.write("\62\32\2\u046a\u046c\5\u008eH\2\u046b\u0469\3\2\2\2\u046b")
+        buf.write("\u046a\3\2\2\2\u046c\u0097\3\2\2\2\u046d\u046f\5.\30\2")
+        buf.write("\u046e\u046d\3\2\2\2\u046e\u046f\3\2\2\2\u046f\u0470\3")
+        buf.write("\2\2\2\u0470\u0471\7Y\2\2\u0471\u0099\3\2\2\2\u0472\u0473")
+        buf.write("\7 \2\2\u0473\u0474\7=\2\2\u0474\u0475\5.\30\2\u0475\u0476")
+        buf.write("\7>\2\2\u0476\u0479\5\u008eH\2\u0477\u0478\7\32\2\2\u0478")
+        buf.write("\u047a\5\u008eH\2\u0479\u0477\3\2\2\2\u0479\u047a\3\2")
+        buf.write("\2\2\u047a\u0482\3\2\2\2\u047b\u047c\7,\2\2\u047c\u047d")
+        buf.write("\7=\2\2\u047d\u047e\5.\30\2\u047e\u047f\7>\2\2\u047f\u0480")
+        buf.write("\5\u008eH\2\u0480\u0482\3\2\2\2\u0481\u0472\3\2\2\2\u0481")
+        buf.write("\u047b\3\2\2\2\u0482\u009b\3\2\2\2\u0483\u0484\7\62\2")
+        buf.write("\2\u0484\u0485\7=\2\2\u0485\u0486\5.\30\2\u0486\u0487")
+        buf.write("\7>\2\2\u0487\u0488\5\u008eH\2\u0488\u04ae\3\2\2\2\u0489")
+        buf.write("\u048a\7\30\2\2\u048a\u048b\5\u008eH\2\u048b\u048c\7\62")
+        buf.write("\2\2\u048c\u048d\7=\2\2\u048d\u048e\5.\30\2\u048e\u048f")
+        buf.write("\7>\2\2\u048f\u0490\7Y\2\2\u0490\u04ae\3\2\2\2\u0491\u0492")
+        buf.write("\7\36\2\2\u0492\u0494\7=\2\2\u0493\u0495\5.\30\2\u0494")
+        buf.write("\u0493\3\2\2\2\u0494\u0495\3\2\2\2\u0495\u0496\3\2\2\2")
+        buf.write("\u0496\u0498\7Y\2\2\u0497\u0499\5.\30\2\u0498\u0497\3")
+        buf.write("\2\2\2\u0498\u0499\3\2\2\2\u0499\u049a\3\2\2\2\u049a\u049c")
+        buf.write("\7Y\2\2\u049b\u049d\5.\30\2\u049c\u049b\3\2\2\2\u049c")
+        buf.write("\u049d\3\2\2\2\u049d\u049e\3\2\2\2\u049e\u049f\7>\2\2")
+        buf.write("\u049f\u04ae\5\u008eH\2\u04a0\u04a1\7\36\2\2\u04a1\u04a2")
+        buf.write("\7=\2\2\u04a2\u04a4\5\62\32\2\u04a3\u04a5\5.\30\2\u04a4")
+        buf.write("\u04a3\3\2\2\2\u04a4\u04a5\3\2\2\2\u04a5\u04a6\3\2\2\2")
+        buf.write("\u04a6\u04a8\7Y\2\2\u04a7\u04a9\5.\30\2\u04a8\u04a7\3")
+        buf.write("\2\2\2\u04a8\u04a9\3\2\2\2\u04a9\u04aa\3\2\2\2\u04aa\u04ab")
+        buf.write("\7>\2\2\u04ab\u04ac\5\u008eH\2\u04ac\u04ae\3\2\2\2\u04ad")
+        buf.write("\u0483\3\2\2\2\u04ad\u0489\3\2\2\2\u04ad\u0491\3\2\2\2")
+        buf.write("\u04ad\u04a0\3\2\2\2\u04ae\u009d\3\2\2\2\u04af\u04b0\7")
+        buf.write("\37\2\2\u04b0\u04b1\7k\2\2\u04b1\u04c0\7Y\2\2\u04b2\u04b3")
+        buf.write("\7\26\2\2\u04b3\u04c0\7Y\2\2\u04b4\u04b5\7\22\2\2\u04b5")
+        buf.write("\u04c0\7Y\2\2\u04b6\u04b8\7&\2\2\u04b7\u04b9\5.\30\2\u04b8")
+        buf.write("\u04b7\3\2\2\2\u04b8\u04b9\3\2\2\2\u04b9\u04ba\3\2\2\2")
+        buf.write("\u04ba\u04c0\7Y\2\2\u04bb\u04bc\7\37\2\2\u04bc\u04bd\5")
+        buf.write("\16\b\2\u04bd\u04be\7Y\2\2\u04be\u04c0\3\2\2\2\u04bf\u04af")
+        buf.write("\3\2\2\2\u04bf\u04b2\3\2\2\2\u04bf\u04b4\3\2\2\2\u04bf")
+        buf.write("\u04b6\3\2\2\2\u04bf\u04bb\3\2\2\2\u04c0\u009f\3\2\2\2")
+        buf.write("\u04c1\u04c3\5\u00a2R\2\u04c2\u04c1\3\2\2\2\u04c2\u04c3")
+        buf.write("\3\2\2\2\u04c3\u04c4\3\2\2\2\u04c4\u04c5\7\2\2\3\u04c5")
+        buf.write("\u00a1\3\2\2\2\u04c6\u04c7\bR\1\2\u04c7\u04c8\5\u00a4")
+        buf.write("S\2\u04c8\u04cd\3\2\2\2\u04c9\u04ca\f\3\2\2\u04ca\u04cc")
+        buf.write("\5\u00a4S\2\u04cb\u04c9\3\2\2\2\u04cc\u04cf\3\2\2\2\u04cd")
+        buf.write("\u04cb\3\2\2\2\u04cd\u04ce\3\2\2\2\u04ce\u00a3\3\2\2\2")
+        buf.write("\u04cf\u04cd\3\2\2\2\u04d0\u04d4\5\u00a6T\2\u04d1\u04d4")
+        buf.write("\5\62\32\2\u04d2\u04d4\7Y\2\2\u04d3\u04d0\3\2\2\2\u04d3")
+        buf.write("\u04d1\3\2\2\2\u04d3\u04d2\3\2\2\2\u04d4\u00a5\3\2\2\2")
+        buf.write("\u04d5\u04d7\5\64\33\2\u04d6\u04d5\3\2\2\2\u04d6\u04d7")
+        buf.write("\3\2\2\2\u04d7\u04d8\3\2\2\2\u04d8\u04da\5`\61\2\u04d9")
+        buf.write("\u04db\5\u00a8U\2\u04da\u04d9\3\2\2\2\u04da\u04db\3\2")
+        buf.write("\2\2\u04db\u04dc\3\2\2\2\u04dc\u04dd\5\u0092J\2\u04dd")
+        buf.write("\u00a7\3\2\2\2\u04de\u04df\bU\1\2\u04df\u04e0\5\62\32")
+        buf.write("\2\u04e0\u04e5\3\2\2\2\u04e1\u04e2\f\3\2\2\u04e2\u04e4")
+        buf.write("\5\62\32\2\u04e3\u04e1\3\2\2\2\u04e4\u04e7\3\2\2\2\u04e5")
+        buf.write("\u04e3\3\2\2\2\u04e5\u04e6\3\2\2\2\u04e6\u00a9\3\2\2\2")
+        buf.write("\u04e7\u04e5\3\2\2\2\u008c\u00af\u00b7\u00cb\u00dc\u00e6")
+        buf.write("\u010a\u0114\u0121\u0123\u012e\u0147\u0157\u0165\u0167")
+        buf.write("\u0173\u0175\u0181\u0183\u0195\u0197\u01a3\u01a5\u01b0")
+        buf.write("\u01bb\u01c6\u01d1\u01dc\u01e5\u01ec\u01f8\u01ff\u0204")
+        buf.write("\u0209\u020e\u0215\u021f\u0227\u0239\u023d\u0246\u0251")
+        buf.write("\u0256\u025b\u025f\u0263\u0265\u026f\u0274\u0278\u027c")
+        buf.write("\u0284\u028d\u0297\u029f\u02b0\u02bc\u02bf\u02c5\u02ce")
+        buf.write("\u02d3\u02d6\u02dd\u02ec\u02f8\u02fb\u02fd\u0305\u0309")
+        buf.write("\u0317\u031b\u0320\u0323\u0326\u032d\u032f\u0334\u0338")
+        buf.write("\u033d\u0341\u0344\u034d\u0355\u035f\u0367\u0369\u0373")
+        buf.write("\u0378\u037c\u0382\u0385\u038e\u0393\u0396\u039c\u03ac")
+        buf.write("\u03b2\u03b5\u03ba\u03bd\u03c4\u03d7\u03dd\u03e0\u03e2")
+        buf.write("\u03f1\u03f5\u03fc\u0401\u040e\u0417\u0420\u0433\u0436")
+        buf.write("\u043e\u0441\u0445\u044a\u0457\u045b\u0466\u046b\u046e")
+        buf.write("\u0479\u0481\u0494\u0498\u049c\u04a4\u04a8\u04ad\u04b8")
+        buf.write("\u04bf\u04c2\u04cd\u04d3\u04d6\u04da\u04e5")
+        return buf.getvalue()
+
+
+class CParser ( Parser ):
+
+    grammarFileName = "C.bnf"
+
+    atn = ATNDeserializer().deserialize(serializedATN())
+
+    decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
+
+    sharedContextCache = PredictionContextCache()
+
+    literalNames = [ "<INVALID>", "'__extension__'", "'__builtin_va_arg'",
+                     "'__builtin_offsetof'", "'__m128'", "'__m128d'", "'__m128i'",
+                     "'__typeof__'", "'__inline__'", "'__stdcall'", "'__declspec'",
+                     "'__asm'", "'__attribute__'", "'__asm__'", "'__volatile__'",
+                     "'auto'", "'break'", "'case'", "'char'", "'const'",
+                     "'continue'", "'default'", "'do'", "'double'", "'else'",
+                     "'enum'", "'extern'", "'float'", "'for'", "'goto'",
+                     "'if'", "'inline'", "'int'", "'long'", "'register'",
+                     "'restrict'", "'return'", "'short'", "'signed'", "'sizeof'",
+                     "'static'", "'struct'", "'switch'", "'typedef'", "'union'",
+                     "'unsigned'", "'void'", "'volatile'", "'while'", "'_Alignas'",
+                     "'_Alignof'", "'_Atomic'", "'_Bool'", "'_Complex'",
+                     "'_Generic'", "'_Imaginary'", "'_Noreturn'", "'_Static_assert'",
+                     "'_Thread_local'", "'('", "')'", "'['", "']'", "'{'",
+                     "'}'", "'<'", "'<='", "'>'", "'>='", "'<<'", "'>>'",
+                     "'+'", "'++'", "'-'", "'--'", "'*'", "'/'", "'%'",
+                     "'&'", "'|'", "'&&'", "'||'", "'^'", "'!'", "'~'",
+                     "'?'", "':'", "';'", "','", "'='", "'*='", "'/='",
+                     "'%='", "'+='", "'-='", "'<<='", "'>>='", "'&='", "'^='",
+                     "'|='", "'=='", "'!='", "'->'", "'.'", "'...'" ]
+
+    symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
+                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
+                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
+                      "<INVALID>", "<INVALID>", "<INVALID>", "Auto", "Break",
+                      "Case", "Char", "Const", "Continue", "Default", "Do",
+                      "Double", "Else", "Enum", "Extern", "Float", "For",
+                      "Goto", "If", "Inline", "Int", "Long", "Register",
+                      "Restrict", "Return", "Short", "Signed", "Sizeof",
+                      "Static", "Struct", "Switch", "Typedef", "Union",
+                      "Unsigned", "Void", "Volatile", "While", "Alignas",
+                      "Alignof", "Atomic", "Bool", "Complex", "Generic",
+                      "Imaginary", "Noreturn", "StaticAssert", "ThreadLocal",
+                      "LeftParen", "RightParen", "LeftBracket", "RightBracket",
+                      "LeftBrace", "RightBrace", "Less", "LessEqual", "Greater",
+                      "GreaterEqual", "LeftShift", "RightShift", "Plus",
+                      "PlusPlus", "Minus", "MinusMinus", "Star", "Div",
+                      "Mod", "And", "Or", "AndAnd", "OrOr", "Caret", "Not",
+                      "Tilde", "Question", "Colon", "Semi", "Comma", "Assign",
+                      "StarAssign", "DivAssign", "ModAssign", "PlusAssign",
+                      "MinusAssign", "LeftShiftAssign", "RightShiftAssign",
+                      "AndAssign", "XorAssign", "OrAssign", "Equal", "NotEqual",
+                      "Arrow", "Dot", "Ellipsis", "Identifier", "Constant",
+                      "StringLiteral", "LineDirective", "PragmaDirective",
+                      "Whitespace", "Newline", "BlockComment", "LineComment" ]
+
+    RULE_primaryExpression = 0
+    RULE_genericSelection = 1
+    RULE_genericAssocList = 2
+    RULE_genericAssociation = 3
+    RULE_postfixExpression = 4
+    RULE_argumentExpressionList = 5
+    RULE_unaryExpression = 6
+    RULE_unaryOperator = 7
+    RULE_castExpression = 8
+    RULE_multiplicativeExpression = 9
+    RULE_additiveExpression = 10
+    RULE_shiftExpression = 11
+    RULE_relationalExpression = 12
+    RULE_equalityExpression = 13
+    RULE_andExpression = 14
+    RULE_exclusiveOrExpression = 15
+    RULE_inclusiveOrExpression = 16
+    RULE_logicalAndExpression = 17
+    RULE_logicalOrExpression = 18
+    RULE_conditionalExpression = 19
+    RULE_assignmentExpression = 20
+    RULE_assignmentOperator = 21
+    RULE_expression = 22
+    RULE_constantExpression = 23
+    RULE_declaration = 24
+    RULE_declarationSpecifiers = 25
+    RULE_declarationSpecifiers2 = 26
+    RULE_declarationSpecifier = 27
+    RULE_initDeclaratorList = 28
+    RULE_initDeclarator = 29
+    RULE_storageClassSpecifier = 30
+    RULE_typeSpecifier = 31
+    RULE_structOrUnionSpecifier = 32
+    RULE_structOrUnion = 33
+    RULE_structDeclarationList = 34
+    RULE_structDeclaration = 35
+    RULE_specifierQualifierList = 36
+    RULE_structDeclaratorList = 37
+    RULE_structDeclarator = 38
+    RULE_enumSpecifier = 39
+    RULE_enumeratorList = 40
+    RULE_enumerator = 41
+    RULE_enumerationConstant = 42
+    RULE_atomicTypeSpecifier = 43
+    RULE_typeQualifier = 44
+    RULE_functionSpecifier = 45
+    RULE_alignmentSpecifier = 46
+    RULE_declarator = 47
+    RULE_directDeclarator = 48
+    RULE_gccDeclaratorExtension = 49
+    RULE_gccAttributeSpecifier = 50
+    RULE_gccAttributeList = 51
+    RULE_gccAttribute = 52
+    RULE_nestedParenthesesBlock = 53
+    RULE_pointer = 54
+    RULE_typeQualifierList = 55
+    RULE_parameterTypeList = 56
+    RULE_parameterList = 57
+    RULE_parameterDeclaration = 58
+    RULE_identifierList = 59
+    RULE_typeName = 60
+    RULE_abstractDeclarator = 61
+    RULE_directAbstractDeclarator = 62
+    RULE_typedefName = 63
+    RULE_initializer = 64
+    RULE_initializerList = 65
+    RULE_designation = 66
+    RULE_designatorList = 67
+    RULE_designator = 68
+    RULE_staticAssertDeclaration = 69
+    RULE_statement = 70
+    RULE_labeledStatement = 71
+    RULE_compoundStatement = 72
+    RULE_blockItemList = 73
+    RULE_blockItem = 74
+    RULE_expressionStatement = 75
+    RULE_selectionStatement = 76
+    RULE_iterationStatement = 77
+    RULE_jumpStatement = 78
+    RULE_compilationUnit = 79
+    RULE_translationUnit = 80
+    RULE_externalDeclaration = 81
+    RULE_functionDefinition = 82
+    RULE_declarationList = 83
+
+    ruleNames =  [ "primaryExpression", "genericSelection", "genericAssocList",
+                   "genericAssociation", "postfixExpression", "argumentExpressionList",
+                   "unaryExpression", "unaryOperator", "castExpression",
+                   "multiplicativeExpression", "additiveExpression", "shiftExpression",
+                   "relationalExpression", "equalityExpression", "andExpression",
+                   "exclusiveOrExpression", "inclusiveOrExpression", "logicalAndExpression",
+                   "logicalOrExpression", "conditionalExpression", "assignmentExpression",
+                   "assignmentOperator", "expression", "constantExpression",
+                   "declaration", "declarationSpecifiers", "declarationSpecifiers2",
+                   "declarationSpecifier", "initDeclaratorList", "initDeclarator",
+                   "storageClassSpecifier", "typeSpecifier", "structOrUnionSpecifier",
+                   "structOrUnion", "structDeclarationList", "structDeclaration",
+                   "specifierQualifierList", "structDeclaratorList", "structDeclarator",
+                   "enumSpecifier", "enumeratorList", "enumerator", "enumerationConstant",
+                   "atomicTypeSpecifier", "typeQualifier", "functionSpecifier",
+                   "alignmentSpecifier", "declarator", "directDeclarator",
+                   "gccDeclaratorExtension", "gccAttributeSpecifier", "gccAttributeList",
+                   "gccAttribute", "nestedParenthesesBlock", "pointer",
+                   "typeQualifierList", "parameterTypeList", "parameterList",
+                   "parameterDeclaration", "identifierList", "typeName",
+                   "abstractDeclarator", "directAbstractDeclarator", "typedefName",
+                   "initializer", "initializerList", "designation", "designatorList",
+                   "designator", "staticAssertDeclaration", "statement",
+                   "labeledStatement", "compoundStatement", "blockItemList",
+                   "blockItem", "expressionStatement", "selectionStatement",
+                   "iterationStatement", "jumpStatement", "compilationUnit",
+                   "translationUnit", "externalDeclaration", "functionDefinition",
+                   "declarationList" ]
+
+    EOF = Token.EOF
+    T__0=1
+    T__1=2
+    T__2=3
+    T__3=4
+    T__4=5
+    T__5=6
+    T__6=7
+    T__7=8
+    T__8=9
+    T__9=10
+    T__10=11
+    T__11=12
+    T__12=13
+    T__13=14
+    Auto=15
+    Break=16
+    Case=17
+    Char=18
+    Const=19
+    Continue=20
+    Default=21
+    Do=22
+    Double=23
+    Else=24
+    Enum=25
+    Extern=26
+    Float=27
+    For=28
+    Goto=29
+    If=30
+    Inline=31
+    Int=32
+    Long=33
+    Register=34
+    Restrict=35
+    Return=36
+    Short=37
+    Signed=38
+    Sizeof=39
+    Static=40
+    Struct=41
+    Switch=42
+    Typedef=43
+    Union=44
+    Unsigned=45
+    Void=46
+    Volatile=47
+    While=48
+    Alignas=49
+    Alignof=50
+    Atomic=51
+    Bool=52
+    Complex=53
+    Generic=54
+    Imaginary=55
+    Noreturn=56
+    StaticAssert=57
+    ThreadLocal=58
+    LeftParen=59
+    RightParen=60
+    LeftBracket=61
+    RightBracket=62
+    LeftBrace=63
+    RightBrace=64
+    Less=65
+    LessEqual=66
+    Greater=67
+    GreaterEqual=68
+    LeftShift=69
+    RightShift=70
+    Plus=71
+    PlusPlus=72
+    Minus=73
+    MinusMinus=74
+    Star=75
+    Div=76
+    Mod=77
+    And=78
+    Or=79
+    AndAnd=80
+    OrOr=81
+    Caret=82
+    Not=83
+    Tilde=84
+    Question=85
+    Colon=86
+    Semi=87
+    Comma=88
+    Assign=89
+    StarAssign=90
+    DivAssign=91
+    ModAssign=92
+    PlusAssign=93
+    MinusAssign=94
+    LeftShiftAssign=95
+    RightShiftAssign=96
+    AndAssign=97
+    XorAssign=98
+    OrAssign=99
+    Equal=100
+    NotEqual=101
+    Arrow=102
+    Dot=103
+    Ellipsis=104
+    Identifier=105
+    Constant=106
+    StringLiteral=107
+    LineDirective=108
+    PragmaDirective=109
+    Whitespace=110
+    Newline=111
+    BlockComment=112
+    LineComment=113
+
+    def __init__(self, input:TokenStream):
+        super().__init__(input)
+        self.checkVersion("4.5.1")
+        self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache)
+        self._predicates = None
+
+
+
+    class PrimaryExpressionContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def Identifier(self):
+            return self.getToken(CParser.Identifier, 0)
+
+        def Constant(self):
+            return self.getToken(CParser.Constant, 0)
+
+        def StringLiteral(self, i:int=None):
+            if i is None:
+                return self.getTokens(CParser.StringLiteral)
+            else:
+                return self.getToken(CParser.StringLiteral, i)
+
+        def expression(self):
+            return self.getTypedRuleContext(CParser.ExpressionContext,0)
+
+
+        def genericSelection(self):
+            return self.getTypedRuleContext(CParser.GenericSelectionContext,0)
+
+
+        def compoundStatement(self):
+            return self.getTypedRuleContext(CParser.CompoundStatementContext,0)
+
+
+        def unaryExpression(self):
+            return self.getTypedRuleContext(CParser.UnaryExpressionContext,0)
+
+
+        def typeName(self):
+            return self.getTypedRuleContext(CParser.TypeNameContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_primaryExpression
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterPrimaryExpression" ):
+                listener.enterPrimaryExpression(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitPrimaryExpression" ):
+                listener.exitPrimaryExpression(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitPrimaryExpression" ):
+                return visitor.visitPrimaryExpression(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def primaryExpression(self):
+
+        localctx = CParser.PrimaryExpressionContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 0, self.RULE_primaryExpression)
+        self._la = 0 # Token type
+        try:
+            self.state = 201
+            la_ = self._interp.adaptivePredict(self._input,2,self._ctx)
+            if la_ == 1:
+                self.enterOuterAlt(localctx, 1)
+                self.state = 168
+                self.match(CParser.Identifier)
+                pass
+
+            elif la_ == 2:
+                self.enterOuterAlt(localctx, 2)
+                self.state = 169
+                self.match(CParser.Constant)
+                pass
+
+            elif la_ == 3:
+                self.enterOuterAlt(localctx, 3)
+                self.state = 171
+                self._errHandler.sync(self)
+                _alt = 1
+                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                    if _alt == 1:
+                        self.state = 170
+                        self.match(CParser.StringLiteral)
+
+                    else:
+                        raise NoViableAltException(self)
+                    self.state = 173
+                    self._errHandler.sync(self)
+                    _alt = self._interp.adaptivePredict(self._input,0,self._ctx)
+
+                pass
+
+            elif la_ == 4:
+                self.enterOuterAlt(localctx, 4)
+                self.state = 175
+                self.match(CParser.LeftParen)
+                self.state = 176
+                self.expression(0)
+                self.state = 177
+                self.match(CParser.RightParen)
+                pass
+
+            elif la_ == 5:
+                self.enterOuterAlt(localctx, 5)
+                self.state = 179
+                self.genericSelection()
+                pass
+
+            elif la_ == 6:
+                self.enterOuterAlt(localctx, 6)
+                self.state = 181
+                _la = self._input.LA(1)
+                if _la==CParser.T__0:
+                    self.state = 180
+                    self.match(CParser.T__0)
+
+
+                self.state = 183
+                self.match(CParser.LeftParen)
+                self.state = 184
+                self.compoundStatement()
+                self.state = 185
+                self.match(CParser.RightParen)
+                pass
+
+            elif la_ == 7:
+                self.enterOuterAlt(localctx, 7)
+                self.state = 187
+                self.match(CParser.T__1)
+                self.state = 188
+                self.match(CParser.LeftParen)
+                self.state = 189
+                self.unaryExpression()
+                self.state = 190
+                self.match(CParser.Comma)
+                self.state = 191
+                self.typeName()
+                self.state = 192
+                self.match(CParser.RightParen)
+                pass
+
+            elif la_ == 8:
+                self.enterOuterAlt(localctx, 8)
+                self.state = 194
+                self.match(CParser.T__2)
+                self.state = 195
+                self.match(CParser.LeftParen)
+                self.state = 196
+                self.typeName()
+                self.state = 197
+                self.match(CParser.Comma)
+                self.state = 198
+                self.unaryExpression()
+                self.state = 199
+                self.match(CParser.RightParen)
+                pass
+
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class GenericSelectionContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def assignmentExpression(self):
+            return self.getTypedRuleContext(CParser.AssignmentExpressionContext,0)
+
+
+        def genericAssocList(self):
+            return self.getTypedRuleContext(CParser.GenericAssocListContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_genericSelection
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterGenericSelection" ):
+                listener.enterGenericSelection(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitGenericSelection" ):
+                listener.exitGenericSelection(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitGenericSelection" ):
+                return visitor.visitGenericSelection(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def genericSelection(self):
+
+        localctx = CParser.GenericSelectionContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 2, self.RULE_genericSelection)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 203
+            self.match(CParser.Generic)
+            self.state = 204
+            self.match(CParser.LeftParen)
+            self.state = 205
+            self.assignmentExpression()
+            self.state = 206
+            self.match(CParser.Comma)
+            self.state = 207
+            self.genericAssocList(0)
+            self.state = 208
+            self.match(CParser.RightParen)
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class GenericAssocListContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def genericAssociation(self):
+            return self.getTypedRuleContext(CParser.GenericAssociationContext,0)
+
+
+        def genericAssocList(self):
+            return self.getTypedRuleContext(CParser.GenericAssocListContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_genericAssocList
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterGenericAssocList" ):
+                listener.enterGenericAssocList(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitGenericAssocList" ):
+                listener.exitGenericAssocList(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitGenericAssocList" ):
+                return visitor.visitGenericAssocList(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+    def genericAssocList(self, _p:int=0):
+        _parentctx = self._ctx
+        _parentState = self.state
+        localctx = CParser.GenericAssocListContext(self, self._ctx, _parentState)
+        _prevctx = localctx
+        _startState = 4
+        self.enterRecursionRule(localctx, 4, self.RULE_genericAssocList, _p)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 211
+            self.genericAssociation()
+            self._ctx.stop = self._input.LT(-1)
+            self.state = 218
+            self._errHandler.sync(self)
+            _alt = self._interp.adaptivePredict(self._input,3,self._ctx)
+            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                if _alt==1:
+                    if self._parseListeners is not None:
+                        self.triggerExitRuleEvent()
+                    _prevctx = localctx
+                    localctx = CParser.GenericAssocListContext(self, _parentctx, _parentState)
+                    self.pushNewRecursionContext(localctx, _startState, self.RULE_genericAssocList)
+                    self.state = 213
+                    if not self.precpred(self._ctx, 1):
+                        from antlr4.error.Errors import FailedPredicateException
+                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
+                    self.state = 214
+                    self.match(CParser.Comma)
+                    self.state = 215
+                    self.genericAssociation()
+                self.state = 220
+                self._errHandler.sync(self)
+                _alt = self._interp.adaptivePredict(self._input,3,self._ctx)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.unrollRecursionContexts(_parentctx)
+        return localctx
+
+    class GenericAssociationContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def typeName(self):
+            return self.getTypedRuleContext(CParser.TypeNameContext,0)
+
+
+        def assignmentExpression(self):
+            return self.getTypedRuleContext(CParser.AssignmentExpressionContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_genericAssociation
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterGenericAssociation" ):
+                listener.enterGenericAssociation(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitGenericAssociation" ):
+                listener.exitGenericAssociation(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitGenericAssociation" ):
+                return visitor.visitGenericAssociation(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def genericAssociation(self):
+
+        localctx = CParser.GenericAssociationContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 6, self.RULE_genericAssociation)
+        try:
+            self.state = 228
+            token = self._input.LA(1)
+            if token in [CParser.T__0, CParser.T__3, CParser.T__4, CParser.T__5, CParser.T__6, CParser.Char, CParser.Const, CParser.Double, CParser.Enum, CParser.Float, CParser.Int, CParser.Long, CParser.Restrict, CParser.Short, CParser.Signed, CParser.Struct, CParser.Union, CParser.Unsigned, CParser.Void, CParser.Volatile, CParser.Atomic, CParser.Bool, CParser.Complex, CParser.Identifier]:
+                self.enterOuterAlt(localctx, 1)
+                self.state = 221
+                self.typeName()
+                self.state = 222
+                self.match(CParser.Colon)
+                self.state = 223
+                self.assignmentExpression()
+
+            elif token in [CParser.Default]:
+                self.enterOuterAlt(localctx, 2)
+                self.state = 225
+                self.match(CParser.Default)
+                self.state = 226
+                self.match(CParser.Colon)
+                self.state = 227
+                self.assignmentExpression()
+
+            else:
+                raise NoViableAltException(self)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class PostfixExpressionContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def primaryExpression(self):
+            return self.getTypedRuleContext(CParser.PrimaryExpressionContext,0)
+
+
+        def typeName(self):
+            return self.getTypedRuleContext(CParser.TypeNameContext,0)
+
+
+        def initializerList(self):
+            return self.getTypedRuleContext(CParser.InitializerListContext,0)
+
+
+        def postfixExpression(self):
+            return self.getTypedRuleContext(CParser.PostfixExpressionContext,0)
+
+
+        def expression(self):
+            return self.getTypedRuleContext(CParser.ExpressionContext,0)
+
+
+        def argumentExpressionList(self):
+            return self.getTypedRuleContext(CParser.ArgumentExpressionListContext,0)
+
+
+        def Identifier(self):
+            return self.getToken(CParser.Identifier, 0)
+
+        def getRuleIndex(self):
+            return CParser.RULE_postfixExpression
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterPostfixExpression" ):
+                listener.enterPostfixExpression(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitPostfixExpression" ):
+                listener.exitPostfixExpression(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitPostfixExpression" ):
+                return visitor.visitPostfixExpression(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+    def postfixExpression(self, _p:int=0):
+        _parentctx = self._ctx
+        _parentState = self.state
+        localctx = CParser.PostfixExpressionContext(self, self._ctx, _parentState)
+        _prevctx = localctx
+        _startState = 8
+        self.enterRecursionRule(localctx, 8, self.RULE_postfixExpression, _p)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 264
+            la_ = self._interp.adaptivePredict(self._input,5,self._ctx)
+            if la_ == 1:
+                self.state = 231
+                self.primaryExpression()
+                pass
+
+            elif la_ == 2:
+                self.state = 232
+                self.match(CParser.LeftParen)
+                self.state = 233
+                self.typeName()
+                self.state = 234
+                self.match(CParser.RightParen)
+                self.state = 235
+                self.match(CParser.LeftBrace)
+                self.state = 236
+                self.initializerList(0)
+                self.state = 237
+                self.match(CParser.RightBrace)
+                pass
+
+            elif la_ == 3:
+                self.state = 239
+                self.match(CParser.LeftParen)
+                self.state = 240
+                self.typeName()
+                self.state = 241
+                self.match(CParser.RightParen)
+                self.state = 242
+                self.match(CParser.LeftBrace)
+                self.state = 243
+                self.initializerList(0)
+                self.state = 244
+                self.match(CParser.Comma)
+                self.state = 245
+                self.match(CParser.RightBrace)
+                pass
+
+            elif la_ == 4:
+                self.state = 247
+                self.match(CParser.T__0)
+                self.state = 248
+                self.match(CParser.LeftParen)
+                self.state = 249
+                self.typeName()
+                self.state = 250
+                self.match(CParser.RightParen)
+                self.state = 251
+                self.match(CParser.LeftBrace)
+                self.state = 252
+                self.initializerList(0)
+                self.state = 253
+                self.match(CParser.RightBrace)
+                pass
+
+            elif la_ == 5:
+                self.state = 255
+                self.match(CParser.T__0)
+                self.state = 256
+                self.match(CParser.LeftParen)
+                self.state = 257
+                self.typeName()
+                self.state = 258
+                self.match(CParser.RightParen)
+                self.state = 259
+                self.match(CParser.LeftBrace)
+                self.state = 260
+                self.initializerList(0)
+                self.state = 261
+                self.match(CParser.Comma)
+                self.state = 262
+                self.match(CParser.RightBrace)
+                pass
+
+
+            self._ctx.stop = self._input.LT(-1)
+            self.state = 289
+            self._errHandler.sync(self)
+            _alt = self._interp.adaptivePredict(self._input,8,self._ctx)
+            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                if _alt==1:
+                    if self._parseListeners is not None:
+                        self.triggerExitRuleEvent()
+                    _prevctx = localctx
+                    self.state = 287
+                    la_ = self._interp.adaptivePredict(self._input,7,self._ctx)
+                    if la_ == 1:
+                        localctx = CParser.PostfixExpressionContext(self, _parentctx, _parentState)
+                        self.pushNewRecursionContext(localctx, _startState, self.RULE_postfixExpression)
+                        self.state = 266
+                        if not self.precpred(self._ctx, 10):
+                            from antlr4.error.Errors import FailedPredicateException
+                            raise FailedPredicateException(self, "self.precpred(self._ctx, 10)")
+                        self.state = 267
+                        self.match(CParser.LeftBracket)
+                        self.state = 268
+                        self.expression(0)
+                        self.state = 269
+                        self.match(CParser.RightBracket)
+                        pass
+
+                    elif la_ == 2:
+                        localctx = CParser.PostfixExpressionContext(self, _parentctx, _parentState)
+                        self.pushNewRecursionContext(localctx, _startState, self.RULE_postfixExpression)
+                        self.state = 271
+                        if not self.precpred(self._ctx, 9):
+                            from antlr4.error.Errors import FailedPredicateException
+                            raise FailedPredicateException(self, "self.precpred(self._ctx, 9)")
+                        self.state = 272
+                        self.match(CParser.LeftParen)
+                        self.state = 274
+                        _la = self._input.LA(1)
+                        if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2) | (1 << CParser.Sizeof) | (1 << CParser.Alignof) | (1 << CParser.Generic) | (1 << CParser.LeftParen))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)) | (1 << (CParser.Identifier - 71)) | (1 << (CParser.Constant - 71)) | (1 << (CParser.StringLiteral - 71)))) != 0):
+                            self.state = 273
+                            self.argumentExpressionList(0)
+
+
+                        self.state = 276
+                        self.match(CParser.RightParen)
+                        pass
+
+                    elif la_ == 3:
+                        localctx = CParser.PostfixExpressionContext(self, _parentctx, _parentState)
+                        self.pushNewRecursionContext(localctx, _startState, self.RULE_postfixExpression)
+                        self.state = 277
+                        if not self.precpred(self._ctx, 8):
+                            from antlr4.error.Errors import FailedPredicateException
+                            raise FailedPredicateException(self, "self.precpred(self._ctx, 8)")
+                        self.state = 278
+                        self.match(CParser.Dot)
+                        self.state = 279
+                        self.match(CParser.Identifier)
+                        pass
+
+                    elif la_ == 4:
+                        localctx = CParser.PostfixExpressionContext(self, _parentctx, _parentState)
+                        self.pushNewRecursionContext(localctx, _startState, self.RULE_postfixExpression)
+                        self.state = 280
+                        if not self.precpred(self._ctx, 7):
+                            from antlr4.error.Errors import FailedPredicateException
+                            raise FailedPredicateException(self, "self.precpred(self._ctx, 7)")
+                        self.state = 281
+                        self.match(CParser.Arrow)
+                        self.state = 282
+                        self.match(CParser.Identifier)
+                        pass
+
+                    elif la_ == 5:
+                        localctx = CParser.PostfixExpressionContext(self, _parentctx, _parentState)
+                        self.pushNewRecursionContext(localctx, _startState, self.RULE_postfixExpression)
+                        self.state = 283
+                        if not self.precpred(self._ctx, 6):
+                            from antlr4.error.Errors import FailedPredicateException
+                            raise FailedPredicateException(self, "self.precpred(self._ctx, 6)")
+                        self.state = 284
+                        self.match(CParser.PlusPlus)
+                        pass
+
+                    elif la_ == 6:
+                        localctx = CParser.PostfixExpressionContext(self, _parentctx, _parentState)
+                        self.pushNewRecursionContext(localctx, _startState, self.RULE_postfixExpression)
+                        self.state = 285
+                        if not self.precpred(self._ctx, 5):
+                            from antlr4.error.Errors import FailedPredicateException
+                            raise FailedPredicateException(self, "self.precpred(self._ctx, 5)")
+                        self.state = 286
+                        self.match(CParser.MinusMinus)
+                        pass
+
+
+                self.state = 291
+                self._errHandler.sync(self)
+                _alt = self._interp.adaptivePredict(self._input,8,self._ctx)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.unrollRecursionContexts(_parentctx)
+        return localctx
+
+    class ArgumentExpressionListContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def assignmentExpression(self):
+            return self.getTypedRuleContext(CParser.AssignmentExpressionContext,0)
+
+
+        def argumentExpressionList(self):
+            return self.getTypedRuleContext(CParser.ArgumentExpressionListContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_argumentExpressionList
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterArgumentExpressionList" ):
+                listener.enterArgumentExpressionList(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitArgumentExpressionList" ):
+                listener.exitArgumentExpressionList(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitArgumentExpressionList" ):
+                return visitor.visitArgumentExpressionList(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+    def argumentExpressionList(self, _p:int=0):
+        _parentctx = self._ctx
+        _parentState = self.state
+        localctx = CParser.ArgumentExpressionListContext(self, self._ctx, _parentState)
+        _prevctx = localctx
+        _startState = 10
+        self.enterRecursionRule(localctx, 10, self.RULE_argumentExpressionList, _p)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 293
+            self.assignmentExpression()
+            self._ctx.stop = self._input.LT(-1)
+            self.state = 300
+            self._errHandler.sync(self)
+            _alt = self._interp.adaptivePredict(self._input,9,self._ctx)
+            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                if _alt==1:
+                    if self._parseListeners is not None:
+                        self.triggerExitRuleEvent()
+                    _prevctx = localctx
+                    localctx = CParser.ArgumentExpressionListContext(self, _parentctx, _parentState)
+                    self.pushNewRecursionContext(localctx, _startState, self.RULE_argumentExpressionList)
+                    self.state = 295
+                    if not self.precpred(self._ctx, 1):
+                        from antlr4.error.Errors import FailedPredicateException
+                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
+                    self.state = 296
+                    self.match(CParser.Comma)
+                    self.state = 297
+                    self.assignmentExpression()
+                self.state = 302
+                self._errHandler.sync(self)
+                _alt = self._interp.adaptivePredict(self._input,9,self._ctx)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.unrollRecursionContexts(_parentctx)
+        return localctx
+
+    class UnaryExpressionContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def postfixExpression(self):
+            return self.getTypedRuleContext(CParser.PostfixExpressionContext,0)
+
+
+        def unaryExpression(self):
+            return self.getTypedRuleContext(CParser.UnaryExpressionContext,0)
+
+
+        def unaryOperator(self):
+            return self.getTypedRuleContext(CParser.UnaryOperatorContext,0)
+
+
+        def castExpression(self):
+            return self.getTypedRuleContext(CParser.CastExpressionContext,0)
+
+
+        def typeName(self):
+            return self.getTypedRuleContext(CParser.TypeNameContext,0)
+
+
+        def Identifier(self):
+            return self.getToken(CParser.Identifier, 0)
+
+        def getRuleIndex(self):
+            return CParser.RULE_unaryExpression
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterUnaryExpression" ):
+                listener.enterUnaryExpression(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitUnaryExpression" ):
+                listener.exitUnaryExpression(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitUnaryExpression" ):
+                return visitor.visitUnaryExpression(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def unaryExpression(self):
+
+        localctx = CParser.UnaryExpressionContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 12, self.RULE_unaryExpression)
+        try:
+            self.state = 325
+            la_ = self._interp.adaptivePredict(self._input,10,self._ctx)
+            if la_ == 1:
+                self.enterOuterAlt(localctx, 1)
+                self.state = 303
+                self.postfixExpression(0)
+                pass
+
+            elif la_ == 2:
+                self.enterOuterAlt(localctx, 2)
+                self.state = 304
+                self.match(CParser.PlusPlus)
+                self.state = 305
+                self.unaryExpression()
+                pass
+
+            elif la_ == 3:
+                self.enterOuterAlt(localctx, 3)
+                self.state = 306
+                self.match(CParser.MinusMinus)
+                self.state = 307
+                self.unaryExpression()
+                pass
+
+            elif la_ == 4:
+                self.enterOuterAlt(localctx, 4)
+                self.state = 308
+                self.unaryOperator()
+                self.state = 309
+                self.castExpression()
+                pass
+
+            elif la_ == 5:
+                self.enterOuterAlt(localctx, 5)
+                self.state = 311
+                self.match(CParser.Sizeof)
+                self.state = 312
+                self.unaryExpression()
+                pass
+
+            elif la_ == 6:
+                self.enterOuterAlt(localctx, 6)
+                self.state = 313
+                self.match(CParser.Sizeof)
+                self.state = 314
+                self.match(CParser.LeftParen)
+                self.state = 315
+                self.typeName()
+                self.state = 316
+                self.match(CParser.RightParen)
+                pass
+
+            elif la_ == 7:
+                self.enterOuterAlt(localctx, 7)
+                self.state = 318
+                self.match(CParser.Alignof)
+                self.state = 319
+                self.match(CParser.LeftParen)
+                self.state = 320
+                self.typeName()
+                self.state = 321
+                self.match(CParser.RightParen)
+                pass
+
+            elif la_ == 8:
+                self.enterOuterAlt(localctx, 8)
+                self.state = 323
+                self.match(CParser.AndAnd)
+                self.state = 324
+                self.match(CParser.Identifier)
+                pass
+
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class UnaryOperatorContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_unaryOperator
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterUnaryOperator" ):
+                listener.enterUnaryOperator(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitUnaryOperator" ):
+                listener.exitUnaryOperator(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitUnaryOperator" ):
+                return visitor.visitUnaryOperator(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def unaryOperator(self):
+
+        localctx = CParser.UnaryOperatorContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 14, self.RULE_unaryOperator)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 327
+            _la = self._input.LA(1)
+            if not(((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)))) != 0)):
+                self._errHandler.recoverInline(self)
+            else:
+                self.consume()
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class CastExpressionContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def unaryExpression(self):
+            return self.getTypedRuleContext(CParser.UnaryExpressionContext,0)
+
+
+        def typeName(self):
+            return self.getTypedRuleContext(CParser.TypeNameContext,0)
+
+
+        def castExpression(self):
+            return self.getTypedRuleContext(CParser.CastExpressionContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_castExpression
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterCastExpression" ):
+                listener.enterCastExpression(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitCastExpression" ):
+                listener.exitCastExpression(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitCastExpression" ):
+                return visitor.visitCastExpression(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def castExpression(self):
+
+        localctx = CParser.CastExpressionContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 16, self.RULE_castExpression)
+        try:
+            self.state = 341
+            la_ = self._interp.adaptivePredict(self._input,11,self._ctx)
+            if la_ == 1:
+                self.enterOuterAlt(localctx, 1)
+                self.state = 329
+                self.unaryExpression()
+                pass
+
+            elif la_ == 2:
+                self.enterOuterAlt(localctx, 2)
+                self.state = 330
+                self.match(CParser.LeftParen)
+                self.state = 331
+                self.typeName()
+                self.state = 332
+                self.match(CParser.RightParen)
+                self.state = 333
+                self.castExpression()
+                pass
+
+            elif la_ == 3:
+                self.enterOuterAlt(localctx, 3)
+                self.state = 335
+                self.match(CParser.T__0)
+                self.state = 336
+                self.match(CParser.LeftParen)
+                self.state = 337
+                self.typeName()
+                self.state = 338
+                self.match(CParser.RightParen)
+                self.state = 339
+                self.castExpression()
+                pass
+
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class MultiplicativeExpressionContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def castExpression(self):
+            return self.getTypedRuleContext(CParser.CastExpressionContext,0)
+
+
+        def multiplicativeExpression(self):
+            return self.getTypedRuleContext(CParser.MultiplicativeExpressionContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_multiplicativeExpression
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterMultiplicativeExpression" ):
+                listener.enterMultiplicativeExpression(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitMultiplicativeExpression" ):
+                listener.exitMultiplicativeExpression(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitMultiplicativeExpression" ):
+                return visitor.visitMultiplicativeExpression(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+    def multiplicativeExpression(self, _p:int=0):
+        _parentctx = self._ctx
+        _parentState = self.state
+        localctx = CParser.MultiplicativeExpressionContext(self, self._ctx, _parentState)
+        _prevctx = localctx
+        _startState = 18
+        self.enterRecursionRule(localctx, 18, self.RULE_multiplicativeExpression, _p)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 344
+            self.castExpression()
+            self._ctx.stop = self._input.LT(-1)
+            self.state = 357
+            self._errHandler.sync(self)
+            _alt = self._interp.adaptivePredict(self._input,13,self._ctx)
+            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                if _alt==1:
+                    if self._parseListeners is not None:
+                        self.triggerExitRuleEvent()
+                    _prevctx = localctx
+                    self.state = 355
+                    la_ = self._interp.adaptivePredict(self._input,12,self._ctx)
+                    if la_ == 1:
+                        localctx = CParser.MultiplicativeExpressionContext(self, _parentctx, _parentState)
+                        self.pushNewRecursionContext(localctx, _startState, self.RULE_multiplicativeExpression)
+                        self.state = 346
+                        if not self.precpred(self._ctx, 3):
+                            from antlr4.error.Errors import FailedPredicateException
+                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
+                        self.state = 347
+                        self.match(CParser.Star)
+                        self.state = 348
+                        self.castExpression()
+                        pass
+
+                    elif la_ == 2:
+                        localctx = CParser.MultiplicativeExpressionContext(self, _parentctx, _parentState)
+                        self.pushNewRecursionContext(localctx, _startState, self.RULE_multiplicativeExpression)
+                        self.state = 349
+                        if not self.precpred(self._ctx, 2):
+                            from antlr4.error.Errors import FailedPredicateException
+                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
+                        self.state = 350
+                        self.match(CParser.Div)
+                        self.state = 351
+                        self.castExpression()
+                        pass
+
+                    elif la_ == 3:
+                        localctx = CParser.MultiplicativeExpressionContext(self, _parentctx, _parentState)
+                        self.pushNewRecursionContext(localctx, _startState, self.RULE_multiplicativeExpression)
+                        self.state = 352
+                        if not self.precpred(self._ctx, 1):
+                            from antlr4.error.Errors import FailedPredicateException
+                            raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
+                        self.state = 353
+                        self.match(CParser.Mod)
+                        self.state = 354
+                        self.castExpression()
+                        pass
+
+
+                self.state = 359
+                self._errHandler.sync(self)
+                _alt = self._interp.adaptivePredict(self._input,13,self._ctx)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.unrollRecursionContexts(_parentctx)
+        return localctx
+
+    class AdditiveExpressionContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def multiplicativeExpression(self):
+            return self.getTypedRuleContext(CParser.MultiplicativeExpressionContext,0)
+
+
+        def additiveExpression(self):
+            return self.getTypedRuleContext(CParser.AdditiveExpressionContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_additiveExpression
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterAdditiveExpression" ):
+                listener.enterAdditiveExpression(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitAdditiveExpression" ):
+                listener.exitAdditiveExpression(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitAdditiveExpression" ):
+                return visitor.visitAdditiveExpression(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+    def additiveExpression(self, _p:int=0):
+        _parentctx = self._ctx
+        _parentState = self.state
+        localctx = CParser.AdditiveExpressionContext(self, self._ctx, _parentState)
+        _prevctx = localctx
+        _startState = 20
+        self.enterRecursionRule(localctx, 20, self.RULE_additiveExpression, _p)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 361
+            self.multiplicativeExpression(0)
+            self._ctx.stop = self._input.LT(-1)
+            self.state = 371
+            self._errHandler.sync(self)
+            _alt = self._interp.adaptivePredict(self._input,15,self._ctx)
+            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                if _alt==1:
+                    if self._parseListeners is not None:
+                        self.triggerExitRuleEvent()
+                    _prevctx = localctx
+                    self.state = 369
+                    la_ = self._interp.adaptivePredict(self._input,14,self._ctx)
+                    if la_ == 1:
+                        localctx = CParser.AdditiveExpressionContext(self, _parentctx, _parentState)
+                        self.pushNewRecursionContext(localctx, _startState, self.RULE_additiveExpression)
+                        self.state = 363
+                        if not self.precpred(self._ctx, 2):
+                            from antlr4.error.Errors import FailedPredicateException
+                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
+                        self.state = 364
+                        self.match(CParser.Plus)
+                        self.state = 365
+                        self.multiplicativeExpression(0)
+                        pass
+
+                    elif la_ == 2:
+                        localctx = CParser.AdditiveExpressionContext(self, _parentctx, _parentState)
+                        self.pushNewRecursionContext(localctx, _startState, self.RULE_additiveExpression)
+                        self.state = 366
+                        if not self.precpred(self._ctx, 1):
+                            from antlr4.error.Errors import FailedPredicateException
+                            raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
+                        self.state = 367
+                        self.match(CParser.Minus)
+                        self.state = 368
+                        self.multiplicativeExpression(0)
+                        pass
+
+
+                self.state = 373
+                self._errHandler.sync(self)
+                _alt = self._interp.adaptivePredict(self._input,15,self._ctx)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.unrollRecursionContexts(_parentctx)
+        return localctx
+
+    class ShiftExpressionContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def additiveExpression(self):
+            return self.getTypedRuleContext(CParser.AdditiveExpressionContext,0)
+
+
+        def shiftExpression(self):
+            return self.getTypedRuleContext(CParser.ShiftExpressionContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_shiftExpression
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterShiftExpression" ):
+                listener.enterShiftExpression(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitShiftExpression" ):
+                listener.exitShiftExpression(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitShiftExpression" ):
+                return visitor.visitShiftExpression(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+    def shiftExpression(self, _p:int=0):
+        _parentctx = self._ctx
+        _parentState = self.state
+        localctx = CParser.ShiftExpressionContext(self, self._ctx, _parentState)
+        _prevctx = localctx
+        _startState = 22
+        self.enterRecursionRule(localctx, 22, self.RULE_shiftExpression, _p)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 375
+            self.additiveExpression(0)
+            self._ctx.stop = self._input.LT(-1)
+            self.state = 385
+            self._errHandler.sync(self)
+            _alt = self._interp.adaptivePredict(self._input,17,self._ctx)
+            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                if _alt==1:
+                    if self._parseListeners is not None:
+                        self.triggerExitRuleEvent()
+                    _prevctx = localctx
+                    self.state = 383
+                    la_ = self._interp.adaptivePredict(self._input,16,self._ctx)
+                    if la_ == 1:
+                        localctx = CParser.ShiftExpressionContext(self, _parentctx, _parentState)
+                        self.pushNewRecursionContext(localctx, _startState, self.RULE_shiftExpression)
+                        self.state = 377
+                        if not self.precpred(self._ctx, 2):
+                            from antlr4.error.Errors import FailedPredicateException
+                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
+                        self.state = 378
+                        self.match(CParser.LeftShift)
+                        self.state = 379
+                        self.additiveExpression(0)
+                        pass
+
+                    elif la_ == 2:
+                        localctx = CParser.ShiftExpressionContext(self, _parentctx, _parentState)
+                        self.pushNewRecursionContext(localctx, _startState, self.RULE_shiftExpression)
+                        self.state = 380
+                        if not self.precpred(self._ctx, 1):
+                            from antlr4.error.Errors import FailedPredicateException
+                            raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
+                        self.state = 381
+                        self.match(CParser.RightShift)
+                        self.state = 382
+                        self.additiveExpression(0)
+                        pass
+
+
+                self.state = 387
+                self._errHandler.sync(self)
+                _alt = self._interp.adaptivePredict(self._input,17,self._ctx)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.unrollRecursionContexts(_parentctx)
+        return localctx
+
+    class RelationalExpressionContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def shiftExpression(self):
+            return self.getTypedRuleContext(CParser.ShiftExpressionContext,0)
+
+
+        def relationalExpression(self):
+            return self.getTypedRuleContext(CParser.RelationalExpressionContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_relationalExpression
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterRelationalExpression" ):
+                listener.enterRelationalExpression(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitRelationalExpression" ):
+                listener.exitRelationalExpression(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitRelationalExpression" ):
+                return visitor.visitRelationalExpression(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+    def relationalExpression(self, _p:int=0):
+        _parentctx = self._ctx
+        _parentState = self.state
+        localctx = CParser.RelationalExpressionContext(self, self._ctx, _parentState)
+        _prevctx = localctx
+        _startState = 24
+        self.enterRecursionRule(localctx, 24, self.RULE_relationalExpression, _p)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 389
+            self.shiftExpression(0)
+            self._ctx.stop = self._input.LT(-1)
+            self.state = 405
+            self._errHandler.sync(self)
+            _alt = self._interp.adaptivePredict(self._input,19,self._ctx)
+            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                if _alt==1:
+                    if self._parseListeners is not None:
+                        self.triggerExitRuleEvent()
+                    _prevctx = localctx
+                    self.state = 403
+                    la_ = self._interp.adaptivePredict(self._input,18,self._ctx)
+                    if la_ == 1:
+                        localctx = CParser.RelationalExpressionContext(self, _parentctx, _parentState)
+                        self.pushNewRecursionContext(localctx, _startState, self.RULE_relationalExpression)
+                        self.state = 391
+                        if not self.precpred(self._ctx, 4):
+                            from antlr4.error.Errors import FailedPredicateException
+                            raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
+                        self.state = 392
+                        self.match(CParser.Less)
+                        self.state = 393
+                        self.shiftExpression(0)
+                        pass
+
+                    elif la_ == 2:
+                        localctx = CParser.RelationalExpressionContext(self, _parentctx, _parentState)
+                        self.pushNewRecursionContext(localctx, _startState, self.RULE_relationalExpression)
+                        self.state = 394
+                        if not self.precpred(self._ctx, 3):
+                            from antlr4.error.Errors import FailedPredicateException
+                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
+                        self.state = 395
+                        self.match(CParser.Greater)
+                        self.state = 396
+                        self.shiftExpression(0)
+                        pass
+
+                    elif la_ == 3:
+                        localctx = CParser.RelationalExpressionContext(self, _parentctx, _parentState)
+                        self.pushNewRecursionContext(localctx, _startState, self.RULE_relationalExpression)
+                        self.state = 397
+                        if not self.precpred(self._ctx, 2):
+                            from antlr4.error.Errors import FailedPredicateException
+                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
+                        self.state = 398
+                        self.match(CParser.LessEqual)
+                        self.state = 399
+                        self.shiftExpression(0)
+                        pass
+
+                    elif la_ == 4:
+                        localctx = CParser.RelationalExpressionContext(self, _parentctx, _parentState)
+                        self.pushNewRecursionContext(localctx, _startState, self.RULE_relationalExpression)
+                        self.state = 400
+                        if not self.precpred(self._ctx, 1):
+                            from antlr4.error.Errors import FailedPredicateException
+                            raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
+                        self.state = 401
+                        self.match(CParser.GreaterEqual)
+                        self.state = 402
+                        self.shiftExpression(0)
+                        pass
+
+
+                self.state = 407
+                self._errHandler.sync(self)
+                _alt = self._interp.adaptivePredict(self._input,19,self._ctx)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.unrollRecursionContexts(_parentctx)
+        return localctx
+
+    class EqualityExpressionContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def relationalExpression(self):
+            return self.getTypedRuleContext(CParser.RelationalExpressionContext,0)
+
+
+        def equalityExpression(self):
+            return self.getTypedRuleContext(CParser.EqualityExpressionContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_equalityExpression
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterEqualityExpression" ):
+                listener.enterEqualityExpression(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitEqualityExpression" ):
+                listener.exitEqualityExpression(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitEqualityExpression" ):
+                return visitor.visitEqualityExpression(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+    def equalityExpression(self, _p:int=0):
+        _parentctx = self._ctx
+        _parentState = self.state
+        localctx = CParser.EqualityExpressionContext(self, self._ctx, _parentState)
+        _prevctx = localctx
+        _startState = 26
+        self.enterRecursionRule(localctx, 26, self.RULE_equalityExpression, _p)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 409
+            self.relationalExpression(0)
+            self._ctx.stop = self._input.LT(-1)
+            self.state = 419
+            self._errHandler.sync(self)
+            _alt = self._interp.adaptivePredict(self._input,21,self._ctx)
+            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                if _alt==1:
+                    if self._parseListeners is not None:
+                        self.triggerExitRuleEvent()
+                    _prevctx = localctx
+                    self.state = 417
+                    la_ = self._interp.adaptivePredict(self._input,20,self._ctx)
+                    if la_ == 1:
+                        localctx = CParser.EqualityExpressionContext(self, _parentctx, _parentState)
+                        self.pushNewRecursionContext(localctx, _startState, self.RULE_equalityExpression)
+                        self.state = 411
+                        if not self.precpred(self._ctx, 2):
+                            from antlr4.error.Errors import FailedPredicateException
+                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
+                        self.state = 412
+                        self.match(CParser.Equal)
+                        self.state = 413
+                        self.relationalExpression(0)
+                        pass
+
+                    elif la_ == 2:
+                        localctx = CParser.EqualityExpressionContext(self, _parentctx, _parentState)
+                        self.pushNewRecursionContext(localctx, _startState, self.RULE_equalityExpression)
+                        self.state = 414
+                        if not self.precpred(self._ctx, 1):
+                            from antlr4.error.Errors import FailedPredicateException
+                            raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
+                        self.state = 415
+                        self.match(CParser.NotEqual)
+                        self.state = 416
+                        self.relationalExpression(0)
+                        pass
+
+
+                self.state = 421
+                self._errHandler.sync(self)
+                _alt = self._interp.adaptivePredict(self._input,21,self._ctx)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.unrollRecursionContexts(_parentctx)
+        return localctx
+
+    class AndExpressionContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def equalityExpression(self):
+            return self.getTypedRuleContext(CParser.EqualityExpressionContext,0)
+
+
+        def andExpression(self):
+            return self.getTypedRuleContext(CParser.AndExpressionContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_andExpression
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterAndExpression" ):
+                listener.enterAndExpression(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitAndExpression" ):
+                listener.exitAndExpression(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitAndExpression" ):
+                return visitor.visitAndExpression(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+    def andExpression(self, _p:int=0):
+        _parentctx = self._ctx
+        _parentState = self.state
+        localctx = CParser.AndExpressionContext(self, self._ctx, _parentState)
+        _prevctx = localctx
+        _startState = 28
+        self.enterRecursionRule(localctx, 28, self.RULE_andExpression, _p)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 423
+            self.equalityExpression(0)
+            self._ctx.stop = self._input.LT(-1)
+            self.state = 430
+            self._errHandler.sync(self)
+            _alt = self._interp.adaptivePredict(self._input,22,self._ctx)
+            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                if _alt==1:
+                    if self._parseListeners is not None:
+                        self.triggerExitRuleEvent()
+                    _prevctx = localctx
+                    localctx = CParser.AndExpressionContext(self, _parentctx, _parentState)
+                    self.pushNewRecursionContext(localctx, _startState, self.RULE_andExpression)
+                    self.state = 425
+                    if not self.precpred(self._ctx, 1):
+                        from antlr4.error.Errors import FailedPredicateException
+                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
+                    self.state = 426
+                    self.match(CParser.And)
+                    self.state = 427
+                    self.equalityExpression(0)
+                self.state = 432
+                self._errHandler.sync(self)
+                _alt = self._interp.adaptivePredict(self._input,22,self._ctx)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.unrollRecursionContexts(_parentctx)
+        return localctx
+
+    class ExclusiveOrExpressionContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def andExpression(self):
+            return self.getTypedRuleContext(CParser.AndExpressionContext,0)
+
+
+        def exclusiveOrExpression(self):
+            return self.getTypedRuleContext(CParser.ExclusiveOrExpressionContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_exclusiveOrExpression
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterExclusiveOrExpression" ):
+                listener.enterExclusiveOrExpression(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitExclusiveOrExpression" ):
+                listener.exitExclusiveOrExpression(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitExclusiveOrExpression" ):
+                return visitor.visitExclusiveOrExpression(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+    def exclusiveOrExpression(self, _p:int=0):
+        _parentctx = self._ctx
+        _parentState = self.state
+        localctx = CParser.ExclusiveOrExpressionContext(self, self._ctx, _parentState)
+        _prevctx = localctx
+        _startState = 30
+        self.enterRecursionRule(localctx, 30, self.RULE_exclusiveOrExpression, _p)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 434
+            self.andExpression(0)
+            self._ctx.stop = self._input.LT(-1)
+            self.state = 441
+            self._errHandler.sync(self)
+            _alt = self._interp.adaptivePredict(self._input,23,self._ctx)
+            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                if _alt==1:
+                    if self._parseListeners is not None:
+                        self.triggerExitRuleEvent()
+                    _prevctx = localctx
+                    localctx = CParser.ExclusiveOrExpressionContext(self, _parentctx, _parentState)
+                    self.pushNewRecursionContext(localctx, _startState, self.RULE_exclusiveOrExpression)
+                    self.state = 436
+                    if not self.precpred(self._ctx, 1):
+                        from antlr4.error.Errors import FailedPredicateException
+                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
+                    self.state = 437
+                    self.match(CParser.Caret)
+                    self.state = 438
+                    self.andExpression(0)
+                self.state = 443
+                self._errHandler.sync(self)
+                _alt = self._interp.adaptivePredict(self._input,23,self._ctx)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.unrollRecursionContexts(_parentctx)
+        return localctx
+
+    class InclusiveOrExpressionContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def exclusiveOrExpression(self):
+            return self.getTypedRuleContext(CParser.ExclusiveOrExpressionContext,0)
+
+
+        def inclusiveOrExpression(self):
+            return self.getTypedRuleContext(CParser.InclusiveOrExpressionContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_inclusiveOrExpression
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterInclusiveOrExpression" ):
+                listener.enterInclusiveOrExpression(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitInclusiveOrExpression" ):
+                listener.exitInclusiveOrExpression(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitInclusiveOrExpression" ):
+                return visitor.visitInclusiveOrExpression(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+    def inclusiveOrExpression(self, _p:int=0):
+        _parentctx = self._ctx
+        _parentState = self.state
+        localctx = CParser.InclusiveOrExpressionContext(self, self._ctx, _parentState)
+        _prevctx = localctx
+        _startState = 32
+        self.enterRecursionRule(localctx, 32, self.RULE_inclusiveOrExpression, _p)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 445
+            self.exclusiveOrExpression(0)
+            self._ctx.stop = self._input.LT(-1)
+            self.state = 452
+            self._errHandler.sync(self)
+            _alt = self._interp.adaptivePredict(self._input,24,self._ctx)
+            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                if _alt==1:
+                    if self._parseListeners is not None:
+                        self.triggerExitRuleEvent()
+                    _prevctx = localctx
+                    localctx = CParser.InclusiveOrExpressionContext(self, _parentctx, _parentState)
+                    self.pushNewRecursionContext(localctx, _startState, self.RULE_inclusiveOrExpression)
+                    self.state = 447
+                    if not self.precpred(self._ctx, 1):
+                        from antlr4.error.Errors import FailedPredicateException
+                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
+                    self.state = 448
+                    self.match(CParser.Or)
+                    self.state = 449
+                    self.exclusiveOrExpression(0)
+                self.state = 454
+                self._errHandler.sync(self)
+                _alt = self._interp.adaptivePredict(self._input,24,self._ctx)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.unrollRecursionContexts(_parentctx)
+        return localctx
+
+    class LogicalAndExpressionContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def inclusiveOrExpression(self):
+            return self.getTypedRuleContext(CParser.InclusiveOrExpressionContext,0)
+
+
+        def logicalAndExpression(self):
+            return self.getTypedRuleContext(CParser.LogicalAndExpressionContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_logicalAndExpression
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterLogicalAndExpression" ):
+                listener.enterLogicalAndExpression(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitLogicalAndExpression" ):
+                listener.exitLogicalAndExpression(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitLogicalAndExpression" ):
+                return visitor.visitLogicalAndExpression(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+    def logicalAndExpression(self, _p:int=0):
+        _parentctx = self._ctx
+        _parentState = self.state
+        localctx = CParser.LogicalAndExpressionContext(self, self._ctx, _parentState)
+        _prevctx = localctx
+        _startState = 34
+        self.enterRecursionRule(localctx, 34, self.RULE_logicalAndExpression, _p)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 456
+            self.inclusiveOrExpression(0)
+            self._ctx.stop = self._input.LT(-1)
+            self.state = 463
+            self._errHandler.sync(self)
+            _alt = self._interp.adaptivePredict(self._input,25,self._ctx)
+            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                if _alt==1:
+                    if self._parseListeners is not None:
+                        self.triggerExitRuleEvent()
+                    _prevctx = localctx
+                    localctx = CParser.LogicalAndExpressionContext(self, _parentctx, _parentState)
+                    self.pushNewRecursionContext(localctx, _startState, self.RULE_logicalAndExpression)
+                    self.state = 458
+                    if not self.precpred(self._ctx, 1):
+                        from antlr4.error.Errors import FailedPredicateException
+                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
+                    self.state = 459
+                    self.match(CParser.AndAnd)
+                    self.state = 460
+                    self.inclusiveOrExpression(0)
+                self.state = 465
+                self._errHandler.sync(self)
+                _alt = self._interp.adaptivePredict(self._input,25,self._ctx)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.unrollRecursionContexts(_parentctx)
+        return localctx
+
+    class LogicalOrExpressionContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def logicalAndExpression(self):
+            return self.getTypedRuleContext(CParser.LogicalAndExpressionContext,0)
+
+
+        def logicalOrExpression(self):
+            return self.getTypedRuleContext(CParser.LogicalOrExpressionContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_logicalOrExpression
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterLogicalOrExpression" ):
+                listener.enterLogicalOrExpression(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitLogicalOrExpression" ):
+                listener.exitLogicalOrExpression(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitLogicalOrExpression" ):
+                return visitor.visitLogicalOrExpression(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+    def logicalOrExpression(self, _p:int=0):
+        _parentctx = self._ctx
+        _parentState = self.state
+        localctx = CParser.LogicalOrExpressionContext(self, self._ctx, _parentState)
+        _prevctx = localctx
+        _startState = 36
+        self.enterRecursionRule(localctx, 36, self.RULE_logicalOrExpression, _p)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 467
+            self.logicalAndExpression(0)
+            self._ctx.stop = self._input.LT(-1)
+            self.state = 474
+            self._errHandler.sync(self)
+            _alt = self._interp.adaptivePredict(self._input,26,self._ctx)
+            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                if _alt==1:
+                    if self._parseListeners is not None:
+                        self.triggerExitRuleEvent()
+                    _prevctx = localctx
+                    localctx = CParser.LogicalOrExpressionContext(self, _parentctx, _parentState)
+                    self.pushNewRecursionContext(localctx, _startState, self.RULE_logicalOrExpression)
+                    self.state = 469
+                    if not self.precpred(self._ctx, 1):
+                        from antlr4.error.Errors import FailedPredicateException
+                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
+                    self.state = 470
+                    self.match(CParser.OrOr)
+                    self.state = 471
+                    self.logicalAndExpression(0)
+                self.state = 476
+                self._errHandler.sync(self)
+                _alt = self._interp.adaptivePredict(self._input,26,self._ctx)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.unrollRecursionContexts(_parentctx)
+        return localctx
+
+    class ConditionalExpressionContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def logicalOrExpression(self):
+            return self.getTypedRuleContext(CParser.LogicalOrExpressionContext,0)
+
+
+        def expression(self):
+            return self.getTypedRuleContext(CParser.ExpressionContext,0)
+
+
+        def conditionalExpression(self):
+            return self.getTypedRuleContext(CParser.ConditionalExpressionContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_conditionalExpression
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterConditionalExpression" ):
+                listener.enterConditionalExpression(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitConditionalExpression" ):
+                listener.exitConditionalExpression(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitConditionalExpression" ):
+                return visitor.visitConditionalExpression(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def conditionalExpression(self):
+
+        localctx = CParser.ConditionalExpressionContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 38, self.RULE_conditionalExpression)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 477
+            self.logicalOrExpression(0)
+            self.state = 483
+            la_ = self._interp.adaptivePredict(self._input,27,self._ctx)
+            if la_ == 1:
+                self.state = 478
+                self.match(CParser.Question)
+                self.state = 479
+                self.expression(0)
+                self.state = 480
+                self.match(CParser.Colon)
+                self.state = 481
+                self.conditionalExpression()
+
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class AssignmentExpressionContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def conditionalExpression(self):
+            return self.getTypedRuleContext(CParser.ConditionalExpressionContext,0)
+
+
+        def unaryExpression(self):
+            return self.getTypedRuleContext(CParser.UnaryExpressionContext,0)
+
+
+        def assignmentOperator(self):
+            return self.getTypedRuleContext(CParser.AssignmentOperatorContext,0)
+
+
+        def assignmentExpression(self):
+            return self.getTypedRuleContext(CParser.AssignmentExpressionContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_assignmentExpression
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterAssignmentExpression" ):
+                listener.enterAssignmentExpression(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitAssignmentExpression" ):
+                listener.exitAssignmentExpression(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitAssignmentExpression" ):
+                return visitor.visitAssignmentExpression(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def assignmentExpression(self):
+
+        localctx = CParser.AssignmentExpressionContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 40, self.RULE_assignmentExpression)
+        try:
+            self.state = 490
+            la_ = self._interp.adaptivePredict(self._input,28,self._ctx)
+            if la_ == 1:
+                self.enterOuterAlt(localctx, 1)
+                self.state = 485
+                self.conditionalExpression()
+                pass
+
+            elif la_ == 2:
+                self.enterOuterAlt(localctx, 2)
+                self.state = 486
+                self.unaryExpression()
+                self.state = 487
+                self.assignmentOperator()
+                self.state = 488
+                self.assignmentExpression()
+                pass
+
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class AssignmentOperatorContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_assignmentOperator
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterAssignmentOperator" ):
+                listener.enterAssignmentOperator(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitAssignmentOperator" ):
+                listener.exitAssignmentOperator(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitAssignmentOperator" ):
+                return visitor.visitAssignmentOperator(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def assignmentOperator(self):
+
+        localctx = CParser.AssignmentOperatorContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 42, self.RULE_assignmentOperator)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 492
+            _la = self._input.LA(1)
+            if not(((((_la - 89)) & ~0x3f) == 0 and ((1 << (_la - 89)) & ((1 << (CParser.Assign - 89)) | (1 << (CParser.StarAssign - 89)) | (1 << (CParser.DivAssign - 89)) | (1 << (CParser.ModAssign - 89)) | (1 << (CParser.PlusAssign - 89)) | (1 << (CParser.MinusAssign - 89)) | (1 << (CParser.LeftShiftAssign - 89)) | (1 << (CParser.RightShiftAssign - 89)) | (1 << (CParser.AndAssign - 89)) | (1 << (CParser.XorAssign - 89)) | (1 << (CParser.OrAssign - 89)))) != 0)):
+                self._errHandler.recoverInline(self)
+            else:
+                self.consume()
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class ExpressionContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def assignmentExpression(self):
+            return self.getTypedRuleContext(CParser.AssignmentExpressionContext,0)
+
+
+        def expression(self):
+            return self.getTypedRuleContext(CParser.ExpressionContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_expression
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterExpression" ):
+                listener.enterExpression(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitExpression" ):
+                listener.exitExpression(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitExpression" ):
+                return visitor.visitExpression(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+    def expression(self, _p:int=0):
+        _parentctx = self._ctx
+        _parentState = self.state
+        localctx = CParser.ExpressionContext(self, self._ctx, _parentState)
+        _prevctx = localctx
+        _startState = 44
+        self.enterRecursionRule(localctx, 44, self.RULE_expression, _p)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 495
+            self.assignmentExpression()
+            self._ctx.stop = self._input.LT(-1)
+            self.state = 502
+            self._errHandler.sync(self)
+            _alt = self._interp.adaptivePredict(self._input,29,self._ctx)
+            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                if _alt==1:
+                    if self._parseListeners is not None:
+                        self.triggerExitRuleEvent()
+                    _prevctx = localctx
+                    localctx = CParser.ExpressionContext(self, _parentctx, _parentState)
+                    self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
+                    self.state = 497
+                    if not self.precpred(self._ctx, 1):
+                        from antlr4.error.Errors import FailedPredicateException
+                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
+                    self.state = 498
+                    self.match(CParser.Comma)
+                    self.state = 499
+                    self.assignmentExpression()
+                self.state = 504
+                self._errHandler.sync(self)
+                _alt = self._interp.adaptivePredict(self._input,29,self._ctx)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.unrollRecursionContexts(_parentctx)
+        return localctx
+
+    class ConstantExpressionContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def conditionalExpression(self):
+            return self.getTypedRuleContext(CParser.ConditionalExpressionContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_constantExpression
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterConstantExpression" ):
+                listener.enterConstantExpression(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitConstantExpression" ):
+                listener.exitConstantExpression(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitConstantExpression" ):
+                return visitor.visitConstantExpression(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def constantExpression(self):
+
+        localctx = CParser.ConstantExpressionContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 46, self.RULE_constantExpression)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 505
+            self.conditionalExpression()
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class DeclarationContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def declarationSpecifiers(self):
+            return self.getTypedRuleContext(CParser.DeclarationSpecifiersContext,0)
+
+
+        def initDeclaratorList(self):
+            return self.getTypedRuleContext(CParser.InitDeclaratorListContext,0)
+
+
+        def staticAssertDeclaration(self):
+            return self.getTypedRuleContext(CParser.StaticAssertDeclarationContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_declaration
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterDeclaration" ):
+                listener.enterDeclaration(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitDeclaration" ):
+                listener.exitDeclaration(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitDeclaration" ):
+                return visitor.visitDeclaration(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def declaration(self):
+
+        localctx = CParser.DeclarationContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 48, self.RULE_declaration)
+        self._la = 0 # Token type
+        try:
+            self.state = 514
+            token = self._input.LA(1)
+            if token in [CParser.T__0, CParser.T__3, CParser.T__4, CParser.T__5, CParser.T__6, CParser.T__7, CParser.T__8, CParser.T__9, CParser.T__11, CParser.Auto, CParser.Char, CParser.Const, CParser.Double, CParser.Enum, CParser.Extern, CParser.Float, CParser.Inline, CParser.Int, CParser.Long, CParser.Register, CParser.Restrict, CParser.Short, CParser.Signed, CParser.Static, CParser.Struct, CParser.Typedef, CParser.Union, CParser.Unsigned, CParser.Void, CParser.Volatile, CParser.Alignas, CParser.Atomic, CParser.Bool, CParser.Complex, CParser.Noreturn, CParser.ThreadLocal, CParser.Identifier]:
+                self.enterOuterAlt(localctx, 1)
+                self.state = 507
+                self.declarationSpecifiers()
+                self.state = 509
+                _la = self._input.LA(1)
+                if ((((_la - 59)) & ~0x3f) == 0 and ((1 << (_la - 59)) & ((1 << (CParser.LeftParen - 59)) | (1 << (CParser.Star - 59)) | (1 << (CParser.Caret - 59)) | (1 << (CParser.Identifier - 59)))) != 0):
+                    self.state = 508
+                    self.initDeclaratorList(0)
+
+
+                self.state = 511
+                self.match(CParser.Semi)
+
+            elif token in [CParser.StaticAssert]:
+                self.enterOuterAlt(localctx, 2)
+                self.state = 513
+                self.staticAssertDeclaration()
+
+            else:
+                raise NoViableAltException(self)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class DeclarationSpecifiersContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def declarationSpecifier(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(CParser.DeclarationSpecifierContext)
+            else:
+                return self.getTypedRuleContext(CParser.DeclarationSpecifierContext,i)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_declarationSpecifiers
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterDeclarationSpecifiers" ):
+                listener.enterDeclarationSpecifiers(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitDeclarationSpecifiers" ):
+                listener.exitDeclarationSpecifiers(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitDeclarationSpecifiers" ):
+                return visitor.visitDeclarationSpecifiers(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def declarationSpecifiers(self):
+
+        localctx = CParser.DeclarationSpecifiersContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 50, self.RULE_declarationSpecifiers)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 517
+            self._errHandler.sync(self)
+            _alt = 1
+            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                if _alt == 1:
+                    self.state = 516
+                    self.declarationSpecifier()
+
+                else:
+                    raise NoViableAltException(self)
+                self.state = 519
+                self._errHandler.sync(self)
+                _alt = self._interp.adaptivePredict(self._input,32,self._ctx)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class DeclarationSpecifiers2Context(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def declarationSpecifier(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(CParser.DeclarationSpecifierContext)
+            else:
+                return self.getTypedRuleContext(CParser.DeclarationSpecifierContext,i)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_declarationSpecifiers2
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterDeclarationSpecifiers2" ):
+                listener.enterDeclarationSpecifiers2(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitDeclarationSpecifiers2" ):
+                listener.exitDeclarationSpecifiers2(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitDeclarationSpecifiers2" ):
+                return visitor.visitDeclarationSpecifiers2(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def declarationSpecifiers2(self):
+
+        localctx = CParser.DeclarationSpecifiers2Context(self, self._ctx, self.state)
+        self.enterRule(localctx, 52, self.RULE_declarationSpecifiers2)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 522
+            self._errHandler.sync(self)
+            _alt = 1
+            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                if _alt == 1:
+                    self.state = 521
+                    self.declarationSpecifier()
+
+                else:
+                    raise NoViableAltException(self)
+                self.state = 524
+                self._errHandler.sync(self)
+                _alt = self._interp.adaptivePredict(self._input,33,self._ctx)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class DeclarationSpecifierContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def storageClassSpecifier(self):
+            return self.getTypedRuleContext(CParser.StorageClassSpecifierContext,0)
+
+
+        def typeSpecifier(self):
+            return self.getTypedRuleContext(CParser.TypeSpecifierContext,0)
+
+
+        def typeQualifier(self):
+            return self.getTypedRuleContext(CParser.TypeQualifierContext,0)
+
+
+        def functionSpecifier(self):
+            return self.getTypedRuleContext(CParser.FunctionSpecifierContext,0)
+
+
+        def alignmentSpecifier(self):
+            return self.getTypedRuleContext(CParser.AlignmentSpecifierContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_declarationSpecifier
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterDeclarationSpecifier" ):
+                listener.enterDeclarationSpecifier(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitDeclarationSpecifier" ):
+                listener.exitDeclarationSpecifier(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitDeclarationSpecifier" ):
+                return visitor.visitDeclarationSpecifier(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def declarationSpecifier(self):
+
+        localctx = CParser.DeclarationSpecifierContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 54, self.RULE_declarationSpecifier)
+        try:
+            self.state = 531
+            la_ = self._interp.adaptivePredict(self._input,34,self._ctx)
+            if la_ == 1:
+                self.enterOuterAlt(localctx, 1)
+                self.state = 526
+                self.storageClassSpecifier()
+                pass
+
+            elif la_ == 2:
+                self.enterOuterAlt(localctx, 2)
+                self.state = 527
+                self.typeSpecifier()
+                pass
+
+            elif la_ == 3:
+                self.enterOuterAlt(localctx, 3)
+                self.state = 528
+                self.typeQualifier()
+                pass
+
+            elif la_ == 4:
+                self.enterOuterAlt(localctx, 4)
+                self.state = 529
+                self.functionSpecifier()
+                pass
+
+            elif la_ == 5:
+                self.enterOuterAlt(localctx, 5)
+                self.state = 530
+                self.alignmentSpecifier()
+                pass
+
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class InitDeclaratorListContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def initDeclarator(self):
+            return self.getTypedRuleContext(CParser.InitDeclaratorContext,0)
+
+
+        def initDeclaratorList(self):
+            return self.getTypedRuleContext(CParser.InitDeclaratorListContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_initDeclaratorList
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterInitDeclaratorList" ):
+                listener.enterInitDeclaratorList(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitInitDeclaratorList" ):
+                listener.exitInitDeclaratorList(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitInitDeclaratorList" ):
+                return visitor.visitInitDeclaratorList(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+    def initDeclaratorList(self, _p:int=0):
+        _parentctx = self._ctx
+        _parentState = self.state
+        localctx = CParser.InitDeclaratorListContext(self, self._ctx, _parentState)
+        _prevctx = localctx
+        _startState = 56
+        self.enterRecursionRule(localctx, 56, self.RULE_initDeclaratorList, _p)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 534
+            self.initDeclarator()
+            self._ctx.stop = self._input.LT(-1)
+            self.state = 541
+            self._errHandler.sync(self)
+            _alt = self._interp.adaptivePredict(self._input,35,self._ctx)
+            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                if _alt==1:
+                    if self._parseListeners is not None:
+                        self.triggerExitRuleEvent()
+                    _prevctx = localctx
+                    localctx = CParser.InitDeclaratorListContext(self, _parentctx, _parentState)
+                    self.pushNewRecursionContext(localctx, _startState, self.RULE_initDeclaratorList)
+                    self.state = 536
+                    if not self.precpred(self._ctx, 1):
+                        from antlr4.error.Errors import FailedPredicateException
+                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
+                    self.state = 537
+                    self.match(CParser.Comma)
+                    self.state = 538
+                    self.initDeclarator()
+                self.state = 543
+                self._errHandler.sync(self)
+                _alt = self._interp.adaptivePredict(self._input,35,self._ctx)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.unrollRecursionContexts(_parentctx)
+        return localctx
+
+    class InitDeclaratorContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def declarator(self):
+            return self.getTypedRuleContext(CParser.DeclaratorContext,0)
+
+
+        def initializer(self):
+            return self.getTypedRuleContext(CParser.InitializerContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_initDeclarator
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterInitDeclarator" ):
+                listener.enterInitDeclarator(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitInitDeclarator" ):
+                listener.exitInitDeclarator(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitInitDeclarator" ):
+                return visitor.visitInitDeclarator(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def initDeclarator(self):
+
+        localctx = CParser.InitDeclaratorContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 58, self.RULE_initDeclarator)
+        try:
+            self.state = 549
+            la_ = self._interp.adaptivePredict(self._input,36,self._ctx)
+            if la_ == 1:
+                self.enterOuterAlt(localctx, 1)
+                self.state = 544
+                self.declarator()
+                pass
+
+            elif la_ == 2:
+                self.enterOuterAlt(localctx, 2)
+                self.state = 545
+                self.declarator()
+                self.state = 546
+                self.match(CParser.Assign)
+                self.state = 547
+                self.initializer()
+                pass
+
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class StorageClassSpecifierContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_storageClassSpecifier
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterStorageClassSpecifier" ):
+                listener.enterStorageClassSpecifier(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitStorageClassSpecifier" ):
+                listener.exitStorageClassSpecifier(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitStorageClassSpecifier" ):
+                return visitor.visitStorageClassSpecifier(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def storageClassSpecifier(self):
+
+        localctx = CParser.StorageClassSpecifierContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 60, self.RULE_storageClassSpecifier)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 551
+            _la = self._input.LA(1)
+            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.Auto) | (1 << CParser.Extern) | (1 << CParser.Register) | (1 << CParser.Static) | (1 << CParser.Typedef) | (1 << CParser.ThreadLocal))) != 0)):
+                self._errHandler.recoverInline(self)
+            else:
+                self.consume()
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class TypeSpecifierContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def atomicTypeSpecifier(self):
+            return self.getTypedRuleContext(CParser.AtomicTypeSpecifierContext,0)
+
+
+        def structOrUnionSpecifier(self):
+            return self.getTypedRuleContext(CParser.StructOrUnionSpecifierContext,0)
+
+
+        def enumSpecifier(self):
+            return self.getTypedRuleContext(CParser.EnumSpecifierContext,0)
+
+
+        def typedefName(self):
+            return self.getTypedRuleContext(CParser.TypedefNameContext,0)
+
+
+        def constantExpression(self):
+            return self.getTypedRuleContext(CParser.ConstantExpressionContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_typeSpecifier
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterTypeSpecifier" ):
+                listener.enterTypeSpecifier(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitTypeSpecifier" ):
+                listener.exitTypeSpecifier(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitTypeSpecifier" ):
+                return visitor.visitTypeSpecifier(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def typeSpecifier(self):
+
+        localctx = CParser.TypeSpecifierContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 62, self.RULE_typeSpecifier)
+        self._la = 0 # Token type
+        try:
+            self.state = 567
+            token = self._input.LA(1)
+            if token in [CParser.T__3, CParser.T__4, CParser.T__5, CParser.Char, CParser.Double, CParser.Float, CParser.Int, CParser.Long, CParser.Short, CParser.Signed, CParser.Unsigned, CParser.Void, CParser.Bool, CParser.Complex]:
+                self.enterOuterAlt(localctx, 1)
+                self.state = 553
+                _la = self._input.LA(1)
+                if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__3) | (1 << CParser.T__4) | (1 << CParser.T__5) | (1 << CParser.Char) | (1 << CParser.Double) | (1 << CParser.Float) | (1 << CParser.Int) | (1 << CParser.Long) | (1 << CParser.Short) | (1 << CParser.Signed) | (1 << CParser.Unsigned) | (1 << CParser.Void) | (1 << CParser.Bool) | (1 << CParser.Complex))) != 0)):
+                    self._errHandler.recoverInline(self)
+                else:
+                    self.consume()
+
+            elif token in [CParser.T__0]:
+                self.enterOuterAlt(localctx, 2)
+                self.state = 554
+                self.match(CParser.T__0)
+                self.state = 555
+                self.match(CParser.LeftParen)
+                self.state = 556
+                _la = self._input.LA(1)
+                if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__3) | (1 << CParser.T__4) | (1 << CParser.T__5))) != 0)):
+                    self._errHandler.recoverInline(self)
+                else:
+                    self.consume()
+                self.state = 557
+                self.match(CParser.RightParen)
+
+            elif token in [CParser.Atomic]:
+                self.enterOuterAlt(localctx, 3)
+                self.state = 558
+                self.atomicTypeSpecifier()
+
+            elif token in [CParser.Struct, CParser.Union]:
+                self.enterOuterAlt(localctx, 4)
+                self.state = 559
+                self.structOrUnionSpecifier()
+
+            elif token in [CParser.Enum]:
+                self.enterOuterAlt(localctx, 5)
+                self.state = 560
+                self.enumSpecifier()
+
+            elif token in [CParser.Identifier]:
+                self.enterOuterAlt(localctx, 6)
+                self.state = 561
+                self.typedefName()
+
+            elif token in [CParser.T__6]:
+                self.enterOuterAlt(localctx, 7)
+                self.state = 562
+                self.match(CParser.T__6)
+                self.state = 563
+                self.match(CParser.LeftParen)
+                self.state = 564
+                self.constantExpression()
+                self.state = 565
+                self.match(CParser.RightParen)
+
+            else:
+                raise NoViableAltException(self)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class StructOrUnionSpecifierContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def structOrUnion(self):
+            return self.getTypedRuleContext(CParser.StructOrUnionContext,0)
+
+
+        def structDeclarationList(self):
+            return self.getTypedRuleContext(CParser.StructDeclarationListContext,0)
+
+
+        def Identifier(self):
+            return self.getToken(CParser.Identifier, 0)
+
+        def getRuleIndex(self):
+            return CParser.RULE_structOrUnionSpecifier
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterStructOrUnionSpecifier" ):
+                listener.enterStructOrUnionSpecifier(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitStructOrUnionSpecifier" ):
+                listener.exitStructOrUnionSpecifier(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitStructOrUnionSpecifier" ):
+                return visitor.visitStructOrUnionSpecifier(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def structOrUnionSpecifier(self):
+
+        localctx = CParser.StructOrUnionSpecifierContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 64, self.RULE_structOrUnionSpecifier)
+        self._la = 0 # Token type
+        try:
+            self.state = 580
+            la_ = self._interp.adaptivePredict(self._input,39,self._ctx)
+            if la_ == 1:
+                self.enterOuterAlt(localctx, 1)
+                self.state = 569
+                self.structOrUnion()
+                self.state = 571
+                _la = self._input.LA(1)
+                if _la==CParser.Identifier:
+                    self.state = 570
+                    self.match(CParser.Identifier)
+
+
+                self.state = 573
+                self.match(CParser.LeftBrace)
+                self.state = 574
+                self.structDeclarationList(0)
+                self.state = 575
+                self.match(CParser.RightBrace)
+                pass
+
+            elif la_ == 2:
+                self.enterOuterAlt(localctx, 2)
+                self.state = 577
+                self.structOrUnion()
+                self.state = 578
+                self.match(CParser.Identifier)
+                pass
+
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class StructOrUnionContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_structOrUnion
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterStructOrUnion" ):
+                listener.enterStructOrUnion(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitStructOrUnion" ):
+                listener.exitStructOrUnion(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitStructOrUnion" ):
+                return visitor.visitStructOrUnion(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def structOrUnion(self):
+
+        localctx = CParser.StructOrUnionContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 66, self.RULE_structOrUnion)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 582
+            _la = self._input.LA(1)
+            if not(_la==CParser.Struct or _la==CParser.Union):
+                self._errHandler.recoverInline(self)
+            else:
+                self.consume()
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class StructDeclarationListContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def structDeclaration(self):
+            return self.getTypedRuleContext(CParser.StructDeclarationContext,0)
+
+
+        def structDeclarationList(self):
+            return self.getTypedRuleContext(CParser.StructDeclarationListContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_structDeclarationList
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterStructDeclarationList" ):
+                listener.enterStructDeclarationList(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitStructDeclarationList" ):
+                listener.exitStructDeclarationList(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitStructDeclarationList" ):
+                return visitor.visitStructDeclarationList(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+    def structDeclarationList(self, _p:int=0):
+        _parentctx = self._ctx
+        _parentState = self.state
+        localctx = CParser.StructDeclarationListContext(self, self._ctx, _parentState)
+        _prevctx = localctx
+        _startState = 68
+        self.enterRecursionRule(localctx, 68, self.RULE_structDeclarationList, _p)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 585
+            self.structDeclaration()
+            self._ctx.stop = self._input.LT(-1)
+            self.state = 591
+            self._errHandler.sync(self)
+            _alt = self._interp.adaptivePredict(self._input,40,self._ctx)
+            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                if _alt==1:
+                    if self._parseListeners is not None:
+                        self.triggerExitRuleEvent()
+                    _prevctx = localctx
+                    localctx = CParser.StructDeclarationListContext(self, _parentctx, _parentState)
+                    self.pushNewRecursionContext(localctx, _startState, self.RULE_structDeclarationList)
+                    self.state = 587
+                    if not self.precpred(self._ctx, 1):
+                        from antlr4.error.Errors import FailedPredicateException
+                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
+                    self.state = 588
+                    self.structDeclaration()
+                self.state = 593
+                self._errHandler.sync(self)
+                _alt = self._interp.adaptivePredict(self._input,40,self._ctx)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.unrollRecursionContexts(_parentctx)
+        return localctx
+
+    class StructDeclarationContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def specifierQualifierList(self):
+            return self.getTypedRuleContext(CParser.SpecifierQualifierListContext,0)
+
+
+        def structDeclaratorList(self):
+            return self.getTypedRuleContext(CParser.StructDeclaratorListContext,0)
+
+
+        def staticAssertDeclaration(self):
+            return self.getTypedRuleContext(CParser.StaticAssertDeclarationContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_structDeclaration
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterStructDeclaration" ):
+                listener.enterStructDeclaration(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitStructDeclaration" ):
+                listener.exitStructDeclaration(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitStructDeclaration" ):
+                return visitor.visitStructDeclaration(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def structDeclaration(self):
+
+        localctx = CParser.StructDeclarationContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 70, self.RULE_structDeclaration)
+        self._la = 0 # Token type
+        try:
+            self.state = 601
+            token = self._input.LA(1)
+            if token in [CParser.T__0, CParser.T__3, CParser.T__4, CParser.T__5, CParser.T__6, CParser.Char, CParser.Const, CParser.Double, CParser.Enum, CParser.Float, CParser.Int, CParser.Long, CParser.Restrict, CParser.Short, CParser.Signed, CParser.Struct, CParser.Union, CParser.Unsigned, CParser.Void, CParser.Volatile, CParser.Atomic, CParser.Bool, CParser.Complex, CParser.Identifier]:
+                self.enterOuterAlt(localctx, 1)
+                self.state = 594
+                self.specifierQualifierList()
+                self.state = 596
+                _la = self._input.LA(1)
+                if ((((_la - 59)) & ~0x3f) == 0 and ((1 << (_la - 59)) & ((1 << (CParser.LeftParen - 59)) | (1 << (CParser.Star - 59)) | (1 << (CParser.Caret - 59)) | (1 << (CParser.Colon - 59)) | (1 << (CParser.Identifier - 59)))) != 0):
+                    self.state = 595
+                    self.structDeclaratorList(0)
+
+
+                self.state = 598
+                self.match(CParser.Semi)
+
+            elif token in [CParser.StaticAssert]:
+                self.enterOuterAlt(localctx, 2)
+                self.state = 600
+                self.staticAssertDeclaration()
+
+            else:
+                raise NoViableAltException(self)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class SpecifierQualifierListContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def typeSpecifier(self):
+            return self.getTypedRuleContext(CParser.TypeSpecifierContext,0)
+
+
+        def specifierQualifierList(self):
+            return self.getTypedRuleContext(CParser.SpecifierQualifierListContext,0)
+
+
+        def typeQualifier(self):
+            return self.getTypedRuleContext(CParser.TypeQualifierContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_specifierQualifierList
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterSpecifierQualifierList" ):
+                listener.enterSpecifierQualifierList(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitSpecifierQualifierList" ):
+                listener.exitSpecifierQualifierList(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitSpecifierQualifierList" ):
+                return visitor.visitSpecifierQualifierList(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def specifierQualifierList(self):
+
+        localctx = CParser.SpecifierQualifierListContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 72, self.RULE_specifierQualifierList)
+        try:
+            self.state = 611
+            la_ = self._interp.adaptivePredict(self._input,45,self._ctx)
+            if la_ == 1:
+                self.enterOuterAlt(localctx, 1)
+                self.state = 603
+                self.typeSpecifier()
+                self.state = 605
+                la_ = self._interp.adaptivePredict(self._input,43,self._ctx)
+                if la_ == 1:
+                    self.state = 604
+                    self.specifierQualifierList()
+
+
+                pass
+
+            elif la_ == 2:
+                self.enterOuterAlt(localctx, 2)
+                self.state = 607
+                self.typeQualifier()
+                self.state = 609
+                la_ = self._interp.adaptivePredict(self._input,44,self._ctx)
+                if la_ == 1:
+                    self.state = 608
+                    self.specifierQualifierList()
+
+
+                pass
+
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class StructDeclaratorListContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def structDeclarator(self):
+            return self.getTypedRuleContext(CParser.StructDeclaratorContext,0)
+
+
+        def structDeclaratorList(self):
+            return self.getTypedRuleContext(CParser.StructDeclaratorListContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_structDeclaratorList
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterStructDeclaratorList" ):
+                listener.enterStructDeclaratorList(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitStructDeclaratorList" ):
+                listener.exitStructDeclaratorList(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitStructDeclaratorList" ):
+                return visitor.visitStructDeclaratorList(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+    def structDeclaratorList(self, _p:int=0):
+        _parentctx = self._ctx
+        _parentState = self.state
+        localctx = CParser.StructDeclaratorListContext(self, self._ctx, _parentState)
+        _prevctx = localctx
+        _startState = 74
+        self.enterRecursionRule(localctx, 74, self.RULE_structDeclaratorList, _p)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 614
+            self.structDeclarator()
+            self._ctx.stop = self._input.LT(-1)
+            self.state = 621
+            self._errHandler.sync(self)
+            _alt = self._interp.adaptivePredict(self._input,46,self._ctx)
+            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                if _alt==1:
+                    if self._parseListeners is not None:
+                        self.triggerExitRuleEvent()
+                    _prevctx = localctx
+                    localctx = CParser.StructDeclaratorListContext(self, _parentctx, _parentState)
+                    self.pushNewRecursionContext(localctx, _startState, self.RULE_structDeclaratorList)
+                    self.state = 616
+                    if not self.precpred(self._ctx, 1):
+                        from antlr4.error.Errors import FailedPredicateException
+                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
+                    self.state = 617
+                    self.match(CParser.Comma)
+                    self.state = 618
+                    self.structDeclarator()
+                self.state = 623
+                self._errHandler.sync(self)
+                _alt = self._interp.adaptivePredict(self._input,46,self._ctx)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.unrollRecursionContexts(_parentctx)
+        return localctx
+
+    class StructDeclaratorContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def declarator(self):
+            return self.getTypedRuleContext(CParser.DeclaratorContext,0)
+
+
+        def constantExpression(self):
+            return self.getTypedRuleContext(CParser.ConstantExpressionContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_structDeclarator
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterStructDeclarator" ):
+                listener.enterStructDeclarator(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitStructDeclarator" ):
+                listener.exitStructDeclarator(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitStructDeclarator" ):
+                return visitor.visitStructDeclarator(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def structDeclarator(self):
+
+        localctx = CParser.StructDeclaratorContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 76, self.RULE_structDeclarator)
+        self._la = 0 # Token type
+        try:
+            self.state = 630
+            la_ = self._interp.adaptivePredict(self._input,48,self._ctx)
+            if la_ == 1:
+                self.enterOuterAlt(localctx, 1)
+                self.state = 624
+                self.declarator()
+                pass
+
+            elif la_ == 2:
+                self.enterOuterAlt(localctx, 2)
+                self.state = 626
+                _la = self._input.LA(1)
+                if ((((_la - 59)) & ~0x3f) == 0 and ((1 << (_la - 59)) & ((1 << (CParser.LeftParen - 59)) | (1 << (CParser.Star - 59)) | (1 << (CParser.Caret - 59)) | (1 << (CParser.Identifier - 59)))) != 0):
+                    self.state = 625
+                    self.declarator()
+
+
+                self.state = 628
+                self.match(CParser.Colon)
+                self.state = 629
+                self.constantExpression()
+                pass
+
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class EnumSpecifierContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def enumeratorList(self):
+            return self.getTypedRuleContext(CParser.EnumeratorListContext,0)
+
+
+        def Identifier(self):
+            return self.getToken(CParser.Identifier, 0)
+
+        def getRuleIndex(self):
+            return CParser.RULE_enumSpecifier
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterEnumSpecifier" ):
+                listener.enterEnumSpecifier(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitEnumSpecifier" ):
+                listener.exitEnumSpecifier(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitEnumSpecifier" ):
+                return visitor.visitEnumSpecifier(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def enumSpecifier(self):
+
+        localctx = CParser.EnumSpecifierContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 78, self.RULE_enumSpecifier)
+        self._la = 0 # Token type
+        try:
+            self.state = 651
+            la_ = self._interp.adaptivePredict(self._input,51,self._ctx)
+            if la_ == 1:
+                self.enterOuterAlt(localctx, 1)
+                self.state = 632
+                self.match(CParser.Enum)
+                self.state = 634
+                _la = self._input.LA(1)
+                if _la==CParser.Identifier:
+                    self.state = 633
+                    self.match(CParser.Identifier)
+
+
+                self.state = 636
+                self.match(CParser.LeftBrace)
+                self.state = 637
+                self.enumeratorList(0)
+                self.state = 638
+                self.match(CParser.RightBrace)
+                pass
+
+            elif la_ == 2:
+                self.enterOuterAlt(localctx, 2)
+                self.state = 640
+                self.match(CParser.Enum)
+                self.state = 642
+                _la = self._input.LA(1)
+                if _la==CParser.Identifier:
+                    self.state = 641
+                    self.match(CParser.Identifier)
+
+
+                self.state = 644
+                self.match(CParser.LeftBrace)
+                self.state = 645
+                self.enumeratorList(0)
+                self.state = 646
+                self.match(CParser.Comma)
+                self.state = 647
+                self.match(CParser.RightBrace)
+                pass
+
+            elif la_ == 3:
+                self.enterOuterAlt(localctx, 3)
+                self.state = 649
+                self.match(CParser.Enum)
+                self.state = 650
+                self.match(CParser.Identifier)
+                pass
+
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class EnumeratorListContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def enumerator(self):
+            return self.getTypedRuleContext(CParser.EnumeratorContext,0)
+
+
+        def enumeratorList(self):
+            return self.getTypedRuleContext(CParser.EnumeratorListContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_enumeratorList
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterEnumeratorList" ):
+                listener.enterEnumeratorList(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitEnumeratorList" ):
+                listener.exitEnumeratorList(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitEnumeratorList" ):
+                return visitor.visitEnumeratorList(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+    def enumeratorList(self, _p:int=0):
+        _parentctx = self._ctx
+        _parentState = self.state
+        localctx = CParser.EnumeratorListContext(self, self._ctx, _parentState)
+        _prevctx = localctx
+        _startState = 80
+        self.enterRecursionRule(localctx, 80, self.RULE_enumeratorList, _p)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 654
+            self.enumerator()
+            self._ctx.stop = self._input.LT(-1)
+            self.state = 661
+            self._errHandler.sync(self)
+            _alt = self._interp.adaptivePredict(self._input,52,self._ctx)
+            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                if _alt==1:
+                    if self._parseListeners is not None:
+                        self.triggerExitRuleEvent()
+                    _prevctx = localctx
+                    localctx = CParser.EnumeratorListContext(self, _parentctx, _parentState)
+                    self.pushNewRecursionContext(localctx, _startState, self.RULE_enumeratorList)
+                    self.state = 656
+                    if not self.precpred(self._ctx, 1):
+                        from antlr4.error.Errors import FailedPredicateException
+                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
+                    self.state = 657
+                    self.match(CParser.Comma)
+                    self.state = 658
+                    self.enumerator()
+                self.state = 663
+                self._errHandler.sync(self)
+                _alt = self._interp.adaptivePredict(self._input,52,self._ctx)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.unrollRecursionContexts(_parentctx)
+        return localctx
+
+    class EnumeratorContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def enumerationConstant(self):
+            return self.getTypedRuleContext(CParser.EnumerationConstantContext,0)
+
+
+        def constantExpression(self):
+            return self.getTypedRuleContext(CParser.ConstantExpressionContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_enumerator
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterEnumerator" ):
+                listener.enterEnumerator(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitEnumerator" ):
+                listener.exitEnumerator(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitEnumerator" ):
+                return visitor.visitEnumerator(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def enumerator(self):
+
+        localctx = CParser.EnumeratorContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 82, self.RULE_enumerator)
+        try:
+            self.state = 669
+            la_ = self._interp.adaptivePredict(self._input,53,self._ctx)
+            if la_ == 1:
+                self.enterOuterAlt(localctx, 1)
+                self.state = 664
+                self.enumerationConstant()
+                pass
+
+            elif la_ == 2:
+                self.enterOuterAlt(localctx, 2)
+                self.state = 665
+                self.enumerationConstant()
+                self.state = 666
+                self.match(CParser.Assign)
+                self.state = 667
+                self.constantExpression()
+                pass
+
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class EnumerationConstantContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def Identifier(self):
+            return self.getToken(CParser.Identifier, 0)
+
+        def getRuleIndex(self):
+            return CParser.RULE_enumerationConstant
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterEnumerationConstant" ):
+                listener.enterEnumerationConstant(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitEnumerationConstant" ):
+                listener.exitEnumerationConstant(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitEnumerationConstant" ):
+                return visitor.visitEnumerationConstant(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def enumerationConstant(self):
+
+        localctx = CParser.EnumerationConstantContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 84, self.RULE_enumerationConstant)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 671
+            self.match(CParser.Identifier)
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class AtomicTypeSpecifierContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def typeName(self):
+            return self.getTypedRuleContext(CParser.TypeNameContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_atomicTypeSpecifier
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterAtomicTypeSpecifier" ):
+                listener.enterAtomicTypeSpecifier(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitAtomicTypeSpecifier" ):
+                listener.exitAtomicTypeSpecifier(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitAtomicTypeSpecifier" ):
+                return visitor.visitAtomicTypeSpecifier(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def atomicTypeSpecifier(self):
+
+        localctx = CParser.AtomicTypeSpecifierContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 86, self.RULE_atomicTypeSpecifier)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 673
+            self.match(CParser.Atomic)
+            self.state = 674
+            self.match(CParser.LeftParen)
+            self.state = 675
+            self.typeName()
+            self.state = 676
+            self.match(CParser.RightParen)
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class TypeQualifierContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_typeQualifier
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterTypeQualifier" ):
+                listener.enterTypeQualifier(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitTypeQualifier" ):
+                listener.exitTypeQualifier(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitTypeQualifier" ):
+                return visitor.visitTypeQualifier(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def typeQualifier(self):
+
+        localctx = CParser.TypeQualifierContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 88, self.RULE_typeQualifier)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 678
+            _la = self._input.LA(1)
+            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.Const) | (1 << CParser.Restrict) | (1 << CParser.Volatile) | (1 << CParser.Atomic))) != 0)):
+                self._errHandler.recoverInline(self)
+            else:
+                self.consume()
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class FunctionSpecifierContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def gccAttributeSpecifier(self):
+            return self.getTypedRuleContext(CParser.GccAttributeSpecifierContext,0)
+
+
+        def Identifier(self):
+            return self.getToken(CParser.Identifier, 0)
+
+        def getRuleIndex(self):
+            return CParser.RULE_functionSpecifier
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterFunctionSpecifier" ):
+                listener.enterFunctionSpecifier(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitFunctionSpecifier" ):
+                listener.exitFunctionSpecifier(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitFunctionSpecifier" ):
+                return visitor.visitFunctionSpecifier(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def functionSpecifier(self):
+
+        localctx = CParser.FunctionSpecifierContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 90, self.RULE_functionSpecifier)
+        self._la = 0 # Token type
+        try:
+            self.state = 686
+            token = self._input.LA(1)
+            if token in [CParser.T__7, CParser.T__8, CParser.Inline, CParser.Noreturn]:
+                self.enterOuterAlt(localctx, 1)
+                self.state = 680
+                _la = self._input.LA(1)
+                if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__7) | (1 << CParser.T__8) | (1 << CParser.Inline) | (1 << CParser.Noreturn))) != 0)):
+                    self._errHandler.recoverInline(self)
+                else:
+                    self.consume()
+
+            elif token in [CParser.T__11]:
+                self.enterOuterAlt(localctx, 2)
+                self.state = 681
+                self.gccAttributeSpecifier()
+
+            elif token in [CParser.T__9]:
+                self.enterOuterAlt(localctx, 3)
+                self.state = 682
+                self.match(CParser.T__9)
+                self.state = 683
+                self.match(CParser.LeftParen)
+                self.state = 684
+                self.match(CParser.Identifier)
+                self.state = 685
+                self.match(CParser.RightParen)
+
+            else:
+                raise NoViableAltException(self)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class AlignmentSpecifierContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def typeName(self):
+            return self.getTypedRuleContext(CParser.TypeNameContext,0)
+
+
+        def constantExpression(self):
+            return self.getTypedRuleContext(CParser.ConstantExpressionContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_alignmentSpecifier
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterAlignmentSpecifier" ):
+                listener.enterAlignmentSpecifier(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitAlignmentSpecifier" ):
+                listener.exitAlignmentSpecifier(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitAlignmentSpecifier" ):
+                return visitor.visitAlignmentSpecifier(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def alignmentSpecifier(self):
+
+        localctx = CParser.AlignmentSpecifierContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 92, self.RULE_alignmentSpecifier)
+        try:
+            self.state = 698
+            la_ = self._interp.adaptivePredict(self._input,55,self._ctx)
+            if la_ == 1:
+                self.enterOuterAlt(localctx, 1)
+                self.state = 688
+                self.match(CParser.Alignas)
+                self.state = 689
+                self.match(CParser.LeftParen)
+                self.state = 690
+                self.typeName()
+                self.state = 691
+                self.match(CParser.RightParen)
+                pass
+
+            elif la_ == 2:
+                self.enterOuterAlt(localctx, 2)
+                self.state = 693
+                self.match(CParser.Alignas)
+                self.state = 694
+                self.match(CParser.LeftParen)
+                self.state = 695
+                self.constantExpression()
+                self.state = 696
+                self.match(CParser.RightParen)
+                pass
+
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class DeclaratorContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def directDeclarator(self):
+            return self.getTypedRuleContext(CParser.DirectDeclaratorContext,0)
+
+
+        def pointer(self):
+            return self.getTypedRuleContext(CParser.PointerContext,0)
+
+
+        def gccDeclaratorExtension(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(CParser.GccDeclaratorExtensionContext)
+            else:
+                return self.getTypedRuleContext(CParser.GccDeclaratorExtensionContext,i)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_declarator
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterDeclarator" ):
+                listener.enterDeclarator(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitDeclarator" ):
+                listener.exitDeclarator(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitDeclarator" ):
+                return visitor.visitDeclarator(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def declarator(self):
+
+        localctx = CParser.DeclaratorContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 94, self.RULE_declarator)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 701
+            _la = self._input.LA(1)
+            if _la==CParser.Star or _la==CParser.Caret:
+                self.state = 700
+                self.pointer()
+
+
+            self.state = 703
+            self.directDeclarator(0)
+            self.state = 707
+            self._errHandler.sync(self)
+            _alt = self._interp.adaptivePredict(self._input,57,self._ctx)
+            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                if _alt==1:
+                    self.state = 704
+                    self.gccDeclaratorExtension()
+                self.state = 709
+                self._errHandler.sync(self)
+                _alt = self._interp.adaptivePredict(self._input,57,self._ctx)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class DirectDeclaratorContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def Identifier(self):
+            return self.getToken(CParser.Identifier, 0)
+
+        def declarator(self):
+            return self.getTypedRuleContext(CParser.DeclaratorContext,0)
+
+
+        def directDeclarator(self):
+            return self.getTypedRuleContext(CParser.DirectDeclaratorContext,0)
+
+
+        def typeQualifierList(self):
+            return self.getTypedRuleContext(CParser.TypeQualifierListContext,0)
+
+
+        def assignmentExpression(self):
+            return self.getTypedRuleContext(CParser.AssignmentExpressionContext,0)
+
+
+        def parameterTypeList(self):
+            return self.getTypedRuleContext(CParser.ParameterTypeListContext,0)
+
+
+        def identifierList(self):
+            return self.getTypedRuleContext(CParser.IdentifierListContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_directDeclarator
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterDirectDeclarator" ):
+                listener.enterDirectDeclarator(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitDirectDeclarator" ):
+                listener.exitDirectDeclarator(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitDirectDeclarator" ):
+                return visitor.visitDirectDeclarator(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+    def directDeclarator(self, _p:int=0):
+        _parentctx = self._ctx
+        _parentState = self.state
+        localctx = CParser.DirectDeclaratorContext(self, self._ctx, _parentState)
+        _prevctx = localctx
+        _startState = 96
+        self.enterRecursionRule(localctx, 96, self.RULE_directDeclarator, _p)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 716
+            token = self._input.LA(1)
+            if token in [CParser.Identifier]:
+                self.state = 711
+                self.match(CParser.Identifier)
+
+            elif token in [CParser.LeftParen]:
+                self.state = 712
+                self.match(CParser.LeftParen)
+                self.state = 713
+                self.declarator()
+                self.state = 714
+                self.match(CParser.RightParen)
+
+            else:
+                raise NoViableAltException(self)
+
+            self._ctx.stop = self._input.LT(-1)
+            self.state = 763
+            self._errHandler.sync(self)
+            _alt = self._interp.adaptivePredict(self._input,65,self._ctx)
+            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                if _alt==1:
+                    if self._parseListeners is not None:
+                        self.triggerExitRuleEvent()
+                    _prevctx = localctx
+                    self.state = 761
+                    la_ = self._interp.adaptivePredict(self._input,64,self._ctx)
+                    if la_ == 1:
+                        localctx = CParser.DirectDeclaratorContext(self, _parentctx, _parentState)
+                        self.pushNewRecursionContext(localctx, _startState, self.RULE_directDeclarator)
+                        self.state = 718
+                        if not self.precpred(self._ctx, 6):
+                            from antlr4.error.Errors import FailedPredicateException
+                            raise FailedPredicateException(self, "self.precpred(self._ctx, 6)")
+                        self.state = 719
+                        self.match(CParser.LeftBracket)
+                        self.state = 721
+                        _la = self._input.LA(1)
+                        if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.Const) | (1 << CParser.Restrict) | (1 << CParser.Volatile) | (1 << CParser.Atomic))) != 0):
+                            self.state = 720
+                            self.typeQualifierList(0)
+
+
+                        self.state = 724
+                        _la = self._input.LA(1)
+                        if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2) | (1 << CParser.Sizeof) | (1 << CParser.Alignof) | (1 << CParser.Generic) | (1 << CParser.LeftParen))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)) | (1 << (CParser.Identifier - 71)) | (1 << (CParser.Constant - 71)) | (1 << (CParser.StringLiteral - 71)))) != 0):
+                            self.state = 723
+                            self.assignmentExpression()
+
+
+                        self.state = 726
+                        self.match(CParser.RightBracket)
+                        pass
+
+                    elif la_ == 2:
+                        localctx = CParser.DirectDeclaratorContext(self, _parentctx, _parentState)
+                        self.pushNewRecursionContext(localctx, _startState, self.RULE_directDeclarator)
+                        self.state = 727
+                        if not self.precpred(self._ctx, 5):
+                            from antlr4.error.Errors import FailedPredicateException
+                            raise FailedPredicateException(self, "self.precpred(self._ctx, 5)")
+                        self.state = 728
+                        self.match(CParser.LeftBracket)
+                        self.state = 729
+                        self.match(CParser.Static)
+                        self.state = 731
+                        _la = self._input.LA(1)
+                        if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.Const) | (1 << CParser.Restrict) | (1 << CParser.Volatile) | (1 << CParser.Atomic))) != 0):
+                            self.state = 730
+                            self.typeQualifierList(0)
+
+
+                        self.state = 733
+                        self.assignmentExpression()
+                        self.state = 734
+                        self.match(CParser.RightBracket)
+                        pass
+
+                    elif la_ == 3:
+                        localctx = CParser.DirectDeclaratorContext(self, _parentctx, _parentState)
+                        self.pushNewRecursionContext(localctx, _startState, self.RULE_directDeclarator)
+                        self.state = 736
+                        if not self.precpred(self._ctx, 4):
+                            from antlr4.error.Errors import FailedPredicateException
+                            raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
+                        self.state = 737
+                        self.match(CParser.LeftBracket)
+                        self.state = 738
+                        self.typeQualifierList(0)
+                        self.state = 739
+                        self.match(CParser.Static)
+                        self.state = 740
+                        self.assignmentExpression()
+                        self.state = 741
+                        self.match(CParser.RightBracket)
+                        pass
+
+                    elif la_ == 4:
+                        localctx = CParser.DirectDeclaratorContext(self, _parentctx, _parentState)
+                        self.pushNewRecursionContext(localctx, _startState, self.RULE_directDeclarator)
+                        self.state = 743
+                        if not self.precpred(self._ctx, 3):
+                            from antlr4.error.Errors import FailedPredicateException
+                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
+                        self.state = 744
+                        self.match(CParser.LeftBracket)
+                        self.state = 746
+                        _la = self._input.LA(1)
+                        if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.Const) | (1 << CParser.Restrict) | (1 << CParser.Volatile) | (1 << CParser.Atomic))) != 0):
+                            self.state = 745
+                            self.typeQualifierList(0)
+
+
+                        self.state = 748
+                        self.match(CParser.Star)
+                        self.state = 749
+                        self.match(CParser.RightBracket)
+                        pass
+
+                    elif la_ == 5:
+                        localctx = CParser.DirectDeclaratorContext(self, _parentctx, _parentState)
+                        self.pushNewRecursionContext(localctx, _startState, self.RULE_directDeclarator)
+                        self.state = 750
+                        if not self.precpred(self._ctx, 2):
+                            from antlr4.error.Errors import FailedPredicateException
+                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
+                        self.state = 751
+                        self.match(CParser.LeftParen)
+                        self.state = 752
+                        self.parameterTypeList()
+                        self.state = 753
+                        self.match(CParser.RightParen)
+                        pass
+
+                    elif la_ == 6:
+                        localctx = CParser.DirectDeclaratorContext(self, _parentctx, _parentState)
+                        self.pushNewRecursionContext(localctx, _startState, self.RULE_directDeclarator)
+                        self.state = 755
+                        if not self.precpred(self._ctx, 1):
+                            from antlr4.error.Errors import FailedPredicateException
+                            raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
+                        self.state = 756
+                        self.match(CParser.LeftParen)
+                        self.state = 758
+                        _la = self._input.LA(1)
+                        if _la==CParser.Identifier:
+                            self.state = 757
+                            self.identifierList(0)
+
+
+                        self.state = 760
+                        self.match(CParser.RightParen)
+                        pass
+
+
+                self.state = 765
+                self._errHandler.sync(self)
+                _alt = self._interp.adaptivePredict(self._input,65,self._ctx)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.unrollRecursionContexts(_parentctx)
+        return localctx
+
+    class GccDeclaratorExtensionContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def StringLiteral(self, i:int=None):
+            if i is None:
+                return self.getTokens(CParser.StringLiteral)
+            else:
+                return self.getToken(CParser.StringLiteral, i)
+
+        def gccAttributeSpecifier(self):
+            return self.getTypedRuleContext(CParser.GccAttributeSpecifierContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_gccDeclaratorExtension
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterGccDeclaratorExtension" ):
+                listener.enterGccDeclaratorExtension(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitGccDeclaratorExtension" ):
+                listener.exitGccDeclaratorExtension(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitGccDeclaratorExtension" ):
+                return visitor.visitGccDeclaratorExtension(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def gccDeclaratorExtension(self):
+
+        localctx = CParser.GccDeclaratorExtensionContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 98, self.RULE_gccDeclaratorExtension)
+        self._la = 0 # Token type
+        try:
+            self.state = 775
+            token = self._input.LA(1)
+            if token in [CParser.T__10]:
+                self.enterOuterAlt(localctx, 1)
+                self.state = 766
+                self.match(CParser.T__10)
+                self.state = 767
+                self.match(CParser.LeftParen)
+                self.state = 769
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+                while True:
+                    self.state = 768
+                    self.match(CParser.StringLiteral)
+                    self.state = 771
+                    self._errHandler.sync(self)
+                    _la = self._input.LA(1)
+                    if not (_la==CParser.StringLiteral):
+                        break
+
+                self.state = 773
+                self.match(CParser.RightParen)
+
+            elif token in [CParser.T__11]:
+                self.enterOuterAlt(localctx, 2)
+                self.state = 774
+                self.gccAttributeSpecifier()
+
+            else:
+                raise NoViableAltException(self)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class GccAttributeSpecifierContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def gccAttributeList(self):
+            return self.getTypedRuleContext(CParser.GccAttributeListContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_gccAttributeSpecifier
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterGccAttributeSpecifier" ):
+                listener.enterGccAttributeSpecifier(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitGccAttributeSpecifier" ):
+                listener.exitGccAttributeSpecifier(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitGccAttributeSpecifier" ):
+                return visitor.visitGccAttributeSpecifier(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def gccAttributeSpecifier(self):
+
+        localctx = CParser.GccAttributeSpecifierContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 100, self.RULE_gccAttributeSpecifier)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 777
+            self.match(CParser.T__11)
+            self.state = 778
+            self.match(CParser.LeftParen)
+            self.state = 779
+            self.match(CParser.LeftParen)
+            self.state = 780
+            self.gccAttributeList()
+            self.state = 781
+            self.match(CParser.RightParen)
+            self.state = 782
+            self.match(CParser.RightParen)
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class GccAttributeListContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def gccAttribute(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(CParser.GccAttributeContext)
+            else:
+                return self.getTypedRuleContext(CParser.GccAttributeContext,i)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_gccAttributeList
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterGccAttributeList" ):
+                listener.enterGccAttributeList(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitGccAttributeList" ):
+                listener.exitGccAttributeList(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitGccAttributeList" ):
+                return visitor.visitGccAttributeList(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def gccAttributeList(self):
+
+        localctx = CParser.GccAttributeListContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 102, self.RULE_gccAttributeList)
+        self._la = 0 # Token type
+        try:
+            self.state = 793
+            la_ = self._interp.adaptivePredict(self._input,69,self._ctx)
+            if la_ == 1:
+                self.enterOuterAlt(localctx, 1)
+                self.state = 784
+                self.gccAttribute()
+                self.state = 789
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+                while _la==CParser.Comma:
+                    self.state = 785
+                    self.match(CParser.Comma)
+                    self.state = 786
+                    self.gccAttribute()
+                    self.state = 791
+                    self._errHandler.sync(self)
+                    _la = self._input.LA(1)
+
+                pass
+
+            elif la_ == 2:
+                self.enterOuterAlt(localctx, 2)
+
+                pass
+
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class GccAttributeContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def argumentExpressionList(self):
+            return self.getTypedRuleContext(CParser.ArgumentExpressionListContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_gccAttribute
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterGccAttribute" ):
+                listener.enterGccAttribute(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitGccAttribute" ):
+                listener.exitGccAttribute(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitGccAttribute" ):
+                return visitor.visitGccAttribute(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def gccAttribute(self):
+
+        localctx = CParser.GccAttributeContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 104, self.RULE_gccAttribute)
+        self._la = 0 # Token type
+        try:
+            self.state = 804
+            token = self._input.LA(1)
+            if token in [CParser.T__0, CParser.T__1, CParser.T__2, CParser.T__3, CParser.T__4, CParser.T__5, CParser.T__6, CParser.T__7, CParser.T__8, CParser.T__9, CParser.T__10, CParser.T__11, CParser.T__12, CParser.T__13, CParser.Auto, CParser.Break, CParser.Case, CParser.Char, CParser.Const, CParser.Continue, CParser.Default, CParser.Do, CParser.Double, CParser.Else, CParser.Enum, CParser.Extern, CParser.Float, CParser.For, CParser.Goto, CParser.If, CParser.Inline, CParser.Int, CParser.Long, CParser.Register, CParser.Restrict, CParser.Return, CParser.Short, CParser.Signed, CParser.Sizeof, CParser.Static, CParser.Struct, CParser.Switch, CParser.Typedef, CParser.Union, CParser.Unsigned, CParser.Void, CParser.Volatile, CParser.While, CParser.Alignas, CParser.Alignof, CParser.Atomic, CParser.Bool, CParser.Complex, CParser.Generic, CParser.Imaginary, CParser.Noreturn, CParser.StaticAssert, CParser.ThreadLocal, CParser.LeftBracket, CParser.RightBracket, CParser.LeftBrace, CParser.RightBrace, CParser.Less, CParser.LessEqual, CParser.Greater, CParser.GreaterEqual, CParser.LeftShift, CParser.RightShift, CParser.Plus, CParser.PlusPlus, CParser.Minus, CParser.MinusMinus, CParser.Star, CParser.Div, CParser.Mod, CParser.And, CParser.Or, CParser.AndAnd, CParser.OrOr, CParser.Caret, CParser.Not, CParser.Tilde, CParser.Question, CParser.Colon, CParser.Semi, CParser.Assign, CParser.StarAssign, CParser.DivAssign, CParser.ModAssign, CParser.PlusAssign, CParser.MinusAssign, CParser.LeftShiftAssign, CParser.RightShiftAssign, CParser.AndAssign, CParser.XorAssign, CParser.OrAssign, CParser.Equal, CParser.NotEqual, CParser.Arrow, CParser.Dot, CParser.Ellipsis, CParser.Identifier, CParser.Constant, CParser.StringLiteral, CParser.LineDirective, CParser.PragmaDirective, CParser.Whitespace, CParser.Newline, CParser.BlockComment, CParser.LineComment]:
+                self.enterOuterAlt(localctx, 1)
+                self.state = 795
+                _la = self._input.LA(1)
+                if _la <= 0 or ((((_la - 59)) & ~0x3f) == 0 and ((1 << (_la - 59)) & ((1 << (CParser.LeftParen - 59)) | (1 << (CParser.RightParen - 59)) | (1 << (CParser.Comma - 59)))) != 0):
+                    self._errHandler.recoverInline(self)
+                else:
+                    self.consume()
+                self.state = 801
+                _la = self._input.LA(1)
+                if _la==CParser.LeftParen:
+                    self.state = 796
+                    self.match(CParser.LeftParen)
+                    self.state = 798
+                    _la = self._input.LA(1)
+                    if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2) | (1 << CParser.Sizeof) | (1 << CParser.Alignof) | (1 << CParser.Generic) | (1 << CParser.LeftParen))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)) | (1 << (CParser.Identifier - 71)) | (1 << (CParser.Constant - 71)) | (1 << (CParser.StringLiteral - 71)))) != 0):
+                        self.state = 797
+                        self.argumentExpressionList(0)
+
+
+                    self.state = 800
+                    self.match(CParser.RightParen)
+
+
+
+            elif token in [CParser.RightParen, CParser.Comma]:
+                self.enterOuterAlt(localctx, 2)
+
+
+            else:
+                raise NoViableAltException(self)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class NestedParenthesesBlockContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def nestedParenthesesBlock(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(CParser.NestedParenthesesBlockContext)
+            else:
+                return self.getTypedRuleContext(CParser.NestedParenthesesBlockContext,i)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_nestedParenthesesBlock
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterNestedParenthesesBlock" ):
+                listener.enterNestedParenthesesBlock(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitNestedParenthesesBlock" ):
+                listener.exitNestedParenthesesBlock(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitNestedParenthesesBlock" ):
+                return visitor.visitNestedParenthesesBlock(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def nestedParenthesesBlock(self):
+
+        localctx = CParser.NestedParenthesesBlockContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 106, self.RULE_nestedParenthesesBlock)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 813
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2) | (1 << CParser.T__3) | (1 << CParser.T__4) | (1 << CParser.T__5) | (1 << CParser.T__6) | (1 << CParser.T__7) | (1 << CParser.T__8) | (1 << CParser.T__9) | (1 << CParser.T__10) | (1 << CParser.T__11) | (1 << CParser.T__12) | (1 << CParser.T__13) | (1 << CParser.Auto) | (1 << CParser.Break) | (1 << CParser.Case) | (1 << CParser.Char) | (1 << CParser.Const) | (1 << CParser.Continue) | (1 << CParser.Default) | (1 << CParser.Do) | (1 << CParser.Double) | (1 << CParser.Else) | (1 << CParser.Enum) | (1 << CParser.Extern) | (1 << CParser.Float) | (1 << CParser.For) | (1 << CParser.Goto) | (1 << CParser.If) | (1 << CParser.Inline) | (1 << CParser.Int) | (1 << CParser.Long) | (1 << CParser.Register) | (1 << CParser.Restrict) | (1 << CParser.Return) | (1 << CParser.Short) | (1 << CParser.Signed) | (1 << CParser.Sizeof) | (1 << CParser.Static) | (1 << CParser.Struct) | (1 << CParser.Switch) | (1 << CParser.Typedef) | (1 << CParser.Union) | (1 << CParser.Unsigned) | (1 << CParser.Void) | (1 << CParser.Volatile) | (1 << CParser.While) | (1 << CParser.Alignas) | (1 << CParser.Alignof) | (1 << CParser.Atomic) | (1 << CParser.Bool) | (1 << CParser.Complex) | (1 << CParser.Generic) | (1 << CParser.Imaginary) | (1 << CParser.Noreturn) | (1 << CParser.StaticAssert) | (1 << CParser.ThreadLocal) | (1 << CParser.LeftParen) | (1 << CParser.LeftBracket) | (1 << CParser.RightBracket) | (1 << CParser.LeftBrace))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CParser.RightBrace - 64)) | (1 << (CParser.Less - 64)) | (1 << (CParser.LessEqual - 64)) | (1 << (CParser.Greater - 64)) | (1 << (CParser.GreaterEqual - 64)) | (1 << (CParser.LeftShift - 64)) | (1 << (CParser.RightShift - 64)) | (1 << (CParser.Plus - 64)) | (1 << (CParser.PlusPlus - 64)) | (1 << (CParser.Minus - 64)) | (1 << (CParser.MinusMinus - 64)) | (1 << (CParser.Star - 64)) | (1 << (CParser.Div - 64)) | (1 << (CParser.Mod - 64)) | (1 << (CParser.And - 64)) | (1 << (CParser.Or - 64)) | (1 << (CParser.AndAnd - 64)) | (1 << (CParser.OrOr - 64)) | (1 << (CParser.Caret - 64)) | (1 << (CParser.Not - 64)) | (1 << (CParser.Tilde - 64)) | (1 << (CParser.Question - 64)) | (1 << (CParser.Colon - 64)) | (1 << (CParser.Semi - 64)) | (1 << (CParser.Comma - 64)) | (1 << (CParser.Assign - 64)) | (1 << (CParser.StarAssign - 64)) | (1 << (CParser.DivAssign - 64)) | (1 << (CParser.ModAssign - 64)) | (1 << (CParser.PlusAssign - 64)) | (1 << (CParser.MinusAssign - 64)) | (1 << (CParser.LeftShiftAssign - 64)) | (1 << (CParser.RightShiftAssign - 64)) | (1 << (CParser.AndAssign - 64)) | (1 << (CParser.XorAssign - 64)) | (1 << (CParser.OrAssign - 64)) | (1 << (CParser.Equal - 64)) | (1 << (CParser.NotEqual - 64)) | (1 << (CParser.Arrow - 64)) | (1 << (CParser.Dot - 64)) | (1 << (CParser.Ellipsis - 64)) | (1 << (CParser.Identifier - 64)) | (1 << (CParser.Constant - 64)) | (1 << (CParser.StringLiteral - 64)) | (1 << (CParser.LineDirective - 64)) | (1 << (CParser.PragmaDirective - 64)) | (1 << (CParser.Whitespace - 64)) | (1 << (CParser.Newline - 64)) | (1 << (CParser.BlockComment - 64)) | (1 << (CParser.LineComment - 64)))) != 0):
+                self.state = 811
+                token = self._input.LA(1)
+                if token in [CParser.T__0, CParser.T__1, CParser.T__2, CParser.T__3, CParser.T__4, CParser.T__5, CParser.T__6, CParser.T__7, CParser.T__8, CParser.T__9, CParser.T__10, CParser.T__11, CParser.T__12, CParser.T__13, CParser.Auto, CParser.Break, CParser.Case, CParser.Char, CParser.Const, CParser.Continue, CParser.Default, CParser.Do, CParser.Double, CParser.Else, CParser.Enum, CParser.Extern, CParser.Float, CParser.For, CParser.Goto, CParser.If, CParser.Inline, CParser.Int, CParser.Long, CParser.Register, CParser.Restrict, CParser.Return, CParser.Short, CParser.Signed, CParser.Sizeof, CParser.Static, CParser.Struct, CParser.Switch, CParser.Typedef, CParser.Union, CParser.Unsigned, CParser.Void, CParser.Volatile, CParser.While, CParser.Alignas, CParser.Alignof, CParser.Atomic, CParser.Bool, CParser.Complex, CParser.Generic, CParser.Imaginary, CParser.Noreturn, CParser.StaticAssert, CParser.ThreadLocal, CParser.LeftBracket, CParser.RightBracket, CParser.LeftBrace, CParser.RightBrace, CParser.Less, CParser.LessEqual, CParser.Greater, CParser.GreaterEqual, CParser.LeftShift, CParser.RightShift, CParser.Plus, CParser.PlusPlus, CParser.Minus, CParser.MinusMinus, CParser.Star, CParser.Div, CParser.Mod, CParser.And, CParser.Or, CParser.AndAnd, CParser.OrOr, CParser.Caret, CParser.Not, CParser.Tilde, CParser.Question, CParser.Colon, CParser.Semi, CParser.Comma, CParser.Assign, CParser.StarAssign, CParser.DivAssign, CParser.ModAssign, CParser.PlusAssign, CParser.MinusAssign, CParser.LeftShiftAssign, CParser.RightShiftAssign, CParser.AndAssign, CParser.XorAssign, CParser.OrAssign, CParser.Equal, CParser.NotEqual, CParser.Arrow, CParser.Dot, CParser.Ellipsis, CParser.Identifier, CParser.Constant, CParser.StringLiteral, CParser.LineDirective, CParser.PragmaDirective, CParser.Whitespace, CParser.Newline, CParser.BlockComment, CParser.LineComment]:
+                    self.state = 806
+                    _la = self._input.LA(1)
+                    if _la <= 0 or _la==CParser.LeftParen or _la==CParser.RightParen:
+                        self._errHandler.recoverInline(self)
+                    else:
+                        self.consume()
+
+                elif token in [CParser.LeftParen]:
+                    self.state = 807
+                    self.match(CParser.LeftParen)
+                    self.state = 808
+                    self.nestedParenthesesBlock()
+                    self.state = 809
+                    self.match(CParser.RightParen)
+
+                else:
+                    raise NoViableAltException(self)
+
+                self.state = 815
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class PointerContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def typeQualifierList(self):
+            return self.getTypedRuleContext(CParser.TypeQualifierListContext,0)
+
+
+        def pointer(self):
+            return self.getTypedRuleContext(CParser.PointerContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_pointer
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterPointer" ):
+                listener.enterPointer(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitPointer" ):
+                listener.exitPointer(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitPointer" ):
+                return visitor.visitPointer(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def pointer(self):
+
+        localctx = CParser.PointerContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 108, self.RULE_pointer)
+        self._la = 0 # Token type
+        try:
+            self.state = 834
+            la_ = self._interp.adaptivePredict(self._input,79,self._ctx)
+            if la_ == 1:
+                self.enterOuterAlt(localctx, 1)
+                self.state = 816
+                self.match(CParser.Star)
+                self.state = 818
+                la_ = self._interp.adaptivePredict(self._input,75,self._ctx)
+                if la_ == 1:
+                    self.state = 817
+                    self.typeQualifierList(0)
+
+
+                pass
+
+            elif la_ == 2:
+                self.enterOuterAlt(localctx, 2)
+                self.state = 820
+                self.match(CParser.Star)
+                self.state = 822
+                _la = self._input.LA(1)
+                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.Const) | (1 << CParser.Restrict) | (1 << CParser.Volatile) | (1 << CParser.Atomic))) != 0):
+                    self.state = 821
+                    self.typeQualifierList(0)
+
+
+                self.state = 824
+                self.pointer()
+                pass
+
+            elif la_ == 3:
+                self.enterOuterAlt(localctx, 3)
+                self.state = 825
+                self.match(CParser.Caret)
+                self.state = 827
+                la_ = self._interp.adaptivePredict(self._input,77,self._ctx)
+                if la_ == 1:
+                    self.state = 826
+                    self.typeQualifierList(0)
+
+
+                pass
+
+            elif la_ == 4:
+                self.enterOuterAlt(localctx, 4)
+                self.state = 829
+                self.match(CParser.Caret)
+                self.state = 831
+                _la = self._input.LA(1)
+                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.Const) | (1 << CParser.Restrict) | (1 << CParser.Volatile) | (1 << CParser.Atomic))) != 0):
+                    self.state = 830
+                    self.typeQualifierList(0)
+
+
+                self.state = 833
+                self.pointer()
+                pass
+
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class TypeQualifierListContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def typeQualifier(self):
+            return self.getTypedRuleContext(CParser.TypeQualifierContext,0)
+
+
+        def typeQualifierList(self):
+            return self.getTypedRuleContext(CParser.TypeQualifierListContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_typeQualifierList
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterTypeQualifierList" ):
+                listener.enterTypeQualifierList(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitTypeQualifierList" ):
+                listener.exitTypeQualifierList(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitTypeQualifierList" ):
+                return visitor.visitTypeQualifierList(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+    def typeQualifierList(self, _p:int=0):
+        _parentctx = self._ctx
+        _parentState = self.state
+        localctx = CParser.TypeQualifierListContext(self, self._ctx, _parentState)
+        _prevctx = localctx
+        _startState = 110
+        self.enterRecursionRule(localctx, 110, self.RULE_typeQualifierList, _p)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 837
+            self.typeQualifier()
+            self._ctx.stop = self._input.LT(-1)
+            self.state = 843
+            self._errHandler.sync(self)
+            _alt = self._interp.adaptivePredict(self._input,80,self._ctx)
+            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                if _alt==1:
+                    if self._parseListeners is not None:
+                        self.triggerExitRuleEvent()
+                    _prevctx = localctx
+                    localctx = CParser.TypeQualifierListContext(self, _parentctx, _parentState)
+                    self.pushNewRecursionContext(localctx, _startState, self.RULE_typeQualifierList)
+                    self.state = 839
+                    if not self.precpred(self._ctx, 1):
+                        from antlr4.error.Errors import FailedPredicateException
+                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
+                    self.state = 840
+                    self.typeQualifier()
+                self.state = 845
+                self._errHandler.sync(self)
+                _alt = self._interp.adaptivePredict(self._input,80,self._ctx)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.unrollRecursionContexts(_parentctx)
+        return localctx
+
+    class ParameterTypeListContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def parameterList(self):
+            return self.getTypedRuleContext(CParser.ParameterListContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_parameterTypeList
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterParameterTypeList" ):
+                listener.enterParameterTypeList(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitParameterTypeList" ):
+                listener.exitParameterTypeList(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitParameterTypeList" ):
+                return visitor.visitParameterTypeList(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def parameterTypeList(self):
+
+        localctx = CParser.ParameterTypeListContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 112, self.RULE_parameterTypeList)
+        try:
+            self.state = 851
+            la_ = self._interp.adaptivePredict(self._input,81,self._ctx)
+            if la_ == 1:
+                self.enterOuterAlt(localctx, 1)
+                self.state = 846
+                self.parameterList(0)
+                pass
+
+            elif la_ == 2:
+                self.enterOuterAlt(localctx, 2)
+                self.state = 847
+                self.parameterList(0)
+                self.state = 848
+                self.match(CParser.Comma)
+                self.state = 849
+                self.match(CParser.Ellipsis)
+                pass
+
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class ParameterListContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def parameterDeclaration(self):
+            return self.getTypedRuleContext(CParser.ParameterDeclarationContext,0)
+
+
+        def parameterList(self):
+            return self.getTypedRuleContext(CParser.ParameterListContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_parameterList
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterParameterList" ):
+                listener.enterParameterList(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitParameterList" ):
+                listener.exitParameterList(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitParameterList" ):
+                return visitor.visitParameterList(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+    def parameterList(self, _p:int=0):
+        _parentctx = self._ctx
+        _parentState = self.state
+        localctx = CParser.ParameterListContext(self, self._ctx, _parentState)
+        _prevctx = localctx
+        _startState = 114
+        self.enterRecursionRule(localctx, 114, self.RULE_parameterList, _p)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 854
+            self.parameterDeclaration()
+            self._ctx.stop = self._input.LT(-1)
+            self.state = 861
+            self._errHandler.sync(self)
+            _alt = self._interp.adaptivePredict(self._input,82,self._ctx)
+            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                if _alt==1:
+                    if self._parseListeners is not None:
+                        self.triggerExitRuleEvent()
+                    _prevctx = localctx
+                    localctx = CParser.ParameterListContext(self, _parentctx, _parentState)
+                    self.pushNewRecursionContext(localctx, _startState, self.RULE_parameterList)
+                    self.state = 856
+                    if not self.precpred(self._ctx, 1):
+                        from antlr4.error.Errors import FailedPredicateException
+                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
+                    self.state = 857
+                    self.match(CParser.Comma)
+                    self.state = 858
+                    self.parameterDeclaration()
+                self.state = 863
+                self._errHandler.sync(self)
+                _alt = self._interp.adaptivePredict(self._input,82,self._ctx)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.unrollRecursionContexts(_parentctx)
+        return localctx
+
+    class ParameterDeclarationContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def declarationSpecifiers(self):
+            return self.getTypedRuleContext(CParser.DeclarationSpecifiersContext,0)
+
+
+        def declarator(self):
+            return self.getTypedRuleContext(CParser.DeclaratorContext,0)
+
+
+        def declarationSpecifiers2(self):
+            return self.getTypedRuleContext(CParser.DeclarationSpecifiers2Context,0)
+
+
+        def abstractDeclarator(self):
+            return self.getTypedRuleContext(CParser.AbstractDeclaratorContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_parameterDeclaration
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterParameterDeclaration" ):
+                listener.enterParameterDeclaration(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitParameterDeclaration" ):
+                listener.exitParameterDeclaration(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitParameterDeclaration" ):
+                return visitor.visitParameterDeclaration(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def parameterDeclaration(self):
+
+        localctx = CParser.ParameterDeclarationContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 116, self.RULE_parameterDeclaration)
+        try:
+            self.state = 871
+            la_ = self._interp.adaptivePredict(self._input,84,self._ctx)
+            if la_ == 1:
+                self.enterOuterAlt(localctx, 1)
+                self.state = 864
+                self.declarationSpecifiers()
+                self.state = 865
+                self.declarator()
+                pass
+
+            elif la_ == 2:
+                self.enterOuterAlt(localctx, 2)
+                self.state = 867
+                self.declarationSpecifiers2()
+                self.state = 869
+                la_ = self._interp.adaptivePredict(self._input,83,self._ctx)
+                if la_ == 1:
+                    self.state = 868
+                    self.abstractDeclarator()
+
+
+                pass
+
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class IdentifierListContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def Identifier(self):
+            return self.getToken(CParser.Identifier, 0)
+
+        def identifierList(self):
+            return self.getTypedRuleContext(CParser.IdentifierListContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_identifierList
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterIdentifierList" ):
+                listener.enterIdentifierList(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitIdentifierList" ):
+                listener.exitIdentifierList(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitIdentifierList" ):
+                return visitor.visitIdentifierList(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+    def identifierList(self, _p:int=0):
+        _parentctx = self._ctx
+        _parentState = self.state
+        localctx = CParser.IdentifierListContext(self, self._ctx, _parentState)
+        _prevctx = localctx
+        _startState = 118
+        self.enterRecursionRule(localctx, 118, self.RULE_identifierList, _p)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 874
+            self.match(CParser.Identifier)
+            self._ctx.stop = self._input.LT(-1)
+            self.state = 881
+            self._errHandler.sync(self)
+            _alt = self._interp.adaptivePredict(self._input,85,self._ctx)
+            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                if _alt==1:
+                    if self._parseListeners is not None:
+                        self.triggerExitRuleEvent()
+                    _prevctx = localctx
+                    localctx = CParser.IdentifierListContext(self, _parentctx, _parentState)
+                    self.pushNewRecursionContext(localctx, _startState, self.RULE_identifierList)
+                    self.state = 876
+                    if not self.precpred(self._ctx, 1):
+                        from antlr4.error.Errors import FailedPredicateException
+                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
+                    self.state = 877
+                    self.match(CParser.Comma)
+                    self.state = 878
+                    self.match(CParser.Identifier)
+                self.state = 883
+                self._errHandler.sync(self)
+                _alt = self._interp.adaptivePredict(self._input,85,self._ctx)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.unrollRecursionContexts(_parentctx)
+        return localctx
+
+    class TypeNameContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def specifierQualifierList(self):
+            return self.getTypedRuleContext(CParser.SpecifierQualifierListContext,0)
+
+
+        def abstractDeclarator(self):
+            return self.getTypedRuleContext(CParser.AbstractDeclaratorContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_typeName
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterTypeName" ):
+                listener.enterTypeName(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitTypeName" ):
+                listener.exitTypeName(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitTypeName" ):
+                return visitor.visitTypeName(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def typeName(self):
+
+        localctx = CParser.TypeNameContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 120, self.RULE_typeName)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 884
+            self.specifierQualifierList()
+            self.state = 886
+            _la = self._input.LA(1)
+            if ((((_la - 59)) & ~0x3f) == 0 and ((1 << (_la - 59)) & ((1 << (CParser.LeftParen - 59)) | (1 << (CParser.LeftBracket - 59)) | (1 << (CParser.Star - 59)) | (1 << (CParser.Caret - 59)))) != 0):
+                self.state = 885
+                self.abstractDeclarator()
+
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class AbstractDeclaratorContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def pointer(self):
+            return self.getTypedRuleContext(CParser.PointerContext,0)
+
+
+        def directAbstractDeclarator(self):
+            return self.getTypedRuleContext(CParser.DirectAbstractDeclaratorContext,0)
+
+
+        def gccDeclaratorExtension(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(CParser.GccDeclaratorExtensionContext)
+            else:
+                return self.getTypedRuleContext(CParser.GccDeclaratorExtensionContext,i)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_abstractDeclarator
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterAbstractDeclarator" ):
+                listener.enterAbstractDeclarator(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitAbstractDeclarator" ):
+                listener.exitAbstractDeclarator(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitAbstractDeclarator" ):
+                return visitor.visitAbstractDeclarator(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def abstractDeclarator(self):
+
+        localctx = CParser.AbstractDeclaratorContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 122, self.RULE_abstractDeclarator)
+        self._la = 0 # Token type
+        try:
+            self.state = 899
+            la_ = self._interp.adaptivePredict(self._input,89,self._ctx)
+            if la_ == 1:
+                self.enterOuterAlt(localctx, 1)
+                self.state = 888
+                self.pointer()
+                pass
+
+            elif la_ == 2:
+                self.enterOuterAlt(localctx, 2)
+                self.state = 890
+                _la = self._input.LA(1)
+                if _la==CParser.Star or _la==CParser.Caret:
+                    self.state = 889
+                    self.pointer()
+
+
+                self.state = 892
+                self.directAbstractDeclarator(0)
+                self.state = 896
+                self._errHandler.sync(self)
+                _alt = self._interp.adaptivePredict(self._input,88,self._ctx)
+                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                    if _alt==1:
+                        self.state = 893
+                        self.gccDeclaratorExtension()
+                    self.state = 898
+                    self._errHandler.sync(self)
+                    _alt = self._interp.adaptivePredict(self._input,88,self._ctx)
+
+                pass
+
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class DirectAbstractDeclaratorContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def abstractDeclarator(self):
+            return self.getTypedRuleContext(CParser.AbstractDeclaratorContext,0)
+
+
+        def gccDeclaratorExtension(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(CParser.GccDeclaratorExtensionContext)
+            else:
+                return self.getTypedRuleContext(CParser.GccDeclaratorExtensionContext,i)
+
+
+        def typeQualifierList(self):
+            return self.getTypedRuleContext(CParser.TypeQualifierListContext,0)
+
+
+        def assignmentExpression(self):
+            return self.getTypedRuleContext(CParser.AssignmentExpressionContext,0)
+
+
+        def parameterTypeList(self):
+            return self.getTypedRuleContext(CParser.ParameterTypeListContext,0)
+
+
+        def directAbstractDeclarator(self):
+            return self.getTypedRuleContext(CParser.DirectAbstractDeclaratorContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_directAbstractDeclarator
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterDirectAbstractDeclarator" ):
+                listener.enterDirectAbstractDeclarator(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitDirectAbstractDeclarator" ):
+                listener.exitDirectAbstractDeclarator(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitDirectAbstractDeclarator" ):
+                return visitor.visitDirectAbstractDeclarator(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+    def directAbstractDeclarator(self, _p:int=0):
+        _parentctx = self._ctx
+        _parentState = self.state
+        localctx = CParser.DirectAbstractDeclaratorContext(self, self._ctx, _parentState)
+        _prevctx = localctx
+        _startState = 124
+        self.enterRecursionRule(localctx, 124, self.RULE_directAbstractDeclarator, _p)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 947
+            la_ = self._interp.adaptivePredict(self._input,96,self._ctx)
+            if la_ == 1:
+                self.state = 902
+                self.match(CParser.LeftParen)
+                self.state = 903
+                self.abstractDeclarator()
+                self.state = 904
+                self.match(CParser.RightParen)
+                self.state = 908
+                self._errHandler.sync(self)
+                _alt = self._interp.adaptivePredict(self._input,90,self._ctx)
+                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                    if _alt==1:
+                        self.state = 905
+                        self.gccDeclaratorExtension()
+                    self.state = 910
+                    self._errHandler.sync(self)
+                    _alt = self._interp.adaptivePredict(self._input,90,self._ctx)
+
+                pass
+
+            elif la_ == 2:
+                self.state = 911
+                self.match(CParser.LeftBracket)
+                self.state = 913
+                _la = self._input.LA(1)
+                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.Const) | (1 << CParser.Restrict) | (1 << CParser.Volatile) | (1 << CParser.Atomic))) != 0):
+                    self.state = 912
+                    self.typeQualifierList(0)
+
+
+                self.state = 916
+                _la = self._input.LA(1)
+                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2) | (1 << CParser.Sizeof) | (1 << CParser.Alignof) | (1 << CParser.Generic) | (1 << CParser.LeftParen))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)) | (1 << (CParser.Identifier - 71)) | (1 << (CParser.Constant - 71)) | (1 << (CParser.StringLiteral - 71)))) != 0):
+                    self.state = 915
+                    self.assignmentExpression()
+
+
+                self.state = 918
+                self.match(CParser.RightBracket)
+                pass
+
+            elif la_ == 3:
+                self.state = 919
+                self.match(CParser.LeftBracket)
+                self.state = 920
+                self.match(CParser.Static)
+                self.state = 922
+                _la = self._input.LA(1)
+                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.Const) | (1 << CParser.Restrict) | (1 << CParser.Volatile) | (1 << CParser.Atomic))) != 0):
+                    self.state = 921
+                    self.typeQualifierList(0)
+
+
+                self.state = 924
+                self.assignmentExpression()
+                self.state = 925
+                self.match(CParser.RightBracket)
+                pass
+
+            elif la_ == 4:
+                self.state = 927
+                self.match(CParser.LeftBracket)
+                self.state = 928
+                self.typeQualifierList(0)
+                self.state = 929
+                self.match(CParser.Static)
+                self.state = 930
+                self.assignmentExpression()
+                self.state = 931
+                self.match(CParser.RightBracket)
+                pass
+
+            elif la_ == 5:
+                self.state = 933
+                self.match(CParser.LeftBracket)
+                self.state = 934
+                self.match(CParser.Star)
+                self.state = 935
+                self.match(CParser.RightBracket)
+                pass
+
+            elif la_ == 6:
+                self.state = 936
+                self.match(CParser.LeftParen)
+                self.state = 938
+                _la = self._input.LA(1)
+                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__3) | (1 << CParser.T__4) | (1 << CParser.T__5) | (1 << CParser.T__6) | (1 << CParser.T__7) | (1 << CParser.T__8) | (1 << CParser.T__9) | (1 << CParser.T__11) | (1 << CParser.Auto) | (1 << CParser.Char) | (1 << CParser.Const) | (1 << CParser.Double) | (1 << CParser.Enum) | (1 << CParser.Extern) | (1 << CParser.Float) | (1 << CParser.Inline) | (1 << CParser.Int) | (1 << CParser.Long) | (1 << CParser.Register) | (1 << CParser.Restrict) | (1 << CParser.Short) | (1 << CParser.Signed) | (1 << CParser.Static) | (1 << CParser.Struct) | (1 << CParser.Typedef) | (1 << CParser.Union) | (1 << CParser.Unsigned) | (1 << CParser.Void) | (1 << CParser.Volatile) | (1 << CParser.Alignas) | (1 << CParser.Atomic) | (1 << CParser.Bool) | (1 << CParser.Complex) | (1 << CParser.Noreturn) | (1 << CParser.ThreadLocal))) != 0) or _la==CParser.Identifier:
+                    self.state = 937
+                    self.parameterTypeList()
+
+
+                self.state = 940
+                self.match(CParser.RightParen)
+                self.state = 944
+                self._errHandler.sync(self)
+                _alt = self._interp.adaptivePredict(self._input,95,self._ctx)
+                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                    if _alt==1:
+                        self.state = 941
+                        self.gccDeclaratorExtension()
+                    self.state = 946
+                    self._errHandler.sync(self)
+                    _alt = self._interp.adaptivePredict(self._input,95,self._ctx)
+
+                pass
+
+
+            self._ctx.stop = self._input.LT(-1)
+            self.state = 992
+            self._errHandler.sync(self)
+            _alt = self._interp.adaptivePredict(self._input,103,self._ctx)
+            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                if _alt==1:
+                    if self._parseListeners is not None:
+                        self.triggerExitRuleEvent()
+                    _prevctx = localctx
+                    self.state = 990
+                    la_ = self._interp.adaptivePredict(self._input,102,self._ctx)
+                    if la_ == 1:
+                        localctx = CParser.DirectAbstractDeclaratorContext(self, _parentctx, _parentState)
+                        self.pushNewRecursionContext(localctx, _startState, self.RULE_directAbstractDeclarator)
+                        self.state = 949
+                        if not self.precpred(self._ctx, 5):
+                            from antlr4.error.Errors import FailedPredicateException
+                            raise FailedPredicateException(self, "self.precpred(self._ctx, 5)")
+                        self.state = 950
+                        self.match(CParser.LeftBracket)
+                        self.state = 952
+                        _la = self._input.LA(1)
+                        if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.Const) | (1 << CParser.Restrict) | (1 << CParser.Volatile) | (1 << CParser.Atomic))) != 0):
+                            self.state = 951
+                            self.typeQualifierList(0)
+
+
+                        self.state = 955
+                        _la = self._input.LA(1)
+                        if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2) | (1 << CParser.Sizeof) | (1 << CParser.Alignof) | (1 << CParser.Generic) | (1 << CParser.LeftParen))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)) | (1 << (CParser.Identifier - 71)) | (1 << (CParser.Constant - 71)) | (1 << (CParser.StringLiteral - 71)))) != 0):
+                            self.state = 954
+                            self.assignmentExpression()
+
+
+                        self.state = 957
+                        self.match(CParser.RightBracket)
+                        pass
+
+                    elif la_ == 2:
+                        localctx = CParser.DirectAbstractDeclaratorContext(self, _parentctx, _parentState)
+                        self.pushNewRecursionContext(localctx, _startState, self.RULE_directAbstractDeclarator)
+                        self.state = 958
+                        if not self.precpred(self._ctx, 4):
+                            from antlr4.error.Errors import FailedPredicateException
+                            raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
+                        self.state = 959
+                        self.match(CParser.LeftBracket)
+                        self.state = 960
+                        self.match(CParser.Static)
+                        self.state = 962
+                        _la = self._input.LA(1)
+                        if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.Const) | (1 << CParser.Restrict) | (1 << CParser.Volatile) | (1 << CParser.Atomic))) != 0):
+                            self.state = 961
+                            self.typeQualifierList(0)
+
+
+                        self.state = 964
+                        self.assignmentExpression()
+                        self.state = 965
+                        self.match(CParser.RightBracket)
+                        pass
+
+                    elif la_ == 3:
+                        localctx = CParser.DirectAbstractDeclaratorContext(self, _parentctx, _parentState)
+                        self.pushNewRecursionContext(localctx, _startState, self.RULE_directAbstractDeclarator)
+                        self.state = 967
+                        if not self.precpred(self._ctx, 3):
+                            from antlr4.error.Errors import FailedPredicateException
+                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
+                        self.state = 968
+                        self.match(CParser.LeftBracket)
+                        self.state = 969
+                        self.typeQualifierList(0)
+                        self.state = 970
+                        self.match(CParser.Static)
+                        self.state = 971
+                        self.assignmentExpression()
+                        self.state = 972
+                        self.match(CParser.RightBracket)
+                        pass
+
+                    elif la_ == 4:
+                        localctx = CParser.DirectAbstractDeclaratorContext(self, _parentctx, _parentState)
+                        self.pushNewRecursionContext(localctx, _startState, self.RULE_directAbstractDeclarator)
+                        self.state = 974
+                        if not self.precpred(self._ctx, 2):
+                            from antlr4.error.Errors import FailedPredicateException
+                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
+                        self.state = 975
+                        self.match(CParser.LeftBracket)
+                        self.state = 976
+                        self.match(CParser.Star)
+                        self.state = 977
+                        self.match(CParser.RightBracket)
+                        pass
+
+                    elif la_ == 5:
+                        localctx = CParser.DirectAbstractDeclaratorContext(self, _parentctx, _parentState)
+                        self.pushNewRecursionContext(localctx, _startState, self.RULE_directAbstractDeclarator)
+                        self.state = 978
+                        if not self.precpred(self._ctx, 1):
+                            from antlr4.error.Errors import FailedPredicateException
+                            raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
+                        self.state = 979
+                        self.match(CParser.LeftParen)
+                        self.state = 981
+                        _la = self._input.LA(1)
+                        if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__3) | (1 << CParser.T__4) | (1 << CParser.T__5) | (1 << CParser.T__6) | (1 << CParser.T__7) | (1 << CParser.T__8) | (1 << CParser.T__9) | (1 << CParser.T__11) | (1 << CParser.Auto) | (1 << CParser.Char) | (1 << CParser.Const) | (1 << CParser.Double) | (1 << CParser.Enum) | (1 << CParser.Extern) | (1 << CParser.Float) | (1 << CParser.Inline) | (1 << CParser.Int) | (1 << CParser.Long) | (1 << CParser.Register) | (1 << CParser.Restrict) | (1 << CParser.Short) | (1 << CParser.Signed) | (1 << CParser.Static) | (1 << CParser.Struct) | (1 << CParser.Typedef) | (1 << CParser.Union) | (1 << CParser.Unsigned) | (1 << CParser.Void) | (1 << CParser.Volatile) | (1 << CParser.Alignas) | (1 << CParser.Atomic) | (1 << CParser.Bool) | (1 << CParser.Complex) | (1 << CParser.Noreturn) | (1 << CParser.ThreadLocal))) != 0) or _la==CParser.Identifier:
+                            self.state = 980
+                            self.parameterTypeList()
+
+
+                        self.state = 983
+                        self.match(CParser.RightParen)
+                        self.state = 987
+                        self._errHandler.sync(self)
+                        _alt = self._interp.adaptivePredict(self._input,101,self._ctx)
+                        while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                            if _alt==1:
+                                self.state = 984
+                                self.gccDeclaratorExtension()
+                            self.state = 989
+                            self._errHandler.sync(self)
+                            _alt = self._interp.adaptivePredict(self._input,101,self._ctx)
+
+                        pass
+
+
+                self.state = 994
+                self._errHandler.sync(self)
+                _alt = self._interp.adaptivePredict(self._input,103,self._ctx)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.unrollRecursionContexts(_parentctx)
+        return localctx
+
+    class TypedefNameContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def Identifier(self):
+            return self.getToken(CParser.Identifier, 0)
+
+        def getRuleIndex(self):
+            return CParser.RULE_typedefName
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterTypedefName" ):
+                listener.enterTypedefName(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitTypedefName" ):
+                listener.exitTypedefName(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitTypedefName" ):
+                return visitor.visitTypedefName(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def typedefName(self):
+
+        localctx = CParser.TypedefNameContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 126, self.RULE_typedefName)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 995
+            self.match(CParser.Identifier)
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class InitializerContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def assignmentExpression(self):
+            return self.getTypedRuleContext(CParser.AssignmentExpressionContext,0)
+
+
+        def initializerList(self):
+            return self.getTypedRuleContext(CParser.InitializerListContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_initializer
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterInitializer" ):
+                listener.enterInitializer(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitInitializer" ):
+                listener.exitInitializer(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitInitializer" ):
+                return visitor.visitInitializer(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def initializer(self):
+
+        localctx = CParser.InitializerContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 128, self.RULE_initializer)
+        try:
+            self.state = 1007
+            la_ = self._interp.adaptivePredict(self._input,104,self._ctx)
+            if la_ == 1:
+                self.enterOuterAlt(localctx, 1)
+                self.state = 997
+                self.assignmentExpression()
+                pass
+
+            elif la_ == 2:
+                self.enterOuterAlt(localctx, 2)
+                self.state = 998
+                self.match(CParser.LeftBrace)
+                self.state = 999
+                self.initializerList(0)
+                self.state = 1000
+                self.match(CParser.RightBrace)
+                pass
+
+            elif la_ == 3:
+                self.enterOuterAlt(localctx, 3)
+                self.state = 1002
+                self.match(CParser.LeftBrace)
+                self.state = 1003
+                self.initializerList(0)
+                self.state = 1004
+                self.match(CParser.Comma)
+                self.state = 1005
+                self.match(CParser.RightBrace)
+                pass
+
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class InitializerListContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def initializer(self):
+            return self.getTypedRuleContext(CParser.InitializerContext,0)
+
+
+        def designation(self):
+            return self.getTypedRuleContext(CParser.DesignationContext,0)
+
+
+        def initializerList(self):
+            return self.getTypedRuleContext(CParser.InitializerListContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_initializerList
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterInitializerList" ):
+                listener.enterInitializerList(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitInitializerList" ):
+                listener.exitInitializerList(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitInitializerList" ):
+                return visitor.visitInitializerList(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+    def initializerList(self, _p:int=0):
+        _parentctx = self._ctx
+        _parentState = self.state
+        localctx = CParser.InitializerListContext(self, self._ctx, _parentState)
+        _prevctx = localctx
+        _startState = 130
+        self.enterRecursionRule(localctx, 130, self.RULE_initializerList, _p)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 1011
+            _la = self._input.LA(1)
+            if _la==CParser.LeftBracket or _la==CParser.Dot:
+                self.state = 1010
+                self.designation()
+
+
+            self.state = 1013
+            self.initializer()
+            self._ctx.stop = self._input.LT(-1)
+            self.state = 1023
+            self._errHandler.sync(self)
+            _alt = self._interp.adaptivePredict(self._input,107,self._ctx)
+            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                if _alt==1:
+                    if self._parseListeners is not None:
+                        self.triggerExitRuleEvent()
+                    _prevctx = localctx
+                    localctx = CParser.InitializerListContext(self, _parentctx, _parentState)
+                    self.pushNewRecursionContext(localctx, _startState, self.RULE_initializerList)
+                    self.state = 1015
+                    if not self.precpred(self._ctx, 1):
+                        from antlr4.error.Errors import FailedPredicateException
+                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
+                    self.state = 1016
+                    self.match(CParser.Comma)
+                    self.state = 1018
+                    _la = self._input.LA(1)
+                    if _la==CParser.LeftBracket or _la==CParser.Dot:
+                        self.state = 1017
+                        self.designation()
+
+
+                    self.state = 1020
+                    self.initializer()
+                self.state = 1025
+                self._errHandler.sync(self)
+                _alt = self._interp.adaptivePredict(self._input,107,self._ctx)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.unrollRecursionContexts(_parentctx)
+        return localctx
+
+    class DesignationContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def designatorList(self):
+            return self.getTypedRuleContext(CParser.DesignatorListContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_designation
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterDesignation" ):
+                listener.enterDesignation(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitDesignation" ):
+                listener.exitDesignation(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitDesignation" ):
+                return visitor.visitDesignation(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def designation(self):
+
+        localctx = CParser.DesignationContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 132, self.RULE_designation)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 1026
+            self.designatorList(0)
+            self.state = 1027
+            self.match(CParser.Assign)
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class DesignatorListContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def designator(self):
+            return self.getTypedRuleContext(CParser.DesignatorContext,0)
+
+
+        def designatorList(self):
+            return self.getTypedRuleContext(CParser.DesignatorListContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_designatorList
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterDesignatorList" ):
+                listener.enterDesignatorList(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitDesignatorList" ):
+                listener.exitDesignatorList(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitDesignatorList" ):
+                return visitor.visitDesignatorList(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+    def designatorList(self, _p:int=0):
+        _parentctx = self._ctx
+        _parentState = self.state
+        localctx = CParser.DesignatorListContext(self, self._ctx, _parentState)
+        _prevctx = localctx
+        _startState = 134
+        self.enterRecursionRule(localctx, 134, self.RULE_designatorList, _p)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 1030
+            self.designator()
+            self._ctx.stop = self._input.LT(-1)
+            self.state = 1036
+            self._errHandler.sync(self)
+            _alt = self._interp.adaptivePredict(self._input,108,self._ctx)
+            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                if _alt==1:
+                    if self._parseListeners is not None:
+                        self.triggerExitRuleEvent()
+                    _prevctx = localctx
+                    localctx = CParser.DesignatorListContext(self, _parentctx, _parentState)
+                    self.pushNewRecursionContext(localctx, _startState, self.RULE_designatorList)
+                    self.state = 1032
+                    if not self.precpred(self._ctx, 1):
+                        from antlr4.error.Errors import FailedPredicateException
+                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
+                    self.state = 1033
+                    self.designator()
+                self.state = 1038
+                self._errHandler.sync(self)
+                _alt = self._interp.adaptivePredict(self._input,108,self._ctx)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.unrollRecursionContexts(_parentctx)
+        return localctx
+
+    class DesignatorContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def constantExpression(self):
+            return self.getTypedRuleContext(CParser.ConstantExpressionContext,0)
+
+
+        def Identifier(self):
+            return self.getToken(CParser.Identifier, 0)
+
+        def getRuleIndex(self):
+            return CParser.RULE_designator
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterDesignator" ):
+                listener.enterDesignator(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitDesignator" ):
+                listener.exitDesignator(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitDesignator" ):
+                return visitor.visitDesignator(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def designator(self):
+
+        localctx = CParser.DesignatorContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 136, self.RULE_designator)
+        try:
+            self.state = 1045
+            token = self._input.LA(1)
+            if token in [CParser.LeftBracket]:
+                self.enterOuterAlt(localctx, 1)
+                self.state = 1039
+                self.match(CParser.LeftBracket)
+                self.state = 1040
+                self.constantExpression()
+                self.state = 1041
+                self.match(CParser.RightBracket)
+
+            elif token in [CParser.Dot]:
+                self.enterOuterAlt(localctx, 2)
+                self.state = 1043
+                self.match(CParser.Dot)
+                self.state = 1044
+                self.match(CParser.Identifier)
+
+            else:
+                raise NoViableAltException(self)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class StaticAssertDeclarationContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def constantExpression(self):
+            return self.getTypedRuleContext(CParser.ConstantExpressionContext,0)
+
+
+        def StringLiteral(self, i:int=None):
+            if i is None:
+                return self.getTokens(CParser.StringLiteral)
+            else:
+                return self.getToken(CParser.StringLiteral, i)
+
+        def getRuleIndex(self):
+            return CParser.RULE_staticAssertDeclaration
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterStaticAssertDeclaration" ):
+                listener.enterStaticAssertDeclaration(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitStaticAssertDeclaration" ):
+                listener.exitStaticAssertDeclaration(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitStaticAssertDeclaration" ):
+                return visitor.visitStaticAssertDeclaration(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def staticAssertDeclaration(self):
+
+        localctx = CParser.StaticAssertDeclarationContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 138, self.RULE_staticAssertDeclaration)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 1047
+            self.match(CParser.StaticAssert)
+            self.state = 1048
+            self.match(CParser.LeftParen)
+            self.state = 1049
+            self.constantExpression()
+            self.state = 1050
+            self.match(CParser.Comma)
+            self.state = 1052
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            while True:
+                self.state = 1051
+                self.match(CParser.StringLiteral)
+                self.state = 1054
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+                if not (_la==CParser.StringLiteral):
+                    break
+
+            self.state = 1056
+            self.match(CParser.RightParen)
+            self.state = 1057
+            self.match(CParser.Semi)
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class StatementContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def labeledStatement(self):
+            return self.getTypedRuleContext(CParser.LabeledStatementContext,0)
+
+
+        def compoundStatement(self):
+            return self.getTypedRuleContext(CParser.CompoundStatementContext,0)
+
+
+        def expressionStatement(self):
+            return self.getTypedRuleContext(CParser.ExpressionStatementContext,0)
+
+
+        def selectionStatement(self):
+            return self.getTypedRuleContext(CParser.SelectionStatementContext,0)
+
+
+        def iterationStatement(self):
+            return self.getTypedRuleContext(CParser.IterationStatementContext,0)
+
+
+        def jumpStatement(self):
+            return self.getTypedRuleContext(CParser.JumpStatementContext,0)
+
+
+        def logicalOrExpression(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(CParser.LogicalOrExpressionContext)
+            else:
+                return self.getTypedRuleContext(CParser.LogicalOrExpressionContext,i)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_statement
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterStatement" ):
+                listener.enterStatement(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitStatement" ):
+                listener.exitStatement(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitStatement" ):
+                return visitor.visitStatement(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def statement(self):
+
+        localctx = CParser.StatementContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 140, self.RULE_statement)
+        self._la = 0 # Token type
+        try:
+            self.state = 1096
+            la_ = self._interp.adaptivePredict(self._input,116,self._ctx)
+            if la_ == 1:
+                self.enterOuterAlt(localctx, 1)
+                self.state = 1059
+                self.labeledStatement()
+                pass
+
+            elif la_ == 2:
+                self.enterOuterAlt(localctx, 2)
+                self.state = 1060
+                self.compoundStatement()
+                pass
+
+            elif la_ == 3:
+                self.enterOuterAlt(localctx, 3)
+                self.state = 1061
+                self.expressionStatement()
+                pass
+
+            elif la_ == 4:
+                self.enterOuterAlt(localctx, 4)
+                self.state = 1062
+                self.selectionStatement()
+                pass
+
+            elif la_ == 5:
+                self.enterOuterAlt(localctx, 5)
+                self.state = 1063
+                self.iterationStatement()
+                pass
+
+            elif la_ == 6:
+                self.enterOuterAlt(localctx, 6)
+                self.state = 1064
+                self.jumpStatement()
+                pass
+
+            elif la_ == 7:
+                self.enterOuterAlt(localctx, 7)
+                self.state = 1065
+                _la = self._input.LA(1)
+                if not(_la==CParser.T__10 or _la==CParser.T__12):
+                    self._errHandler.recoverInline(self)
+                else:
+                    self.consume()
+                self.state = 1066
+                _la = self._input.LA(1)
+                if not(_la==CParser.T__13 or _la==CParser.Volatile):
+                    self._errHandler.recoverInline(self)
+                else:
+                    self.consume()
+                self.state = 1067
+                self.match(CParser.LeftParen)
+                self.state = 1076
+                _la = self._input.LA(1)
+                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2) | (1 << CParser.Sizeof) | (1 << CParser.Alignof) | (1 << CParser.Generic) | (1 << CParser.LeftParen))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)) | (1 << (CParser.Identifier - 71)) | (1 << (CParser.Constant - 71)) | (1 << (CParser.StringLiteral - 71)))) != 0):
+                    self.state = 1068
+                    self.logicalOrExpression(0)
+                    self.state = 1073
+                    self._errHandler.sync(self)
+                    _la = self._input.LA(1)
+                    while _la==CParser.Comma:
+                        self.state = 1069
+                        self.match(CParser.Comma)
+                        self.state = 1070
+                        self.logicalOrExpression(0)
+                        self.state = 1075
+                        self._errHandler.sync(self)
+                        _la = self._input.LA(1)
+
+
+
+                self.state = 1091
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+                while _la==CParser.Colon:
+                    self.state = 1078
+                    self.match(CParser.Colon)
+                    self.state = 1087
+                    _la = self._input.LA(1)
+                    if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2) | (1 << CParser.Sizeof) | (1 << CParser.Alignof) | (1 << CParser.Generic) | (1 << CParser.LeftParen))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)) | (1 << (CParser.Identifier - 71)) | (1 << (CParser.Constant - 71)) | (1 << (CParser.StringLiteral - 71)))) != 0):
+                        self.state = 1079
+                        self.logicalOrExpression(0)
+                        self.state = 1084
+                        self._errHandler.sync(self)
+                        _la = self._input.LA(1)
+                        while _la==CParser.Comma:
+                            self.state = 1080
+                            self.match(CParser.Comma)
+                            self.state = 1081
+                            self.logicalOrExpression(0)
+                            self.state = 1086
+                            self._errHandler.sync(self)
+                            _la = self._input.LA(1)
+
+
+
+                    self.state = 1093
+                    self._errHandler.sync(self)
+                    _la = self._input.LA(1)
+
+                self.state = 1094
+                self.match(CParser.RightParen)
+                self.state = 1095
+                self.match(CParser.Semi)
+                pass
+
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class LabeledStatementContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def Identifier(self):
+            return self.getToken(CParser.Identifier, 0)
+
+        def statement(self):
+            return self.getTypedRuleContext(CParser.StatementContext,0)
+
+
+        def constantExpression(self):
+            return self.getTypedRuleContext(CParser.ConstantExpressionContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_labeledStatement
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterLabeledStatement" ):
+                listener.enterLabeledStatement(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitLabeledStatement" ):
+                listener.exitLabeledStatement(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitLabeledStatement" ):
+                return visitor.visitLabeledStatement(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def labeledStatement(self):
+
+        localctx = CParser.LabeledStatementContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 142, self.RULE_labeledStatement)
+        try:
+            self.state = 1109
+            token = self._input.LA(1)
+            if token in [CParser.Identifier]:
+                self.enterOuterAlt(localctx, 1)
+                self.state = 1098
+                self.match(CParser.Identifier)
+                self.state = 1099
+                self.match(CParser.Colon)
+                self.state = 1100
+                self.statement()
+
+            elif token in [CParser.Case]:
+                self.enterOuterAlt(localctx, 2)
+                self.state = 1101
+                self.match(CParser.Case)
+                self.state = 1102
+                self.constantExpression()
+                self.state = 1103
+                self.match(CParser.Colon)
+                self.state = 1104
+                self.statement()
+
+            elif token in [CParser.Default]:
+                self.enterOuterAlt(localctx, 3)
+                self.state = 1106
+                self.match(CParser.Default)
+                self.state = 1107
+                self.match(CParser.Colon)
+                self.state = 1108
+                self.statement()
+
+            else:
+                raise NoViableAltException(self)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class CompoundStatementContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def blockItemList(self):
+            return self.getTypedRuleContext(CParser.BlockItemListContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_compoundStatement
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterCompoundStatement" ):
+                listener.enterCompoundStatement(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitCompoundStatement" ):
+                listener.exitCompoundStatement(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitCompoundStatement" ):
+                return visitor.visitCompoundStatement(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def compoundStatement(self):
+
+        localctx = CParser.CompoundStatementContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 144, self.RULE_compoundStatement)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 1111
+            self.match(CParser.LeftBrace)
+            self.state = 1113
+            _la = self._input.LA(1)
+            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2) | (1 << CParser.T__3) | (1 << CParser.T__4) | (1 << CParser.T__5) | (1 << CParser.T__6) | (1 << CParser.T__7) | (1 << CParser.T__8) | (1 << CParser.T__9) | (1 << CParser.T__10) | (1 << CParser.T__11) | (1 << CParser.T__12) | (1 << CParser.Auto) | (1 << CParser.Break) | (1 << CParser.Case) | (1 << CParser.Char) | (1 << CParser.Const) | (1 << CParser.Continue) | (1 << CParser.Default) | (1 << CParser.Do) | (1 << CParser.Double) | (1 << CParser.Enum) | (1 << CParser.Extern) | (1 << CParser.Float) | (1 << CParser.For) | (1 << CParser.Goto) | (1 << CParser.If) | (1 << CParser.Inline) | (1 << CParser.Int) | (1 << CParser.Long) | (1 << CParser.Register) | (1 << CParser.Restrict) | (1 << CParser.Return) | (1 << CParser.Short) | (1 << CParser.Signed) | (1 << CParser.Sizeof) | (1 << CParser.Static) | (1 << CParser.Struct) | (1 << CParser.Switch) | (1 << CParser.Typedef) | (1 << CParser.Union) | (1 << CParser.Unsigned) | (1 << CParser.Void) | (1 << CParser.Volatile) | (1 << CParser.While) | (1 << CParser.Alignas) | (1 << CParser.Alignof) | (1 << CParser.Atomic) | (1 << CParser.Bool) | (1 << CParser.Complex) | (1 << CParser.Generic) | (1 << CParser.Noreturn) | (1 << CParser.StaticAssert) | (1 << CParser.ThreadLocal) | (1 << CParser.LeftParen) | (1 << CParser.LeftBrace))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)) | (1 << (CParser.Semi - 71)) | (1 << (CParser.Identifier - 71)) | (1 << (CParser.Constant - 71)) | (1 << (CParser.StringLiteral - 71)))) != 0):
+                self.state = 1112
+                self.blockItemList(0)
+
+
+            self.state = 1115
+            self.match(CParser.RightBrace)
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class BlockItemListContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def blockItem(self):
+            return self.getTypedRuleContext(CParser.BlockItemContext,0)
+
+
+        def blockItemList(self):
+            return self.getTypedRuleContext(CParser.BlockItemListContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_blockItemList
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterBlockItemList" ):
+                listener.enterBlockItemList(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitBlockItemList" ):
+                listener.exitBlockItemList(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitBlockItemList" ):
+                return visitor.visitBlockItemList(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+    def blockItemList(self, _p:int=0):
+        _parentctx = self._ctx
+        _parentState = self.state
+        localctx = CParser.BlockItemListContext(self, self._ctx, _parentState)
+        _prevctx = localctx
+        _startState = 146
+        self.enterRecursionRule(localctx, 146, self.RULE_blockItemList, _p)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 1118
+            self.blockItem()
+            self._ctx.stop = self._input.LT(-1)
+            self.state = 1124
+            self._errHandler.sync(self)
+            _alt = self._interp.adaptivePredict(self._input,119,self._ctx)
+            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                if _alt==1:
+                    if self._parseListeners is not None:
+                        self.triggerExitRuleEvent()
+                    _prevctx = localctx
+                    localctx = CParser.BlockItemListContext(self, _parentctx, _parentState)
+                    self.pushNewRecursionContext(localctx, _startState, self.RULE_blockItemList)
+                    self.state = 1120
+                    if not self.precpred(self._ctx, 1):
+                        from antlr4.error.Errors import FailedPredicateException
+                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
+                    self.state = 1121
+                    self.blockItem()
+                self.state = 1126
+                self._errHandler.sync(self)
+                _alt = self._interp.adaptivePredict(self._input,119,self._ctx)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.unrollRecursionContexts(_parentctx)
+        return localctx
+
+    class BlockItemContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def declaration(self):
+            return self.getTypedRuleContext(CParser.DeclarationContext,0)
+
+
+        def statement(self):
+            return self.getTypedRuleContext(CParser.StatementContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_blockItem
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterBlockItem" ):
+                listener.enterBlockItem(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitBlockItem" ):
+                listener.exitBlockItem(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitBlockItem" ):
+                return visitor.visitBlockItem(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def blockItem(self):
+
+        localctx = CParser.BlockItemContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 148, self.RULE_blockItem)
+        try:
+            self.state = 1129
+            la_ = self._interp.adaptivePredict(self._input,120,self._ctx)
+            if la_ == 1:
+                self.enterOuterAlt(localctx, 1)
+                self.state = 1127
+                self.declaration()
+                pass
+
+            elif la_ == 2:
+                self.enterOuterAlt(localctx, 2)
+                self.state = 1128
+                self.statement()
+                pass
+
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class ExpressionStatementContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def expression(self):
+            return self.getTypedRuleContext(CParser.ExpressionContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_expressionStatement
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterExpressionStatement" ):
+                listener.enterExpressionStatement(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitExpressionStatement" ):
+                listener.exitExpressionStatement(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitExpressionStatement" ):
+                return visitor.visitExpressionStatement(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def expressionStatement(self):
+
+        localctx = CParser.ExpressionStatementContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 150, self.RULE_expressionStatement)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 1132
+            _la = self._input.LA(1)
+            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2) | (1 << CParser.Sizeof) | (1 << CParser.Alignof) | (1 << CParser.Generic) | (1 << CParser.LeftParen))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)) | (1 << (CParser.Identifier - 71)) | (1 << (CParser.Constant - 71)) | (1 << (CParser.StringLiteral - 71)))) != 0):
+                self.state = 1131
+                self.expression(0)
+
+
+            self.state = 1134
+            self.match(CParser.Semi)
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class SelectionStatementContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def expression(self):
+            return self.getTypedRuleContext(CParser.ExpressionContext,0)
+
+
+        def statement(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(CParser.StatementContext)
+            else:
+                return self.getTypedRuleContext(CParser.StatementContext,i)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_selectionStatement
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterSelectionStatement" ):
+                listener.enterSelectionStatement(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitSelectionStatement" ):
+                listener.exitSelectionStatement(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitSelectionStatement" ):
+                return visitor.visitSelectionStatement(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def selectionStatement(self):
+
+        localctx = CParser.SelectionStatementContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 152, self.RULE_selectionStatement)
+        try:
+            self.state = 1151
+            token = self._input.LA(1)
+            if token in [CParser.If]:
+                self.enterOuterAlt(localctx, 1)
+                self.state = 1136
+                self.match(CParser.If)
+                self.state = 1137
+                self.match(CParser.LeftParen)
+                self.state = 1138
+                self.expression(0)
+                self.state = 1139
+                self.match(CParser.RightParen)
+                self.state = 1140
+                self.statement()
+                self.state = 1143
+                la_ = self._interp.adaptivePredict(self._input,122,self._ctx)
+                if la_ == 1:
+                    self.state = 1141
+                    self.match(CParser.Else)
+                    self.state = 1142
+                    self.statement()
+
+
+
+            elif token in [CParser.Switch]:
+                self.enterOuterAlt(localctx, 2)
+                self.state = 1145
+                self.match(CParser.Switch)
+                self.state = 1146
+                self.match(CParser.LeftParen)
+                self.state = 1147
+                self.expression(0)
+                self.state = 1148
+                self.match(CParser.RightParen)
+                self.state = 1149
+                self.statement()
+
+            else:
+                raise NoViableAltException(self)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class IterationStatementContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def expression(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(CParser.ExpressionContext)
+            else:
+                return self.getTypedRuleContext(CParser.ExpressionContext,i)
+
+
+        def statement(self):
+            return self.getTypedRuleContext(CParser.StatementContext,0)
+
+
+        def declaration(self):
+            return self.getTypedRuleContext(CParser.DeclarationContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_iterationStatement
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterIterationStatement" ):
+                listener.enterIterationStatement(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitIterationStatement" ):
+                listener.exitIterationStatement(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitIterationStatement" ):
+                return visitor.visitIterationStatement(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def iterationStatement(self):
+
+        localctx = CParser.IterationStatementContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 154, self.RULE_iterationStatement)
+        self._la = 0 # Token type
+        try:
+            self.state = 1195
+            la_ = self._interp.adaptivePredict(self._input,129,self._ctx)
+            if la_ == 1:
+                self.enterOuterAlt(localctx, 1)
+                self.state = 1153
+                self.match(CParser.While)
+                self.state = 1154
+                self.match(CParser.LeftParen)
+                self.state = 1155
+                self.expression(0)
+                self.state = 1156
+                self.match(CParser.RightParen)
+                self.state = 1157
+                self.statement()
+                pass
+
+            elif la_ == 2:
+                self.enterOuterAlt(localctx, 2)
+                self.state = 1159
+                self.match(CParser.Do)
+                self.state = 1160
+                self.statement()
+                self.state = 1161
+                self.match(CParser.While)
+                self.state = 1162
+                self.match(CParser.LeftParen)
+                self.state = 1163
+                self.expression(0)
+                self.state = 1164
+                self.match(CParser.RightParen)
+                self.state = 1165
+                self.match(CParser.Semi)
+                pass
+
+            elif la_ == 3:
+                self.enterOuterAlt(localctx, 3)
+                self.state = 1167
+                self.match(CParser.For)
+                self.state = 1168
+                self.match(CParser.LeftParen)
+                self.state = 1170
+                _la = self._input.LA(1)
+                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2) | (1 << CParser.Sizeof) | (1 << CParser.Alignof) | (1 << CParser.Generic) | (1 << CParser.LeftParen))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)) | (1 << (CParser.Identifier - 71)) | (1 << (CParser.Constant - 71)) | (1 << (CParser.StringLiteral - 71)))) != 0):
+                    self.state = 1169
+                    self.expression(0)
+
+
+                self.state = 1172
+                self.match(CParser.Semi)
+                self.state = 1174
+                _la = self._input.LA(1)
+                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2) | (1 << CParser.Sizeof) | (1 << CParser.Alignof) | (1 << CParser.Generic) | (1 << CParser.LeftParen))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)) | (1 << (CParser.Identifier - 71)) | (1 << (CParser.Constant - 71)) | (1 << (CParser.StringLiteral - 71)))) != 0):
+                    self.state = 1173
+                    self.expression(0)
+
+
+                self.state = 1176
+                self.match(CParser.Semi)
+                self.state = 1178
+                _la = self._input.LA(1)
+                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2) | (1 << CParser.Sizeof) | (1 << CParser.Alignof) | (1 << CParser.Generic) | (1 << CParser.LeftParen))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)) | (1 << (CParser.Identifier - 71)) | (1 << (CParser.Constant - 71)) | (1 << (CParser.StringLiteral - 71)))) != 0):
+                    self.state = 1177
+                    self.expression(0)
+
+
+                self.state = 1180
+                self.match(CParser.RightParen)
+                self.state = 1181
+                self.statement()
+                pass
+
+            elif la_ == 4:
+                self.enterOuterAlt(localctx, 4)
+                self.state = 1182
+                self.match(CParser.For)
+                self.state = 1183
+                self.match(CParser.LeftParen)
+                self.state = 1184
+                self.declaration()
+                self.state = 1186
+                _la = self._input.LA(1)
+                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2) | (1 << CParser.Sizeof) | (1 << CParser.Alignof) | (1 << CParser.Generic) | (1 << CParser.LeftParen))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)) | (1 << (CParser.Identifier - 71)) | (1 << (CParser.Constant - 71)) | (1 << (CParser.StringLiteral - 71)))) != 0):
+                    self.state = 1185
+                    self.expression(0)
+
+
+                self.state = 1188
+                self.match(CParser.Semi)
+                self.state = 1190
+                _la = self._input.LA(1)
+                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2) | (1 << CParser.Sizeof) | (1 << CParser.Alignof) | (1 << CParser.Generic) | (1 << CParser.LeftParen))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)) | (1 << (CParser.Identifier - 71)) | (1 << (CParser.Constant - 71)) | (1 << (CParser.StringLiteral - 71)))) != 0):
+                    self.state = 1189
+                    self.expression(0)
+
+
+                self.state = 1192
+                self.match(CParser.RightParen)
+                self.state = 1193
+                self.statement()
+                pass
+
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class JumpStatementContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def Identifier(self):
+            return self.getToken(CParser.Identifier, 0)
+
+        def expression(self):
+            return self.getTypedRuleContext(CParser.ExpressionContext,0)
+
+
+        def unaryExpression(self):
+            return self.getTypedRuleContext(CParser.UnaryExpressionContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_jumpStatement
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterJumpStatement" ):
+                listener.enterJumpStatement(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitJumpStatement" ):
+                listener.exitJumpStatement(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitJumpStatement" ):
+                return visitor.visitJumpStatement(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def jumpStatement(self):
+
+        localctx = CParser.JumpStatementContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 156, self.RULE_jumpStatement)
+        self._la = 0 # Token type
+        try:
+            self.state = 1213
+            la_ = self._interp.adaptivePredict(self._input,131,self._ctx)
+            if la_ == 1:
+                self.enterOuterAlt(localctx, 1)
+                self.state = 1197
+                self.match(CParser.Goto)
+                self.state = 1198
+                self.match(CParser.Identifier)
+                self.state = 1199
+                self.match(CParser.Semi)
+                pass
+
+            elif la_ == 2:
+                self.enterOuterAlt(localctx, 2)
+                self.state = 1200
+                self.match(CParser.Continue)
+                self.state = 1201
+                self.match(CParser.Semi)
+                pass
+
+            elif la_ == 3:
+                self.enterOuterAlt(localctx, 3)
+                self.state = 1202
+                self.match(CParser.Break)
+                self.state = 1203
+                self.match(CParser.Semi)
+                pass
+
+            elif la_ == 4:
+                self.enterOuterAlt(localctx, 4)
+                self.state = 1204
+                self.match(CParser.Return)
+                self.state = 1206
+                _la = self._input.LA(1)
+                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2) | (1 << CParser.Sizeof) | (1 << CParser.Alignof) | (1 << CParser.Generic) | (1 << CParser.LeftParen))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)) | (1 << (CParser.Identifier - 71)) | (1 << (CParser.Constant - 71)) | (1 << (CParser.StringLiteral - 71)))) != 0):
+                    self.state = 1205
+                    self.expression(0)
+
+
+                self.state = 1208
+                self.match(CParser.Semi)
+                pass
+
+            elif la_ == 5:
+                self.enterOuterAlt(localctx, 5)
+                self.state = 1209
+                self.match(CParser.Goto)
+                self.state = 1210
+                self.unaryExpression()
+                self.state = 1211
+                self.match(CParser.Semi)
+                pass
+
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class CompilationUnitContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def EOF(self):
+            return self.getToken(CParser.EOF, 0)
+
+        def translationUnit(self):
+            return self.getTypedRuleContext(CParser.TranslationUnitContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_compilationUnit
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterCompilationUnit" ):
+                listener.enterCompilationUnit(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitCompilationUnit" ):
+                listener.exitCompilationUnit(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitCompilationUnit" ):
+                return visitor.visitCompilationUnit(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def compilationUnit(self):
+
+        localctx = CParser.CompilationUnitContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 158, self.RULE_compilationUnit)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 1216
+            _la = self._input.LA(1)
+            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__3) | (1 << CParser.T__4) | (1 << CParser.T__5) | (1 << CParser.T__6) | (1 << CParser.T__7) | (1 << CParser.T__8) | (1 << CParser.T__9) | (1 << CParser.T__11) | (1 << CParser.Auto) | (1 << CParser.Char) | (1 << CParser.Const) | (1 << CParser.Double) | (1 << CParser.Enum) | (1 << CParser.Extern) | (1 << CParser.Float) | (1 << CParser.Inline) | (1 << CParser.Int) | (1 << CParser.Long) | (1 << CParser.Register) | (1 << CParser.Restrict) | (1 << CParser.Short) | (1 << CParser.Signed) | (1 << CParser.Static) | (1 << CParser.Struct) | (1 << CParser.Typedef) | (1 << CParser.Union) | (1 << CParser.Unsigned) | (1 << CParser.Void) | (1 << CParser.Volatile) | (1 << CParser.Alignas) | (1 << CParser.Atomic) | (1 << CParser.Bool) | (1 << CParser.Complex) | (1 << CParser.Noreturn) | (1 << CParser.StaticAssert) | (1 << CParser.ThreadLocal) | (1 << CParser.LeftParen))) != 0) or ((((_la - 75)) & ~0x3f) == 0 and ((1 << (_la - 75)) & ((1 << (CParser.Star - 75)) | (1 << (CParser.Caret - 75)) | (1 << (CParser.Semi - 75)) | (1 << (CParser.Identifier - 75)))) != 0):
+                self.state = 1215
+                self.translationUnit(0)
+
+
+            self.state = 1218
+            self.match(CParser.EOF)
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class TranslationUnitContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def externalDeclaration(self):
+            return self.getTypedRuleContext(CParser.ExternalDeclarationContext,0)
+
+
+        def translationUnit(self):
+            return self.getTypedRuleContext(CParser.TranslationUnitContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_translationUnit
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterTranslationUnit" ):
+                listener.enterTranslationUnit(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitTranslationUnit" ):
+                listener.exitTranslationUnit(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitTranslationUnit" ):
+                return visitor.visitTranslationUnit(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+    def translationUnit(self, _p:int=0):
+        _parentctx = self._ctx
+        _parentState = self.state
+        localctx = CParser.TranslationUnitContext(self, self._ctx, _parentState)
+        _prevctx = localctx
+        _startState = 160
+        self.enterRecursionRule(localctx, 160, self.RULE_translationUnit, _p)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 1221
+            self.externalDeclaration()
+            self._ctx.stop = self._input.LT(-1)
+            self.state = 1227
+            self._errHandler.sync(self)
+            _alt = self._interp.adaptivePredict(self._input,133,self._ctx)
+            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                if _alt==1:
+                    if self._parseListeners is not None:
+                        self.triggerExitRuleEvent()
+                    _prevctx = localctx
+                    localctx = CParser.TranslationUnitContext(self, _parentctx, _parentState)
+                    self.pushNewRecursionContext(localctx, _startState, self.RULE_translationUnit)
+                    self.state = 1223
+                    if not self.precpred(self._ctx, 1):
+                        from antlr4.error.Errors import FailedPredicateException
+                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
+                    self.state = 1224
+                    self.externalDeclaration()
+                self.state = 1229
+                self._errHandler.sync(self)
+                _alt = self._interp.adaptivePredict(self._input,133,self._ctx)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.unrollRecursionContexts(_parentctx)
+        return localctx
+
+    class ExternalDeclarationContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def functionDefinition(self):
+            return self.getTypedRuleContext(CParser.FunctionDefinitionContext,0)
+
+
+        def declaration(self):
+            return self.getTypedRuleContext(CParser.DeclarationContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_externalDeclaration
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterExternalDeclaration" ):
+                listener.enterExternalDeclaration(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitExternalDeclaration" ):
+                listener.exitExternalDeclaration(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitExternalDeclaration" ):
+                return visitor.visitExternalDeclaration(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def externalDeclaration(self):
+
+        localctx = CParser.ExternalDeclarationContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 162, self.RULE_externalDeclaration)
+        try:
+            self.state = 1233
+            la_ = self._interp.adaptivePredict(self._input,134,self._ctx)
+            if la_ == 1:
+                self.enterOuterAlt(localctx, 1)
+                self.state = 1230
+                self.functionDefinition()
+                pass
+
+            elif la_ == 2:
+                self.enterOuterAlt(localctx, 2)
+                self.state = 1231
+                self.declaration()
+                pass
+
+            elif la_ == 3:
+                self.enterOuterAlt(localctx, 3)
+                self.state = 1232
+                self.match(CParser.Semi)
+                pass
+
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class FunctionDefinitionContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def declarator(self):
+            return self.getTypedRuleContext(CParser.DeclaratorContext,0)
+
+
+        def compoundStatement(self):
+            return self.getTypedRuleContext(CParser.CompoundStatementContext,0)
+
+
+        def declarationSpecifiers(self):
+            return self.getTypedRuleContext(CParser.DeclarationSpecifiersContext,0)
+
+
+        def declarationList(self):
+            return self.getTypedRuleContext(CParser.DeclarationListContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_functionDefinition
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterFunctionDefinition" ):
+                listener.enterFunctionDefinition(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitFunctionDefinition" ):
+                listener.exitFunctionDefinition(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitFunctionDefinition" ):
+                return visitor.visitFunctionDefinition(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def functionDefinition(self):
+
+        localctx = CParser.FunctionDefinitionContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 164, self.RULE_functionDefinition)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 1236
+            la_ = self._interp.adaptivePredict(self._input,135,self._ctx)
+            if la_ == 1:
+                self.state = 1235
+                self.declarationSpecifiers()
+
+
+            self.state = 1238
+            self.declarator()
+            self.state = 1240
+            _la = self._input.LA(1)
+            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__3) | (1 << CParser.T__4) | (1 << CParser.T__5) | (1 << CParser.T__6) | (1 << CParser.T__7) | (1 << CParser.T__8) | (1 << CParser.T__9) | (1 << CParser.T__11) | (1 << CParser.Auto) | (1 << CParser.Char) | (1 << CParser.Const) | (1 << CParser.Double) | (1 << CParser.Enum) | (1 << CParser.Extern) | (1 << CParser.Float) | (1 << CParser.Inline) | (1 << CParser.Int) | (1 << CParser.Long) | (1 << CParser.Register) | (1 << CParser.Restrict) | (1 << CParser.Short) | (1 << CParser.Signed) | (1 << CParser.Static) | (1 << CParser.Struct) | (1 << CParser.Typedef) | (1 << CParser.Union) | (1 << CParser.Unsigned) | (1 << CParser.Void) | (1 << CParser.Volatile) | (1 << CParser.Alignas) | (1 << CParser.Atomic) | (1 << CParser.Bool) | (1 << CParser.Complex) | (1 << CParser.Noreturn) | (1 << CParser.StaticAssert) | (1 << CParser.ThreadLocal))) != 0) or _la==CParser.Identifier:
+                self.state = 1239
+                self.declarationList(0)
+
+
+            self.state = 1242
+            self.compoundStatement()
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+    class DeclarationListContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def declaration(self):
+            return self.getTypedRuleContext(CParser.DeclarationContext,0)
+
+
+        def declarationList(self):
+            return self.getTypedRuleContext(CParser.DeclarationListContext,0)
+
+
+        def getRuleIndex(self):
+            return CParser.RULE_declarationList
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterDeclarationList" ):
+                listener.enterDeclarationList(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitDeclarationList" ):
+                listener.exitDeclarationList(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitDeclarationList" ):
+                return visitor.visitDeclarationList(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+    def declarationList(self, _p:int=0):
+        _parentctx = self._ctx
+        _parentState = self.state
+        localctx = CParser.DeclarationListContext(self, self._ctx, _parentState)
+        _prevctx = localctx
+        _startState = 166
+        self.enterRecursionRule(localctx, 166, self.RULE_declarationList, _p)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 1245
+            self.declaration()
+            self._ctx.stop = self._input.LT(-1)
+            self.state = 1251
+            self._errHandler.sync(self)
+            _alt = self._interp.adaptivePredict(self._input,137,self._ctx)
+            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                if _alt==1:
+                    if self._parseListeners is not None:
+                        self.triggerExitRuleEvent()
+                    _prevctx = localctx
+                    localctx = CParser.DeclarationListContext(self, _parentctx, _parentState)
+                    self.pushNewRecursionContext(localctx, _startState, self.RULE_declarationList)
+                    self.state = 1247
+                    if not self.precpred(self._ctx, 1):
+                        from antlr4.error.Errors import FailedPredicateException
+                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
+                    self.state = 1248
+                    self.declaration()
+                self.state = 1253
+                self._errHandler.sync(self)
+                _alt = self._interp.adaptivePredict(self._input,137,self._ctx)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.unrollRecursionContexts(_parentctx)
+        return localctx
+
+
+
+    def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int):
+        if self._predicates == None:
+            self._predicates = dict()
+        self._predicates[2] = self.genericAssocList_sempred
+        self._predicates[4] = self.postfixExpression_sempred
+        self._predicates[5] = self.argumentExpressionList_sempred
+        self._predicates[9] = self.multiplicativeExpression_sempred
+        self._predicates[10] = self.additiveExpression_sempred
+        self._predicates[11] = self.shiftExpression_sempred
+        self._predicates[12] = self.relationalExpression_sempred
+        self._predicates[13] = self.equalityExpression_sempred
+        self._predicates[14] = self.andExpression_sempred
+        self._predicates[15] = self.exclusiveOrExpression_sempred
+        self._predicates[16] = self.inclusiveOrExpression_sempred
+        self._predicates[17] = self.logicalAndExpression_sempred
+        self._predicates[18] = self.logicalOrExpression_sempred
+        self._predicates[22] = self.expression_sempred
+        self._predicates[28] = self.initDeclaratorList_sempred
+        self._predicates[34] = self.structDeclarationList_sempred
+        self._predicates[37] = self.structDeclaratorList_sempred
+        self._predicates[40] = self.enumeratorList_sempred
+        self._predicates[48] = self.directDeclarator_sempred
+        self._predicates[55] = self.typeQualifierList_sempred
+        self._predicates[57] = self.parameterList_sempred
+        self._predicates[59] = self.identifierList_sempred
+        self._predicates[62] = self.directAbstractDeclarator_sempred
+        self._predicates[65] = self.initializerList_sempred
+        self._predicates[67] = self.designatorList_sempred
+        self._predicates[73] = self.blockItemList_sempred
+        self._predicates[80] = self.translationUnit_sempred
+        self._predicates[83] = self.declarationList_sempred
+        pred = self._predicates.get(ruleIndex, None)
+        if pred is None:
+            raise Exception("No predicate with index:" + str(ruleIndex))
+        else:
+            return pred(localctx, predIndex)
+
+    def genericAssocList_sempred(self, localctx:GenericAssocListContext, predIndex:int):
+            if predIndex == 0:
+                return self.precpred(self._ctx, 1)
+
+
+    def postfixExpression_sempred(self, localctx:PostfixExpressionContext, predIndex:int):
+            if predIndex == 1:
+                return self.precpred(self._ctx, 10)
+
+
+            if predIndex == 2:
+                return self.precpred(self._ctx, 9)
+
+
+            if predIndex == 3:
+                return self.precpred(self._ctx, 8)
+
+
+            if predIndex == 4:
+                return self.precpred(self._ctx, 7)
+
+
+            if predIndex == 5:
+                return self.precpred(self._ctx, 6)
+
+
+            if predIndex == 6:
+                return self.precpred(self._ctx, 5)
+
+
+    def argumentExpressionList_sempred(self, localctx:ArgumentExpressionListContext, predIndex:int):
+            if predIndex == 7:
+                return self.precpred(self._ctx, 1)
+
+
+    def multiplicativeExpression_sempred(self, localctx:MultiplicativeExpressionContext, predIndex:int):
+            if predIndex == 8:
+                return self.precpred(self._ctx, 3)
+
+
+            if predIndex == 9:
+                return self.precpred(self._ctx, 2)
+
+
+            if predIndex == 10:
+                return self.precpred(self._ctx, 1)
+
+
+    def additiveExpression_sempred(self, localctx:AdditiveExpressionContext, predIndex:int):
+            if predIndex == 11:
+                return self.precpred(self._ctx, 2)
+
+
+            if predIndex == 12:
+                return self.precpred(self._ctx, 1)
+
+
+    def shiftExpression_sempred(self, localctx:ShiftExpressionContext, predIndex:int):
+            if predIndex == 13:
+                return self.precpred(self._ctx, 2)
+
+
+            if predIndex == 14:
+                return self.precpred(self._ctx, 1)
+
+
+    def relationalExpression_sempred(self, localctx:RelationalExpressionContext, predIndex:int):
+            if predIndex == 15:
+                return self.precpred(self._ctx, 4)
+
+
+            if predIndex == 16:
+                return self.precpred(self._ctx, 3)
+
+
+            if predIndex == 17:
+                return self.precpred(self._ctx, 2)
+
+
+            if predIndex == 18:
+                return self.precpred(self._ctx, 1)
+
+
+    def equalityExpression_sempred(self, localctx:EqualityExpressionContext, predIndex:int):
+            if predIndex == 19:
+                return self.precpred(self._ctx, 2)
+
+
+            if predIndex == 20:
+                return self.precpred(self._ctx, 1)
+
+
+    def andExpression_sempred(self, localctx:AndExpressionContext, predIndex:int):
+            if predIndex == 21:
+                return self.precpred(self._ctx, 1)
+
+
+    def exclusiveOrExpression_sempred(self, localctx:ExclusiveOrExpressionContext, predIndex:int):
+            if predIndex == 22:
+                return self.precpred(self._ctx, 1)
+
+
+    def inclusiveOrExpression_sempred(self, localctx:InclusiveOrExpressionContext, predIndex:int):
+            if predIndex == 23:
+                return self.precpred(self._ctx, 1)
+
+
+    def logicalAndExpression_sempred(self, localctx:LogicalAndExpressionContext, predIndex:int):
+            if predIndex == 24:
+                return self.precpred(self._ctx, 1)
+
+
+    def logicalOrExpression_sempred(self, localctx:LogicalOrExpressionContext, predIndex:int):
+            if predIndex == 25:
+                return self.precpred(self._ctx, 1)
+
+
+    def expression_sempred(self, localctx:ExpressionContext, predIndex:int):
+            if predIndex == 26:
+                return self.precpred(self._ctx, 1)
+
+
+    def initDeclaratorList_sempred(self, localctx:InitDeclaratorListContext, predIndex:int):
+            if predIndex == 27:
+                return self.precpred(self._ctx, 1)
+
+
+    def structDeclarationList_sempred(self, localctx:StructDeclarationListContext, predIndex:int):
+            if predIndex == 28:
+                return self.precpred(self._ctx, 1)
+
+
+    def structDeclaratorList_sempred(self, localctx:StructDeclaratorListContext, predIndex:int):
+            if predIndex == 29:
+                return self.precpred(self._ctx, 1)
+
+
+    def enumeratorList_sempred(self, localctx:EnumeratorListContext, predIndex:int):
+            if predIndex == 30:
+                return self.precpred(self._ctx, 1)
+
+
+    def directDeclarator_sempred(self, localctx:DirectDeclaratorContext, predIndex:int):
+            if predIndex == 31:
+                return self.precpred(self._ctx, 6)
+
+
+            if predIndex == 32:
+                return self.precpred(self._ctx, 5)
+
+
+            if predIndex == 33:
+                return self.precpred(self._ctx, 4)
+
+
+            if predIndex == 34:
+                return self.precpred(self._ctx, 3)
+
+
+            if predIndex == 35:
+                return self.precpred(self._ctx, 2)
+
+
+            if predIndex == 36:
+                return self.precpred(self._ctx, 1)
+
+
+    def typeQualifierList_sempred(self, localctx:TypeQualifierListContext, predIndex:int):
+            if predIndex == 37:
+                return self.precpred(self._ctx, 1)
+
+
+    def parameterList_sempred(self, localctx:ParameterListContext, predIndex:int):
+            if predIndex == 38:
+                return self.precpred(self._ctx, 1)
+
+
+    def identifierList_sempred(self, localctx:IdentifierListContext, predIndex:int):
+            if predIndex == 39:
+                return self.precpred(self._ctx, 1)
+
+
+    def directAbstractDeclarator_sempred(self, localctx:DirectAbstractDeclaratorContext, predIndex:int):
+            if predIndex == 40:
+                return self.precpred(self._ctx, 5)
+
+
+            if predIndex == 41:
+                return self.precpred(self._ctx, 4)
+
+
+            if predIndex == 42:
+                return self.precpred(self._ctx, 3)
+
+
+            if predIndex == 43:
+                return self.precpred(self._ctx, 2)
+
+
+            if predIndex == 44:
+                return self.precpred(self._ctx, 1)
+
+
+    def initializerList_sempred(self, localctx:InitializerListContext, predIndex:int):
+            if predIndex == 45:
+                return self.precpred(self._ctx, 1)
+
+
+    def designatorList_sempred(self, localctx:DesignatorListContext, predIndex:int):
+            if predIndex == 46:
+                return self.precpred(self._ctx, 1)
+
+
+    def blockItemList_sempred(self, localctx:BlockItemListContext, predIndex:int):
+            if predIndex == 47:
+                return self.precpred(self._ctx, 1)
+
+
+    def translationUnit_sempred(self, localctx:TranslationUnitContext, predIndex:int):
+            if predIndex == 48:
+                return self.precpred(self._ctx, 1)
+
+
+    def declarationList_sempred(self, localctx:DeclarationListContext, predIndex:int):
+            if predIndex == 49:
+                return self.precpred(self._ctx, 1)
+
diff --git a/tool-testsuite/pom.xml b/tool-testsuite/pom.xml
new file mode 100644
index 000000000..c7b1564d4
--- /dev/null
+++ b/tool-testsuite/pom.xml
@@ -0,0 +1,91 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+
+  <modelVersion>4.0.0</modelVersion>
+  <parent>
+    <groupId>org.antlr</groupId>
+    <artifactId>antlr4-master</artifactId>
+    <version>4.5.4-SNAPSHOT</version>
+  </parent>
+  <artifactId>antlr4-tool-testsuite</artifactId>
+  <name>ANTLR 4 Tool Tests</name>
+  <description>A collection of tests for ANTLR 4 Runtime libraries.</description>
+
+  <prerequisites>
+    <maven>3.0</maven>
+  </prerequisites>
+
+  <inceptionYear>2009</inceptionYear>
+
+  <dependencies>
+    <dependency>
+      <groupId>org.antlr</groupId>
+      <artifactId>ST4</artifactId>
+      <version>4.0.8</version>
+    </dependency>
+    <dependency>
+      <groupId>org.antlr</groupId>
+      <artifactId>antlr4-runtime</artifactId>
+      <version>${project.version}</version>
+    </dependency>
+    <dependency>
+      <groupId>org.antlr</groupId>
+      <artifactId>antlr4-runtime-testsuite</artifactId>
+      <version>${project.version}</version>
+    </dependency>
+    <dependency>
+      <groupId>org.antlr</groupId>
+      <artifactId>antlr4</artifactId>
+      <version>${project.version}</version>
+    </dependency>
+    <dependency>
+      <groupId>org.antlr</groupId>
+      <artifactId>antlr4</artifactId>
+      <version>${project.version}</version>
+      <type>test-jar</type>
+    </dependency>
+    <dependency>
+      <groupId>org.antlr</groupId>
+      <artifactId>antlr4-runtime-testsuite</artifactId>
+      <version>${project.version}</version>
+      <type>test-jar</type>
+    </dependency>
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <version>4.11</version>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
+
+  <build>
+    <sourceDirectory>src</sourceDirectory>
+    <plugins>
+      <plugin>
+        <groupId>com.googlecode.maven-download-plugin</groupId>
+        <artifactId>download-maven-plugin</artifactId>
+        <version>1.2.1</version>
+        <configuration>
+          <skipCache>true</skipCache>
+        </configuration>
+      </plugin>
+      <plugin>
+        <groupId>org.codehaus.mojo</groupId>
+        <artifactId>build-helper-maven-plugin</artifactId>
+        <version>1.8</version>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-surefire-plugin</artifactId>
+        <version>2.12.4</version>
+        <configuration>
+          <systemPropertyVariables>
+            <antlr-python2-runtime>../../antlr4-python2/src</antlr-python2-runtime>
+            <antlr-python3-runtime>../../antlr4-python3/src</antlr-python3-runtime>
+            <antlr-csharp-runtime-project>../../antlr4-csharp/runtime/CSharp/Antlr4.Runtime/Antlr4.Runtime.mono.csproj</antlr-csharp-runtime-project>
+            <antlr-javascript-runtime>../../antlr4-javascript/src</antlr-javascript-runtime>
+          </systemPropertyVariables>
+        </configuration>
+      </plugin>
+    </plugins>
+  </build>
+</project>
diff --git a/tool-testsuite/test/org/antlr/v4/test/tool/InterpreterTreeTextProvider.java b/tool-testsuite/test/org/antlr/v4/test/tool/InterpreterTreeTextProvider.java
new file mode 100644
index 000000000..bff84ae17
--- /dev/null
+++ b/tool-testsuite/test/org/antlr/v4/test/tool/InterpreterTreeTextProvider.java
@@ -0,0 +1,24 @@
+package org.antlr.v4.test.tool;
+
+import org.antlr.v4.gui.TreeTextProvider;
+import org.antlr.v4.runtime.tree.ErrorNode;
+import org.antlr.v4.runtime.tree.Tree;
+import org.antlr.v4.runtime.tree.Trees;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class InterpreterTreeTextProvider implements TreeTextProvider {
+	public List<String> ruleNames;
+	public InterpreterTreeTextProvider(String[] ruleNames) {this.ruleNames = Arrays.asList(ruleNames);}
+
+	@Override
+	public String getText(Tree node) {
+		if ( node==null ) return "null";
+		String nodeText = Trees.getNodeText(node, ruleNames);
+		if ( node instanceof ErrorNode) {
+			return "<error "+nodeText+">";
+		}
+		return nodeText;
+	}
+}
diff --git a/tool/test/org/antlr/v4/test/Java.g4 b/tool-testsuite/test/org/antlr/v4/test/tool/Java.g4
similarity index 100%
rename from tool/test/org/antlr/v4/test/Java.g4
rename to tool-testsuite/test/org/antlr/v4/test/tool/Java.g4
diff --git a/tool/test/org/antlr/v4/test/Java-LR.g4 b/tool-testsuite/test/org/antlr/v4/test/tool/JavaLR.g4
similarity index 98%
rename from tool/test/org/antlr/v4/test/Java-LR.g4
rename to tool-testsuite/test/org/antlr/v4/test/tool/JavaLR.g4
index 49d7efb3a..049e28357 100644
--- a/tool/test/org/antlr/v4/test/Java-LR.g4
+++ b/tool-testsuite/test/org/antlr/v4/test/tool/JavaLR.g4
@@ -168,7 +168,7 @@
  *      letter-or-digit is a character for which the method 
  *      Character.isJavaIdentifierPart(int) returns true."
  */
-grammar Java;
+grammar JavaLR;
 
 // starting point for parsing a java file
 /* The annotations are separated out to make parsing faster, but must be associated with
@@ -734,19 +734,19 @@ expression
 	|   expression '&&' expression
 	|   expression '||' expression
 	|   expression '?' expression ':' expression
-	|   expression
-        (	'='<assoc=right>
-        |	'+='<assoc=right>
-        |	'-='<assoc=right>
-        |	'*='<assoc=right>
-        |	'/='<assoc=right>
-        |	'&='<assoc=right>
-        |	'|='<assoc=right>
-        |	'^='<assoc=right>
-        |	'>>='<assoc=right>
-        |	'>>>='<assoc=right>
-        |	'<<='<assoc=right>
-        |	'%='<assoc=right>
+	|<assoc=right> expression
+        (	'='
+        |	'+='
+        |	'-='
+        |	'*='
+        |	'/='
+        |	'&='
+        |	'|='
+        |	'^='
+        |	'>>='
+        |	'>>>='
+        |	'<<='
+        |	'%='
         )
         expression
     ;
diff --git a/tool/test/org/antlr/v4/test/JavaUnicodeInputStream.java b/tool-testsuite/test/org/antlr/v4/test/tool/JavaUnicodeInputStream.java
similarity index 98%
rename from tool/test/org/antlr/v4/test/JavaUnicodeInputStream.java
rename to tool-testsuite/test/org/antlr/v4/test/tool/JavaUnicodeInputStream.java
index d9c22dde3..d51d0000d 100644
--- a/tool/test/org/antlr/v4/test/JavaUnicodeInputStream.java
+++ b/tool-testsuite/test/org/antlr/v4/test/tool/JavaUnicodeInputStream.java
@@ -28,19 +28,18 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-package org.antlr.v4.test;
+package org.antlr.v4.test.tool;
 
 import org.antlr.v4.runtime.CharStream;
 import org.antlr.v4.runtime.misc.IntegerList;
 import org.antlr.v4.runtime.misc.Interval;
-import org.antlr.v4.runtime.misc.NotNull;
 
 /**
  *
  * @author Sam Harwell
  */
 public class JavaUnicodeInputStream implements CharStream {
-	@NotNull
+
 	private final CharStream source;
 	private final IntegerList escapeIndexes = new IntegerList();
 	private final IntegerList escapeCharacters = new IntegerList();
@@ -52,7 +51,7 @@ public class JavaUnicodeInputStream implements CharStream {
 
 	private int la1;
 
-	public JavaUnicodeInputStream(@NotNull CharStream source) {
+	public JavaUnicodeInputStream(CharStream source) {
 		if (source == null) {
 			throw new NullPointerException("source");
 		}
diff --git a/tool/test/org/antlr/v4/test/ParserInterpreterForTesting.java b/tool-testsuite/test/org/antlr/v4/test/tool/ParserInterpreterForTesting.java
similarity index 89%
rename from tool/test/org/antlr/v4/test/ParserInterpreterForTesting.java
rename to tool-testsuite/test/org/antlr/v4/test/tool/ParserInterpreterForTesting.java
index 542eefe06..9fe58a1bf 100644
--- a/tool/test/org/antlr/v4/test/ParserInterpreterForTesting.java
+++ b/tool-testsuite/test/org/antlr/v4/test/tool/ParserInterpreterForTesting.java
@@ -28,7 +28,7 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-package org.antlr.v4.test;
+package org.antlr.v4.test.tool;
 
 import org.antlr.v4.Tool;
 import org.antlr.v4.runtime.Parser;
@@ -40,8 +40,6 @@ import org.antlr.v4.runtime.atn.DecisionState;
 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.misc.NotNull;
-import org.antlr.v4.runtime.misc.Nullable;
 import org.antlr.v4.tool.Grammar;
 
 public class ParserInterpreterForTesting {
@@ -73,6 +71,7 @@ public class ParserInterpreterForTesting {
 		}
 
 		@Override
+		@Deprecated
 		public String[] getTokenNames() {
 			return g.getTokenNames();
 		}
@@ -88,11 +87,11 @@ public class ParserInterpreterForTesting {
 	protected ParserATNSimulator atnSimulator;
 	protected TokenStream input;
 
-	public ParserInterpreterForTesting(@NotNull Grammar g) {
+	public ParserInterpreterForTesting(Grammar g) {
 		this.g = g;
 	}
 
-	public ParserInterpreterForTesting(@NotNull Grammar g, @NotNull TokenStream input) {
+	public ParserInterpreterForTesting(Grammar g, TokenStream input) {
 		Tool antlr = new Tool();
 		antlr.process(g,false);
 		parser = new DummyParser(g, g.atn, input);
@@ -101,14 +100,14 @@ public class ParserInterpreterForTesting {
 										  parser.sharedContextCache);
 	}
 
-	public int adaptivePredict(@NotNull TokenStream input, int decision,
-							   @Nullable ParserRuleContext outerContext)
+	public int adaptivePredict(TokenStream input, int decision,
+							   ParserRuleContext outerContext)
 	{
 		return atnSimulator.adaptivePredict(input, decision, outerContext);
 	}
 
-	public int matchATN(@NotNull TokenStream input,
-						@NotNull ATNState startState)
+	public int matchATN(TokenStream input,
+						ATNState startState)
 	{
 		if (startState.getNumberOfTransitions() == 1) {
 			return 1;
diff --git a/tool/test/org/antlr/v4/test/PositionAdjustingLexer.g4 b/tool-testsuite/test/org/antlr/v4/test/tool/PositionAdjustingLexer.g4
similarity index 100%
rename from tool/test/org/antlr/v4/test/PositionAdjustingLexer.g4
rename to tool-testsuite/test/org/antlr/v4/test/tool/PositionAdjustingLexer.g4
diff --git a/tool-testsuite/test/org/antlr/v4/test/tool/Psl.g4 b/tool-testsuite/test/org/antlr/v4/test/tool/Psl.g4
new file mode 100644
index 000000000..acc64488d
--- /dev/null
+++ b/tool-testsuite/test/org/antlr/v4/test/tool/Psl.g4
@@ -0,0 +1,348 @@
+grammar Psl;
+
+@parser::members
+{
+	public void printPosition(String name, Token tok)
+	{
+		System.out.printf("%s: pos %d, len %d%n",
+				name, tok.getCharPositionInLine(), tok.getText().length());
+	}
+
+
+	/**
+	 * Checks whether a set of digit groups and commas construct
+	 * a valid command-number.
+	 *
+	 * @param digits
+	 *		The groups of digits, each group in a separate item.
+	 * @param commas
+	 *		The commas found separating the digit groups.
+	 *
+	 * There should be one more digit group than commas.
+	 * There should be no internal white space.
+	 *
+	 * @returns true (valid), false (invalid)
+	 */
+
+	public boolean isValidCommaNumber(List<Token> digits, List<Token> commas)
+	{
+		Token[]	aDigits = new Token[0];
+		Token[]	aCommas = new Token[0];
+		int		j;
+
+		aDigits = digits.toArray(aDigits);
+		aCommas = commas.toArray(aCommas);
+		if (aDigits.length != aCommas.length + 1)
+		{
+			return false;
+		}
+		for (j = 0; j < aCommas.length; ++j)
+		{
+			int	p1, p2, p3;
+			p1 = aDigits[j].getCharPositionInLine()
+					+ aDigits[j].getText().length();
+			p2 = aCommas[j].getCharPositionInLine();
+			p3 = aDigits[j + 1].getCharPositionInLine();
+			if (p1 != p2 || (p2 + 1) != p3)
+			{
+				return false;
+			}
+		}
+		return true;
+	}
+
+
+	/**
+	 * Checks whether a the pieces of a floating-point number
+	 * construct a valid number.
+	 *
+	 * @param whole
+	 *		The whole part of the number.  Can be null.
+	 * @param period
+	 *		The decimal point.
+	 * @param fraction
+	 *		The fraction part of the number.  Can be null.
+	 *
+	 * At least one of the whole or fraction must be present.
+	 * The decimal point is required.
+	 *
+	 * @returns true (valid), false (invalid)
+	 */
+
+	public boolean isValidFloatingConstant(
+		Token whole,
+		Token period,
+		Token fraction
+	)
+	{
+		boolean		foundDigits = false;
+		int			column;
+
+		if (whole != null)
+		{
+			foundDigits = true;
+			column = whole.getCharPositionInLine()
+					+ whole.getText().length();
+			if (column != period.getCharPositionInLine())
+			{
+				return false;
+			}
+		}
+		if (fraction != null)
+		{
+			foundDigits = true;
+			column = period.getCharPositionInLine() + 1;
+			if (column != fraction.getCharPositionInLine())
+			{
+				return false;
+			}
+		}
+		return foundDigits;
+	}
+}
+
+translation_unit
+	:	numeric_range
+		EOF
+	;
+
+pattern
+	:	numeric_range
+	;
+
+numeric_range
+	:	EURO_NUMBER
+		PAREN_LEFT
+		numeric_endpoint
+		TILDE
+		numeric_endpoint
+		PAREN_RIGHT
+	|	NUMBER
+		PAREN_LEFT
+		numeric_endpoint
+		TILDE
+		numeric_endpoint
+		PAREN_RIGHT
+	;
+
+numeric_endpoint
+	:	( PLUS | MINUS )? integer_constant
+	|	( PLUS | MINUS )? floating_constant
+	|	( PLUS | MINUS )? comma_number
+	;
+
+	/* Floating-point numbers and comma numbers are valid only
+	 * as numeric endpoints in number() or euro_number().  Otherwise,
+	 * the pieces should be parsed as separate lexical tokens, such as
+	 *
+	 *	integer_constant '.' integer_constant
+	 *
+	 * Because of parser lookahead and the subtle interactions between
+	 * the parser and the lexer, changing lexical modes from the parser
+	 * is not safe.  The code below checks the constraints for floating
+	 * numbers, forbidding internal white space.
+	 */
+
+floating_constant
+	:	comma_number PERIOD fraction=DIGIT_SEQUENCE?
+		{
+			isValidFloatingConstant($comma_number.stop, $PERIOD, $fraction)
+		}?<fail = {
+			"COMMA:A floating-point constant cannot have internal white space"
+		}>
+
+	/*|	whole=DIGIT_SEQUENCE PERIOD fraction=DIGIT_SEQUENCE?
+		{
+			isValidFloatingConstant($whole, $PERIOD, $fraction)
+		}?/* <fail = {
+			"DIG:A floating-point constant cannot have internal white space"
+		}>*/
+
+	|	PERIOD fraction=DIGIT_SEQUENCE
+		{
+			isValidFloatingConstant(null, $PERIOD, $fraction)
+		}?<fail = {
+			"DEC:A floating-point constant cannot have internal white space"
+		}>
+	;
+
+comma_number
+	:	digits+=DIGIT_SEQUENCE ( commas+=COMMA digits+=DIGIT_SEQUENCE )+
+		{
+			isValidCommaNumber($digits, $commas)
+		}?<fail = {
+			"A comma-number cannot have internal white space"
+		}>
+	;
+
+term_expression
+	:	term
+	|	RETURN
+		(
+			PAREN_LEFT
+			( integer_constant | ALL )
+			PAREN_RIGHT
+		)?
+		term
+	;
+
+term
+	:	pattern
+	|	PAREN_LEFT term_expression PAREN_RIGHT
+	;
+
+integer_constant
+	:	DIGIT_SEQUENCE
+	|	INTEGER_CONSTANT
+	|	BINARY_CONSTANT
+	|	DECIMAL_CONSTANT
+	|	HEXADECIMAL_CONSTANT
+	|	OCTAL_CONSTANT
+	;
+
+// LEXER
+
+/* Letter fragments
+ */
+
+fragment A: [Aa] ;
+fragment B: [BB] ;
+fragment C: [Cc] ;
+fragment D: [Dd] ;
+fragment E: [Ee] ;
+fragment F: [Ff] ;
+fragment G: [Gg] ;
+fragment H: [Hh] ;
+fragment I: [Ii] ;
+fragment J: [Jj] ;
+fragment K: [Kk] ;
+fragment L: [Ll] ;
+fragment M: [Mm] ;
+fragment N: [Nn] ;
+fragment O: [Oo] ;
+fragment P: [Pp] ;
+fragment Q: [Qq] ;
+fragment R: [Rr] ;
+fragment S: [Ss] ;
+fragment T: [Tt] ;
+fragment U: [Uu] ;
+fragment V: [Vv] ;
+fragment W: [Ww] ;
+fragment X: [Xx] ;
+fragment Y: [Yy] ;
+fragment Z: [Zz] ;
+
+
+WHITESPACE_IN_LINE
+	:	[ \t]+
+		-> skip
+	;
+
+NEWLINE
+	:	'\r'? '\n'
+		-> skip
+	;
+
+WHITESPACE_ALL
+	:	[ \n\r\t]+
+		-> skip
+	;
+
+
+	/* A sequence of decimal digits is useful on its own,
+	 * to avoid the base-prefixes (0b, 0x, ...) that an
+	 * INTEGER_CONTANT would allow.
+	 * Need to define before INTEGER_CONSTANT to make sure
+	 * DIGIT_SEQUENCE is recognized before INTEGER_CONSTANT.
+	 */
+
+DIGIT_SEQUENCE
+	:	[0-9]+
+	;
+
+INTEGER_CONSTANT
+	:	BINARY_CONSTANT
+	|	DECIMAL_CONSTANT
+	|	HEXADECIMAL_CONSTANT
+	|	OCTAL_CONSTANT
+	;
+
+BINARY_CONSTANT
+	:	'0' [Bb] [0-1]+
+	;
+
+DECIMAL_CONSTANT
+	:	( '0' [Dd] )? [0-9]+
+	;
+
+HEXADECIMAL_CONSTANT
+	:	'0' [HhXx] [0-9a-fA-F]+
+	;
+
+OCTAL_CONSTANT
+	:	'0' [Oo] [0-7]+
+	;
+
+/*	keywords
+ */
+
+ALL
+	:	A L L
+	;
+
+EURO_NUMBER
+	:	E U R O '_' N U M B E R
+	;
+
+
+NUMBER
+	:	N U M B E R
+	;
+
+RETURN
+	:	R E T U R N
+	;
+
+IDENTIFIER
+	:	[A-Za-z][A-Za-z0-9_]*
+	;
+
+
+/* The single-character tokens.
+ */
+
+COMMA
+	:	','
+	;
+
+MINUS
+	:	'-'
+	;
+
+PAREN_LEFT
+	:	'('
+	;
+
+PAREN_RIGHT
+	:	')'
+	;
+
+PERIOD
+	:	'.'
+	;
+
+PLUS
+	:	'+'
+	;
+
+TILDE
+	:	'~'
+	;
+
+	/* This rule must be last (or nearly last) to avoid
+	 * matching individual characters for other rules.
+	 */
+
+ANY_CHAR_BUT_NEWLINE
+	:	~[\n\r]
+	;
diff --git a/tool/test/org/antlr/v4/test/TestASTStructure.gunit b/tool-testsuite/test/org/antlr/v4/test/tool/TestASTStructure.gunit
similarity index 100%
rename from tool/test/org/antlr/v4/test/TestASTStructure.gunit
rename to tool-testsuite/test/org/antlr/v4/test/tool/TestASTStructure.gunit
diff --git a/tool/test/org/antlr/v4/test/TestASTStructure.java b/tool-testsuite/test/org/antlr/v4/test/tool/TestASTStructure.java
similarity index 99%
rename from tool/test/org/antlr/v4/test/TestASTStructure.java
rename to tool-testsuite/test/org/antlr/v4/test/tool/TestASTStructure.java
index 90662460d..d081fe8da 100644
--- a/tool/test/org/antlr/v4/test/TestASTStructure.java
+++ b/tool-testsuite/test/org/antlr/v4/test/tool/TestASTStructure.java
@@ -28,7 +28,7 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-package org.antlr.v4.test;
+package org.antlr.v4.test.tool;
 
 import org.antlr.runtime.ANTLRStringStream;
 import org.antlr.runtime.CharStream;
diff --git a/tool/test/org/antlr/v4/test/TestATNConstruction.java b/tool-testsuite/test/org/antlr/v4/test/tool/TestATNConstruction.java
similarity index 90%
rename from tool/test/org/antlr/v4/test/TestATNConstruction.java
rename to tool-testsuite/test/org/antlr/v4/test/tool/TestATNConstruction.java
index 2d836a7fd..08648f5c4 100644
--- a/tool/test/org/antlr/v4/test/TestATNConstruction.java
+++ b/tool-testsuite/test/org/antlr/v4/test/tool/TestATNConstruction.java
@@ -27,17 +27,32 @@
  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-package org.antlr.v4.test;
+package org.antlr.v4.test.tool;
+
+import org.antlr.v4.Tool;
 import org.antlr.v4.automata.ATNPrinter;
 import org.antlr.v4.automata.LexerATNFactory;
 import org.antlr.v4.automata.ParserATNFactory;
+import org.antlr.v4.parse.ANTLRParser;
 import org.antlr.v4.runtime.atn.ATN;
 import org.antlr.v4.runtime.atn.ATNState;
+import org.antlr.v4.test.runtime.java.BaseTest;
+import org.antlr.v4.test.runtime.java.ErrorQueue;
+import org.antlr.v4.tool.ErrorType;
 import org.antlr.v4.tool.Grammar;
 import org.antlr.v4.tool.LexerGrammar;
+import org.antlr.v4.tool.ast.GrammarAST;
+import org.antlr.v4.tool.ast.GrammarRootAST;
+import org.antlr.v4.tool.ast.RuleAST;
 import org.junit.Test;
 
-import static org.junit.Assert.*;
+import java.util.Arrays;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
 
 public class TestATNConstruction extends BaseTest {
 	@Test
@@ -279,6 +294,33 @@ public class TestATNConstruction extends BaseTest {
 				"RuleStop_a_1-EOF->s7\n";
 		checkRuleATN(g, "a", expecting);
 	}
+	@Test public void testAplusSingleAltHasPlusASTPointingAtLoopBackState() throws Exception {
+		Grammar g = new Grammar(
+			"parser grammar P;\n"+
+			"s : a B ;\n" +			// (RULE a (BLOCK (ALT (+ (BLOCK (ALT A))))))
+			"a : A+;");
+		String expecting =
+			"RuleStart_a_2->PlusBlockStart_8\n" +
+			"PlusBlockStart_8->s7\n" +
+			"s7-A->BlockEnd_9\n" +
+			"BlockEnd_9->PlusLoopBack_10\n" +
+			"PlusLoopBack_10->PlusBlockStart_8\n" +
+			"PlusLoopBack_10->s11\n" +
+			"s11->RuleStop_a_3\n" +
+			"RuleStop_a_3->s5\n";
+		checkRuleATN(g, "a", expecting);
+		// Get all AST -> ATNState relationships. Make sure loopback is covered when no loop entry decision
+		List<GrammarAST> ruleNodes = g.ast.getNodesWithType(ANTLRParser.RULE);
+		RuleAST a = (RuleAST)ruleNodes.get(1);
+		List<GrammarAST> nodesInRule = a.getNodesWithType(null);
+		Map<GrammarAST, ATNState> covered = new LinkedHashMap<GrammarAST, ATNState>();
+		for (GrammarAST node : nodesInRule) {
+			if ( node.atnState != null ) {
+				covered.put(node, node.atnState);
+			}
+		}
+		assertEquals("{RULE=2, BLOCK=8, +=10, BLOCK=8, A=7}", covered.toString());
+	}
 	@Test public void testAorBplus() throws Exception {
 		Grammar g = new Grammar(
 			"parser grammar P;\n"+
@@ -390,6 +432,38 @@ public class TestATNConstruction extends BaseTest {
 				"RuleStop_a_1-EOF->s8\n";
 		checkRuleATN(g, "a", expecting);
 	}
+
+	@Test public void testParserRuleRefInLexerRule() throws Exception {
+		boolean threwException = false;
+		ErrorQueue errorQueue = new ErrorQueue();
+		try {
+			String gstr =
+				"grammar U;\n"+
+				"a : A;\n"+
+				"A : a;\n";
+
+			Tool tool = new Tool();
+			tool.removeListeners();
+			tool.addListener(errorQueue);
+			assertEquals(0, errorQueue.size());
+			GrammarRootAST grammarRootAST = tool.parseGrammarFromString(gstr);
+			assertEquals(0, errorQueue.size());
+			Grammar g = tool.createGrammar(grammarRootAST);
+			assertEquals(0, errorQueue.size());
+			g.fileName = "<string>";
+			tool.process(g, false);
+		}
+		catch (Exception e) {
+			threwException = true;
+			e.printStackTrace();
+		}
+		System.out.println(errorQueue);
+		assertEquals(1, errorQueue.errors.size());
+		assertEquals(ErrorType.PARSER_RULE_REF_IN_LEXER_RULE, errorQueue.errors.get(0).getErrorType());
+		assertEquals("[a, A]", Arrays.toString(errorQueue.errors.get(0).getArgs()));
+		assertTrue(!threwException);
+	}
+
 /*
 	@Test public void testMultiplePredicates() throws Exception {
 		Grammar g = new Grammar(
diff --git a/tool/test/org/antlr/v4/test/TestATNDeserialization.java b/tool-testsuite/test/org/antlr/v4/test/tool/TestATNDeserialization.java
similarity index 97%
rename from tool/test/org/antlr/v4/test/TestATNDeserialization.java
rename to tool-testsuite/test/org/antlr/v4/test/tool/TestATNDeserialization.java
index bf08ab592..a8ef3affc 100644
--- a/tool/test/org/antlr/v4/test/TestATNDeserialization.java
+++ b/tool-testsuite/test/org/antlr/v4/test/tool/TestATNDeserialization.java
@@ -28,20 +28,21 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-package org.antlr.v4.test;
+package org.antlr.v4.test.tool;
 
 import org.antlr.v4.runtime.atn.ATN;
 import org.antlr.v4.runtime.atn.ATNDeserializer;
 import org.antlr.v4.runtime.atn.ATNSerializer;
 import org.antlr.v4.runtime.misc.Utils;
+import org.antlr.v4.test.runtime.java.BaseTest;
 import org.antlr.v4.tool.Grammar;
 import org.antlr.v4.tool.LexerGrammar;
 import org.junit.Test;
 
-import static org.junit.Assert.*;
-
 import java.util.Arrays;
 
+import static org.junit.Assert.assertEquals;
+
 public class TestATNDeserialization extends BaseTest {
 	@Test public void testSimpleNoBlock() throws Exception {
 		Grammar g = new Grammar(
diff --git a/tool/test/org/antlr/v4/test/TestATNInterpreter.java b/tool-testsuite/test/org/antlr/v4/test/tool/TestATNInterpreter.java
similarity index 99%
rename from tool/test/org/antlr/v4/test/TestATNInterpreter.java
rename to tool-testsuite/test/org/antlr/v4/test/tool/TestATNInterpreter.java
index 289890f37..2309a1cf2 100644
--- a/tool/test/org/antlr/v4/test/TestATNInterpreter.java
+++ b/tool-testsuite/test/org/antlr/v4/test/tool/TestATNInterpreter.java
@@ -28,7 +28,7 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-package org.antlr.v4.test;
+package org.antlr.v4.test.tool;
 
 import org.antlr.v4.automata.ParserATNFactory;
 import org.antlr.v4.runtime.Lexer;
@@ -39,6 +39,7 @@ import org.antlr.v4.runtime.atn.BlockStartState;
 import org.antlr.v4.runtime.atn.LexerATNSimulator;
 import org.antlr.v4.runtime.dfa.DFA;
 import org.antlr.v4.runtime.misc.IntegerList;
+import org.antlr.v4.test.runtime.java.BaseTest;
 import org.antlr.v4.tool.DOTGenerator;
 import org.antlr.v4.tool.Grammar;
 import org.antlr.v4.tool.LexerGrammar;
diff --git a/tool/test/org/antlr/v4/test/TestATNLexerInterpreter.java b/tool-testsuite/test/org/antlr/v4/test/tool/TestATNLexerInterpreter.java
similarity index 98%
rename from tool/test/org/antlr/v4/test/TestATNLexerInterpreter.java
rename to tool-testsuite/test/org/antlr/v4/test/tool/TestATNLexerInterpreter.java
index a88449c99..aaf28c3b0 100644
--- a/tool/test/org/antlr/v4/test/TestATNLexerInterpreter.java
+++ b/tool-testsuite/test/org/antlr/v4/test/tool/TestATNLexerInterpreter.java
@@ -28,20 +28,21 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-package org.antlr.v4.test;
+package org.antlr.v4.test.tool;
 
 import org.antlr.v4.runtime.ANTLRInputStream;
 import org.antlr.v4.runtime.CharStream;
 import org.antlr.v4.runtime.atn.ATN;
 import org.antlr.v4.runtime.atn.ATNState;
 import org.antlr.v4.runtime.misc.Utils;
+import org.antlr.v4.test.runtime.java.BaseTest;
 import org.antlr.v4.tool.DOTGenerator;
 import org.antlr.v4.tool.LexerGrammar;
 import org.junit.Test;
 
 import java.util.List;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
 
 /**
  * Lexer rules are little quirky when it comes to wildcards. Problem
diff --git a/tool/test/org/antlr/v4/test/TestATNParserPrediction.java b/tool-testsuite/test/org/antlr/v4/test/tool/TestATNParserPrediction.java
similarity index 59%
rename from tool/test/org/antlr/v4/test/TestATNParserPrediction.java
rename to tool-testsuite/test/org/antlr/v4/test/tool/TestATNParserPrediction.java
index 841143edd..5e5731cff 100644
--- a/tool/test/org/antlr/v4/test/TestATNParserPrediction.java
+++ b/tool-testsuite/test/org/antlr/v4/test/tool/TestATNParserPrediction.java
@@ -28,7 +28,7 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-package org.antlr.v4.test;
+package org.antlr.v4.test.tool;
 
 import org.antlr.v4.Tool;
 import org.antlr.v4.automata.ParserATNFactory;
@@ -41,155 +41,160 @@ import org.antlr.v4.runtime.atn.LexerATNSimulator;
 import org.antlr.v4.runtime.atn.PredictionContextCache;
 import org.antlr.v4.runtime.dfa.DFA;
 import org.antlr.v4.runtime.misc.IntegerList;
+import org.antlr.v4.test.runtime.java.BaseTest;
 import org.antlr.v4.tool.DOTGenerator;
 import org.antlr.v4.tool.Grammar;
+import org.antlr.v4.tool.LeftRecursiveRule;
 import org.antlr.v4.tool.LexerGrammar;
 import org.antlr.v4.tool.Rule;
 import org.junit.Test;
 
-import static org.junit.Assert.assertEquals;
+import java.util.Arrays;
 
-	// NOTICE: TOKENS IN LEXER, PARSER MUST BE SAME OR TOKEN TYPE MISMATCH
-	// NOTICE: TOKENS IN LEXER, PARSER MUST BE SAME OR TOKEN TYPE MISMATCH
-	// NOTICE: TOKENS IN LEXER, PARSER MUST BE SAME OR TOKEN TYPE MISMATCH
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+// NOTICE: TOKENS IN LEXER, PARSER MUST BE SAME OR TOKEN TYPE MISMATCH
+// NOTICE: TOKENS IN LEXER, PARSER MUST BE SAME OR TOKEN TYPE MISMATCH
+// NOTICE: TOKENS IN LEXER, PARSER MUST BE SAME OR TOKEN TYPE MISMATCH
 
 public class TestATNParserPrediction extends BaseTest {
 	@Test public void testAorB() throws Exception {
 		LexerGrammar lg = new LexerGrammar(
-			"lexer grammar L;\n" +
-			"A : 'a' ;\n" +
-			"B : 'b' ;\n" +
-			"C : 'c' ;\n");
+		"lexer grammar L;\n" +
+		"A : 'a' ;\n" +
+		"B : 'b' ;\n" +
+		"C : 'c' ;\n");
 		Grammar g = new Grammar(
-			"parser grammar T;\n"+
-			"a : A{;} | B ;");
+		"parser grammar T;\n"+
+		"a : A{;} | B ;");
 		int decision = 0;
 		checkPredictedAlt(lg, g, decision, "a", 1);
 		checkPredictedAlt(lg, g, decision, "b", 2);
 
 		// After matching these inputs for decision, what is DFA after each prediction?
 		String[] inputs = {
-			"a",
-			"b",
-			"a"
+		"a",
+		"b",
+		"a"
 		};
 		String[] dfa = {
-			"s0-'a'->:s1=>1\n",
+		"s0-'a'->:s1=>1\n",
 
-			"s0-'a'->:s1=>1\n" +
-			"s0-'b'->:s2=>2\n",
+		"s0-'a'->:s1=>1\n" +
+		"s0-'b'->:s2=>2\n",
 
-			"s0-'a'->:s1=>1\n" + // don't change after it works
-			"s0-'b'->:s2=>2\n",
+		"s0-'a'->:s1=>1\n" + // don't change after it works
+		"s0-'b'->:s2=>2\n",
 		};
 		checkDFAConstruction(lg, g, decision, inputs, dfa);
 	}
 
 	@Test public void testEmptyInput() throws Exception {
 		LexerGrammar lg = new LexerGrammar(
-			"lexer grammar L;\n" +
-			"A : 'a' ;\n" +
-			"B : 'b' ;\n" +
-			"C : 'c' ;\n");
+		"lexer grammar L;\n" +
+		"A : 'a' ;\n" +
+		"B : 'b' ;\n" +
+		"C : 'c' ;\n");
 		Grammar g = new Grammar(
-			"parser grammar T;\n"+
-			"a : A | ;");
+		"parser grammar T;\n"+
+		"a : A | ;");
 		int decision = 0;
 		checkPredictedAlt(lg, g, decision, "a", 1);
 		checkPredictedAlt(lg, g, decision, "", 2);
 
 		// After matching these inputs for decision, what is DFA after each prediction?
 		String[] inputs = {
-			"a",
-			"",
+		"a",
+		"",
 		};
 		String[] dfa = {
-			"s0-'a'->:s1=>1\n",
+		"s0-'a'->:s1=>1\n",
 
-			"s0-EOF->:s2=>2\n" +
-			"s0-'a'->:s1=>1\n",
+		"s0-EOF->:s2=>2\n" +
+		"s0-'a'->:s1=>1\n",
 		};
 		checkDFAConstruction(lg, g, decision, inputs, dfa);
 	}
 
 	@Test public void testPEGAchillesHeel() throws Exception {
 		LexerGrammar lg = new LexerGrammar(
-			"lexer grammar L;\n" +
-			"A : 'a' ;\n" +
-			"B : 'b' ;\n" +
-			"C : 'c' ;\n");
+		"lexer grammar L;\n" +
+		"A : 'a' ;\n" +
+		"B : 'b' ;\n" +
+		"C : 'c' ;\n");
 		Grammar g = new Grammar(
-			"parser grammar T;\n"+
-			"a : A | A B ;");
+		"parser grammar T;\n"+
+		"a : A | A B ;");
 		checkPredictedAlt(lg, g, 0, "a", 1);
 		checkPredictedAlt(lg, g, 0, "ab", 2);
 		checkPredictedAlt(lg, g, 0, "abc", 2);
 
 		String[] inputs = {
-			"a",
-			"ab",
-			"abc"
+		"a",
+		"ab",
+		"abc"
 		};
 		String[] dfa = {
-			"s0-'a'->s1\n" +
-			"s1-EOF->:s2=>1\n",
+		"s0-'a'->s1\n" +
+		"s1-EOF->:s2=>1\n",
 
-			"s0-'a'->s1\n" +
-			"s1-EOF->:s2=>1\n" +
-			"s1-'b'->:s3=>2\n",
+		"s0-'a'->s1\n" +
+		"s1-EOF->:s2=>1\n" +
+		"s1-'b'->:s3=>2\n",
 
-			"s0-'a'->s1\n" +
-			"s1-EOF->:s2=>1\n" +
-			"s1-'b'->:s3=>2\n"
+		"s0-'a'->s1\n" +
+		"s1-EOF->:s2=>1\n" +
+		"s1-'b'->:s3=>2\n"
 		};
 		checkDFAConstruction(lg, g, 0, inputs, dfa);
 	}
 
 	@Test public void testRuleRefxory() throws Exception {
 		LexerGrammar lg = new LexerGrammar(
-			"lexer grammar L;\n" +
-			"A : 'a' ;\n" +
-			"B : 'b' ;\n" +
-			"C : 'c' ;\n");
+		"lexer grammar L;\n" +
+		"A : 'a' ;\n" +
+		"B : 'b' ;\n" +
+		"C : 'c' ;\n");
 		Grammar g = new Grammar(
-			"parser grammar T;\n"+
-			"a : x | y ;\n" +
-			"x : A ;\n" +
-			"y : B ;\n");
+		"parser grammar T;\n"+
+		"a : x | y ;\n" +
+		"x : A ;\n" +
+		"y : B ;\n");
 		int decision = 0;
 		checkPredictedAlt(lg, g, decision, "a", 1);
 		checkPredictedAlt(lg, g, decision, "b", 2);
 
 		// After matching these inputs for decision, what is DFA after each prediction?
 		String[] inputs = {
-			"a",
-			"b",
-			"a"
+		"a",
+		"b",
+		"a"
 		};
 		String[] dfa = {
-			"s0-'a'->:s1=>1\n",
+		"s0-'a'->:s1=>1\n",
 
-			"s0-'a'->:s1=>1\n" +
-			"s0-'b'->:s2=>2\n",
+		"s0-'a'->:s1=>1\n" +
+		"s0-'b'->:s2=>2\n",
 
-			"s0-'a'->:s1=>1\n" + // don't change after it works
-			"s0-'b'->:s2=>2\n",
+		"s0-'a'->:s1=>1\n" + // don't change after it works
+		"s0-'b'->:s2=>2\n",
 		};
 		checkDFAConstruction(lg, g, decision, inputs, dfa);
 	}
 
 	@Test public void testOptionalRuleChasesGlobalFollow() throws Exception {
 		LexerGrammar lg = new LexerGrammar(
-			"lexer grammar L;\n" +
-			"A : 'a' ;\n" +
-			"B : 'b' ;\n" +
-			"C : 'c' ;\n");
+		"lexer grammar L;\n" +
+		"A : 'a' ;\n" +
+		"B : 'b' ;\n" +
+		"C : 'c' ;\n");
 		Grammar g = new Grammar(
-			"parser grammar T;\n"+
-			"tokens {A,B,C}\n" +
-			"a : x B ;\n" +
-			"b : x C ;\n" +
-			"x : A | ;\n");
+		"parser grammar T;\n"+
+		"tokens {A,B,C}\n" +
+		"a : x B ;\n" +
+		"b : x C ;\n" +
+		"x : A | ;\n");
 		int decision = 0;
 		checkPredictedAlt(lg, g, decision, "a", 1);
 		checkPredictedAlt(lg, g, decision, "b", 2);
@@ -197,116 +202,116 @@ public class TestATNParserPrediction extends BaseTest {
 
 		// After matching these inputs for decision, what is DFA after each prediction?
 		String[] inputs = {
-			"a",
-			"b",
-			"c",
-			"c",
+		"a",
+		"b",
+		"c",
+		"c",
 		};
 		String[] dfa = {
-			"s0-'a'->:s1=>1\n",
+		"s0-'a'->:s1=>1\n",
 
-			"s0-'a'->:s1=>1\n" +
-			"s0-'b'->:s2=>2\n",
+		"s0-'a'->:s1=>1\n" +
+		"s0-'b'->:s2=>2\n",
 
-			"s0-'a'->:s1=>1\n" +
-			"s0-'b'->:s2=>2\n" +
-			"s0-'c'->:s3=>2\n",
+		"s0-'a'->:s1=>1\n" +
+		"s0-'b'->:s2=>2\n" +
+		"s0-'c'->:s3=>2\n",
 
-			"s0-'a'->:s1=>1\n" +
-			"s0-'b'->:s2=>2\n" +
-			"s0-'c'->:s3=>2\n",
+		"s0-'a'->:s1=>1\n" +
+		"s0-'b'->:s2=>2\n" +
+		"s0-'c'->:s3=>2\n",
 		};
 		checkDFAConstruction(lg, g, decision, inputs, dfa);
 	}
 
 	@Test public void testLL1Ambig() throws Exception {
 		LexerGrammar lg = new LexerGrammar(
-			"lexer grammar L;\n" +
-			"A : 'a' ;\n" +
-			"B : 'b' ;\n" +
-			"C : 'c' ;\n");
+		"lexer grammar L;\n" +
+		"A : 'a' ;\n" +
+		"B : 'b' ;\n" +
+		"C : 'c' ;\n");
 		Grammar g = new Grammar(
-			"parser grammar T;\n"+
-			"a : A | A | A B ;");
+		"parser grammar T;\n"+
+		"a : A | A | A B ;");
 		int decision = 0;
 		checkPredictedAlt(lg, g, decision, "a", 1);
 		checkPredictedAlt(lg, g, decision, "ab", 3);
 
 		// After matching these inputs for decision, what is DFA after each prediction?
 		String[] inputs = {
-			"a",
-			"ab",
-			"ab"
+		"a",
+		"ab",
+		"ab"
 		};
 		String[] dfa = {
-			"s0-'a'->s1\n" +
-			"s1-EOF->:s2^=>1\n",
+		"s0-'a'->s1\n" +
+		"s1-EOF->:s2^=>1\n",
 
-			"s0-'a'->s1\n" +
-			"s1-EOF->:s2^=>1\n" +
-			"s1-'b'->:s3=>3\n",
+		"s0-'a'->s1\n" +
+		"s1-EOF->:s2^=>1\n" +
+		"s1-'b'->:s3=>3\n",
 
-			"s0-'a'->s1\n" +
-			"s1-EOF->:s2^=>1\n" +
-			"s1-'b'->:s3=>3\n",
+		"s0-'a'->s1\n" +
+		"s1-EOF->:s2^=>1\n" +
+		"s1-'b'->:s3=>3\n",
 		};
 		checkDFAConstruction(lg, g, decision, inputs, dfa);
 	}
 
 	@Test public void testLL2Ambig() throws Exception {
 		LexerGrammar lg = new LexerGrammar(
-			"lexer grammar L;\n" +
-			"A : 'a' ;\n" +
-			"B : 'b' ;\n" +
-			"C : 'c' ;\n");
+		"lexer grammar L;\n" +
+		"A : 'a' ;\n" +
+		"B : 'b' ;\n" +
+		"C : 'c' ;\n");
 		Grammar g = new Grammar(
-			"parser grammar T;\n"+
-			"a : A B | A B | A B C ;");
+		"parser grammar T;\n"+
+		"a : A B | A B | A B C ;");
 		int decision = 0;
 		checkPredictedAlt(lg, g, decision, "ab", 1);
 		checkPredictedAlt(lg, g, decision, "abc", 3);
 
 		// After matching these inputs for decision, what is DFA after each prediction?
 		String[] inputs = {
-			"ab",
-			"abc",
-			"ab"
+		"ab",
+		"abc",
+		"ab"
 		};
 		String[] dfa = {
-			"s0-'a'->s1\n" +
-			"s1-'b'->s2\n" +
-			"s2-EOF->:s3^=>1\n",
+		"s0-'a'->s1\n" +
+		"s1-'b'->s2\n" +
+		"s2-EOF->:s3^=>1\n",
 
-			"s0-'a'->s1\n" +
-			"s1-'b'->s2\n" +
-			"s2-EOF->:s3^=>1\n" +
-			"s2-'c'->:s4=>3\n",
+		"s0-'a'->s1\n" +
+		"s1-'b'->s2\n" +
+		"s2-EOF->:s3^=>1\n" +
+		"s2-'c'->:s4=>3\n",
 
-			"s0-'a'->s1\n" +
-			"s1-'b'->s2\n" +
-			"s2-EOF->:s3^=>1\n" +
-			"s2-'c'->:s4=>3\n",
+		"s0-'a'->s1\n" +
+		"s1-'b'->s2\n" +
+		"s2-EOF->:s3^=>1\n" +
+		"s2-'c'->:s4=>3\n",
 		};
 		checkDFAConstruction(lg, g, decision, inputs, dfa);
 	}
 
 	@Test public void testRecursiveLeftPrefix() throws Exception {
 		LexerGrammar lg = new LexerGrammar(
-			"lexer grammar L;\n" +
-			"A : 'a' ;\n" +
-			"B : 'b' ;\n" +
-			"C : 'c' ;\n" +
-			"LP : '(' ;\n" +
-			"RP : ')' ;\n" +
-			"INT : '0'..'9'+ ;\n"
+		"lexer grammar L;\n" +
+		"A : 'a' ;\n" +
+		"B : 'b' ;\n" +
+		"C : 'c' ;\n" +
+		"LP : '(' ;\n" +
+		"RP : ')' ;\n" +
+		"INT : '0'..'9'+ ;\n"
 		);
 		Grammar g = new Grammar(
-			"parser grammar T;\n"+
-			"tokens {A,B,C,LP,RP,INT}\n" +
-			"a : e B | e C ;\n" +
-			"e : LP e RP\n" +
-			"  | INT\n" +
-			"  ;");
+		"parser grammar T;\n"+
+		"tokens {A,B,C,LP,RP,INT}\n" +
+		"a : e B | e C ;\n" +
+		"e : LP e RP\n" +
+		"  | INT\n" +
+		"  ;");
 		int decision = 0;
 		checkPredictedAlt(lg, g, decision, "34b", 1);
 		checkPredictedAlt(lg, g, decision, "34c", 2);
@@ -315,57 +320,57 @@ public class TestATNParserPrediction extends BaseTest {
 
 		// After matching these inputs for decision, what is DFA after each prediction?
 		String[] inputs = {
-			"34b",
-			"34c",
-			"((34))b",
-			"((34))c"
+		"34b",
+		"34c",
+		"((34))b",
+		"((34))c"
 		};
 		String[] dfa = {
-			"s0-INT->s1\n" +
-			"s1-'b'->:s2=>1\n",
+		"s0-INT->s1\n" +
+		"s1-'b'->:s2=>1\n",
 
-			"s0-INT->s1\n" +
-			"s1-'b'->:s2=>1\n" +
-			"s1-'c'->:s3=>2\n",
+		"s0-INT->s1\n" +
+		"s1-'b'->:s2=>1\n" +
+		"s1-'c'->:s3=>2\n",
 
-			"s0-'('->s4\n" +
-			"s0-INT->s1\n" +
-			"s1-'b'->:s2=>1\n" +
-			"s1-'c'->:s3=>2\n" +
-			"s4-'('->s5\n" +
-			"s5-INT->s6\n" +
-			"s6-')'->s7\n" +
-			"s7-')'->s1\n",
+		"s0-'('->s4\n" +
+		"s0-INT->s1\n" +
+		"s1-'b'->:s2=>1\n" +
+		"s1-'c'->:s3=>2\n" +
+		"s4-'('->s5\n" +
+		"s5-INT->s6\n" +
+		"s6-')'->s7\n" +
+		"s7-')'->s1\n",
 
-			"s0-'('->s4\n" +
-			"s0-INT->s1\n" +
-			"s1-'b'->:s2=>1\n" +
-			"s1-'c'->:s3=>2\n" +
-			"s4-'('->s5\n" +
-			"s5-INT->s6\n" +
-			"s6-')'->s7\n" +
-			"s7-')'->s1\n",
+		"s0-'('->s4\n" +
+		"s0-INT->s1\n" +
+		"s1-'b'->:s2=>1\n" +
+		"s1-'c'->:s3=>2\n" +
+		"s4-'('->s5\n" +
+		"s5-INT->s6\n" +
+		"s6-')'->s7\n" +
+		"s7-')'->s1\n",
 		};
 		checkDFAConstruction(lg, g, decision, inputs, dfa);
 	}
 
 	@Test public void testRecursiveLeftPrefixWithAorABIssue() throws Exception {
 		LexerGrammar lg = new LexerGrammar(
-			"lexer grammar L;\n" +
-			"A : 'a' ;\n" +
-			"B : 'b' ;\n" +
-			"C : 'c' ;\n" +
-			"LP : '(' ;\n" +
-			"RP : ')' ;\n" +
-			"INT : '0'..'9'+ ;\n"
+		"lexer grammar L;\n" +
+		"A : 'a' ;\n" +
+		"B : 'b' ;\n" +
+		"C : 'c' ;\n" +
+		"LP : '(' ;\n" +
+		"RP : ')' ;\n" +
+		"INT : '0'..'9'+ ;\n"
 		);
 		Grammar g = new Grammar(
-			"parser grammar T;\n"+
-			"tokens {A,B,C,LP,RP,INT}\n" +
-			"a : e A | e A B ;\n" +
-			"e : LP e RP\n" +
-			"  | INT\n" +
-			"  ;");
+		"parser grammar T;\n"+
+		"tokens {A,B,C,LP,RP,INT}\n" +
+		"a : e A | e A B ;\n" +
+		"e : LP e RP\n" +
+		"  | INT\n" +
+		"  ;");
 		int decision = 0;
 		checkPredictedAlt(lg, g, decision, "34a", 1);
 		checkPredictedAlt(lg, g, decision, "34ab", 2); // PEG would miss this one!
@@ -374,40 +379,40 @@ public class TestATNParserPrediction extends BaseTest {
 
 		// After matching these inputs for decision, what is DFA after each prediction?
 		String[] inputs = {
-			"34a",
-			"34ab",
-			"((34))a",
-			"((34))ab",
+		"34a",
+		"34ab",
+		"((34))a",
+		"((34))ab",
 		};
 		String[] dfa = {
-			"s0-INT->s1\n" +
-			"s1-'a'->s2\n" +
-			"s2-EOF->:s3=>1\n",
+		"s0-INT->s1\n" +
+		"s1-'a'->s2\n" +
+		"s2-EOF->:s3=>1\n",
 
-			"s0-INT->s1\n" +
-			"s1-'a'->s2\n" +
-			"s2-EOF->:s3=>1\n" +
-			"s2-'b'->:s4=>2\n",
+		"s0-INT->s1\n" +
+		"s1-'a'->s2\n" +
+		"s2-EOF->:s3=>1\n" +
+		"s2-'b'->:s4=>2\n",
 
-			"s0-'('->s5\n" +
-			"s0-INT->s1\n" +
-			"s1-'a'->s2\n" +
-			"s2-EOF->:s3=>1\n" +
-			"s2-'b'->:s4=>2\n" +
-			"s5-'('->s6\n" +
-			"s6-INT->s7\n" +
-			"s7-')'->s8\n" +
-			"s8-')'->s1\n",
+		"s0-'('->s5\n" +
+		"s0-INT->s1\n" +
+		"s1-'a'->s2\n" +
+		"s2-EOF->:s3=>1\n" +
+		"s2-'b'->:s4=>2\n" +
+		"s5-'('->s6\n" +
+		"s6-INT->s7\n" +
+		"s7-')'->s8\n" +
+		"s8-')'->s1\n",
 
-			"s0-'('->s5\n" +
-			"s0-INT->s1\n" +
-			"s1-'a'->s2\n" +
-			"s2-EOF->:s3=>1\n" +
-			"s2-'b'->:s4=>2\n" +
-			"s5-'('->s6\n" +
-			"s6-INT->s7\n" +
-			"s7-')'->s8\n" +
-			"s8-')'->s1\n",
+		"s0-'('->s5\n" +
+		"s0-INT->s1\n" +
+		"s1-'a'->s2\n" +
+		"s2-EOF->:s3=>1\n" +
+		"s2-'b'->:s4=>2\n" +
+		"s5-'('->s6\n" +
+		"s6-INT->s7\n" +
+		"s7-')'->s8\n" +
+		"s8-')'->s1\n",
 		};
 		checkDFAConstruction(lg, g, decision, inputs, dfa);
 	}
@@ -418,15 +423,15 @@ public class TestATNParserPrediction extends BaseTest {
 		// be declared ambig since (12, 2, []) can take us to
 		// unambig state maybe. keep going.
 		LexerGrammar lg = new LexerGrammar(
-			"lexer grammar L;\n" +
-			"ID : 'a'..'z' ;\n" + // one char
-			"SEMI : ';' ;\n"+
-			"INT : '0'..'9'+ ;\n"
+		"lexer grammar L;\n" +
+		"ID : 'a'..'z' ;\n" + // one char
+		"SEMI : ';' ;\n"+
+		"INT : '0'..'9'+ ;\n"
 		);
 		Grammar g = new Grammar(
-			"parser grammar T;\n"+
-			"tokens {ID,SEMI,INT}\n" +
-			"a : (ID | ID ID?) SEMI ;");
+		"parser grammar T;\n"+
+		"tokens {ID,SEMI,INT}\n" +
+		"a : (ID | ID ID?) SEMI ;");
 		int decision = 1;
 		checkPredictedAlt(lg, g, decision, "a;", 1);
 		checkPredictedAlt(lg, g, decision, "ab;", 2);
@@ -435,30 +440,85 @@ public class TestATNParserPrediction extends BaseTest {
 	@Test public void testContinuePrediction2() throws Exception {
 		// ID is ambig for first two alts, but ID SEMI lets us move forward with alt 3
 		LexerGrammar lg = new LexerGrammar(
-			"lexer grammar L;\n" +
-			"ID : 'a'..'z' ;\n" + // one char
-			"SEMI : ';' ;\n"+
-			"INT : '0'..'9'+ ;\n"
+		"lexer grammar L;\n" +
+		"ID : 'a'..'z' ;\n" + // one char
+		"SEMI : ';' ;\n"+
+		"INT : '0'..'9'+ ;\n"
 		);
 		Grammar g = new Grammar(
-			"parser grammar T;\n"+
-			"tokens {ID,SEMI,INT}\n" +
-			"a : ID | ID | ID SEMI ;\n");
+		"parser grammar T;\n"+
+		"tokens {ID,SEMI,INT}\n" +
+		"a : ID | ID | ID SEMI ;\n");
 		int decision = 0;
 		checkPredictedAlt(lg, g, decision, "a", 1);
 		checkPredictedAlt(lg, g, decision, "a;", 3);
 	}
 
+	@Test public void testAltsForLRRuleComputation() throws Exception {
+		Grammar g = new Grammar(
+		"grammar T;\n" +
+		"e : e '*' e\n" +
+		"  | INT\n" +
+		"  | e '+' e\n" +
+		"  | ID\n" +
+		"  ;\n" +
+		"ID : [a-z]+ ;\n" +
+		"INT : [0-9]+ ;\n" +
+		"WS : [ \\r\\t\\n]+ ;");
+		Rule e = g.getRule("e");
+		assertTrue(e instanceof LeftRecursiveRule);
+		LeftRecursiveRule lr = (LeftRecursiveRule)e;
+		assertEquals("[0, 2, 4]", Arrays.toString(lr.getPrimaryAlts()));
+		assertEquals("[0, 1, 3]", Arrays.toString(lr.getRecursiveOpAlts()));
+	}
+
+	@Test public void testAltsForLRRuleComputation2() throws Exception {
+		Grammar g = new Grammar(
+		"grammar T;\n" +
+		"e : INT\n" +
+		"  | e '*' e\n" +
+		"  | ID\n" +
+		"  ;\n" +
+		"ID : [a-z]+ ;\n" +
+		"INT : [0-9]+ ;\n" +
+		"WS : [ \\r\\t\\n]+ ;");
+		Rule e = g.getRule("e");
+		assertTrue(e instanceof LeftRecursiveRule);
+		LeftRecursiveRule lr = (LeftRecursiveRule)e;
+		assertEquals("[0, 1, 3]", Arrays.toString(lr.getPrimaryAlts()));
+		assertEquals("[0, 2]", Arrays.toString(lr.getRecursiveOpAlts()));
+	}
+
+	@Test public void testAltsForLRRuleComputation3() throws Exception {
+		Grammar g = new Grammar(
+		"grammar T;\n" +
+		"random : 'blort';\n" + // should have no effect
+		"e : '--' e\n" +
+		"  | e '*' e\n" +
+		"  | e '+' e\n" +
+		"  | e '--'\n" +
+		"  | ID\n" +
+		"  ;\n" +
+		"ID : [a-z]+ ;\n" +
+		"INT : [0-9]+ ;\n" +
+		"WS : [ \\r\\t\\n]+ ;");
+		Rule e = g.getRule("e");
+		assertTrue(e instanceof LeftRecursiveRule);
+		LeftRecursiveRule lr = (LeftRecursiveRule)e;
+		assertEquals("[0, 1, 5]", Arrays.toString(lr.getPrimaryAlts()));
+		assertEquals("[0, 2, 3, 4]", Arrays.toString(lr.getRecursiveOpAlts()));
+	}
+
 	/** first check that the ATN predicts right alt.
 	 *  Then check adaptive prediction.
 	 */
 	public void checkPredictedAlt(LexerGrammar lg, Grammar g, int decision,
-								  String inputString, int expectedAlt)
+	                              String inputString, int expectedAlt)
 	{
 		Tool.internalOption_ShowATNConfigsInDFA = true;
 		ATN lexatn = createATN(lg, true);
 		LexerATNSimulator lexInterp =
-			new LexerATNSimulator(lexatn,new DFA[] { new DFA(lexatn.modeToStartState.get(Lexer.DEFAULT_MODE)) },new PredictionContextCache());
+		new LexerATNSimulator(lexatn,new DFA[] { new DFA(lexatn.modeToStartState.get(Lexer.DEFAULT_MODE)) },new PredictionContextCache());
 		IntegerList types = getTokenTypesViaATN(inputString, lexInterp);
 		System.out.println(types);
 
@@ -501,12 +561,12 @@ public class TestATNParserPrediction extends BaseTest {
 	}
 
 	public void checkDFAConstruction(LexerGrammar lg, Grammar g, int decision,
-									 String[] inputString, String[] dfaString)
+	                                 String[] inputString, String[] dfaString)
 	{
 //		Tool.internalOption_ShowATNConfigsInDFA = true;
 		ATN lexatn = createATN(lg, true);
 		LexerATNSimulator lexInterp =
-			new LexerATNSimulator(lexatn,new DFA[] { new DFA(lexatn.getDecisionState(Lexer.DEFAULT_MODE)) }, new PredictionContextCache());
+		new LexerATNSimulator(lexatn,new DFA[] { new DFA(lexatn.getDecisionState(Lexer.DEFAULT_MODE)) }, new PredictionContextCache());
 
 		semanticProcess(lg);
 		g.importVocab(lg);
@@ -525,7 +585,7 @@ public class TestATNParserPrediction extends BaseTest {
 				nvae.printStackTrace(System.err);
 			}
 			DFA dfa = interp.parser.decisionToDFA[decision];
-			assertEquals(dfaString[i], dfa.toString(g.getTokenDisplayNames()));
+			assertEquals(dfaString[i], dfa.toString(g.getVocabulary()));
 		}
 	}
 }
diff --git a/tool/test/org/antlr/v4/test/TestATNSerialization.java b/tool-testsuite/test/org/antlr/v4/test/tool/TestATNSerialization.java
similarity index 96%
rename from tool/test/org/antlr/v4/test/TestATNSerialization.java
rename to tool-testsuite/test/org/antlr/v4/test/tool/TestATNSerialization.java
index 7c3a81fe9..2c1a2b098 100644
--- a/tool/test/org/antlr/v4/test/TestATNSerialization.java
+++ b/tool-testsuite/test/org/antlr/v4/test/tool/TestATNSerialization.java
@@ -28,10 +28,11 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-package org.antlr.v4.test;
+package org.antlr.v4.test.tool;
 
 import org.antlr.v4.runtime.atn.ATN;
 import org.antlr.v4.runtime.atn.ATNSerializer;
+import org.antlr.v4.test.runtime.java.BaseTest;
 import org.antlr.v4.tool.DOTGenerator;
 import org.antlr.v4.tool.Grammar;
 import org.antlr.v4.tool.LexerGrammar;
@@ -39,7 +40,7 @@ import org.junit.Test;
 
 import java.util.Arrays;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
 
 public class TestATNSerialization extends BaseTest {
 	@Test public void testSimpleNoBlock() throws Exception {
@@ -292,8 +293,8 @@ public class TestATNSerialization extends BaseTest {
 			"6:BASIC 0\n" +
 			"7:BASIC 1\n" +
 			"8:BASIC 1\n" +
-			"rule 0:1 1,-1\n" +
-			"rule 1:3 2,-1\n" +
+			"rule 0:1 1\n" +
+			"rule 1:3 2\n" +
 			"mode 0:0\n" +
 			"0->1 EPSILON 0,0,0\n" +
 			"0->3 EPSILON 0,0,0\n" +
@@ -320,7 +321,7 @@ public class TestATNSerialization extends BaseTest {
 			"2:RULE_STOP 0\n" +
 			"3:BASIC 0\n" +
 			"4:BASIC 0\n" +
-			"rule 0:1 1,-1\n" +
+			"rule 0:1 1\n" +
 			"mode 0:0\n" +
 			"0->1 EPSILON 0,0,0\n" +
 			"1->3 EPSILON 0,0,0\n" +
@@ -344,7 +345,7 @@ public class TestATNSerialization extends BaseTest {
 				"3:BASIC 0\n" +
 				"4:BASIC 0\n" +
 				"5:BASIC 0\n" +
-				"rule 0:1 1,-1\n" +
+				"rule 0:1 1\n" +
 				"mode 0:0\n" +
 				"0->1 EPSILON 0,0,0\n" +
 				"1->3 EPSILON 0,0,0\n" +
@@ -370,7 +371,7 @@ public class TestATNSerialization extends BaseTest {
 				"4:BASIC 0\n" +
 				"5:BLOCK_START 0 6\n" +
 				"6:BLOCK_END 0\n" +
-				"rule 0:1 1,-1\n" +
+				"rule 0:1 1\n" +
 				"mode 0:0\n" +
 				"0:EOF, '\\n'..'\\n'\n" +
 				"0->1 EPSILON 0,0,0\n" +
@@ -400,7 +401,7 @@ public class TestATNSerialization extends BaseTest {
 				"5:BLOCK_END 0\n" +
 				"6:PLUS_LOOP_BACK 0\n" +
 				"7:LOOP_END 0 6\n" +
-				"rule 0:1 1,-1\n" +
+				"rule 0:1 1\n" +
 				"mode 0:0\n" +
 				"0->1 EPSILON 0,0,0\n" +
 				"1->4 EPSILON 0,0,0\n" +
@@ -440,9 +441,9 @@ public class TestATNSerialization extends BaseTest {
 				"12:BASIC 2\n" +
 				"13:BASIC 2\n" +
 				"14:BASIC 2\n" +
-				"rule 0:1 1,0\n" +
-				"rule 1:3 2,-1\n" +
-				"rule 2:5 3,1\n" +
+				"rule 0:1 1\n" +
+				"rule 1:3 2\n" +
+				"rule 2:5 3\n" +
 				"mode 0:0\n" +
 				"0->1 EPSILON 0,0,0\n" +
 				"0->3 EPSILON 0,0,0\n" +
@@ -475,7 +476,7 @@ public class TestATNSerialization extends BaseTest {
 			"2:RULE_STOP 0\n" +
 			"3:BASIC 0\n" +
 			"4:BASIC 0\n" +
-			"rule 0:1 1,-1\n" +
+			"rule 0:1 1\n" +
 			"mode 0:0\n" +
 			"0:'a'..'b'\n" +
 			"0->1 EPSILON 0,0,0\n" +
@@ -499,7 +500,7 @@ public class TestATNSerialization extends BaseTest {
 			"2:RULE_STOP 0\n" +
 			"3:BASIC 0\n" +
 			"4:BASIC 0\n" +
-			"rule 0:1 1,-1\n" +
+			"rule 0:1 1\n" +
 			"mode 0:0\n" +
 			"0:'a'..'b', 'e'..'e', 'p'..'t'\n" +
 			"0->1 EPSILON 0,0,0\n" +
@@ -523,7 +524,7 @@ public class TestATNSerialization extends BaseTest {
 			"2:RULE_STOP 0\n" +
 			"3:BASIC 0\n" +
 			"4:BASIC 0\n" +
-			"rule 0:1 1,-1\n" +
+			"rule 0:1 1\n" +
 			"mode 0:0\n" +
 			"0:'a'..'b', 'e'..'e', 'p'..'t'\n" +
 			"0->1 EPSILON 0,0,0\n" +
@@ -566,9 +567,9 @@ public class TestATNSerialization extends BaseTest {
 				"18:BASIC 2\n" +
 				"19:BASIC 2\n" +
 				"20:BASIC 2\n" +
-				"rule 0:2 1,-1\n" +
-				"rule 1:4 2,0\n" +
-				"rule 2:6 3,1\n" +
+				"rule 0:2 1\n" +
+				"rule 1:4 2\n" +
+				"rule 2:6 3\n" +
 				"mode 0:0\n" +
 				"mode 1:1\n" +
 				"0->2 EPSILON 0,0,0\n" +
@@ -611,7 +612,7 @@ public class TestATNSerialization extends BaseTest {
 				"3:BASIC 0\n" +
 				"4:BASIC 0\n" +
 				"5:BASIC 0\n" +
-				"rule 0:1 1,-1\n" +
+				"rule 0:1 1\n" +
 				"mode 0:0\n" +
 				"0:'a'..'b'\n" +
 				"1:'e'..'e', 'p'..'t'\n" +
@@ -631,7 +632,7 @@ public class TestATNSerialization extends BaseTest {
 			"lexer grammar L;\n"+
 			"A : 'a'\n ;\n" +
 			"B : 'b';\n" +
-			"mode A;\n" +
+			"mode M;\n" +
 			"C : 'c';\n"+
 			"D : 'd';\n");
 		String expecting =
@@ -654,10 +655,10 @@ public class TestATNSerialization extends BaseTest {
 			"15:BASIC 2\n" +
 			"16:BASIC 3\n" +
 			"17:BASIC 3\n" +
-			"rule 0:2 1,-1\n" +
-			"rule 1:4 2,-1\n" +
-			"rule 2:6 3,-1\n" +
-			"rule 3:8 4,-1\n" +
+			"rule 0:2 1\n" +
+			"rule 1:4 2\n" +
+			"rule 2:6 3\n" +
+			"rule 3:8 4\n" +
 			"mode 0:0\n" +
 			"mode 1:1\n" +
 			"0->2 EPSILON 0,0,0\n" +
@@ -708,9 +709,9 @@ public class TestATNSerialization extends BaseTest {
 			"12:BASIC 1\n" +
 			"13:BASIC 2\n" +
 			"14:BASIC 2\n" +
-			"rule 0:3 1,-1\n" +
-			"rule 1:5 2,-1\n" +
-			"rule 2:7 3,-1\n" +
+			"rule 0:3 1\n" +
+			"rule 1:5 2\n" +
+			"rule 2:7 3\n" +
 			"mode 0:0\n" +
 			"mode 1:1\n" +
 			"mode 2:2\n" +
diff --git a/tool/test/org/antlr/v4/test/TestActionSplitter.java b/tool-testsuite/test/org/antlr/v4/test/tool/TestActionSplitter.java
similarity index 96%
rename from tool/test/org/antlr/v4/test/TestActionSplitter.java
rename to tool-testsuite/test/org/antlr/v4/test/tool/TestActionSplitter.java
index af8c11f87..d8ad87c3f 100644
--- a/tool/test/org/antlr/v4/test/TestActionSplitter.java
+++ b/tool-testsuite/test/org/antlr/v4/test/tool/TestActionSplitter.java
@@ -28,18 +28,19 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-package org.antlr.v4.test;
+package org.antlr.v4.test.tool;
 
 import org.antlr.runtime.ANTLRStringStream;
 import org.antlr.runtime.Token;
 import org.antlr.v4.parse.ActionSplitter;
 import org.antlr.v4.semantics.BlankActionSplitterListener;
+import org.antlr.v4.test.runtime.java.BaseTest;
 import org.junit.Test;
 
 import java.util.ArrayList;
 import java.util.List;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
 
 public class TestActionSplitter extends BaseTest {
     static String[] exprs = {
diff --git a/tool/test/org/antlr/v4/test/TestActionTranslation.java b/tool-testsuite/test/org/antlr/v4/test/tool/TestActionTranslation.java
similarity index 96%
rename from tool/test/org/antlr/v4/test/TestActionTranslation.java
rename to tool-testsuite/test/org/antlr/v4/test/tool/TestActionTranslation.java
index 85b4c345d..dfe170418 100644
--- a/tool/test/org/antlr/v4/test/TestActionTranslation.java
+++ b/tool-testsuite/test/org/antlr/v4/test/tool/TestActionTranslation.java
@@ -28,11 +28,14 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-package org.antlr.v4.test;
+package org.antlr.v4.test.tool;
 
+import org.antlr.v4.test.runtime.java.BaseTest;
+import org.antlr.v4.tool.Grammar;
 import org.junit.Test;
 
 /** */
+@SuppressWarnings("unused")
 public class TestActionTranslation extends BaseTest {
 	String attributeTemplate =
 		"attributeTemplate(members,init,inline,finally,inline2) ::= <<\n" +
@@ -119,25 +122,25 @@ public class TestActionTranslation extends BaseTest {
 	}
 
 	@Test public void testArguments() throws Exception {
-		String action = "$x; $a.x";
+		String action = "$x; $ctx.x";
 		String expected = "_localctx.x; _localctx.x";
 		testActions(attributeTemplate, "inline", action, expected);
 	}
 
 	@Test public void testReturnValue() throws Exception {
-		String action = "$x; $a.x";
-		String expected = "_localctx.x; _localctx.x";
+		String action = "$y; $ctx.y";
+		String expected = "_localctx.y; _localctx.y";
 		testActions(attributeTemplate, "inline", action, expected);
 	}
 
 	@Test public void testReturnValueWithNumber() throws Exception {
-		String action = "$a.x1";
+		String action = "$ctx.x1";
 		String expected = "_localctx.x1";
 		testActions(attributeTemplate, "inline", action, expected);
 	}
 
 	@Test public void testReturnValuesCurrentRule() throws Exception {
-		String action = "$y; $a.y;";
+		String action = "$y; $ctx.y;";
 		String expected = "_localctx.y; _localctx.y;";
 		testActions(attributeTemplate, "inline", action, expected);
 	}
@@ -167,17 +170,26 @@ public class TestActionTranslation extends BaseTest {
     }
 
 	@Test public void testRefToTextAttributeForCurrentRule() throws Exception {
-        String action = "$a.text; $text";
+        String action = "$ctx.text; $text";
 
 		// this is the expected translation for all cases
 		String expected =
-			"_input.getText(_localctx.start, _input.LT(-1)); _input.getText(_localctx.start, _input.LT(-1))";
+			"_localctx.text; _input.getText(_localctx.start, _input.LT(-1))";
 
 		testActions(attributeTemplate, "init", action, expected);
 		testActions(attributeTemplate, "inline", action, expected);
 		testActions(attributeTemplate, "finally", action, expected);
     }
 
+    @Test public void testEmptyActions() throws Exception {
+	    String gS =
+	   		"grammar A;\n"+
+	   		"a[] : 'a' ;\n" +
+	   		"c : a[] c[] ;\n";
+	    Grammar g = new Grammar(gS);
+    }
+
+
     @Test public void testDynamicRuleScopeRefInSubrule() throws Exception {
         String action = "$a::n;";
     }
diff --git a/tool-testsuite/test/org/antlr/v4/test/tool/TestAmbigParseTrees.java b/tool-testsuite/test/org/antlr/v4/test/tool/TestAmbigParseTrees.java
new file mode 100644
index 000000000..992b11679
--- /dev/null
+++ b/tool-testsuite/test/org/antlr/v4/test/tool/TestAmbigParseTrees.java
@@ -0,0 +1,274 @@
+package org.antlr.v4.test.tool;
+
+import org.antlr.v4.runtime.ANTLRInputStream;
+import org.antlr.v4.runtime.CommonTokenStream;
+import org.antlr.v4.runtime.LexerInterpreter;
+import org.antlr.v4.runtime.ParserInterpreter;
+import org.antlr.v4.runtime.ParserRuleContext;
+import org.antlr.v4.runtime.atn.ATNState;
+import org.antlr.v4.runtime.atn.AmbiguityInfo;
+import org.antlr.v4.runtime.atn.BasicBlockStartState;
+import org.antlr.v4.runtime.atn.DecisionInfo;
+import org.antlr.v4.runtime.atn.DecisionState;
+import org.antlr.v4.runtime.atn.PredictionMode;
+import org.antlr.v4.runtime.atn.RuleStartState;
+import org.antlr.v4.runtime.atn.Transition;
+import org.antlr.v4.runtime.tree.ParseTree;
+import org.antlr.v4.gui.Trees;
+import org.antlr.v4.tool.Grammar;
+import org.antlr.v4.tool.GrammarParserInterpreter;
+import org.antlr.v4.tool.LexerGrammar;
+import org.junit.Test;
+
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+
+public class TestAmbigParseTrees {
+	@Test public void testParseDecisionWithinAmbiguousStartRule() throws Exception {
+		LexerGrammar lg = new LexerGrammar(
+			"lexer grammar L;\n" +
+			"A : 'a' ;\n" +
+			"B : 'b' ;\n" +
+			"C : 'c' ;\n");
+		Grammar g = new Grammar(
+			"parser grammar T;\n" +
+			"s : A x C" +
+			"  | A B C" +
+			"  ;" +
+			"x : B ; \n",
+			lg);
+
+		testInterpAtSpecificAlt(lg, g, "s", 1, "abc", "(s:1 a (x:1 b) c)");
+		testInterpAtSpecificAlt(lg, g, "s", 2, "abc", "(s:2 a b c)");
+	}
+
+	@Test public void testAmbigAltsAtRoot() throws Exception {
+		LexerGrammar lg = new LexerGrammar(
+			"lexer grammar L;\n" +
+			"A : 'a' ;\n" +
+			"B : 'b' ;\n" +
+			"C : 'c' ;\n");
+		Grammar g = new Grammar(
+			"parser grammar T;\n" +
+			"s : A x C" +
+			"  | A B C" +
+			"  ;" +
+			"x : B ; \n",
+			lg);
+
+		String startRule = "s";
+		String input = "abc";
+		String expectedAmbigAlts = "{1, 2}";
+		int decision = 0;
+		String expectedOverallTree = "(s:1 a (x:1 b) c)";
+		String[] expectedParseTrees = {"(s:1 a (x:1 b) c)",
+									   "(s:2 a b c)"};
+
+		testAmbiguousTrees(lg, g, startRule, input, decision,
+						   expectedAmbigAlts,
+						   expectedOverallTree, expectedParseTrees);
+	}
+
+	@Test public void testAmbigAltsNotAtRoot() throws Exception {
+		LexerGrammar lg = new LexerGrammar(
+			"lexer grammar L;\n" +
+			"A : 'a' ;\n" +
+			"B : 'b' ;\n" +
+			"C : 'c' ;\n");
+		Grammar g = new Grammar(
+			"parser grammar T;\n" +
+			"s : x ;" +
+			"x : y ;" +
+			"y : A z C" +
+			"  | A B C" +
+			"  ;" +
+			"z : B ; \n",
+			lg);
+
+		String startRule = "s";
+		String input = "abc";
+		String expectedAmbigAlts = "{1, 2}";
+		int decision = 0;
+		String expectedOverallTree = "(s:1 (x:1 (y:1 a (z:1 b) c)))";
+		String[] expectedParseTrees = {"(y:1 a (z:1 b) c)",
+									   "(y:2 a b c)"};
+
+		testAmbiguousTrees(lg, g, startRule, input, decision,
+						   expectedAmbigAlts,
+						   expectedOverallTree, expectedParseTrees);
+	}
+
+	@Test public void testAmbigAltDipsIntoOuterContextToRoot() throws Exception {
+		LexerGrammar lg = new LexerGrammar(
+			"lexer grammar L;\n" +
+			"SELF : 'self' ;\n" +
+			"ID : [a-z]+ ;\n" +
+			"DOT : '.' ;\n");
+		Grammar g = new Grammar(
+			"parser grammar T;\n" +
+			"e : p (DOT ID)* ;\n"+
+			"p : SELF" +
+			"  | SELF DOT ID" +
+			"  ;",
+			lg);
+
+		String startRule = "e";
+		String input = "self.x";
+		String expectedAmbigAlts = "{1, 2}";
+		int decision = 1; // decision in p
+		String expectedOverallTree = "(e:1 (p:1 self) . x)";
+		String[] expectedParseTrees = {"(e:1 (p:1 self) . x)",
+									   "(p:2 self . x)"};
+
+		testAmbiguousTrees(lg, g, startRule, input, decision,
+						   expectedAmbigAlts,
+						   expectedOverallTree, expectedParseTrees);
+	}
+
+	@Test public void testAmbigAltDipsIntoOuterContextBelowRoot() throws Exception {
+		LexerGrammar lg = new LexerGrammar(
+			"lexer grammar L;\n" +
+			"SELF : 'self' ;\n" +
+			"ID : [a-z]+ ;\n" +
+			"DOT : '.' ;\n");
+		Grammar g = new Grammar(
+			"parser grammar T;\n" +
+			"s : e ;\n"+
+			"e : p (DOT ID)* ;\n"+
+			"p : SELF" +
+			"  | SELF DOT ID" +
+			"  ;",
+			lg);
+
+		String startRule = "s";
+		String input = "self.x";
+		String expectedAmbigAlts = "{1, 2}";
+		int decision = 1; // decision in p
+		String expectedOverallTree = "(s:1 (e:1 (p:1 self) . x))";
+		String[] expectedParseTrees = {"(e:1 (p:1 self) . x)", // shouldn't include s
+									   "(p:2 self . x)"};      // shouldn't include e
+
+		testAmbiguousTrees(lg, g, startRule, input, decision,
+						   expectedAmbigAlts,
+						   expectedOverallTree, expectedParseTrees);
+	}
+
+	@Test public void testAmbigAltInLeftRecursiveBelowStartRule() throws Exception {
+		LexerGrammar lg = new LexerGrammar(
+			"lexer grammar L;\n" +
+			"SELF : 'self' ;\n" +
+			"ID : [a-z]+ ;\n" +
+			"DOT : '.' ;\n");
+		Grammar g = new Grammar(
+			"parser grammar T;\n" +
+			"s : e ;\n" +
+			"e : p | e DOT ID ;\n"+
+			"p : SELF" +
+			"  | SELF DOT ID" +
+			"  ;",
+			lg);
+
+		String startRule = "s";
+		String input = "self.x";
+		String expectedAmbigAlts = "{1, 2}";
+		int decision = 1; // decision in p
+		String expectedOverallTree = "(s:1 (e:2 (e:1 (p:1 self)) . x))";
+		String[] expectedParseTrees = {"(e:2 (e:1 (p:1 self)) . x)",
+									   "(p:2 self . x)"};
+
+		testAmbiguousTrees(lg, g, startRule, input, decision,
+						   expectedAmbigAlts,
+						   expectedOverallTree, expectedParseTrees);
+	}
+
+	@Test public void testAmbigAltInLeftRecursiveStartRule() throws Exception {
+		LexerGrammar lg = new LexerGrammar(
+			"lexer grammar L;\n" +
+			"SELF : 'self' ;\n" +
+			"ID : [a-z]+ ;\n" +
+			"DOT : '.' ;\n");
+		Grammar g = new Grammar(
+			"parser grammar T;\n" +
+			"e : p | e DOT ID ;\n"+
+			"p : SELF" +
+			"  | SELF DOT ID" +
+			"  ;",
+			lg);
+
+		String startRule = "e";
+		String input = "self.x";
+		String expectedAmbigAlts = "{1, 2}";
+		int decision = 1; // decision in p
+		String expectedOverallTree = "(e:2 (e:1 (p:1 self)) . x)";
+		String[] expectedParseTrees = {"(e:2 (e:1 (p:1 self)) . x)",
+									   "(p:2 self . x)"}; // shows just enough for self.x
+
+		testAmbiguousTrees(lg, g, startRule, input, decision,
+						   expectedAmbigAlts,
+						   expectedOverallTree, expectedParseTrees);
+	}
+
+	public void testAmbiguousTrees(LexerGrammar lg, Grammar g,
+								   String startRule, String input, int decision,
+								   String expectedAmbigAlts,
+								   String overallTree,
+								   String[] expectedParseTrees)
+	{
+		InterpreterTreeTextProvider nodeTextProvider = new InterpreterTreeTextProvider(g.getRuleNames());
+
+		LexerInterpreter lexEngine = lg.createLexerInterpreter(new ANTLRInputStream(input));
+		CommonTokenStream tokens = new CommonTokenStream(lexEngine);
+		final GrammarParserInterpreter parser = g.createGrammarParserInterpreter(tokens);
+		parser.setProfile(true);
+		parser.getInterpreter().setPredictionMode(PredictionMode.LL_EXACT_AMBIG_DETECTION);
+
+		// PARSE
+		int ruleIndex = g.rules.get(startRule).index;
+		ParserRuleContext parseTree = parser.parse(ruleIndex);
+		assertEquals(overallTree, Trees.toStringTree(parseTree, nodeTextProvider));
+		System.out.println();
+
+		DecisionInfo[] decisionInfo = parser.getParseInfo().getDecisionInfo();
+		List<AmbiguityInfo> ambiguities = decisionInfo[decision].ambiguities;
+		assertEquals(1, ambiguities.size());
+		AmbiguityInfo ambiguityInfo = ambiguities.get(0);
+
+		List<ParserRuleContext> ambiguousParseTrees =
+			GrammarParserInterpreter.getAllPossibleParseTrees(g,
+															  parser,
+															  tokens,
+															  decision,
+															  ambiguityInfo.ambigAlts,
+															  ambiguityInfo.startIndex,
+															  ambiguityInfo.stopIndex,
+															  ruleIndex);
+		assertEquals(expectedAmbigAlts, ambiguityInfo.ambigAlts.toString());
+		assertEquals(ambiguityInfo.ambigAlts.cardinality(), ambiguousParseTrees.size());
+
+		for (int i = 0; i<ambiguousParseTrees.size(); i++) {
+			ParserRuleContext t = ambiguousParseTrees.get(i);
+			assertEquals(expectedParseTrees[i], Trees.toStringTree(t, nodeTextProvider));
+		}
+	}
+
+	void testInterpAtSpecificAlt(LexerGrammar lg, Grammar g,
+								 String startRule, int startAlt,
+								 String input,
+								 String expectedParseTree)
+	{
+		LexerInterpreter lexEngine = lg.createLexerInterpreter(new ANTLRInputStream(input));
+		CommonTokenStream tokens = new CommonTokenStream(lexEngine);
+		ParserInterpreter parser = g.createGrammarParserInterpreter(tokens);
+		RuleStartState ruleStartState = g.atn.ruleToStartState[g.getRule(startRule).index];
+		Transition tr = ruleStartState.transition(0);
+		ATNState t2 = tr.target;
+		if ( !(t2 instanceof BasicBlockStartState) ) {
+			throw new IllegalArgumentException("rule has no decision: "+startRule);
+		}
+		parser.addDecisionOverride(((DecisionState)t2).decision, 0, startAlt);
+		ParseTree t = parser.parse(g.rules.get(startRule).index);
+		InterpreterTreeTextProvider nodeTextProvider = new InterpreterTreeTextProvider(g.getRuleNames());
+		assertEquals(expectedParseTree, Trees.toStringTree(t, nodeTextProvider));
+	}
+}
diff --git a/tool/test/org/antlr/v4/test/TestAttributeChecks.java b/tool-testsuite/test/org/antlr/v4/test/tool/TestAttributeChecks.java
similarity index 61%
rename from tool/test/org/antlr/v4/test/TestAttributeChecks.java
rename to tool-testsuite/test/org/antlr/v4/test/tool/TestAttributeChecks.java
index 652beb065..cef7abdca 100644
--- a/tool/test/org/antlr/v4/test/TestAttributeChecks.java
+++ b/tool-testsuite/test/org/antlr/v4/test/tool/TestAttributeChecks.java
@@ -16,7 +16,7 @@
  *  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
+ *  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,
@@ -28,9 +28,10 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-package org.antlr.v4.test;
+package org.antlr.v4.test.tool;
 
 import org.antlr.runtime.RecognitionException;
+import org.antlr.v4.test.runtime.java.BaseTest;
 import org.antlr.v4.tool.ErrorType;
 import org.junit.Test;
 import org.stringtemplate.v4.ST;
@@ -55,8 +56,8 @@ public class TestAttributeChecks extends BaseTest {
         "c   :   ;\n";
 
     String[] membersChecks = {
-		"$a",			"error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:2:11: unknown attribute reference 'a' in '$a'\n",
-        "$a.y",			"error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:2:11: unknown attribute reference 'a' in '$a.y'\n",
+		"$a",			"error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:2:11: unknown attribute reference a in $a\n",
+        "$a.y",			"error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:2:11: unknown attribute reference a in $a.y\n",
     };
 
     String[] initChecks = {
@@ -68,8 +69,8 @@ public class TestAttributeChecks extends BaseTest {
 		"$ids",			"",
 		"$labs",		"",
 
-		"$c",			"error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:5:8: unknown attribute reference 'c' in '$c'\n",
-		"$a.q",			"error(" + ErrorType.UNKNOWN_RULE_ATTRIBUTE.code + "): A.g4:5:10: unknown attribute 'q' for rule 'a' in '$a.q'\n",
+		"$c",			"error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:5:8: unknown attribute reference c in $c\n",
+		"$a.q",			"error(" + ErrorType.UNKNOWN_RULE_ATTRIBUTE.code + "): A.g4:5:10: unknown attribute q for rule a in $a.q\n",
     };
 
 	String[] inlineChecks = {
@@ -78,7 +79,7 @@ public class TestAttributeChecks extends BaseTest {
 		"$x = $y",		"",
 		"$y = $x",		"",
 		"$y.b = 3;",	"",
-		"$a.x = $a.y",	"",
+		"$ctx.x = $ctx.y",	"",
 		"$lab.e",		"",
 		"$lab.text",	"",
 		"$b.e",			"",
@@ -92,21 +93,21 @@ public class TestAttributeChecks extends BaseTest {
 	};
 
 	String[] bad_inlineChecks = {
-		"$lab",			"error(" + ErrorType.ISOLATED_RULE_REF.code + "): A.g4:7:4: missing attribute access on rule reference 'lab' in '$lab'\n",
-		"$q",           "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:7:4: unknown attribute reference 'q' in '$q'\n",
-		"$q.y",         "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:7:4: unknown attribute reference 'q' in '$q.y'\n",
-		"$q = 3",       "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:7:4: unknown attribute reference 'q' in '$q'\n",
-		"$q = 3;",      "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:7:4: unknown attribute reference 'q' in '$q = 3;'\n",
-		"$q.y = 3;",    "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:7:4: unknown attribute reference 'q' in '$q.y'\n",
-		"$q = $blort;", "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:7:4: unknown attribute reference 'q' in '$q = $blort;'\n" +
-						"error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:7:9: unknown attribute reference 'blort' in '$blort'\n",
-		"$a.ick",       "error(" + ErrorType.UNKNOWN_RULE_ATTRIBUTE.code + "): A.g4:7:6: unknown attribute 'ick' for rule 'a' in '$a.ick'\n",
-		"$a.ick = 3;",  "error(" + ErrorType.UNKNOWN_RULE_ATTRIBUTE.code + "): A.g4:7:6: unknown attribute 'ick' for rule 'a' in '$a.ick'\n",
-		"$b.d",         "error(" + ErrorType.INVALID_RULE_PARAMETER_REF.code + "): A.g4:7:6: parameter 'd' of rule 'b' is not accessible in this scope: $b.d\n",  // can't see rule ref's arg
-		"$d.text",      "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:7:4: unknown attribute reference 'd' in '$d.text'\n", // valid rule, but no ref
-		"$lab.d",		"error(" + ErrorType.INVALID_RULE_PARAMETER_REF.code + "): A.g4:7:8: parameter 'd' of rule 'b' is not accessible in this scope: $lab.d\n",
-		"$ids = null;",	"error(" + ErrorType.ASSIGNMENT_TO_LIST_LABEL.code + "): A.g4:7:4: cannot assign a value to list label 'ids'\n",
-		"$labs = null;","error(" + ErrorType.ASSIGNMENT_TO_LIST_LABEL.code + "): A.g4:7:4: cannot assign a value to list label 'labs'\n",
+		"$lab",			"error(" + ErrorType.ISOLATED_RULE_REF.code + "): A.g4:7:4: missing attribute access on rule reference lab in $lab\n",
+		"$q",           "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:7:4: unknown attribute reference q in $q\n",
+		"$q.y",         "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:7:4: unknown attribute reference q in $q.y\n",
+		"$q = 3",       "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:7:4: unknown attribute reference q in $q\n",
+		"$q = 3;",      "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:7:4: unknown attribute reference q in $q = 3;\n",
+		"$q.y = 3;",    "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:7:4: unknown attribute reference q in $q.y\n",
+		"$q = $blort;", "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:7:4: unknown attribute reference q in $q = $blort;\n" +
+						"error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:7:9: unknown attribute reference blort in $blort\n",
+		"$a.ick",       "error(" + ErrorType.UNKNOWN_RULE_ATTRIBUTE.code + "): A.g4:7:6: unknown attribute ick for rule a in $a.ick\n",
+		"$a.ick = 3;",  "error(" + ErrorType.UNKNOWN_RULE_ATTRIBUTE.code + "): A.g4:7:6: unknown attribute ick for rule a in $a.ick\n",
+		"$b.d",         "error(" + ErrorType.INVALID_RULE_PARAMETER_REF.code + "): A.g4:7:6: parameter d of rule b is not accessible in this scope: $b.d\n",  // cant see rule refs arg
+		"$d.text",      "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:7:4: unknown attribute reference d in $d.text\n", // valid rule, but no ref
+		"$lab.d",		"error(" + ErrorType.INVALID_RULE_PARAMETER_REF.code + "): A.g4:7:8: parameter d of rule b is not accessible in this scope: $lab.d\n",
+		"$ids = null;",	"error(" + ErrorType.ASSIGNMENT_TO_LIST_LABEL.code + "): A.g4:7:4: cannot assign a value to list label ids\n",
+		"$labs = null;","error(" + ErrorType.ASSIGNMENT_TO_LIST_LABEL.code + "): A.g4:7:4: cannot assign a value to list label labs\n",
 	};
 
 	String[] finallyChecks = {
@@ -121,97 +122,97 @@ public class TestAttributeChecks extends BaseTest {
 		"$ids",			"",
 		"$labs",		"",
 
-		"$lab",			"error(" + ErrorType.ISOLATED_RULE_REF.code + "): A.g4:10:14: missing attribute access on rule reference 'lab' in '$lab'\n",
-		"$q",           "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:10:14: unknown attribute reference 'q' in '$q'\n",
-		"$q.y",         "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:10:14: unknown attribute reference 'q' in '$q.y'\n",
-		"$q = 3",       "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:10:14: unknown attribute reference 'q' in '$q'\n",
-		"$q = 3;",      "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:10:14: unknown attribute reference 'q' in '$q = 3;'\n",
-		"$q.y = 3;",    "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:10:14: unknown attribute reference 'q' in '$q.y'\n",
-		"$q = $blort;", "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:10:14: unknown attribute reference 'q' in '$q = $blort;'\n" +
-						"error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:10:19: unknown attribute reference 'blort' in '$blort'\n",
-		"$a.ick",       "error(" + ErrorType.UNKNOWN_RULE_ATTRIBUTE.code + "): A.g4:10:16: unknown attribute 'ick' for rule 'a' in '$a.ick'\n",
-		"$a.ick = 3;",  "error(" + ErrorType.UNKNOWN_RULE_ATTRIBUTE.code + "): A.g4:10:16: unknown attribute 'ick' for rule 'a' in '$a.ick'\n",
-		"$b.e",			"error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:10:14: unknown attribute reference 'b' in '$b.e'\n", // can't see rule refs outside alts
-		"$b.d",         "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:10:14: unknown attribute reference 'b' in '$b.d'\n",
-		"$c.text",      "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:10:14: unknown attribute reference 'c' in '$c.text'\n",
-		"$lab.d",		"error(" + ErrorType.INVALID_RULE_PARAMETER_REF.code + "): A.g4:10:18: parameter 'd' of rule 'b' is not accessible in this scope: $lab.d\n",
+		"$lab",			"error(" + ErrorType.ISOLATED_RULE_REF.code + "): A.g4:10:14: missing attribute access on rule reference lab in $lab\n",
+		"$q",           "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:10:14: unknown attribute reference q in $q\n",
+		"$q.y",         "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:10:14: unknown attribute reference q in $q.y\n",
+		"$q = 3",       "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:10:14: unknown attribute reference q in $q\n",
+		"$q = 3;",      "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:10:14: unknown attribute reference q in $q = 3;\n",
+		"$q.y = 3;",    "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:10:14: unknown attribute reference q in $q.y\n",
+		"$q = $blort;", "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:10:14: unknown attribute reference q in $q = $blort;\n" +
+						"error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:10:19: unknown attribute reference blort in $blort\n",
+		"$a.ick",       "error(" + ErrorType.UNKNOWN_RULE_ATTRIBUTE.code + "): A.g4:10:16: unknown attribute ick for rule a in $a.ick\n",
+		"$a.ick = 3;",  "error(" + ErrorType.UNKNOWN_RULE_ATTRIBUTE.code + "): A.g4:10:16: unknown attribute ick for rule a in $a.ick\n",
+		"$b.e",			"error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:10:14: unknown attribute reference b in $b.e\n", // cant see rule refs outside alts
+		"$b.d",         "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:10:14: unknown attribute reference b in $b.d\n",
+		"$c.text",      "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:10:14: unknown attribute reference c in $c.text\n",
+		"$lab.d",		"error(" + ErrorType.INVALID_RULE_PARAMETER_REF.code + "): A.g4:10:18: parameter d of rule b is not accessible in this scope: $lab.d\n",
 	};
 
 	String[] dynMembersChecks = {
-		"$S",			"error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:2:11: unknown attribute reference 'S' in '$S'\n",
-		"$S::i",		"error(" + ErrorType.UNDEFINED_RULE_IN_NONLOCAL_REF.code + "): A.g4:2:11: reference to undefined rule 'S' in non-local ref '$S::i'\n",
-		"$S::i=$S::i",	"error(" + ErrorType.UNDEFINED_RULE_IN_NONLOCAL_REF.code + "): A.g4:2:11: reference to undefined rule 'S' in non-local ref '$S::i'\n" +
-						"error(" + ErrorType.UNDEFINED_RULE_IN_NONLOCAL_REF.code + "): A.g4:2:17: reference to undefined rule 'S' in non-local ref '$S::i'\n",
+		"$S",			"error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:2:11: unknown attribute reference S in $S\n",
+		"$S::i",		"error(" + ErrorType.UNDEFINED_RULE_IN_NONLOCAL_REF.code + "): A.g4:2:11: reference to undefined rule S in non-local ref $S::i\n",
+		"$S::i=$S::i",	"error(" + ErrorType.UNDEFINED_RULE_IN_NONLOCAL_REF.code + "): A.g4:2:11: reference to undefined rule S in non-local ref $S::i\n" +
+						"error(" + ErrorType.UNDEFINED_RULE_IN_NONLOCAL_REF.code + "): A.g4:2:17: reference to undefined rule S in non-local ref $S::i\n",
 
-		"$b::f",		"error(" + ErrorType.UNKNOWN_RULE_ATTRIBUTE.code + "): A.g4:2:14: unknown attribute 'f' for rule 'b' in '$b::f'\n",
-		"$S::j",		"error(" + ErrorType.UNDEFINED_RULE_IN_NONLOCAL_REF.code + "): A.g4:2:11: reference to undefined rule 'S' in non-local ref '$S::j'\n",
-		"$S::j = 3;",	"error(" + ErrorType.UNDEFINED_RULE_IN_NONLOCAL_REF.code + "): A.g4:2:11: reference to undefined rule 'S' in non-local ref '$S::j = 3;'\n",
-		"$S::j = $S::k;",	"error(" + ErrorType.UNDEFINED_RULE_IN_NONLOCAL_REF.code + "): A.g4:2:11: reference to undefined rule 'S' in non-local ref '$S::j = $S::k;'\n",
+		"$b::f",		"error(" + ErrorType.UNKNOWN_RULE_ATTRIBUTE.code + "): A.g4:2:14: unknown attribute f for rule b in $b::f\n",
+		"$S::j",		"error(" + ErrorType.UNDEFINED_RULE_IN_NONLOCAL_REF.code + "): A.g4:2:11: reference to undefined rule S in non-local ref $S::j\n",
+		"$S::j = 3;",	"error(" + ErrorType.UNDEFINED_RULE_IN_NONLOCAL_REF.code + "): A.g4:2:11: reference to undefined rule S in non-local ref $S::j = 3;\n",
+		"$S::j = $S::k;",	"error(" + ErrorType.UNDEFINED_RULE_IN_NONLOCAL_REF.code + "): A.g4:2:11: reference to undefined rule S in non-local ref $S::j = $S::k;\n",
 	};
 
 	String[] dynInitChecks = {
-		"$a",			"error(" + ErrorType.ISOLATED_RULE_REF.code + "): A.g4:5:8: missing attribute access on rule reference 'a' in '$a'\n",
-		"$b",			"error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:5:8: unknown attribute reference 'b' in '$b'\n",
-		"$lab",			"error(" + ErrorType.ISOLATED_RULE_REF.code + "): A.g4:5:8: missing attribute access on rule reference 'lab' in '$lab'\n",
-		"$b::f",		"error(" + ErrorType.UNKNOWN_RULE_ATTRIBUTE.code + "): A.g4:5:11: unknown attribute 'f' for rule 'b' in '$b::f'\n",
-		"$S::i",		"error(" + ErrorType.UNDEFINED_RULE_IN_NONLOCAL_REF.code + "): A.g4:5:8: reference to undefined rule 'S' in non-local ref '$S::i'\n",
-		"$S::i=$S::i",	"error(" + ErrorType.UNDEFINED_RULE_IN_NONLOCAL_REF.code + "): A.g4:5:8: reference to undefined rule 'S' in non-local ref '$S::i'\n" +
-						"error(" + ErrorType.UNDEFINED_RULE_IN_NONLOCAL_REF.code + "): A.g4:5:14: reference to undefined rule 'S' in non-local ref '$S::i'\n",
-		"$a::z",		"error(" + ErrorType.UNKNOWN_RULE_ATTRIBUTE.code + "): A.g4:5:11: unknown attribute 'z' for rule 'a' in '$a::z'\n",
-		"$S",			"error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:5:8: unknown attribute reference 'S' in '$S'\n",
+		"$a",			"error(" + ErrorType.ISOLATED_RULE_REF.code + "): A.g4:5:8: missing attribute access on rule reference a in $a\n",
+		"$b",			"error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:5:8: unknown attribute reference b in $b\n",
+		"$lab",			"error(" + ErrorType.ISOLATED_RULE_REF.code + "): A.g4:5:8: missing attribute access on rule reference lab in $lab\n",
+		"$b::f",		"error(" + ErrorType.UNKNOWN_RULE_ATTRIBUTE.code + "): A.g4:5:11: unknown attribute f for rule b in $b::f\n",
+		"$S::i",		"error(" + ErrorType.UNDEFINED_RULE_IN_NONLOCAL_REF.code + "): A.g4:5:8: reference to undefined rule S in non-local ref $S::i\n",
+		"$S::i=$S::i",	"error(" + ErrorType.UNDEFINED_RULE_IN_NONLOCAL_REF.code + "): A.g4:5:8: reference to undefined rule S in non-local ref $S::i\n" +
+						"error(" + ErrorType.UNDEFINED_RULE_IN_NONLOCAL_REF.code + "): A.g4:5:14: reference to undefined rule S in non-local ref $S::i\n",
+		"$a::z",		"error(" + ErrorType.UNKNOWN_RULE_ATTRIBUTE.code + "): A.g4:5:11: unknown attribute z for rule a in $a::z\n",
+		"$S",			"error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:5:8: unknown attribute reference S in $S\n",
 
-		"$S::j",		"error(" + ErrorType.UNDEFINED_RULE_IN_NONLOCAL_REF.code + "): A.g4:5:8: reference to undefined rule 'S' in non-local ref '$S::j'\n",
-		"$S::j = 3;",	"error(" + ErrorType.UNDEFINED_RULE_IN_NONLOCAL_REF.code + "): A.g4:5:8: reference to undefined rule 'S' in non-local ref '$S::j = 3;'\n",
-		"$S::j = $S::k;",	"error(" + ErrorType.UNDEFINED_RULE_IN_NONLOCAL_REF.code + "): A.g4:5:8: reference to undefined rule 'S' in non-local ref '$S::j = $S::k;'\n",
+		"$S::j",		"error(" + ErrorType.UNDEFINED_RULE_IN_NONLOCAL_REF.code + "): A.g4:5:8: reference to undefined rule S in non-local ref $S::j\n",
+		"$S::j = 3;",	"error(" + ErrorType.UNDEFINED_RULE_IN_NONLOCAL_REF.code + "): A.g4:5:8: reference to undefined rule S in non-local ref $S::j = 3;\n",
+		"$S::j = $S::k;",	"error(" + ErrorType.UNDEFINED_RULE_IN_NONLOCAL_REF.code + "): A.g4:5:8: reference to undefined rule S in non-local ref $S::j = $S::k;\n",
 	};
 
 	String[] dynInlineChecks = {
-		"$a",			"error(" + ErrorType.ISOLATED_RULE_REF.code + "): A.g4:7:4: missing attribute access on rule reference 'a' in '$a'\n",
-		"$b",			"error(" + ErrorType.ISOLATED_RULE_REF.code + "): A.g4:7:4: missing attribute access on rule reference 'b' in '$b'\n",
-		"$lab",			"error(" + ErrorType.ISOLATED_RULE_REF.code + "): A.g4:7:4: missing attribute access on rule reference 'lab' in '$lab'\n",
-		"$b::f",		"error(" + ErrorType.UNKNOWN_RULE_ATTRIBUTE.code + "): A.g4:7:7: unknown attribute 'f' for rule 'b' in '$b::f'\n",
-		"$S::i",		"error(" + ErrorType.UNDEFINED_RULE_IN_NONLOCAL_REF.code + "): A.g4:7:4: reference to undefined rule 'S' in non-local ref '$S::i'\n",
-		"$S::i=$S::i",	"error(" + ErrorType.UNDEFINED_RULE_IN_NONLOCAL_REF.code + "): A.g4:7:4: reference to undefined rule 'S' in non-local ref '$S::i'\n" +
-						"error(" + ErrorType.UNDEFINED_RULE_IN_NONLOCAL_REF.code + "): A.g4:7:10: reference to undefined rule 'S' in non-local ref '$S::i'\n",
-		"$a::z",		"error(" + ErrorType.UNKNOWN_RULE_ATTRIBUTE.code + "): A.g4:7:7: unknown attribute 'z' for rule 'a' in '$a::z'\n",
+		"$a",			"error(" + ErrorType.ISOLATED_RULE_REF.code + "): A.g4:7:4: missing attribute access on rule reference a in $a\n",
+		"$b",			"error(" + ErrorType.ISOLATED_RULE_REF.code + "): A.g4:7:4: missing attribute access on rule reference b in $b\n",
+		"$lab",			"error(" + ErrorType.ISOLATED_RULE_REF.code + "): A.g4:7:4: missing attribute access on rule reference lab in $lab\n",
+		"$b::f",		"error(" + ErrorType.UNKNOWN_RULE_ATTRIBUTE.code + "): A.g4:7:7: unknown attribute f for rule b in $b::f\n",
+		"$S::i",		"error(" + ErrorType.UNDEFINED_RULE_IN_NONLOCAL_REF.code + "): A.g4:7:4: reference to undefined rule S in non-local ref $S::i\n",
+		"$S::i=$S::i",	"error(" + ErrorType.UNDEFINED_RULE_IN_NONLOCAL_REF.code + "): A.g4:7:4: reference to undefined rule S in non-local ref $S::i\n" +
+						"error(" + ErrorType.UNDEFINED_RULE_IN_NONLOCAL_REF.code + "): A.g4:7:10: reference to undefined rule S in non-local ref $S::i\n",
+		"$a::z",		"error(" + ErrorType.UNKNOWN_RULE_ATTRIBUTE.code + "): A.g4:7:7: unknown attribute z for rule a in $a::z\n",
 
-		"$S::j",			"error(" + ErrorType.UNDEFINED_RULE_IN_NONLOCAL_REF.code + "): A.g4:7:4: reference to undefined rule 'S' in non-local ref '$S::j'\n",
-		"$S::j = 3;",		"error(" + ErrorType.UNDEFINED_RULE_IN_NONLOCAL_REF.code + "): A.g4:7:4: reference to undefined rule 'S' in non-local ref '$S::j = 3;'\n",
-		"$S::j = $S::k;",	"error(" + ErrorType.UNDEFINED_RULE_IN_NONLOCAL_REF.code + "): A.g4:7:4: reference to undefined rule 'S' in non-local ref '$S::j = $S::k;'\n",
-		"$Q[-1]::y",        "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:7:4: unknown attribute reference 'Q' in '$Q'\n",
-		"$Q[-i]::y",        "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:7:4: unknown attribute reference 'Q' in '$Q'\n",
-		"$Q[i]::y",    		"error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:7:4: unknown attribute reference 'Q' in '$Q'\n",
-		"$Q[0]::y",    		"error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:7:4: unknown attribute reference 'Q' in '$Q'\n",
-		"$Q[-1]::y = 23;",  "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:7:4: unknown attribute reference 'Q' in '$Q'\n",
-		"$Q[-i]::y = 23;",  "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:7:4: unknown attribute reference 'Q' in '$Q'\n",
-		"$Q[i]::y = 23;",   "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:7:4: unknown attribute reference 'Q' in '$Q'\n",
-		"$Q[0]::y = 23;",   "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:7:4: unknown attribute reference 'Q' in '$Q'\n",
-		"$S[-1]::y",        "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:7:4: unknown attribute reference 'S' in '$S'\n",
-		"$S[-i]::y",        "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:7:4: unknown attribute reference 'S' in '$S'\n",
-		"$S[i]::y",     	"error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:7:4: unknown attribute reference 'S' in '$S'\n",
-		"$S[0]::y",     	"error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:7:4: unknown attribute reference 'S' in '$S'\n",
-		"$S[-1]::y = 23;",  "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:7:4: unknown attribute reference 'S' in '$S'\n",
-		"$S[-i]::y = 23;",  "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:7:4: unknown attribute reference 'S' in '$S'\n",
-		"$S[i]::y = 23;",   "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:7:4: unknown attribute reference 'S' in '$S'\n",
-		"$S[0]::y = 23;",   "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:7:4: unknown attribute reference 'S' in '$S'\n",
-		"$S[$S::y]::i",		"error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:7:4: unknown attribute reference 'S' in '$S'\n" +
-							"error(" + ErrorType.UNDEFINED_RULE_IN_NONLOCAL_REF.code + "): A.g4:7:7: reference to undefined rule 'S' in non-local ref '$S::y'\n"
+		"$S::j",			"error(" + ErrorType.UNDEFINED_RULE_IN_NONLOCAL_REF.code + "): A.g4:7:4: reference to undefined rule S in non-local ref $S::j\n",
+		"$S::j = 3;",		"error(" + ErrorType.UNDEFINED_RULE_IN_NONLOCAL_REF.code + "): A.g4:7:4: reference to undefined rule S in non-local ref $S::j = 3;\n",
+		"$S::j = $S::k;",	"error(" + ErrorType.UNDEFINED_RULE_IN_NONLOCAL_REF.code + "): A.g4:7:4: reference to undefined rule S in non-local ref $S::j = $S::k;\n",
+		"$Q[-1]::y",        "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:7:4: unknown attribute reference Q in $Q\n",
+		"$Q[-i]::y",        "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:7:4: unknown attribute reference Q in $Q\n",
+		"$Q[i]::y",    		"error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:7:4: unknown attribute reference Q in $Q\n",
+		"$Q[0]::y",    		"error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:7:4: unknown attribute reference Q in $Q\n",
+		"$Q[-1]::y = 23;",  "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:7:4: unknown attribute reference Q in $Q\n",
+		"$Q[-i]::y = 23;",  "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:7:4: unknown attribute reference Q in $Q\n",
+		"$Q[i]::y = 23;",   "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:7:4: unknown attribute reference Q in $Q\n",
+		"$Q[0]::y = 23;",   "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:7:4: unknown attribute reference Q in $Q\n",
+		"$S[-1]::y",        "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:7:4: unknown attribute reference S in $S\n",
+		"$S[-i]::y",        "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:7:4: unknown attribute reference S in $S\n",
+		"$S[i]::y",     	"error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:7:4: unknown attribute reference S in $S\n",
+		"$S[0]::y",     	"error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:7:4: unknown attribute reference S in $S\n",
+		"$S[-1]::y = 23;",  "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:7:4: unknown attribute reference S in $S\n",
+		"$S[-i]::y = 23;",  "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:7:4: unknown attribute reference S in $S\n",
+		"$S[i]::y = 23;",   "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:7:4: unknown attribute reference S in $S\n",
+		"$S[0]::y = 23;",   "error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:7:4: unknown attribute reference S in $S\n",
+		"$S[$S::y]::i",		"error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:7:4: unknown attribute reference S in $S\n" +
+							"error(" + ErrorType.UNDEFINED_RULE_IN_NONLOCAL_REF.code + "): A.g4:7:7: reference to undefined rule S in non-local ref $S::y\n"
 	};
 
 	String[] dynFinallyChecks = {
-		"$a",			"error(" + ErrorType.ISOLATED_RULE_REF.code + "): A.g4:10:14: missing attribute access on rule reference 'a' in '$a'\n",
-		"$b",			"error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:10:14: unknown attribute reference 'b' in '$b'\n",
-		"$lab",			"error(" + ErrorType.ISOLATED_RULE_REF.code + "): A.g4:10:14: missing attribute access on rule reference 'lab' in '$lab'\n",
-		"$b::f",		"error(" + ErrorType.UNKNOWN_RULE_ATTRIBUTE.code + "): A.g4:10:17: unknown attribute 'f' for rule 'b' in '$b::f'\n",
-		"$S",			"error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:10:14: unknown attribute reference 'S' in '$S'\n",
-		"$S::i",		"error(" + ErrorType.UNDEFINED_RULE_IN_NONLOCAL_REF.code + "): A.g4:10:14: reference to undefined rule 'S' in non-local ref '$S::i'\n",
-		"$S::i=$S::i",	"error(" + ErrorType.UNDEFINED_RULE_IN_NONLOCAL_REF.code + "): A.g4:10:14: reference to undefined rule 'S' in non-local ref '$S::i'\n" +
-						"error(" + ErrorType.UNDEFINED_RULE_IN_NONLOCAL_REF.code + "): A.g4:10:20: reference to undefined rule 'S' in non-local ref '$S::i'\n",
-		"$a::z",		"error(" + ErrorType.UNKNOWN_RULE_ATTRIBUTE.code + "): A.g4:10:17: unknown attribute 'z' for rule 'a' in '$a::z'\n",
+		"$a",			"error(" + ErrorType.ISOLATED_RULE_REF.code + "): A.g4:10:14: missing attribute access on rule reference a in $a\n",
+		"$b",			"error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:10:14: unknown attribute reference b in $b\n",
+		"$lab",			"error(" + ErrorType.ISOLATED_RULE_REF.code + "): A.g4:10:14: missing attribute access on rule reference lab in $lab\n",
+		"$b::f",		"error(" + ErrorType.UNKNOWN_RULE_ATTRIBUTE.code + "): A.g4:10:17: unknown attribute f for rule b in $b::f\n",
+		"$S",			"error(" + ErrorType.UNKNOWN_SIMPLE_ATTRIBUTE.code + "): A.g4:10:14: unknown attribute reference S in $S\n",
+		"$S::i",		"error(" + ErrorType.UNDEFINED_RULE_IN_NONLOCAL_REF.code + "): A.g4:10:14: reference to undefined rule S in non-local ref $S::i\n",
+		"$S::i=$S::i",	"error(" + ErrorType.UNDEFINED_RULE_IN_NONLOCAL_REF.code + "): A.g4:10:14: reference to undefined rule S in non-local ref $S::i\n" +
+						"error(" + ErrorType.UNDEFINED_RULE_IN_NONLOCAL_REF.code + "): A.g4:10:20: reference to undefined rule S in non-local ref $S::i\n",
+		"$a::z",		"error(" + ErrorType.UNKNOWN_RULE_ATTRIBUTE.code + "): A.g4:10:17: unknown attribute z for rule a in $a::z\n",
 
-		"$S::j",		"error(" + ErrorType.UNDEFINED_RULE_IN_NONLOCAL_REF.code + "): A.g4:10:14: reference to undefined rule 'S' in non-local ref '$S::j'\n",
-		"$S::j = 3;",	"error(" + ErrorType.UNDEFINED_RULE_IN_NONLOCAL_REF.code + "): A.g4:10:14: reference to undefined rule 'S' in non-local ref '$S::j = 3;'\n",
-		"$S::j = $S::k;",	"error(" + ErrorType.UNDEFINED_RULE_IN_NONLOCAL_REF.code + "): A.g4:10:14: reference to undefined rule 'S' in non-local ref '$S::j = $S::k;'\n",
+		"$S::j",		"error(" + ErrorType.UNDEFINED_RULE_IN_NONLOCAL_REF.code + "): A.g4:10:14: reference to undefined rule S in non-local ref $S::j\n",
+		"$S::j = 3;",	"error(" + ErrorType.UNDEFINED_RULE_IN_NONLOCAL_REF.code + "): A.g4:10:14: reference to undefined rule S in non-local ref $S::j = 3;\n",
+		"$S::j = $S::k;",	"error(" + ErrorType.UNDEFINED_RULE_IN_NONLOCAL_REF.code + "): A.g4:10:14: reference to undefined rule S in non-local ref $S::j = $S::k;\n",
 	};
 
     @Test public void testMembersActions() throws RecognitionException {
diff --git a/tool/test/org/antlr/v4/test/TestBasicSemanticErrors.java b/tool-testsuite/test/org/antlr/v4/test/tool/TestBasicSemanticErrors.java
similarity index 80%
rename from tool/test/org/antlr/v4/test/TestBasicSemanticErrors.java
rename to tool-testsuite/test/org/antlr/v4/test/tool/TestBasicSemanticErrors.java
index 59f2b6648..807172f5a 100644
--- a/tool/test/org/antlr/v4/test/TestBasicSemanticErrors.java
+++ b/tool-testsuite/test/org/antlr/v4/test/tool/TestBasicSemanticErrors.java
@@ -28,8 +28,9 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-package org.antlr.v4.test;
+package org.antlr.v4.test.tool;
 
+import org.antlr.v4.test.runtime.java.BaseTest;
 import org.antlr.v4.tool.ErrorType;
 import org.junit.Test;
 import org.stringtemplate.v4.ST;
@@ -54,17 +55,17 @@ public class TestBasicSemanticErrors extends BaseTest {
         "b : ( options { ick=bar; greedy=true; } : ID )+ ;\n" +
         "c : ID<blue> ID<x=y> ;",
         // YIELDS
-		"warning(" + ErrorType.ILLEGAL_OPTION.code + "): U.g4:2:10: unsupported option 'foo'\n" +
-		"warning(" + ErrorType.ILLEGAL_OPTION.code + "): U.g4:2:19: unsupported option 'k'\n" +
+		"warning(" + ErrorType.ILLEGAL_OPTION.code + "): U.g4:2:10: unsupported option foo\n" +
+		"warning(" + ErrorType.ILLEGAL_OPTION.code + "): U.g4:2:19: unsupported option k\n" +
 		"error(" + ErrorType.TOKEN_NAMES_MUST_START_UPPER.code + "): U.g4:5:8: token names must start with an uppercase letter: f\n" +
-		"warning(" + ErrorType.ILLEGAL_OPTION.code + "): U.g4:9:10: unsupported option 'x'\n" +
-		"error(" + ErrorType.REPEATED_PREQUEL.code + "): U.g4:9:0: repeated grammar prequel spec (option, token, or import); please merge\n" +
-		"error(" + ErrorType.REPEATED_PREQUEL.code + "): U.g4:8:0: repeated grammar prequel spec (option, token, or import); please merge\n" +
-		"warning(" + ErrorType.ILLEGAL_OPTION.code + "): U.g4:12:10: unsupported option 'blech'\n" +
-		"warning(" + ErrorType.ILLEGAL_OPTION.code + "): U.g4:12:21: unsupported option 'greedy'\n" +
-		"warning(" + ErrorType.ILLEGAL_OPTION.code + "): U.g4:15:16: unsupported option 'ick'\n" +
-		"warning(" + ErrorType.ILLEGAL_OPTION.code + "): U.g4:15:25: unsupported option 'greedy'\n" +
-		"warning(" + ErrorType.ILLEGAL_OPTION.code + "): U.g4:16:16: unsupported option 'x'\n",
+		"warning(" + ErrorType.ILLEGAL_OPTION.code + "): U.g4:9:10: unsupported option x\n" +
+		"error(" + ErrorType.REPEATED_PREQUEL.code + "): U.g4:9:0: repeated grammar prequel spec (options, tokens, or import); please merge\n" +
+		"error(" + ErrorType.REPEATED_PREQUEL.code + "): U.g4:8:0: repeated grammar prequel spec (options, tokens, or import); please merge\n" +
+		"warning(" + ErrorType.ILLEGAL_OPTION.code + "): U.g4:12:10: unsupported option blech\n" +
+		"warning(" + ErrorType.ILLEGAL_OPTION.code + "): U.g4:12:21: unsupported option greedy\n" +
+		"warning(" + ErrorType.ILLEGAL_OPTION.code + "): U.g4:15:16: unsupported option ick\n" +
+		"warning(" + ErrorType.ILLEGAL_OPTION.code + "): U.g4:15:25: unsupported option greedy\n" +
+		"warning(" + ErrorType.ILLEGAL_OPTION.code + "): U.g4:16:16: unsupported option x\n",
     };
 
 	@Test public void testU() { super.testErrors(U, false); }
@@ -82,7 +83,7 @@ public class TestBasicSemanticErrors extends BaseTest {
 			"";
 
 		String expected =
-			"error(" + ErrorType.LABEL_BLOCK_NOT_A_SET.code + "): T.g4:2:5: label 'op' assigned to a block which is not a set\n";
+			"error(" + ErrorType.LABEL_BLOCK_NOT_A_SET.code + "): T.g4:2:5: label op assigned to a block which is not a set\n";
 
 		testErrors(new String[] { grammar, expected }, false);
 	}
@@ -97,16 +98,16 @@ public class TestBasicSemanticErrors extends BaseTest {
 			"expr : '=';\n";
 
 		String expected =
-			"error(" + ErrorType.ARG_CONFLICTS_WITH_RULE.code + "): T.g4:2:7: parameter 'expr' conflicts with rule with same name\n" +
-			"error(" + ErrorType.RETVAL_CONFLICTS_WITH_RULE.code + "): T.g4:2:26: return value 'expr' conflicts with rule with same name\n" +
-			"error(" + ErrorType.LOCAL_CONFLICTS_WITH_RULE.code + "): T.g4:3:12: local 'expr' conflicts with rule with same name\n" +
-			"error(" + ErrorType.RETVAL_CONFLICTS_WITH_ARG.code + "): T.g4:2:26: return value 'expr' conflicts with parameter with same name\n" +
-			"error(" + ErrorType.LOCAL_CONFLICTS_WITH_ARG.code + "): T.g4:3:12: local 'expr' conflicts with parameter with same name\n" +
-			"error(" + ErrorType.LOCAL_CONFLICTS_WITH_RETVAL.code + "): T.g4:3:12: local 'expr' conflicts with return value with same name\n" +
-			"error(" + ErrorType.LABEL_CONFLICTS_WITH_RULE.code + "): T.g4:4:4: label 'expr' conflicts with rule with same name\n" +
-			"error(" + ErrorType.LABEL_CONFLICTS_WITH_ARG.code + "): T.g4:4:4: label 'expr' conflicts with parameter with same name\n" +
-			"error(" + ErrorType.LABEL_CONFLICTS_WITH_RETVAL.code + "): T.g4:4:4: label 'expr' conflicts with return value with same name\n" +
-			"error(" + ErrorType.LABEL_CONFLICTS_WITH_LOCAL.code + "): T.g4:4:4: label 'expr' conflicts with local with same name\n";
+			"error(" + ErrorType.ARG_CONFLICTS_WITH_RULE.code + "): T.g4:2:7: parameter expr conflicts with rule with same name\n" +
+			"error(" + ErrorType.RETVAL_CONFLICTS_WITH_RULE.code + "): T.g4:2:26: return value expr conflicts with rule with same name\n" +
+			"error(" + ErrorType.LOCAL_CONFLICTS_WITH_RULE.code + "): T.g4:3:12: local expr conflicts with rule with same name\n" +
+			"error(" + ErrorType.RETVAL_CONFLICTS_WITH_ARG.code + "): T.g4:2:26: return value expr conflicts with parameter with same name\n" +
+			"error(" + ErrorType.LOCAL_CONFLICTS_WITH_ARG.code + "): T.g4:3:12: local expr conflicts with parameter with same name\n" +
+			"error(" + ErrorType.LOCAL_CONFLICTS_WITH_RETVAL.code + "): T.g4:3:12: local expr conflicts with return value with same name\n" +
+			"error(" + ErrorType.LABEL_CONFLICTS_WITH_RULE.code + "): T.g4:4:4: label expr conflicts with rule with same name\n" +
+			"error(" + ErrorType.LABEL_CONFLICTS_WITH_ARG.code + "): T.g4:4:4: label expr conflicts with parameter with same name\n" +
+			"error(" + ErrorType.LABEL_CONFLICTS_WITH_RETVAL.code + "): T.g4:4:4: label expr conflicts with return value with same name\n" +
+			"error(" + ErrorType.LABEL_CONFLICTS_WITH_LOCAL.code + "): T.g4:4:4: label expr conflicts with local with same name\n";
 		ST grammarST = new ST(grammarTemplate);
 		grammarST.add("args", "int expr");
 		grammarST.add("retvals", "int expr");
diff --git a/tool/test/org/antlr/v4/test/TestBufferedTokenStream.java b/tool-testsuite/test/org/antlr/v4/test/tool/TestBufferedTokenStream.java
similarity index 98%
rename from tool/test/org/antlr/v4/test/TestBufferedTokenStream.java
rename to tool-testsuite/test/org/antlr/v4/test/tool/TestBufferedTokenStream.java
index 5a635867a..fd85b4399 100644
--- a/tool/test/org/antlr/v4/test/TestBufferedTokenStream.java
+++ b/tool-testsuite/test/org/antlr/v4/test/tool/TestBufferedTokenStream.java
@@ -28,7 +28,7 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-package org.antlr.v4.test;
+package org.antlr.v4.test.tool;
 
 import org.antlr.v4.runtime.ANTLRInputStream;
 import org.antlr.v4.runtime.BufferedTokenStream;
@@ -37,6 +37,7 @@ import org.antlr.v4.runtime.LexerInterpreter;
 import org.antlr.v4.runtime.Token;
 import org.antlr.v4.runtime.TokenSource;
 import org.antlr.v4.runtime.TokenStream;
+import org.antlr.v4.test.runtime.java.BaseTest;
 import org.antlr.v4.tool.LexerGrammar;
 import org.junit.Test;
 
diff --git a/tool-testsuite/test/org/antlr/v4/test/tool/TestCodeGeneration.java b/tool-testsuite/test/org/antlr/v4/test/tool/TestCodeGeneration.java
new file mode 100644
index 000000000..766c7756d
--- /dev/null
+++ b/tool-testsuite/test/org/antlr/v4/test/tool/TestCodeGeneration.java
@@ -0,0 +1,164 @@
+/*
+ * [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.
+ */
+package org.antlr.v4.test.tool;
+
+import org.antlr.runtime.RecognitionException;
+import org.antlr.v4.automata.ATNFactory;
+import org.antlr.v4.automata.LexerATNFactory;
+import org.antlr.v4.automata.ParserATNFactory;
+import org.antlr.v4.codegen.CodeGenerator;
+import org.antlr.v4.semantics.SemanticPipeline;
+import org.antlr.v4.test.runtime.java.BaseTest;
+import org.antlr.v4.test.runtime.java.ErrorQueue;
+import org.antlr.v4.tool.Grammar;
+import org.antlr.v4.tool.LexerGrammar;
+import org.junit.Test;
+import org.stringtemplate.v4.AutoIndentWriter;
+import org.stringtemplate.v4.InstanceScope;
+import org.stringtemplate.v4.Interpreter;
+import org.stringtemplate.v4.ST;
+import org.stringtemplate.v4.STGroup;
+import org.stringtemplate.v4.STWriter;
+import org.stringtemplate.v4.misc.ErrorManager;
+import org.stringtemplate.v4.misc.ErrorType;
+
+import java.io.IOException;
+import java.io.StringWriter;
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.Assert.assertFalse;
+
+public class TestCodeGeneration extends BaseTest {
+	@Test public void testArgDecl() throws Exception { // should use template not string
+		/*ErrorQueue equeue = */new ErrorQueue();
+		String g =
+				"grammar T;\n" +
+				"a[int xyz] : 'a' ;\n";
+		List<String> evals = getEvalInfoForString(g, "int xyz");
+		System.out.println(evals);
+		for (int i = 0; i < evals.size(); i++) {
+			String eval = evals.get(i);
+			assertFalse("eval should not be POJO: "+eval, eval.startsWith("<pojo:"));
+		}
+	}
+
+	/** Add tags around each attribute/template/value write */
+	public static class DebugInterpreter extends Interpreter {
+		List<String> evals = new ArrayList<String>();
+		ErrorManager myErrMgrCopy;
+		int tab = 0;
+		public DebugInterpreter(STGroup group, ErrorManager errMgr, boolean debug) {
+			super(group, errMgr, debug);
+			myErrMgrCopy = errMgr;
+		}
+
+		@Override
+		protected int writeObject(STWriter out, InstanceScope scope, Object o, String[] options) {
+			if ( o instanceof ST ) {
+				String name = ((ST)o).getName();
+				name = name.substring(1);
+				if ( !name.startsWith("_sub") ) {
+					try {
+						out.write("<ST:" + name + ">");
+						evals.add("<ST:" + name + ">");
+						int r = super.writeObject(out, scope, o, options);
+						out.write("</ST:" + name + ">");
+						evals.add("</ST:" + name + ">");
+						return r;
+					} catch (IOException ioe) {
+						myErrMgrCopy.IOError(scope.st, ErrorType.WRITE_IO_ERROR, ioe);
+					}
+				}
+			}
+			return super.writeObject(out, scope, o, options);
+		}
+
+		@Override
+		protected int writePOJO(STWriter out, InstanceScope scope, Object o, String[] options) throws IOException {
+			Class<?> type = o.getClass();
+			String name = type.getSimpleName();
+			out.write("<pojo:"+name+">"+o.toString()+"</pojo:"+name+">");
+			evals.add("<pojo:" + name + ">" + o.toString() + "</pojo:" + name + ">");
+			return super.writePOJO(out, scope, o, options);
+		}
+
+		public void indent(STWriter out) throws IOException {
+			for (int i=1; i<=tab; i++) {
+				out.write("\t");
+			}
+		}
+	}
+
+	public List<String> getEvalInfoForString(String grammarString, String pattern) throws RecognitionException {
+		ErrorQueue equeue = new ErrorQueue();
+		Grammar g = new Grammar(grammarString);
+		List<String> evals = new ArrayList<String>();
+		if ( g.ast!=null && !g.ast.hasErrors ) {
+			SemanticPipeline sem = new SemanticPipeline(g);
+			sem.process();
+
+			ATNFactory factory = new ParserATNFactory(g);
+			if (g.isLexer()) factory = new LexerATNFactory((LexerGrammar) g);
+			g.atn = factory.createATN();
+
+			CodeGenerator gen = new CodeGenerator(g);
+			ST outputFileST = gen.generateParser();
+
+//			STViz viz = outputFileST.inspect();
+//			try {
+//				viz.waitForClose();
+//			}
+//			catch (Exception e) {
+//				e.printStackTrace();
+//			}
+
+			boolean debug = false;
+			DebugInterpreter interp =
+					new DebugInterpreter(outputFileST.groupThatCreatedThisInstance,
+							outputFileST.impl.nativeGroup.errMgr,
+							debug);
+			InstanceScope scope = new InstanceScope(null, outputFileST);
+			StringWriter sw = new StringWriter();
+			AutoIndentWriter out = new AutoIndentWriter(sw);
+			interp.exec(out, scope);
+
+			for (String e : interp.evals) {
+				if (e.contains(pattern)) {
+					evals.add(e);
+				}
+			}
+		}
+		if ( equeue.size()>0 ) {
+			System.err.println(equeue.toString());
+		}
+		return evals;
+	}
+}
diff --git a/tool/test/org/antlr/v4/test/TestCommonTokenStream.java b/tool-testsuite/test/org/antlr/v4/test/tool/TestCommonTokenStream.java
similarity index 96%
rename from tool/test/org/antlr/v4/test/TestCommonTokenStream.java
rename to tool-testsuite/test/org/antlr/v4/test/tool/TestCommonTokenStream.java
index a58451568..825782449 100644
--- a/tool/test/org/antlr/v4/test/TestCommonTokenStream.java
+++ b/tool-testsuite/test/org/antlr/v4/test/tool/TestCommonTokenStream.java
@@ -28,11 +28,12 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-package org.antlr.v4.test;
+package org.antlr.v4.test.tool;
 
 import org.antlr.v4.runtime.CharStream;
 import org.antlr.v4.runtime.CommonToken;
 import org.antlr.v4.runtime.CommonTokenStream;
+import org.antlr.v4.runtime.IntStream;
 import org.antlr.v4.runtime.Lexer;
 import org.antlr.v4.runtime.Token;
 import org.antlr.v4.runtime.TokenFactory;
@@ -41,7 +42,7 @@ import org.antlr.v4.runtime.TokenStream;
 import org.antlr.v4.runtime.WritableToken;
 import org.junit.Test;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
 
 public class TestCommonTokenStream extends TestBufferedTokenStream {
 
@@ -54,7 +55,8 @@ public class TestCommonTokenStream extends TestBufferedTokenStream {
         TokenSource lexer = // simulate input " x =34  ;\n"
             new TokenSource() {
                 int i = 0;
-                WritableToken[] tokens = {
+                @SuppressWarnings("serial")
+				WritableToken[] tokens = {
                     new CommonToken(1," ") {{channel = Lexer.HIDDEN;}},
                     new CommonToken(1,"x"),
                     new CommonToken(1," ") {{channel = Lexer.HIDDEN;}},
@@ -124,6 +126,7 @@ public class TestCommonTokenStream extends TestBufferedTokenStream {
 		                    // token indexes   01234 56789
 			new TokenSource() {
 				int i = 0;
+				@SuppressWarnings("serial")
 				WritableToken[] tokens = {
 				new CommonToken(1," ") {{channel = Lexer.HIDDEN;}}, // 0
 				new CommonToken(1,"x"),								// 1
@@ -235,7 +238,7 @@ public class TestCommonTokenStream extends TestBufferedTokenStream {
 
 			@Override
 			public String getSourceName() {
-				return null;
+				return IntStream.UNKNOWN_SOURCE_NAME;
 			}
 
 			@Override
@@ -283,7 +286,7 @@ public class TestCommonTokenStream extends TestBufferedTokenStream {
 
 			@Override
 			public String getSourceName() {
-				return null;
+				return IntStream.UNKNOWN_SOURCE_NAME;
 			}
 
 			@Override
diff --git a/tool-testsuite/test/org/antlr/v4/test/tool/TestCompositeGrammars.java b/tool-testsuite/test/org/antlr/v4/test/tool/TestCompositeGrammars.java
new file mode 100644
index 000000000..02947abb5
--- /dev/null
+++ b/tool-testsuite/test/org/antlr/v4/test/tool/TestCompositeGrammars.java
@@ -0,0 +1,456 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2012 Terence Parr
+ *  Copyright (c) 2012 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.
+ */
+
+package org.antlr.v4.test.tool;
+
+import org.antlr.v4.test.runtime.java.BaseTest;
+import org.antlr.v4.test.runtime.java.ErrorQueue;
+import org.antlr.v4.tool.ANTLRMessage;
+import org.antlr.v4.tool.ErrorType;
+import org.antlr.v4.tool.Grammar;
+import org.antlr.v4.tool.GrammarSemanticsMessage;
+import org.junit.Test;
+
+import java.io.File;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
+public class TestCompositeGrammars extends BaseTest {
+	protected boolean debug = false;
+
+	@Test public void testImportFileLocationInSubdir() throws Exception {
+		String slave =
+			"parser grammar S;\n" +
+			"a : B {System.out.println(\"S.a\");} ;\n";
+		mkdir(tmpdir);
+		String subdir = tmpdir + "/sub";
+		mkdir(subdir);
+		writeFile(subdir, "S.g4", slave);
+		String master =
+			"grammar M;\n" +
+			"import S;\n" +
+			"s : a ;\n" +
+			"B : 'b' ;" + // defines B from inherited token space
+			"WS : (' '|'\\n') -> skip ;\n" ;
+		writeFile(tmpdir, "M.g4", master);
+		ErrorQueue equeue = antlr("M.g4", false, "-lib", subdir);
+		assertEquals(equeue.size(), 0);
+	}
+
+	@Test public void testErrorInImportedGetsRightFilename() throws Exception {
+		String slave =
+			"parser grammar S;\n" +
+			"a : 'a' | c;\n";
+		mkdir(tmpdir);
+		writeFile(tmpdir, "S.g4", slave);
+		String master =
+			"grammar M;\n" +
+			"import S;\n";
+		writeFile(tmpdir, "M.g4", master);
+		ErrorQueue equeue = antlr("M.g4", false, "-lib", tmpdir);
+		ANTLRMessage msg = equeue.errors.get(0);
+		assertEquals(ErrorType.UNDEFINED_RULE_REF, msg.getErrorType());
+		assertEquals("c", msg.getArgs()[0]);
+		assertEquals(2, msg.line);
+		assertEquals(10, msg.charPosition);
+		assertEquals("S.g4", new File(msg.fileName).getName());
+	}
+
+	@Test public void testImportFileNotSearchedForInOutputDir() throws Exception {
+		String slave =
+			"parser grammar S;\n" +
+			"a : B {System.out.println(\"S.a\");} ;\n";
+		mkdir(tmpdir);
+		String outdir = tmpdir + "/out";
+		mkdir(outdir);
+		writeFile(outdir, "S.g4", slave);
+		String master =
+			"grammar M;\n" +
+			"import S;\n" +
+			"s : a ;\n" +
+			"B : 'b' ;" + // defines B from inherited token space
+			"WS : (' '|'\\n') -> skip ;\n" ;
+		writeFile(tmpdir, "M.g4", master);
+		ErrorQueue equeue = antlr("M.g4", false, "-o", outdir);
+		assertEquals(ErrorType.CANNOT_FIND_IMPORTED_GRAMMAR, equeue.errors.get(0).getErrorType());
+	}
+
+	@Test public void testOutputDirShouldNotEffectImports() throws Exception {
+		String slave =
+			"parser grammar S;\n" +
+			"a : B {System.out.println(\"S.a\");} ;\n";
+		mkdir(tmpdir);
+		String subdir = tmpdir + "/sub";
+		mkdir(subdir);
+		writeFile(subdir, "S.g4", slave);
+		String master =
+			"grammar M;\n" +
+			"import S;\n" +
+			"s : a ;\n" +
+			"B : 'b' ;" + // defines B from inherited token space
+			"WS : (' '|'\\n') -> skip ;\n" ;
+		writeFile(tmpdir, "M.g4", master);
+		String outdir = tmpdir + "/out";
+		mkdir(outdir);
+		ErrorQueue equeue = antlr("M.g4", false, "-o", outdir, "-lib", subdir);
+		assertEquals(0, equeue.size());
+	}
+
+	@Test public void testTokensFileInOutputDirAndImportFileInSubdir() throws Exception {
+		String slave =
+			"parser grammar S;\n" +
+			"a : B {System.out.println(\"S.a\");} ;\n";
+		mkdir(tmpdir);
+		String subdir = tmpdir + "/sub";
+		mkdir(subdir);
+		writeFile(subdir, "S.g4", slave);
+		String parser =
+			"parser grammar MParser;\n" +
+			"import S;\n" +
+			"options {tokenVocab=MLexer;}\n" +
+			"s : a ;\n";
+		writeFile(tmpdir, "MParser.g4", parser);
+		String lexer =
+			"lexer grammar MLexer;\n" +
+			"B : 'b' ;" + // defines B from inherited token space
+			"WS : (' '|'\\n') -> skip ;\n" ;
+		writeFile(tmpdir, "MLexer.g4", lexer);
+		String outdir = tmpdir + "/out";
+		mkdir(outdir);
+		ErrorQueue equeue = antlr("MLexer.g4", false, "-o", outdir);
+		assertEquals(0, equeue.size());
+		equeue = antlr("MParser.g4", false, "-o", outdir, "-lib", subdir);
+		assertEquals(0, equeue.size());
+	}
+
+	@Test public void testImportedTokenVocabIgnoredWithWarning() throws Exception {
+		ErrorQueue equeue = new ErrorQueue();
+		String slave =
+			"parser grammar S;\n" +
+			"options {tokenVocab=whatever;}\n" +
+			"tokens { A }\n" +
+			"x : A {System.out.println(\"S.x\");} ;\n";
+		mkdir(tmpdir);
+		writeFile(tmpdir, "S.g4", slave);
+
+		String master =
+			"grammar M;\n" +
+			"import S;\n" +
+			"s : x ;\n" +
+			"WS : (' '|'\\n') -> skip ;\n" ;
+		writeFile(tmpdir, "M.g4", master);
+		Grammar g = new Grammar(tmpdir+"/M.g4", master, equeue);
+
+		Object expectedArg = "S";
+		ErrorType expectedMsgID = ErrorType.OPTIONS_IN_DELEGATE;
+		GrammarSemanticsMessage expectedMessage =
+			new GrammarSemanticsMessage(expectedMsgID, g.fileName, null, expectedArg);
+		checkGrammarSemanticsWarning(equeue, expectedMessage);
+
+		assertEquals("unexpected errors: "+equeue, 0, equeue.errors.size());
+		assertEquals("unexpected warnings: "+equeue, 1, equeue.warnings.size());
+	}
+
+	@Test public void testSyntaxErrorsInImportsNotThrownOut() throws Exception {
+		ErrorQueue equeue = new ErrorQueue();
+		String slave =
+			"parser grammar S;\n" +
+			"options {toke\n";
+		mkdir(tmpdir);
+		writeFile(tmpdir, "S.g4", slave);
+
+		String master =
+			"grammar M;\n" +
+			"import S;\n" +
+			"s : x ;\n" +
+			"WS : (' '|'\\n') -> skip ;\n" ;
+		writeFile(tmpdir, "M.g4", master);
+		/*Grammar g =*/ new Grammar(tmpdir+"/M.g4", master, equeue);
+
+		assertEquals(ErrorType.SYNTAX_ERROR, equeue.errors.get(0).getErrorType());
+	}
+
+	// Make sure that M can import S that imports T.
+	@Test public void test3LevelImport() throws Exception {
+		ErrorQueue equeue = new ErrorQueue();
+		String slave =
+			"parser grammar T;\n" +
+			"a : T ;\n" ;
+		mkdir(tmpdir);
+		writeFile(tmpdir, "T.g4", slave);
+		String slave2 =
+			"parser grammar S;\n" +
+			"import T;\n" +
+			"a : S ;\n" ;
+		mkdir(tmpdir);
+		writeFile(tmpdir, "S.g4", slave2);
+
+		String master =
+			"grammar M;\n" +
+			"import S;\n" +
+			"a : M ;\n" ;
+		writeFile(tmpdir, "M.g4", master);
+		Grammar g = new Grammar(tmpdir+"/M.g4", master, equeue);
+
+		String expectedTokenIDToTypeMap = "{EOF=-1, M=1}"; // S and T aren't imported; overridden
+		String expectedStringLiteralToTypeMap = "{}";
+		String expectedTypeToTokenList = "[M]";
+
+		assertEquals(expectedTokenIDToTypeMap,
+					 g.tokenNameToTypeMap.toString());
+		assertEquals(expectedStringLiteralToTypeMap, g.stringLiteralToTypeMap.toString());
+		assertEquals(expectedTypeToTokenList,
+					 realElements(g.typeToTokenList).toString());
+
+		assertEquals("unexpected errors: "+equeue, 0, equeue.errors.size());
+
+		boolean ok =
+			rawGenerateAndBuildRecognizer("M.g4", master, "MParser", null);
+		boolean expecting = true; // should be ok
+		assertEquals(expecting, ok);
+	}
+
+	@Test public void testBigTreeOfImports() throws Exception {
+		ErrorQueue equeue = new ErrorQueue();
+		String slave =
+			"parser grammar T;\n" +
+			"tokens{T}\n" +
+			"x : T ;\n" ;
+		mkdir(tmpdir);
+		writeFile(tmpdir, "T.g4", slave);
+		slave =
+			"parser grammar S;\n" +
+			"import T;\n" +
+			"tokens{S}\n" +
+			"y : S ;\n" ;
+		mkdir(tmpdir);
+		writeFile(tmpdir, "S.g4", slave);
+
+		slave =
+			"parser grammar C;\n" +
+			"tokens{C}\n" +
+			"i : C ;\n" ;
+		mkdir(tmpdir);
+		writeFile(tmpdir, "C.g4", slave);
+		slave =
+			"parser grammar B;\n" +
+			"tokens{B}\n" +
+			"j : B ;\n" ;
+		mkdir(tmpdir);
+		writeFile(tmpdir, "B.g4", slave);
+		slave =
+			"parser grammar A;\n" +
+			"import B,C;\n" +
+			"tokens{A}\n" +
+			"k : A ;\n" ;
+		mkdir(tmpdir);
+		writeFile(tmpdir, "A.g4", slave);
+
+		String master =
+			"grammar M;\n" +
+			"import S,A;\n" +
+			"tokens{M}\n" +
+			"a : M ;\n" ;
+		writeFile(tmpdir, "M.g4", master);
+		Grammar g = new Grammar(tmpdir+"/M.g4", master, equeue);
+
+		assertEquals("[]", equeue.errors.toString());
+		assertEquals("[]", equeue.warnings.toString());
+		String expectedTokenIDToTypeMap = "{EOF=-1, M=1, S=2, T=3, A=4, B=5, C=6}";
+		String expectedStringLiteralToTypeMap = "{}";
+		String expectedTypeToTokenList = "[M, S, T, A, B, C]";
+
+		assertEquals(expectedTokenIDToTypeMap,
+					 g.tokenNameToTypeMap.toString());
+		assertEquals(expectedStringLiteralToTypeMap, g.stringLiteralToTypeMap.toString());
+		assertEquals(expectedTypeToTokenList,
+					 realElements(g.typeToTokenList).toString());
+
+		boolean ok =
+			rawGenerateAndBuildRecognizer("M.g4", master, "MParser", null);
+		boolean expecting = true; // should be ok
+		assertEquals(expecting, ok);
+	}
+
+	@Test public void testRulesVisibleThroughMultilevelImport() throws Exception {
+		ErrorQueue equeue = new ErrorQueue();
+		String slave =
+			"parser grammar T;\n" +
+			"x : T ;\n" ;
+		mkdir(tmpdir);
+		writeFile(tmpdir, "T.g4", slave);
+		String slave2 =
+			"parser grammar S;\n" + // A, B, C token type order
+			"import T;\n" +
+			"a : S ;\n" ;
+		mkdir(tmpdir);
+		writeFile(tmpdir, "S.g4", slave2);
+
+		String master =
+			"grammar M;\n" +
+			"import S;\n" +
+			"a : M x ;\n" ; // x MUST BE VISIBLE TO M
+		writeFile(tmpdir, "M.g4", master);
+		Grammar g = new Grammar(tmpdir+"/M.g4", master, equeue);
+
+		String expectedTokenIDToTypeMap = "{EOF=-1, M=1, T=2}";
+		String expectedStringLiteralToTypeMap = "{}";
+		String expectedTypeToTokenList = "[M, T]";
+
+		assertEquals(expectedTokenIDToTypeMap,
+					 g.tokenNameToTypeMap.toString());
+		assertEquals(expectedStringLiteralToTypeMap, g.stringLiteralToTypeMap.toString());
+		assertEquals(expectedTypeToTokenList,
+					 realElements(g.typeToTokenList).toString());
+
+		assertEquals("unexpected errors: "+equeue, 0, equeue.errors.size());
+	}
+
+	@Test public void testNestedComposite() throws Exception {
+		// Wasn't compiling. http://www.antlr.org/jira/browse/ANTLR-438
+		ErrorQueue equeue = new ErrorQueue();
+		String gstr =
+			"lexer grammar L;\n" +
+			"T1: '1';\n" +
+			"T2: '2';\n" +
+			"T3: '3';\n" +
+			"T4: '4';\n" ;
+		mkdir(tmpdir);
+		writeFile(tmpdir, "L.g4", gstr);
+		gstr =
+			"parser grammar G1;\n" +
+			"s: a | b;\n" +
+			"a: T1;\n" +
+			"b: T2;\n" ;
+		mkdir(tmpdir);
+		writeFile(tmpdir, "G1.g4", gstr);
+
+		gstr =
+			"parser grammar G2;\n" +
+			"import G1;\n" +
+			"a: T3;\n" ;
+		mkdir(tmpdir);
+		writeFile(tmpdir, "G2.g4", gstr);
+		String G3str =
+			"grammar G3;\n" +
+			"import G2;\n" +
+			"b: T4;\n" ;
+		mkdir(tmpdir);
+		writeFile(tmpdir, "G3.g4", G3str);
+
+		Grammar g = new Grammar(tmpdir+"/G3.g4", G3str, equeue);
+
+		String expectedTokenIDToTypeMap = "{EOF=-1, T4=1, T3=2}";
+		String expectedStringLiteralToTypeMap = "{}";
+		String expectedTypeToTokenList = "[T4, T3]";
+
+		assertEquals(expectedTokenIDToTypeMap,
+					 g.tokenNameToTypeMap.toString());
+		assertEquals(expectedStringLiteralToTypeMap, g.stringLiteralToTypeMap.toString());
+		assertEquals(expectedTypeToTokenList,
+					 realElements(g.typeToTokenList).toString());
+
+		assertEquals("unexpected errors: "+equeue, 0, equeue.errors.size());
+
+		boolean ok =
+			rawGenerateAndBuildRecognizer("G3.g4", G3str, "G3Parser", null);
+		boolean expecting = true; // should be ok
+		assertEquals(expecting, ok);
+	}
+
+	@Test public void testHeadersPropogatedCorrectlyToImportedGrammars() throws Exception {
+		String slave =
+			"parser grammar S;\n" +
+			"a : B {System.out.print(\"S.a\");} ;\n";
+		mkdir(tmpdir);
+		writeFile(tmpdir, "S.g4", slave);
+		String master =
+			"grammar M;\n" +
+			"import S;\n" +
+			"@header{package mypackage;}\n" +
+			"s : a ;\n" +
+			"B : 'b' ;" + // defines B from inherited token space
+			"WS : (' '|'\\n') -> skip ;\n" ;
+		ErrorQueue equeue = antlr("M.g4", master, false);
+		int expecting = 0; // should be ok
+		assertEquals(expecting, equeue.errors.size());
+	}
+
+	/**
+	 * This is a regression test for antlr/antlr4#670 "exception when importing
+	 * grammar".  I think this one always worked but I found that a different
+	 * Java grammar caused an error and so I made the testImportLeftRecursiveGrammar() test below.
+	 * https://github.com/antlr/antlr4/issues/670
+	 */
+	// TODO: migrate to test framework
+	@Test
+	public void testImportLargeGrammar() throws Exception {
+		String slave = load("Java.g4", "UTF-8");
+		String master =
+			"grammar NewJava;\n" +
+			"import Java;\n";
+
+		System.out.println("dir "+tmpdir);
+		mkdir(tmpdir);
+		writeFile(tmpdir, "Java.g4", slave);
+		String found = execParser("NewJava.g4", master, "NewJavaParser", "NewJavaLexer", "compilationUnit", "package Foo;", debug);
+		assertEquals("", found);
+		assertNull(stderrDuringParse);
+	}
+
+	/**
+	 * This is a regression test for antlr/antlr4#670 "exception when importing
+	 * grammar".
+	 * https://github.com/antlr/antlr4/issues/670
+	 */
+	// TODO: migrate to test framework
+	@Test
+	public void testImportLeftRecursiveGrammar() throws Exception {
+		String slave =
+			"grammar Java;\n" +
+			"e : '(' e ')'\n" +
+			"  | e '=' e\n" +
+			"  | ID\n" +
+			"  ;\n" +
+			"ID : [a-z]+ ;\n";
+		String master =
+			"grammar T;\n" +
+			"import Java;\n" +
+			"s : e ;\n";
+
+		System.out.println("dir "+tmpdir);
+		mkdir(tmpdir);
+		writeFile(tmpdir, "Java.g4", slave);
+		String found = execParser("T.g4", master, "TParser", "TLexer", "s", "a=b", debug);
+		assertEquals("", found);
+		assertNull(stderrDuringParse);
+	}
+}
diff --git a/tool-testsuite/test/org/antlr/v4/test/tool/TestDollarParser.java b/tool-testsuite/test/org/antlr/v4/test/tool/TestDollarParser.java
new file mode 100644
index 000000000..9519f9dcd
--- /dev/null
+++ b/tool-testsuite/test/org/antlr/v4/test/tool/TestDollarParser.java
@@ -0,0 +1,22 @@
+package org.antlr.v4.test.tool;
+
+import org.antlr.v4.test.runtime.java.BaseTest;
+import org.junit.Test;
+
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+public class TestDollarParser extends BaseTest {
+
+	@Test
+	public void testSimpleCall() throws Exception {
+		String grammar = "grammar T;\n" +
+	                  "a : ID  { System.out.println( $parser.getSourceName() ); }\n" +
+	                  "  ;\n" +
+	                  "ID : 'a'..'z'+ ;\n";
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", "x", true);
+		assertTrue(found.indexOf(this.getClass().getSimpleName())>=0);
+		assertNull(this.stderrDuringParse);
+	}
+
+}
diff --git a/tool/src/org/antlr/v4/codegen/model/LL1StarBlock.java b/tool-testsuite/test/org/antlr/v4/test/tool/TestErrorSets.java
similarity index 53%
rename from tool/src/org/antlr/v4/codegen/model/LL1StarBlock.java
rename to tool-testsuite/test/org/antlr/v4/test/tool/TestErrorSets.java
index 1995af507..7afa2b7a2 100644
--- a/tool/src/org/antlr/v4/codegen/model/LL1StarBlock.java
+++ b/tool-testsuite/test/org/antlr/v4/test/tool/TestErrorSets.java
@@ -27,44 +27,43 @@
  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
+package org.antlr.v4.test.tool;
 
-package org.antlr.v4.codegen.model;
+import org.antlr.v4.test.runtime.java.BaseTest;
+import org.antlr.v4.tool.ErrorType;
+import org.junit.Test;
 
-import org.antlr.v4.codegen.OutputModelFactory;
-import org.antlr.v4.runtime.atn.StarLoopEntryState;
-import org.antlr.v4.runtime.misc.IntervalSet;
-import org.antlr.v4.tool.ast.GrammarAST;
+/** Test errors with the set stuff in lexer and parser */
+public class TestErrorSets extends BaseTest {
+	protected boolean debug = false;
 
-import java.util.Arrays;
-import java.util.List;
-
-/** */
-public class LL1StarBlock extends LL1Loop {
-	/** Token names for each alt 0..n-1 */
-	public List<String[]> altLook;
-	public String loopLabel;
-	public String[] exitLook;
-
-	public LL1StarBlock(OutputModelFactory factory, GrammarAST starRootAST, List<CodeBlockForAlt> alts) {
-		super(factory, starRootAST, alts);
-
-		StarLoopEntryState star = (StarLoopEntryState)starRootAST.atnState;
-		blockStartStateNumber =
-			starRootAST.atnState.transition(0).target.stateNumber;
-
-		loopBackStateNumber = star.loopBackState.stateNumber;
-
-		this.decision = star.decision;
-
-		/** Lookahead for each alt 1..n */
-		IntervalSet[] altLookSets = factory.getGrammar().decisionLOOK.get(decision);
-		IntervalSet lastLook = altLookSets[altLookSets.length-1];
-		// remove last (exit) alt
-		altLookSets = Arrays.copyOf(altLookSets, altLookSets.length - 1);
-		altLook = getAltLookaheadAsStringLists(altLookSets);
-		loopLabel = factory.getGenerator().getTarget().getLoopLabel(starRootAST);
-
-		this.exitLook =
-			factory.getGenerator().getTarget().getTokenTypesAsTargetLabels(factory.getGrammar(), lastLook.toArray());
+	/** Public default constructor used by TestRig */
+	public TestErrorSets() {
 	}
+
+	@Test public void testNotCharSetWithRuleRef() throws Exception {
+		// might be a useful feature to add someday
+		String[] pair = new String[] {
+			"grammar T;\n" +
+			"a : A {System.out.println($A.text);} ;\n" +
+			"A : ~('a'|B) ;\n" +
+			"B : 'b' ;\n",
+			"error(" + ErrorType.UNSUPPORTED_REFERENCE_IN_LEXER_SET.code + "): T.g4:3:10: rule reference B is not currently supported in a set\n"
+		};
+		super.testErrors(pair, true);
+	}
+
+	@Test public void testNotCharSetWithString() throws Exception {
+		// might be a useful feature to add someday
+		String[] pair = new String[] {
+			"grammar T;\n" +
+			"a : A {System.out.println($A.text);} ;\n" +
+			"A : ~('a'|'aa') ;\n" +
+			"B : 'b' ;\n",
+			"error(" + ErrorType.INVALID_LITERAL_IN_LEXER_SET.code + "): T.g4:3:10: multi-character literals are not allowed in lexer sets: 'aa'\n"
+		};
+		super.testErrors(pair, true);
+	}
+
+
 }
diff --git a/tool/test/org/antlr/v4/test/TestFastQueue.java b/tool-testsuite/test/org/antlr/v4/test/tool/TestFastQueue.java
similarity index 99%
rename from tool/test/org/antlr/v4/test/TestFastQueue.java
rename to tool-testsuite/test/org/antlr/v4/test/tool/TestFastQueue.java
index 2a90ef0dd..c28c8c7d0 100644
--- a/tool/test/org/antlr/v4/test/TestFastQueue.java
+++ b/tool-testsuite/test/org/antlr/v4/test/tool/TestFastQueue.java
@@ -27,7 +27,7 @@
  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-package org.antlr.v4.test;
+package org.antlr.v4.test.tool;
 
 import org.antlr.runtime.misc.FastQueue;
 import org.junit.Test;
diff --git a/tool-testsuite/test/org/antlr/v4/test/tool/TestGrammarParserInterpreter.java b/tool-testsuite/test/org/antlr/v4/test/tool/TestGrammarParserInterpreter.java
new file mode 100644
index 000000000..d2afde633
--- /dev/null
+++ b/tool-testsuite/test/org/antlr/v4/test/tool/TestGrammarParserInterpreter.java
@@ -0,0 +1,142 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2012 Terence Parr
+ *  Copyright (c) 2012 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.
+ */
+package org.antlr.v4.test.tool;
+
+import org.antlr.v4.runtime.ANTLRInputStream;
+import org.antlr.v4.runtime.CommonTokenStream;
+import org.antlr.v4.runtime.InterpreterRuleContext;
+import org.antlr.v4.runtime.LexerInterpreter;
+import org.antlr.v4.runtime.tree.ParseTree;
+import org.antlr.v4.gui.Trees;
+import org.antlr.v4.tool.Grammar;
+import org.antlr.v4.tool.GrammarParserInterpreter;
+import org.antlr.v4.tool.LexerGrammar;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+/** Tests to ensure GrammarParserInterpreter subclass of ParserInterpreter
+ *  hasn't messed anything up.
+ */
+public class TestGrammarParserInterpreter {
+	public static final String lexerText = "lexer grammar L;\n" +
+										   "PLUS : '+' ;\n" +
+										   "MULT : '*' ;\n" +
+										   "ID : [a-z]+ ;\n" +
+										   "INT : [0-9]+ ;\n" +
+										   "WS : [ \\r\\t\\n]+ ;\n";
+
+	@Test
+	public void testAlts() throws Exception {
+		LexerGrammar lg = new LexerGrammar(lexerText);
+		Grammar g = new Grammar(
+			"parser grammar T;\n" +
+			"s : ID\n"+
+			"  | INT{;}\n"+
+			"  ;\n",
+			lg);
+		testInterp(lg, g, "s", "a",		"(s:1 a)");
+		testInterp(lg, g, "s", "3", 	"(s:2 3)");
+	}
+
+	@Test
+	public void testAltsAsSet() throws Exception {
+		LexerGrammar lg = new LexerGrammar(lexerText);
+		Grammar g = new Grammar(
+			"parser grammar T;\n" +
+			"s : ID\n"+
+			"  | INT\n"+
+			"  ;\n",
+			lg);
+		testInterp(lg, g, "s", "a",		"(s:1 a)");
+		testInterp(lg, g, "s", "3", 	"(s:1 3)");
+	}
+
+	@Test
+	public void testAltsWithLabels() throws Exception {
+		LexerGrammar lg = new LexerGrammar(lexerText);
+		Grammar g = new Grammar(
+			"parser grammar T;\n" +
+			"s : ID  # foo\n" +
+			"  | INT # bar\n" +
+			"  ;\n",
+			lg);
+		// it won't show the labels here because my simple node text provider above just shows the alternative
+		testInterp(lg, g, "s", "a",		"(s:1 a)");
+		testInterp(lg, g, "s", "3", 	"(s:2 3)");
+	}
+
+	@Test
+	public void testOneAlt() throws Exception {
+		LexerGrammar lg = new LexerGrammar(lexerText);
+		Grammar g = new Grammar(
+			"parser grammar T;\n" +
+			"s : ID\n"+
+			"  ;\n",
+			lg);
+		testInterp(lg, g, "s", "a",		"(s:1 a)");
+	}
+
+
+	@Test
+	public void testLeftRecursionWithMultiplePrimaryAndRecursiveOps() throws Exception {
+		LexerGrammar lg = new LexerGrammar(lexerText);
+		Grammar g = new Grammar(
+			"parser grammar T;\n" +
+			"s : e EOF ;\n" +
+			"e : e MULT e\n" +
+			"  | e PLUS e\n" +
+			"  | INT\n" +
+			"  | ID\n" +
+			"  ;\n",
+			lg);
+
+		testInterp(lg, g, "s", "a",		"(s:1 (e:4 a) <EOF>)");
+		testInterp(lg, g, "e", "a",		"(e:4 a)");
+		testInterp(lg, g, "e", "34",	"(e:3 34)");
+		testInterp(lg, g, "e", "a+1",	"(e:2 (e:4 a) + (e:3 1))");
+		testInterp(lg, g, "e", "1+2*a",	"(e:2 (e:3 1) + (e:1 (e:3 2) * (e:4 a)))");
+	}
+
+	InterpreterRuleContext testInterp(LexerGrammar lg, Grammar g,
+	                                  String startRule, String input,
+	                                  String expectedParseTree)
+	{
+		LexerInterpreter lexEngine = lg.createLexerInterpreter(new ANTLRInputStream(input));
+		CommonTokenStream tokens = new CommonTokenStream(lexEngine);
+		GrammarParserInterpreter parser = g.createGrammarParserInterpreter(tokens);
+		ParseTree t = parser.parse(g.rules.get(startRule).index);
+		InterpreterTreeTextProvider nodeTextProvider = new InterpreterTreeTextProvider(g.getRuleNames());
+		String treeStr = Trees.toStringTree(t, nodeTextProvider);
+		System.out.println("parse tree: "+treeStr);
+		assertEquals(expectedParseTree, treeStr);
+		return (InterpreterRuleContext)t;
+	}
+}
diff --git a/tool/test/org/antlr/v4/test/TestGraphNodes.java b/tool-testsuite/test/org/antlr/v4/test/tool/TestGraphNodes.java
similarity index 99%
rename from tool/test/org/antlr/v4/test/TestGraphNodes.java
rename to tool-testsuite/test/org/antlr/v4/test/tool/TestGraphNodes.java
index 0f64a9724..8081afc54 100644
--- a/tool/test/org/antlr/v4/test/TestGraphNodes.java
+++ b/tool-testsuite/test/org/antlr/v4/test/tool/TestGraphNodes.java
@@ -28,7 +28,7 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-package org.antlr.v4.test;
+package org.antlr.v4.test.tool;
 
 import org.antlr.v4.runtime.atn.ArrayPredictionContext;
 import org.antlr.v4.runtime.atn.PredictionContext;
diff --git a/tool/test/org/antlr/v4/test/TestIntervalSet.java b/tool-testsuite/test/org/antlr/v4/test/tool/TestIntervalSet.java
similarity index 91%
rename from tool/test/org/antlr/v4/test/TestIntervalSet.java
rename to tool-testsuite/test/org/antlr/v4/test/tool/TestIntervalSet.java
index 337df2298..c06362ee9 100644
--- a/tool/test/org/antlr/v4/test/TestIntervalSet.java
+++ b/tool-testsuite/test/org/antlr/v4/test/tool/TestIntervalSet.java
@@ -28,10 +28,12 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-package org.antlr.v4.test;
+package org.antlr.v4.test.tool;
 
 import org.antlr.v4.runtime.Lexer;
+import org.antlr.v4.runtime.Token;
 import org.antlr.v4.runtime.misc.IntervalSet;
+import org.antlr.v4.test.runtime.java.BaseTest;
 import org.junit.Test;
 
 import static org.junit.Assert.assertEquals;
@@ -42,21 +44,26 @@ public class TestIntervalSet extends BaseTest {
 
     /** Public default constructor used by TestRig */
     public TestIntervalSet() {
-    }
+	}
 
-    @Test
-	public void testSingleElement() throws Exception {
-        IntervalSet s = IntervalSet.of(99);
-        String expecting = "99";
-        assertEquals(s.toString(), expecting);
-    }
+	@Test public void testSingleElement() throws Exception {
+		IntervalSet s = IntervalSet.of(99);
+		String expecting = "99";
+		assertEquals(s.toString(), expecting);
+	}
 
-    @Test public void testIsolatedElements() throws Exception {
-        IntervalSet s = new IntervalSet();
-        s.add(1);
-        s.add('z');
-        s.add('\uFFF0');
-        String expecting = "{1, 122, 65520}";
+	@Test public void testMin() throws Exception {
+		assertEquals(0, IntervalSet.COMPLETE_CHAR_SET.getMinElement());
+		assertEquals(Token.EPSILON, IntervalSet.COMPLETE_CHAR_SET.or(IntervalSet.of(Token.EPSILON)).getMinElement());
+		assertEquals(Token.EOF, IntervalSet.COMPLETE_CHAR_SET.or(IntervalSet.of(Token.EOF)).getMinElement());
+	}
+
+	@Test public void testIsolatedElements() throws Exception {
+		IntervalSet s = new IntervalSet();
+		s.add(1);
+		s.add('z');
+		s.add('\uFFF0');
+		String expecting = "{1, 122, 65520}";
         assertEquals(s.toString(), expecting);
     }
 
@@ -140,7 +147,7 @@ public class TestIntervalSet extends BaseTest {
         IntervalSet vocabulary = IntervalSet.of(1,255);
         vocabulary.add(1000,2000);
         vocabulary.add(9999);
-        IntervalSet s = IntervalSet.of(50,60);
+        IntervalSet s = IntervalSet.of(50, 60);
         s.add(3);
         s.add(250,300);
         s.add(10000); // this is outside range of vocab and should be ignored
@@ -157,10 +164,19 @@ public class TestIntervalSet extends BaseTest {
         assertEquals(expecting, result);
     }
 
-    @Test public void testSubtractOfOverlappingRangeFromLeft() throws Exception {
-        IntervalSet s = IntervalSet.of(10,20);
-        IntervalSet s2 = IntervalSet.of(5,11);
-        String expecting = "{12..20}";
+	@Test public void testSubtractFromSetWithEOF() throws Exception {
+		IntervalSet s = IntervalSet.of(10,20);
+		s.add(Token.EOF);
+		IntervalSet s2 = IntervalSet.of(12,15);
+		String expecting = "{<EOF>, 10..11, 16..20}";
+		String result = (s.subtract(s2)).toString();
+		assertEquals(expecting, result);
+	}
+
+	@Test public void testSubtractOfOverlappingRangeFromLeft() throws Exception {
+		IntervalSet s = IntervalSet.of(10,20);
+		IntervalSet s2 = IntervalSet.of(5,11);
+		String expecting = "{12..20}";
         String result = (s.subtract(s2)).toString();
         assertEquals(expecting, result);
 
diff --git a/tool-testsuite/test/org/antlr/v4/test/tool/TestLeftRecursionToolIssues.java b/tool-testsuite/test/org/antlr/v4/test/tool/TestLeftRecursionToolIssues.java
new file mode 100644
index 000000000..713dab804
--- /dev/null
+++ b/tool-testsuite/test/org/antlr/v4/test/tool/TestLeftRecursionToolIssues.java
@@ -0,0 +1,134 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2012 Terence Parr
+ *  Copyright (c) 2012 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.
+ */
+
+package org.antlr.v4.test.tool;
+
+import org.antlr.v4.test.runtime.java.BaseTest;
+import org.antlr.v4.tool.ErrorType;
+import org.junit.Test;
+
+/** */
+public class TestLeftRecursionToolIssues extends BaseTest {
+	protected boolean debug = false;
+
+	@Test public void testCheckForNonLeftRecursiveRule() throws Exception {
+		String grammar =
+			"grammar T;\n" +
+			"s @after {System.out.println($ctx.toStringTree(this));} : a ;\n" +
+			"a : a ID\n" +
+			"  ;\n" +
+			"ID : 'a'..'z'+ ;\n" +
+			"WS : (' '|'\\n') -> skip ;\n";
+		String expected =
+			"error(" + ErrorType.NO_NON_LR_ALTS.code + "): T.g4:3:0: left recursive rule a must contain an alternative which is not left recursive\n";
+		testErrors(new String[] { grammar, expected }, false);
+	}
+
+	@Test public void testCheckForLeftRecursiveEmptyFollow() throws Exception {
+		String grammar =
+			"grammar T;\n" +
+			"s @after {System.out.println($ctx.toStringTree(this));} : a ;\n" +
+			"a : a ID?\n" +
+			"  | ID\n" +
+			"  ;\n" +
+			"ID : 'a'..'z'+ ;\n" +
+			"WS : (' '|'\\n') -> skip ;\n";
+		String expected =
+			"error(" + ErrorType.EPSILON_LR_FOLLOW.code + "): T.g4:3:0: left recursive rule a contains a left recursive alternative which can be followed by the empty string\n";
+		testErrors(new String[] { grammar, expected }, false);
+	}
+
+	/** Reproduces https://github.com/antlr/antlr4/issues/855 */
+	@Test public void testLeftRecursiveRuleRefWithArg() throws Exception {
+		String grammar =
+			"grammar T;\n" +
+			"statement\n" +
+			"locals[Scope scope]\n" +
+			"    : expressionA[$scope] ';'\n" +
+			"    ;\n" +
+			"expressionA[Scope scope]\n" +
+			"    : atom[$scope]\n" +
+			"    | expressionA[$scope] '[' expressionA[$scope] ']'\n" +
+			"    ;\n" +
+			"atom[Scope scope]\n" +
+			"    : 'dummy'\n" +
+			"    ;\n";
+		String expected =
+			"error(" + ErrorType.NONCONFORMING_LR_RULE.code + "): T.g4:6:0: rule expressionA is left recursive but doesn't conform to a pattern ANTLR can handle\n";
+		testErrors(new String[]{grammar, expected}, false);
+	}
+
+	/** Reproduces https://github.com/antlr/antlr4/issues/855 */
+	@Test public void testLeftRecursiveRuleRefWithArg2() throws Exception {
+		String grammar =
+			"grammar T;\n" +
+			"a[int i] : 'x'\n" +
+			"  | a[3] 'y'\n" +
+			"  ;";
+		String expected =
+			"error(" + ErrorType.NONCONFORMING_LR_RULE.code + "): T.g4:2:0: rule a is left recursive but doesn't conform to a pattern ANTLR can handle\n";
+		testErrors(new String[]{grammar, expected}, false);
+	}
+
+	/** Reproduces https://github.com/antlr/antlr4/issues/855 */
+	@Test public void testLeftRecursiveRuleRefWithArg3() throws Exception {
+		String grammar =
+			"grammar T;\n" +
+			"a : 'x'\n" +
+			"  | a[3] 'y'\n" +
+			"  ;";
+		String expected =
+			"error(" + ErrorType.NONCONFORMING_LR_RULE.code + "): T.g4:2:0: rule a is left recursive but doesn't conform to a pattern ANTLR can handle\n";
+		testErrors(new String[]{grammar, expected}, false);
+	}
+
+	/** Reproduces https://github.com/antlr/antlr4/issues/822 */
+	@Test public void testIsolatedLeftRecursiveRuleRef() throws Exception {
+		String grammar =
+			"grammar T;\n" +
+			"a : a | b ;\n" +
+			"b : 'B' ;\n";
+		String expected =
+			"error(" + ErrorType.NONCONFORMING_LR_RULE.code + "): T.g4:2:0: rule a is left recursive but doesn't conform to a pattern ANTLR can handle\n";
+		testErrors(new String[]{grammar, expected}, false);
+	}
+
+	/** Reproduces https://github.com/antlr/antlr4/issues/773 */
+	@Test public void testArgOnPrimaryRuleInLeftRecursiveRule() throws Exception {
+		String grammar =
+			"grammar T;\n" +
+			"val: dval[1]\n" +
+			"   | val '*' val\n" +
+			"   ;\n" +
+			"dval[int  x]: '.';\n";
+		String expected = ""; // dval[1] should not be error
+		testErrors(new String[]{grammar, expected}, false);
+	}
+}
diff --git a/tool-testsuite/test/org/antlr/v4/test/tool/TestLexerActions.java b/tool-testsuite/test/org/antlr/v4/test/tool/TestLexerActions.java
new file mode 100644
index 000000000..1e8740ddd
--- /dev/null
+++ b/tool-testsuite/test/org/antlr/v4/test/tool/TestLexerActions.java
@@ -0,0 +1,284 @@
+package org.antlr.v4.test.tool;
+
+import org.antlr.v4.test.runtime.java.BaseTest;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class TestLexerActions extends BaseTest {
+	// ----- ACTIONS --------------------------------------------------------
+
+	@Test public void testActionExecutedInDFA() throws Exception {
+		String grammar =
+			"lexer grammar L;\n"+
+			"I : '0'..'9'+ {System.out.println(\"I\");} ;\n"+
+			"WS : (' '|'\\n') -> skip ;";
+		String found = execLexer("L.g4", grammar, "L", "34 34");
+		String expecting =
+			"I\n" +
+			"I\n" +
+			"[@0,0:1='34',<1>,1:0]\n" +
+			"[@1,3:4='34',<1>,1:3]\n" +
+			"[@2,5:4='<EOF>',<-1>,1:5]\n";
+		assertEquals(expecting, found);
+	}
+
+	@Test public void testActionEvalsAtCorrectIndex() throws Exception {
+		String grammar =
+			"lexer grammar L;\n"+
+			"I : [0-9] {System.out.println(\"2nd char: \"+(char)_input.LA(1));} [0-9]+ ;\n"+
+			"WS : (' '|'\\n') -> skip ;";
+		String found = execLexer("L.g4", grammar, "L", "123 45");
+		String expecting =
+			"2nd char: 2\n" +
+			"2nd char: 5\n" +
+			"[@0,0:2='123',<1>,1:0]\n" +
+			"[@1,4:5='45',<1>,1:4]\n" +
+			"[@2,6:5='<EOF>',<-1>,1:6]\n";
+		assertEquals(expecting, found);
+	}
+
+	/**
+	 * This is a regressing test for antlr/antlr4#469 "Not all internal lexer
+	 * rule actions are executed".
+	 * https://github.com/antlr/antlr4/issues/469
+	 */
+	@Test public void testEvalMultipleActions() throws Exception {
+		String grammar =
+			"lexer grammar L;\n" +
+			"\n" +
+			"@lexer::members\n" +
+			"{\n" +
+			"class Marker\n" +
+			"{\n" +
+			"   Marker (Lexer lexer) { this.lexer = lexer; }\n" +
+			"\n" +
+			"   public String getText ()\n" +
+			"   {\n" +
+			"      return lexer._input.getText (new Interval (start_index, stop_index));\n" +
+			"   }\n" +
+			"\n" +
+			"   public void start ()  { start_index = lexer._input.index (); System.out.println (\"Start:\" + start_index);}\n" +
+			"   public void stop () { stop_index = lexer._input.index (); System.out.println (\"Stop:\" + stop_index);}\n" +
+			"\n" +
+			"   private int start_index = 0;\n" +
+			"   private int stop_index = 0;\n" +
+			"   private Lexer lexer;\n" +
+			"}\n" +
+			"\n" +
+			"Marker m_name = new Marker (this);\n" +
+			"}\n" +
+			"\n" +
+			"HELLO: 'hello' WS { m_name.start (); } NAME { m_name.stop (); } '\\n' { System.out.println (\"Hello: \" + m_name.getText ()); };\n" +
+			"NAME: ('a'..'z' | 'A'..'Z')+ ('\\n')?;\n" +
+			"\n" +
+			"fragment WS: [ \\r\\t\\n]+ ;\n";
+		String found = execLexer("L.g4", grammar, "L", "hello Steve\n");
+		String expecting =
+			"Start:6\n" +
+			"Stop:11\n" +
+			"Hello: Steve\n" +
+			"\n" +
+			"[@0,0:11='hello Steve\\n',<1>,1:0]\n" +
+			"[@1,12:11='<EOF>',<-1>,2:0]\n";
+		assertEquals(expecting, found);
+	}
+
+	@Test public void test2ActionsIn1Rule() throws Exception {
+		String grammar =
+			"lexer grammar L;\n"+
+			"I : [0-9] {System.out.println(\"x\");} [0-9]+ {System.out.println(\"y\");} ;\n"+
+			"WS : (' '|'\\n') -> skip ;";
+		String found = execLexer("L.g4", grammar, "L", "123 45");
+		String expecting =
+			"x\n" +
+			"y\n" +
+			"x\n" +
+			"y\n" +
+			"[@0,0:2='123',<1>,1:0]\n" +
+			"[@1,4:5='45',<1>,1:4]\n" +
+			"[@2,6:5='<EOF>',<-1>,1:6]\n";
+		assertEquals(expecting, found);
+	}
+
+	@Test public void testAltActionsIn1Rule() throws Exception {
+		String grammar =
+			"lexer grammar L;\n"+
+			"I : ( [0-9]+ {System.out.print(\"int\");}\n" +
+			"    | [a-z]+ {System.out.print(\"id\");}\n" +
+			"    )\n" +
+			"    {System.out.println(\" last\");}\n" +
+			"    ;\n"+
+			"WS : (' '|'\\n') -> skip ;";
+		String found = execLexer("L.g4", grammar, "L", "123 ab");
+		String expecting =
+			"int last\n" +
+			"id last\n" +
+			"[@0,0:2='123',<1>,1:0]\n" +
+			"[@1,4:5='ab',<1>,1:4]\n" +
+			"[@2,6:5='<EOF>',<-1>,1:6]\n";
+		assertEquals(expecting, found);
+	}
+
+	@Test public void testActionPlusCommand() throws Exception {
+		String grammar =
+			"lexer grammar L;\n"+
+			"I : '0'..'9'+ {System.out.println(\"I\");} -> skip ;\n"+
+			"WS : (' '|'\\n') -> skip ;";
+		String found = execLexer("L.g4", grammar, "L", "34 34");
+		String expecting =
+			"I\n" +
+			"I\n" +
+			"[@0,5:4='<EOF>',<-1>,1:5]\n";
+		assertEquals(expecting, found);
+	}
+
+	// ----- COMMANDS --------------------------------------------------------
+
+	@Test public void testSkipCommand() throws Exception {
+		String grammar =
+			"lexer grammar L;\n"+
+			"I : '0'..'9'+ {System.out.println(\"I\");} ;\n"+
+			"WS : (' '|'\\n') -> skip ;";
+		String found = execLexer("L.g4", grammar, "L", "34 34");
+		String expecting =
+			"I\n" +
+			"I\n" +
+			"[@0,0:1='34',<1>,1:0]\n" +
+			"[@1,3:4='34',<1>,1:3]\n" +
+			"[@2,5:4='<EOF>',<-1>,1:5]\n";
+		assertEquals(expecting, found);
+	}
+
+	@Test public void testMoreCommand() throws Exception {
+		String grammar =
+			"lexer grammar L;\n"+
+			"I : '0'..'9'+ {System.out.println(\"I\");} ;\n"+
+			"WS : '#' -> more ;";
+		String found = execLexer("L.g4", grammar, "L", "34#10");
+		String expecting =
+			"I\n" +
+			"I\n" +
+			"[@0,0:1='34',<1>,1:0]\n" +
+			"[@1,2:4='#10',<1>,1:2]\n" +
+			"[@2,5:4='<EOF>',<-1>,1:5]\n";
+		assertEquals(expecting, found);
+	}
+
+	@Test public void testTypeCommand() throws Exception {
+		String grammar =
+			"lexer grammar L;\n"+
+			"I : '0'..'9'+ {System.out.println(\"I\");} ;\n"+
+			"HASH : '#' -> type(HASH) ;";
+		String found = execLexer("L.g4", grammar, "L", "34#");
+		String expecting =
+			"I\n" +
+			"[@0,0:1='34',<1>,1:0]\n" +
+			"[@1,2:2='#',<2>,1:2]\n" +
+			"[@2,3:2='<EOF>',<-1>,1:3]\n";
+		assertEquals(expecting, found);
+	}
+
+	@Test public void testCombinedCommand() throws Exception {
+		String grammar =
+			"lexer grammar L;\n"+
+			"I : '0'..'9'+ {System.out.println(\"I\");} ;\n"+
+			"HASH : '#' -> type(100), skip, more  ;";
+		String found = execLexer("L.g4", grammar, "L", "34#11");
+		String expecting =
+			"I\n" +
+			"I\n" +
+			"[@0,0:1='34',<1>,1:0]\n" +
+			"[@1,2:4='#11',<1>,1:2]\n" +
+			"[@2,5:4='<EOF>',<-1>,1:5]\n";
+		assertEquals(expecting, found);
+	}
+
+	@Test public void testLexerMode() throws Exception {
+		String grammar =
+			"lexer grammar L;\n" +
+			"STRING_START : '\"' -> pushMode(STRING_MODE), more;\n" +
+			"WS : (' '|'\\n') -> skip ;\n"+
+			"mode STRING_MODE;\n"+
+			"STRING : '\"' -> popMode;\n"+
+			"ANY : . -> more;\n";
+		String found = execLexer("L.g4", grammar, "L", "\"abc\" \"ab\"");
+		String expecting =
+			"[@0,0:4='\"abc\"',<2>,1:0]\n" +
+			"[@1,6:9='\"ab\"',<2>,1:6]\n" +
+			"[@2,10:9='<EOF>',<-1>,1:10]\n";
+		assertEquals(expecting, found);
+	}
+
+	@Test public void testLexerPushPopModeAction() throws Exception {
+		String grammar =
+			"lexer grammar L;\n" +
+			"STRING_START : '\"' -> pushMode(STRING_MODE), more ;\n" +
+			"WS : (' '|'\\n') -> skip ;\n"+
+			"mode STRING_MODE;\n"+
+			"STRING : '\"' -> popMode ;\n"+  // token type 2
+			"ANY : . -> more ;\n";
+		String found = execLexer("L.g4", grammar, "L", "\"abc\" \"ab\"");
+		String expecting =
+			"[@0,0:4='\"abc\"',<2>,1:0]\n" +
+			"[@1,6:9='\"ab\"',<2>,1:6]\n" +
+			"[@2,10:9='<EOF>',<-1>,1:10]\n";
+		assertEquals(expecting, found);
+	}
+
+	@Test public void testLexerModeAction() throws Exception {
+		String grammar =
+			"lexer grammar L;\n" +
+			"STRING_START : '\"' -> mode(STRING_MODE), more ;\n" +
+			"WS : (' '|'\\n') -> skip ;\n"+
+			"mode STRING_MODE;\n"+
+			"STRING : '\"' -> mode(DEFAULT_MODE) ;\n"+ // ttype 2 since '"' ambiguity
+			"ANY : . -> more ;\n";
+		String found = execLexer("L.g4", grammar, "L", "\"abc\" \"ab\"");
+		String expecting =
+			"[@0,0:4='\"abc\"',<2>,1:0]\n" +
+			"[@1,6:9='\"ab\"',<2>,1:6]\n" +
+			"[@2,10:9='<EOF>',<-1>,1:10]\n";
+		assertEquals(expecting, found);
+	}
+
+	// ----- PREDICATES --------------------------------------------------------
+
+	/**
+	 * This is a regression test for antlr/antlr4#398 "Lexer: literal matches
+	 * while negated char set fail to match"
+	 * https://github.com/antlr/antlr4/issues/398
+	 */
+	@Test
+	public void testFailingPredicateEvalIsNotCached() {
+		String grammar =
+			"lexer grammar TestLexer;\n" +
+			"\n" +
+			"fragment WS: [ \\t]+;\n" +
+			"fragment EOL: '\\r'? '\\n';\n" +
+			"\n" +
+			"LINE: WS? ~[\\r\\n]* EOL { !getText().trim().startsWith(\"Item:\") }?;\n" +
+			"ITEM: WS? 'Item:' -> pushMode(ITEM_HEADING_MODE);\n" +
+			"\n" +
+			"mode ITEM_HEADING_MODE;\n" +
+			"\n" +
+			"NAME: ~[\\r\\n]+;\n" +
+			"SECTION_HEADING_END: EOL -> popMode;\n";
+		String input =
+			"A line here.\n" +
+			"Item: name of item\n" +
+			"Another line.\n" +
+			"More line.\n";
+		String found = execLexer("TestLexer.g4", grammar, "TestLexer", input);
+		String expecting =
+			"[@0,0:12='A line here.\\n',<1>,1:0]\n" +
+			"[@1,13:17='Item:',<2>,2:0]\n" +
+			"[@2,18:30=' name of item',<3>,2:5]\n" +
+			"[@3,31:31='\\n',<4>,2:18]\n" +
+			"[@4,32:45='Another line.\\n',<1>,3:0]\n" +
+			"[@5,46:56='More line.\\n',<1>,4:0]\n" +
+			"[@6,57:56='<EOF>',<-1>,5:0]\n";
+		assertEquals(expecting, found);
+	}
+
+}
diff --git a/tool-testsuite/test/org/antlr/v4/test/tool/TestLookaheadTrees.java b/tool-testsuite/test/org/antlr/v4/test/tool/TestLookaheadTrees.java
new file mode 100644
index 000000000..36c816340
--- /dev/null
+++ b/tool-testsuite/test/org/antlr/v4/test/tool/TestLookaheadTrees.java
@@ -0,0 +1,144 @@
+package org.antlr.v4.test.tool;
+
+import org.antlr.v4.runtime.ANTLRInputStream;
+import org.antlr.v4.runtime.CommonTokenStream;
+import org.antlr.v4.runtime.LexerInterpreter;
+import org.antlr.v4.runtime.ParserRuleContext;
+import org.antlr.v4.runtime.atn.DecisionInfo;
+import org.antlr.v4.runtime.atn.LookaheadEventInfo;
+import org.antlr.v4.runtime.tree.ParseTree;
+import org.antlr.v4.gui.Trees;
+import org.antlr.v4.tool.Grammar;
+import org.antlr.v4.tool.GrammarParserInterpreter;
+import org.antlr.v4.tool.LexerGrammar;
+import org.junit.Test;
+
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+
+public class TestLookaheadTrees {
+	public static final String lexerText =
+		"lexer grammar L;\n" +
+		"DOT  : '.' ;\n" +
+		"SEMI : ';' ;\n" +
+		"BANG : '!' ;\n" +
+		"PLUS : '+' ;\n" +
+		"LPAREN : '(' ;\n" +
+		"RPAREN : ')' ;\n" +
+		"MULT : '*' ;\n" +
+		"ID : [a-z]+ ;\n" +
+		"INT : [0-9]+ ;\n" +
+		"WS : [ \\r\\t\\n]+ ;\n";
+
+	@Test
+	public void testAlts() throws Exception {
+		LexerGrammar lg = new LexerGrammar(lexerText);
+		Grammar g = new Grammar(
+			"parser grammar T;\n" +
+			"s : e SEMI EOF ;\n" +
+			"e : ID DOT ID\n"+
+			"  | ID LPAREN RPAREN\n"+
+			"  ;\n",
+			lg);
+
+		String startRuleName = "s";
+		int decision = 0;
+
+		testLookaheadTrees(lg, g, "a.b;", startRuleName, decision,
+						   new String[] {"(e:1 a . b)", "(e:2 a <error .>)"});
+	}
+
+	@Test
+	public void testAlts2() throws Exception {
+		LexerGrammar lg = new LexerGrammar(lexerText);
+		Grammar g = new Grammar(
+			"parser grammar T;\n" +
+			"s : e? SEMI EOF ;\n" +
+			"e : ID\n" +
+			"  | e BANG" +
+			"  ;\n",
+			lg);
+
+		String startRuleName = "s";
+		int decision = 1; // (...)* in e.
+
+		testLookaheadTrees(lg, g, "a;", startRuleName, decision,
+						   new String[] {"(e:2 (e:1 a) <error ;>)", // Decision for alt 1 is error as no ! char, but alt 2 (exit) is good.
+										 "(s:1 (e:1 a) ; <EOF>)"}); // root s:1 is included to show ';' node
+	}
+
+	@Test
+	public void testIncludeEOF() throws Exception {
+		LexerGrammar lg = new LexerGrammar(lexerText);
+		Grammar g = new Grammar(
+			"parser grammar T;\n" +
+			"s : e ;\n" +
+			"e : ID DOT ID EOF\n"+
+			"  | ID DOT ID EOF\n"+
+			"  ;\n",
+			lg);
+
+		int decision = 0;
+		testLookaheadTrees(lg, g, "a.b", "s", decision,
+						   new String[] {"(e:1 a . b <EOF>)", "(e:2 a . b <EOF>)"});
+	}
+
+	@Test
+	public void testCallLeftRecursiveRule() throws Exception {
+		LexerGrammar lg = new LexerGrammar(lexerText);
+		Grammar g = new Grammar(
+			"parser grammar T;\n" +
+			"s : a BANG EOF;\n" +
+			"a : e SEMI \n" +
+			"  | ID SEMI \n" +
+			"  ;" +
+			"e : e MULT e\n" +
+			"  | e PLUS e\n" +
+			"  | e DOT e\n" +
+			"  | ID\n" +
+			"  | INT\n" +
+			"  ;\n",
+			lg);
+
+		int decision = 0;
+		testLookaheadTrees(lg, g, "x;!", "s", decision,
+						   new String[] {"(a:1 (e:4 x) ;)",
+										 "(a:2 x ;)"}); // shouldn't include BANG, EOF
+		decision = 2; // (...)* in e
+		testLookaheadTrees(lg, g, "x+1;!", "s", decision,
+						   new String[] {"(e:1 (e:4 x) <error +>)",
+										 "(e:2 (e:4 x) + (e:5 1))",
+										 "(e:3 (e:4 x) <error +>)"});
+	}
+
+	public void testLookaheadTrees(LexerGrammar lg, Grammar g,
+								   String input,
+								   String startRuleName,
+								   int decision,
+								   String[] expectedTrees)
+	{
+		int startRuleIndex = g.getRule(startRuleName).index;
+		InterpreterTreeTextProvider nodeTextProvider =
+					new InterpreterTreeTextProvider(g.getRuleNames());
+
+		LexerInterpreter lexEngine = lg.createLexerInterpreter(new ANTLRInputStream(input));
+		CommonTokenStream tokens = new CommonTokenStream(lexEngine);
+		GrammarParserInterpreter parser = g.createGrammarParserInterpreter(tokens);
+		parser.setProfile(true);
+		ParseTree t = parser.parse(startRuleIndex);
+
+		DecisionInfo decisionInfo = parser.getParseInfo().getDecisionInfo()[decision];
+		LookaheadEventInfo lookaheadEventInfo = decisionInfo.SLL_MaxLookEvent;
+
+		List<ParserRuleContext> lookaheadParseTrees =
+			GrammarParserInterpreter.getLookaheadParseTrees(g, parser, tokens, startRuleIndex, lookaheadEventInfo.decision,
+															lookaheadEventInfo.startIndex, lookaheadEventInfo.stopIndex);
+
+		assertEquals(expectedTrees.length, lookaheadParseTrees.size());
+		for (int i = 0; i < lookaheadParseTrees.size(); i++) {
+			ParserRuleContext lt = lookaheadParseTrees.get(i);
+			assertEquals(expectedTrees[i], Trees.toStringTree(lt, nodeTextProvider));
+		}
+	}
+}
diff --git a/tool/test/org/antlr/v4/test/TestParseTreeMatcher.java b/tool-testsuite/test/org/antlr/v4/test/tool/TestParseTreeMatcher.java
similarity index 85%
rename from tool/test/org/antlr/v4/test/TestParseTreeMatcher.java
rename to tool-testsuite/test/org/antlr/v4/test/tool/TestParseTreeMatcher.java
index 62d20fb29..8f79005c8 100644
--- a/tool/test/org/antlr/v4/test/TestParseTreeMatcher.java
+++ b/tool-testsuite/test/org/antlr/v4/test/tool/TestParseTreeMatcher.java
@@ -1,8 +1,10 @@
-package org.antlr.v4.test;
+package org.antlr.v4.test.tool;
 
 import org.antlr.v4.runtime.CharStream;
 import org.antlr.v4.runtime.CommonTokenStream;
+import org.antlr.v4.runtime.InputMismatchException;
 import org.antlr.v4.runtime.Lexer;
+import org.antlr.v4.runtime.NoViableAltException;
 import org.antlr.v4.runtime.Parser;
 import org.antlr.v4.runtime.Token;
 import org.antlr.v4.runtime.TokenStream;
@@ -10,6 +12,7 @@ import org.antlr.v4.runtime.tree.ParseTree;
 import org.antlr.v4.runtime.tree.pattern.ParseTreeMatch;
 import org.antlr.v4.runtime.tree.pattern.ParseTreePattern;
 import org.antlr.v4.runtime.tree.pattern.ParseTreePatternMatcher;
+import org.antlr.v4.test.runtime.java.BaseTest;
 import org.junit.Test;
 
 import java.lang.reflect.Constructor;
@@ -119,6 +122,81 @@ public class TestParseTreeMatcher extends BaseTest {
 		assertEquals(expected, results);
 	}
 
+	@Test
+	public void testCompilingPatternConsumesAllTokens() throws Exception {
+		String grammar =
+			"grammar X2;\n" +
+			"s : ID '=' expr ';' ;\n" +
+			"expr : ID | INT ;\n" +
+			"ID : [a-z]+ ;\n" +
+			"INT : [0-9]+ ;\n" +
+			"WS : [ \\r\\n\\t]+ -> skip ;\n";
+		boolean ok =
+			rawGenerateAndBuildRecognizer("X2.g4", grammar, "X2Parser", "X2Lexer", false);
+		assertTrue(ok);
+
+		ParseTreePatternMatcher m = getPatternMatcher("X2");
+
+		boolean failed = false;
+		try {
+			m.compile("<ID> = <expr> ; extra", m.getParser().getRuleIndex("s"));
+		}
+		catch (ParseTreePatternMatcher.StartRuleDoesNotConsumeFullPattern e) {
+			failed = true;
+		}
+		assertTrue(failed);
+	}
+
+	@Test
+	public void testPatternMatchesStartRule() throws Exception {
+		String grammar =
+			"grammar X2;\n" +
+			"s : ID '=' expr ';' ;\n" +
+			"expr : ID | INT ;\n" +
+			"ID : [a-z]+ ;\n" +
+			"INT : [0-9]+ ;\n" +
+			"WS : [ \\r\\n\\t]+ -> skip ;\n";
+		boolean ok =
+			rawGenerateAndBuildRecognizer("X2.g4", grammar, "X2Parser", "X2Lexer", false);
+		assertTrue(ok);
+
+		ParseTreePatternMatcher m = getPatternMatcher("X2");
+
+		boolean failed = false;
+		try {
+			m.compile("<ID> ;", m.getParser().getRuleIndex("s"));
+		}
+		catch (InputMismatchException e) {
+			failed = true;
+		}
+		assertTrue(failed);
+	}
+
+	@Test
+	public void testPatternMatchesStartRule2() throws Exception {
+		String grammar =
+			"grammar X2;\n" +
+			"s : ID '=' expr ';' | expr ';' ;\n" +
+			"expr : ID | INT ;\n" +
+			"ID : [a-z]+ ;\n" +
+			"INT : [0-9]+ ;\n" +
+			"WS : [ \\r\\n\\t]+ -> skip ;\n";
+		boolean ok =
+			rawGenerateAndBuildRecognizer("X2.g4", grammar, "X2Parser", "X2Lexer", false);
+		assertTrue(ok);
+
+		ParseTreePatternMatcher m = getPatternMatcher("X2");
+
+		boolean failed = false;
+		try {
+			m.compile("<ID> <ID> ;", m.getParser().getRuleIndex("s"));
+		}
+		catch (NoViableAltException e) {
+			failed = true;
+		}
+		assertTrue(failed);
+	}
+
 	@Test
 	public void testHiddenTokensNotSeenByTreePatternParser() throws Exception {
 		String grammar =
diff --git a/tool-testsuite/test/org/antlr/v4/test/tool/TestParserExec.java b/tool-testsuite/test/org/antlr/v4/test/tool/TestParserExec.java
new file mode 100644
index 000000000..3066d4c6b
--- /dev/null
+++ b/tool-testsuite/test/org/antlr/v4/test/tool/TestParserExec.java
@@ -0,0 +1,180 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2012 Terence Parr
+ *  Copyright (c) 2012 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.
+ */
+
+package org.antlr.v4.test.tool;
+
+import org.antlr.v4.test.runtime.java.BaseTest;
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+/** Test parser execution.
+ *
+ *  For the non-greedy stuff, the rule is that .* or any other non-greedy loop
+ *  (any + or * loop that has an alternative with '.' in it is automatically
+ *  non-greedy) never sees past the end of the rule containing that loop.
+ *  There is no automatic way to detect when the exit branch of a non-greedy
+ *  loop has seen enough input to determine how much the loop should consume
+ *  yet still allow matching the entire input. Of course, this is extremely
+ *  inefficient, particularly for things like
+ *
+ *     block : '{' (block|.)* '}' ;
+ *
+ *  that need only see one symbol to know when it hits a '}'. So, I
+ *  came up with a practical solution.  During prediction, the ATN
+ *  simulator never fall off the end of a rule to compute the global
+ *  FOLLOW. Instead, we terminate the loop, choosing the exit branch.
+ *  Otherwise, we predict to reenter the loop.  For example, input
+ *  "{ foo }" will allow the loop to match foo, but that's it. During
+ *  prediction, the ATN simulator will see that '}' reaches the end of a
+ *  rule that contains a non-greedy loop and stop prediction. It will choose
+ *  the exit branch of the inner loop. So, the way in which you construct
+ *  the rule containing a non-greedy loop dictates how far it will scan ahead.
+ *  Include everything after the non-greedy loop that you know it must scan
+ *  in order to properly make a prediction decision. these beasts are tricky,
+ *  so be careful. don't liberally sprinkle them around your code.
+ *
+ *  To simulate filter mode, use ( .* (pattern1|pattern2|...) )*
+ *
+ *  Nongreedy loops match as much input as possible while still allowing
+ *  the remaining input to match.
+ */
+public class TestParserExec extends BaseTest {
+
+
+	/**
+	 * This is a regression test for antlr/antlr4#118.
+	 * https://github.com/antlr/antlr4/issues/118
+	 */
+	@Ignore("Performance impact of passing this test may not be worthwhile")
+	// TODO: port to test framework (not ported because test currently fails)
+	@Test public void testStartRuleWithoutEOF() {
+		String grammar =
+			"grammar T;\n"+
+			"s @after {dumpDFA();}\n" +
+			"  : ID | ID INT ID ;\n" +
+			"ID : 'a'..'z'+ ;\n"+
+			"INT : '0'..'9'+ ;\n"+
+			"WS : (' '|'\\t'|'\\n')+ -> skip ;\n";
+		String result = execParser("T.g4", grammar, "TParser", "TLexer", "s",
+								   "abc 34", true);
+		String expecting =
+			"Decision 0:\n" +
+			"s0-ID->s1\n" +
+			"s1-INT->s2\n" +
+			"s2-EOF->:s3=>1\n"; // Must point at accept state
+		assertEquals(expecting, result);
+		assertNull(this.stderrDuringParse);
+	}
+
+	/**
+	 * This is a regression test for antlr/antlr4#588 "ClassCastException during
+	 * semantic predicate handling".
+	 * https://github.com/antlr/antlr4/issues/588
+	 */
+	// TODO: port to test framework (can we simplify the Psl grammar?)
+	@Test public void testFailedPredicateExceptionState() throws Exception {
+		String grammar = load("Psl.g4", "UTF-8");
+		String found = execParser("Psl.g4", grammar, "PslParser", "PslLexer", "floating_constant", " . 234", false);
+		assertEquals("", found);
+		assertEquals("line 1:6 rule floating_constant DEC:A floating-point constant cannot have internal white space\n", stderrDuringParse);
+	}
+
+	/**
+	 * This is a regression test for antlr/antlr4#563 "Inconsistent token
+	 * handling in ANTLR4".
+	 * https://github.com/antlr/antlr4/issues/563
+	 */
+	// TODO: port to test framework (missing templates)
+	@Test public void testAlternateQuotes() throws Exception {
+		String lexerGrammar =
+			"lexer grammar ModeTagsLexer;\n" +
+			"\n" +
+			"// Default mode rules (the SEA)\n" +
+			"OPEN  : '«'     -> mode(ISLAND) ;       // switch to ISLAND mode\n" +
+			"TEXT  : ~'«'+ ;                         // clump all text together\n" +
+			"\n" +
+			"mode ISLAND;\n" +
+			"CLOSE : '»'     -> mode(DEFAULT_MODE) ; // back to SEA mode \n" +
+			"SLASH : '/' ;\n" +
+			"ID    : [a-zA-Z]+ ;                     // match/send ID in tag to parser\n";
+		String parserGrammar =
+			"parser grammar ModeTagsParser;\n" +
+			"\n" +
+			"options { tokenVocab=ModeTagsLexer; } // use tokens from ModeTagsLexer.g4\n" +
+			"\n" +
+			"file: (tag | TEXT)* ;\n" +
+			"\n" +
+			"tag : '«' ID '»'\n" +
+			"    | '«' '/' ID '»'\n" +
+			"    ;";
+
+		boolean success = rawGenerateAndBuildRecognizer("ModeTagsLexer.g4",
+														lexerGrammar,
+														null,
+														"ModeTagsLexer");
+		assertTrue(success);
+
+		String found = execParser("ModeTagsParser.g4", parserGrammar, "ModeTagsParser", "ModeTagsLexer", "file", "", false);
+		assertEquals("", found);
+		assertNull(stderrDuringParse);
+	}
+
+	/**
+	 * This is a regression test for antlr/antlr4#672 "Initialization failed in
+	 * locals".
+	 * https://github.com/antlr/antlr4/issues/672
+	 */
+	// TODO: port to test framework (missing templates)
+	@Test public void testAttributeValueInitialization() throws Exception {
+		String grammar =
+			"grammar Data; \n" +
+			"\n" +
+			"file : group+ EOF; \n" +
+			"\n" +
+			"group: INT sequence {System.out.println($sequence.values.size());} ; \n" +
+			"\n" +
+			"sequence returns [List<Integer> values = new ArrayList<Integer>()] \n" +
+			"  locals[List<Integer> localValues = new ArrayList<Integer>()]\n" +
+			"         : (INT {$localValues.add($INT.int);})* {$values.addAll($localValues);}\n" +
+			"; \n" +
+			"\n" +
+			"INT : [0-9]+ ; // match integers \n" +
+			"WS : [ \\t\\n\\r]+ -> skip ; // toss out all whitespace\n";
+
+		String input = "2 9 10 3 1 2 3";
+		String found = execParser("Data.g4", grammar, "DataParser", "DataLexer", "file", input, false);
+		assertEquals("6\n", found);
+		assertNull(stderrDuringParse);
+	}
+}
diff --git a/tool/test/org/antlr/v4/test/TestParserInterpreter.java b/tool-testsuite/test/org/antlr/v4/test/tool/TestParserInterpreter.java
similarity index 54%
rename from tool/test/org/antlr/v4/test/TestParserInterpreter.java
rename to tool-testsuite/test/org/antlr/v4/test/tool/TestParserInterpreter.java
index 88d3ce6c3..04abbccef 100644
--- a/tool/test/org/antlr/v4/test/TestParserInterpreter.java
+++ b/tool-testsuite/test/org/antlr/v4/test/tool/TestParserInterpreter.java
@@ -28,13 +28,14 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-package org.antlr.v4.test;
+package org.antlr.v4.test.tool;
 
 import org.antlr.v4.runtime.ANTLRInputStream;
 import org.antlr.v4.runtime.CommonTokenStream;
 import org.antlr.v4.runtime.LexerInterpreter;
 import org.antlr.v4.runtime.ParserInterpreter;
 import org.antlr.v4.runtime.tree.ParseTree;
+import org.antlr.v4.test.runtime.java.BaseTest;
 import org.antlr.v4.tool.Grammar;
 import org.antlr.v4.tool.LexerGrammar;
 import org.junit.Test;
@@ -43,6 +44,19 @@ import static org.junit.Assert.assertEquals;
 
 
 public class TestParserInterpreter extends BaseTest {
+	@Test public void testEmptyStartRule() throws Exception {
+		LexerGrammar lg = new LexerGrammar(
+			"lexer grammar L;\n" +
+			"A : 'a' ;\n");
+		Grammar g = new Grammar(
+			"parser grammar T;\n" +
+			"s :  ;",
+			lg);
+
+		testInterp(lg, g, "s", "", "s");
+		testInterp(lg, g, "s", "a", "s");
+	}
+
 	@Test public void testA() throws Exception {
 		LexerGrammar lg = new LexerGrammar(
 			"lexer grammar L;\n" +
@@ -52,7 +66,120 @@ public class TestParserInterpreter extends BaseTest {
 			"s : A ;",
 			lg);
 
-		testInterp(lg, g, "s", "a", "(s a)");
+		ParseTree t = testInterp(lg, g, "s", "a", "(s a)");
+		assertEquals("0..0", t.getSourceInterval().toString());
+	}
+
+	@Test public void testEOF() throws Exception {
+		LexerGrammar lg = new LexerGrammar(
+			"lexer grammar L;\n" +
+			"A : 'a' ;\n");
+		Grammar g = new Grammar(
+			"parser grammar T;\n" +
+			"s : A EOF ;",
+			lg);
+
+		ParseTree t = testInterp(lg, g, "s", "a", "(s a <EOF>)");
+		assertEquals("0..1", t.getSourceInterval().toString());
+	}
+
+	@Test public void testEOFInChild() throws Exception {
+		LexerGrammar lg = new LexerGrammar(
+			"lexer grammar L;\n" +
+			"A : 'a' ;\n");
+		Grammar g = new Grammar(
+			"parser grammar T;\n" +
+			"s : x ;\n" +
+			"x : A EOF ;",
+			lg);
+
+		ParseTree t = testInterp(lg, g, "s", "a", "(s (x a <EOF>))");
+		assertEquals("0..1", t.getSourceInterval().toString());
+		assertEquals("0..1", t.getChild(0).getSourceInterval().toString());
+	}
+
+	@Test public void testEmptyRuleAfterEOFInChild() throws Exception {
+		LexerGrammar lg = new LexerGrammar(
+			"lexer grammar L;\n" +
+			"A : 'a' ;\n");
+		Grammar g = new Grammar(
+			"parser grammar T;\n" +
+			"s : x y;\n" +
+			"x : A EOF ;\n" +
+			"y : ;",
+			lg);
+
+		ParseTree t = testInterp(lg, g, "s", "a", "(s (x a <EOF>) y)");
+		assertEquals("0..1", t.getSourceInterval().toString()); // s
+		assertEquals("0..1", t.getChild(0).getSourceInterval().toString()); // x
+// unspecified		assertEquals("1..0", t.getChild(1).getSourceInterval().toString()); // y
+	}
+
+	@Test public void testEmptyRuleAfterJustEOFInChild() throws Exception {
+		LexerGrammar lg = new LexerGrammar(
+			"lexer grammar L;\n" +
+			"A : 'a' ;\n");
+		Grammar g = new Grammar(
+			"parser grammar T;\n" +
+			"s : x y;\n" +
+			"x : EOF ;\n" +
+			"y : ;",
+			lg);
+
+		ParseTree t = testInterp(lg, g, "s", "", "(s (x <EOF>) y)");
+		assertEquals("0..0", t.getSourceInterval().toString()); // s
+		assertEquals("0..0", t.getChild(0).getSourceInterval().toString()); // x
+		// this next one is a weird special case where somebody tries to match beyond in the file
+// unspecified		assertEquals("0..-1", t.getChild(1).getSourceInterval().toString()); // y
+	}
+
+	@Test public void testEmptyInput() throws Exception {
+		LexerGrammar lg = new LexerGrammar(
+			"lexer grammar L;\n" +
+			"A : 'a' ;\n");
+		Grammar g = new Grammar(
+			"parser grammar T;\n" +
+			"s : x EOF ;\n" +
+			"x : ;\n",
+			lg);
+
+		ParseTree t = testInterp(lg, g, "s", "", "(s x <EOF>)");
+		assertEquals("0..0", t.getSourceInterval().toString()); // s
+		assertEquals("0..-1", t.getChild(0).getSourceInterval().toString()); // x
+	}
+
+	@Test public void testEmptyInputWithCallsAfter() throws Exception {
+		LexerGrammar lg = new LexerGrammar(
+			"lexer grammar L;\n" +
+			"A : 'a' ;\n");
+		Grammar g = new Grammar(
+			"parser grammar T;\n" +
+			"s : x y ;\n" +
+			"x : EOF ;\n" +
+			"y : z ;\n" +
+			"z : ;",
+			lg);
+
+		ParseTree t = testInterp(lg, g, "s", "", "(s (x <EOF>) (y z))");
+		assertEquals("0..0", t.getSourceInterval().toString()); // s
+		assertEquals("0..0", t.getChild(0).getSourceInterval().toString()); // x
+// unspecified		assertEquals("0..-1", t.getChild(1).getSourceInterval().toString()); // x
+	}
+
+	@Test public void testEmptyFirstRule() throws Exception {
+		LexerGrammar lg = new LexerGrammar(
+			"lexer grammar L;\n" +
+			"A : 'a' ;\n");
+		Grammar g = new Grammar(
+			"parser grammar T;\n" +
+			"s : x A ;\n" +
+			"x : ;\n",
+			lg);
+
+		ParseTree t = testInterp(lg, g, "s", "a", "(s x a)");
+		assertEquals("0..0", t.getSourceInterval().toString()); // s
+		// This gets an empty interval because the stop token is null for x
+		assertEquals("0..-1", t.getChild(0).getSourceInterval().toString()); // x
 	}
 
 	@Test public void testAorB() throws Exception {
@@ -192,15 +319,45 @@ public class TestParserInterpreter extends BaseTest {
 		testInterp(lg, g, "s", "a+a*a", "(s (e (e a) + (e (e a) * (e a))))");
 	}
 
-	void testInterp(LexerGrammar lg, Grammar g,
+	/**
+	 * This is a regression test for antlr/antlr4#461.
+	 * https://github.com/antlr/antlr4/issues/461
+	 */
+	@Test public void testLeftRecursiveStartRule() throws Exception {
+		LexerGrammar lg = new LexerGrammar(
+			"lexer grammar L;\n" +
+			"A : 'a' ;\n" +
+			"B : 'b' ;\n" +
+			"C : 'c' ;\n" +
+			"PLUS : '+' ;\n" +
+			"MULT : '*' ;\n");
+		Grammar g = new Grammar(
+			"parser grammar T;\n" +
+			"s : e ;\n" +
+			"e : e MULT e\n" +
+			"  | e PLUS e\n" +
+			"  | A\n" +
+			"  ;\n",
+			lg);
+
+		testInterp(lg, g, "e", "a", 	"(e a)");
+		testInterp(lg, g, "e", "a+a", 	"(e (e a) + (e a))");
+		testInterp(lg, g, "e", "a*a", 	"(e (e a) * (e a))");
+		testInterp(lg, g, "e", "a+a+a", "(e (e (e a) + (e a)) + (e a))");
+		testInterp(lg, g, "e", "a*a+a", "(e (e (e a) * (e a)) + (e a))");
+		testInterp(lg, g, "e", "a+a*a", "(e (e a) + (e (e a) * (e a)))");
+	}
+
+	ParseTree testInterp(LexerGrammar lg, Grammar g,
 					String startRule, String input,
-					String parseTree)
+					String expectedParseTree)
 	{
 		LexerInterpreter lexEngine = lg.createLexerInterpreter(new ANTLRInputStream(input));
 		CommonTokenStream tokens = new CommonTokenStream(lexEngine);
 		ParserInterpreter parser = g.createParserInterpreter(tokens);
 		ParseTree t = parser.parse(g.rules.get(startRule).index);
 		System.out.println("parse tree: "+t.toStringTree(parser));
-		assertEquals(parseTree, t.toStringTree(parser));
+		assertEquals(expectedParseTree, t.toStringTree(parser));
+		return t;
 	}
 }
diff --git a/tool-testsuite/test/org/antlr/v4/test/tool/TestParserProfiler.java b/tool-testsuite/test/org/antlr/v4/test/tool/TestParserProfiler.java
new file mode 100644
index 000000000..f1b01600e
--- /dev/null
+++ b/tool-testsuite/test/org/antlr/v4/test/tool/TestParserProfiler.java
@@ -0,0 +1,282 @@
+/*
+ * [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.
+ */
+
+package org.antlr.v4.test.tool;
+
+import org.antlr.v4.runtime.ANTLRInputStream;
+import org.antlr.v4.runtime.CommonTokenStream;
+import org.antlr.v4.runtime.LexerInterpreter;
+import org.antlr.v4.runtime.ParserInterpreter;
+import org.antlr.v4.runtime.ParserRuleContext;
+import org.antlr.v4.runtime.atn.DecisionInfo;
+import org.antlr.v4.test.runtime.java.BaseTest;
+import org.antlr.v4.tool.Grammar;
+import org.antlr.v4.tool.LexerGrammar;
+import org.antlr.v4.tool.Rule;
+import org.junit.Ignore;
+import org.junit.Test;
+
+import java.util.Arrays;
+
+import static org.junit.Assert.assertEquals;
+
+@SuppressWarnings("unused")
+public class TestParserProfiler extends BaseTest {
+	LexerGrammar lg;
+
+	@Override
+	public void setUp() throws Exception {
+		super.setUp();
+		lg = new LexerGrammar(
+				"lexer grammar L;\n" +
+				"WS : [ \\r\\t\\n]+ -> channel(HIDDEN) ;\n" +
+				"SEMI : ';' ;\n" +
+				"DOT : '.' ;\n" +
+				"ID : [a-zA-Z]+ ;\n" +
+				"INT : [0-9]+ ;\n" +
+				"PLUS : '+' ;\n" +
+				"MULT : '*' ;\n");
+	}
+
+	@Test public void testLL1() throws Exception {
+		Grammar g = new Grammar(
+				"parser grammar T;\n" +
+				"s : ';'{}\n" +
+				"  | '.'\n" +
+				"  ;\n",
+				lg);
+
+		DecisionInfo[] info = interpAndGetDecisionInfo(lg, g, "s", ";");
+		assertEquals(1, info.length);
+		String expecting =
+				"{decision=0, contextSensitivities=0, errors=0, ambiguities=0, SLL_lookahead=1, " +
+				"SLL_ATNTransitions=1, SLL_DFATransitions=0, LL_Fallback=0, LL_lookahead=0, LL_ATNTransitions=0}";
+		assertEquals(expecting, info[0].toString());
+	}
+
+	@Test public void testLL2() throws Exception {
+		Grammar g = new Grammar(
+				"parser grammar T;\n" +
+				"s : ID ';'{}\n" +
+				"  | ID '.'\n" +
+				"  ;\n",
+				lg);
+
+		DecisionInfo[] info = interpAndGetDecisionInfo(lg, g, "s", "xyz;");
+		assertEquals(1, info.length);
+		String expecting =
+				"{decision=0, contextSensitivities=0, errors=0, ambiguities=0, SLL_lookahead=2, " +
+				"SLL_ATNTransitions=2, SLL_DFATransitions=0, LL_Fallback=0, LL_lookahead=0, LL_ATNTransitions=0}";
+		assertEquals(expecting, info[0].toString());
+	}
+
+	@Test public void testRepeatedLL2() throws Exception {
+		Grammar g = new Grammar(
+				"parser grammar T;\n" +
+				"s : ID ';'{}\n" +
+				"  | ID '.'\n" +
+				"  ;\n",
+				lg);
+
+		DecisionInfo[] info = interpAndGetDecisionInfo(lg, g, "s", "xyz;", "abc;");
+		assertEquals(1, info.length);
+		String expecting =
+				"{decision=0, contextSensitivities=0, errors=0, ambiguities=0, SLL_lookahead=4, " +
+				"SLL_ATNTransitions=2, SLL_DFATransitions=2, LL_Fallback=0, LL_lookahead=0, LL_ATNTransitions=0}";
+		assertEquals(expecting, info[0].toString());
+	}
+
+	@Test public void test3xLL2() throws Exception {
+		Grammar g = new Grammar(
+				"parser grammar T;\n" +
+				"s : ID ';'{}\n" +
+				"  | ID '.'\n" +
+				"  ;\n",
+				lg);
+
+		// The '.' vs ';' causes another ATN transition
+		DecisionInfo[] info = interpAndGetDecisionInfo(lg, g, "s", "xyz;", "abc;", "z.");
+		assertEquals(1, info.length);
+		String expecting =
+				"{decision=0, contextSensitivities=0, errors=0, ambiguities=0, SLL_lookahead=6, " +
+				"SLL_ATNTransitions=3, SLL_DFATransitions=3, LL_Fallback=0, LL_lookahead=0, LL_ATNTransitions=0}";
+		assertEquals(expecting, info[0].toString());
+	}
+
+	@Test public void testOptional() throws Exception {
+		Grammar g = new Grammar(
+				"parser grammar T;\n" +
+				"s : ID ('.' ID)? ';'\n" +
+				"  | ID INT \n" +
+				"  ;\n",
+				lg);
+
+		DecisionInfo[] info = interpAndGetDecisionInfo(lg, g, "s", "a.b;");
+		assertEquals(2, info.length);
+		String expecting =
+			"[{decision=0, contextSensitivities=0, errors=0, ambiguities=0, SLL_lookahead=1, " +
+			  "SLL_ATNTransitions=1, SLL_DFATransitions=0, LL_Fallback=0, LL_lookahead=0, LL_ATNTransitions=0}, " +
+			 "{decision=1, contextSensitivities=0, errors=0, ambiguities=0, SLL_lookahead=2, " +
+			  "SLL_ATNTransitions=2, SLL_DFATransitions=0, LL_Fallback=0, LL_lookahead=0, LL_ATNTransitions=0}]";
+		assertEquals(expecting, Arrays.toString(info));
+	}
+
+	@Test public void test2xOptional() throws Exception {
+		Grammar g = new Grammar(
+				"parser grammar T;\n" +
+				"s : ID ('.' ID)? ';'\n" +
+				"  | ID INT \n" +
+				"  ;\n",
+				lg);
+
+		DecisionInfo[] info = interpAndGetDecisionInfo(lg, g, "s", "a.b;", "a.b;");
+		assertEquals(2, info.length);
+		String expecting =
+			"[{decision=0, contextSensitivities=0, errors=0, ambiguities=0, SLL_lookahead=2, " +
+			  "SLL_ATNTransitions=1, SLL_DFATransitions=1, LL_Fallback=0, LL_lookahead=0, LL_ATNTransitions=0}, " +
+			 "{decision=1, contextSensitivities=0, errors=0, ambiguities=0, SLL_lookahead=4, " +
+			  "SLL_ATNTransitions=2, SLL_DFATransitions=2, LL_Fallback=0, LL_lookahead=0, LL_ATNTransitions=0}]";
+		assertEquals(expecting, Arrays.toString(info));
+	}
+
+	@Test public void testContextSensitivity() throws Exception {
+		Grammar g = new Grammar(
+			"parser grammar T;\n"+
+			"a : '.' e ID \n" +
+			"  | ';' e INT ID ;\n" +
+			"e : INT | ;\n",
+			lg);
+		DecisionInfo[] info = interpAndGetDecisionInfo(lg, g, "a", "; 1 x");
+		assertEquals(2, info.length);
+		String expecting =
+			"{decision=1, contextSensitivities=1, errors=0, ambiguities=0, SLL_lookahead=3, SLL_ATNTransitions=2, SLL_DFATransitions=0, LL_Fallback=1, LL_lookahead=3, LL_ATNTransitions=2}";
+		assertEquals(expecting, info[1].toString());
+	}
+
+	@Ignore
+	@Test public void testSimpleLanguage() throws Exception {
+		Grammar g = new Grammar(TestXPath.grammar);
+		String input =
+			"def f(x,y) { x = 3+4*1*1/5*1*1+1*1+1; y; ; }\n" +
+			"def g(x,a,b,c,d,e) { return 1+2*x; }\n"+
+			"def h(x) { a=3; x=0+1; return a*x; }\n";
+		DecisionInfo[] info = interpAndGetDecisionInfo(g.getImplicitLexer(), g, "prog", input);
+		String expecting =
+			"[{decision=0, contextSensitivities=1, errors=0, ambiguities=0, SLL_lookahead=3, " +
+			"SLL_ATNTransitions=2, SLL_DFATransitions=0, LL_Fallback=1, LL_ATNTransitions=1}]";
+
+
+		assertEquals(expecting, Arrays.toString(info));
+		assertEquals(1, info.length);
+	}
+
+	@Ignore
+	@Test public void testDeepLookahead() throws Exception {
+		Grammar g = new Grammar(
+				"parser grammar T;\n" +
+				"s : e ';'\n" +
+				"  | e '.' \n" +
+				"  ;\n" +
+				"e : (ID|INT) ({true}? '+' e)*\n" +       // d=1 entry, d=2 bypass
+				"  ;\n",
+				lg);
+
+		// pred forces to
+		// ambig and ('+' e)* tail recursion forces lookahead to fall out of e
+		// any non-precedence predicates are always evaluated as true by the interpreter
+		DecisionInfo[] info = interpAndGetDecisionInfo(lg, g, "s", "a+b+c;");
+		// at "+b" it uses k=1 and enters loop then calls e for b...
+		// e matches and d=2 uses "+c;" for k=3
+		assertEquals(2, info.length);
+		String expecting =
+			"[{decision=0, contextSensitivities=0, errors=0, ambiguities=0, SLL_lookahead=6, " +
+			  "SLL_ATNTransitions=6, SLL_DFATransitions=0, LL_Fallback=0, LL_lookahead=0, LL_ATNTransitions=0}, " +
+			 "{decision=1, contextSensitivities=0, errors=0, ambiguities=0, SLL_lookahead=4, " +
+			  "SLL_ATNTransitions=2, SLL_DFATransitions=2, LL_Fallback=0, LL_lookahead=0, LL_ATNTransitions=0}]";
+		assertEquals(expecting, Arrays.toString(info));
+	}
+
+	@Test public void testProfilerGeneratedCode() throws Exception {
+		String grammar =
+			"grammar T;\n" +
+			"s : a+ ID EOF ;\n" +
+			"a : ID ';'{}\n" +
+			"  | ID '.'\n" +
+			"  ;\n"+
+			"WS : [ \\r\\t\\n]+ -> channel(HIDDEN) ;\n" +
+			"SEMI : ';' ;\n" +
+			"DOT : '.' ;\n" +
+			"ID : [a-zA-Z]+ ;\n" +
+			"INT : [0-9]+ ;\n" +
+			"PLUS : '+' ;\n" +
+			"MULT : '*' ;\n";
+
+		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s",
+								  "xyz;abc;z.q", false, true);
+		String expecting =
+			"[{decision=0, contextSensitivities=0, errors=0, ambiguities=0, SLL_lookahead=6, SLL_ATNTransitions=4, " +
+			"SLL_DFATransitions=2, LL_Fallback=0, LL_lookahead=0, LL_ATNTransitions=0}," +
+			" {decision=1, contextSensitivities=0, errors=0, ambiguities=0, SLL_lookahead=6, " +
+			"SLL_ATNTransitions=3, SLL_DFATransitions=3, LL_Fallback=0, LL_lookahead=0, LL_ATNTransitions=0}]\n";
+		assertEquals(expecting, found);
+		assertEquals(null, stderrDuringParse);
+	}
+
+	public DecisionInfo[] interpAndGetDecisionInfo(
+			LexerGrammar lg, Grammar g,
+			String startRule, String... input)
+	{
+
+		LexerInterpreter lexEngine = lg.createLexerInterpreter(null);
+		ParserInterpreter parser = g.createParserInterpreter(null);
+		parser.setProfile(true);
+		for (String s : input) {
+			lexEngine.reset();
+			parser.reset();
+			lexEngine.setInputStream(new ANTLRInputStream(s));
+			CommonTokenStream tokens = new CommonTokenStream(lexEngine);
+			parser.setInputStream(tokens);
+			Rule r = g.rules.get(startRule);
+			if ( r==null ) {
+				return parser.getParseInfo().getDecisionInfo();
+			}
+			ParserRuleContext t = parser.parse(r.index);
+//			try {
+//				Utils.waitForClose(t.inspect(parser).get());
+//			}
+//			catch (Exception e) {
+//				e.printStackTrace();
+//			}
+//
+//			System.out.println(t.toStringTree(parser));
+		}
+		return parser.getParseInfo().getDecisionInfo();
+	}
+}
diff --git a/tool/test/org/antlr/v4/test/TestPerformance.java b/tool-testsuite/test/org/antlr/v4/test/tool/TestPerformance.java
similarity index 95%
rename from tool/test/org/antlr/v4/test/TestPerformance.java
rename to tool-testsuite/test/org/antlr/v4/test/tool/TestPerformance.java
index 512122127..990cac617 100644
--- a/tool/test/org/antlr/v4/test/TestPerformance.java
+++ b/tool-testsuite/test/org/antlr/v4/test/tool/TestPerformance.java
@@ -28,7 +28,7 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-package org.antlr.v4.test;
+package org.antlr.v4.test.tool;
 
 import org.antlr.v4.runtime.ANTLRFileStream;
 import org.antlr.v4.runtime.ANTLRInputStream;
@@ -57,22 +57,20 @@ import org.antlr.v4.runtime.atn.PredictionMode;
 import org.antlr.v4.runtime.dfa.DFA;
 import org.antlr.v4.runtime.dfa.DFAState;
 import org.antlr.v4.runtime.misc.Interval;
-import org.antlr.v4.runtime.misc.NotNull;
-import org.antlr.v4.runtime.misc.Nullable;
 import org.antlr.v4.runtime.misc.ParseCancellationException;
 import org.antlr.v4.runtime.tree.ErrorNode;
 import org.antlr.v4.runtime.tree.ParseTree;
 import org.antlr.v4.runtime.tree.ParseTreeListener;
 import org.antlr.v4.runtime.tree.ParseTreeWalker;
 import org.antlr.v4.runtime.tree.TerminalNode;
+import org.antlr.v4.test.runtime.java.BaseTest;
+import org.antlr.v4.test.runtime.java.ErrorQueue;
 import org.junit.Assert;
 import org.junit.Test;
 
 import java.io.File;
 import java.io.FilenameFilter;
 import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
 import java.lang.ref.Reference;
 import java.lang.ref.SoftReference;
 import java.lang.ref.WeakReference;
@@ -108,6 +106,7 @@ import static org.hamcrest.CoreMatchers.instanceOf;
 import static org.junit.Assert.assertThat;
 import static org.junit.Assert.assertTrue;
 
+@SuppressWarnings("unused")
 public class TestPerformance extends BaseTest {
     /**
      * Parse all java files under this package within the JDK_SOURCE_ROOT
@@ -154,7 +153,7 @@ public class TestPerformance extends BaseTest {
 
     /**
      * {@code true} to use the Java grammar with expressions in the v4
-     * left-recursive syntax (Java-LR.g4). {@code false} to use the standard
+     * left-recursive syntax (JavaLR.g4). {@code false} to use the standard
      * grammar (Java.g4). In either case, the grammar is renamed in the
      * temporary directory to Java.g4 before compiling.
      */
@@ -291,6 +290,12 @@ public class TestPerformance extends BaseTest {
 	 */
 	private static final boolean TIME_PARSE_ONLY = false;
 
+	/**
+	 * When {@code true}, messages will be printed to {@link System#err} when
+	 * the first stage (SLL) parsing resulted in a syntax error. This option is
+	 * ignored when {@link #TWO_STAGE_PARSING} is {@code false}.
+	 */
+	private static final boolean REPORT_SECOND_STAGE_RETRY = true;
 	private static final boolean REPORT_SYNTAX_ERRORS = true;
 	private static final boolean REPORT_AMBIGUITIES = false;
 	private static final boolean REPORT_FULL_CONTEXT = false;
@@ -404,16 +409,16 @@ public class TestPerformance extends BaseTest {
     private final AtomicIntegerArray tokenCount = new AtomicIntegerArray(PASSES);
 
     @Test
-    //@org.junit.Ignore
+    @org.junit.Ignore
     public void compileJdk() throws IOException, InterruptedException, ExecutionException {
         String jdkSourceRoot = getSourceRoot("JDK");
 		assertTrue("The JDK_SOURCE_ROOT environment variable must be set for performance testing.", jdkSourceRoot != null && !jdkSourceRoot.isEmpty());
 
         compileJavaParser(USE_LR_GRAMMAR);
-		final String lexerName = "JavaLexer";
-		final String parserName = "JavaParser";
-		final String listenerName = "JavaBaseListener";
-		final String entryPoint = "compilationUnit";
+        final String lexerName    = USE_LR_GRAMMAR ? "JavaLRLexer"        : "JavaLexer";
+        final String parserName   = USE_LR_GRAMMAR ? "JavaLRParser"       : "JavaParser";
+        final String listenerName = USE_LR_GRAMMAR ? "JavaLRBaseListener" : "JavaBaseListener";
+        final String entryPoint = "compilationUnit";
         final ParserFactory factory = getParserFactory(lexerName, parserName, listenerName, entryPoint);
 
 		if (!TOP_PACKAGE.isEmpty()) {
@@ -785,7 +790,6 @@ public class TestPerformance extends BaseTest {
 
     int configOutputSize = 0;
 
-    @SuppressWarnings("unused")
 	protected void parseSources(final int currentPass, final ParserFactory factory, Collection<InputDescriptor> sources, boolean shuffleSources) throws InterruptedException {
 		if (shuffleSources) {
 			List<InputDescriptor> sourcesList = new ArrayList<InputDescriptor>(sources);
@@ -877,12 +881,12 @@ public class TestPerformance extends BaseTest {
 		executorService.shutdown();
 		executorService.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS);
 
-        System.out.format("%d. Total parse time for %d files (%d KB, %d tokens, checksum 0x%8X): %.0fms%n",
+        System.out.format("%d. Total parse time for %d files (%d KB, %d tokens%s): %.0fms%n",
 						  currentPass + 1,
                           inputCount,
                           inputSize / 1024,
                           tokenCount.get(currentPass),
-						  COMPUTE_CHECKSUM ? checksum.getValue() : 0,
+						  COMPUTE_CHECKSUM ? String.format(", checksum 0x%8X", checksum.getValue()) : "",
                           (double)(System.nanoTime() - startTime) / 1000000.0);
 
 		if (sharedLexers.length > 0) {
@@ -1104,9 +1108,10 @@ public class TestPerformance extends BaseTest {
 	}
 
     protected void compileJavaParser(boolean leftRecursive) throws IOException {
-        String grammarFileName = "Java.g4";
-        String sourceName = leftRecursive ? "Java-LR.g4" : "Java.g4";
-        String body = load(sourceName, null);
+        String grammarFileName = leftRecursive ? "JavaLR.g4"    : "Java.g4";
+        String parserName      = leftRecursive ? "JavaLRParser" : "JavaParser";
+        String lexerName       = leftRecursive ? "JavaLRLexer"  : "JavaLexer";
+        String body = load(grammarFileName, null);
         List<String> extraOptions = new ArrayList<String>();
 		extraOptions.add("-Werror");
         if (FORCE_ATN) {
@@ -1123,37 +1128,10 @@ public class TestPerformance extends BaseTest {
 		}
 		extraOptions.add("-visitor");
         String[] extraOptionsArray = extraOptions.toArray(new String[extraOptions.size()]);
-        boolean success = rawGenerateAndBuildRecognizer(grammarFileName, body, "JavaParser", "JavaLexer", true, extraOptionsArray);
+        boolean success = rawGenerateAndBuildRecognizer(grammarFileName, body, parserName, lexerName, true, extraOptionsArray);
         assertTrue(success);
     }
 
-    protected String load(String fileName, @Nullable String encoding)
-        throws IOException
-    {
-        if ( fileName==null ) {
-            return null;
-        }
-
-        String fullFileName = getClass().getPackage().getName().replace('.', '/') + '/' + fileName;
-        int size = 65000;
-        InputStreamReader isr;
-        InputStream fis = getClass().getClassLoader().getResourceAsStream(fullFileName);
-        if ( encoding!=null ) {
-            isr = new InputStreamReader(fis, encoding);
-        }
-        else {
-            isr = new InputStreamReader(fis);
-        }
-        try {
-            char[] data = new char[size];
-            int n = isr.read(data);
-            return new String(data, 0, n);
-        }
-        finally {
-            isr.close();
-        }
-    }
-
 	private static void updateChecksum(Checksum checksum, int value) {
 		checksum.update((value) & 0xFF);
 		checksum.update((value >>> 8) & 0xFF);
@@ -1190,6 +1168,7 @@ public class TestPerformance extends BaseTest {
             parserCtor.newInstance(new CommonTokenStream(tokenSource));
 
             return new ParserFactory() {
+
 				@Override
                 public FileParseResult parseFile(CharStream input, int currentPass, int thread) {
 					final Checksum checksum = new CRC32();
@@ -1257,7 +1236,7 @@ public class TestPerformance extends BaseTest {
 
 							if (USE_PARSER_INTERPRETER) {
 								Parser referenceParser = parserCtor.newInstance(tokens);
-								parser = new ParserInterpreter(referenceParser.getGrammarFileName(), Arrays.asList(referenceParser.getTokenNames()), Arrays.asList(referenceParser.getRuleNames()), referenceParser.getATN(), tokens);
+								parser = new ParserInterpreter(referenceParser.getGrammarFileName(), referenceParser.getVocabulary(), Arrays.asList(referenceParser.getRuleNames()), referenceParser.getATN(), tokens);
 							}
 							else {
 								parser = parserCtor.newInstance(tokens);
@@ -1322,7 +1301,9 @@ public class TestPerformance extends BaseTest {
 
 							String sourceName = tokens.getSourceName();
 							sourceName = sourceName != null && !sourceName.isEmpty() ? sourceName+": " : "";
-							System.err.println(sourceName+"Forced to retry with full context.");
+							if (REPORT_SECOND_STAGE_RETRY) {
+								System.err.println(sourceName+"Forced to retry with full context.");
+							}
 
 							if (!(ex.getCause() instanceof ParseCancellationException)) {
 								throw ex;
@@ -1336,7 +1317,7 @@ public class TestPerformance extends BaseTest {
 
 								if (USE_PARSER_INTERPRETER) {
 									Parser referenceParser = parserCtor.newInstance(tokens);
-									parser = new ParserInterpreter(referenceParser.getGrammarFileName(), Arrays.asList(referenceParser.getTokenNames()), Arrays.asList(referenceParser.getRuleNames()), referenceParser.getATN(), tokens);
+									parser = new ParserInterpreter(referenceParser.getGrammarFileName(), referenceParser.getVocabulary(), Arrays.asList(referenceParser.getRuleNames()), referenceParser.getATN(), tokens);
 								}
 								else {
 									parser = parserCtor.newInstance(tokens);
@@ -1421,7 +1402,7 @@ public class TestPerformance extends BaseTest {
 		public final long[] parserComputedTransitions;
 		public final long[] parserFullContextTransitions;
 
-		public FileParseResult(String sourceName, int checksum, @Nullable ParseTree parseTree, int tokenCount, long startTime, Lexer lexer, Parser parser) {
+		public FileParseResult(String sourceName, int checksum, ParseTree parseTree, int tokenCount, long startTime, Lexer lexer, Parser parser) {
 			this.sourceName = sourceName;
 			this.checksum = checksum;
 			this.parseTree = parseTree;
@@ -1909,14 +1890,14 @@ public class TestPerformance extends BaseTest {
 		private final String source;
 		private Reference<CloneableANTLRFileStream> inputStream;
 
-		public InputDescriptor(@NotNull String source) {
+		public InputDescriptor(String source) {
 			this.source = source;
 			if (PRELOAD_SOURCES) {
 				getInputStream();
 			}
 		}
 
-		@NotNull
+
 		public synchronized CharStream getInputStream() {
 			CloneableANTLRFileStream stream = inputStream != null ? inputStream.get() : null;
 			if (stream == null) {
@@ -1963,4 +1944,36 @@ public class TestPerformance extends BaseTest {
 			return referent;
 		}
 	}
+
+	@Test(timeout = 20000)
+	public void testExponentialInclude() {
+		String grammarFormat =
+			"parser grammar Level_%d_%d;\n" +
+			"\n" +
+			"%s import Level_%d_1, Level_%d_2;\n" +
+			"\n" +
+			"rule_%d_%d : EOF;\n";
+
+		System.out.println("dir "+tmpdir);
+		mkdir(tmpdir);
+
+		long startTime = System.nanoTime();
+
+		int levels = 20;
+		for (int level = 0; level < levels; level++) {
+			String leafPrefix = level == levels - 1 ? "//" : "";
+			String grammar1 = String.format(grammarFormat, level, 1, leafPrefix, level + 1, level + 1, level, 1);
+			writeFile(tmpdir, "Level_" + level + "_1.g4", grammar1);
+			if (level > 0) {
+				String grammar2 = String.format(grammarFormat, level, 2, leafPrefix, level + 1, level + 1, level, 1);
+				writeFile(tmpdir, "Level_" + level + "_2.g4", grammar2);
+			}
+		}
+
+		ErrorQueue equeue = antlr("Level_0_1.g4", false);
+		Assert.assertTrue(equeue.errors.isEmpty());
+
+		long endTime = System.nanoTime();
+		System.out.format("%s milliseconds.%n", (endTime - startTime) / 1000000.0);
+	}
 }
diff --git a/tool/test/org/antlr/v4/test/TestScopeParsing.java b/tool-testsuite/test/org/antlr/v4/test/tool/TestScopeParsing.java
similarity index 88%
rename from tool/test/org/antlr/v4/test/TestScopeParsing.java
rename to tool-testsuite/test/org/antlr/v4/test/tool/TestScopeParsing.java
index 98fe29a75..3bcfa0682 100644
--- a/tool/test/org/antlr/v4/test/TestScopeParsing.java
+++ b/tool-testsuite/test/org/antlr/v4/test/tool/TestScopeParsing.java
@@ -28,13 +28,14 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-package org.antlr.v4.test;
+package org.antlr.v4.test.tool;
 
 import org.antlr.v4.parse.ScopeParser;
-import org.antlr.v4.tool.ErrorManager;
+import org.antlr.v4.test.runtime.java.BaseTest;
+import org.antlr.v4.tool.Grammar;
 import org.junit.Test;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
 
 public class TestScopeParsing extends BaseTest {
     String[] argPairs = {
@@ -55,11 +56,12 @@ public class TestScopeParsing extends BaseTest {
         "i,j, k",                           "{i=null i, j=null j, k=null k}",
     };
 
-    @Test public void testArgs() {
+    @Test public void testArgs() throws Exception {
         for (int i = 0; i < argPairs.length; i+=2) {
             String input = argPairs[i];
             String expected = argPairs[i+1];
-            String actual = ScopeParser.parseTypedArgList(null, input, new ErrorManager(null)).attributes.toString();
+			Grammar dummy = new Grammar("grammar T; a:'a';");
+			String actual = ScopeParser.parseTypedArgList(null, input, dummy).attributes.toString();
             assertEquals(expected, actual);
         }
     }
diff --git a/tool/test/org/antlr/v4/test/TestSymbolIssues.java b/tool-testsuite/test/org/antlr/v4/test/tool/TestSymbolIssues.java
similarity index 64%
rename from tool/test/org/antlr/v4/test/TestSymbolIssues.java
rename to tool-testsuite/test/org/antlr/v4/test/tool/TestSymbolIssues.java
index f863687ab..1c68ba30a 100644
--- a/tool/test/org/antlr/v4/test/TestSymbolIssues.java
+++ b/tool-testsuite/test/org/antlr/v4/test/tool/TestSymbolIssues.java
@@ -28,13 +28,14 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-package org.antlr.v4.test;
+package org.antlr.v4.test.tool;
 
+import org.antlr.v4.test.runtime.java.BaseTest;
 import org.antlr.v4.tool.ErrorType;
 import org.antlr.v4.tool.LexerGrammar;
 import org.junit.Test;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
 
 /** */
 public class TestSymbolIssues extends BaseTest {
@@ -54,15 +55,15 @@ public class TestSymbolIssues extends BaseTest {
         "\n" +
         "ID : 'a'..'z'+ ID ;",
         // YIELDS
-			"error(" + ErrorType.ACTION_REDEFINITION.code + "): A.g4:5:1: redefinition of 'members' action\n" +
-			"error(" + ErrorType.ACTION_REDEFINITION.code + "): A.g4:7:1: redefinition of 'header' action\n" +
-			"warning(" + ErrorType.ILLEGAL_OPTION.code + "): A.g4:2:10: unsupported option 'opt'\n" +
-			"warning(" + ErrorType.ILLEGAL_OPTION.code + "): A.g4:2:21: unsupported option 'k'\n" +
-			"error(" + ErrorType.ACTION_REDEFINITION.code + "): A.g4:5:1: redefinition of 'members' action\n" +
-			"warning(" + ErrorType.IMPLICIT_TOKEN_DEFINITION.code + "): A.g4:9:27: implicit definition of token 'X' in parser\n" +
-			"warning(" + ErrorType.IMPLICIT_TOKEN_DEFINITION.code + "): A.g4:10:20: implicit definition of token 'Y' in parser\n" +
-			"warning(" + ErrorType.IMPLICIT_TOKEN_DEFINITION.code + "): A.g4:11:4: implicit definition of token 'FJKD' in parser\n" +
-			"error(" + ErrorType.RULE_HAS_NO_ARGS.code + "): A.g4:9:37: rule 'b' has no defined parameters\n" +
+			"error(" + ErrorType.ACTION_REDEFINITION.code + "): A.g4:5:1: redefinition of members action\n" +
+			"error(" + ErrorType.ACTION_REDEFINITION.code + "): A.g4:7:1: redefinition of header action\n" +
+			"warning(" + ErrorType.ILLEGAL_OPTION.code + "): A.g4:2:10: unsupported option opt\n" +
+			"warning(" + ErrorType.ILLEGAL_OPTION.code + "): A.g4:2:21: unsupported option k\n" +
+			"error(" + ErrorType.ACTION_REDEFINITION.code + "): A.g4:5:1: redefinition of members action\n" +
+			"warning(" + ErrorType.IMPLICIT_TOKEN_DEFINITION.code + "): A.g4:9:27: implicit definition of token X in parser\n" +
+			"warning(" + ErrorType.IMPLICIT_TOKEN_DEFINITION.code + "): A.g4:10:20: implicit definition of token Y in parser\n" +
+			"warning(" + ErrorType.IMPLICIT_TOKEN_DEFINITION.code + "): A.g4:11:4: implicit definition of token FJKD in parser\n" +
+			"error(" + ErrorType.RULE_HAS_NO_ARGS.code + "): A.g4:9:37: rule b has no defined parameters\n" +
 			"error(" + ErrorType.MISSING_RULE_ARGS.code + "): A.g4:10:31: missing arguments(s) on rule reference: a\n"
     };
 
@@ -77,10 +78,10 @@ public class TestSymbolIssues extends BaseTest {
         "\n" +
         "s : FOO ;",
         // YIELDS
-		"error(" + ErrorType.LABEL_CONFLICTS_WITH_RULE.code + "): B.g4:4:4: label 's' conflicts with rule with same name\n" +
-		"error(" + ErrorType.LABEL_CONFLICTS_WITH_RULE.code + "): B.g4:4:9: label 'b' conflicts with rule with same name\n" +
-		"error(" + ErrorType.LABEL_CONFLICTS_WITH_TOKEN.code + "): B.g4:4:15: label 'X' conflicts with token with same name\n" +
-		"error(" + ErrorType.LABEL_TYPE_CONFLICT.code + "): B.g4:6:9: label 'x' type mismatch with previous definition: TOKEN_LIST_LABEL!=TOKEN_LABEL\n" +
+		"error(" + ErrorType.LABEL_CONFLICTS_WITH_RULE.code + "): B.g4:4:4: label s conflicts with rule with same name\n" +
+		"error(" + ErrorType.LABEL_CONFLICTS_WITH_RULE.code + "): B.g4:4:9: label b conflicts with rule with same name\n" +
+		"error(" + ErrorType.LABEL_CONFLICTS_WITH_TOKEN.code + "): B.g4:4:15: label X conflicts with token with same name\n" +
+		"error(" + ErrorType.LABEL_TYPE_CONFLICT.code + "): B.g4:6:9: label x type mismatch with previous definition: TOKEN_LIST_LABEL!=TOKEN_LABEL\n" +
 		"error(" + ErrorType.IMPLICIT_STRING_DEFINITION.code + "): B.g4:4:20: cannot create implicit token for string literal in non-combined grammar: '.'\n"
     };
 
@@ -97,8 +98,8 @@ public class TestSymbolIssues extends BaseTest {
         "        :       ID ;",
 
         // YIELDS
-        "error(" + ErrorType.LABEL_CONFLICTS_WITH_ARG.code + "): D.g4:4:21: label 'j' conflicts with parameter with same name\n" +
-		"error(" + ErrorType.RETVAL_CONFLICTS_WITH_ARG.code + "): D.g4:6:22: return value 'i' conflicts with parameter with same name\n"
+        "error(" + ErrorType.LABEL_CONFLICTS_WITH_ARG.code + "): D.g4:4:21: label j conflicts with parameter with same name\n" +
+		"error(" + ErrorType.RETVAL_CONFLICTS_WITH_ARG.code + "): D.g4:6:22: return value i conflicts with parameter with same name\n"
     };
 
 	static String[] E = {
@@ -112,13 +113,28 @@ public class TestSymbolIssues extends BaseTest {
 		"a : A ;\n",
 
 		// YIELDS
-		"warning(" + ErrorType.TOKEN_NAME_REASSIGNMENT.code + "): E.g4:3:4: token name 'A' is already defined\n"
+		"warning(" + ErrorType.TOKEN_NAME_REASSIGNMENT.code + "): E.g4:3:4: token name A is already defined\n"
+	};
+
+	static String[] F = {
+		// INPUT
+		"lexer grammar F;\n" +
+		"A: 'a';\n" +
+		"mode M1;\n" +
+		"A1: 'a';\n" +
+		"mode M2;\n" +
+		"A2: 'a';\n" +
+		"M1: 'b';\n",
+
+		// YIELDS
+		"error(" + ErrorType.MODE_CONFLICTS_WITH_TOKEN.code + "): F.g4:3:0: mode M1 conflicts with token with same name\n"
 	};
 
     @Test public void testA() { super.testErrors(A, false); }
     @Test public void testB() { super.testErrors(B, false); }
 	@Test public void testD() { super.testErrors(D, false); }
 	@Test public void testE() { super.testErrors(E, false); }
+	@Test public void testF() { super.testErrors(F, false); }
 
 	@Test public void testStringLiteralRedefs() throws Exception {
 		String grammar =
@@ -147,7 +163,7 @@ public class TestSymbolIssues extends BaseTest {
 			"mode X;\n" +
 			"fragment B : 'b';",
 
-			"error(" + ErrorType.MODE_WITHOUT_RULES.code + "): L.g4:3:5: lexer mode 'X' must contain at least one non-fragment rule\n"
+			"error(" + ErrorType.MODE_WITHOUT_RULES.code + "): L.g4:3:5: lexer mode X must contain at least one non-fragment rule\n"
 		};
 
 		testErrors(test, false);
@@ -162,8 +178,47 @@ public class TestSymbolIssues extends BaseTest {
 			"  B : C;\n" +
 			"  fragment C : A | (A C)?;",
 
-			"warning(" + ErrorType.EPSILON_TOKEN.code + "): L.g4:3:0: non-fragment lexer rule 'WS' can match the empty string\n" +
-			"warning(" + ErrorType.EPSILON_TOKEN.code + "): L.g4:5:2: non-fragment lexer rule 'B' can match the empty string\n"
+			"warning(" + ErrorType.EPSILON_TOKEN.code + "): L.g4:3:0: non-fragment lexer rule WS can match the empty string\n" +
+			"warning(" + ErrorType.EPSILON_TOKEN.code + "): L.g4:5:2: non-fragment lexer rule B can match the empty string\n"
+		};
+
+		testErrors(test, false);
+	}
+
+	@Test public void testTokensModesChannelsDeclarationConflictsWithReserved() throws Exception {
+		String[] test = {
+			"lexer grammar L;\n" +
+			"channels { SKIP, HIDDEN, channel0 }\n" +
+			"A: 'a';\n" +
+			"mode MAX_CHAR_VALUE;\n" +
+			"MIN_CHAR_VALUE: 'a';\n" +
+			"mode DEFAULT_MODE;\n" +
+			"B: 'b';\n" +
+			"mode M;\n" +
+			"C: 'c';",
+
+			"error(" + ErrorType.RESERVED_RULE_NAME.code + "): L.g4:5:0: cannot declare a rule with reserved name MIN_CHAR_VALUE\n" +
+			"error(" + ErrorType.MODE_CONFLICTS_WITH_COMMON_CONSTANTS.code + "): L.g4:4:0: cannot use or declare mode with reserved name MAX_CHAR_VALUE\n" +
+			"error(" + ErrorType.CHANNEL_CONFLICTS_WITH_COMMON_CONSTANTS.code + "): L.g4:2:11: cannot use or declare channel with reserved name SKIP\n" +
+			"error(" + ErrorType.CHANNEL_CONFLICTS_WITH_COMMON_CONSTANTS.code + "): L.g4:2:17: cannot use or declare channel with reserved name HIDDEN\n"
+		};
+
+		testErrors(test, false);
+	}
+
+	@Test public void testTokensModesChannelsUsingConflictsWithReserved() throws Exception {
+		String[] test = {
+			"lexer grammar L;\n" +
+			"A: 'a' -> channel(SKIP);\n" +
+			"B: 'b' -> type(MORE);\n" +
+			"C: 'c' -> mode(SKIP);\n" +
+			"D: 'd' -> channel(HIDDEN);\n" +
+			"E: 'e' -> type(EOF);\n" +
+			"F: 'f' -> pushMode(DEFAULT_MODE);",
+
+			"error(" + ErrorType.CHANNEL_CONFLICTS_WITH_COMMON_CONSTANTS.code + "): L.g4:2:18: cannot use or declare channel with reserved name SKIP\n" +
+			"error(" + ErrorType.TOKEN_CONFLICTS_WITH_COMMON_CONSTANTS.code + "): L.g4:3:15: cannot use or declare token with reserved name MORE\n" +
+			"error(" + ErrorType.MODE_CONFLICTS_WITH_COMMON_CONSTANTS.code + "): L.g4:4:15: cannot use or declare mode with reserved name SKIP\n"
 		};
 
 		testErrors(test, false);
diff --git a/tool-testsuite/test/org/antlr/v4/test/tool/TestTokenPositionOptions.java b/tool-testsuite/test/org/antlr/v4/test/tool/TestTokenPositionOptions.java
new file mode 100644
index 000000000..8a6881d49
--- /dev/null
+++ b/tool-testsuite/test/org/antlr/v4/test/tool/TestTokenPositionOptions.java
@@ -0,0 +1,180 @@
+/*
+ * [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.
+ */
+package org.antlr.v4.test.tool;
+
+import org.antlr.runtime.Token;
+import org.antlr.v4.misc.Utils;
+import org.antlr.v4.parse.ANTLRParser;
+import org.antlr.v4.runtime.misc.IntervalSet;
+import org.antlr.v4.test.runtime.java.BaseTest;
+import org.antlr.v4.tool.Grammar;
+import org.antlr.v4.tool.ast.GrammarAST;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+
+public class TestTokenPositionOptions extends BaseTest {
+	@Test public void testLeftRecursionRewrite() throws Exception {
+		Grammar g = new Grammar(
+				"grammar T;\n" +
+				"s : e ';' ;\n" +
+				"e : e '*' e\n" +
+				"  | e '+' e\n" +
+				"  | e '.' ID\n" +
+				"  | '-' e\n" +
+				"  | ID\n" +
+				"  ;\n" +
+				"ID : [a-z]+ ;\n"
+		);
+
+		String expectedTree =
+				"(COMBINED_GRAMMAR T (RULES (RULE s (BLOCK (ALT e ';'))) (RULE e (BLOCK (ALT (BLOCK (ALT {} ('-' (ELEMENT_OPTIONS (= tokenIndex 43))) (e (ELEMENT_OPTIONS (= tokenIndex 45) (= p 2)))) (ALT (ID (ELEMENT_OPTIONS (= tokenIndex 49))))) (* (BLOCK (ALT ({precpred(_ctx, 5)}? (ELEMENT_OPTIONS (= p 5))) ('*' (ELEMENT_OPTIONS (= tokenIndex 21))) (e (ELEMENT_OPTIONS (= tokenIndex 23) (= p 6)))) (ALT ({precpred(_ctx, 4)}? (ELEMENT_OPTIONS (= p 4))) ('+' (ELEMENT_OPTIONS (= tokenIndex 29))) (e (ELEMENT_OPTIONS (= tokenIndex 31) (= p 5)))) (ALT ({precpred(_ctx, 3)}? (ELEMENT_OPTIONS (= p 3))) ('.' (ELEMENT_OPTIONS (= tokenIndex 37))) (ID (ELEMENT_OPTIONS (= tokenIndex 39)))))))))))";
+		assertEquals(expectedTree, g.ast.toStringTree());
+
+		String expectedElementTokens =
+				"[@5,11:11='s',<57>,2:0]\n" +
+				"[@9,15:15='e',<57>,2:4]\n" +
+				"[@11,17:19='';'',<62>,2:6]\n" +
+				"[@15,23:23='e',<57>,3:0]\n" +
+				"[@43,64:66=''-'',<62>,6:4]\n" +
+				"[@45,68:68='e',<57>,6:8]\n" +
+				"[@49,74:75='ID',<66>,7:4]\n" +
+				"[@21,29:31=''*'',<62>,3:6]\n" +
+				"[@23,33:33='e',<57>,3:10]\n" +
+				"[@29,41:43=''+'',<62>,4:6]\n" +
+				"[@31,45:45='e',<57>,4:10]\n" +
+				"[@37,53:55=''.'',<62>,5:6]\n" +
+				"[@39,57:58='ID',<66>,5:10]";
+
+		IntervalSet types =
+				new IntervalSet(ANTLRParser.TOKEN_REF,
+				ANTLRParser.STRING_LITERAL,
+				ANTLRParser.RULE_REF);
+		List<GrammarAST> nodes = g.ast.getNodesWithTypePreorderDFS(types);
+		List<Token> tokens = new ArrayList<Token>();
+		for (GrammarAST node : nodes) {
+			tokens.add(node.getToken());
+		}
+		assertEquals(expectedElementTokens, Utils.join(tokens.toArray(), "\n"));
+	}
+
+	@Test public void testLeftRecursionWithLabels() throws Exception {
+		Grammar g = new Grammar(
+				"grammar T;\n" +
+				"s : e ';' ;\n" +
+				"e : e '*' x=e\n" +
+				"  | e '+' e\n" +
+				"  | e '.' y=ID\n" +
+				"  | '-' e\n" +
+				"  | ID\n" +
+				"  ;\n" +
+				"ID : [a-z]+ ;\n"
+		);
+
+		String expectedTree =
+				"(COMBINED_GRAMMAR T (RULES (RULE s (BLOCK (ALT e ';'))) (RULE e (BLOCK (ALT (BLOCK (ALT {} ('-' (ELEMENT_OPTIONS (= tokenIndex 47))) (e (ELEMENT_OPTIONS (= tokenIndex 49) (= p 2)))) (ALT (ID (ELEMENT_OPTIONS (= tokenIndex 53))))) (* (BLOCK (ALT ({precpred(_ctx, 5)}? (ELEMENT_OPTIONS (= p 5))) ('*' (ELEMENT_OPTIONS (= tokenIndex 21))) (= x (e (ELEMENT_OPTIONS (= tokenIndex 25) (= p 6))))) (ALT ({precpred(_ctx, 4)}? (ELEMENT_OPTIONS (= p 4))) ('+' (ELEMENT_OPTIONS (= tokenIndex 31))) (e (ELEMENT_OPTIONS (= tokenIndex 33) (= p 5)))) (ALT ({precpred(_ctx, 3)}? (ELEMENT_OPTIONS (= p 3))) ('.' (ELEMENT_OPTIONS (= tokenIndex 39))) (= y (ID (ELEMENT_OPTIONS (= tokenIndex 43))))))))))))";
+		assertEquals(expectedTree, g.ast.toStringTree());
+
+		String expectedElementTokens =
+				"[@5,11:11='s',<57>,2:0]\n" +
+				"[@9,15:15='e',<57>,2:4]\n" +
+				"[@11,17:19='';'',<62>,2:6]\n" +
+				"[@15,23:23='e',<57>,3:0]\n" +
+				"[@47,68:70=''-'',<62>,6:4]\n" +
+				"[@49,72:72='e',<57>,6:8]\n" +
+				"[@53,78:79='ID',<66>,7:4]\n" +
+				"[@21,29:31=''*'',<62>,3:6]\n" +
+				"[@25,35:35='e',<57>,3:12]\n" +
+				"[@31,43:45=''+'',<62>,4:6]\n" +
+				"[@33,47:47='e',<57>,4:10]\n" +
+				"[@39,55:57=''.'',<62>,5:6]\n" +
+				"[@43,61:62='ID',<66>,5:12]";
+
+		IntervalSet types =
+				new IntervalSet(ANTLRParser.TOKEN_REF,
+				ANTLRParser.STRING_LITERAL,
+				ANTLRParser.RULE_REF);
+		List<GrammarAST> nodes = g.ast.getNodesWithTypePreorderDFS(types);
+		List<Token> tokens = new ArrayList<Token>();
+		for (GrammarAST node : nodes) {
+			tokens.add(node.getToken());
+		}
+		assertEquals(expectedElementTokens, Utils.join(tokens.toArray(), "\n"));
+	}
+
+	@Test public void testLeftRecursionWithSet() throws Exception {
+		Grammar g = new Grammar(
+				"grammar T;\n" +
+				"s : e ';' ;\n" +
+				"e : e op=('*'|'/') e\n" +
+				"  | e '+' e\n" +
+				"  | e '.' ID\n" +
+				"  | '-' e\n" +
+				"  | ID\n" +
+				"  ;\n" +
+				"ID : [a-z]+ ;\n"
+		);
+
+		String expectedTree =
+				"(COMBINED_GRAMMAR T (RULES (RULE s (BLOCK (ALT e ';'))) (RULE e (BLOCK (ALT (BLOCK (ALT {} ('-' (ELEMENT_OPTIONS (= tokenIndex 49))) (e (ELEMENT_OPTIONS (= tokenIndex 51) (= p 2)))) (ALT (ID (ELEMENT_OPTIONS (= tokenIndex 55))))) (* (BLOCK (ALT ({precpred(_ctx, 5)}? (ELEMENT_OPTIONS (= p 5))) (= op (SET ('*' (ELEMENT_OPTIONS (= tokenIndex 24))) ('/' (ELEMENT_OPTIONS (= tokenIndex 26))))) (e (ELEMENT_OPTIONS (= tokenIndex 29) (= p 6)))) (ALT ({precpred(_ctx, 4)}? (ELEMENT_OPTIONS (= p 4))) ('+' (ELEMENT_OPTIONS (= tokenIndex 35))) (e (ELEMENT_OPTIONS (= tokenIndex 37) (= p 5)))) (ALT ({precpred(_ctx, 3)}? (ELEMENT_OPTIONS (= p 3))) ('.' (ELEMENT_OPTIONS (= tokenIndex 43))) (ID (ELEMENT_OPTIONS (= tokenIndex 45)))))))))))";
+		assertEquals(expectedTree, g.ast.toStringTree());
+
+		String expectedElementTokens =
+				"[@5,11:11='s',<57>,2:0]\n" +
+				"[@9,15:15='e',<57>,2:4]\n" +
+				"[@11,17:19='';'',<62>,2:6]\n" +
+				"[@15,23:23='e',<57>,3:0]\n" +
+				"[@49,73:75=''-'',<62>,6:4]\n" +
+				"[@51,77:77='e',<57>,6:8]\n" +
+				"[@55,83:84='ID',<66>,7:4]\n" +
+				"[@24,33:35=''*'',<62>,3:10]\n" +
+				"[@26,37:39=''/'',<62>,3:14]\n" +
+				"[@29,42:42='e',<57>,3:19]\n" +
+				"[@35,50:52=''+'',<62>,4:6]\n" +
+				"[@37,54:54='e',<57>,4:10]\n" +
+				"[@43,62:64=''.'',<62>,5:6]\n" +
+				"[@45,66:67='ID',<66>,5:10]";
+
+		IntervalSet types =
+				new IntervalSet(ANTLRParser.TOKEN_REF,
+				ANTLRParser.STRING_LITERAL,
+				ANTLRParser.RULE_REF);
+		List<GrammarAST> nodes = g.ast.getNodesWithTypePreorderDFS(types);
+		List<Token> tokens = new ArrayList<Token>();
+		for (GrammarAST node : nodes) {
+			tokens.add(node.getToken());
+		}
+		assertEquals(expectedElementTokens, Utils.join(tokens.toArray(), "\n"));
+	}
+
+}
diff --git a/tool/test/org/antlr/v4/test/TestTokenStreamRewriter.java b/tool-testsuite/test/org/antlr/v4/test/tool/TestTokenStreamRewriter.java
similarity index 97%
rename from tool/test/org/antlr/v4/test/TestTokenStreamRewriter.java
rename to tool-testsuite/test/org/antlr/v4/test/tool/TestTokenStreamRewriter.java
index acac405ca..e2d8061ca 100644
--- a/tool/test/org/antlr/v4/test/TestTokenStreamRewriter.java
+++ b/tool-testsuite/test/org/antlr/v4/test/tool/TestTokenStreamRewriter.java
@@ -27,14 +27,16 @@
  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-package org.antlr.v4.test;
+package org.antlr.v4.test.tool;
 
 import org.antlr.v4.runtime.ANTLRInputStream;
 import org.antlr.v4.runtime.CommonTokenStream;
 import org.antlr.v4.runtime.LexerInterpreter;
 import org.antlr.v4.runtime.TokenStreamRewriter;
 import org.antlr.v4.runtime.misc.Interval;
+import org.antlr.v4.test.runtime.java.BaseTest;
 import org.antlr.v4.tool.LexerGrammar;
+import org.junit.Ignore;
 import org.junit.Test;
 
 import static org.junit.Assert.assertEquals;
@@ -881,4 +883,27 @@ public class TestTokenStreamRewriter extends BaseTest {
 		assertEquals(expecting, result);
 	}
 
+	// Test for https://github.com/antlr/antlr4/issues/550
+	@Test
+	@Ignore
+	public void testPreservesOrderOfContiguousInserts() throws Exception {
+		LexerGrammar g = new LexerGrammar(
+											 "lexer grammar T;\n"+
+											 "A : 'a';\n" +
+											 "B : 'b';\n" +
+											 "C : 'c';\n");
+		String input = "aa";
+		LexerInterpreter lexEngine = g.createLexerInterpreter(new ANTLRInputStream(input));
+		CommonTokenStream stream = new CommonTokenStream(lexEngine);
+		stream.fill();
+		TokenStreamRewriter tokens = new TokenStreamRewriter(stream);
+		tokens.insertBefore(0, "<b>");
+		tokens.insertAfter(0, "</b>");
+		tokens.insertBefore(1, "<b>");
+		tokens.insertAfter(1, "</b>");
+		String result = tokens.getText();
+		String expecting = "<b>a</b><b>a</b>"; // fails with <b>a<b></b>a</b>"
+		assertEquals(expecting, result);
+	}
+
 }
diff --git a/tool/test/org/antlr/v4/test/TestTokenTypeAssignment.java b/tool-testsuite/test/org/antlr/v4/test/tool/TestTokenTypeAssignment.java
similarity index 90%
rename from tool/test/org/antlr/v4/test/TestTokenTypeAssignment.java
rename to tool-testsuite/test/org/antlr/v4/test/tool/TestTokenTypeAssignment.java
index 603f0739a..635f15c53 100644
--- a/tool/test/org/antlr/v4/test/TestTokenTypeAssignment.java
+++ b/tool-testsuite/test/org/antlr/v4/test/tool/TestTokenTypeAssignment.java
@@ -28,19 +28,22 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-package org.antlr.v4.test;
+package org.antlr.v4.test.tool;
 
 import org.antlr.v4.runtime.Token;
+import org.antlr.v4.test.runtime.java.BaseTest;
 import org.antlr.v4.tool.Grammar;
 import org.antlr.v4.tool.LexerGrammar;
 import org.junit.Test;
 
 import java.util.HashSet;
-import java.util.Iterator;
+import java.util.LinkedHashSet;
 import java.util.Set;
 import java.util.StringTokenizer;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
 
 public class TestTokenTypeAssignment extends BaseTest {
 
@@ -110,10 +113,10 @@ public class TestTokenTypeAssignment extends BaseTest {
 		foundLiterals = g.implicitLexer.stringLiteralToTypeMap.keySet().toString();
 		assertEquals("['x']", foundLiterals); // pushed in lexer from parser
 
-		String[] typeToTokenName = g.getTokenNames();
-		Set<String> tokens = new HashSet<String>();
+		String[] typeToTokenName = g.getTokenDisplayNames();
+		Set<String> tokens = new LinkedHashSet<String>();
 		for (String t : typeToTokenName) if ( t!=null ) tokens.add(t);
-		assertEquals("[E, 'x']", tokens.toString());
+		assertEquals("[<INVALID>, 'x', E]", tokens.toString());
 	}
 
 	@Test public void testPredDoesNotHideNameToLiteralMapInLexer() throws Exception {
@@ -170,7 +173,17 @@ public class TestTokenTypeAssignment extends BaseTest {
 	{
 		String[] typeToTokenName = g.getTokenNames();
 		Set<String> tokens = new HashSet<String>();
-		for (String t : typeToTokenName) if ( t!=null ) tokens.add(t);
+		for (int i = 0; i < typeToTokenName.length; i++) {
+			String t = typeToTokenName[i];
+			if ( t!=null ) {
+				if (t.startsWith(Grammar.AUTO_GENERATED_TOKEN_NAME_PREFIX)) {
+					tokens.add(g.getTokenDisplayName(i));
+				}
+				else {
+					tokens.add(t);
+				}
+			}
+		}
 
 		// make sure expected tokens are there
 		StringTokenizer st = new StringTokenizer(allValidTokensStr, ", ");
diff --git a/tool/test/org/antlr/v4/test/TestToolSyntaxErrors.java b/tool-testsuite/test/org/antlr/v4/test/tool/TestToolSyntaxErrors.java
similarity index 50%
rename from tool/test/org/antlr/v4/test/TestToolSyntaxErrors.java
rename to tool-testsuite/test/org/antlr/v4/test/tool/TestToolSyntaxErrors.java
index 36d66c35e..c41143422 100644
--- a/tool/test/org/antlr/v4/test/TestToolSyntaxErrors.java
+++ b/tool-testsuite/test/org/antlr/v4/test/tool/TestToolSyntaxErrors.java
@@ -28,8 +28,10 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-package org.antlr.v4.test;
+package org.antlr.v4.test.tool;
 
+import org.antlr.v4.Tool;
+import org.antlr.v4.test.runtime.java.BaseTest;
 import org.antlr.v4.tool.ErrorType;
 import org.junit.Test;
 
@@ -39,7 +41,7 @@ public class TestToolSyntaxErrors extends BaseTest {
         "grammar A;\n" +
         "",
         // YIELDS
-        "error(" + ErrorType.NO_RULES.code + "): A.g4::: grammar 'A' has no rules\n",
+        "error(" + ErrorType.NO_RULES.code + "): A.g4::: grammar A has no rules\n",
 
 		"A;",
 		"error(" + ErrorType.SYNTAX_ERROR.code + "): A.g4:1:0: syntax error: 'A' came as a complete surprise to me\n",
@@ -273,8 +275,8 @@ public class TestToolSyntaxErrors extends BaseTest {
 			"X : 'foo' -> popmode;\n" + // "meant" to use -> popMode
 			"Y : 'foo' -> token(Foo);", // "meant" to use -> type(Foo)
 
-			"error(" + ErrorType.INVALID_LEXER_COMMAND.code + "): A.g4:4:13: lexer command 'popmode' does not exist or is not supported by the current target\n" +
-			"error(" + ErrorType.INVALID_LEXER_COMMAND.code + "): A.g4:5:13: lexer command 'token' does not exist or is not supported by the current target\n"
+			"error(" + ErrorType.INVALID_LEXER_COMMAND.code + "): A.g4:4:13: lexer command popmode does not exist or is not supported by the current target\n" +
+			"error(" + ErrorType.INVALID_LEXER_COMMAND.code + "): A.g4:5:13: lexer command token does not exist or is not supported by the current target\n"
 		};
 		super.testErrors(pair, true);
 	}
@@ -287,8 +289,8 @@ public class TestToolSyntaxErrors extends BaseTest {
 			"X : 'foo' -> popMode(Foo);\n" + // "meant" to use -> popMode
 			"Y : 'foo' -> type;", // "meant" to use -> type(Foo)
 
-			"error(" + ErrorType.UNWANTED_LEXER_COMMAND_ARGUMENT.code + "): A.g4:4:13: lexer command 'popMode' does not take any arguments\n" +
-			"error(" + ErrorType.MISSING_LEXER_COMMAND_ARGUMENT.code + "): A.g4:5:13: missing argument for lexer command 'type'\n"
+			"error(" + ErrorType.UNWANTED_LEXER_COMMAND_ARGUMENT.code + "): A.g4:4:13: lexer command popMode does not take any arguments\n" +
+			"error(" + ErrorType.MISSING_LEXER_COMMAND_ARGUMENT.code + "): A.g4:5:13: missing argument for lexer command type\n"
 		};
 		super.testErrors(pair, true);
 	}
@@ -303,7 +305,7 @@ public class TestToolSyntaxErrors extends BaseTest {
 			"A : 'a' ;\n" +
 			"B : 'b' ;\n",
 
-			"error(" + ErrorType.RULE_REDEFINITION.code + "): Oops.g4:4:0: rule 'ret_ty' redefinition; previous at line 3\n"
+			"error(" + ErrorType.RULE_REDEFINITION.code + "): Oops.g4:4:0: rule ret_ty redefinition; previous at line 3\n"
 		};
 		super.testErrors(pair, true);
 	}
@@ -317,15 +319,15 @@ public class TestToolSyntaxErrors extends BaseTest {
 			+ "z1 : ('foo' | 'bar'? 'bar2'?)*;\n"
 			+ "z2 : ('foo' | 'bar' 'bar2'? | 'bar2')*;\n";
 		String expected =
-			"error(" + ErrorType.EPSILON_CLOSURE.code + "): A.g4:3:0: rule 'y1' contains a closure with at least one alternative that can match an empty string\n" +
-			"error(" + ErrorType.EPSILON_CLOSURE.code + "): A.g4:4:0: rule 'y2' contains a closure with at least one alternative that can match an empty string\n" +
-			"error(" + ErrorType.EPSILON_CLOSURE.code + "): A.g4:5:0: rule 'z1' contains a closure with at least one alternative that can match an empty string\n";
+			"error(" + ErrorType.EPSILON_CLOSURE.code + "): A.g4:3:0: rule y1 contains a closure with at least one alternative that can match an empty string\n" +
+			"error(" + ErrorType.EPSILON_CLOSURE.code + "): A.g4:4:0: rule y2 contains a closure with at least one alternative that can match an empty string\n" +
+			"error(" + ErrorType.EPSILON_CLOSURE.code + "): A.g4:5:0: rule z1 contains a closure with at least one alternative that can match an empty string\n";
 
 		String[] pair = new String[] {
 			grammar,
 			expected
 		};
-			
+
 		super.testErrors(pair, true);
 	}
 
@@ -337,8 +339,8 @@ public class TestToolSyntaxErrors extends BaseTest {
 			+ "z1 : ('foo' | 'bar'? 'bar2'?)?;\n"
 			+ "z2 : ('foo' | 'bar' 'bar2'? | 'bar2')?;\n";
 		String expected =
-			"warning(" + ErrorType.EPSILON_OPTIONAL.code + "): A.g4:3:0: rule 'y' contains an optional block with at least one alternative that can match an empty string\n" +
-			"warning(" + ErrorType.EPSILON_OPTIONAL.code + "): A.g4:4:0: rule 'z1' contains an optional block with at least one alternative that can match an empty string\n";
+			"warning(" + ErrorType.EPSILON_OPTIONAL.code + "): A.g4:3:0: rule y contains an optional block with at least one alternative that can match an empty string\n" +
+			"warning(" + ErrorType.EPSILON_OPTIONAL.code + "): A.g4:4:0: rule z1 contains an optional block with at least one alternative that can match an empty string\n";
 
 		String[] pair = new String[] {
 			grammar,
@@ -372,9 +374,311 @@ public class TestToolSyntaxErrors extends BaseTest {
 			"\n" +
 			"WS   : [ \\r\\t\\n]+ -> skip ;\n";
 		String expected =
-			"error(" + ErrorType.LEXER_ACTION_PLACEMENT_ISSUE.code + "): A.g4:8:21: action in lexer rule 'CharacterLiteral' must be last element of single outermost alt\n";
-		
+			"";
+
 		String[] pair = new String[] { grammar, expected };
 		super.testErrors(pair, true);
 	}
+
+	/**
+	 * This is a regression test for antlr/antlr4#308 "NullPointer exception"
+	 * https://github.com/antlr/antlr4/issues/308
+	 */
+	@Test public void testDoubleQuotedStringLiteral() {
+		String grammar =
+			"lexer grammar A;\n"
+			+ "WHITESPACE : (\" \" | \"\\t\" | \"\\n\" | \"\\r\" | \"\\f\");\n";
+		String expected =
+			"error(" + ErrorType.SYNTAX_ERROR.code + "): A.g4:2:14: syntax error: '\"' came as a complete surprise to me\n" +
+			"error(" + ErrorType.SYNTAX_ERROR.code + "): A.g4:2:16: syntax error: '\"' came as a complete surprise to me\n" +
+			"error(" + ErrorType.SYNTAX_ERROR.code + "): A.g4:2:20: syntax error: '\"' came as a complete surprise to me\n" +
+			"error(" + ErrorType.SYNTAX_ERROR.code + "): A.g4:2:21: syntax error: '\\' came as a complete surprise to me\n" +
+			"error(" + ErrorType.SYNTAX_ERROR.code + "): A.g4:2:23: syntax error: '\"' came as a complete surprise to me\n" +
+			"error(" + ErrorType.SYNTAX_ERROR.code + "): A.g4:2:27: syntax error: '\"' came as a complete surprise to me\n" +
+			"error(" + ErrorType.SYNTAX_ERROR.code + "): A.g4:2:28: syntax error: '\\' came as a complete surprise to me\n" +
+			"error(" + ErrorType.SYNTAX_ERROR.code + "): A.g4:2:30: syntax error: '\"' came as a complete surprise to me\n" +
+			"error(" + ErrorType.SYNTAX_ERROR.code + "): A.g4:2:34: syntax error: '\"' came as a complete surprise to me\n" +
+			"error(" + ErrorType.SYNTAX_ERROR.code + "): A.g4:2:35: syntax error: '\\' came as a complete surprise to me\n" +
+			"error(" + ErrorType.SYNTAX_ERROR.code + "): A.g4:2:37: syntax error: '\"' came as a complete surprise to me\n" +
+			"error(" + ErrorType.SYNTAX_ERROR.code + "): A.g4:2:41: syntax error: '\"' came as a complete surprise to me\n" +
+			"error(" + ErrorType.SYNTAX_ERROR.code + "): A.g4:2:42: syntax error: '\\' came as a complete surprise to me\n" +
+			"error(" + ErrorType.SYNTAX_ERROR.code + "): A.g4:2:44: syntax error: '\"' came as a complete surprise to me\n";
+
+		String[] pair = new String[] {
+			grammar,
+			expected
+		};
+
+		super.testErrors(pair, true);
+	}
+
+	/**
+	 * This test ensures that the {@link ErrorType#INVALID_ESCAPE_SEQUENCE}
+	 * error is not reported for escape sequences that are known to be valid.
+	 */
+	@Test public void testValidEscapeSequences() {
+		String grammar =
+			"lexer grammar A;\n" +
+			"NORMAL_ESCAPE : '\\b \\t \\n \\f \\r \\\" \\' \\\\';\n" +
+			"UNICODE_ESCAPE : '\\u0001 \\u00A1 \\u00a1 \\uaaaa \\uAAAA';\n";
+		String expected =
+			"";
+
+		String[] pair = new String[] {
+			grammar,
+			expected
+		};
+
+		super.testErrors(pair, true);
+	}
+
+	/**
+	 * This is a regression test for antlr/antlr4#507 "NullPointerException When
+	 * Generating Code from Grammar".
+	 * https://github.com/antlr/antlr4/issues/507
+	 */
+	@Test public void testInvalidEscapeSequences() {
+		String grammar =
+			"lexer grammar A;\n" +
+			"RULE : 'Foo \\uAABG \\x \\u';\n";
+		String expected =
+			"error(" + ErrorType.INVALID_ESCAPE_SEQUENCE.code + "): A.g4:2:12: invalid escape sequence\n" +
+			"error(" + ErrorType.INVALID_ESCAPE_SEQUENCE.code + "): A.g4:2:19: invalid escape sequence\n" +
+			"error(" + ErrorType.INVALID_ESCAPE_SEQUENCE.code + "): A.g4:2:22: invalid escape sequence\n";
+
+		String[] pair = new String[] {
+			grammar,
+			expected
+		};
+
+		super.testErrors(pair, true);
+	}
+
+	/**
+	 * This is a regression test for antlr/antlr4#959 "NullPointerException".
+	 * https://github.com/antlr/antlr4/issues/959
+	 */
+	@Test public void testNotAllowedEmptyStrings() {
+		String grammar =
+			"lexer grammar T;\n" +
+			"Error0: '''test''';\n" +
+			"Error1: '' 'test';\n" +
+			"Error2: 'test' '';\n" +
+			"Error3: '';\n" +
+			"NotError: ' ';";
+		String expected =
+			"error(" + ErrorType.EMPTY_STRINGS_NOT_ALLOWED.code + "): T.g4:2:8: string literals cannot be empty\n" +
+			"error(" + ErrorType.EMPTY_STRINGS_NOT_ALLOWED.code + "): T.g4:2:16: string literals cannot be empty\n" +
+			"error(" + ErrorType.EMPTY_STRINGS_NOT_ALLOWED.code + "): T.g4:3:8: string literals cannot be empty\n" +
+			"error(" + ErrorType.EMPTY_STRINGS_NOT_ALLOWED.code + "): T.g4:4:15: string literals cannot be empty\n" +
+			"error(" + ErrorType.EMPTY_STRINGS_NOT_ALLOWED.code + "): T.g4:5:8: string literals cannot be empty\n";
+
+		String[] pair = new String[] {
+				grammar,
+				expected
+		};
+
+		super.testErrors(pair, true);
+	}
+
+	/**
+	 * This test ensures the {@link ErrorType#UNRECOGNIZED_ASSOC_OPTION} warning
+	 * is produced as described in the documentation.
+	 */
+	@Test public void testUnrecognizedAssocOption() {
+		String grammar =
+			"grammar A;\n" +
+			"x : 'x'\n" +
+			"  | x '+'<assoc=right> x   // warning 157\n" +
+			"  |<assoc=right> x '*' x   // ok\n" +
+			"  ;\n";
+		String expected =
+			"warning(" + ErrorType.UNRECOGNIZED_ASSOC_OPTION.code + "): A.g4:3:10: rule x contains an assoc terminal option in an unrecognized location\n";
+
+		String[] pair = new String[] {
+			grammar,
+			expected
+		};
+
+		super.testErrors(pair, true);
+	}
+
+	/**
+	 * This test ensures the {@link ErrorType#FRAGMENT_ACTION_IGNORED} warning
+	 * is produced as described in the documentation.
+	 */
+	@Test public void testFragmentActionIgnored() {
+		String grammar =
+			"lexer grammar A;\n" +
+			"X1 : 'x' -> more    // ok\n" +
+			"   ;\n" +
+			"Y1 : 'x' {more();}  // ok\n" +
+			"   ;\n" +
+			"fragment\n" +
+			"X2 : 'x' -> more    // warning 158\n" +
+			"   ;\n" +
+			"fragment\n" +
+			"Y2 : 'x' {more();}  // warning 158\n" +
+			"   ;\n";
+		String expected =
+			"warning(" + ErrorType.FRAGMENT_ACTION_IGNORED.code + "): A.g4:7:12: fragment rule X2 contains an action or command which can never be executed\n" +
+			"warning(" + ErrorType.FRAGMENT_ACTION_IGNORED.code + "): A.g4:10:9: fragment rule Y2 contains an action or command which can never be executed\n";
+
+		String[] pair = new String[] {
+			grammar,
+			expected
+		};
+
+		super.testErrors(pair, true);
+	}
+
+	/**
+	 * This is a regression test for antlr/antlr4#500 "Array Index Out Of
+	 * Bounds".
+	 * https://github.com/antlr/antlr4/issues/500
+	 */
+	@Test public void testTokenNamedEOF() {
+		String grammar =
+			"lexer grammar A;\n" +
+			"WS : ' ';\n" +
+			" EOF : 'a';\n";
+		String expected =
+			"error(" + ErrorType.RESERVED_RULE_NAME.code + "): A.g4:3:1: cannot declare a rule with reserved name EOF\n";
+
+		String[] pair = new String[] {
+			grammar,
+			expected
+		};
+
+		super.testErrors(pair, true);
+	}
+
+	/**
+	 * This is a regression test for antlr/antlr4#649 "unknown target causes
+	 * null ptr exception.".
+	 * https://github.com/antlr/antlr4/issues/649
+	 * Stops before processing the lexer
+	 */
+	@Test public void testInvalidLanguageInGrammarWithLexerCommand() throws Exception {
+		String grammar =
+			"grammar T;\n" +
+			"options { language=Foo; }\n" +
+			"start : 'T' EOF;\n" +
+			"Something : 'something' -> channel(CUSTOM);";
+		String expected =
+			"error(" + ErrorType.CANNOT_CREATE_TARGET_GENERATOR.code + "):  ANTLR cannot generate Foo code as of version " + Tool.VERSION + "\n";
+		String[] pair = new String[] {
+			grammar,
+			expected
+		};
+
+		super.testErrors(pair, true);
+	}
+
+	/**
+	 * This is a regression test for antlr/antlr4#649 "unknown target causes
+	 * null ptr exception.".
+	 * https://github.com/antlr/antlr4/issues/649
+	 */
+	@Test public void testInvalidLanguageInGrammar() throws Exception {
+		String grammar =
+			"grammar T;\n" +
+			"options { language=Foo; }\n" +
+			"start : 'T' EOF;\n";
+		String expected =
+			"error(" + ErrorType.CANNOT_CREATE_TARGET_GENERATOR.code + "):  ANTLR cannot generate Foo code as of version " + Tool.VERSION + "\n";
+
+		String[] pair = new String[] {
+			grammar,
+			expected
+		};
+
+		super.testErrors(pair, true);
+	}
+
+	@Test public void testChannelDefinitionInLexer() throws Exception {
+		String grammar =
+			"lexer grammar T;\n" +
+			"\n" +
+			"channels {\n" +
+			"	WHITESPACE_CHANNEL,\n" +
+			"	COMMENT_CHANNEL\n" +
+			"}\n" +
+			"\n" +
+			"COMMENT:    '//' ~[\\n]+ -> channel(COMMENT_CHANNEL);\n" +
+			"WHITESPACE: [ \\t]+      -> channel(WHITESPACE_CHANNEL);\n";
+
+		String expected = "";
+
+		String[] pair = { grammar, expected };
+		super.testErrors(pair, true);
+	}
+
+	@Test public void testChannelDefinitionInParser() throws Exception {
+		String grammar =
+			"parser grammar T;\n" +
+			"\n" +
+			"channels {\n" +
+			"	WHITESPACE_CHANNEL,\n" +
+			"	COMMENT_CHANNEL\n" +
+			"}\n" +
+			"\n" +
+			"start : EOF;\n";
+
+		String expected =
+			"error(" + ErrorType.CHANNELS_BLOCK_IN_PARSER_GRAMMAR.code + "): T.g4:3:0: custom channels are not supported in parser grammars\n";
+
+		String[] pair = { grammar, expected };
+		super.testErrors(pair, true);
+	}
+
+	@Test public void testChannelDefinitionInCombined() throws Exception {
+		String grammar =
+			"grammar T;\n" +
+			"\n" +
+			"channels {\n" +
+			"	WHITESPACE_CHANNEL,\n" +
+			"	COMMENT_CHANNEL\n" +
+			"}\n" +
+			"\n" +
+			"start : EOF;\n" +
+			"\n" +
+			"COMMENT:    '//' ~[\\n]+ -> channel(COMMENT_CHANNEL);\n" +
+			"WHITESPACE: [ \\t]+      -> channel(WHITESPACE_CHANNEL);\n";
+
+		String expected =
+			"warning(" + ErrorType.UNKNOWN_LEXER_CONSTANT.code + "): T.g4:10:35: rule COMMENT contains a lexer command with an unrecognized constant value; lexer interpreters may produce incorrect output\n" +
+			"warning(" + ErrorType.UNKNOWN_LEXER_CONSTANT.code + "): T.g4:11:35: rule WHITESPACE contains a lexer command with an unrecognized constant value; lexer interpreters may produce incorrect output\n" +
+			"error(" + ErrorType.CHANNELS_BLOCK_IN_COMBINED_GRAMMAR.code + "): T.g4:3:0: custom channels are not supported in combined grammars\n";
+
+		String[] pair = { grammar, expected };
+		super.testErrors(pair, true);
+	}
+
+	/**
+	 * This is a regression test for antlr/antlr4#497 now that antlr/antlr4#309
+	 * is resolved.
+	 * https://github.com/antlr/antlr4/issues/497
+	 * https://github.com/antlr/antlr4/issues/309
+	 */
+	@Test public void testChannelDefinitions() throws Exception {
+		String grammar =
+			"lexer grammar T;\n" +
+			"\n" +
+			"channels {\n" +
+			"	WHITESPACE_CHANNEL,\n" +
+			"	COMMENT_CHANNEL\n" +
+			"}\n" +
+			"\n" +
+			"COMMENT:    '//' ~[\\n]+ -> channel(COMMENT_CHANNEL);\n" +
+			"WHITESPACE: [ \\t]+      -> channel(WHITESPACE_CHANNEL);\n" +
+			"NEWLINE:    '\\r'? '\\n' -> channel(NEWLINE_CHANNEL);";
+
+		// WHITESPACE_CHANNEL and COMMENT_CHANNEL are defined, but NEWLINE_CHANNEL is not
+		String expected =
+			"warning(" + ErrorType.UNKNOWN_LEXER_CONSTANT.code + "): T.g4:10:34: rule NEWLINE contains a lexer command with an unrecognized constant value; lexer interpreters may produce incorrect output\n";
+
+		String[] pair = { grammar, expected };
+		super.testErrors(pair, true);
+	}
 }
diff --git a/tool/test/org/antlr/v4/test/TestTopologicalSort.java b/tool-testsuite/test/org/antlr/v4/test/tool/TestTopologicalSort.java
similarity index 94%
rename from tool/test/org/antlr/v4/test/TestTopologicalSort.java
rename to tool-testsuite/test/org/antlr/v4/test/tool/TestTopologicalSort.java
index 7f506e744..38a2e603d 100644
--- a/tool/test/org/antlr/v4/test/TestTopologicalSort.java
+++ b/tool-testsuite/test/org/antlr/v4/test/tool/TestTopologicalSort.java
@@ -27,14 +27,15 @@
  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-package org.antlr.v4.test;
+package org.antlr.v4.test.tool;
 
 import org.antlr.v4.misc.Graph;
+import org.antlr.v4.test.runtime.java.BaseTest;
 import org.junit.Test;
 
 import java.util.List;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
 
 /** Test topo sort in GraphNode. */
 public class TestTopologicalSort extends BaseTest {
@@ -53,7 +54,7 @@ public class TestTopologicalSort extends BaseTest {
         g.addEdge("F", "H");
         g.addEdge("E", "F");
 
-        String expecting = "[H, F, E, D, G, A, B, C]";
+        String expecting = "[H, F, G, E, D, A, B, C]";
         List<String> nodes = g.sort();
         String result = nodes.toString();
         assertEquals(expecting, result);
@@ -95,7 +96,7 @@ public class TestTopologicalSort extends BaseTest {
         g.addEdge("Def.g4", "Java.tokens");    // walkers feed off generated tokens
         g.addEdge("Ref.g4", "Java.tokens");
 
-        String expecting = "[MyJava.tokens, Java.g4, Java.tokens, Ref.g4, Def.g4]";
+        String expecting = "[MyJava.tokens, Java.g4, Java.tokens, Def.g4, Ref.g4]";
         List<String> nodes = g.sort();
         String result = nodes.toString();
         assertEquals(expecting, result);
@@ -109,7 +110,7 @@ public class TestTopologicalSort extends BaseTest {
         g.addEdge("Def.g4", "JavaLexer.tokens");
         g.addEdge("Ref.g4", "JavaLexer.tokens");
 
-        String expecting = "[JavaLexer.g4, JavaLexer.tokens, JavaParser.g4, Ref.g4, Def.g4]";
+        String expecting = "[JavaLexer.g4, JavaLexer.tokens, JavaParser.g4, Def.g4, Ref.g4]";
         List<String> nodes = g.sort();
         String result = nodes.toString();
         assertEquals(expecting, result);
diff --git a/tool/test/org/antlr/v4/test/TestUnbufferedCharStream.java b/tool-testsuite/test/org/antlr/v4/test/tool/TestUnbufferedCharStream.java
similarity index 99%
rename from tool/test/org/antlr/v4/test/TestUnbufferedCharStream.java
rename to tool-testsuite/test/org/antlr/v4/test/tool/TestUnbufferedCharStream.java
index 0e6b02e89..52a8a1b04 100644
--- a/tool/test/org/antlr/v4/test/TestUnbufferedCharStream.java
+++ b/tool-testsuite/test/org/antlr/v4/test/tool/TestUnbufferedCharStream.java
@@ -28,7 +28,7 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-package org.antlr.v4.test;
+package org.antlr.v4.test.tool;
 
 import org.antlr.v4.runtime.CharStream;
 import org.antlr.v4.runtime.CommonTokenFactory;
@@ -37,6 +37,7 @@ import org.antlr.v4.runtime.IntStream;
 import org.antlr.v4.runtime.LexerInterpreter;
 import org.antlr.v4.runtime.UnbufferedCharStream;
 import org.antlr.v4.runtime.misc.Interval;
+import org.antlr.v4.test.runtime.java.BaseTest;
 import org.antlr.v4.tool.LexerGrammar;
 import org.junit.Test;
 
@@ -45,6 +46,7 @@ import java.io.StringReader;
 
 import static org.junit.Assert.assertEquals;
 
+@SuppressWarnings("unused")
 public class TestUnbufferedCharStream extends BaseTest {
 	@Test public void testNoChar() throws Exception {
 		CharStream input = createStream("");
diff --git a/tool/test/org/antlr/v4/test/TestUnbufferedTokenStream.java b/tool-testsuite/test/org/antlr/v4/test/tool/TestUnbufferedTokenStream.java
similarity index 98%
rename from tool/test/org/antlr/v4/test/TestUnbufferedTokenStream.java
rename to tool-testsuite/test/org/antlr/v4/test/tool/TestUnbufferedTokenStream.java
index 79accab1c..9ab81b35a 100644
--- a/tool/test/org/antlr/v4/test/TestUnbufferedTokenStream.java
+++ b/tool-testsuite/test/org/antlr/v4/test/tool/TestUnbufferedTokenStream.java
@@ -28,7 +28,7 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-package org.antlr.v4.test;
+package org.antlr.v4.test.tool;
 
 import org.antlr.v4.runtime.ANTLRInputStream;
 import org.antlr.v4.runtime.CharStream;
@@ -37,6 +37,7 @@ import org.antlr.v4.runtime.Token;
 import org.antlr.v4.runtime.TokenSource;
 import org.antlr.v4.runtime.TokenStream;
 import org.antlr.v4.runtime.UnbufferedTokenStream;
+import org.antlr.v4.test.runtime.java.BaseTest;
 import org.antlr.v4.tool.LexerGrammar;
 import org.junit.Test;
 
@@ -47,6 +48,7 @@ import java.util.List;
 
 import static org.junit.Assert.assertEquals;
 
+@SuppressWarnings("unused")
 public class TestUnbufferedTokenStream extends BaseTest {
 	@Test public void testLookahead() throws Exception {
         LexerGrammar g = new LexerGrammar(
diff --git a/tool-testsuite/test/org/antlr/v4/test/tool/TestVocabulary.java b/tool-testsuite/test/org/antlr/v4/test/tool/TestVocabulary.java
new file mode 100644
index 000000000..b786e003c
--- /dev/null
+++ b/tool-testsuite/test/org/antlr/v4/test/tool/TestVocabulary.java
@@ -0,0 +1,80 @@
+/*
+ * [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.
+ */
+package org.antlr.v4.test.tool;
+
+import org.antlr.v4.runtime.Token;
+import org.antlr.v4.runtime.Vocabulary;
+import org.antlr.v4.runtime.VocabularyImpl;
+import org.antlr.v4.test.runtime.java.BaseTest;
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ *
+ * @author Sam Harwell
+ */
+public class TestVocabulary extends BaseTest {
+
+	@Test
+	public void testEmptyVocabulary() {
+		Assert.assertNotNull(VocabularyImpl.EMPTY_VOCABULARY);
+		Assert.assertEquals("EOF", VocabularyImpl.EMPTY_VOCABULARY.getSymbolicName(Token.EOF));
+		Assert.assertEquals("0", VocabularyImpl.EMPTY_VOCABULARY.getDisplayName(Token.INVALID_TYPE));
+	}
+
+	@Test
+	public void testVocabularyFromTokenNames() {
+		String[] tokenNames = {
+			"<INVALID>",
+			"TOKEN_REF", "RULE_REF", "'//'", "'/'", "'*'", "'!'", "ID", "STRING"
+		};
+
+		Vocabulary vocabulary = VocabularyImpl.fromTokenNames(tokenNames);
+		Assert.assertNotNull(vocabulary);
+		Assert.assertEquals("EOF", vocabulary.getSymbolicName(Token.EOF));
+		for (int i = 0; i < tokenNames.length; i++) {
+			Assert.assertEquals(tokenNames[i], vocabulary.getDisplayName(i));
+
+			if (tokenNames[i].startsWith("'")) {
+				Assert.assertEquals(tokenNames[i], vocabulary.getLiteralName(i));
+				Assert.assertNull(vocabulary.getSymbolicName(i));
+			}
+			else if (Character.isUpperCase(tokenNames[i].charAt(0))) {
+				Assert.assertNull(vocabulary.getLiteralName(i));
+				Assert.assertEquals(tokenNames[i], vocabulary.getSymbolicName(i));
+			}
+			else {
+				Assert.assertNull(vocabulary.getLiteralName(i));
+				Assert.assertNull(vocabulary.getSymbolicName(i));
+			}
+		}
+	}
+
+}
diff --git a/tool/test/org/antlr/v4/test/TestXPath.java b/tool-testsuite/test/org/antlr/v4/test/tool/TestXPath.java
similarity index 84%
rename from tool/test/org/antlr/v4/test/TestXPath.java
rename to tool-testsuite/test/org/antlr/v4/test/tool/TestXPath.java
index 8d51489dc..7a374ee18 100644
--- a/tool/test/org/antlr/v4/test/TestXPath.java
+++ b/tool-testsuite/test/org/antlr/v4/test/tool/TestXPath.java
@@ -1,4 +1,4 @@
-package org.antlr.v4.test;
+package org.antlr.v4.test.tool;
 
 import org.antlr.v4.runtime.Lexer;
 import org.antlr.v4.runtime.Parser;
@@ -7,6 +7,7 @@ import org.antlr.v4.runtime.misc.Pair;
 import org.antlr.v4.runtime.tree.ParseTree;
 import org.antlr.v4.runtime.tree.TerminalNode;
 import org.antlr.v4.runtime.tree.xpath.XPath;
+import org.antlr.v4.test.runtime.java.BaseTest;
 import org.junit.Test;
 
 import java.util.ArrayList;
@@ -42,10 +43,14 @@ public class TestXPath extends BaseTest {
 		"DIV :   '/' ;\n" +
 		"ADD :   '+' ;\n" +
 		"SUB :   '-' ;\n" +
+		"RETURN : 'return' ;\n" +
 		"ID  :   [a-zA-Z]+ ;      // match identifiers\n" +
 		"INT :   [0-9]+ ;         // match integers\n" +
 		"NEWLINE:'\\r'? '\\n' -> skip;     // return newlines to parser (is end-statement signal)\n" +
 		"WS  :   [ \\t]+ -> skip ; // toss out whitespace\n";
+	public static final String SAMPLE_PROGRAM =
+			"def f(x,y) { x = 3+4; y; ; }\n" +
+			"def g(x) { return 1+2*x; }\n";
 
 	@Test public void testValidPaths() throws Exception {
 		boolean ok =
@@ -53,9 +58,6 @@ public class TestXPath extends BaseTest {
 										  "ExprLexer", false);
 		assertTrue(ok);
 
-		String input =
-			"def f(x,y) { x = 3+4; y; ; }\n" +
-			"def g(x) { return 1+2*x; }\n";
 		String xpath[] = {
 			"/prog/func",		// all funcs under prog at root
 			"/prog/*",			// all children of prog at root
@@ -67,7 +69,8 @@ public class TestXPath extends BaseTest {
 			"//ID",				// any ID in tree
 			"//expr/primary/ID",// any ID child of a primary under any expr
 			"//body//ID",		// any ID under a body
-			"//'return'",		// any 'return' literal in tree
+			"//'return'",		// any 'return' literal in tree, matched by literal name
+			"//RETURN",			// any 'return' literal in tree, matched by symbolic name
 			"//primary/*",		// all kids of any primary
 			"//func/*/stat",	// all stat nodes grandkids of any func node
 			"/prog/func/'def'",	// all def literal kids of func kid of prog
@@ -76,6 +79,7 @@ public class TestXPath extends BaseTest {
 			"//expr/!primary",	// anything but primary under any expr node
 			"//!*",				// nothing anywhere
 			"/!*",				// nothing at root
+			"//expr//ID",		// any ID under any expression (tests antlr/antlr4#370)
 		};
 		String expected[] = {
 			"[func, func]",
@@ -89,6 +93,7 @@ public class TestXPath extends BaseTest {
 			"[y, x]",
 			"[x, y, x]",
 			"[return]",
+			"[return]",
 			"[3, 4, y, 1, 2, x]",
 			"[stat, stat, stat, stat]",
 			"[def, def]",
@@ -97,10 +102,11 @@ public class TestXPath extends BaseTest {
 			"[expr, expr, expr, expr, expr, expr]",
 			"[]",
 			"[]",
+			"[y, x]",
 		};
 
 		for (int i=0; i<xpath.length; i++) {
-			List<String> nodes = getNodeStrings(input, xpath[i], "prog", "ExprParser", "ExprLexer");
+			List<String> nodes = getNodeStrings(SAMPLE_PROGRAM, xpath[i], "prog", "ExprParser", "ExprLexer");
 			String result = nodes.toString();
 			assertEquals("path "+xpath[i]+" failed", expected[i], result);
 		}
@@ -112,13 +118,10 @@ public class TestXPath extends BaseTest {
 										  "ExprLexer", false);
 		assertTrue(ok);
 
-		String input =
-			"def f(x,y) { x = 3+4; y; ; }\n" +
-			"def g(x) { return 1+2*x; }\n";
 		String path = "&";
 		String expected = "Invalid tokens or characters at index 0 in path '&'";
 
-		testError(input, path, expected, "prog", "ExprParser", "ExprLexer");
+		testError(SAMPLE_PROGRAM, path, expected, "prog", "ExprParser", "ExprLexer");
 	}
 
 	@Test public void testWeirdChar2() throws Exception {
@@ -127,13 +130,10 @@ public class TestXPath extends BaseTest {
 										  "ExprLexer", false);
 		assertTrue(ok);
 
-		String input =
-			"def f(x,y) { x = 3+4; y; ; }\n" +
-			"def g(x) { return 1+2*x; }\n";
 		String path = "//w&e/";
 		String expected = "Invalid tokens or characters at index 3 in path '//w&e/'";
 
-		testError(input, path, expected, "prog", "ExprParser", "ExprLexer");
+		testError(SAMPLE_PROGRAM, path, expected, "prog", "ExprParser", "ExprLexer");
 	}
 
 	@Test public void testBadSyntax() throws Exception {
@@ -142,13 +142,10 @@ public class TestXPath extends BaseTest {
 										  "ExprLexer", false);
 		assertTrue(ok);
 
-		String input =
-			"def f(x,y) { x = 3+4; y; ; }\n" +
-			"def g(x) { return 1+2*x; }\n";
 		String path = "///";
 		String expected = "/ at index 2 isn't a valid rule name";
 
-		testError(input, path, expected, "prog", "ExprParser", "ExprLexer");
+		testError(SAMPLE_PROGRAM, path, expected, "prog", "ExprParser", "ExprLexer");
 	}
 
 	@Test public void testMissingWordAtEnd() throws Exception {
@@ -157,13 +154,10 @@ public class TestXPath extends BaseTest {
 										  "ExprLexer", false);
 		assertTrue(ok);
 
-		String input =
-			"def f(x,y) { x = 3+4; y; ; }\n" +
-			"def g(x) { return 1+2*x; }\n";
 		String path = "//";
 		String expected = "Missing path element at end of path";
 
-		testError(input, path, expected, "prog", "ExprParser", "ExprLexer");
+		testError(SAMPLE_PROGRAM, path, expected, "prog", "ExprParser", "ExprLexer");
 	}
 
 	@Test public void testBadTokenName() throws Exception {
@@ -172,13 +166,10 @@ public class TestXPath extends BaseTest {
 										  "ExprLexer", false);
 		assertTrue(ok);
 
-		String input =
-			"def f(x,y) { x = 3+4; y; ; }\n" +
-			"def g(x) { return 1+2*x; }\n";
 		String path = "//Ick";
 		String expected = "Ick at index 2 isn't a valid token name";
 
-		testError(input, path, expected, "prog", "ExprParser", "ExprLexer");
+		testError(SAMPLE_PROGRAM, path, expected, "prog", "ExprParser", "ExprLexer");
 	}
 
 	@Test public void testBadRuleName() throws Exception {
@@ -187,13 +178,10 @@ public class TestXPath extends BaseTest {
 										  "ExprLexer", false);
 		assertTrue(ok);
 
-		String input =
-			"def f(x,y) { x = 3+4; y; ; }\n" +
-			"def g(x) { return 1+2*x; }\n";
 		String path = "/prog/ick";
 		String expected = "ick at index 6 isn't a valid rule name";
 
-		testError(input, path, expected, "prog", "ExprParser", "ExprLexer");
+		testError(SAMPLE_PROGRAM, path, expected, "prog", "ExprParser", "ExprLexer");
 	}
 
 	protected void testError(String input, String path, String expected,
diff --git a/tool/playground/Main.java b/tool/playground/Main.java
new file mode 100644
index 000000000..8001d315a
--- /dev/null
+++ b/tool/playground/Main.java
@@ -0,0 +1,44 @@
+public class Main
+{
+//    public static void main(String[] args)
+//    {
+//        TParser parser = new TParser(new CommonTokenStream(new TLexer(new ANTLRInputStream("b"))));
+//        parser.addParseListener(new MyTBaseListener());
+//
+//		parser.a();
+//
+//		System.out.println("######################");
+//		parser = new TParser(new CommonTokenStream(new TLexer(new ANTLRInputStream("x"))));
+//		parser.addParseListener(new MyTBaseListener());
+//		parser.b();
+//    }
+//
+//	private static class MyTBaseListener extends TBaseListener {
+//		@Override
+//		public void enterAlt1(TParser.Alt1Context ctx)
+//		{
+//			System.out.println("entering alt1");
+//		}
+//
+//		@Override
+//		public void exitAlt1(TParser.Alt1Context ctx)
+//		{
+//			System.out.println("exiting alt1");
+//		}
+//
+//		@Override
+//		public void enterB(TParser.BContext ctx) {
+//			System.out.println("enter b");
+//		}
+//
+//		@Override
+//		public void exitB(TParser.BContext ctx) {
+//			System.out.println("exiting b");
+//		}
+//
+//		@Override
+//		public void enterEveryRule(ParserRuleContext ctx) {
+//			System.out.println("enterEveryRule");
+//		}
+//	}
+}
diff --git a/tool/playground/T.g4 b/tool/playground/T.g4
new file mode 100644
index 000000000..47265ebbf
--- /dev/null
+++ b/tool/playground/T.g4
@@ -0,0 +1,12 @@
+grammar T;
+
+a
+    : 'b'   #alt1
+    | 'c'   #alt2
+    ;
+
+b : 'x' | 'y' {} ;
+
+e : e '*' e
+  | 'foo'
+  ;
diff --git a/tool/pom.xml b/tool/pom.xml
index c1c111a90..42e5f825f 100644
--- a/tool/pom.xml
+++ b/tool/pom.xml
@@ -1,126 +1,117 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <parent>
+    <groupId>org.antlr</groupId>
+    <artifactId>antlr4-master</artifactId>
+    <version>4.5.4-SNAPSHOT</version>
+  </parent>
+  <artifactId>antlr4</artifactId>
+  <name>ANTLR 4 Tool</name>
+  <description>The ANTLR 4 grammar compiler.</description>
 
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <modelVersion>4.0.0</modelVersion>
+  <dependencies>
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <version>4.11</version>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.seleniumhq.selenium</groupId>
+      <artifactId>selenium-java</artifactId>
+      <version>2.44.0</version>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.eclipse.jetty</groupId>
+      <artifactId>jetty-server</artifactId>
+      <version>8.1.16.v20140903</version>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.antlr</groupId>
+      <artifactId>antlr4-runtime</artifactId>
+      <version>${project.version}</version>
+    </dependency>
+    <dependency>
+      <groupId>org.antlr</groupId>
+      <artifactId>antlr-runtime</artifactId>
+      <version>3.5.2</version>
+      <scope>compile</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.antlr</groupId>
+      <artifactId>ST4</artifactId>
+      <version>4.0.8</version>
+      <scope>compile</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.abego.treelayout</groupId>
+      <artifactId>org.abego.treelayout.core</artifactId>
+      <version>1.0.1</version>
+    </dependency>
+  </dependencies>
 
-    <parent>
+  <build>
+    <sourceDirectory>src</sourceDirectory>
+    <testSourceDirectory>test</testSourceDirectory>
+    <testResources>
+      <testResource>
+        <directory>test</directory>
+      </testResource>
+    </testResources>
+    <plugins>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-jar-plugin</artifactId>
+        <version>2.6</version>
+        <executions>
+          <execution>
+            <goals>
+              <goal>test-jar</goal>
+            </goals>
+          </execution>
+        </executions>
+      </plugin>
+      <plugin>
         <groupId>org.antlr</groupId>
-        <artifactId>antlr4-master</artifactId>
-        <version>4.1.1-SNAPSHOT</version>
-    </parent>
-
-    <artifactId>antlr4</artifactId>
-
-    <name>ANTLR 4 Tool</name>
-    <description>The ANTLR 4 grammar compiler.</description>
-
-    <dependencies>
-        <dependency>
-            <groupId>junit</groupId>
-            <artifactId>junit</artifactId>
-            <version>4.10</version>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.antlr</groupId>
-            <artifactId>antlr4-runtime</artifactId>
-            <version>${project.version}</version>
-            <scope>compile</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.antlr</groupId>
-            <artifactId>antlr-runtime</artifactId>
-            <version>3.5</version>
-            <scope>compile</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.antlr</groupId>
-            <artifactId>ST4</artifactId>
-            <version>4.0.7</version>
-            <scope>compile</scope>
-        </dependency>
-    </dependencies>
-
-    <profiles>
-        <profile>
-            <id>sonatype-oss-release</id>
-            <build>
-                <plugins>
-                    <plugin>
-                        <groupId>org.apache.maven.plugins</groupId>
-                        <artifactId>maven-shade-plugin</artifactId>
-                        <version>2.1</version>
-                        <inherited>false</inherited>
-                        <executions>
-                            <execution>
-                                <phase>package</phase>
-                                <goals>
-                                    <goal>shade</goal>
-                                </goals>
-                                <configuration>
-                                    <minimizeJar>true</minimizeJar>
-                                    <createDependencyReducedPom>false</createDependencyReducedPom>
-                                    <shadedArtifactAttached>true</shadedArtifactAttached>
-                                    <createSourcesJar>true</createSourcesJar>
-                                    <shadedClassifierName>complete</shadedClassifierName>
-                                    <filters>
-                                        <filter>
-                                            <artifact>org.antlr:antlr4-runtime</artifact>
-                                            <includes>
-                                                <include>org/antlr/v4/runtime/**</include>
-                                            </includes>
-                                        </filter>
-                                    </filters>
-                                    <transformers>
-                                        <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
-                                            <mainClass>org.antlr.v4.Tool</mainClass>
-                                        </transformer>
-                                    </transformers>
-                                </configuration>
-                            </execution>
-                        </executions>
-                    </plugin>
-                </plugins>
-            </build>
-        </profile>
-    </profiles>
-
-    <build>
-
-        <sourceDirectory>src</sourceDirectory>
-        <resources>
-            <resource>
-                <directory>resources</directory>
-            </resource>
-        </resources>
-
-        <testSourceDirectory>test</testSourceDirectory>
-        <testResources>
-            <testResource>
-                <directory>test</directory>
-            </testResource>
-        </testResources>
-
-        <plugins>
-
-           <plugin>
-                <groupId>org.antlr</groupId>
-                <artifactId>antlr3-maven-plugin</artifactId>
-                <version>3.5</version>
-                <configuration>
-                    <sourceDirectory>src</sourceDirectory>
-                    <verbose>true</verbose>
-                </configuration>
-                <executions>
-                    <execution>
-                        <goals>
-                            <goal>antlr</goal>
-                        </goals>
-                    </execution>
-                </executions>
-            </plugin>
-
-        </plugins>
-    </build>
-
+        <artifactId>antlr3-maven-plugin</artifactId>
+        <version>3.5.2</version>
+        <configuration>
+          <sourceDirectory>src</sourceDirectory>
+          <verbose>true</verbose>
+        </configuration>
+        <executions>
+          <execution>
+            <goals>
+              <goal>antlr</goal>
+            </goals>
+          </execution>
+        </executions>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-shade-plugin</artifactId>
+        <version>2.3</version>
+        <executions>
+          <execution>
+            <phase>package</phase>
+            <configuration>
+              <dependencyReducedPomLocation>${project.build.directory}/dependency-reduced-pom.xml</dependencyReducedPomLocation>
+              <transformers>
+                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
+                  <manifestEntries>
+                    <Main-Class>org.antlr.v4.Tool</Main-Class>
+                  </manifestEntries>
+                </transformer>
+              </transformers>
+            </configuration>
+            <goals>
+              <goal>shade</goal>
+            </goals>
+          </execution>
+        </executions>
+      </plugin>
+    </plugins>
+  </build>
 </project>
diff --git a/tool/resources/org/antlr/v4/tool/templates/codegen/CSharp/CSharp.stg b/tool/resources/org/antlr/v4/tool/templates/codegen/CSharp/CSharp.stg
new file mode 100644
index 000000000..6d5710922
--- /dev/null
+++ b/tool/resources/org/antlr/v4/tool/templates/codegen/CSharp/CSharp.stg
@@ -0,0 +1,1117 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+
+// args must be <object-model-object>, <fields-resulting-in-STs>
+
+ParserFile(file, parser, namedActions, contextSuperClass) ::= <<
+<fileHeader(file.grammarFileName, file.ANTLRVersion)>
+<if(file.genPackage)>
+namespace <file.genPackage> {
+<endif>
+<namedActions.header>
+using System;
+using System.Text;
+using System.Diagnostics;
+using System.Collections.Generic;
+using Antlr4.Runtime;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Tree;
+using DFA = Antlr4.Runtime.Dfa.DFA;
+
+<parser>
+<if(file.genPackage)>
+} // namespace <file.genPackage>
+<endif>
+>>
+
+ListenerFile(file, header) ::= <<
+<fileHeader(file.grammarFileName, file.ANTLRVersion)>
+<if(file.genPackage)>
+namespace <file.genPackage> {
+<endif>
+<header>
+using Antlr4.Runtime.Misc;
+using IParseTreeListener = Antlr4.Runtime.Tree.IParseTreeListener;
+using IToken = Antlr4.Runtime.IToken;
+
+/// \<summary>
+/// This interface defines a complete listener for a parse tree produced by
+/// \<see cref="<csIdentifier.(file.parserName)>"/>.
+/// \</summary>
+[System.CodeDom.Compiler.GeneratedCode("ANTLR", "<file.ANTLRVersion>")]
+[System.CLSCompliant(false)]
+public interface I<file.grammarName>Listener : IParseTreeListener {
+	<file.listenerNames:{lname |
+/// \<summary>
+<if(file.listenerLabelRuleNames.(lname))>
+/// Enter a parse tree produced by the \<c><lname>\</c>
+/// labeled alternative in \<see cref="<file.parserName>.<file.listenerLabelRuleNames.(lname)>"/>.
+<else>
+/// Enter a parse tree produced by \<see cref="<file.parserName>.<lname>"/>.
+<endif>
+/// \</summary>
+/// \<param name="context">The parse tree.\</param>
+void Enter<lname; format="cap">([NotNull] <csIdentifier.(file.parserName)>.<lname; format="cap">Context context);
+/// \<summary>
+<if(file.listenerLabelRuleNames.(lname))>
+/// Exit a parse tree produced by the \<c><lname>\</c>
+/// labeled alternative in \<see cref="<file.parserName>.<file.listenerLabelRuleNames.(lname)>"/>.
+<else>
+/// Exit a parse tree produced by \<see cref="<file.parserName>.<lname>"/>.
+<endif>
+/// \</summary>
+/// \<param name="context">The parse tree.\</param>
+void Exit<lname; format="cap">([NotNull] <csIdentifier.(file.parserName)>.<lname; format="cap">Context context);}; separator="\n">
+}
+<if(file.genPackage)>
+} // namespace <file.genPackage>
+<endif>
+>>
+
+BaseListenerFile(file, header) ::= <<
+<fileHeader(file.grammarFileName, file.ANTLRVersion)>
+<if(file.genPackage)>
+namespace <file.genPackage> {
+<endif>
+<header>
+
+using Antlr4.Runtime.Misc;
+using IErrorNode = Antlr4.Runtime.Tree.IErrorNode;
+using ITerminalNode = Antlr4.Runtime.Tree.ITerminalNode;
+using IToken = Antlr4.Runtime.IToken;
+using ParserRuleContext = Antlr4.Runtime.ParserRuleContext;
+
+/// \<summary>
+/// This class provides an empty implementation of \<see cref="I<file.grammarName>Listener"/>,
+/// which can be extended to create a listener which only needs to handle a subset
+/// of the available methods.
+/// \</summary>
+[System.CodeDom.Compiler.GeneratedCode("ANTLR", "<file.ANTLRVersion>")]
+[System.CLSCompliant(false)]
+public partial class <file.grammarName>BaseListener : I<file.grammarName>Listener {
+	<file.listenerNames:{lname |
+/// \<summary>
+<if(file.listenerLabelRuleNames.(lname))>
+/// Enter a parse tree produced by the \<c><lname>\</c>
+/// labeled alternative in \<see cref="<file.parserName>.<file.listenerLabelRuleNames.(lname)>"/>.
+<else>
+/// Enter a parse tree produced by \<see cref="<file.parserName>.<lname>"/>.
+<endif>
+/// \<para>The default implementation does nothing.\</para>
+/// \</summary>
+/// \<param name="context">The parse tree.\</param>
+public virtual void Enter<lname; format="cap">([NotNull] <csIdentifier.(file.parserName)>.<lname; format="cap">Context context) { \}
+/// \<summary>
+<if(file.listenerLabelRuleNames.(lname))>
+/// Exit a parse tree produced by the \<c><lname>\</c>
+/// labeled alternative in \<see cref="<file.parserName>.<file.listenerLabelRuleNames.(lname)>"/>.
+<else>
+/// Exit a parse tree produced by \<see cref="<file.parserName>.<lname>"/>.
+<endif>
+/// \<para>The default implementation does nothing.\</para>
+/// \</summary>
+/// \<param name="context">The parse tree.\</param>
+public virtual void Exit<lname; format="cap">([NotNull] <csIdentifier.(file.parserName)>.<lname; format="cap">Context context) { \}}; separator="\n">
+
+	/// \<inheritdoc/>
+	/// \<remarks>The default implementation does nothing.\</remarks>
+	public virtual void EnterEveryRule([NotNull] ParserRuleContext context) { }
+	/// \<inheritdoc/>
+	/// \<remarks>The default implementation does nothing.\</remarks>
+	public virtual void ExitEveryRule([NotNull] ParserRuleContext context) { }
+	/// \<inheritdoc/>
+	/// \<remarks>The default implementation does nothing.\</remarks>
+	public virtual void VisitTerminal([NotNull] ITerminalNode node) { }
+	/// \<inheritdoc/>
+	/// \<remarks>The default implementation does nothing.\</remarks>
+	public virtual void VisitErrorNode([NotNull] IErrorNode node) { }
+}
+<if(file.genPackage)>
+} // namespace <file.genPackage>
+<endif>
+>>
+
+VisitorFile(file, header) ::= <<
+<fileHeader(file.grammarFileName, file.ANTLRVersion)>
+<if(file.genPackage)>
+namespace <file.genPackage> {
+<endif>
+<header>
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Tree;
+using IToken = Antlr4.Runtime.IToken;
+
+/// \<summary>
+/// This interface defines a complete generic visitor for a parse tree produced
+/// by \<see cref="<csIdentifier.(file.parserName)>"/>.
+/// \</summary>
+/// \<typeparam name="Result">The return type of the visit operation.\</typeparam>
+[System.CodeDom.Compiler.GeneratedCode("ANTLR", "<file.ANTLRVersion>")]
+[System.CLSCompliant(false)]
+public interface I<file.grammarName>Visitor\<Result> : IParseTreeVisitor\<Result> {
+	<file.visitorNames:{lname |
+/// \<summary>
+<if(file.visitorLabelRuleNames.(lname))>
+/// Visit a parse tree produced by the \<c><lname>\</c>
+/// labeled alternative in \<see cref="<file.parserName>.<file.visitorLabelRuleNames.(lname)>"/>.
+<else>
+/// Visit a parse tree produced by \<see cref="<file.parserName>.<lname>"/>.
+<endif>
+/// \</summary>
+/// \<param name="context">The parse tree.\</param>
+/// \<return>The visitor result.\</return>
+Result Visit<lname; format="cap">([NotNull] <csIdentifier.(file.parserName)>.<lname; format="cap">Context context);}; separator="\n">
+}
+<if(file.genPackage)>
+} // namespace <file.genPackage>
+<endif>
+>>
+
+BaseVisitorFile(file, header) ::= <<
+<fileHeader(file.grammarFileName, file.ANTLRVersion)>
+<if(file.genPackage)>
+namespace <file.genPackage> {
+<endif>
+<header>
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Tree;
+using IToken = Antlr4.Runtime.IToken;
+using ParserRuleContext = Antlr4.Runtime.ParserRuleContext;
+
+/// \<summary>
+/// This class provides an empty implementation of \<see cref="I<file.grammarName>Visitor{Result}"/>,
+/// which can be extended to create a visitor which only needs to handle a subset
+/// of the available methods.
+/// \</summary>
+/// \<typeparam name="Result">The return type of the visit operation.\</typeparam>
+[System.CodeDom.Compiler.GeneratedCode("ANTLR", "<file.ANTLRVersion>")]
+[System.CLSCompliant(false)]
+public partial class <file.grammarName>BaseVisitor\<Result> : AbstractParseTreeVisitor\<Result>, I<file.grammarName>Visitor\<Result> {
+	<file.visitorNames:{lname |
+/// \<summary>
+<if(file.visitorLabelRuleNames.(lname))>
+/// Visit a parse tree produced by the \<c><lname>\</c>
+/// labeled alternative in \<see cref="<file.parserName>.<file.visitorLabelRuleNames.(lname)>"/>.
+<else>
+/// Visit a parse tree produced by \<see cref="<file.parserName>.<lname>"/>.
+<endif>
+/// \<para>
+/// The default implementation returns the result of calling \<see cref="AbstractParseTreeVisitor{Result\}.VisitChildren(IRuleNode)"/>
+/// on \<paramref name="context"/>.
+/// \</para>
+/// \</summary>
+/// \<param name="context">The parse tree.\</param>
+/// \<return>The visitor result.\</return>
+public virtual Result Visit<lname; format="cap">([NotNull] <csIdentifier.(file.parserName)>.<lname; format="cap">Context context) { return VisitChildren(context); \}}; separator="\n">
+}
+<if(file.genPackage)>
+} // namespace <file.genPackage>
+<endif>
+>>
+
+fileHeader(grammarFileName, ANTLRVersion) ::= <<
+//------------------------------------------------------------------------------
+// \<auto-generated>
+//     This code was generated by a tool.
+//     ANTLR Version: <ANTLRVersion>
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// \</auto-generated>
+//------------------------------------------------------------------------------
+
+// Generated from <grammarFileName> by ANTLR <ANTLRVersion>
+
+// Unreachable code detected
+#pragma warning disable 0162
+// The variable '...' is assigned but its value is never used
+#pragma warning disable 0219
+// Missing XML comment for publicly visible type or member '...'
+#pragma warning disable 1591
+// Ambiguous reference in cref attribute
+#pragma warning disable 419
+
+>>
+
+Parser(parser, funcs, atn, sempredFuncs, superClass) ::= <<
+<Parser_(ctor="parser_ctor", ...)>
+>>
+
+Parser_(parser, funcs, atn, sempredFuncs, ctor, superClass) ::= <<
+[System.CodeDom.Compiler.GeneratedCode("ANTLR", "<file.ANTLRVersion>")]
+[System.CLSCompliant(false)]
+public partial class <csIdentifier.(parser.name)> : <superClass; null="Parser"> {
+	<if(parser.tokens)>
+	public const int
+		<parser.tokens:{k | <k>=<parser.tokens.(k)>}; separator=", ", wrap, anchor>;
+	<endif>
+	public const int
+		<parser.rules:{r | RULE_<r.name> = <r.index>}; separator=", ", wrap, anchor>;
+	public static readonly string[] ruleNames = {
+		<parser.ruleNames:{r | "<r>"}; separator=", ", wrap, anchor>
+	};
+
+	<vocabulary(parser.literalNames, parser.symbolicNames)>
+
+	public override string GrammarFileName { get { return "<parser.grammarFileName>"; } }
+
+	public override string[] RuleNames { get { return ruleNames; } }
+
+	public override string SerializedAtn { get { return _serializedATN; } }
+
+	<namedActions.members>
+	<parser:(ctor)()>
+	<funcs; separator="\n">
+
+<if(sempredFuncs)>
+	public override bool Sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
+		switch (ruleIndex) {
+		<parser.sempredFuncs.values:{f|
+case <f.ruleIndex>: return <f.name>_sempred((<f.ctxType>)_localctx, predIndex);}; separator="\n">
+		}
+		return true;
+	}
+	<sempredFuncs.values; separator="\n">
+<endif>
+
+	<atn>
+}
+>>
+
+vocabulary(literalNames, symbolicNames) ::= <<
+private static readonly string[] _LiteralNames = {
+	<literalNames:{t | <t>}; null="null", separator=", ", wrap, anchor>
+};
+private static readonly string[] _SymbolicNames = {
+	<symbolicNames:{t | <t>}; null="null", separator=", ", wrap, anchor>
+};
+public static readonly IVocabulary DefaultVocabulary = new Vocabulary(_LiteralNames, _SymbolicNames);
+
+[NotNull]
+public override IVocabulary Vocabulary
+{
+	get
+	{
+		return DefaultVocabulary;
+	}
+}
+>>
+
+dumpActions(recog, argFuncs, actionFuncs, sempredFuncs) ::= <<
+<if(actionFuncs)>
+public override void Action(RuleContext _localctx, int ruleIndex, int actionIndex) {
+	switch (ruleIndex) {
+	<recog.actionFuncs.values:{f|
+case <f.ruleIndex> : <f.name>_action(<if(!recog.modes)>(<f.ctxType>)<endif>_localctx, actionIndex); break;}; separator="\n">
+	}
+}
+<actionFuncs.values; separator="\n">
+<endif>
+<if(sempredFuncs)>
+public override bool Sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
+	switch (ruleIndex) {
+	<recog.sempredFuncs.values:{f|
+case <f.ruleIndex> : return <f.name>_sempred(<if(!recog.modes)>(<f.ctxType>)<endif>_localctx, predIndex);}; separator="\n">
+	}
+	return true;
+}
+<sempredFuncs.values; separator="\n">
+<endif>
+>>
+
+parser_ctor(parser) ::= <<
+public <csIdentifier.(parser.name)>(ITokenStream input)
+	: base(input)
+{
+	Interpreter = new ParserATNSimulator(this,_ATN);
+}
+>>
+
+/* This generates a private method since the actionIndex is generated, making an
+ * overriding implementation impossible to maintain.
+ */
+RuleActionFunction(r, actions) ::= <<
+private void <r.name>_action(<r.ctxType> _localctx, int actionIndex) {
+	switch (actionIndex) {
+	<actions:{index|
+case <index>: <actions.(index)> break;}; separator="\n">
+	}
+}
+>>
+
+/* This generates a private method since the predIndex is generated, making an
+ * overriding implementation impossible to maintain.
+ */
+RuleSempredFunction(r, actions) ::= <<
+private bool <r.name>_sempred(<r.ctxType> _localctx, int predIndex) {
+	switch (predIndex) {
+	<actions:{index|
+case <index>: return <actions.(index)>;}; separator="\n">
+	}
+	return true;
+}
+>>
+
+RuleFunction(currentRule,args,code,locals,ruleCtx,altLabelCtxs,namedActions,finallyAction,postamble,exceptions) ::= <<
+
+<if(ruleCtx)>
+<ruleCtx>
+<endif>
+<altLabelCtxs:{l | <altLabelCtxs.(l)>}; separator="\n">
+
+[RuleVersion(<namedActions.version; null="0">)]
+<if(currentRule.modifiers)><currentRule.modifiers:{f | <f> }><else>public <endif><currentRule.ctxType> <csIdentifier.(currentRule.name)>(<args; separator=", ">) {
+	<currentRule.ctxType> _localctx = new <currentRule.ctxType>(Context, State<currentRule.args:{a | , <csIdentifier.(a.name)>}>);
+	EnterRule(_localctx, <currentRule.startState>, RULE_<currentRule.name>);
+	<namedActions.init>
+	<locals; separator="\n">
+	try {
+<if(currentRule.hasLookaheadBlock)>
+		int _alt;
+<endif>
+		<code>
+		<postamble; separator="\n">
+		<namedActions.after>
+	}
+	<if(exceptions)>
+	<exceptions; separator="\n">
+	<else>
+	catch (RecognitionException re) {
+		_localctx.exception = re;
+		ErrorHandler.ReportError(this, re);
+		ErrorHandler.Recover(this, re);
+	}
+	<endif>
+	finally {
+		<finallyAction>
+		ExitRule();
+	}
+	return _localctx;
+}
+>>
+
+LeftFactoredRuleFunction(currentRule,args,code,locals,namedActions,finallyAction,postamble) ::=
+<<
+
+<if(currentRule.modifiers)><currentRule.modifiers:{f | <f> }><else>private <endif><currentRule.ctxType> <csIdentifier.(currentRule.name)>(<args; separator=", ">) {
+	<currentRule.ctxType> _localctx = new <currentRule.ctxType>(Context, State<currentRule.args:{a | , <csIdentifier.(a.name)>}>);
+	EnterLeftFactoredRule(_localctx, <currentRule.startState>, RULE_<currentRule.variantOf>);
+	<namedActions.init>
+	<locals; separator="\n">
+	try {
+<if(currentRule.hasLookaheadBlock)>
+		int _alt;
+<endif>
+		<code>
+		<postamble; separator="\n">
+		<namedActions.after>
+	}
+	catch (RecognitionException re) {
+		_localctx.exception = re;
+		ErrorHandler.ReportError(this, re);
+		ErrorHandler.Recover(this, re);
+	}
+	finally {
+		<finallyAction>
+		ExitRule();
+	}
+	return _localctx;
+}
+>>
+
+// This behaves similar to RuleFunction (enterRule is called, and no adjustments
+// are made to the parse tree), but since it's still a variant no context class
+// needs to be generated.
+LeftUnfactoredRuleFunction(currentRule,args,code,locals,namedActions,finallyAction,postamble) ::=
+<<
+
+<if(currentRule.modifiers)><currentRule.modifiers:{f | <f> }><else>private <endif><currentRule.ctxType> <csIdentifier.(currentRule.name)>(<args; separator=", ">) {
+	<currentRule.ctxType> _localctx = new <currentRule.ctxType>(Context, State<currentRule.args:{a | , <csIdentifier.(a.name)>}>);
+	EnterRule(_localctx, <currentRule.startState>, RULE_<currentRule.variantOf>);
+	<namedActions.init>
+	<locals; separator="\n">
+	try {
+<if(currentRule.hasLookaheadBlock)>
+		int _alt;
+<endif>
+		<code>
+		<postamble; separator="\n">
+		<namedActions.after>
+	}
+	catch (RecognitionException re) {
+		_localctx.exception = re;
+		ErrorHandler.ReportError(this, re);
+		ErrorHandler.Recover(this, re);
+	}
+	finally {
+		<finallyAction>
+		ExitRule();
+	}
+	return _localctx;
+}
+>>
+
+LeftRecursiveRuleFunction(currentRule,args,code,locals,ruleCtx,altLabelCtxs,
+	namedActions,finallyAction,postamble) ::=
+<<
+
+<ruleCtx>
+<altLabelCtxs:{l | <altLabelCtxs.(l)>}; separator="\n">
+
+[RuleVersion(<namedActions.version; null="0">)]
+<if(currentRule.modifiers)><currentRule.modifiers:{f | <f> }><else>public <endif><currentRule.ctxType> <csIdentifier.(currentRule.name)>(<args; separator=", ">) {
+	return <csIdentifier.(currentRule.name)>(0<currentRule.args:{a | , <csIdentifier.(a.name)>}>);
+}
+
+private <currentRule.ctxType> <csIdentifier.(currentRule.name)>(int _p<args:{a | , <a>}>) {
+	ParserRuleContext _parentctx = Context;
+	int _parentState = State;
+	<currentRule.ctxType> _localctx = new <currentRule.ctxType>(Context, _parentState<currentRule.args:{a | , <csIdentifier.(a.name)>}>);
+	<currentRule.ctxType> _prevctx = _localctx;
+	int _startState = <currentRule.startState>;
+	EnterRecursionRule(_localctx, <currentRule.startState>, RULE_<currentRule.name>, _p);
+	<namedActions.init>
+	<locals; separator="\n">
+	try {
+<if(currentRule.hasLookaheadBlock)>
+		int _alt;
+<endif>
+		<code>
+		<postamble; separator="\n">
+		<namedActions.after>
+	}
+	catch (RecognitionException re) {
+		_localctx.exception = re;
+		ErrorHandler.ReportError(this, re);
+		ErrorHandler.Recover(this, re);
+	}
+	finally {
+		<finallyAction>
+		UnrollRecursionContexts(_parentctx);
+	}
+	return _localctx;
+}
+>>
+
+CodeBlockForOuterMostAlt(currentOuterMostAltCodeBlock, locals, preamble, ops) ::= <<
+<if(currentOuterMostAltCodeBlock.altLabel)>_localctx = new <currentOuterMostAltCodeBlock.altLabel; format="cap">Context(_localctx);<endif>
+EnterOuterAlt(_localctx, <currentOuterMostAltCodeBlock.alt.altNum>);
+<CodeBlockForAlt(currentAltCodeBlock=currentOuterMostAltCodeBlock, ...)>
+>>
+
+CodeBlockForAlt(currentAltCodeBlock, locals, preamble, ops) ::= <<
+{
+<locals; separator="\n">
+<preamble; separator="\n">
+<ops; separator="\n">
+}
+>>
+
+LL1AltBlock(choice, preamble, alts, error) ::= <<
+State = <choice.stateNumber>;
+<if(choice.label)><labelref(choice.label)> = TokenStream.Lt(1);<endif>
+<preamble; separator="\n">
+switch (TokenStream.La(1)) {
+<choice.altLook,alts:{look,alt| <cases(ttypes=look)>
+	<alt>
+	break;}; separator="\n">
+default:
+	<error>
+}
+>>
+
+LL1OptionalBlock(choice, alts, error) ::= <<
+State = <choice.stateNumber>;
+switch (TokenStream.La(1)) {
+<choice.altLook,alts:{look,alt| <cases(ttypes=look)>
+	<alt>
+	break;}; separator="\n">
+default:
+	<error>
+}
+>>
+
+LL1OptionalBlockSingleAlt(choice, expr, alts, preamble, error, followExpr) ::= <<
+State = <choice.stateNumber>;
+<preamble; separator="\n">
+if (<expr>) {
+	<alts; separator="\n">
+}
+<!else if ( !(<followExpr>) ) <error>!>
+>>
+
+LL1StarBlockSingleAlt(choice, loopExpr, alts, preamble, iteration) ::= <<
+State = <choice.stateNumber>;
+ErrorHandler.Sync(this);
+<preamble; separator="\n">
+while (<loopExpr>) {
+	<alts; separator="\n">
+	State = <choice.loopBackStateNumber>;
+	ErrorHandler.Sync(this);
+	<iteration>
+}
+>>
+
+LL1PlusBlockSingleAlt(choice, loopExpr, alts, preamble, iteration) ::= <<
+State = <choice.blockStartStateNumber>;<! alt block decision !>
+ErrorHandler.Sync(this);
+<preamble; separator="\n">
+do {
+	<alts; separator="\n">
+	State = <choice.stateNumber>;<! loopback/exit decision !>
+	ErrorHandler.Sync(this);
+	<iteration>
+} while ( <loopExpr> );
+>>
+
+// LL(*) stuff
+
+AltBlock(choice, preamble, alts, error) ::= <<
+State = <choice.stateNumber>;
+ErrorHandler.Sync(this);
+<if(choice.label)><labelref(choice.label)> = TokenStream.Lt(1);<endif>
+<preamble; separator="\n">
+switch ( Interpreter.AdaptivePredict(TokenStream,<choice.decision>,Context) ) {
+<alts:{alt |
+case <i>:
+	<alt>
+	break;}; separator="\n">
+}
+>>
+
+OptionalBlock(choice, alts, error) ::= <<
+State = <choice.stateNumber>;
+ErrorHandler.Sync(this);
+switch ( Interpreter.AdaptivePredict(TokenStream,<choice.decision>,Context) ) {
+<alts:{alt |
+case <i><if(!choice.ast.greedy)>+1<endif>:
+	<alt>
+	break;}; separator="\n">
+}
+>>
+
+StarBlock(choice, alts, sync, iteration) ::= <<
+State = <choice.stateNumber>;
+ErrorHandler.Sync(this);
+_alt = Interpreter.AdaptivePredict(TokenStream,<choice.decision>,Context);
+while ( _alt!=<choice.exitAlt> && _alt!=global::Antlr4.Runtime.Atn.ATN.InvalidAltNumber ) {
+	if ( _alt==1<if(!choice.ast.greedy)>+1<endif> ) {
+		<iteration>
+		<alts> <! should only be one !>
+	}
+	State = <choice.loopBackStateNumber>;
+	ErrorHandler.Sync(this);
+	_alt = Interpreter.AdaptivePredict(TokenStream,<choice.decision>,Context);
+}
+>>
+
+PlusBlock(choice, alts, error) ::= <<
+State = <choice.blockStartStateNumber>;<! alt block decision !>
+ErrorHandler.Sync(this);
+_alt = 1<if(!choice.ast.greedy)>+1<endif>;
+do {
+	switch (_alt) {
+	<alts:{alt|
+case <i><if(!choice.ast.greedy)>+1<endif>:
+	<alt>
+	break;}; separator="\n">
+	default:
+		<error>
+	}
+	State = <choice.loopBackStateNumber>;<! loopback/exit decision !>
+	ErrorHandler.Sync(this);
+	_alt = Interpreter.AdaptivePredict(TokenStream,<choice.decision>,Context);
+} while ( _alt!=<choice.exitAlt> && _alt!=global::Antlr4.Runtime.Atn.ATN.InvalidAltNumber );
+>>
+
+Sync(s) ::= "Sync(<s.expecting.name>);"
+
+ThrowNoViableAlt(t) ::= "throw new NoViableAltException(this);"
+
+TestSetInline(s) ::= <<
+<s.bitsets:{bits | <if(rest(rest(bits.ttypes)))><bitsetBitfieldComparison(s, bits)><else><bitsetInlineComparison(s, bits)><endif>}; separator=" || ">
+>>
+
+// Java language spec 15.19 - shift operators mask operands rather than overflow to 0... need range test
+testShiftInRange(shiftAmount) ::= <<
+((<shiftAmount>) & ~0x3f) == 0
+>>
+
+// produces smaller bytecode only when bits.ttypes contains more than two items
+bitsetBitfieldComparison(s, bits) ::= <%
+(<testShiftInRange({<offsetShift(s.varName, bits.shift)>})> && ((1L \<\< <offsetShift(s.varName, bits.shift)>) & (<bits.ttypes:{ttype | (1L \<\< <offsetShift(tokenType.(ttype), bits.shift)>)}; separator=" | ">)) != 0)
+%>
+
+isZero ::= [
+"0":true,
+default:false
+]
+
+offsetShift(shiftAmount, offset) ::= <%
+<if(!isZero.(offset))>(<shiftAmount> - <offset>)<else><shiftAmount><endif>
+%>
+
+// produces more efficient bytecode when bits.ttypes contains at most two items
+bitsetInlineComparison(s, bits) ::= <%
+<bits.ttypes:{ttype | <s.varName>==<tokenType.(ttype)>}; separator=" || ">
+%>
+
+cases(ttypes) ::= <<
+<ttypes:{t | case <tokenType.(t)>:}; separator="\n">
+>>
+
+InvokeRule(r, argExprsChunks) ::= <<
+State = <r.stateNumber>; <if(r.labels)><r.labels:{l | <labelref(l)> = }><endif><csIdentifier.(r.name)>(<if(r.ast.options.p)><r.ast.options.p><if(argExprsChunks)>,<endif><endif><argExprsChunks>);
+>>
+
+MatchToken(m) ::= <<
+State = <m.stateNumber>; <if(m.labels)><m.labels:{l | <labelref(l)> = }><endif>Match(<tokenType.(m.name)>);
+>>
+
+MatchSet(m, expr, capture) ::= "<CommonSetStuff(m, expr, capture, false)>"
+
+MatchNotSet(m, expr, capture) ::= "<CommonSetStuff(m, expr, capture, true)>"
+
+CommonSetStuff(m, expr, capture, invert) ::= <<
+State = <m.stateNumber>;
+<if(m.labels)><m.labels:{l | <labelref(l)> = }>TokenStream.Lt(1);<endif>
+<capture>
+if ( <if(invert)><m.varName> \<= 0 || <else>!<endif>(<expr>) ) {
+	<if(m.labels)><m.labels:{l | <labelref(l)> = }><endif>ErrorHandler.RecoverInline(this);
+}
+else {
+    Consume();
+}
+>>
+
+Wildcard(w) ::= <<
+State = <w.stateNumber>;
+<if(w.labels)><w.labels:{l | <labelref(l)> = }><endif>MatchWildcard();
+>>
+
+// ACTION STUFF
+
+Action(a, foo, chunks) ::= "<chunks>"
+
+ArgAction(a, chunks) ::= "<chunks>"
+
+SemPred(p, chunks, failChunks) ::= <<
+State = <p.stateNumber>;
+if (!(<chunks>)) throw new FailedPredicateException(this, <p.predicate><if(failChunks)>, <failChunks><elseif(p.msg)>, <p.msg><endif>);
+>>
+
+ExceptionClause(e, catchArg, catchAction) ::= <<
+catch (<catchArg>) {
+	<catchAction>
+}
+>>
+
+// lexer actions are not associated with model objects
+
+LexerSkipCommand()  ::= "Skip();"
+LexerMoreCommand()  ::= "More();"
+LexerPopModeCommand() ::= "PopMode();"
+
+LexerTypeCommand(arg)      ::= "_type = <tokenType.(arg)>;"
+LexerChannelCommand(arg)   ::= "_channel = <channelName.(arg)>;"
+LexerModeCommand(arg)      ::= "_mode = <modeName.(arg)>;"
+LexerPushModeCommand(arg)  ::= "PushMode(<modeName.(arg)>);"
+
+ActionText(t) ::= "<t.text>"
+ActionTemplate(t) ::= "<t.st>"
+ArgRef(a) ::= "_localctx.<csIdentifier.(a.name)>"
+LocalRef(a) ::= "_localctx.<csIdentifier.(a.name)>"
+RetValueRef(a) ::= "_localctx.<csIdentifier.(a.name)>"
+QRetValueRef(a) ::= "<ctx(a)>.<a.dict>.<csIdentifier.(a.name)>"
+/** How to translate $tokenLabel */
+TokenRef(t) ::= "<ctx(t)>.<csIdentifier.(tokenType.(t.name))>"
+LabelRef(t) ::= "<ctx(t)>.<csIdentifier.(t.name)>"
+ListLabelRef(t) ::= "<ctx(t)>.<ListLabelName(csIdentifier.(t.name))>"
+SetAttr(s,rhsChunks) ::= "<ctx(s)>.<csIdentifier.(s.name)> = <rhsChunks>;"
+
+TokenLabelType() ::= "<file.TokenLabelType; null={IToken}>"
+InputSymbolType() ::= "<file.InputSymbolType; null={IToken}>"
+
+TokenPropertyRef_text(t) ::= "(<ctx(t)>.<tokenType.(t.label)>!=null?<ctx(t)>.<tokenType.(t.label)>.Text:null)"
+TokenPropertyRef_type(t) ::= "(<ctx(t)>.<tokenType.(t.label)>!=null?<ctx(t)>.<tokenType.(t.label)>.Type:0)"
+TokenPropertyRef_line(t) ::= "(<ctx(t)>.<tokenType.(t.label)>!=null?<ctx(t)>.<tokenType.(t.label)>.Line:0)"
+TokenPropertyRef_pos(t) ::= "(<ctx(t)>.<tokenType.(t.label)>!=null?<ctx(t)>.<tokenType.(t.label)>.CharPositionInLine:0)"
+TokenPropertyRef_channel(t) ::= "(<ctx(t)>.<tokenType.(t.label)>!=null?<ctx(t)>.<tokenType.(t.label)>.Channel:0)"
+TokenPropertyRef_index(t) ::= "(<ctx(t)>.<tokenType.(t.label)>!=null?<ctx(t)>.<tokenType.(t.label)>.TokenIndex:0)"
+TokenPropertyRef_int(t) ::= "(<ctx(t)>.<tokenType.(t.label)>!=null?int.Parse(<ctx(t)>.<tokenType.(t.label)>.Text):0)"
+
+RulePropertyRef_start(r) ::= "(<ctx(r)>.<r.label>!=null?(<ctx(r)>.<r.label>.Start):null)"
+RulePropertyRef_stop(r)	 ::= "(<ctx(r)>.<r.label>!=null?(<ctx(r)>.<r.label>.Stop):null)"
+RulePropertyRef_text(r)	 ::= "(<ctx(r)>.<r.label>!=null?TokenStream.GetText(<ctx(r)>.<r.label>.Start,<ctx(r)>.<r.label>.Stop):null)"
+RulePropertyRef_ctx(r)	 ::= "<ctx(r)>.<r.label>"
+RulePropertyRef_parser(r)	 ::= "this"
+
+ThisRulePropertyRef_start(r) ::= "_localctx.Start"
+ThisRulePropertyRef_stop(r)	 ::= "_localctx.Stop"
+ThisRulePropertyRef_text(r)	 ::= "TokenStream.GetText(_localctx.Start, TokenStream.Lt(-1))"
+ThisRulePropertyRef_ctx(r)	 ::= "_localctx"
+ThisRulePropertyRef_parser(r)	 ::= "this"
+
+NonLocalAttrRef(s)		 ::= <%((<s.ruleName; format="cap">Context)GetInvokingContext(<s.ruleIndex>)).<csIdentifier.(s.name)>%>
+SetNonLocalAttr(s, rhsChunks)	  ::=
+	<%((<s.ruleName; format="cap">Context)GetInvokingContext(<s.ruleIndex>)).<csIdentifier.(s.name)> = <rhsChunks>;%>
+
+AddToLabelList(a) ::= "<ctx(a.label)>.<a.listName>.Add(<labelref(a.label)>);"
+
+TokenDecl(t) ::= "<TokenLabelType()> <csIdentifier.(tokenType.(t.name))>"
+TokenTypeDecl(t) ::= "int <csIdentifier.(tokenType.(t.name))>;"
+TokenListDecl(t) ::= "IList\<IToken> <csIdentifier.(tokenType.(t.name))> = new List\<IToken>()"
+RuleContextDecl(r) ::= "<r.ctxName> <csIdentifier.(r.name)>"
+RuleContextListDecl(rdecl) ::= "IList\<<rdecl.ctxName>> <csIdentifier.(rdecl.name)> = new List\<<rdecl.ctxName>>()"
+
+contextGetterCollection(elementType) ::= <%
+<elementType>[]
+%>
+
+ContextTokenGetterDecl(t)      ::=
+    "public ITerminalNode <csIdentifier.(tokenType.(t.name))>() { return GetToken(<csIdentifier.(parser.name)>.<csIdentifier.(tokenType.(t.name))>, 0); }"
+ContextTokenListGetterDecl(t)  ::= <<
+public <contextGetterCollection("ITerminalNode")> <csIdentifier.(tokenType.(t.name))>() { return GetTokens(<csIdentifier.(parser.name)>.<csIdentifier.(tokenType.(t.name))>); }
+>>
+ContextTokenListIndexedGetterDecl(t)  ::= <<
+public ITerminalNode <csIdentifier.(tokenType.(t.name))>(int i) {
+	return GetToken(<csIdentifier.(parser.name)>.<csIdentifier.(tokenType.(t.name))>, i);
+}
+>>
+ContextRuleGetterDecl(r)       ::= <<
+public <r.ctxName> <csIdentifier.(r.name)>() {
+	return GetRuleContext\<<r.ctxName>\>(0);
+}
+>>
+ContextRuleListGetterDecl(r)   ::= <<
+public <contextGetterCollection({<r.ctxName>})> <csIdentifier.(r.name)>() {
+	return GetRuleContexts\<<r.ctxName>\>();
+}
+>>
+ContextRuleListIndexedGetterDecl(r)   ::= <<
+public <r.ctxName> <csIdentifier.(r.name)>(int i) {
+	return GetRuleContext\<<r.ctxName>\>(i);
+}
+>>
+
+LexerRuleContext() ::= "RuleContext"
+
+/** The rule context name is the rule followed by a suffix; e.g.,
+ *	r becomes rContext.
+ */
+RuleContextNameSuffix() ::= "Context"
+
+ImplicitTokenLabel(tokenName) ::= "_<tokenType.(tokenName)>"
+ImplicitRuleLabel(ruleName)	  ::= "_<ruleName>"
+ImplicitSetLabel(id)		  ::= "_tset<id>"
+ListLabelName(label)		  ::= "_<label>"
+
+CaptureNextToken(d) ::= "<d.varName> = TokenStream.Lt(1);"
+CaptureNextTokenType(d) ::= "<d.varName> = TokenStream.La(1);"
+
+StructDecl(struct,ctorAttrs,attrs,getters,dispatchMethods,interfaces,extensionMembers,
+           superClass={ParserRuleContext}) ::= <<
+public partial class <struct.name> : <if(contextSuperClass)><contextSuperClass><else>ParserRuleContext<endif><if(interfaces)>, <interfaces; separator=", "><endif> {
+	<attrs:{a | public <a>;}; separator="\n">
+	<getters:{g | <g>}; separator="\n">
+	<if(ctorAttrs)>public <struct.name>(ParserRuleContext parent, int invokingState) : base(parent, invokingState) { }<endif>
+	public <struct.name>(ParserRuleContext parent, int invokingState<ctorAttrs:{a | , <a>}>)
+		: base(parent, invokingState)
+	{
+		<struct.ctorAttrs:{a | this.<csIdentifier.(a.name)> = <csIdentifier.(a.name)>;}; separator="\n">
+	}
+	public override int RuleIndex { get { return RULE_<struct.derivedFromName>; } }
+<if(struct.provideCopyFrom)> <! don't need copy unless we have subclasses !>
+	public <struct.name>() { }
+	public virtual void CopyFrom(<struct.name> context) {
+		base.CopyFrom(context);
+		<struct.attrs:{a | this.<csIdentifier.(a.name)> = context.<csIdentifier.(a.name)>;}; separator="\n">
+	}
+<endif>
+	<dispatchMethods; separator="\n">
+	<extensionMembers; separator="\n">
+}
+>>
+
+AltLabelStructDecl(struct,attrs,getters,dispatchMethods) ::= <<
+public partial class <struct.name> : <currentRule.name; format="cap">Context {
+	<attrs:{a | public <a>;}; separator="\n">
+	<getters:{g | <g>}; separator="\n">
+	public <struct.name>(<currentRule.name; format="cap">Context context) { CopyFrom(context); }
+	<dispatchMethods; separator="\n">
+}
+>>
+
+ListenerDispatchMethod(method) ::= <<
+public override void <if(method.isEnter)>Enter<else>Exit<endif>Rule(IParseTreeListener listener) {
+	I<parser.grammarName>Listener typedListener = listener as I<parser.grammarName>Listener;
+	if (typedListener != null) typedListener.<if(method.isEnter)>Enter<else>Exit<endif><struct.derivedFromName; format="cap">(this);
+}
+>>
+
+VisitorDispatchMethod(method) ::= <<
+public override TResult Accept\<TResult>(IParseTreeVisitor\<TResult> visitor) {
+	I<parser.grammarName>Visitor\<TResult> typedVisitor = visitor as I<parser.grammarName>Visitor\<TResult>;
+	if (typedVisitor != null) return typedVisitor.Visit<struct.derivedFromName; format="cap">(this);
+	else return visitor.VisitChildren(this);
+}
+>>
+
+AttributeDecl(d) ::= "<d.type> <csIdentifier.(d.name)><if(d.initValue)> = <d.initValue><endif>"
+
+/** If we don't know location of label def x, use this template */
+labelref(x) ::= "<if(!x.isLocal)><typedContext(x.ctx)>.<endif><csIdentifier.(x.name)>"
+
+/** For any action chunk, what is correctly-typed context struct ptr? */
+ctx(actionChunk) ::= "<typedContext(actionChunk.ctx)>"
+
+// only casts _localctx to the type when the cast isn't redundant (i.e. to a sub-context for a labeled alt)
+typedContext(ctx) ::= "<if(ctx.provideCopyFrom)>((<ctx.name>)_localctx)<else>_localctx<endif>"
+
+// used for left-recursive rules
+recRuleAltPredicate(ruleName,opPrec)  ::= "Precpred(Context, <opPrec>)"
+recRuleSetReturnAction(src,name)	  ::= "$<name>=$<src>.<name>;"
+recRuleSetStopToken()                 ::= "Context.Stop = TokenStream.Lt(-1);"
+
+recRuleAltStartAction(ruleName, ctxName, label, isListLabel) ::= <<
+_localctx = new <ctxName>Context(_parentctx, _parentState);
+<if(label)>
+<if(isListLabel)>
+_localctx.<label>.Add(_prevctx);
+<else>
+_localctx.<label> = _prevctx;
+<endif>
+<endif>
+PushNewRecursionContext(_localctx, _startState, RULE_<ruleName>);
+>>
+
+recRuleLabeledAltStartAction(ruleName, currentAltLabel, label, isListLabel) ::= <<
+_localctx = new <currentAltLabel; format="cap">Context(new <ruleName; format="cap">Context(_parentctx, _parentState));
+<if(label)>
+<if(isListLabel)>
+((<currentAltLabel; format="cap">Context)_localctx).<label>.Add(_prevctx);
+<else>
+((<currentAltLabel; format="cap">Context)_localctx).<label> = _prevctx;
+<endif>
+<endif>
+PushNewRecursionContext(_localctx, _startState, RULE_<ruleName>);
+>>
+
+recRuleReplaceContext(ctxName) ::= <<
+_localctx = new <ctxName>Context(_localctx);
+Context = _localctx;
+_prevctx = _localctx;
+>>
+
+recRuleSetPrevCtx() ::= <<
+if ( ParseListeners!=null )
+	TriggerExitRuleEvent();
+_prevctx = _localctx;
+>>
+
+
+LexerFile(file, lexer, namedActions) ::= <<
+<fileHeader(file.grammarFileName, file.ANTLRVersion)>
+<if(file.genPackage)>
+namespace <file.genPackage> {
+<endif>
+<namedActions.header>
+using System;
+using System.Text;
+using Antlr4.Runtime;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Misc;
+using DFA = Antlr4.Runtime.Dfa.DFA;
+
+<lexer>
+<if(file.genPackage)>
+} // namespace <file.genPackage>
+<endif>
+>>
+
+Lexer(lexer, atn, actionFuncs, sempredFuncs, superClass) ::= <<
+[System.CodeDom.Compiler.GeneratedCode("ANTLR", "<file.ANTLRVersion>")]
+[System.CLSCompliant(false)]
+public partial class <csIdentifier.(lexer.name)> : <superClass; null="Lexer"> {
+	public const int
+		<lexer.tokens:{k | <tokenType.(k)>=<lexer.tokens.(k)>}; separator=", ", wrap, anchor>;
+	<if(lexer.channels)>
+	public const int
+		<lexer.channels:{k | <csIdentifier.(k)>=<lexer.channels.(k)>}; separator=", ", wrap, anchor>;
+	<endif>
+	<rest(lexer.modes):{m| public const int <modeName.(m)> = <i>;}; separator="\n">
+	public static string[] modeNames = {
+		<lexer.modes:{m| "<m>"}; separator=", ", wrap, anchor>
+	};
+
+	public static readonly string[] ruleNames = {
+		<lexer.ruleNames:{r | "<r>"}; separator=", ", wrap, anchor>
+	};
+
+	<namedActions.members>
+
+	public <csIdentifier.(lexer.name)>(ICharStream input)
+		: base(input)
+	{
+		Interpreter = new LexerATNSimulator(this,_ATN);
+	}
+
+	<vocabulary(lexer.literalNames, lexer.symbolicNames)>
+
+	public override string GrammarFileName { get { return "<lexer.grammarFileName>"; } }
+
+	public override string[] RuleNames { get { return ruleNames; } }
+
+	public override string[] ModeNames { get { return modeNames; } }
+
+	public override string SerializedAtn { get { return _serializedATN; } }
+
+	<dumpActions(lexer, "", actionFuncs, sempredFuncs)>
+	<atn>
+}
+>>
+
+
+SerializedATN(model) ::= <<
+private static string _serializedATN = _serializeATN();
+private static string _serializeATN()
+{
+    StringBuilder sb = new StringBuilder();
+    sb.Append("<model.serialized; wrap={");<\n><\t>sb.Append("}>");
+    return sb.ToString();
+}
+
+public static readonly ATN _ATN =
+	new ATNDeserializer().Deserialize(_serializedATN.ToCharArray());
+>>
+
+initValue(typeName) ::= <<
+default(<typeName>)
+>>
+
+codeFileExtension() ::= ".cs"
+
+modeName ::= [
+	"DEFAULT_MODE" : "DefaultMode",
+	default : key
+]
+
+channelName ::= [
+	"HIDDEN" : "Hidden",
+	"DEFAULT_TOKEN_CHANNEL" : "DefaultTokenChannel",
+	default : key
+]
+
+tokenType ::= [
+	"EOF" : "Eof",
+	default : key
+]
+
+csIdentifier ::= [
+	"abstract" : "@abstract",
+	"as" : "@as",
+	"base" : "@base",
+	"bool" : "@bool",
+	"break" : "@break",
+	"byte" : "@byte",
+	"case" : "@case",
+	"catch" : "@catch",
+	"char" : "@char",
+	"checked" : "@checked",
+	"class" : "@class",
+	"const" : "@const",
+	"continue" : "@continue",
+	"decimal" : "@decimal",
+	"default" : "@default",
+	"delegate" : "@delegate",
+	"do" : "@do",
+	"double" : "@double",
+	"else" : "@else",
+	"enum" : "@enum",
+	"event" : "@event",
+	"explicit" : "@explicit",
+	"extern" : "@extern",
+	"false" : "@false",
+	"finally" : "@finally",
+	"fixed" : "@fixed",
+	"float" : "@float",
+	"for" : "@for",
+	"foreach" : "@foreach",
+	"goto" : "@goto",
+	"if" : "@if",
+	"implicit" : "@implicit",
+	"in" : "@in",
+	"int" : "@int",
+	"interface" : "@interface",
+	"internal" : "@internal",
+	"is" : "@is",
+	"lock" : "@lock",
+	"long" : "@long",
+	"namespace" : "@namespace",
+	"new" : "@new",
+	"null" : "@null",
+	"object" : "@object",
+	"operator" : "@operator",
+	"out" : "@out",
+	"override" : "@override",
+	"params" : "@params",
+	"private" : "@private",
+	"protected" : "@protected",
+	"public" : "@public",
+	"readonly" : "@readonly",
+	"ref" : "@ref",
+	"return" : "@return",
+	"sbyte" : "@sbyte",
+	"sealed" : "@sealed",
+	"short" : "@short",
+	"sizeof" : "@sizeof",
+	"stackalloc" : "@stackalloc",
+	"static" : "@static",
+	"string" : "@string",
+	"struct" : "@struct",
+	"switch" : "@switch",
+	"this" : "@this",
+	"throw" : "@throw",
+	"true" : "@true",
+	"try" : "@try",
+	"typeof" : "@typeof",
+	"uint" : "@uint",
+	"ulong" : "@ulong",
+	"unchecked" : "@unchecked",
+	"unsafe" : "@unsafe",
+	"ushort" : "@ushort",
+	"using" : "@using",
+	"virtual" : "@virtual",
+	"void" : "@void",
+	"volatile" : "@volatile",
+	"while" : "@while",
+	default : key
+]
diff --git a/tool/resources/org/antlr/v4/tool/templates/codegen/Java/Java.stg b/tool/resources/org/antlr/v4/tool/templates/codegen/Java/Java.stg
index 23642d764..74b63b377 100644
--- a/tool/resources/org/antlr/v4/tool/templates/codegen/Java/Java.stg
+++ b/tool/resources/org/antlr/v4/tool/templates/codegen/Java/Java.stg
@@ -42,7 +42,7 @@ javaTypeInitMap ::= [
 
 // args must be <object-model-object>, <fields-resulting-in-STs>
 
-ParserFile(file, parser, namedActions) ::= <<
+ParserFile(file, parser, namedActions, contextSuperClass) ::= <<
 <fileHeader(file.grammarFileName, file.ANTLRVersion)>
 <if(file.genPackage)>
 package <file.genPackage>;
@@ -66,7 +66,6 @@ ListenerFile(file, header) ::= <<
 package <file.genPackage>;
 <endif>
 <header>
-import org.antlr.v4.runtime.misc.NotNull;
 import org.antlr.v4.runtime.tree.ParseTreeListener;
 
 /**
@@ -76,15 +75,25 @@ import org.antlr.v4.runtime.tree.ParseTreeListener;
 public interface <file.grammarName>Listener extends ParseTreeListener {
 	<file.listenerNames:{lname |
 /**
+<if(file.listenerLabelRuleNames.(lname))>
+ * Enter a parse tree produced by the {@code <lname>\}
+ * labeled alternative in {@link <file.parserName>#<file.listenerLabelRuleNames.(lname)>\}.
+<else>
  * Enter a parse tree produced by {@link <file.parserName>#<lname>\}.
+<endif>
  * @param ctx the parse tree
  */
-void enter<lname; format="cap">(@NotNull <file.parserName>.<lname; format="cap">Context ctx);
+void enter<lname; format="cap">(<file.parserName>.<lname; format="cap">Context ctx);
 /**
+<if(file.listenerLabelRuleNames.(lname))>
+ * Exit a parse tree produced by the {@code <lname>\}
+ * labeled alternative in {@link <file.parserName>#<file.listenerLabelRuleNames.(lname)>\}.
+<else>
  * Exit a parse tree produced by {@link <file.parserName>#<lname>\}.
+<endif>
  * @param ctx the parse tree
  */
-void exit<lname; format="cap">(@NotNull <file.parserName>.<lname; format="cap">Context ctx);}; separator="\n">
+void exit<lname; format="cap">(<file.parserName>.<lname; format="cap">Context ctx);}; separator="\n">
 }
 >>
 
@@ -96,7 +105,6 @@ package <file.genPackage>;
 <header>
 
 import org.antlr.v4.runtime.ParserRuleContext;
-import org.antlr.v4.runtime.misc.NotNull;
 import org.antlr.v4.runtime.tree.ErrorNode;
 import org.antlr.v4.runtime.tree.TerminalNode;
 
@@ -109,41 +117,41 @@ public class <file.grammarName>BaseListener implements <file.grammarName>Listene
 	<file.listenerNames:{lname |
 /**
  * {@inheritDoc\}
- * \<p/>
- * The default implementation does nothing.
+ *
+ * \<p>The default implementation does nothing.\</p>
  */
-@Override public void enter<lname; format="cap">(@NotNull <file.parserName>.<lname; format="cap">Context ctx) { \}
+@Override public void enter<lname; format="cap">(<file.parserName>.<lname; format="cap">Context ctx) { \}
 /**
  * {@inheritDoc\}
- * \<p/>
- * The default implementation does nothing.
+ *
+ * \<p>The default implementation does nothing.\</p>
  */
-@Override public void exit<lname; format="cap">(@NotNull <file.parserName>.<lname; format="cap">Context ctx) { \}}; separator="\n">
+@Override public void exit<lname; format="cap">(<file.parserName>.<lname; format="cap">Context ctx) { \}}; separator="\n">
 
 	/**
 	 * {@inheritDoc\}
-	 * \<p/>
-	 * The default implementation does nothing.
+	 *
+	 * \<p>The default implementation does nothing.\</p>
 	 */
-	@Override public void enterEveryRule(@NotNull ParserRuleContext ctx) { }
+	@Override public void enterEveryRule(ParserRuleContext ctx) { }
 	/**
 	 * {@inheritDoc\}
-	 * \<p/>
-	 * The default implementation does nothing.
+	 *
+	 * \<p>The default implementation does nothing.\</p>
 	 */
-	@Override public void exitEveryRule(@NotNull ParserRuleContext ctx) { }
+	@Override public void exitEveryRule(ParserRuleContext ctx) { }
 	/**
 	 * {@inheritDoc\}
-	 * \<p/>
-	 * The default implementation does nothing.
+	 *
+	 * \<p>The default implementation does nothing.\</p>
 	 */
-	@Override public void visitTerminal(@NotNull TerminalNode node) { }
+	@Override public void visitTerminal(TerminalNode node) { }
 	/**
 	 * {@inheritDoc\}
-	 * \<p/>
-	 * The default implementation does nothing.
+	 *
+	 * \<p>The default implementation does nothing.\</p>
 	 */
-	@Override public void visitErrorNode(@NotNull ErrorNode node) { }
+	@Override public void visitErrorNode(ErrorNode node) { }
 }
 >>
 
@@ -153,7 +161,6 @@ VisitorFile(file, header) ::= <<
 package <file.genPackage>;
 <endif>
 <header>
-import org.antlr.v4.runtime.misc.NotNull;
 import org.antlr.v4.runtime.tree.ParseTreeVisitor;
 
 /**
@@ -166,11 +173,16 @@ import org.antlr.v4.runtime.tree.ParseTreeVisitor;
 public interface <file.grammarName>Visitor\<T> extends ParseTreeVisitor\<T> {
 	<file.visitorNames:{lname |
 /**
+<if(file.visitorLabelRuleNames.(lname))>
+ * Visit a parse tree produced by the {@code <lname>\}
+ * labeled alternative in {@link <file.parserName>#<file.visitorLabelRuleNames.(lname)>\}.
+<else>
  * Visit a parse tree produced by {@link <file.parserName>#<lname>\}.
+<endif>
  * @param ctx the parse tree
  * @return the visitor result
  */
-T visit<lname; format="cap">(@NotNull <file.parserName>.<lname; format="cap">Context ctx);}; separator="\n">
+T visit<lname; format="cap">(<file.parserName>.<lname; format="cap">Context ctx);}; separator="\n">
 }
 >>
 
@@ -180,7 +192,6 @@ BaseVisitorFile(file, header) ::= <<
 package <file.genPackage>;
 <endif>
 <header>
-import org.antlr.v4.runtime.misc.NotNull;
 import org.antlr.v4.runtime.tree.AbstractParseTreeVisitor;
 
 /**
@@ -195,11 +206,11 @@ public class <file.grammarName>BaseVisitor\<T> extends AbstractParseTreeVisitor\
 	<file.visitorNames:{lname |
 /**
  * {@inheritDoc\}
- * \<p/>
- * The default implementation returns the result of calling
- * {@link #visitChildren\} on {@code ctx\}.
+ *
+ * \<p>The default implementation returns the result of calling
+ * {@link #visitChildren\} on {@code ctx\}.\</p>
  */
-@Override public T visit<lname; format="cap">(@NotNull <file.parserName>.<lname; format="cap">Context ctx) { return visitChildren(ctx); \}}; separator="\n">
+@Override public T visit<lname; format="cap">(<file.parserName>.<lname; format="cap">Context ctx) { return visitChildren(ctx); \}}; separator="\n">
 }
 >>
 
@@ -213,7 +224,9 @@ Parser(parser, funcs, atn, sempredFuncs, superClass) ::= <<
 
 Parser_(parser, funcs, atn, sempredFuncs, ctor, superClass) ::= <<
 @SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
-public class <parser.name> extends <superClass> {
+public class <parser.name> extends <superClass; null="Parser"> {
+	static { RuntimeMetaData.checkVersion("<file.ANTLRVersion>", RuntimeMetaData.VERSION); }
+
 	protected static final DFA[] _decisionToDFA;
 	protected static final PredictionContextCache _sharedContextCache =
 		new PredictionContextCache();
@@ -221,20 +234,16 @@ public class <parser.name> extends <superClass> {
 	public static final int
 		<parser.tokens:{k | <k>=<parser.tokens.(k)>}; separator=", ", wrap, anchor>;
 	<endif>
-	public static final String[] tokenNames = {
-		<parser.tokenNames:{t | <t>}; null="\"\<INVALID>\"", separator=", ", wrap, anchor>
-	};
 	public static final int
 		<parser.rules:{r | RULE_<r.name> = <r.index>}; separator=", ", wrap, anchor>;
 	public static final String[] ruleNames = {
 		<parser.ruleNames:{r | "<r>"}; separator=", ", wrap, anchor>
 	};
 
-	@Override
-	public String getGrammarFileName() { return "<parser.grammarFileName; format="java-escape">"; }
+	<vocabulary(parser.literalNames, parser.symbolicNames)>
 
 	@Override
-	public String[] getTokenNames() { return tokenNames; }
+	public String getGrammarFileName() { return "<parser.grammarFileName; format="java-escape">"; }
 
 	@Override
 	public String[] getRuleNames() { return ruleNames; }
@@ -253,7 +262,8 @@ public class <parser.name> extends <superClass> {
 	public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
 		switch (ruleIndex) {
 		<parser.sempredFuncs.values:{f|
-case <f.ruleIndex>: return <f.name>_sempred((<f.ctxType>)_localctx, predIndex);}; separator="\n">
+case <f.ruleIndex>:
+	return <f.name>_sempred((<f.ctxType>)_localctx, predIndex);}; separator="\n">
 		}
 		return true;
 	}
@@ -264,13 +274,56 @@ case <f.ruleIndex>: return <f.name>_sempred((<f.ctxType>)_localctx, predIndex);}
 }
 >>
 
+vocabulary(literalNames, symbolicNames) ::= <<
+private static final String[] _LITERAL_NAMES = {
+	<literalNames:{t | <t>}; null="null", separator=", ", wrap, anchor>
+};
+private static final String[] _SYMBOLIC_NAMES = {
+	<symbolicNames:{t | <t>}; null="null", separator=", ", wrap, anchor>
+};
+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;
+}
+>>
+
 dumpActions(recog, argFuncs, actionFuncs, sempredFuncs) ::= <<
 <if(actionFuncs)>
 @Override
 public void action(RuleContext _localctx, int ruleIndex, int actionIndex) {
 	switch (ruleIndex) {
 	<recog.actionFuncs.values:{f|
-case <f.ruleIndex>: <f.name>_action((<f.ctxType>)_localctx, actionIndex); break;}; separator="\n">
+case <f.ruleIndex>:
+	<f.name>_action((<f.ctxType>)_localctx, actionIndex);
+	break;}; separator="\n">
 	}
 }
 <actionFuncs.values; separator="\n">
@@ -280,7 +333,8 @@ case <f.ruleIndex>: <f.name>_action((<f.ctxType>)_localctx, actionIndex); break;
 public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
 	switch (ruleIndex) {
 	<recog.sempredFuncs.values:{f|
-case <f.ruleIndex>: return <f.name>_sempred((<f.ctxType>)_localctx, predIndex);}; separator="\n">
+case <f.ruleIndex>:
+	return <f.name>_sempred((<f.ctxType>)_localctx, predIndex);}; separator="\n">
 	}
 	return true;
 }
@@ -302,7 +356,9 @@ RuleActionFunction(r, actions) ::= <<
 private void <r.name>_action(<r.ctxType> _localctx, int actionIndex) {
 	switch (actionIndex) {
 	<actions:{index|
-case <index>: <actions.(index)> break;}; separator="\n">
+case <index>:
+	<actions.(index)>
+	break;}; separator="\n">
 	}
 }
 >>
@@ -314,18 +370,19 @@ RuleSempredFunction(r, actions) ::= <<
 private boolean <r.name>_sempred(<r.ctxType> _localctx, int predIndex) {
 	switch (predIndex) {
 	<actions:{index|
-case <index>: return <actions.(index)>;}; separator="\n">
+case <index>:
+	return <actions.(index)>;}; separator="\n">
 	}
 	return true;
 }
 >>
 
-RuleFunction(currentRule,code,locals,ruleCtx,altLabelCtxs,namedActions,finallyAction,postamble,exceptions) ::= <<
+RuleFunction(currentRule,args,code,locals,ruleCtx,altLabelCtxs,namedActions,finallyAction,postamble,exceptions) ::= <<
 
 <ruleCtx>
 <altLabelCtxs:{l | <altLabelCtxs.(l)>}; separator="\n">
 
-<if(currentRule.modifiers)><currentRule.modifiers:{f | <f> }><else>public final <endif><currentRule.ctxType> <currentRule.name>(<currentRule.args; separator=",">) throws RecognitionException {
+<if(currentRule.modifiers)><currentRule.modifiers:{f | <f> }><else>public final <endif><currentRule.ctxType> <currentRule.name>(<args; separator=",">) throws RecognitionException {
 	<currentRule.ctxType> _localctx = new <currentRule.ctxType>(_ctx, getState()<currentRule.args:{a | , <a.name>}>);
 	enterRule(_localctx, <currentRule.startState>, RULE_<currentRule.name>);
 	<namedActions.init>
@@ -355,18 +412,18 @@ RuleFunction(currentRule,code,locals,ruleCtx,altLabelCtxs,namedActions,finallyAc
 }
 >>
 
-LeftRecursiveRuleFunction(currentRule,code,locals,ruleCtx,altLabelCtxs,
+LeftRecursiveRuleFunction(currentRule,args,code,locals,ruleCtx,altLabelCtxs,
 	namedActions,finallyAction,postamble) ::=
 <<
 
 <ruleCtx>
 <altLabelCtxs:{l | <altLabelCtxs.(l)>}; separator="\n">
 
-<if(currentRule.modifiers)><currentRule.modifiers:{f | <f> }><else>public final <endif><currentRule.ctxType> <currentRule.name>(<currentRule.args; separator=", ">) throws RecognitionException {
+<if(currentRule.modifiers)><currentRule.modifiers:{f | <f> }><else>public final <endif><currentRule.ctxType> <currentRule.name>(<args; separator=", ">) throws RecognitionException {
 	return <currentRule.name>(0<currentRule.args:{a | , <a.name>}>);
 }
 
-private <currentRule.ctxType> <currentRule.name>(int _p<currentRule.args:{a | , <a>}>) throws RecognitionException {
+private <currentRule.ctxType> <currentRule.name>(int _p<args:{a | , <a>}>) throws RecognitionException {
 	ParserRuleContext _parentctx = _ctx;
 	int _parentState = getState();
 	<currentRule.ctxType> _localctx = new <currentRule.ctxType>(_ctx, _parentState<currentRule.args:{a | , <a.name>}>);
@@ -412,7 +469,6 @@ CodeBlockForAlt(currentAltCodeBlock, locals, preamble, ops) ::= <<
 
 LL1AltBlock(choice, preamble, alts, error) ::= <<
 setState(<choice.stateNumber>);
-<!_errHandler.sync(this);!>
 <if(choice.label)><labelref(choice.label)> = _input.LT(1);<endif>
 <preamble; separator="\n">
 switch (_input.LA(1)) {
@@ -426,7 +482,6 @@ default:
 
 LL1OptionalBlock(choice, alts, error) ::= <<
 setState(<choice.stateNumber>);
-<!_errHandler.sync(this);!>
 switch (_input.LA(1)) {
 <choice.altLook,alts:{look,alt| <cases(ttypes=look)>
 	<alt>
@@ -438,7 +493,6 @@ default:
 
 LL1OptionalBlockSingleAlt(choice, expr, alts, preamble, error, followExpr) ::= <<
 setState(<choice.stateNumber>);
-<!_errHandler.sync(this);!>
 <preamble; separator="\n">
 if (<expr>) {
 	<alts; separator="\n">
@@ -446,23 +500,6 @@ if (<expr>) {
 <!else if ( !(<followExpr>) ) <error>!>
 >>
 
-LL1StarBlock(choice, alts) ::= <<
-setState(<choice.stateNumber>);
-_errHandler.sync(this);
-<choice.loopLabel>:
-while (true) {
-	switch (_input.LA(1)) {
-	<choice.altLook,alts:{look,alt| <cases(look)>
-	<alt>
-	break;}; separator="\n">
-	<cases(choice.exitLook)>
-		break <choice.loopLabel>;
-	}
-	setState(<choice.loopBackStateNumber>);
-	_errHandler.sync(this);
-}
->>
-
 LL1StarBlockSingleAlt(choice, loopExpr, alts, preamble, iteration) ::= <<
 setState(<choice.stateNumber>);
 _errHandler.sync(this);
@@ -475,23 +512,6 @@ while (<loopExpr>) {
 }
 >>
 
-LL1PlusBlock(choice, alts, iteration, loopExpr, error) ::= <<
-setState(<choice.blockStartStateNumber>); <! alt block decision !>
-_errHandler.sync(this);
-do {
-	switch (_input.LA(1)) {
-	<choice.altLook,alts:{look,alt| <cases(look)>
-	<alt>
-	break;}; separator="\n">
-	default:
-		<error>
-	}
-	setState(<choice.stateNumber>);
-	_errHandler.sync(this);
-	<iteration>
-} while ( <loopExpr> );
->>
-
 LL1PlusBlockSingleAlt(choice, loopExpr, alts, preamble, iteration) ::= <<
 setState(<choice.blockStartStateNumber>); <! alt block decision !>
 _errHandler.sync(this);
@@ -508,7 +528,7 @@ do {
 
 AltBlock(choice, preamble, alts, error) ::= <<
 setState(<choice.stateNumber>);
-<!_errHandler.sync(this);!>
+_errHandler.sync(this);
 <if(choice.label)><labelref(choice.label)> = _input.LT(1);<endif>
 <preamble; separator="\n">
 switch ( getInterpreter().adaptivePredict(_input,<choice.decision>,_ctx) ) {
@@ -521,7 +541,7 @@ case <i>:
 
 OptionalBlock(choice, alts, error) ::= <<
 setState(<choice.stateNumber>);
-<!_errHandler.sync(this);!>
+_errHandler.sync(this);
 switch ( getInterpreter().adaptivePredict(_input,<choice.decision>,_ctx) ) {
 <alts:{alt |
 case <i><if(!choice.ast.greedy)>+1<endif>:
@@ -534,7 +554,7 @@ StarBlock(choice, alts, sync, iteration) ::= <<
 setState(<choice.stateNumber>);
 _errHandler.sync(this);
 _alt = getInterpreter().adaptivePredict(_input,<choice.decision>,_ctx);
-while ( _alt!=<choice.exitAlt> && _alt!=-1 ) {
+while ( _alt!=<choice.exitAlt> && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
 	if ( _alt==1<if(!choice.ast.greedy)>+1<endif> ) {
 		<iteration>
 		<alts> <! should only be one !>
@@ -548,7 +568,7 @@ while ( _alt!=<choice.exitAlt> && _alt!=-1 ) {
 PlusBlock(choice, alts, error) ::= <<
 setState(<choice.blockStartStateNumber>); <! alt block decision !>
 _errHandler.sync(this);
-_alt = getInterpreter().adaptivePredict(_input,<choice.decision>,_ctx);
+_alt = 1<if(!choice.ast.greedy)>+1<endif>;
 do {
 	switch (_alt) {
 	<alts:{alt|
@@ -561,7 +581,7 @@ case <i><if(!choice.ast.greedy)>+1<endif>:
 	setState(<choice.loopBackStateNumber>); <! loopback/exit decision !>
 	_errHandler.sync(this);
 	_alt = getInterpreter().adaptivePredict(_input,<choice.decision>,_ctx);
-} while ( _alt!=<choice.exitAlt> && _alt!=-1 );
+} while ( _alt!=<choice.exitAlt> && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
 >>
 
 Sync(s) ::= "sync(<s.expecting.name>);"
@@ -601,11 +621,13 @@ cases(ttypes) ::= <<
 >>
 
 InvokeRule(r, argExprsChunks) ::= <<
-setState(<r.stateNumber>); <if(r.labels)><r.labels:{l | <labelref(l)> = }><endif><r.name>(<if(r.ast.options.p)><r.ast.options.p><if(argExprsChunks)>,<endif><endif><argExprsChunks>);
+setState(<r.stateNumber>);
+<if(r.labels)><r.labels:{l | <labelref(l)> = }><endif><r.name>(<if(r.ast.options.p)><r.ast.options.p><if(argExprsChunks)>,<endif><endif><argExprsChunks>);
 >>
 
 MatchToken(m) ::= <<
-setState(<m.stateNumber>); <if(m.labels)><m.labels:{l | <labelref(l)> = }><endif>match(<m.name>);
+setState(<m.stateNumber>);
+<if(m.labels)><m.labels:{l | <labelref(l)> = }><endif>match(<m.name>);
 >>
 
 MatchSet(m, expr, capture) ::= "<CommonSetStuff(m, expr, capture, false)>"
@@ -618,8 +640,9 @@ setState(<m.stateNumber>);
 <capture>
 if ( <if(invert)><m.varName> \<= 0 || <else>!<endif>(<expr>) ) {
 	<if(m.labels)><m.labels:{l | <labelref(l)> = (Token)}><endif>_errHandler.recoverInline(this);
+} else {
+	consume();
 }
-consume();
 >>
 
 Wildcard(w) ::= <<
@@ -655,9 +678,6 @@ LexerChannelCommand(arg, grammar)   ::= "_channel = <arg>;"
 LexerModeCommand(arg, grammar)      ::= "_mode = <arg>;"
 LexerPushModeCommand(arg, grammar)  ::= "pushMode(<arg>);"
 
-DefaultParserSuperClass(s) ::= "Parser"
-DefaultLexerSuperClass(s)  ::= "Lexer"
-
 ActionText(t) ::= "<t.text>"
 ActionTemplate(t) ::= "<t.st>"
 ArgRef(a) ::= "_localctx.<a.name>"
@@ -685,11 +705,13 @@ RulePropertyRef_start(r) ::= "(<ctx(r)>.<r.label>!=null?(<ctx(r)>.<r.label>.star
 RulePropertyRef_stop(r)	 ::= "(<ctx(r)>.<r.label>!=null?(<ctx(r)>.<r.label>.stop):null)"
 RulePropertyRef_text(r)	 ::= "(<ctx(r)>.<r.label>!=null?_input.getText(<ctx(r)>.<r.label>.start,<ctx(r)>.<r.label>.stop):null)"
 RulePropertyRef_ctx(r)	 ::= "<ctx(r)>.<r.label>"
+RulePropertyRef_parser(r)	 ::= "this"
 
 ThisRulePropertyRef_start(r) ::= "_localctx.start"
 ThisRulePropertyRef_stop(r)	 ::= "_localctx.stop"
 ThisRulePropertyRef_text(r)	 ::= "_input.getText(_localctx.start, _input.LT(-1))"
 ThisRulePropertyRef_ctx(r)	 ::= "_localctx"
+ThisRulePropertyRef_parser(r)	 ::= "this"
 
 NonLocalAttrRef(s)		 ::= "((<s.ruleName; format=\"cap\">Context)getInvokingContext(<s.ruleIndex>)).<s.name>"
 SetNonLocalAttr(s, rhsChunks)	  ::=
@@ -697,11 +719,11 @@ SetNonLocalAttr(s, rhsChunks)	  ::=
 
 AddToLabelList(a) ::= "<ctx(a.label)>.<a.listName>.add(<labelref(a.label)>);"
 
-TokenDecl(t) ::= "public <TokenLabelType()> <t.name>;"
+TokenDecl(t) ::= "<TokenLabelType()> <t.name>"
 TokenTypeDecl(t) ::= "int <t.name>;"
-TokenListDecl(t) ::= "public List\<Token> <t.name> = new ArrayList\<Token>();"
-RuleContextDecl(r) ::= "public <r.ctxName> <r.name>;"
-RuleContextListDecl(rdecl) ::= "public List\<<rdecl.ctxName>> <rdecl.name> = new ArrayList\<<rdecl.ctxName>>();"
+TokenListDecl(t) ::= "List\<Token> <t.name> = new ArrayList\<Token>()"
+RuleContextDecl(r) ::= "<r.ctxName> <r.name>"
+RuleContextListDecl(rdecl) ::= "List\<<rdecl.ctxName>> <rdecl.name> = new ArrayList\<<rdecl.ctxName>>()"
 
 ContextTokenGetterDecl(t)      ::=
     "public TerminalNode <t.name>() { return getToken(<parser.name>.<t.name>, 0); }"
@@ -743,13 +765,13 @@ ListLabelName(label)		  ::= "<label>"
 CaptureNextToken(d) ::= "<d.varName> = _input.LT(1);"
 CaptureNextTokenType(d) ::= "<d.varName> = _input.LA(1);"
 
-StructDecl(struct,attrs,getters,dispatchMethods,interfaces,extensionMembers,
-           superClass={ParserRuleContext}) ::= <<
-public static class <struct.name> extends <superClass><if(interfaces)> implements <interfaces; separator=", "><endif> {
-	<attrs:{a | <a>}; separator="\n">
+StructDecl(struct,ctorAttrs,attrs,getters,dispatchMethods,interfaces,extensionMembers)
+	::= <<
+public static class <struct.name> extends <if(contextSuperClass)><contextSuperClass><else>ParserRuleContext<endif><if(interfaces)> implements <interfaces; separator=", "><endif> {
+	<attrs:{a | public <a>;}; separator="\n">
 	<getters:{g | <g>}; separator="\n">
-	<if(struct.ctorAttrs)>public <struct.name>(ParserRuleContext parent, int invokingState) { super(parent, invokingState); }<endif>
-	public <struct.name>(ParserRuleContext parent, int invokingState<struct.ctorAttrs:{a | , <a>}>) {
+	<if(ctorAttrs)>public <struct.name>(ParserRuleContext parent, int invokingState) { super(parent, invokingState); }<endif>
+	public <struct.name>(ParserRuleContext parent, int invokingState<ctorAttrs:{a | , <a>}>) {
 		super(parent, invokingState);
 		<struct.ctorAttrs:{a | this.<a.name> = <a.name>;}; separator="\n">
 	}
@@ -768,7 +790,7 @@ public static class <struct.name> extends <superClass><if(interfaces)> implement
 
 AltLabelStructDecl(struct,attrs,getters,dispatchMethods) ::= <<
 public static class <struct.name> extends <currentRule.name; format="cap">Context {
-	<attrs:{a | <a>}; separator="\n">
+	<attrs:{a | public <a>;}; separator="\n">
 	<getters:{g | <g>}; separator="\n">
 	public <struct.name>(<currentRule.name; format="cap">Context ctx) { copyFrom(ctx); }
 	<dispatchMethods; separator="\n">
@@ -790,7 +812,7 @@ public \<T> T accept(ParseTreeVisitor\<? extends T> visitor) {
 }
 >>
 
-AttributeDecl(d) ::= "public <d.decl>;"
+AttributeDecl(d) ::= "<d.type> <d.name><if(d.initValue)> = <d.initValue><endif>"
 
 /** If we don't know location of label def x, use this template */
 labelref(x) ::= "<if(!x.isLocal)>((<x.ctx.name>)_localctx).<endif><x.name>"
@@ -803,15 +825,28 @@ recRuleAltPredicate(ruleName,opPrec)  ::= "precpred(_ctx, <opPrec>)"
 recRuleSetReturnAction(src,name)	  ::= "$<name>=$<src>.<name>;"
 recRuleSetStopToken()                 ::= "_ctx.stop = _input.LT(-1);"
 
-recRuleAltStartAction(ruleName, ctxName, label) ::= <<
+recRuleAltStartAction(ruleName, ctxName, label, isListLabel) ::= <<
 _localctx = new <ctxName>Context(_parentctx, _parentState);
+<if(label)>
+<if(isListLabel)>
+_localctx.<label>.add(_prevctx);
+<else>
+_localctx.<label> = _prevctx;
+<endif>
+<endif>
 <if(label)>_localctx.<label> = _prevctx;<endif>
 pushNewRecursionContext(_localctx, _startState, RULE_<ruleName>);
 >>
 
-recRuleLabeledAltStartAction(ruleName, currentAltLabel, label) ::= <<
+recRuleLabeledAltStartAction(ruleName, currentAltLabel, label, isListLabel) ::= <<
 _localctx = new <currentAltLabel; format="cap">Context(new <ruleName; format="cap">Context(_parentctx, _parentState));
-<if(label)>((<currentAltLabel; format="cap">Context)_localctx).<label> = _prevctx;<endif>
+<if(label)>
+<if(isListLabel)>
+((<currentAltLabel; format="cap">Context)_localctx).<label>.add(_prevctx);
+<else>
+((<currentAltLabel; format="cap">Context)_localctx).<label> = _prevctx;
+<endif>
+<endif>
 pushNewRecursionContext(_localctx, _startState, RULE_<ruleName>);
 >>
 
@@ -847,25 +882,29 @@ import org.antlr.v4.runtime.misc.*;
 
 Lexer(lexer, atn, actionFuncs, sempredFuncs, superClass) ::= <<
 @SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
-public class <lexer.name> extends <superClass> {
+public class <lexer.name> extends <superClass; null="Lexer"> {
+	static { RuntimeMetaData.checkVersion("<lexerFile.ANTLRVersion>", RuntimeMetaData.VERSION); }
+
 	protected static final DFA[] _decisionToDFA;
 	protected static final PredictionContextCache _sharedContextCache =
 		new PredictionContextCache();
 	public static final int
 		<lexer.tokens:{k | <k>=<lexer.tokens.(k)>}; separator=", ", wrap, anchor>;
+	<if(lexer.channels)>
+	public static final int
+		<lexer.channels:{k | <k>=<lexer.channels.(k)>}; separator=", ", wrap, anchor>;
+	<endif>
 	<rest(lexer.modes):{m| public static final int <m> = <i>;}; separator="\n">
 	public static String[] modeNames = {
 		<lexer.modes:{m| "<m>"}; separator=", ", wrap, anchor>
 	};
 
-	public static final String[] tokenNames = {
-		"\<INVALID>",
-		<lexer.tokenNames:{t | <t>}; separator=", ", wrap, anchor>
-	};
 	public static final String[] ruleNames = {
 		<lexer.ruleNames:{r | "<r>"}; separator=", ", wrap, anchor>
 	};
 
+	<vocabulary(lexer.literalNames, lexer.symbolicNames)>
+
 	<namedActions.members>
 
 	public <lexer.name>(CharStream input) {
@@ -876,9 +915,6 @@ public class <lexer.name> extends <superClass> {
 	@Override
 	public String getGrammarFileName() { return "<lexer.grammarFileName>"; }
 
-	@Override
-	public String[] getTokenNames() { return tokenNames; }
-
 	@Override
 	public String[] getRuleNames() { return ruleNames; }
 
diff --git a/tool/resources/org/antlr/v4/tool/templates/codegen/JavaScript/JavaScript.stg b/tool/resources/org/antlr/v4/tool/templates/codegen/JavaScript/JavaScript.stg
new file mode 100644
index 000000000..f8101b2da
--- /dev/null
+++ b/tool/resources/org/antlr/v4/tool/templates/codegen/JavaScript/JavaScript.stg
@@ -0,0 +1,854 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2012 Terence Parr
+ *  Copyright (c) 2012 Sam Harwell
+ *  Copyright (c) 2014 Eric Vergnaud
+ *  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.
+ */
+
+/** ANTLR tool checks output templates are compatible with tool code generation.
+ *  For now, a simple string match used on x.y of x.y.z scheme.
+ *  Must match Tool.VERSION during load to templates.
+ *
+ *  REQUIRED.
+ */
+
+pythonTypeInitMap ::= [
+	"bool":"False",
+	"int":"0",
+	"float":"0.0",
+	"str":"",
+	default:"None" // anything other than a primitive type is an object
+]
+
+// args must be <object-model-object>, <fields-resulting-in-STs>
+
+ParserFile(file, parser, namedActions, contextSuperClass) ::= <<
+<fileHeader(file.grammarFileName, file.ANTLRVersion)>
+var antlr4 = require('antlr4/index');
+<if(file.genListener)>
+var <file.grammarName>Listener = require('./<file.grammarName>Listener').<file.grammarName>Listener;
+<endif>
+<if(file.genVisitor)>
+var <file.grammarName>Visitor = require('./<file.grammarName>Visitor').<file.grammarName>Visitor;
+<endif>
+
+<namedActions.header>
+<parser>
+>>
+
+ListenerFile(file, header) ::= <<
+<fileHeader(file.grammarFileName, file.ANTLRVersion)>
+var antlr4 = require('antlr4/index');
+
+// This class defines a complete listener for a parse tree produced by <file.parserName>.
+function <file.grammarName>Listener() {
+	antlr4.tree.ParseTreeListener.call(this);
+	return this;
+}
+
+<file.grammarName>Listener.prototype = Object.create(antlr4.tree.ParseTreeListener.prototype);
+<file.grammarName>Listener.prototype.constructor = <file.grammarName>Listener;
+
+<file.listenerNames:{lname |
+// Enter a parse tree produced by <file.parserName>#<lname>.
+<file.grammarName>Listener.prototype.enter<lname; format="cap"> = function(ctx) {
+\};
+
+// Exit a parse tree produced by <file.parserName>#<lname>.
+<file.grammarName>Listener.prototype.exit<lname; format="cap"> = function(ctx) {
+\};
+
+}; separator="\n">
+
+exports.<file.grammarName>Listener = <file.grammarName>Listener;
+>>
+
+
+VisitorFile(file, header) ::= <<
+<fileHeader(file.grammarFileName, file.ANTLRVersion)>
+var antlr4 = require('antlr4/index');
+<header>
+
+// This class defines a complete generic visitor for a parse tree produced by <file.parserName>.
+
+function <file.grammarName>Visitor() {
+	antlr4.tree.ParseTreeVisitor.call(this);
+	return this;
+}
+
+<file.grammarName>Visitor.prototype = Object.create(antlr4.tree.ParseTreeVisitor.prototype);
+<file.grammarName>Visitor.prototype.constructor = <file.grammarName>Visitor;
+
+<file.visitorNames:{lname |
+// Visit a parse tree produced by <file.parserName>#<lname>.
+<file.grammarName>Visitor.prototype.visit<lname; format="cap"> = function(ctx) {
+\};
+
+}; separator="\n">
+
+exports.<file.grammarName>Visitor = <file.grammarName>Visitor;
+>>
+
+
+fileHeader(grammarFileName, ANTLRVersion) ::= <<
+// Generated from <grammarFileName; format="java-escape"> by ANTLR <ANTLRVersion>
+// jshint ignore: start
+>>
+
+Parser(parser, funcs, atn, sempredFuncs, superClass) ::= <<
+<if(superClass)>
+var <superClass> = require('./<superClass>').<superClass>;
+<endif>
+
+var grammarFileName = "<parser.grammarFileName; format="java-escape">";
+
+<atn>
+
+var atn = new antlr4.atn.ATNDeserializer().deserialize(serializedATN);
+
+var decisionsToDFA = atn.decisionToState.map( function(ds, index) { return new antlr4.dfa.DFA(ds, index); });
+
+var sharedContextCache = new antlr4.PredictionContextCache();
+
+var literalNames = [ <parser.literalNames:{t | <t>}; null="null", separator=", ", wrap, anchor> ];
+
+var symbolicNames = [ <parser.symbolicNames:{t | <t>}; null="null", separator=", ", wrap, anchor> ];
+
+var ruleNames =  [ <parser.ruleNames:{r | "<r>"}; separator=", ", wrap, anchor> ];
+
+function <parser.name> (input) {
+	<superClass; null="antlr4.Parser">.call(this, input);
+    this._interp = new antlr4.atn.ParserATNSimulator(this, atn, decisionsToDFA, sharedContextCache);
+    this.ruleNames = ruleNames;
+    this.literalNames = literalNames;
+    this.symbolicNames = symbolicNames;
+	<namedActions.members>
+    return this;
+}
+
+<parser.name>.prototype = Object.create(<superClass; null="antlr4.Parser">.prototype);
+<parser.name>.prototype.constructor = <parser.name>;
+
+Object.defineProperty(<parser.name>.prototype, "atn", {
+	get : function() {
+		return atn;
+	}
+});
+
+<parser.name>.EOF = antlr4.Token.EOF;
+<if(parser.tokens)>
+<parser.tokens:{k | <parser.name>.<k> = <parser.tokens.(k)>;}; separator="\n", wrap, anchor>
+<endif>
+
+<parser.rules:{r | <parser.name>.RULE_<r.name> = <r.index>;}; separator="\n", wrap, anchor>
+
+<funcs; separator="\n">
+
+<if(sempredFuncs)>
+<parser.name>.prototype.sempred = function(localctx, ruleIndex, predIndex) {
+	switch(ruleIndex) {
+	<parser.sempredFuncs.values:{f | case <f.ruleIndex>:
+		return this.<f.name>_sempred(localctx, predIndex);}; separator="\n">
+    default:
+        throw "No predicate with index:" + ruleIndex;
+   }
+};
+
+<sempredFuncs.values; separator="\n">
+<endif>
+
+exports.<parser.name> = <parser.name>;
+
+>>
+
+dumpActions(recog, argFuncs, actionFuncs, sempredFuncs) ::= <<
+<if(actionFuncs)>
+<lexer.name>.prototype.action = function(localctx, ruleIndex, actionIndex) {
+	switch (ruleIndex) {
+	<recog.actionFuncs.values:{f|
+case <f.ruleIndex>:
+	this.<f.name>_action(localctx, actionIndex);
+	break;}; separator="\n">
+	default:
+		throw "No registered action for:" + ruleIndex;
+	}
+};
+
+<actionFuncs.values; separator="\n">
+<endif>
+<if(sempredFuncs)>
+<lexer.name>.prototype.sempred = function(localctx, ruleIndex, predIndex) {
+	switch (ruleIndex) {
+		<recog.sempredFuncs.values:{f| case <f.ruleIndex>:
+	return this.<f.name>_sempred(localctx, predIndex);}; separator="\n">
+    	default:
+    		throw "No registered predicate for:" + ruleIndex;
+    }
+};
+
+<sempredFuncs.values; separator="\n">
+<endif>
+>>
+
+
+/* This generates a private method since the actionIndex is generated, making an
+ * overriding implementation impossible to maintain.
+ */
+RuleActionFunction(r, actions) ::= <<
+
+<lexer.name>.prototype.<r.name>_action = function(localctx , actionIndex) {
+	switch (actionIndex) {
+	<actions:{index|
+case <index>:
+	<actions.(index)>
+	break;}; separator="\n">
+	default:
+		throw "No registered action for:" + actionIndex;
+	}
+};
+>>
+
+/* This generates a private method since the predIndex is generated, making an
+ * overriding implementation impossible to maintain.
+ */
+RuleSempredFunction(r, actions) ::= <<
+<if(parser)><parser.name><else><lexer.name><endif>.prototype.<r.name>_sempred = function(localctx, predIndex) {
+	switch(predIndex) {
+		<actions:{index| case <index>:
+	return <actions.(index)>;}; separator="\n">
+		default:
+			throw "No predicate with index:" + predIndex;
+	}
+};
+
+>>
+
+RuleFunction(currentRule,args,code,locals,ruleCtx,altLabelCtxs,namedActions,finallyAction,postamble,exceptions) ::= <<
+
+<ruleCtx>
+
+<altLabelCtxs:{l | <altLabelCtxs.(l)>}; separator="\n">
+
+<! Define fields of this parser to export the context classes !>
+<parser.name>.<currentRule.ctxType> = <currentRule.ctxType>;
+
+<parser.name>.prototype.<currentRule.name> = function(<currentRule.args:{a | <a.name>}; separator=", ">) {
+
+    var localctx = new <currentRule.ctxType>(this, this._ctx, this.state<currentRule.args:{a | , <a.name>}>);
+    this.enterRule(localctx, <currentRule.startState>, <parser.name>.RULE_<currentRule.name>);
+    <namedActions.init>
+    <locals; separator="\n">
+    try {
+        <code>
+        <postamble; separator="\n">
+        <namedActions.after>
+    <if(exceptions)>
+    <exceptions; separator="\n">
+    <else>
+    } catch (re) {
+    	if(re instanceof antlr4.error.RecognitionException) {
+	        localctx.exception = re;
+	        this._errHandler.reportError(this, re);
+	        this._errHandler.recover(this, re);
+	    } else {
+	    	throw re;
+	    }
+    }<endif> finally {
+        <finallyAction>
+        this.exitRule();
+    }
+    return localctx;
+};
+
+>>
+
+LeftRecursiveRuleFunction(currentRule,args,code,locals,ruleCtx,altLabelCtxs,
+	namedActions,finallyAction,postamble) ::=
+<<
+
+<ruleCtx>
+<altLabelCtxs:{l | <altLabelCtxs.(l)>}; separator="\n">
+
+<parser.name>.prototype.<currentRule.name> = function(_p<if(currentRule.args)>, <args:{a | , <a>}><endif>) {
+	if(_p===undefined) {
+	    _p = 0;
+	}
+    var _parentctx = this._ctx;
+    var _parentState = this.state;
+    var localctx = new <currentRule.ctxType>(this, this._ctx, _parentState<args:{a | , <a.name>}>);
+    var _prevctx = localctx;
+    var _startState = <currentRule.startState>;
+    this.enterRecursionRule(localctx, <currentRule.startState>, <parser.name>.RULE_<currentRule.name>, _p);
+    <namedActions.init>
+    <locals; separator="\n">
+    try {
+        <code>
+        <postamble; separator="\n">
+        <namedActions.after>
+    } catch( error) {
+        if(error instanceof antlr4.error.RecognitionException) {
+	        localctx.exception = error;
+	        this._errHandler.reportError(this, error);
+	        this._errHandler.recover(this, error);
+	    } else {
+	    	throw error;
+	    }
+    } finally {
+        <finallyAction>
+        this.unrollRecursionContexts(_parentctx)
+    }
+    return localctx;
+};
+
+>>
+
+CodeBlockForOuterMostAlt(currentOuterMostAltCodeBlock, locals, preamble, ops) ::= <<
+<if(currentOuterMostAltCodeBlock.altLabel)>localctx = new <currentOuterMostAltCodeBlock.altLabel; format="cap">Context(this, localctx);<endif>
+this.enterOuterAlt(localctx, <currentOuterMostAltCodeBlock.alt.altNum>);
+<CodeBlockForAlt(currentAltCodeBlock=currentOuterMostAltCodeBlock, ...)>
+>>
+
+CodeBlockForAlt(currentAltCodeBlock, locals, preamble, ops) ::= <<
+<locals; separator="\n">
+<preamble; separator="\n">
+<ops; separator="\n">
+>>
+
+LL1AltBlock(choice, preamble, alts, error) ::= <<
+this.state = <choice.stateNumber>;
+<if(choice.label)><labelref(choice.label)> = this._input.LT(1);<endif>
+<preamble; separator="\n">
+switch(this._input.LA(1)) {
+<choice.altLook,alts:{look,alt| <cases(ttypes=look)>
+    <alt>
+    break;}; separator="\n">
+default:
+    <error>
+}
+>>
+
+LL1OptionalBlock(choice, alts, error) ::= <<
+this.state = <choice.stateNumber>;
+switch (this._input.LA(1)) {
+<choice.altLook,alts:{look,alt| <cases(ttypes=look)>
+	<alt>
+	break;}; separator="\n">
+default:
+	<error>
+}
+>>
+
+LL1OptionalBlockSingleAlt(choice, expr, alts, preamble, error, followExpr) ::= <<
+this.state = <choice.stateNumber>;
+<preamble; separator="\n">
+if(<expr>) {
+    <alts; separator="\n">
+}
+<!else if ( !(<followExpr>) ) <error>!>
+>>
+
+LL1StarBlockSingleAlt(choice, loopExpr, alts, preamble, iteration) ::= <<
+this.state = <choice.stateNumber>;
+this._errHandler.sync(this);
+<preamble; separator="\n">
+while(<loopExpr>) {
+    <alts; separator="\n">
+    this.state = <choice.loopBackStateNumber>;
+    this._errHandler.sync(this);
+    <iteration>
+}
+>>
+
+LL1PlusBlockSingleAlt(choice, loopExpr, alts, preamble, iteration) ::= <<
+this.state = <choice.blockStartStateNumber>; <! alt block decision !>
+this._errHandler.sync(this);
+<preamble; separator="\n">
+do {
+    <alts; separator="\n">
+    this.state = <choice.stateNumber>; <! loopback/exit decision !>
+    this._errHandler.sync(this);
+    <iteration>
+} while(<loopExpr>);
+>>
+
+// LL(*) stuff
+
+AltBlock(choice, preamble, alts, error) ::= <<
+this.state = <choice.stateNumber>;
+this._errHandler.sync(this);
+<if(choice.label)><labelref(choice.label)> = _input.LT(1)<endif>
+<preamble; separator="\n">
+var la_ = this._interp.adaptivePredict(this._input,<choice.decision>,this._ctx);
+switch(la_) {
+<alts:{alt |
+case <i>:
+    <alt>
+    break;
+}; separator="\n">
+}
+>>
+
+OptionalBlock(choice, alts, error) ::= <<
+this.state = <choice.stateNumber>;
+this._errHandler.sync(this);
+var la_ = this._interp.adaptivePredict(this._input,<choice.decision>,this._ctx);
+<alts:{alt |
+if(la_===<i><if(!choice.ast.greedy)>+1<endif>) {
+    <alt>
+}; separator="\n} else ">
+}
+>>
+
+StarBlock(choice, alts, sync, iteration) ::= <<
+this.state = <choice.stateNumber>;
+this._errHandler.sync(this);
+var _alt = this._interp.adaptivePredict(this._input,<choice.decision>,this._ctx)
+while(_alt!=<choice.exitAlt> && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) {
+    if(_alt===1<if(!choice.ast.greedy)>+1<endif>) {
+        <iteration>
+        <alts> <! should only be one !>
+    }
+    this.state = <choice.loopBackStateNumber>;
+    this._errHandler.sync(this);
+    _alt = this._interp.adaptivePredict(this._input,<choice.decision>,this._ctx);
+}
+
+>>
+
+PlusBlock(choice, alts, error) ::= <<
+this.state = <choice.blockStartStateNumber>; <! alt block decision !>
+this._errHandler.sync(this);
+var _alt = 1<if(!choice.ast.greedy)>+1<endif>;
+do {
+	switch (_alt) {
+	<alts:{alt|
+case <i><if(!choice.ast.greedy)>+1<endif>:
+	<alt>
+	break;}; separator="\n">
+	default:
+		<error>
+	}
+	this.state = <choice.loopBackStateNumber>; <! loopback/exit decision !>
+	this._errHandler.sync(this);
+	_alt = this._interp.adaptivePredict(this._input,<choice.decision>, this._ctx);
+} while ( _alt!=<choice.exitAlt> && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER );
+>>
+
+Sync(s) ::= "sync(<s.expecting.name>)"
+
+ThrowNoViableAlt(t) ::= "throw new antlr4.error.NoViableAltException(this);"
+
+TestSetInline(s) ::= <<
+<s.bitsets:{bits | <if(rest(rest(bits.ttypes)))><bitsetBitfieldComparison(s, bits)><else><bitsetInlineComparison(s, bits)><endif>}; separator=" || ">
+>>
+
+// Javascript language spec - shift operators are 32 bits long max
+testShiftInRange(shiftAmount) ::= <<
+((<shiftAmount>) & ~0x1f) == 0
+>>
+
+// produces smaller bytecode only when bits.ttypes contains more than two items
+bitsetBitfieldComparison(s, bits) ::= <%
+(<testShiftInRange({<offsetShiftVar(s.varName, bits.shift)>})> && ((1 \<\< <offsetShiftVar(s.varName, bits.shift)>) & (<bits.ttypes:{ttype | (1 \<\< <offsetShiftType(ttype, bits.shift)>)}; separator=" | ">)) !== 0)
+%>
+
+isZero ::= [
+"0":true,
+default:false
+]
+
+offsetShiftVar(shiftAmount, offset) ::= <%
+<if(!isZero.(offset))>(<shiftAmount> - <offset>)<else><shiftAmount><endif>
+%>
+
+offsetShiftType(shiftAmount, offset) ::= <%
+<if(!isZero.(offset))>(<parser.name>.<shiftAmount> - <offset>)<else><parser.name>.<shiftAmount><endif>
+%>
+
+// produces more efficient bytecode when bits.ttypes contains at most two items
+bitsetInlineComparison(s, bits) ::= <%
+<bits.ttypes:{ttype | <s.varName>===<parser.name>.<ttype>}; separator=" || ">
+%>
+
+cases(ttypes) ::= <<
+<ttypes:{t | case <parser.name>.<t>:}; separator="\n">
+>>
+
+InvokeRule(r, argExprsChunks) ::= <<
+this.state = <r.stateNumber>;
+<if(r.labels)><r.labels:{l | <labelref(l)> = }><endif>this.<r.name>(<if(r.ast.options.p)><r.ast.options.p><if(argExprsChunks)>,<endif><endif><argExprsChunks>);
+>>
+
+MatchToken(m) ::= <<
+this.state = <m.stateNumber>;
+<if(m.labels)><m.labels:{l | <labelref(l)> = }><endif>this.match(<parser.name>.<m.name>);
+>>
+
+MatchSet(m, expr, capture) ::= "<CommonSetStuff(m, expr, capture, false)>"
+
+MatchNotSet(m, expr, capture) ::= "<CommonSetStuff(m, expr, capture, true)>"
+
+CommonSetStuff(m, expr, capture, invert) ::= <<
+this.state = <m.stateNumber>;
+<if(m.labels)><m.labels:{l | <labelref(l)> = }>this._input.LT(1);<endif>
+<capture>
+<if(invert)>if(<m.varName>\<=0 || <expr>)<else>if(!(<expr>))<endif> {
+    <if(m.labels)><m.labels:{l | <labelref(l)> = }><endif>this._errHandler.recoverInline(this);
+}
+else {
+    this.consume();
+}
+>>
+
+Wildcard(w) ::= <<
+this.state = <w.stateNumber>;
+<if(w.labels)><w.labels:{l | <labelref(l)> = }><endif>matchWildcard();
+>>
+
+// ACTION STUFF
+
+Action(a, foo, chunks) ::= "<chunks>"
+
+ArgAction(a, chunks) ::= "<chunks>"
+
+SemPred(p, chunks, failChunks) ::= <<
+this.state = <p.stateNumber>;
+if (!( <chunks>)) {
+    throw new antlr4.error.FailedPredicateException(this, <p.predicate><if(failChunks)>, <failChunks><elseif(p.msg)>, <p.msg><endif>);
+}
+>>
+
+ExceptionClause(e, catchArg, catchAction) ::= <<
+catch (<catchArg>) {
+	<catchAction>
+}
+>>
+
+// lexer actions are not associated with model objects
+
+LexerSkipCommand()  ::= "this.skip()"
+LexerMoreCommand()  ::= "this.more()"
+LexerPopModeCommand() ::= "this.popMode()"
+LexerTypeCommand(arg)      ::= "this._type = <arg>"
+LexerChannelCommand(arg)   ::= "this._channel = <arg>"
+LexerModeCommand(arg)      ::= "this._mode = <arg>"
+LexerPushModeCommand(arg)  ::= "this.pushMode(<arg>)"
+
+ActionText(t) ::= "<t.text>"
+ActionTemplate(t) ::= "<t.st>"
+ArgRef(a) ::= "localctx.<a.name>"
+LocalRef(a) ::= "localctx.<a.name>"
+RetValueRef(a) ::= "localctx.<a.name>"
+QRetValueRef(a) ::= "<ctx(a)>.<a.dict>.<a.name>"
+/** How to translate $tokenLabel */
+TokenRef(t) ::= "<ctx(t)>.<t.name>"
+LabelRef(t) ::= "<ctx(t)>.<t.name>"
+ListLabelRef(t) ::= "<ctx(t)>.<ListLabelName(t.name)>"
+SetAttr(s,rhsChunks) ::= "<ctx(s)>.<s.name> = <rhsChunks>"
+
+TokenLabelType() ::= "<file.TokenLabelType; null={Token}>"
+InputSymbolType() ::= "<file.InputSymbolType; null={Token}>"
+
+TokenPropertyRef_text(t) ::= "(<ctx(t)>.<t.label>===null ? null : <ctx(t)>.<t.label>.text)"
+TokenPropertyRef_type(t) ::= "(<ctx(t)>.<t.label> === null ? 0 : <ctx(t)>.<t.label>.type)"
+TokenPropertyRef_line(t) ::= "(<ctx(t)>.<t.label> === null ? 0 : <ctx(t)>.<t.label>.line)"
+TokenPropertyRef_pos(t) ::= "(<ctx(t)>.<t.label> === null ? 0 : <ctx(t)>.<t.label>.column)"
+TokenPropertyRef_channel(t) ::= "(<ctx(t)>.<t.label> === null ? 0 : <ctx(t)>.<t.label>.channel)"
+TokenPropertyRef_index(t) ::= "(<ctx(t)>.<t.label> === null ? 0 : <ctx(t)>.<t.label>.tokenIndex)"
+TokenPropertyRef_int(t) ::= "(<ctx(t)>.<t.label> === null ? 0 : parseInt(<ctx(t)>.<t.label>.text))"
+
+RulePropertyRef_start(r) ::= "(<ctx(r)>.<r.label>===null ? null : <ctx(r)>.<r.label>.start)"
+RulePropertyRef_stop(r)	 ::= "(<ctx(r)>.<r.label>===null ? null : <ctx(r)>.<r.label>.stop)"
+RulePropertyRef_text(r)	 ::= "(<ctx(r)>.<r.label>===null ? null : this._input.getText(new antlr4.Interval(<ctx(r)>.<r.label>.start,<ctx(r)>.<r.label>.stop)))"
+RulePropertyRef_ctx(r)	 ::= "<ctx(r)>.<r.label>"
+RulePropertyRef_parser(r)	 ::= "this"
+
+ThisRulePropertyRef_start(r) ::= "localctx.start"
+ThisRulePropertyRef_stop(r)	 ::= "localctx.stop"
+ThisRulePropertyRef_text(r)	 ::= "this._input.getText(new antlr4.Interval(localctx.start, this._input.LT(-1)))"
+ThisRulePropertyRef_ctx(r)	 ::= "localctx"
+ThisRulePropertyRef_parser(r)	 ::= "this"
+
+NonLocalAttrRef(s)		 	 ::= "getInvokingContext(<s.ruleIndex>).<s.name>"
+SetNonLocalAttr(s, rhsChunks)  ::= "getInvokingContext(<s.ruleIndex>).<s.name> = <rhsChunks>"
+
+AddToLabelList(a) ::= "<ctx(a.label)>.<a.listName>.push(<labelref(a.label)>);"
+
+TokenDecl(t) ::= "this.<t.name> = null; // <TokenLabelType()>"
+TokenTypeDecl(t) ::= "var <t.name> = 0; // <TokenLabelType()> type"
+TokenListDecl(t) ::= "this.<t.name> = []; // of <TokenLabelType()>s"
+RuleContextDecl(r) ::= "this.<r.name> = null; // <r.ctxName>"
+RuleContextListDecl(rdecl) ::= "this.<rdecl.name> = []; // of <rdecl.ctxName>s"
+
+ContextTokenGetterDecl(t)      ::= <<
+<t.name> = function() {
+    return this.getToken(<parser.name>.<t.name>, 0);
+};
+>>
+
+// should never be called
+ContextTokenListGetterDecl(t)  ::= <<
+def <t.name>_list(self):
+    return self.getTokens(<parser.name>.<t.name>)
+>>
+
+ContextTokenListIndexedGetterDecl(t)  ::= <<
+<t.name> = function(i) {
+	if(i===undefined) {
+		i = null;
+	}
+    if(i===null) {
+        return this.getTokens(<parser.name>.<t.name>);
+    } else {
+        return this.getToken(<parser.name>.<t.name>, i);
+    }
+};
+
+>>
+
+ContextRuleGetterDecl(r)       ::= <<
+<r.name> = function() {
+    return this.getTypedRuleContext(<r.ctxName>,0);
+};
+>>
+
+// should never be called
+ContextRuleListGetterDecl(r)   ::= <<
+def <r.name>_list(self):
+    return self.getTypedRuleContexts(<parser.name>.<r.ctxName>)
+
+>>
+
+ContextRuleListIndexedGetterDecl(r)   ::= <<
+<r.name> = function(i) {
+    if(i===undefined) {
+        i = null;
+    }
+    if(i===null) {
+        return this.getTypedRuleContexts(<r.ctxName>);
+    } else {
+        return this.getTypedRuleContext(<r.ctxName>,i);
+    }
+};
+>>
+
+LexerRuleContext() ::= "RuleContext"
+
+/** The rule context name is the rule followed by a suffix; e.g.,
+ *	r becomes rContext.
+ */
+RuleContextNameSuffix() ::= "Context"
+
+ImplicitTokenLabel(tokenName) ::= "_<tokenName>"
+ImplicitRuleLabel(ruleName)	  ::= "_<ruleName>"
+ImplicitSetLabel(id)		  ::= "_tset<id>"
+ListLabelName(label)		  ::= "<label>"
+
+CaptureNextToken(d) ::= "<d.varName> = self._input.LT(1)"
+CaptureNextTokenType(d) ::= "<d.varName> = this._input.LA(1);"
+
+StructDecl(struct,ctorAttrs,attrs,getters,dispatchMethods,interfaces,extensionMembers) ::= <<
+function <struct.name>(parser, parent, invokingState<struct.ctorAttrs:{a | , <a.name>}>) {
+	if(parent===undefined) {
+	    parent = null;
+	}
+	if(invokingState===undefined || invokingState===null) {
+		invokingState = -1;
+	}
+	<if(contextSuperClass)><contextSuperClass><else>antlr4.ParserRuleContext<endif>.call(this, parent, invokingState);
+    this.parser = parser;
+    this.ruleIndex = <parser.name>.RULE_<struct.derivedFromName>;
+    <attrs:{a | <a>}; separator="\n">
+    <struct.ctorAttrs:{a | this.<a.name> = <a.name> || null;}; separator="\n">
+    return this;
+}
+
+<struct.name>.prototype = Object.create(<if(contextSuperClass)><contextSuperClass><else>antlr4.ParserRuleContext<endif>.prototype);
+<struct.name>.prototype.constructor = <struct.name>;
+
+<getters:{g | <struct.name>.prototype.<g>}; separator="\n\n">
+
+<if(struct.provideCopyFrom)> <! don't need copy unless we have subclasses !>
+<struct.name>.prototype.copyFrom = function(ctx) {
+    <if(contextSuperClass)><contextSuperClass><else>antlr4.ParserRuleContext<endif>.prototype.copyFrom.call(this, ctx);
+    <struct.attrs:{a | this.<a.name> = ctx.<a.name>;}; separator="\n">
+};
+<endif>
+<dispatchMethods; separator="\n">
+<extensionMembers; separator="\n">
+
+>>
+
+AltLabelStructDecl(struct,attrs,getters,dispatchMethods) ::= <<
+function <struct.name>(parser, ctx) {
+	<currentRule.name; format="cap">Context.call(this, parser);
+    <attrs:{a | <a>;}; separator="\n">
+    <currentRule.name; format="cap">Context.prototype.copyFrom.call(this, ctx);
+    return this;
+}
+
+<struct.name>.prototype = Object.create(<currentRule.name; format="cap">Context.prototype);
+<struct.name>.prototype.constructor = <struct.name>;
+
+<! Define fields of this parser to export this struct/context class !>
+<parser.name>.<struct.name> = <struct.name>;
+
+<getters:{g | <struct.name>.prototype.<g>}; separator="\n\n">
+<dispatchMethods; separator="\n">
+
+>>
+
+ListenerDispatchMethod(method) ::= <<
+<struct.name>.prototype.<if(method.isEnter)>enter<else>exit<endif>Rule = function(listener) {
+    if(listener instanceof <parser.grammarName>Listener ) {
+        listener.<if(method.isEnter)>enter<else>exit<endif><struct.derivedFromName; format="cap">(this);
+	}
+};
+
+>>
+
+VisitorDispatchMethod(method) ::= <<
+<struct.name>.prototype.accept = function(visitor) {
+    if ( visitor instanceof <parser.grammarName>Visitor ) {
+        return visitor.visit<struct.derivedFromName; format="cap">(this);
+    } else {
+        return visitor.visitChildren(this);
+    }
+};
+
+>>
+
+AttributeDecl(d) ::= "this.<d.name> = <if(d.initValue)><d.initValue><else>null<endif>"
+
+/** If we don't know location of label def x, use this template */
+labelref(x) ::= "<if(!x.isLocal)>localctx.<endif><x.name>"
+
+/** For any action chunk, what is correctly-typed context struct ptr? */
+ctx(actionChunk) ::= "localctx"
+
+// used for left-recursive rules
+recRuleAltPredicate(ruleName,opPrec)  ::= "this.precpred(this._ctx, <opPrec>)"
+recRuleSetReturnAction(src,name)	  ::= "$<name>=$<src>.<name>"
+recRuleSetStopToken()                 ::= "this._ctx.stop = this._input.LT(-1);"
+
+recRuleAltStartAction(ruleName, ctxName, label) ::= <<
+localctx = new <ctxName>Context(this, _parentctx, _parentState);
+<if(label)>localctx.<label> = _prevctx;<endif>
+this.pushNewRecursionContext(localctx, _startState, <parser.name>.RULE_<ruleName>);
+>>
+
+recRuleLabeledAltStartAction(ruleName, currentAltLabel, label, isListLabel) ::= <<
+localctx = new <currentAltLabel; format="cap">Context(this, new <ruleName; format="cap">Context(this, _parentctx, _parentState));
+<if(label)>
+<if(isListLabel)>
+localctx.<label>.push(_prevctx);
+<else>
+localctx.<label> = _prevctx;
+<endif>
+<endif>
+this.pushNewRecursionContext(localctx, _startState, <parser.name>.RULE_<ruleName>);
+>>
+
+recRuleReplaceContext(ctxName) ::= <<
+localctx = new <ctxName>Context(this, localctx);
+this._ctx = localctx;
+_prevctx = localctx;
+>>
+
+recRuleSetPrevCtx() ::= <<
+if(this._parseListeners!==null) {
+    this.triggerExitRuleEvent();
+}
+_prevctx = localctx;
+>>
+
+
+LexerFile(lexerFile, lexer, namedActions) ::= <<
+<fileHeader(lexerFile.grammarFileName, lexerFile.ANTLRVersion)>
+var antlr4 = require('antlr4/index');
+
+<namedActions.header>
+
+<lexer>
+
+>>
+
+Lexer(lexer, atn, actionFuncs, sempredFuncs, superClass) ::= <<
+
+<atn>
+
+var atn = new antlr4.atn.ATNDeserializer().deserialize(serializedATN);
+
+var decisionsToDFA = atn.decisionToState.map( function(ds, index) { return new antlr4.dfa.DFA(ds, index); });
+
+function <lexer.name>(input) {
+	<if(superClass)><superClass><else>antlr4.Lexer<endif>.call(this, input);
+    this._interp = new antlr4.atn.LexerATNSimulator(this, atn, decisionsToDFA, new antlr4.PredictionContextCache());
+    return this;
+}
+
+<lexer.name>.prototype = Object.create(<if(superClass)><superClass><else>antlr4.Lexer<endif>.prototype);
+<lexer.name>.prototype.constructor = <lexer.name>;
+
+<lexer.name>.EOF = antlr4.Token.EOF;
+<lexer.tokens:{k | <lexer.name>.<k> = <lexer.tokens.(k)>;}; separator="\n", wrap, anchor>
+
+<rest(lexer.modes):{m| <lexer.name>.<m> = <i>;}; separator="\n">
+
+<lexer.name>.modeNames = [ <lexer.modes:{m| "<m>"}; separator=", ", wrap, anchor> ];
+
+<lexer.name>.literalNames = [ <lexer.literalNames:{t | <t>}; null="null", separator=", ", wrap, anchor> ];
+
+<lexer.name>.symbolicNames = [ <lexer.symbolicNames:{t | <t>}; null="null", separator=", ", wrap, anchor> ];
+
+<lexer.name>.ruleNames = [ <lexer.ruleNames:{r | "<r>"}; separator=", ", wrap, anchor> ];
+
+<lexer.name>.grammarFileName = "<lexer.grammarFileName>";
+
+<namedActions.members>
+
+<dumpActions(lexer, "", actionFuncs, sempredFuncs)>
+
+exports.<lexer.name> = <lexer.name>;
+
+>>
+
+SerializedATN(model) ::= <<
+<! only one segment, can be inlined !>
+
+var serializedATN = ["<model.serialized; wrap={",<\n>    "}>"].join("");
+
+>>
+
+/** Using a type to init value map, try to init a type; if not in table
+ *	must be an object, default value is "null".
+ */
+initValue(typeName) ::= <<
+<javaTypeInitMap.(typeName)>
+>>
+
+codeFileExtension() ::= ".js"
diff --git a/tool/resources/org/antlr/v4/tool/templates/codegen/Python2/Python2.stg b/tool/resources/org/antlr/v4/tool/templates/codegen/Python2/Python2.stg
new file mode 100644
index 000000000..c4ab7cccd
--- /dev/null
+++ b/tool/resources/org/antlr/v4/tool/templates/codegen/Python2/Python2.stg
@@ -0,0 +1,801 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2012 Terence Parr
+ *  Copyright (c) 2012 Sam Harwell
+ *  Copyright (c) 2014 Eric Vergnaud
+ *  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.
+ */
+
+/** ANTLR tool checks output templates are compatible with tool code generation.
+ *  For now, a simple string match used on x.y of x.y.z scheme.
+ *  Must match Tool.VERSION during load to templates.
+ *
+ *  REQUIRED.
+ */
+
+pythonTypeInitMap ::= [
+	"bool":"False",
+	"int":"0",
+	"float":"0.0",
+	"str":"",
+	default:"None" // anything other than a primitive type is an object
+]
+
+// args must be <object-model-object>, <fields-resulting-in-STs>
+
+ParserFile(file, parser, namedActions, contextSuperClass) ::= <<
+<fileHeader(file.grammarFileName, file.ANTLRVersion)>
+# encoding: utf-8
+from __future__ import print_function
+from antlr4 import *
+from io import StringIO
+
+<namedActions.header>
+<parser>
+
+>>
+
+ListenerFile(file, header) ::= <<
+<fileHeader(file.grammarFileName, file.ANTLRVersion)>
+from antlr4 import *
+<header>
+
+# This class defines a complete listener for a parse tree produced by <file.parserName>.
+class <file.grammarName>Listener(ParseTreeListener):
+
+    <file.listenerNames:{lname |
+# Enter a parse tree produced by <file.parserName>#<lname>.
+def enter<lname; format="cap">(self, ctx):
+    pass
+
+# Exit a parse tree produced by <file.parserName>#<lname>.
+def exit<lname; format="cap">(self, ctx):
+    pass
+
+}; separator="\n">
+
+>>
+
+
+VisitorFile(file, header) ::= <<
+<fileHeader(file.grammarFileName, file.ANTLRVersion)>
+from antlr4 import *
+<header>
+
+# This class defines a complete generic visitor for a parse tree produced by <file.parserName>.
+
+class <file.grammarName>Visitor(ParseTreeVisitor):
+
+    <file.visitorNames:{lname |
+# Visit a parse tree produced by <file.parserName>#<lname>.
+def visit<lname; format="cap">(self, ctx):
+    return self.visitChildren(ctx)
+
+}; separator="\n">
+
+>>
+
+
+fileHeader(grammarFileName, ANTLRVersion) ::= <<
+# Generated from <grammarFileName> by ANTLR <ANTLRVersion>
+>>
+
+Parser(parser, funcs, atn, sempredFuncs, superClass) ::= <<
+<Parser_(ctor="parser_ctor", ...)>
+>>
+
+Parser_(parser, funcs, atn, sempredFuncs, ctor, superClass) ::= <<
+<if(superClass)>
+from .<superClass> import <superClass>
+
+<endif>
+<atn>
+
+class <parser.name> ( <if(superClass)><superClass><else>Parser<endif> ):
+
+    grammarFileName = "<parser.grammarFileName>"
+
+    atn = ATNDeserializer().deserialize(serializedATN())
+
+    decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
+
+    sharedContextCache = PredictionContextCache()
+
+    literalNames = [ <parser.literalNames:{t | u<t>}; null="u\"\<INVALID>\"", separator=", ", wrap, anchor> ]
+
+    symbolicNames = [ <parser.symbolicNames:{t | u<t>}; null="u\"\<INVALID>\"", separator=", ", wrap, anchor> ]
+
+    <parser.rules:{r | RULE_<r.name> = <r.index>}; separator="\n", wrap, anchor>
+
+    ruleNames =  [ <parser.ruleNames:{r | u"<r>"}; separator=", ", wrap, anchor> ]
+
+    EOF = <TokenLabelType()>.EOF
+    <if(parser.tokens)>
+    <parser.tokens:{k | <k>=<parser.tokens.(k)>}; separator="\n", wrap, anchor>
+    <endif>
+
+    <parser:(ctor)()>
+
+    <namedActions.members>
+
+    <funcs; separator="\n">
+
+
+<if(sempredFuncs)>
+    def sempred(self, localctx, ruleIndex, predIndex):
+        if self._predicates == None:
+            self._predicates = dict()
+<parser.sempredFuncs.values:{f |
+        self._predicates[<f.ruleIndex>] = self.<f.name>_sempred}; separator="\n        ">
+        pred = self._predicates.get(ruleIndex, None)
+        if pred is None:
+            raise Exception("No predicate with index:" + str(ruleIndex))
+        else:
+            return pred(localctx, predIndex)
+
+    <sempredFuncs.values; separator="\n">
+<endif>
+
+
+
+>>
+
+dumpActions(recog, argFuncs, actionFuncs, sempredFuncs) ::= <<
+<if(actionFuncs)>
+def action(self, localctx, ruleIndex, actionIndex):
+	if self._actions is None:
+		actions = dict()
+<recog.actionFuncs.values:{f|
+		actions[<f.ruleIndex>] = self.<f.name>_action }; separator="\n">
+		self._actions = actions
+	action = self._actions.get(ruleIndex, None)
+	if action is not None:
+		action(localctx, actionIndex)
+	else:
+		raise Exception("No registered action for:" + str(ruleIndex))
+
+<actionFuncs.values; separator="\n">
+
+<endif>
+<if(sempredFuncs)>
+def sempred(self, localctx, ruleIndex, predIndex):
+    if self._predicates is None:
+        preds = dict()
+<recog.sempredFuncs.values:{f|
+        preds[<f.ruleIndex>] = self.<f.name>_sempred}; separator="\n">
+        self._predicates = preds
+    pred = self._predicates.get(ruleIndex, None)
+    if pred is not None:
+        return pred(localctx, predIndex)
+    else:
+        raise Exception("No registered predicate for:" + str(ruleIndex))
+
+<sempredFuncs.values; separator="\n">
+<endif>
+>>
+
+parser_ctor(p) ::= <<
+def __init__(self, input):
+    super(<parser.name>, self).__init__(input)
+    self.checkVersion("<file.ANTLRVersion>")
+    self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache)
+    self._predicates = None
+
+>>
+
+/* This generates a private method since the actionIndex is generated, making an
+ * overriding implementation impossible to maintain.
+ */
+RuleActionFunction(r, actions) ::= <<
+
+def <r.name>_action(self, localctx , actionIndex):
+<actions:{index|
+<if(first(actions))>
+    if actionIndex == <index>:
+        <actions.(index)>
+<elseif(rest(actions))>
+    elif actionIndex == <index>:
+        <actions.(index)>
+<endif> }; separator="\n">
+>>
+
+/* This generates a private method since the predIndex is generated, making an
+ * overriding implementation impossible to maintain.
+ */
+RuleSempredFunction(r, actions) ::= <<
+def <r.name>_sempred(self, localctx, predIndex):
+    <actions:{index|
+<if(first(actions))>
+    if predIndex == <index>:
+        return <actions.(index)>
+<elseif(rest(actions))>
+    elif predIndex == <index>:
+        return <actions.(index)>
+<endif> }; separator="\n">
+
+>>
+
+RuleFunction(currentRule,args,code,locals,ruleCtx,altLabelCtxs,namedActions,finallyAction,postamble,exceptions) ::= <<
+
+<ruleCtx>
+
+<altLabelCtxs:{l | <altLabelCtxs.(l)>}; separator="\n">
+
+def <currentRule.name>(self<currentRule.args:{a | , <a.name>}>):
+
+    localctx = <parser.name>.<currentRule.ctxType>(self, self._ctx, self.state<currentRule.args:{a | , <a.name>}>)
+    self.enterRule(localctx, <currentRule.startState>, self.RULE_<currentRule.name>)
+    <namedActions.init>
+    <locals; separator="\n">
+    try:
+        <code>
+        <postamble; separator="\n">
+        <namedActions.after>
+    <if(exceptions)>
+    <exceptions; separator="\n">
+    <else>
+    except RecognitionException as re:
+        localctx.exception = re
+        self._errHandler.reportError(self, re)
+        self._errHandler.recover(self, re)
+    <endif>
+    finally:
+        <finallyAction>
+        self.exitRule()
+    return localctx
+
+>>
+
+LeftRecursiveRuleFunction(currentRule,args,code,locals,ruleCtx,altLabelCtxs,
+	namedActions,finallyAction,postamble) ::=
+<<
+
+<ruleCtx>
+<altLabelCtxs:{l | <altLabelCtxs.(l)>}; separator="\n">
+
+def <currentRule.name>(self, _p=0<if(currentRule.args)>, <args:{a | , <a>}><endif>):
+    _parentctx = self._ctx
+    _parentState = self.state
+    localctx = <parser.name>.<currentRule.ctxType>(self, self._ctx, _parentState<args:{a | , <a.name>}>)
+    _prevctx = localctx
+    _startState = <currentRule.startState>
+    self.enterRecursionRule(localctx, <currentRule.startState>, self.RULE_<currentRule.name>, _p)
+    <namedActions.init>
+    <locals; separator="\n">
+    try:
+        <code>
+        <postamble; separator="\n">
+        <namedActions.after>
+    except RecognitionException as re:
+        localctx.exception = re
+        self._errHandler.reportError(self, re)
+        self._errHandler.recover(self, re)
+    finally:
+        <finallyAction>
+        self.unrollRecursionContexts(_parentctx)
+    return localctx
+
+>>
+
+CodeBlockForOuterMostAlt(currentOuterMostAltCodeBlock, locals, preamble, ops) ::= <<
+<if(currentOuterMostAltCodeBlock.altLabel)>localctx = <parser.name>.<currentOuterMostAltCodeBlock.altLabel; format="cap">Context(self, localctx)<endif>
+self.enterOuterAlt(localctx, <currentOuterMostAltCodeBlock.alt.altNum>)
+<CodeBlockForAlt(currentAltCodeBlock=currentOuterMostAltCodeBlock, ...)>
+>>
+
+CodeBlockForAlt(currentAltCodeBlock, locals, preamble, ops) ::= <<
+<locals; separator="\n">
+<preamble; separator="\n">
+<ops; separator="\n">
+>>
+
+LL1AltBlock(choice, preamble, alts, error) ::= <<
+self.state = <choice.stateNumber>
+<if(choice.label)><labelref(choice.label)> = _input.LT(1)<endif>
+<preamble; separator="\n">
+token = self._input.LA(1)
+<choice.altLook,alts:{look,alt| <cases(ttypes=look)>
+    <alt>
+	}; separator="\nel">
+else:
+    <error>
+
+>>
+
+LL1OptionalBlock(choice, alts, error) ::= <<
+self.state = <choice.stateNumber>
+token = self._input.LA(1)
+<choice.altLook,alts:{look,alt| <cases(ttypes=look)>
+    <alt>
+    pass}; separator="\nel">
+else:
+    <error>
+>>
+
+LL1OptionalBlockSingleAlt(choice, expr, alts, preamble, error, followExpr) ::= <<
+self.state = <choice.stateNumber>
+<preamble; separator="\n">
+if <expr>:
+    <alts; separator="\n">
+
+<!else if ( !(<followExpr>) ) <error>!>
+>>
+
+
+LL1StarBlockSingleAlt(choice, loopExpr, alts, preamble, iteration) ::= <<
+self.state = <choice.stateNumber>
+self._errHandler.sync(self)
+<preamble; separator="\n">
+while <loopExpr>:
+    <alts; separator="\n">
+    self.state = <choice.loopBackStateNumber>
+    self._errHandler.sync(self)
+    <iteration>
+
+>>
+
+LL1PlusBlockSingleAlt(choice, loopExpr, alts, preamble, iteration) ::= <<
+self.state = <choice.blockStartStateNumber> <! alt block decision !>
+self._errHandler.sync(self)
+<preamble; separator="\n">
+while True:
+    <alts; separator="\n">
+    self.state = <choice.stateNumber> <! loopback/exit decision !>
+    self._errHandler.sync(self)
+    <iteration>
+    if not (<loopExpr>):
+        break
+
+>>
+
+// LL(*) stuff
+
+AltBlock(choice, preamble, alts, error) ::= <<
+self.state = <choice.stateNumber>
+self._errHandler.sync(self);
+<if(choice.label)><labelref(choice.label)> = _input.LT(1)<endif>
+<preamble; separator="\n">
+la_ = self._interp.adaptivePredict(self._input,<choice.decision>,self._ctx)
+<alts:{alt |
+if la_ == <i>:
+    <alt>
+    pass
+}; separator="\nel">
+
+>>
+
+OptionalBlock(choice, alts, error) ::= <<
+self.state = <choice.stateNumber>
+self._errHandler.sync(self);
+la_ = self._interp.adaptivePredict(self._input,<choice.decision>,self._ctx)
+<alts:{alt |
+if la_ == <i><if(!choice.ast.greedy)>+1<endif>:
+    <alt>
+}; separator="\nel">
+
+>>
+
+StarBlock(choice, alts, sync, iteration) ::= <<
+self.state = <choice.stateNumber>
+self._errHandler.sync(self)
+_alt = self._interp.adaptivePredict(self._input,<choice.decision>,self._ctx)
+while _alt!=<choice.exitAlt> and _alt!=ATN.INVALID_ALT_NUMBER:
+    if _alt==1<if(!choice.ast.greedy)>+1<endif>:
+        <iteration>
+        <alts> <! should only be one !>
+    self.state = <choice.loopBackStateNumber>
+    self._errHandler.sync(self)
+    _alt = self._interp.adaptivePredict(self._input,<choice.decision>,self._ctx)
+
+>>
+
+PlusBlock(choice, alts, error) ::= <<
+self.state = <choice.blockStartStateNumber> <! alt block decision !>
+self._errHandler.sync(self)
+_alt = 1<if(!choice.ast.greedy)>+1<endif>
+while _alt!=<choice.exitAlt> and _alt!=ATN.INVALID_ALT_NUMBER:
+    <alts:{alt|
+if _alt == <i><if(!choice.ast.greedy)>+1<endif>:
+    <alt>
+}; separator="\nel">
+    else:
+        <error>
+    self.state = <choice.loopBackStateNumber> <! loopback/exit decision !>
+    self._errHandler.sync(self)
+    _alt = self._interp.adaptivePredict(self._input,<choice.decision>,self._ctx)
+
+>>
+
+Sync(s) ::= "sync(<s.expecting.name>)"
+
+ThrowNoViableAlt(t) ::= "raise NoViableAltException(self)"
+
+TestSetInline(s) ::= <<
+<s.bitsets:{bits | <if(rest(rest(bits.ttypes)))><bitsetBitfieldComparison(s, bits)><else><bitsetInlineComparison(s, bits)><endif>}; separator=" or ">
+>>
+
+// Java language spec 15.19 - shift operators mask operands rather than overflow to 0... need range test
+testShiftInRange(shiftAmount) ::= <<
+((<shiftAmount>) & ~0x3f) == 0
+>>
+
+// produces smaller bytecode only when bits.ttypes contains more than two items
+bitsetBitfieldComparison(s, bits) ::= <%
+(<testShiftInRange({<offsetShiftVar(s.varName, bits.shift)>})> and ((1 \<\< <offsetShiftVar(s.varName, bits.shift)>) & (<bits.ttypes:{ttype | (1 \<\< <offsetShiftType(ttype, bits.shift)>)}; separator=" | ">)) != 0)
+%>
+
+isZero ::= [
+"0":true,
+default:false
+]
+
+offsetShiftVar(shiftAmount, offset) ::= <%
+<if(!isZero.(offset))>(<shiftAmount> - <offset>)<else><shiftAmount><endif>
+%>
+
+offsetShiftType(shiftAmount, offset) ::= <%
+<if(!isZero.(offset))>(<parser.name>.<shiftAmount> - <offset>)<else><parser.name>.<shiftAmount><endif>
+%>
+
+// produces more efficient bytecode when bits.ttypes contains at most two items
+bitsetInlineComparison(s, bits) ::= <%
+<bits.ttypes:{ttype | <s.varName>==<parser.name>.<ttype>}; separator=" or ">
+%>
+
+cases(ttypes) ::= <<
+if token in [<ttypes:{t | <parser.name>.<t>}; separator=", ">]:
+>>
+
+InvokeRule(r, argExprsChunks) ::= <<
+self.state = <r.stateNumber>
+<if(r.labels)><r.labels:{l | <labelref(l)> = }><endif>self.<r.name>(<if(r.ast.options.p)><r.ast.options.p><if(argExprsChunks)>,<endif><endif><argExprsChunks>)
+>>
+
+MatchToken(m) ::= <<
+self.state = <m.stateNumber>
+<if(m.labels)><m.labels:{l | <labelref(l)> = }><endif>self.match(<parser.name>.<m.name>)
+>>
+
+MatchSet(m, expr, capture) ::= "<CommonSetStuff(m, expr, capture, false)>"
+
+MatchNotSet(m, expr, capture) ::= "<CommonSetStuff(m, expr, capture, true)>"
+
+CommonSetStuff(m, expr, capture, invert) ::= <<
+self.state = <m.stateNumber>
+<if(m.labels)><m.labels:{l | <labelref(l)> = }>self._input.LT(1)<endif>
+<capture>
+<if(invert)>if <m.varName> \<= 0 or <expr><else>if not(<expr>)<endif>:
+<if(m.labels)><m.labels:{l |     <labelref(l)> = }><else>    <endif>self._errHandler.recoverInline(self)
+else:
+    self.consume()
+>>
+
+Wildcard(w) ::= <<
+self.state = <w.stateNumber>
+<if(w.labels)><w.labels:{l | <labelref(l)> = }><endif>self.matchWildcard()
+>>
+
+// ACTION STUFF
+
+Action(a, foo, chunks) ::= "<chunks>"
+
+ArgAction(a, chunks) ::= "<chunks>"
+
+SemPred(p, chunks, failChunks) ::= <<
+self.state = <p.stateNumber>
+if not <chunks>:
+    from antlr4.error.Errors import FailedPredicateException
+    raise FailedPredicateException(self, <p.predicate><if(failChunks)>, <failChunks><elseif(p.msg)>, <p.msg><endif>)
+>>
+
+ExceptionClause(e, catchArg, catchAction) ::= <<
+catch (<catchArg>) {
+	<catchAction>
+}
+>>
+
+// lexer actions are not associated with model objects
+
+LexerSkipCommand()  ::= "skip()"
+LexerMoreCommand()  ::= "more()"
+LexerPopModeCommand() ::= "popMode()"
+
+LexerTypeCommand(arg)      ::= "_type = <arg>"
+LexerChannelCommand(arg)   ::= "_channel = <arg>"
+LexerModeCommand(arg)      ::= "_mode = <arg>"
+LexerPushModeCommand(arg)  ::= "pushMode(<arg>)"
+
+ActionText(t) ::= "<t.text>"
+ActionTemplate(t) ::= "<t.st>"
+ArgRef(a) ::= "localctx.<a.name>"
+LocalRef(a) ::= "localctx.<a.name>"
+RetValueRef(a) ::= "localctx.<a.name>"
+QRetValueRef(a) ::= "<ctx(a)>.<a.dict>.<a.name>"
+/** How to translate $tokenLabel */
+TokenRef(t) ::= "<ctx(t)>.<t.name>"
+LabelRef(t) ::= "<ctx(t)>.<t.name>"
+ListLabelRef(t) ::= "<ctx(t)>.<ListLabelName(t.name)>"
+SetAttr(s,rhsChunks) ::= "<ctx(s)>.<s.name> = <rhsChunks>"
+
+TokenLabelType() ::= "<file.TokenLabelType; null={Token}>"
+InputSymbolType() ::= "<file.InputSymbolType; null={Token}>"
+
+TokenPropertyRef_text(t) ::= "(None if <ctx(t)>.<t.label> is None else <ctx(t)>.<t.label>.text)"
+TokenPropertyRef_type(t) ::= "(0 if <ctx(t)>.<t.label> is None else <ctx(t)>.<t.label>.type()"
+TokenPropertyRef_line(t) ::= "(0 if <ctx(t)>.<t.label> is None else <ctx(t)>.<t.label>.line)"
+TokenPropertyRef_pos(t) ::= "(0 if <ctx(t)>.<t.label> is None else <ctx(t)>.<t.label>.column)"
+TokenPropertyRef_channel(t) ::= "(0 if (<ctx(t)>.<t.label> is None else <ctx(t)>.<t.label>.channel)"
+TokenPropertyRef_index(t) ::= "(0 if <ctx(t)>.<t.label> is None else <ctx(t)>.<t.label>.tokenIndex)"
+TokenPropertyRef_int(t) ::= "(0 if <ctx(t)>.<t.label> is None else int(<ctx(t)>.<t.label>.text))"
+
+RulePropertyRef_start(r) ::= "(None if <ctx(r)>.<r.label> is None else <ctx(r)>.<r.label>.start)"
+RulePropertyRef_stop(r)	 ::= "(None if <ctx(r)>.<r.label> is None else <ctx(r)>.<r.label>.stop)"
+RulePropertyRef_text(r)	 ::= "(None if <ctx(r)>.<r.label> is None else self._input.getText((<ctx(r)>.<r.label>.start,<ctx(r)>.<r.label>.stop)))"
+RulePropertyRef_ctx(r)	 ::= "<ctx(r)>.<r.label>"
+RulePropertyRef_parser(r)	 ::= "self"
+
+ThisRulePropertyRef_start(r) ::= "localctx.start"
+ThisRulePropertyRef_stop(r)	 ::= "localctx.stop"
+ThisRulePropertyRef_text(r)	 ::= "self._input.getText((localctx.start, self._input.LT(-1)))"
+ThisRulePropertyRef_ctx(r)	 ::= "localctx"
+ThisRulePropertyRef_parser(r)	 ::= "self"
+
+NonLocalAttrRef(s)		 	 ::= "getInvokingContext(<s.ruleIndex>).<s.name>"
+SetNonLocalAttr(s, rhsChunks)  ::= "getInvokingContext(<s.ruleIndex>).<s.name> = <rhsChunks>"
+
+AddToLabelList(a) ::= "<ctx(a.label)>.<a.listName>.append(<labelref(a.label)>)"
+
+TokenDecl(t) ::= "self.<t.name> = None # <TokenLabelType()>"
+TokenTypeDecl(t) ::= "self.<t.name> = 0 # <TokenLabelType()> type"
+TokenListDecl(t) ::= "self.<t.name> = list() # of <TokenLabelType()>s"
+RuleContextDecl(r) ::= "self.<r.name> = None # <r.ctxName>"
+RuleContextListDecl(rdecl) ::= "self.<rdecl.name> = list() # of <rdecl.ctxName>s"
+
+ContextTokenGetterDecl(t)      ::= <<
+def <t.name>(self):
+    return self.getToken(<parser.name>.<t.name>, 0)
+>>
+
+// should never be called
+ContextTokenListGetterDecl(t)  ::= <<
+def <t.name>_list(self):
+    return self.getTokens(<parser.name>.<t.name>)
+>>
+
+ContextTokenListIndexedGetterDecl(t)  ::= <<
+def <t.name>(self, i=None):
+    if i is None:
+        return self.getTokens(<parser.name>.<t.name>)
+    else:
+        return self.getToken(<parser.name>.<t.name>, i)
+>>
+
+ContextRuleGetterDecl(r)       ::= <<
+def <r.name>(self):
+    return self.getTypedRuleContext(<parser.name>.<r.ctxName>,0)
+
+>>
+
+// should never be called
+ContextRuleListGetterDecl(r)   ::= <<
+def <r.name>_list(self):
+    return self.getTypedRuleContexts(<parser.name>.<r.ctxName>)
+
+>>
+
+ContextRuleListIndexedGetterDecl(r)   ::= <<
+def <r.name>(self, i=None):
+    if i is None:
+        return self.getTypedRuleContexts(<parser.name>.<r.ctxName>)
+    else:
+        return self.getTypedRuleContext(<parser.name>.<r.ctxName>,i)
+
+>>
+
+LexerRuleContext() ::= "RuleContext"
+
+/** The rule context name is the rule followed by a suffix; e.g.,
+ *	r becomes rContext.
+ */
+RuleContextNameSuffix() ::= "Context"
+
+ImplicitTokenLabel(tokenName) ::= "_<tokenName>"
+ImplicitRuleLabel(ruleName)	  ::= "_<ruleName>"
+ImplicitSetLabel(id)		  ::= "_tset<id>"
+ListLabelName(label)		  ::= "<label>"
+
+CaptureNextToken(d) ::= "<d.varName> = self._input.LT(1)"
+CaptureNextTokenType(d) ::= "<d.varName> = self._input.LA(1)"
+
+StructDecl(struct,ctorAttrs,attrs,getters,dispatchMethods,interfaces,extensionMembers) ::= <<
+class <struct.name>(<if(contextSuperClass)><contextSuperClass><else>ParserRuleContext<endif>):
+
+    def __init__(self, parser, parent=None, invokingState=-1<struct.ctorAttrs:{a | , <a.name>=None}>):
+        super(<parser.name>.<struct.name>, self).__init__(parent, invokingState)
+        self.parser = parser
+        <attrs:{a | <a>}; separator="\n">
+        <struct.ctorAttrs:{a | self.<a.name> = <a.name>}; separator="\n">
+
+    <getters:{g | <g>}; separator="\n\n">
+
+    def getRuleIndex(self):
+        return <parser.name>.RULE_<struct.derivedFromName>
+
+<if(struct.provideCopyFrom)> <! don't need copy unless we have subclasses !>
+    def copyFrom(self, ctx):
+        super(<parser.name>.<struct.name>, self).copyFrom(ctx)
+        <struct.attrs:{a | self.<a.name> = ctx.<a.name>}; separator="\n">
+
+<endif>
+    <dispatchMethods; separator="\n">
+    <extensionMembers; separator="\n">
+
+>>
+
+AltLabelStructDecl(struct,attrs,getters,dispatchMethods) ::= <<
+class <struct.name>(<currentRule.name; format="cap">Context):
+
+    def __init__(self, parser, ctx): # actually a <parser.name>.<currentRule.name; format="cap">Context)
+        super(<parser.name>.<struct.name>, self).__init__(parser)
+        <attrs:{a | <a>}; separator="\n">
+        self.copyFrom(ctx)
+
+    <getters:{g | <g>}; separator="\n">
+
+    <dispatchMethods; separator="\n">
+
+>>
+
+ListenerDispatchMethod(method) ::= <<
+def <if(method.isEnter)>enter<else>exit<endif>Rule(self, listener):
+    if hasattr(listener, "<if(method.isEnter)>enter<else>exit<endif><struct.derivedFromName; format="cap">"):
+        listener.<if(method.isEnter)>enter<else>exit<endif><struct.derivedFromName; format="cap">(self)
+
+>>
+
+VisitorDispatchMethod(method) ::= <<
+def accept(self, visitor):
+    if hasattr(visitor, "visit<struct.derivedFromName; format="cap">"):
+        return visitor.visit<struct.derivedFromName; format="cap">(self)
+    else:
+        return visitor.visitChildren(self)
+
+>>
+
+AttributeDecl(d) ::= "self.<d.name> = <if(d.initValue)><d.initValue><else>None<endif>"
+
+/** If we don't know location of label def x, use this template */
+labelref(x) ::= "<if(!x.isLocal)>localctx.<endif><x.name>"
+
+/** For any action chunk, what is correctly-typed context struct ptr? */
+ctx(actionChunk) ::= "localctx"
+
+// used for left-recursive rules
+recRuleAltPredicate(ruleName,opPrec)  ::= "self.precpred(self._ctx, <opPrec>)"
+recRuleSetReturnAction(src,name)	  ::= "$<name>=$<src>.<name>"
+recRuleSetStopToken()                 ::= "self._ctx.stop = self._input.LT(-1)"
+
+recRuleAltStartAction(ruleName, ctxName, label) ::= <<
+localctx = <parser.name>.<ctxName>Context(self, _parentctx, _parentState)
+<if(label)>localctx.<label> = _prevctx<endif>
+self.pushNewRecursionContext(localctx, _startState, self.RULE_<ruleName>)
+>>
+
+recRuleLabeledAltStartAction(ruleName, currentAltLabel, label, isListLabel) ::= <<
+localctx = <parser.name>.<currentAltLabel; format="cap">Context(self, <parser.name>.<ruleName; format="cap">Context(self, _parentctx, _parentState))
+<if(label)>
+<if(isListLabel)>
+localctx.<label>.append(_prevctx)
+<else>
+localctx.<label> = _prevctx
+<endif>
+<endif>
+self.pushNewRecursionContext(localctx, _startState, self.RULE_<ruleName>)
+>>
+
+
+recRuleReplaceContext(ctxName) ::= <<
+localctx = <parser.name>.<ctxName>Context(self, localctx)
+self._ctx = localctx
+_prevctx = localctx
+>>
+
+recRuleSetPrevCtx() ::= <<
+if self._parseListeners is not None:
+    self.triggerExitRuleEvent()
+_prevctx = localctx
+>>
+
+
+LexerFile(lexerFile, lexer, namedActions) ::= <<
+<fileHeader(lexerFile.grammarFileName, lexerFile.ANTLRVersion)>
+# encoding: utf-8
+from __future__ import print_function
+from antlr4 import *
+from io import StringIO
+
+<namedActions.header>
+
+<lexer>
+>>
+
+Lexer(lexer, atn, actionFuncs, sempredFuncs, superClass) ::= <<
+
+<atn>
+
+class <lexer.name>(<if(superClass)><superClass><else>Lexer<endif>):
+
+    atn = ATNDeserializer().deserialize(serializedATN())
+
+    decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
+
+    <rest(lexer.modes):{m| <m> = <i>}; separator="\n">
+
+    <lexer.tokens:{k | <k> = <lexer.tokens.(k)>}; separator="\n", wrap, anchor>
+
+    modeNames = [ <lexer.modes:{m| u"<m>"}; separator=", ", wrap, anchor> ]
+
+    literalNames = [ u"\<INVALID>",
+            <lexer.literalNames:{t | u<t>}; separator=", ", wrap, anchor> ]
+
+    symbolicNames = [ u"\<INVALID>",
+            <lexer.symbolicNames:{t | u<t>}; separator=", ", wrap, anchor> ]
+
+    ruleNames = [ <lexer.ruleNames:{r | u"<r>"}; separator=", ", wrap, anchor> ]
+
+    grammarFileName = u"<lexer.grammarFileName>"
+
+    def __init__(self, input=None):
+        super(<lexer.name>, self).__init__(input)
+        self.checkVersion("<lexerFile.ANTLRVersion>")
+        self._interp = LexerATNSimulator(self, self.atn, self.decisionsToDFA, PredictionContextCache())
+        self._actions = None
+        self._predicates = None
+
+    <namedActions.members>
+
+    <dumpActions(lexer, "", actionFuncs, sempredFuncs)>
+
+>>
+
+SerializedATN(model) ::= <<
+<! only one segment, can be inlined !>
+
+def serializedATN():
+    with StringIO() as buf:
+        buf.write(u"<model.serialized; wrap={")<\n>        buf.write(u"}>")
+        return buf.getvalue()
+
+>>
+
+/** Using a type to init value map, try to init a type; if not in table
+ *	must be an object, default value is "null".
+ */
+initValue(typeName) ::= <<
+<javaTypeInitMap.(typeName)>
+>>
+
+codeFileExtension() ::= ".py"
diff --git a/tool/resources/org/antlr/v4/tool/templates/codegen/Python3/Python3.stg b/tool/resources/org/antlr/v4/tool/templates/codegen/Python3/Python3.stg
new file mode 100644
index 000000000..c3410795b
--- /dev/null
+++ b/tool/resources/org/antlr/v4/tool/templates/codegen/Python3/Python3.stg
@@ -0,0 +1,806 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2012 Terence Parr
+ *  Copyright (c) 2012 Sam Harwell
+ *  Copyright (c) 2014 Eric Vergnaud
+ *  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.
+ */
+
+/** ANTLR tool checks output templates are compatible with tool code generation.
+ *  For now, a simple string match used on x.y of x.y.z scheme.
+ *  Must match Tool.VERSION during load to templates.
+ *
+ *  REQUIRED.
+ */
+
+pythonTypeInitMap ::= [
+	"bool":"False",
+	"int":"0",
+	"float":"0.0",
+	"str":"",
+	default:"None" // anything other than a primitive type is an object
+]
+
+// args must be <object-model-object>, <fields-resulting-in-STs>
+
+ParserFile(file, parser, namedActions, contextSuperClass) ::= <<
+<fileHeader(file.grammarFileName, file.ANTLRVersion)>
+# encoding: utf-8
+from antlr4 import *
+from io import StringIO
+
+<namedActions.header>
+<parser>
+
+>>
+
+ListenerFile(file, header) ::= <<
+<fileHeader(file.grammarFileName, file.ANTLRVersion)>
+from antlr4 import *
+if __name__ is not None and "." in __name__:
+    from .<file.parserName> import <file.parserName>
+else:
+    from <file.parserName> import <file.parserName>
+<header>
+
+# This class defines a complete listener for a parse tree produced by <file.parserName>.
+class <file.grammarName>Listener(ParseTreeListener):
+
+    <file.listenerNames:{lname |
+# Enter a parse tree produced by <file.parserName>#<lname>.
+def enter<lname; format="cap">(self, ctx:<file.parserName>.<lname; format="cap">Context):
+    pass
+
+# Exit a parse tree produced by <file.parserName>#<lname>.
+def exit<lname; format="cap">(self, ctx:<file.parserName>.<lname; format="cap">Context):
+    pass
+
+}; separator="\n">
+
+>>
+
+
+VisitorFile(file, header) ::= <<
+<fileHeader(file.grammarFileName, file.ANTLRVersion)>
+from antlr4 import *
+if __name__ is not None and "." in __name__:
+    from .<file.parserName> import <file.parserName>
+else:
+    from <file.parserName> import <file.parserName>
+<header>
+
+# This class defines a complete generic visitor for a parse tree produced by <file.parserName>.
+
+class <file.grammarName>Visitor(ParseTreeVisitor):
+
+    <file.visitorNames:{lname |
+# Visit a parse tree produced by <file.parserName>#<lname>.
+def visit<lname; format="cap">(self, ctx:<file.parserName>.<lname; format="cap">Context):
+    return self.visitChildren(ctx)
+
+}; separator="\n">
+
+del <file.parserName>
+>>
+
+
+fileHeader(grammarFileName, ANTLRVersion) ::= <<
+# Generated from <grammarFileName> by ANTLR <ANTLRVersion>
+>>
+
+Parser(parser, funcs, atn, sempredFuncs, superClass) ::= <<
+<Parser_(ctor="parser_ctor", ...)>
+>>
+
+Parser_(parser, funcs, atn, sempredFuncs, ctor, superClass) ::= <<
+<if(superClass)>
+from .<superClass> import <superClass>
+
+<endif>
+<atn>
+
+class <parser.name> ( <if(superClass)><superClass><else>Parser<endif> ):
+
+    grammarFileName = "<parser.grammarFileName>"
+
+    atn = ATNDeserializer().deserialize(serializedATN())
+
+    decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
+
+    sharedContextCache = PredictionContextCache()
+
+    literalNames = [ <parser.literalNames:{t | <t>}; null="\"\<INVALID>\"", separator=", ", wrap, anchor> ]
+
+    symbolicNames = [ <parser.symbolicNames:{t | <t>}; null="\"\<INVALID>\"", separator=", ", wrap, anchor> ]
+
+    <parser.rules:{r | RULE_<r.name> = <r.index>}; separator="\n", wrap, anchor>
+
+    ruleNames =  [ <parser.ruleNames:{r | "<r>"}; separator=", ", wrap, anchor> ]
+
+    EOF = <TokenLabelType()>.EOF
+    <if(parser.tokens)>
+    <parser.tokens:{k | <k>=<parser.tokens.(k)>}; separator="\n", wrap, anchor>
+    <endif>
+
+    <parser:(ctor)()>
+
+    <namedActions.members>
+
+    <funcs; separator="\n">
+
+
+<if(sempredFuncs)>
+    def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int):
+        if self._predicates == None:
+            self._predicates = dict()
+<parser.sempredFuncs.values:{f |
+        self._predicates[<f.ruleIndex>] = self.<f.name>_sempred}; separator="\n        ">
+        pred = self._predicates.get(ruleIndex, None)
+        if pred is None:
+            raise Exception("No predicate with index:" + str(ruleIndex))
+        else:
+            return pred(localctx, predIndex)
+
+    <sempredFuncs.values; separator="\n">
+<endif>
+
+
+
+>>
+
+dumpActions(recog, argFuncs, actionFuncs, sempredFuncs) ::= <<
+<if(actionFuncs)>
+def action(self, localctx:RuleContext, ruleIndex:int, actionIndex:int):
+	if self._actions is None:
+		actions = dict()
+<recog.actionFuncs.values:{f|
+		actions[<f.ruleIndex>] = self.<f.name>_action }; separator="\n">
+		self._actions = actions
+	action = self._actions.get(ruleIndex, None)
+	if action is not None:
+		action(localctx, actionIndex)
+	else:
+		raise Exception("No registered action for:" + str(ruleIndex))
+
+<actionFuncs.values; separator="\n">
+
+<endif>
+<if(sempredFuncs)>
+def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int):
+    if self._predicates is None:
+        preds = dict()
+<recog.sempredFuncs.values:{f|
+        preds[<f.ruleIndex>] = self.<f.name>_sempred}; separator="\n">
+        self._predicates = preds
+    pred = self._predicates.get(ruleIndex, None)
+    if pred is not None:
+        return pred(localctx, predIndex)
+    else:
+        raise Exception("No registered predicate for:" + str(ruleIndex))
+
+<sempredFuncs.values; separator="\n">
+<endif>
+>>
+
+parser_ctor(p) ::= <<
+def __init__(self, input:TokenStream):
+    super().__init__(input)
+    self.checkVersion("<file.ANTLRVersion>")
+    self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache)
+    self._predicates = None
+
+>>
+
+/* This generates a private method since the actionIndex is generated, making an
+ * overriding implementation impossible to maintain.
+ */
+RuleActionFunction(r, actions) ::= <<
+
+def <r.name>_action(self, localctx:<r.ctxType> , actionIndex:int):
+<actions:{index|
+<if(first(actions))>
+    if actionIndex == <index>:
+        <actions.(index)>
+<elseif(rest(actions))>
+    elif actionIndex == <index>:
+        <actions.(index)>
+<endif> }; separator="\n">
+>>
+
+/* This generates a private method since the predIndex is generated, making an
+ * overriding implementation impossible to maintain.
+ */
+RuleSempredFunction(r, actions) ::= <<
+def <r.name>_sempred(self, localctx:<r.ctxType>, predIndex:int):
+    <actions:{index|
+<if(first(actions))>
+    if predIndex == <index>:
+        return <actions.(index)>
+<elseif(rest(actions))>
+    elif predIndex == <index>:
+        return <actions.(index)>
+<endif> }; separator="\n">
+
+>>
+
+RuleFunction(currentRule,args,code,locals,ruleCtx,altLabelCtxs,namedActions,finallyAction,postamble,exceptions) ::= <<
+
+<ruleCtx>
+
+<altLabelCtxs:{l | <altLabelCtxs.(l)>}; separator="\n">
+
+def <currentRule.name>(self<currentRule.args:{a | , <a.name><if(a.type)>:<a.type><endif>}>):
+
+    localctx = <parser.name>.<currentRule.ctxType>(self, self._ctx, self.state<currentRule.args:{a | , <a.name>}>)
+    self.enterRule(localctx, <currentRule.startState>, self.RULE_<currentRule.name>)
+    <namedActions.init>
+    <locals; separator="\n">
+    try:
+        <code>
+        <postamble; separator="\n">
+        <namedActions.after>
+    <if(exceptions)>
+    <exceptions; separator="\n">
+    <else>
+    except RecognitionException as re:
+        localctx.exception = re
+        self._errHandler.reportError(self, re)
+        self._errHandler.recover(self, re)
+    <endif>
+    finally:
+        <finallyAction>
+        self.exitRule()
+    return localctx
+
+>>
+
+LeftRecursiveRuleFunction(currentRule,args,code,locals,ruleCtx,altLabelCtxs,
+	namedActions,finallyAction,postamble) ::=
+<<
+
+<ruleCtx>
+<altLabelCtxs:{l | <altLabelCtxs.(l)>}; separator="\n">
+
+def <currentRule.name>(self, _p:int=0<if(currentRule.args)>, <args:{a | , <a>}><endif>):
+    _parentctx = self._ctx
+    _parentState = self.state
+    localctx = <parser.name>.<currentRule.ctxType>(self, self._ctx, _parentState<args:{a | , <a.name>}>)
+    _prevctx = localctx
+    _startState = <currentRule.startState>
+    self.enterRecursionRule(localctx, <currentRule.startState>, self.RULE_<currentRule.name>, _p)
+    <namedActions.init>
+    <locals; separator="\n">
+    try:
+        <code>
+        <postamble; separator="\n">
+        <namedActions.after>
+    except RecognitionException as re:
+        localctx.exception = re
+        self._errHandler.reportError(self, re)
+        self._errHandler.recover(self, re)
+    finally:
+        <finallyAction>
+        self.unrollRecursionContexts(_parentctx)
+    return localctx
+
+>>
+
+CodeBlockForOuterMostAlt(currentOuterMostAltCodeBlock, locals, preamble, ops) ::= <<
+<if(currentOuterMostAltCodeBlock.altLabel)>localctx = <parser.name>.<currentOuterMostAltCodeBlock.altLabel; format="cap">Context(self, localctx)<endif>
+self.enterOuterAlt(localctx, <currentOuterMostAltCodeBlock.alt.altNum>)
+<CodeBlockForAlt(currentAltCodeBlock=currentOuterMostAltCodeBlock, ...)>
+>>
+
+CodeBlockForAlt(currentAltCodeBlock, locals, preamble, ops) ::= <<
+<locals; separator="\n">
+<preamble; separator="\n">
+<ops; separator="\n">
+>>
+
+LL1AltBlock(choice, preamble, alts, error) ::= <<
+self.state = <choice.stateNumber>
+<if(choice.label)><labelref(choice.label)> = _input.LT(1)<endif>
+<preamble; separator="\n">
+token = self._input.LA(1)
+<choice.altLook,alts:{look,alt| <cases(ttypes=look)>
+    <alt>
+	}; separator="\nel">
+else:
+    <error>
+
+>>
+
+LL1OptionalBlock(choice, alts, error) ::= <<
+self.state = <choice.stateNumber>
+token = self._input.LA(1)
+<choice.altLook,alts:{look,alt| <cases(ttypes=look)>
+    <alt>
+    pass}; separator="\nel">
+else:
+    <error>
+>>
+
+LL1OptionalBlockSingleAlt(choice, expr, alts, preamble, error, followExpr) ::= <<
+self.state = <choice.stateNumber>
+<preamble; separator="\n">
+if <expr>:
+    <alts; separator="\n">
+
+<!else if ( !(<followExpr>) ) <error>!>
+>>
+
+
+LL1StarBlockSingleAlt(choice, loopExpr, alts, preamble, iteration) ::= <<
+self.state = <choice.stateNumber>
+self._errHandler.sync(self)
+<preamble; separator="\n">
+while <loopExpr>:
+    <alts; separator="\n">
+    self.state = <choice.loopBackStateNumber>
+    self._errHandler.sync(self)
+    <iteration>
+
+>>
+
+LL1PlusBlockSingleAlt(choice, loopExpr, alts, preamble, iteration) ::= <<
+self.state = <choice.blockStartStateNumber> <! alt block decision !>
+self._errHandler.sync(self)
+<preamble; separator="\n">
+while True:
+    <alts; separator="\n">
+    self.state = <choice.stateNumber> <! loopback/exit decision !>
+    self._errHandler.sync(self)
+    <iteration>
+    if not (<loopExpr>):
+        break
+
+>>
+
+// LL(*) stuff
+
+AltBlock(choice, preamble, alts, error) ::= <<
+self.state = <choice.stateNumber>
+self._errHandler.sync(self);
+<if(choice.label)><labelref(choice.label)> = _input.LT(1)<endif>
+<preamble; separator="\n">
+la_ = self._interp.adaptivePredict(self._input,<choice.decision>,self._ctx)
+<alts:{alt |
+if la_ == <i>:
+    <alt>
+    pass
+}; separator="\nel">
+
+>>
+
+OptionalBlock(choice, alts, error) ::= <<
+self.state = <choice.stateNumber>
+self._errHandler.sync(self);
+la_ = self._interp.adaptivePredict(self._input,<choice.decision>,self._ctx)
+<alts:{alt |
+if la_ == <i><if(!choice.ast.greedy)>+1<endif>:
+    <alt>
+}; separator="\nel">
+
+>>
+
+StarBlock(choice, alts, sync, iteration) ::= <<
+self.state = <choice.stateNumber>
+self._errHandler.sync(self)
+_alt = self._interp.adaptivePredict(self._input,<choice.decision>,self._ctx)
+while _alt!=<choice.exitAlt> and _alt!=ATN.INVALID_ALT_NUMBER:
+    if _alt==1<if(!choice.ast.greedy)>+1<endif>:
+        <iteration>
+        <alts> <! should only be one !>
+    self.state = <choice.loopBackStateNumber>
+    self._errHandler.sync(self)
+    _alt = self._interp.adaptivePredict(self._input,<choice.decision>,self._ctx)
+
+>>
+
+PlusBlock(choice, alts, error) ::= <<
+self.state = <choice.blockStartStateNumber> <! alt block decision !>
+self._errHandler.sync(self)
+_alt = 1<if(!choice.ast.greedy)>+1<endif>
+while _alt!=<choice.exitAlt> and _alt!=ATN.INVALID_ALT_NUMBER:
+    <alts:{alt|
+if _alt == <i><if(!choice.ast.greedy)>+1<endif>:
+    <alt>
+}; separator="\nel">
+    else:
+        <error>
+    self.state = <choice.loopBackStateNumber> <! loopback/exit decision !>
+    self._errHandler.sync(self)
+    _alt = self._interp.adaptivePredict(self._input,<choice.decision>,self._ctx)
+
+>>
+
+Sync(s) ::= "sync(<s.expecting.name>)"
+
+ThrowNoViableAlt(t) ::= "raise NoViableAltException(self)"
+
+TestSetInline(s) ::= <<
+<s.bitsets:{bits | <if(rest(rest(bits.ttypes)))><bitsetBitfieldComparison(s, bits)><else><bitsetInlineComparison(s, bits)><endif>}; separator=" or ">
+>>
+
+// Java language spec 15.19 - shift operators mask operands rather than overflow to 0... need range test
+testShiftInRange(shiftAmount) ::= <<
+((<shiftAmount>) & ~0x3f) == 0
+>>
+
+// produces smaller bytecode only when bits.ttypes contains more than two items
+bitsetBitfieldComparison(s, bits) ::= <%
+(<testShiftInRange({<offsetShiftVar(s.varName, bits.shift)>})> and ((1 \<\< <offsetShiftVar(s.varName, bits.shift)>) & (<bits.ttypes:{ttype | (1 \<\< <offsetShiftType(ttype, bits.shift)>)}; separator=" | ">)) != 0)
+%>
+
+isZero ::= [
+"0":true,
+default:false
+]
+
+offsetShiftVar(shiftAmount, offset) ::= <%
+<if(!isZero.(offset))>(<shiftAmount> - <offset>)<else><shiftAmount><endif>
+%>
+
+offsetShiftType(shiftAmount, offset) ::= <%
+<if(!isZero.(offset))>(<parser.name>.<shiftAmount> - <offset>)<else><parser.name>.<shiftAmount><endif>
+%>
+
+// produces more efficient bytecode when bits.ttypes contains at most two items
+bitsetInlineComparison(s, bits) ::= <%
+<bits.ttypes:{ttype | <s.varName>==<parser.name>.<ttype>}; separator=" or ">
+%>
+
+cases(ttypes) ::= <<
+if token in [<ttypes:{t | <parser.name>.<t>}; separator=", ">]:
+>>
+
+InvokeRule(r, argExprsChunks) ::= <<
+self.state = <r.stateNumber>
+<if(r.labels)><r.labels:{l | <labelref(l)> = }><endif>self.<r.name>(<if(r.ast.options.p)><r.ast.options.p><if(argExprsChunks)>,<endif><endif><argExprsChunks>)
+>>
+
+MatchToken(m) ::= <<
+self.state = <m.stateNumber>
+<if(m.labels)><m.labels:{l | <labelref(l)> = }><endif>self.match(<parser.name>.<m.name>)
+>>
+
+MatchSet(m, expr, capture) ::= "<CommonSetStuff(m, expr, capture, false)>"
+
+MatchNotSet(m, expr, capture) ::= "<CommonSetStuff(m, expr, capture, true)>"
+
+CommonSetStuff(m, expr, capture, invert) ::= <<
+self.state = <m.stateNumber>
+<if(m.labels)><m.labels:{l | <labelref(l)> = }>self._input.LT(1)<endif>
+<capture>
+<if(invert)>if <m.varName> \<= 0 or <expr><else>if not(<expr>)<endif>:
+<if(m.labels)><m.labels:{l |     <labelref(l)> = }><else>    <endif>self._errHandler.recoverInline(self)
+else:
+    self.consume()
+>>
+
+Wildcard(w) ::= <<
+self.state = <w.stateNumber>
+<if(w.labels)><w.labels:{l | <labelref(l)> = }><endif>self.matchWildcard()
+>>
+
+// ACTION STUFF
+
+Action(a, foo, chunks) ::= "<chunks>"
+
+ArgAction(a, chunks) ::= "<chunks>"
+
+SemPred(p, chunks, failChunks) ::= <<
+self.state = <p.stateNumber>
+if not <chunks>:
+    from antlr4.error.Errors import FailedPredicateException
+    raise FailedPredicateException(self, <p.predicate><if(failChunks)>, <failChunks><elseif(p.msg)>, <p.msg><endif>)
+>>
+
+ExceptionClause(e, catchArg, catchAction) ::= <<
+catch (<catchArg>) {
+	<catchAction>
+}
+>>
+
+// lexer actions are not associated with model objects
+
+LexerSkipCommand()  ::= "skip()"
+LexerMoreCommand()  ::= "more()"
+LexerPopModeCommand() ::= "popMode()"
+
+LexerTypeCommand(arg)      ::= "_type = <arg>"
+LexerChannelCommand(arg)   ::= "_channel = <arg>"
+LexerModeCommand(arg)      ::= "_mode = <arg>"
+LexerPushModeCommand(arg)  ::= "pushMode(<arg>)"
+
+ActionText(t) ::= "<t.text>"
+ActionTemplate(t) ::= "<t.st>"
+ArgRef(a) ::= "localctx.<a.name>"
+LocalRef(a) ::= "localctx.<a.name>"
+RetValueRef(a) ::= "localctx.<a.name>"
+QRetValueRef(a) ::= "<ctx(a)>.<a.dict>.<a.name>"
+/** How to translate $tokenLabel */
+TokenRef(t) ::= "<ctx(t)>.<t.name>"
+LabelRef(t) ::= "<ctx(t)>.<t.name>"
+ListLabelRef(t) ::= "<ctx(t)>.<ListLabelName(t.name)>"
+SetAttr(s,rhsChunks) ::= "<ctx(s)>.<s.name> = <rhsChunks>"
+
+TokenLabelType() ::= "<file.TokenLabelType; null={Token}>"
+InputSymbolType() ::= "<file.InputSymbolType; null={Token}>"
+
+TokenPropertyRef_text(t) ::= "(None if <ctx(t)>.<t.label> is None else <ctx(t)>.<t.label>.text)"
+TokenPropertyRef_type(t) ::= "(0 if <ctx(t)>.<t.label> is None else <ctx(t)>.<t.label>.type()"
+TokenPropertyRef_line(t) ::= "(0 if <ctx(t)>.<t.label> is None else <ctx(t)>.<t.label>.line)"
+TokenPropertyRef_pos(t) ::= "(0 if <ctx(t)>.<t.label> is None else <ctx(t)>.<t.label>.column)"
+TokenPropertyRef_channel(t) ::= "(0 if (<ctx(t)>.<t.label> is None else <ctx(t)>.<t.label>.channel)"
+TokenPropertyRef_index(t) ::= "(0 if <ctx(t)>.<t.label> is None else <ctx(t)>.<t.label>.tokenIndex)"
+TokenPropertyRef_int(t) ::= "(0 if <ctx(t)>.<t.label> is None else int(<ctx(t)>.<t.label>.text))"
+
+RulePropertyRef_start(r) ::= "(None if <ctx(r)>.<r.label> is None else <ctx(r)>.<r.label>.start)"
+RulePropertyRef_stop(r)	 ::= "(None if <ctx(r)>.<r.label> is None else <ctx(r)>.<r.label>.stop)"
+RulePropertyRef_text(r)	 ::= "(None if <ctx(r)>.<r.label> is None else self._input.getText((<ctx(r)>.<r.label>.start,<ctx(r)>.<r.label>.stop)))"
+RulePropertyRef_ctx(r)	 ::= "<ctx(r)>.<r.label>"
+RulePropertyRef_parser(r)	 ::= "self"
+
+ThisRulePropertyRef_start(r) ::= "localctx.start"
+ThisRulePropertyRef_stop(r)	 ::= "localctx.stop"
+ThisRulePropertyRef_text(r)	 ::= "self._input.getText((localctx.start, self._input.LT(-1)))"
+ThisRulePropertyRef_ctx(r)	 ::= "localctx"
+ThisRulePropertyRef_parser(r)	 ::= "self"
+
+NonLocalAttrRef(s)		 	 ::= "getInvokingContext(<s.ruleIndex>).<s.name>"
+SetNonLocalAttr(s, rhsChunks)  ::= "getInvokingContext(<s.ruleIndex>).<s.name> = <rhsChunks>"
+
+AddToLabelList(a) ::= "<ctx(a.label)>.<a.listName>.append(<labelref(a.label)>)"
+
+TokenDecl(t) ::= "self.<t.name> = None # <TokenLabelType()>"
+TokenTypeDecl(t) ::= "self.<t.name> = 0 # <TokenLabelType()> type"
+TokenListDecl(t) ::= "self.<t.name> = list() # of <TokenLabelType()>s"
+RuleContextDecl(r) ::= "self.<r.name> = None # <r.ctxName>"
+RuleContextListDecl(rdecl) ::= "self.<rdecl.name> = list() # of <rdecl.ctxName>s"
+
+ContextTokenGetterDecl(t)      ::= <<
+def <t.name>(self):
+    return self.getToken(<parser.name>.<t.name>, 0)
+>>
+
+// should never be called
+ContextTokenListGetterDecl(t)  ::= <<
+def <t.name>_list(self):
+    return self.getTokens(<parser.name>.<t.name>)
+>>
+
+ContextTokenListIndexedGetterDecl(t)  ::= <<
+def <t.name>(self, i:int=None):
+    if i is None:
+        return self.getTokens(<parser.name>.<t.name>)
+    else:
+        return self.getToken(<parser.name>.<t.name>, i)
+>>
+
+ContextRuleGetterDecl(r)       ::= <<
+def <r.name>(self):
+    return self.getTypedRuleContext(<parser.name>.<r.ctxName>,0)
+
+>>
+
+// should never be called
+ContextRuleListGetterDecl(r)   ::= <<
+def <r.name>_list(self):
+    return self.getTypedRuleContexts(<parser.name>.<r.ctxName>)
+
+>>
+
+ContextRuleListIndexedGetterDecl(r)   ::= <<
+def <r.name>(self, i:int=None):
+    if i is None:
+        return self.getTypedRuleContexts(<parser.name>.<r.ctxName>)
+    else:
+        return self.getTypedRuleContext(<parser.name>.<r.ctxName>,i)
+
+>>
+
+LexerRuleContext() ::= "RuleContext"
+
+/** The rule context name is the rule followed by a suffix; e.g.,
+ *	r becomes rContext.
+ */
+RuleContextNameSuffix() ::= "Context"
+
+ImplicitTokenLabel(tokenName) ::= "_<tokenName>"
+ImplicitRuleLabel(ruleName)	  ::= "_<ruleName>"
+ImplicitSetLabel(id)		  ::= "_tset<id>"
+ListLabelName(label)		  ::= "<label>"
+
+CaptureNextToken(d) ::= "<d.varName> = self._input.LT(1)"
+CaptureNextTokenType(d) ::= "<d.varName> = self._input.LA(1)"
+
+StructDecl(struct,ctorAttrs,attrs,getters,dispatchMethods,interfaces,extensionMembers) ::= <<
+class <struct.name>(<if(contextSuperClass)><contextSuperClass><else>ParserRuleContext<endif>):
+
+    def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1<struct.ctorAttrs:{a | , <a.name><if(a.type)>:<a.type><endif>=None}>):
+        super().__init__(parent, invokingState)
+        self.parser = parser
+        <attrs:{a | <a>}; separator="\n">
+        <struct.ctorAttrs:{a | self.<a.name> = <a.name>}; separator="\n">
+
+    <getters:{g | <g>}; separator="\n\n">
+
+    def getRuleIndex(self):
+        return <parser.name>.RULE_<struct.derivedFromName>
+
+<if(struct.provideCopyFrom)> <! don't need copy unless we have subclasses !>
+    def copyFrom(self, ctx:ParserRuleContext):
+        super().copyFrom(ctx)
+        <struct.attrs:{a | self.<a.name> = ctx.<a.name>}; separator="\n">
+
+<endif>
+    <dispatchMethods; separator="\n">
+    <extensionMembers; separator="\n">
+
+>>
+
+AltLabelStructDecl(struct,attrs,getters,dispatchMethods) ::= <<
+class <struct.name>(<currentRule.name; format="cap">Context):
+
+    def __init__(self, parser, ctx:ParserRuleContext): # actually a <parser.name>.<currentRule.name; format="cap">Context
+        super().__init__(parser)
+        <attrs:{a | <a>}; separator="\n">
+        self.copyFrom(ctx)
+
+    <getters:{g | <g>}; separator="\n">
+
+    <dispatchMethods; separator="\n">
+
+>>
+
+ListenerDispatchMethod(method) ::= <<
+def <if(method.isEnter)>enter<else>exit<endif>Rule(self, listener:ParseTreeListener):
+    if hasattr( listener, "<if(method.isEnter)>enter<else>exit<endif><struct.derivedFromName; format="cap">" ):
+        listener.<if(method.isEnter)>enter<else>exit<endif><struct.derivedFromName; format="cap">(self)
+
+>>
+
+VisitorDispatchMethod(method) ::= <<
+def accept(self, visitor:ParseTreeVisitor):
+    if hasattr( visitor, "visit<struct.derivedFromName; format="cap">" ):
+        return visitor.visit<struct.derivedFromName; format="cap">(self)
+    else:
+        return visitor.visitChildren(self)
+
+>>
+
+AttributeDecl(d) ::= "self.<d.name> = <if(d.initValue)><d.initValue><else>None<endif>"
+
+/** If we don't know location of label def x, use this template */
+labelref(x) ::= "<if(!x.isLocal)>localctx.<endif><x.name>"
+
+/** For any action chunk, what is correctly-typed context struct ptr? */
+ctx(actionChunk) ::= "localctx"
+
+// used for left-recursive rules
+recRuleAltPredicate(ruleName,opPrec)  ::= "self.precpred(self._ctx, <opPrec>)"
+recRuleSetReturnAction(src,name)	  ::= "$<name>=$<src>.<name>"
+recRuleSetStopToken()                 ::= "self._ctx.stop = self._input.LT(-1)"
+
+recRuleAltStartAction(ruleName, ctxName, label) ::= <<
+localctx = <parser.name>.<ctxName>Context(self, _parentctx, _parentState)
+<if(label)>localctx.<label> = _prevctx<endif>
+self.pushNewRecursionContext(localctx, _startState, self.RULE_<ruleName>)
+>>
+
+recRuleLabeledAltStartAction(ruleName, currentAltLabel, label, isListLabel) ::= <<
+localctx = <parser.name>.<currentAltLabel; format="cap">Context(self, <parser.name>.<ruleName; format="cap">Context(self, _parentctx, _parentState))
+<if(label)>
+<if(isListLabel)>
+localctx.<label>.append(_prevctx)
+<else>
+localctx.<label> = _prevctx
+<endif>
+<endif>
+self.pushNewRecursionContext(localctx, _startState, self.RULE_<ruleName>)
+>>
+
+recRuleReplaceContext(ctxName) ::= <<
+localctx = <parser.name>.<ctxName>Context(self, localctx)
+self._ctx = localctx
+_prevctx = localctx
+>>
+
+recRuleSetPrevCtx() ::= <<
+if self._parseListeners is not None:
+    self.triggerExitRuleEvent()
+_prevctx = localctx
+>>
+
+
+LexerFile(lexerFile, lexer, namedActions) ::= <<
+<fileHeader(lexerFile.grammarFileName, lexerFile.ANTLRVersion)>
+from antlr4 import *
+from io import StringIO
+
+<namedActions.header>
+
+<lexer>
+>>
+
+Lexer(lexer, atn, actionFuncs, sempredFuncs, superClass) ::= <<
+
+<atn>
+
+class <lexer.name>(<if(superClass)><superClass><else>Lexer<endif>):
+
+    atn = ATNDeserializer().deserialize(serializedATN())
+
+    decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
+
+    <rest(lexer.modes):{m| <m> = <i>}; separator="\n">
+
+    <lexer.tokens:{k | <k> = <lexer.tokens.(k)>}; separator="\n", wrap, anchor>
+
+    modeNames = [ <lexer.modes:{m| "<m>"}; separator=", ", wrap, anchor> ]
+
+    literalNames = [ "\<INVALID>",
+            <lexer.literalNames:{t | <t>}; separator=", ", wrap, anchor> ]
+
+    symbolicNames = [ "\<INVALID>",
+            <lexer.symbolicNames:{t | <t>}; separator=", ", wrap, anchor> ]
+
+    ruleNames = [ <lexer.ruleNames:{r | "<r>"}; separator=", ", wrap, anchor> ]
+
+    grammarFileName = "<lexer.grammarFileName>"
+
+    def __init__(self, input=None):
+        super().__init__(input)
+        self.checkVersion("<lexerFile.ANTLRVersion>")
+        self._interp = LexerATNSimulator(self, self.atn, self.decisionsToDFA, PredictionContextCache())
+        self._actions = None
+        self._predicates = None
+
+    <namedActions.members>
+
+    <dumpActions(lexer, "", actionFuncs, sempredFuncs)>
+
+>>
+
+SerializedATN(model) ::= <<
+<! only one segment, can be inlined !>
+
+def serializedATN():
+    with StringIO() as buf:
+        buf.write("<model.serialized; wrap={")<\n>        buf.write("}>")
+        return buf.getvalue()
+
+>>
+
+/** Using a type to init value map, try to init a type; if not in table
+ *	must be an object, default value is "null".
+ */
+initValue(typeName) ::= <<
+<javaTypeInitMap.(typeName)>
+>>
+
+codeFileExtension() ::= ".py"
diff --git a/tool/src/org/antlr/v4/Tool.java b/tool/src/org/antlr/v4/Tool.java
index 8ed72ea6d..244126868 100644
--- a/tool/src/org/antlr/v4/Tool.java
+++ b/tool/src/org/antlr/v4/Tool.java
@@ -41,6 +41,7 @@ import org.antlr.v4.automata.ATNFactory;
 import org.antlr.v4.automata.LexerATNFactory;
 import org.antlr.v4.automata.ParserATNFactory;
 import org.antlr.v4.codegen.CodeGenPipeline;
+import org.antlr.v4.codegen.CodeGenerator;
 import org.antlr.v4.misc.Graph;
 import org.antlr.v4.parse.ANTLRParser;
 import org.antlr.v4.parse.GrammarASTAdaptor;
@@ -48,8 +49,8 @@ import org.antlr.v4.parse.GrammarTreeVisitor;
 import org.antlr.v4.parse.ToolANTLRLexer;
 import org.antlr.v4.parse.ToolANTLRParser;
 import org.antlr.v4.parse.v3TreeGrammarException;
+import org.antlr.v4.runtime.RuntimeMetaData;
 import org.antlr.v4.runtime.misc.LogManager;
-import org.antlr.v4.runtime.misc.Nullable;
 import org.antlr.v4.semantics.SemanticPipeline;
 import org.antlr.v4.tool.ANTLRMessage;
 import org.antlr.v4.tool.ANTLRToolListener;
@@ -89,8 +90,9 @@ import java.util.concurrent.CopyOnWriteArrayList;
 public class Tool {
 	public static final String VERSION;
 	static {
-		String version = Tool.class.getPackage().getImplementationVersion();
-		VERSION = version != null ? version : "4.x";
+		// Assigned in a static{} block to prevent the field from becoming a
+		// compile-time constant
+		VERSION = RuntimeMetaData.VERSION;
 	}
 
 	public static final String GRAMMAR_EXTENSION = ".g4";
@@ -120,7 +122,7 @@ public class Tool {
 
 	// fields set by option manager
 
-	public File inputDirectory;
+	public File inputDirectory; // used by mvn plugin but not set by tool itself.
 	public String outputDirectory;
 	public String libDirectory;
 	public boolean generate_ATN_dot = false;
@@ -339,7 +341,7 @@ public class Tool {
 				System.out.println(dep.getDependencies().render());
 
 			}
-			else {
+			else if (errMgr.getNumErrors() == 0) {
 				process(g, true);
 			}
 		}
@@ -396,6 +398,12 @@ public class Tool {
 		SemanticPipeline sem = new SemanticPipeline(g);
 		sem.process();
 
+		String language = g.getOptionString("language");
+		if ( !CodeGenerator.targetExists(language) ) {
+			errMgr.toolError(ErrorType.CANNOT_CREATE_TARGET_GENERATOR, language);
+			return;
+		}
+
 		if ( errMgr.getNumErrors()>prevErrors ) return;
 
 		// BUILD ATN FROM AST
@@ -425,7 +433,8 @@ public class Tool {
 	 * Important enough to avoid multiple definitions that we do very early,
 	 * right after AST construction. Also check for undefined rules in
 	 * parser/lexer to avoid exceptions later. Return true if we find multiple
-	 * definitions of the same rule or a reference to an undefined rule.
+	 * definitions of the same rule or a reference to an undefined rule or
+	 * parser rule ref in lexer rule.
 	 */
 	public boolean checkForRuleIssues(final Grammar g) {
 		// check for redefined rules
@@ -457,7 +466,7 @@ public class Tool {
 
 		// check for undefined rules
 		class UndefChecker extends GrammarTreeVisitor {
-			public boolean undefined = false;
+			public boolean badref = false;
 			@Override
 			public void tokenRef(TerminalAST ref) {
 				if ("EOF".equals(ref.getText())) {
@@ -471,18 +480,28 @@ public class Tool {
 			@Override
 			public void ruleRef(GrammarAST ref, ActionAST arg) {
 				RuleAST ruleAST = ruleToAST.get(ref.getText());
-				if ( ruleAST==null ) {
-					undefined = true;
+				String fileName = ref.getToken().getInputStream().getSourceName();
+				if (Character.isUpperCase(currentRuleName.charAt(0)) &&
+					Character.isLowerCase(ref.getText().charAt(0)))
+				{
+					badref = true;
+					errMgr.grammarError(ErrorType.PARSER_RULE_REF_IN_LEXER_RULE,
+										fileName, ref.getToken(), ref.getText(), currentRuleName);
+				}
+				else if ( ruleAST==null ) {
+					badref = true;
 					errMgr.grammarError(ErrorType.UNDEFINED_RULE_REF,
-										g.fileName, ref.token, ref.getText());
+										fileName, ref.token, ref.getText());
 				}
 			}
+			@Override
+			public ErrorManager getErrorManager() { return errMgr; }
 		}
 
 		UndefChecker chk = new UndefChecker();
 		chk.visitGrammar(g.ast);
 
-		return redefinition || chk.undefined;
+		return redefinition || chk.badref;
 	}
 
 	public List<GrammarRootAST> sortGrammarByTokenVocab(List<String> fileNames) {
@@ -490,7 +509,7 @@ public class Tool {
 		Graph<String> g = new Graph<String>();
 		List<GrammarRootAST> roots = new ArrayList<GrammarRootAST>();
 		for (String fileName : fileNames) {
-			GrammarAST t = loadGrammar(fileName);
+			GrammarAST t = parseGrammar(fileName);
 			if ( t==null || t instanceof GrammarASTErrorNode) continue; // came back as error node
 			if ( ((GrammarRootAST)t).hasErrors ) continue;
 			GrammarRootAST root = (GrammarRootAST)t;
@@ -558,7 +577,7 @@ public class Tool {
 		return g;
 	}
 
-	public GrammarRootAST loadGrammar(String fileName) {
+	public GrammarRootAST parseGrammar(String fileName) {
 		try {
 			File file = new File(fileName);
 			if (!file.isAbsolute()) {
@@ -566,7 +585,7 @@ public class Tool {
 			}
 
 			ANTLRFileStream in = new ANTLRFileStream(file.getAbsolutePath(), grammarEncoding);
-			GrammarRootAST t = load(fileName, in);
+			GrammarRootAST t = parse(fileName, in);
 			return t;
 		}
 		catch (IOException ioe) {
@@ -575,38 +594,64 @@ public class Tool {
 		return null;
 	}
 
+	/** Convenience method to load and process an ANTLR grammar. Useful
+	 *  when creating interpreters.  If you need to access to the lexer
+	 *  grammar created while processing a combined grammar, use
+	 *  getImplicitLexer() on returned grammar.
+	 */
+	public Grammar loadGrammar(String fileName) {
+		GrammarRootAST grammarRootAST = parseGrammar(fileName);
+		final Grammar g = createGrammar(grammarRootAST);
+		g.fileName = fileName;
+		process(g, false);
+		return g;
+	}
+
+	private final Map<String, Grammar> importedGrammars = new HashMap<String, Grammar>();
+
 	/**
 	 * Try current dir then dir of g then lib dir
 	 * @param g
-	 * @param name The imported grammar name.
+	 * @param nameNode The node associated with the imported grammar name.
 	 */
-	public Grammar loadImportedGrammar(Grammar g, String name) throws IOException {
-		g.tool.log("grammar", "load " + name + " from " + g.fileName);
-		File importedFile = null;
-		for (String extension : ALL_GRAMMAR_EXTENSIONS) {
-			importedFile = getImportedGrammarFile(g, name + extension);
-			if (importedFile != null) {
-				break;
+	public Grammar loadImportedGrammar(Grammar g, GrammarAST nameNode) throws IOException {
+		String name = nameNode.getText();
+		Grammar imported = importedGrammars.get(name);
+		if (imported == null) {
+			g.tool.log("grammar", "load " + name + " from " + g.fileName);
+			File importedFile = null;
+			for (String extension : ALL_GRAMMAR_EXTENSIONS) {
+				importedFile = getImportedGrammarFile(g, name + extension);
+				if (importedFile != null) {
+					break;
+				}
 			}
+
+			if ( importedFile==null ) {
+				errMgr.grammarError(ErrorType.CANNOT_FIND_IMPORTED_GRAMMAR, g.fileName, nameNode.getToken(), name);
+				return null;
+			}
+
+			String absolutePath = importedFile.getAbsolutePath();
+			ANTLRFileStream in = new ANTLRFileStream(absolutePath, grammarEncoding);
+			GrammarRootAST root = parse(g.fileName, in);
+			if (root == null) {
+				return null;
+			}
+
+			imported = createGrammar(root);
+			imported.fileName = absolutePath;
+			importedGrammars.put(root.getGrammarName(), imported);
 		}
 
-		if ( importedFile==null ) {
-			errMgr.toolError(ErrorType.CANNOT_FIND_IMPORTED_GRAMMAR, name, g.fileName);
-			return null;
-		}
-
-		ANTLRFileStream in = new ANTLRFileStream(importedFile.getAbsolutePath());
-		GrammarRootAST root = load(g.fileName, in);
-		Grammar imported = createGrammar(root);
-		imported.fileName = importedFile.getAbsolutePath();
 		return imported;
 	}
 
-	public GrammarRootAST loadFromString(String grammar) {
-		return load("<string>", new ANTLRStringStream(grammar));
+	public GrammarRootAST parseGrammarFromString(String grammar) {
+		return parse("<string>", new ANTLRStringStream(grammar));
 	}
 
-	public GrammarRootAST load(String fileName, CharStream in) {
+	public GrammarRootAST parse(String fileName, CharStream in) {
 		try {
 			GrammarASTAdaptor adaptor = new GrammarASTAdaptor(in);
 			ToolANTLRLexer lexer = new ToolANTLRLexer(in, this);
@@ -618,7 +663,7 @@ public class Tool {
 				ParserRuleReturnScope r = p.grammarSpec();
 				GrammarAST root = (GrammarAST)r.getTree();
 				if ( root instanceof GrammarRootAST) {
-					((GrammarRootAST)root).hasErrors = p.getNumberOfSyntaxErrors()>0;
+					((GrammarRootAST)root).hasErrors = lexer.getNumberOfSyntaxErrors()>0 || p.getNumberOfSyntaxErrors()>0;
 					assert ((GrammarRootAST)root).tokenStream == tokens;
 					if ( grammarOptions!=null ) {
 						((GrammarRootAST)root).cmdLineOptions = grammarOptions;
@@ -796,7 +841,7 @@ public class Tool {
 		}
 	}
 
-    public void log(@Nullable String component, String msg) { logMgr.log(component, msg); }
+    public void log(String component, String msg) { logMgr.log(component, msg); }
     public void log(String msg) { log(null, msg); }
 
 	public int getNumErrors() { return errMgr.getNumErrors(); }
diff --git a/tool/src/org/antlr/v4/analysis/AnalysisPipeline.java b/tool/src/org/antlr/v4/analysis/AnalysisPipeline.java
index 5bd84be2e..a04ec319f 100644
--- a/tool/src/org/antlr/v4/analysis/AnalysisPipeline.java
+++ b/tool/src/org/antlr/v4/analysis/AnalysisPipeline.java
@@ -100,7 +100,7 @@ public class AnalysisPipeline {
 		}
 	}
 
-	/** Return whether lookahead sets are disjoint; no lookahead => not disjoint */
+	/** Return whether lookahead sets are disjoint; no lookahead ⇒ not disjoint */
 	public static boolean disjoint(IntervalSet[] altLook) {
 		boolean collision = false;
 		IntervalSet combined = new IntervalSet();
diff --git a/tool/src/org/antlr/v4/analysis/LeftRecursiveRuleAltInfo.java b/tool/src/org/antlr/v4/analysis/LeftRecursiveRuleAltInfo.java
index ff8a33dcd..a5ef7b453 100644
--- a/tool/src/org/antlr/v4/analysis/LeftRecursiveRuleAltInfo.java
+++ b/tool/src/org/antlr/v4/analysis/LeftRecursiveRuleAltInfo.java
@@ -36,24 +36,27 @@ public class LeftRecursiveRuleAltInfo {
 	public int altNum; // original alt index (from 1)
 	public String leftRecursiveRuleRefLabel;
 	public String altLabel;
+	public final boolean isListLabel;
 	public String altText;
 	public AltAST altAST; // transformed ALT
 	public AltAST originalAltAST;
 	public int nextPrec;
 
 	public LeftRecursiveRuleAltInfo(int altNum, String altText) {
-		this(altNum, altText, null, null, null);
+		this(altNum, altText, null, null, false, null);
 	}
 
 	public LeftRecursiveRuleAltInfo(int altNum, String altText,
 									String leftRecursiveRuleRefLabel,
 									String altLabel,
+									boolean isListLabel,
 									AltAST originalAltAST)
 	{
 		this.altNum = altNum;
 		this.altText = altText;
 		this.leftRecursiveRuleRefLabel = leftRecursiveRuleRefLabel;
 		this.altLabel = altLabel;
+		this.isListLabel = isListLabel;
 		this.originalAltAST = originalAltAST;
 	}
 }
diff --git a/tool/src/org/antlr/v4/analysis/LeftRecursiveRuleAnalyzer.java b/tool/src/org/antlr/v4/analysis/LeftRecursiveRuleAnalyzer.java
index e51791c38..7a1d233ed 100644
--- a/tool/src/org/antlr/v4/analysis/LeftRecursiveRuleAnalyzer.java
+++ b/tool/src/org/antlr/v4/analysis/LeftRecursiveRuleAnalyzer.java
@@ -31,6 +31,7 @@
 package org.antlr.v4.analysis;
 
 import org.antlr.runtime.CommonToken;
+import org.antlr.runtime.Token;
 import org.antlr.runtime.TokenStream;
 import org.antlr.runtime.tree.CommonTreeNodeStream;
 import org.antlr.runtime.tree.Tree;
@@ -44,6 +45,8 @@ import org.antlr.v4.runtime.misc.Pair;
 import org.antlr.v4.tool.ErrorType;
 import org.antlr.v4.tool.ast.AltAST;
 import org.antlr.v4.tool.ast.GrammarAST;
+import org.antlr.v4.tool.ast.GrammarASTWithOptions;
+import org.antlr.v4.tool.ast.RuleRefAST;
 import org.stringtemplate.v4.ST;
 import org.stringtemplate.v4.STGroup;
 import org.stringtemplate.v4.STGroupFile;
@@ -65,8 +68,7 @@ public class LeftRecursiveRuleAnalyzer extends LeftRecursiveRuleWalker {
 	public LinkedHashMap<Integer, LeftRecursiveRuleAltInfo> binaryAlts = new LinkedHashMap<Integer, LeftRecursiveRuleAltInfo>();
 	public LinkedHashMap<Integer, LeftRecursiveRuleAltInfo> ternaryAlts = new LinkedHashMap<Integer, LeftRecursiveRuleAltInfo>();
 	public LinkedHashMap<Integer, LeftRecursiveRuleAltInfo> suffixAlts = new LinkedHashMap<Integer, LeftRecursiveRuleAltInfo>();
-	public List<LeftRecursiveRuleAltInfo> prefixAlts = new ArrayList<LeftRecursiveRuleAltInfo>();
-	public List<LeftRecursiveRuleAltInfo> otherAlts = new ArrayList<LeftRecursiveRuleAltInfo>();
+	public List<LeftRecursiveRuleAltInfo> prefixAndOtherAlts = new ArrayList<LeftRecursiveRuleAltInfo>();
 
 	/** Pointer to ID node of ^(= ID element) */
 	public List<Pair<GrammarAST,String>> leftRecursiveRuleRefLabels =
@@ -128,13 +130,13 @@ public class LeftRecursiveRuleAnalyzer extends LeftRecursiveRuleWalker {
 					assoc = ASSOC.left;
 				}
 				else {
-					tool.errMgr.toolError(ErrorType.ILLEGAL_OPTION_VALUE, "assoc", assoc);
+					tool.errMgr.grammarError(ErrorType.ILLEGAL_OPTION_VALUE, t.g.fileName, t.getOptionAST("assoc").getToken(), "assoc", assoc);
 				}
 			}
 		}
 
 		if ( altAssociativity.get(alt)!=null && altAssociativity.get(alt)!=assoc ) {
-			tool.errMgr.toolError(ErrorType.ALL_OPS_NEED_SAME_ASSOC, alt);
+			tool.errMgr.toolError(ErrorType.INTERNAL_ERROR, "all operators of alt " + alt + " of left-recursive rule must have same associativity");
 		}
 		altAssociativity.put(alt, assoc);
 
@@ -146,12 +148,15 @@ public class LeftRecursiveRuleAnalyzer extends LeftRecursiveRuleWalker {
 		AltAST altTree = (AltAST)originalAltTree.dupTree();
 		String altLabel = altTree.altLabel!=null ? altTree.altLabel.getText() : null;
 
+		String label = null;
+		boolean isListLabel = false;
 		GrammarAST lrlabel = stripLeftRecursion(altTree);
-		String label = lrlabel != null ? lrlabel.getText() : null;
 		if ( lrlabel!=null ) {
+			label = lrlabel.getText();
+			isListLabel = lrlabel.getParent().getType() == PLUS_ASSIGN;
 			leftRecursiveRuleRefLabels.add(new Pair<GrammarAST,String>(lrlabel,altLabel));
 		}
-		stripAssocOptions(altTree);
+
 		stripAltLabel(altTree);
 
 		// rewrite e to be e_[rec_arg]
@@ -162,7 +167,7 @@ public class LeftRecursiveRuleAnalyzer extends LeftRecursiveRuleWalker {
 		String altText = text(altTree);
 		altText = altText.trim();
 		LeftRecursiveRuleAltInfo a =
-			new LeftRecursiveRuleAltInfo(alt, altText, label, altLabel, originalAltTree);
+			new LeftRecursiveRuleAltInfo(alt, altText, label, altLabel, isListLabel, originalAltTree);
 		a.nextPrec = nextPrec;
 		binaryAlts.put(alt, a);
 		//System.out.println("binaryAlt " + alt + ": " + altText + ", rewrite=" + rewriteText);
@@ -180,9 +185,9 @@ public class LeftRecursiveRuleAnalyzer extends LeftRecursiveRuleWalker {
 		altText = altText.trim();
 		String altLabel = altTree.altLabel!=null ? altTree.altLabel.getText() : null;
 		LeftRecursiveRuleAltInfo a =
-			new LeftRecursiveRuleAltInfo(alt, altText, null, altLabel, originalAltTree);
+			new LeftRecursiveRuleAltInfo(alt, altText, null, altLabel, false, originalAltTree);
 		a.nextPrec = nextPrec;
-		prefixAlts.add(a);
+		prefixAndOtherAlts.add(a);
 		//System.out.println("prefixAlt " + alt + ": " + altText + ", rewrite=" + rewriteText);
 	}
 
@@ -191,16 +196,19 @@ public class LeftRecursiveRuleAnalyzer extends LeftRecursiveRuleWalker {
 		AltAST altTree = (AltAST)originalAltTree.dupTree();
 		String altLabel = altTree.altLabel!=null ? altTree.altLabel.getText() : null;
 
+		String label = null;
+		boolean isListLabel = false;
 		GrammarAST lrlabel = stripLeftRecursion(altTree);
-		String label = lrlabel != null ? lrlabel.getText() : null;
 		if ( lrlabel!=null ) {
+			label = lrlabel.getText();
+			isListLabel = lrlabel.getParent().getType() == PLUS_ASSIGN;
 			leftRecursiveRuleRefLabels.add(new Pair<GrammarAST,String>(lrlabel,altLabel));
 		}
 		stripAltLabel(altTree);
 		String altText = text(altTree);
 		altText = altText.trim();
 		LeftRecursiveRuleAltInfo a =
-			new LeftRecursiveRuleAltInfo(alt, altText, label, altLabel, originalAltTree);
+			new LeftRecursiveRuleAltInfo(alt, altText, label, altLabel, isListLabel, originalAltTree);
 		suffixAlts.put(alt, a);
 //		System.out.println("suffixAlt " + alt + ": " + altText + ", rewrite=" + rewriteText);
 	}
@@ -212,8 +220,10 @@ public class LeftRecursiveRuleAnalyzer extends LeftRecursiveRuleWalker {
 		String altText = text(altTree);
 		String altLabel = altTree.altLabel!=null ? altTree.altLabel.getText() : null;
 		LeftRecursiveRuleAltInfo a =
-			new LeftRecursiveRuleAltInfo(alt, altText, null, altLabel, originalAltTree);
-		otherAlts.add(a);
+			new LeftRecursiveRuleAltInfo(alt, altText, null, altLabel, false, originalAltTree);
+		// We keep other alts with prefix alts since they are all added to the start of the generated rule, and
+		// we want to retain any prior ordering between them
+		prefixAndOtherAlts.add(a);
 //		System.out.println("otherAlt " + alt + ": " + altText);
 	}
 
@@ -245,8 +255,7 @@ public class LeftRecursiveRuleAnalyzer extends LeftRecursiveRuleWalker {
 			ruleST.add("opAlts", altST);
 		}
 
-		ruleST.add("primaryAlts", prefixAlts);
-		ruleST.add("primaryAlts", otherAlts);
+		ruleST.add("primaryAlts", prefixAndOtherAlts);
 
 		tool.log("left-recursion", ruleST.render());
 
@@ -257,37 +266,18 @@ public class LeftRecursiveRuleAnalyzer extends LeftRecursiveRuleWalker {
 		if ( t==null ) return null;
 		// get all top-level rule refs from ALT
 		List<GrammarAST> outerAltRuleRefs = t.getNodesWithTypePreorderDFS(IntervalSet.of(RULE_REF));
-		for (GrammarAST rref : outerAltRuleRefs) {
+		for (GrammarAST x : outerAltRuleRefs) {
+			RuleRefAST rref = (RuleRefAST)x;
 			boolean recursive = rref.getText().equals(ruleName);
 			boolean rightmost = rref == outerAltRuleRefs.get(outerAltRuleRefs.size()-1);
 			if ( recursive && rightmost ) {
-				rref.setText(ruleName+"<"+LeftRecursiveRuleTransformer.PRECEDENCE_OPTION_NAME+"="+prec+">");
+				GrammarAST dummyValueNode = new GrammarAST(new CommonToken(ANTLRParser.INT, ""+prec));
+				rref.setOption(LeftRecursiveRuleTransformer.PRECEDENCE_OPTION_NAME, dummyValueNode);
 			}
 		}
 		return t;
 	}
 
-	public void stripAssocOptions(GrammarAST t) {
-		if ( t==null ) return;
-		for (GrammarAST options : t.getNodesWithType(ELEMENT_OPTIONS)) {
-			int i=0;
-			while ( i<options.getChildCount() ) {
-				GrammarAST c = (GrammarAST)options.getChild(i);
-				if ( c.getChild(0).getText().equals("assoc") ) {
-					options.deleteChild(i); // kill this option
-				}
-				else {
-					i++;
-				}
-			}
-			if ( options.getChildCount()==0 )	{
-				Tree parent = options.getParent();
-				parent.deleteChild(options.getChildIndex()); // no more options
-				return;
-			}
-		}
-	}
-
 	/**
 	 * Match (RULE RULE_REF (BLOCK (ALT .*) (ALT RULE_REF[self] .*) (ALT .*)))
 	 * Match (RULE RULE_REF (BLOCK (ALT .*) (ALT (ASSIGN ID RULE_REF[self]) .*) (ALT .*)))
@@ -301,6 +291,12 @@ public class LeftRecursiveRuleAnalyzer extends LeftRecursiveRuleWalker {
 			GrammarAST alt = (GrammarAST)blk.getChildren().get(i);
 			Tree first = alt.getChild(0);
 			if ( first==null ) continue;
+			if (first.getType() == ELEMENT_OPTIONS) {
+				first = alt.getChild(1);
+				if (first == null) {
+					continue;
+				}
+			}
 			if ( first.getType()==RULE_REF && first.getText().equals(ruleName) ) return true;
 			Tree rref = first.getChild(1);
 			if ( rref!=null && rref.getType()==RULE_REF && rref.getText().equals(ruleName) ) return true;
@@ -323,7 +319,7 @@ public class LeftRecursiveRuleAnalyzer extends LeftRecursiveRuleWalker {
 		if ( (first.getType()==RULE_REF && first.getText().equals(ruleName)) ||
 			 (rref!=null && rref.getType()==RULE_REF && rref.getText().equals(ruleName)) )
 		{
-			if ( first.getType()==ASSIGN ) lrlabel = (GrammarAST)first.getChild(0);
+			if ( first.getType()==ASSIGN || first.getType()==PLUS_ASSIGN ) lrlabel = (GrammarAST)first.getChild(0);
 			// remove rule ref (first child unless options present)
 			altAST.deleteChild(leftRecurRuleIndex);
 			// reset index so it prints properly (sets token range of
@@ -334,7 +330,7 @@ public class LeftRecursiveRuleAnalyzer extends LeftRecursiveRuleWalker {
 		return lrlabel;
 	}
 
-	/** Strip last 2 tokens if -> label; alter indexes in altAST */
+	/** Strip last 2 tokens if → label; alter indexes in altAST */
 	public void stripAltLabel(GrammarAST altAST) {
 		int start = altAST.getTokenStartIndex();
 		int stop = altAST.getTokenStopIndex();
@@ -349,9 +345,81 @@ public class LeftRecursiveRuleAnalyzer extends LeftRecursiveRuleWalker {
 
 	public String text(GrammarAST t) {
 		if ( t==null ) return "";
-		CommonToken ta = (CommonToken) tokenStream.get(t.getTokenStartIndex());
-		CommonToken tb = (CommonToken) tokenStream.get(t.getTokenStopIndex());
-		return tokenStream.toString(ta, tb);
+
+		int tokenStartIndex = t.getTokenStartIndex();
+		int tokenStopIndex = t.getTokenStopIndex();
+
+		// ignore tokens from existing option subtrees like:
+		//    (ELEMENT_OPTIONS (= assoc right))
+		//
+		// element options are added back according to the values in the map
+		// returned by getOptions().
+		IntervalSet ignore = new IntervalSet();
+		List<GrammarAST> optionsSubTrees = t.getNodesWithType(ELEMENT_OPTIONS);
+		for (GrammarAST sub : optionsSubTrees) {
+			ignore.add(sub.getTokenStartIndex(), sub.getTokenStopIndex());
+		}
+
+		// Individual labels appear as RULE_REF or TOKEN_REF tokens in the tree,
+		// but do not support the ELEMENT_OPTIONS syntax. Make sure to not try
+		// and add the tokenIndex option when writing these tokens.
+		IntervalSet noOptions = new IntervalSet();
+		List<GrammarAST> labeledSubTrees = t.getNodesWithType(new IntervalSet(ASSIGN,PLUS_ASSIGN));
+		for (GrammarAST sub : labeledSubTrees) {
+			noOptions.add(sub.getChild(0).getTokenStartIndex());
+		}
+
+		StringBuilder buf = new StringBuilder();
+		int i=tokenStartIndex;
+		while ( i<=tokenStopIndex ) {
+			if ( ignore.contains(i) ) {
+				i++;
+				continue;
+			}
+
+			Token tok = tokenStream.get(i);
+
+			// Compute/hold any element options
+			StringBuilder elementOptions = new StringBuilder();
+			if (!noOptions.contains(i)) {
+				GrammarAST node = t.getNodeWithTokenIndex(tok.getTokenIndex());
+				if ( node!=null &&
+					 (tok.getType()==TOKEN_REF ||
+					  tok.getType()==STRING_LITERAL ||
+					  tok.getType()==RULE_REF) )
+				{
+					elementOptions.append("tokenIndex=").append(tok.getTokenIndex());
+				}
+
+				if ( node instanceof GrammarASTWithOptions ) {
+					GrammarASTWithOptions o = (GrammarASTWithOptions)node;
+					for (Map.Entry<String, GrammarAST> entry : o.getOptions().entrySet()) {
+						if (elementOptions.length() > 0) {
+							elementOptions.append(',');
+						}
+
+						elementOptions.append(entry.getKey());
+						elementOptions.append('=');
+						elementOptions.append(entry.getValue().getText());
+					}
+				}
+			}
+
+			buf.append(tok.getText()); // add actual text of the current token to the rewritten alternative
+			i++;                       // move to the next token
+
+			// Are there args on a rule?
+			if ( tok.getType()==RULE_REF && i<=tokenStopIndex && tokenStream.get(i).getType()==ARG_ACTION ) {
+				buf.append('['+tokenStream.get(i).getText()+']');
+				i++;
+			}
+
+			// now that we have the actual element, we can add the options.
+			if (elementOptions.length() > 0) {
+				buf.append('<').append(elementOptions).append('>');
+			}
+		}
+		return buf.toString();
 	}
 
 	public int precedence(int alt) {
@@ -371,8 +439,7 @@ public class LeftRecursiveRuleAnalyzer extends LeftRecursiveRuleWalker {
 			   "binaryAlts=" + binaryAlts +
 			   ", ternaryAlts=" + ternaryAlts +
 			   ", suffixAlts=" + suffixAlts +
-			   ", prefixAlts=" + prefixAlts +
-			   ", otherAlts=" + otherAlts +
+			   ", prefixAndOtherAlts=" +prefixAndOtherAlts+
 			   '}';
 	}
 }
diff --git a/tool/src/org/antlr/v4/analysis/LeftRecursiveRuleTransformer.java b/tool/src/org/antlr/v4/analysis/LeftRecursiveRuleTransformer.java
index db5039103..45cb5170a 100644
--- a/tool/src/org/antlr/v4/analysis/LeftRecursiveRuleTransformer.java
+++ b/tool/src/org/antlr/v4/analysis/LeftRecursiveRuleTransformer.java
@@ -31,10 +31,10 @@
 package org.antlr.v4.analysis;
 
 import org.antlr.runtime.ANTLRStringStream;
-import org.antlr.runtime.CommonToken;
 import org.antlr.runtime.CommonTokenStream;
 import org.antlr.runtime.ParserRuleReturnScope;
 import org.antlr.runtime.RecognitionException;
+import org.antlr.runtime.Token;
 import org.antlr.v4.Tool;
 import org.antlr.v4.misc.OrderedHashMap;
 import org.antlr.v4.parse.ANTLRLexer;
@@ -71,6 +71,7 @@ import java.util.List;
  */
 public class LeftRecursiveRuleTransformer {
 	public static final String PRECEDENCE_OPTION_NAME = "p";
+	public static final String TOKENINDEX_OPTION_NAME = "tokenIndex";
 
 	public GrammarRootAST ast;
 	public Collection<Rule> rules;
@@ -92,7 +93,12 @@ public class LeftRecursiveRuleTransformer {
 			if ( !Grammar.isTokenName(r.name) ) {
 				if ( LeftRecursiveRuleAnalyzer.hasImmediateRecursiveRuleRefs(r.ast, r.name) ) {
 					boolean fitsPattern = translateLeftRecursiveRule(ast, (LeftRecursiveRule)r, language);
-					if ( fitsPattern ) leftRecursiveRuleNames.add(r.name);
+					if ( fitsPattern ) {
+						leftRecursiveRuleNames.add(r.name);
+					}
+					else { // better given an error that non-conforming left-recursion exists
+						tool.errMgr.grammarError(ErrorType.NONCONFORMING_LR_RULE, g.fileName, ((GrammarAST)r.ast.getChild(0)).token, r.name);
+					}
 				}
 			}
 		}
@@ -114,7 +120,6 @@ public class LeftRecursiveRuleTransformer {
 											  String language)
 	{
 		//tool.log("grammar", ruleAST.toStringTree());
-		Grammar g = r.ast.g;
 		GrammarAST prevRuleAST = r.ast;
 		String ruleName = prevRuleAST.getChild(0).getText();
 		LeftRecursiveRuleAnalyzer leftRecursiveRuleWalker =
@@ -130,11 +135,15 @@ public class LeftRecursiveRuleTransformer {
 		}
 		if ( !isLeftRec ) return false;
 
-		// replace old rule's AST
+		// replace old rule's AST; first create text of altered rule
 		GrammarAST RULES = (GrammarAST)ast.getFirstChildWithType(ANTLRParser.RULES);
 		String newRuleText = leftRecursiveRuleWalker.getArtificialOpPrecRule();
 //		System.out.println("created: "+newRuleText);
-		RuleAST t = parseArtificialRule(g, newRuleText);
+		// now parse within the context of the grammar that originally created
+		// the AST we are transforming. This could be an imported grammar so
+		// we cannot just reference this.g because the role might come from
+		// the imported grammar and not the root grammar (this.g)
+		RuleAST t = parseArtificialRule(prevRuleAST.g, newRuleText);
 
 		// reuse the name token from the original AST since it refers to the proper source location in the original grammar
 		((GrammarAST)t.getChild(0)).token = ((GrammarAST)prevRuleAST.getChild(0)).getToken();
@@ -152,12 +161,14 @@ public class LeftRecursiveRuleTransformer {
 		RuleCollector ruleCollector = new RuleCollector(g);
 		ruleCollector.visit(t, "rule");
 		BasicSemanticChecks basics = new BasicSemanticChecks(g, ruleCollector);
+		// disable the assoc element option checks because they are already
+		// handled for the pre-transformed rule.
+		basics.checkAssocElementOption = false;
 		basics.visit(t, "rule");
 
 		// track recursive alt info for codegen
 		r.recPrimaryAlts = new ArrayList<LeftRecursiveRuleAltInfo>();
-		r.recPrimaryAlts.addAll(leftRecursiveRuleWalker.prefixAlts);
-		r.recPrimaryAlts.addAll(leftRecursiveRuleWalker.otherAlts);
+		r.recPrimaryAlts.addAll(leftRecursiveRuleWalker.prefixAndOtherAlts);
 		if (r.recPrimaryAlts.isEmpty()) {
 			tool.errMgr.grammarError(ErrorType.NO_NON_LR_ALTS, g.fileName, ((GrammarAST)r.ast.getChild(0)).getToken(), r.name);
 		}
@@ -174,7 +185,7 @@ public class LeftRecursiveRuleTransformer {
 		// update Rule to just one alt and add prec alt
 		ActionAST arg = (ActionAST)r.ast.getFirstChildWithType(ANTLRParser.ARG_ACTION);
 		if ( arg!=null ) {
-			r.args = ScopeParser.parseTypedArgList(arg, arg.getText(), g.tool.errMgr);
+			r.args = ScopeParser.parseTypedArgList(arg, arg.getText(), g);
 			r.args.type = AttributeDict.DictType.ARG;
 			r.args.ast = arg;
 			arg.resolver = r.alt[1]; // todo: isn't this Rule or something?
@@ -203,16 +214,20 @@ public class LeftRecursiveRuleTransformer {
 		lexer.tokens = tokens;
 		ToolANTLRParser p = new ToolANTLRParser(tokens, tool);
 		p.setTreeAdaptor(adaptor);
+		Token ruleStart = null;
 		try {
 			ParserRuleReturnScope r = p.rule();
 			RuleAST tree = (RuleAST)r.getTree();
+			ruleStart = (Token)r.getStart();
 			GrammarTransformPipeline.setGrammarPtr(g, tree);
+			GrammarTransformPipeline.augmentTokensWithOriginalPosition(g, tree);
 			return tree;
 		}
 		catch (Exception e) {
 			tool.errMgr.toolError(ErrorType.INTERNAL_ERROR,
-								  "error parsing rule created during left-recursion detection: "+ruleText,
-								  e);
+								  e,
+								  ruleStart,
+								  "error parsing rule created during left-recursion detection: "+ruleText);
 		}
 		return null;
 	}
@@ -228,9 +243,9 @@ public class LeftRecursiveRuleTransformer {
 	 * 			(ALT ID))
 	 * 		(* (BLOCK
 	 *			(OPTIONS ...)
-	 * 			(ALT {7 >= $_p}? '*' (= b e) {$v = $a.v * $b.v;})
-	 * 			(ALT {6 >= $_p}? '+' (= b e) {$v = $a.v + $b.v;})
-	 * 			(ALT {3 >= $_p}? '++') (ALT {2 >= $_p}? '--'))))))
+	 * 			(ALT {7 &gt;= $_p}? '*' (= b e) {$v = $a.v * $b.v;})
+	 * 			(ALT {6 &gt;= $_p}? '+' (= b e) {$v = $a.v + $b.v;})
+	 * 			(ALT {3 &gt;= $_p}? '++') (ALT {2 &gt;= $_p}? '--'))))))
 	 * </pre>
 	 */
 	public void setAltASTPointers(LeftRecursiveRule r, RuleAST t) {
diff --git a/tool/src/org/antlr/v4/automata/ATNFactory.java b/tool/src/org/antlr/v4/automata/ATNFactory.java
index 5fc6d8919..b1f61a8cf 100644
--- a/tool/src/org/antlr/v4/automata/ATNFactory.java
+++ b/tool/src/org/antlr/v4/automata/ATNFactory.java
@@ -59,81 +59,97 @@ public interface ATNFactory {
 		}
 	}
 
+
 	ATN createATN();
 
 	void setCurrentRuleName(String name);
 
 	void setCurrentOuterAlt(int alt);
 
+
 	Handle rule(GrammarAST ruleAST, String name, Handle blk);
 
+
 	ATNState newState();
 
+
 	Handle label(Handle t);
 
+
 	Handle listLabel(Handle t);
 
+
 	Handle tokenRef(TerminalAST node);
 
+
 	Handle set(GrammarAST associatedAST, List<GrammarAST> alts, boolean invert);
 
+
 	Handle charSetLiteral(GrammarAST charSetAST);
 
+
 	Handle range(GrammarAST a, GrammarAST b);
 
 	/** For a non-lexer, just build a simple token reference atom.
 	 *  For a lexer, a string is a sequence of char to match.  That is,
 	 *  "fog" is treated as 'f' 'o' 'g' not as a single transition in
-	 *  the DFA.  Machine== o-'f'->o-'o'->o-'g'->o and has n+1 states
+	 *  the DFA.  Machine== o-'f'-&gt;o-'o'-&gt;o-'g'-&gt;o and has n+1 states
 	 *  for n characters.
 	 */
+
 	Handle stringLiteral(TerminalAST stringLiteralAST);
 
 	/** For reference to rule r, build
 	 *
-	 *  o-e->(r)  o
+	 *  o-e-&gt;(r)  o
 	 *
 	 *  where (r) is the start of rule r and the trailing o is not linked
 	 *  to from rule ref state directly (it's done thru the transition(0)
 	 *  RuleClosureTransition.
 	 *
 	 *  If the rule r is just a list of tokens, it's block will be just
-	 *  a set on an edge o->o->o-set->o->o->o, could inline it rather than doing
+	 *  a set on an edge o-&gt;o-&gt;o-set-&gt;o-&gt;o-&gt;o, could inline it rather than doing
 	 *  the rule reference, but i'm not doing this yet as I'm not sure
-	 *  it would help much in the ATN->DFA construction.
+	 *  it would help much in the ATN-&gt;DFA construction.
 	 *
 	 *  TODO add to codegen: collapse alt blks that are sets into single matchSet
 	 * @param node
 	 */
+
 	Handle ruleRef(GrammarAST node);
 
-	/** From an empty alternative build Grip o-e->o */
+	/** From an empty alternative build Grip o-e-&gt;o */
+
 	Handle epsilon(GrammarAST node);
 
 	/** Build what amounts to an epsilon transition with a semantic
 	 *  predicate action.  The pred is a pointer into the AST of
 	 *  the SEMPRED token.
 	 */
+
 	Handle sempred(PredAST pred);
 
 	/** Build what amounts to an epsilon transition with an action.
 	 *  The action goes into ATN though it is ignored during analysis.
 	 */
+
 	Handle action(ActionAST action);
 
+
 	Handle action(String action);
 
+
 	Handle alt(List<Handle> els);
 
 	/** From A|B|..|Z alternative block build
      *
-     *  o->o-A->o->o (last ATNState is blockEndATNState pointed to by all alts)
+     *  o-&gt;o-A-&gt;o-&gt;o (last ATNState is blockEndATNState pointed to by all alts)
      *  |          ^
-     *  o->o-B->o--|
+     *  o-&gt;o-B-&gt;o--|
      *  |          |
      *  ...        |
      *  |          |
-     *  o->o-Z->o--|
+     *  o-&gt;o-Z-&gt;o--|
      *
      *  So every alternative gets begin ATNState connected by epsilon
      *  and every alt right side points at a block end ATNState.  There is a
@@ -144,29 +160,31 @@ public interface ATNFactory {
      *  begin/end.
      *
      *  Special case: if just a list of tokens/chars/sets, then collapse
-     *  to a single edge'd o-set->o graph.
+     *  to a single edge'd o-set-&gt;o graph.
      *
      *  Set alt number (1..n) in the left-Transition ATNState.
      */
+
 	Handle block(BlockAST blockAST, GrammarAST ebnfRoot, List<Handle> alternativeGrips);
 
 //	Handle notBlock(GrammarAST blockAST, Handle set);
 
 	/** From (A)? build either:
 	 *
-	 *  o--A->o
+	 *  o--A-&gt;o
 	 *  |     ^
-	 *  o---->|
+	 *  o----&gt;|
 	 *
 	 *  or, if A is a block, just add an empty alt to the end of the block
 	 */
+
 	Handle optional(GrammarAST optAST, Handle blk);
 
 	/** From (A)+ build
 	 *
 	 *     |---|    (Transition 2 from A.right points at alt 1)
 	 *     v   |    (follow of loop is Transition 1)
-	 *  o->o-A-o->o
+	 *  o-&gt;o-A-o-&gt;o
 	 *
 	 *  Meaning that the last ATNState in A points back to A's left Transition ATNState
 	 *  and we add a new begin/end ATNState.  A can be single alternative or
@@ -175,13 +193,14 @@ public interface ATNFactory {
 	 *  During analysis we'll call the follow link (transition 1) alt n+1 for
 	 *  an n-alt A block.
 	 */
+
 	Handle plus(GrammarAST plusAST, Handle blk);
 
 	/** From (A)* build
 	 *
 	 *     |---|
 	 *     v   |
-	 *  o->o-A-o--o (Transition 2 from block end points at alt 1; follow is Transition 1)
+	 *  o-&gt;o-A-o--o (Transition 2 from block end points at alt 1; follow is Transition 1)
 	 *  |         ^
 	 *  o---------| (optional branch is 2nd alt of optional block containing A+)
 	 *
@@ -207,14 +226,19 @@ public interface ATNFactory {
 	 *  is sufficient to let me make an appropriate enter, exit, loop
 	 *  determination.  See codegen.g
 	 */
+
 	Handle star(GrammarAST starAST, Handle blk);
 
 	/** Build an atom with all possible values in its label */
+
 	Handle wildcard(GrammarAST associatedAST);
 
-	Handle lexerAltCommands(ATNFactory.Handle alt, ATNFactory.Handle cmds);
 
-	String lexerCallCommand(GrammarAST ID, GrammarAST arg);
+	Handle lexerAltCommands(Handle alt, Handle cmds);
 
-	String lexerCommand(GrammarAST ID);
+
+	Handle lexerCallCommand(GrammarAST ID, GrammarAST arg);
+
+
+	Handle lexerCommand(GrammarAST ID);
 }
diff --git a/tool/src/org/antlr/v4/automata/ATNOptimizer.java b/tool/src/org/antlr/v4/automata/ATNOptimizer.java
index 59a3d78e5..4f72b640c 100644
--- a/tool/src/org/antlr/v4/automata/ATNOptimizer.java
+++ b/tool/src/org/antlr/v4/automata/ATNOptimizer.java
@@ -42,7 +42,6 @@ import org.antlr.v4.runtime.atn.SetTransition;
 import org.antlr.v4.runtime.atn.Transition;
 import org.antlr.v4.runtime.misc.Interval;
 import org.antlr.v4.runtime.misc.IntervalSet;
-import org.antlr.v4.runtime.misc.NotNull;
 import org.antlr.v4.tool.Grammar;
 import org.antlr.v4.tool.Rule;
 
@@ -55,7 +54,7 @@ import java.util.List;
  */
 public class ATNOptimizer {
 
-	public static void optimize(@NotNull Grammar g, @NotNull ATN atn) {
+	public static void optimize(Grammar g, ATN atn) {
 		optimizeSets(g, atn);
 		optimizeStates(atn);
 	}
diff --git a/tool/src/org/antlr/v4/automata/ATNPrinter.java b/tool/src/org/antlr/v4/automata/ATNPrinter.java
index 9ee0b0b73..9fe114560 100644
--- a/tool/src/org/antlr/v4/automata/ATNPrinter.java
+++ b/tool/src/org/antlr/v4/automata/ATNPrinter.java
@@ -106,7 +106,7 @@ public class ATNPrinter {
 						buf.append("-").append(not?"~":"").append(st.toString()).append("->").append(getStateString(t.target)).append('\n');
 					}
 					else {
-						buf.append("-").append(not?"~":"").append(st.label().toString(g.getTokenNames())).append("->").append(getStateString(t.target)).append('\n');
+						buf.append("-").append(not?"~":"").append(st.label().toString(g.getVocabulary())).append("->").append(getStateString(t.target)).append('\n');
 					}
 				}
 				else if ( t instanceof AtomTransition ) {
diff --git a/tool/src/org/antlr/v4/automata/ATNVisitor.java b/tool/src/org/antlr/v4/automata/ATNVisitor.java
index 4c812f10e..af5e18ac8 100644
--- a/tool/src/org/antlr/v4/automata/ATNVisitor.java
+++ b/tool/src/org/antlr/v4/automata/ATNVisitor.java
@@ -32,7 +32,6 @@ package org.antlr.v4.automata;
 
 import org.antlr.v4.runtime.atn.ATNState;
 import org.antlr.v4.runtime.atn.Transition;
-import org.antlr.v4.runtime.misc.NotNull;
 
 import java.util.HashSet;
 import java.util.Set;
@@ -42,11 +41,11 @@ import java.util.Set;
  *  visitState() to provide functionality.
  */
 public class ATNVisitor {
-	public void visit(@NotNull ATNState s) {
+	public void visit(ATNState s) {
 		visit_(s, new HashSet<Integer>());
 	}
 
-	public void visit_(@NotNull ATNState s, @NotNull Set<Integer> visited) {
+	public void visit_(ATNState s, Set<Integer> visited) {
 		if ( !visited.add(s.stateNumber) ) return;
 		visited.add(s.stateNumber);
 
@@ -58,5 +57,5 @@ public class ATNVisitor {
 		}
 	}
 
-	public void visitState(@NotNull ATNState s) { }
+	public void visitState(ATNState s) { }
 }
diff --git a/tool/src/org/antlr/v4/automata/LexerATNFactory.java b/tool/src/org/antlr/v4/automata/LexerATNFactory.java
index 73df6c7e6..2d91cf3f3 100644
--- a/tool/src/org/antlr/v4/automata/LexerATNFactory.java
+++ b/tool/src/org/antlr/v4/automata/LexerATNFactory.java
@@ -31,14 +31,25 @@
 package org.antlr.v4.automata;
 
 import org.antlr.runtime.CommonToken;
+import org.antlr.runtime.Token;
 import org.antlr.v4.codegen.CodeGenerator;
 import org.antlr.v4.misc.CharSupport;
 import org.antlr.v4.parse.ANTLRParser;
 import org.antlr.v4.runtime.IntStream;
+import org.antlr.v4.runtime.Lexer;
 import org.antlr.v4.runtime.atn.ATN;
 import org.antlr.v4.runtime.atn.ATNState;
 import org.antlr.v4.runtime.atn.ActionTransition;
 import org.antlr.v4.runtime.atn.AtomTransition;
+import org.antlr.v4.runtime.atn.LexerAction;
+import org.antlr.v4.runtime.atn.LexerChannelAction;
+import org.antlr.v4.runtime.atn.LexerCustomAction;
+import org.antlr.v4.runtime.atn.LexerModeAction;
+import org.antlr.v4.runtime.atn.LexerMoreAction;
+import org.antlr.v4.runtime.atn.LexerPopModeAction;
+import org.antlr.v4.runtime.atn.LexerPushModeAction;
+import org.antlr.v4.runtime.atn.LexerSkipAction;
+import org.antlr.v4.runtime.atn.LexerTypeAction;
 import org.antlr.v4.runtime.atn.NotSetTransition;
 import org.antlr.v4.runtime.atn.RangeTransition;
 import org.antlr.v4.runtime.atn.RuleStartState;
@@ -56,11 +67,43 @@ import org.antlr.v4.tool.ast.TerminalAST;
 import org.stringtemplate.v4.ST;
 import org.stringtemplate.v4.STGroup;
 
+import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 
 public class LexerATNFactory extends ParserATNFactory {
 	public STGroup codegenTemplates;
+
+	/**
+	 * Provides a map of names of predefined constants which are likely to
+	 * appear as the argument for lexer commands. These names would be resolved
+	 * by the Java compiler for lexer commands that are translated to embedded
+	 * actions, but are required during code generation for creating
+	 * {@link LexerAction} instances that are usable by a lexer interpreter.
+	 */
+	public static final Map<String, Integer> COMMON_CONSTANTS = new HashMap<String, Integer>();
+	static {
+		COMMON_CONSTANTS.put("HIDDEN", Lexer.HIDDEN);
+		COMMON_CONSTANTS.put("DEFAULT_TOKEN_CHANNEL", Lexer.DEFAULT_TOKEN_CHANNEL);
+		COMMON_CONSTANTS.put("DEFAULT_MODE", Lexer.DEFAULT_MODE);
+		COMMON_CONSTANTS.put("SKIP", Lexer.SKIP);
+		COMMON_CONSTANTS.put("MORE", Lexer.MORE);
+		COMMON_CONSTANTS.put("EOF", Lexer.EOF);
+		COMMON_CONSTANTS.put("MAX_CHAR_VALUE", Lexer.MAX_CHAR_VALUE);
+		COMMON_CONSTANTS.put("MIN_CHAR_VALUE", Lexer.MIN_CHAR_VALUE);
+	}
+
+	/**
+	 * Maps from an action index to a {@link LexerAction} object.
+	 */
+	protected Map<Integer, LexerAction> indexToActionMap = new HashMap<Integer, LexerAction>();
+	/**
+	 * Maps from a {@link LexerAction} object to the action index.
+	 */
+	protected Map<LexerAction, Integer> actionToIndexMap = new HashMap<LexerAction, Integer>();
+
 	public LexerATNFactory(LexerGrammar g) {
 		super(g);
 		// use codegen to get correct language templates for lexer commands
@@ -69,6 +112,10 @@ public class LexerATNFactory extends ParserATNFactory {
 		codegenTemplates = gen.getTemplates();
 	}
 
+	public static Set<String> getCommonConstants() {
+		return COMMON_CONSTANTS.keySet();
+	}
+
 	@Override
 	public ATN createATN() {
 		// BUILD ALL START STATES (ONE PER MODE)
@@ -84,15 +131,18 @@ public class LexerATNFactory extends ParserATNFactory {
 
 		// INIT ACTION, RULE->TOKEN_TYPE MAP
 		atn.ruleToTokenType = new int[g.rules.size()];
-		atn.ruleToActionIndex = new int[g.rules.size()];
 		for (Rule r : g.rules.values()) {
 			atn.ruleToTokenType[r.index] = g.getTokenType(r.name);
-			atn.ruleToActionIndex[r.index] = r.actionIndex;
 		}
 
 		// CREATE ATN FOR EACH RULE
 		_createATN(g.rules.values());
 
+		atn.lexerActions = new LexerAction[indexToActionMap.size()];
+		for (Map.Entry<Integer, LexerAction> entry : indexToActionMap.entrySet()) {
+			atn.lexerActions[entry.getKey()] = entry.getValue();
+		}
+
 		// LINK MODE START STATE TO EACH TOKEN RULE
 		for (String modeName : modes) {
 			List<Rule> rules = ((LexerGrammar)g).modes.get(modeName);
@@ -111,26 +161,51 @@ public class LexerATNFactory extends ParserATNFactory {
 
 	@Override
 	public Handle action(ActionAST action) {
-		ATNState left = newState(action);
-		ATNState right = newState(action);
-		boolean isCtxDependent = false;
+		int ruleIndex = currentRule.index;
 		int actionIndex = g.lexerActions.get(action);
-		ActionTransition a =
-			new ActionTransition(right, currentRule.index, actionIndex, isCtxDependent);
-		left.addTransition(a);
-		action.atnState = left;
-		Handle h = new Handle(left, right);
-		return h;
+		LexerCustomAction lexerAction = new LexerCustomAction(ruleIndex, actionIndex);
+		return action(action, lexerAction);
+	}
+
+	protected int getLexerActionIndex(LexerAction lexerAction) {
+		Integer lexerActionIndex = actionToIndexMap.get(lexerAction);
+		if (lexerActionIndex == null) {
+			lexerActionIndex = actionToIndexMap.size();
+			actionToIndexMap.put(lexerAction, lexerActionIndex);
+			indexToActionMap.put(lexerActionIndex, lexerAction);
+		}
+
+		return lexerActionIndex;
 	}
 
 	@Override
 	public Handle action(String action) {
-        // define action AST for this rule as if we had found in grammar
+		if (action.trim().isEmpty()) {
+			ATNState left = newState(null);
+			ATNState right = newState(null);
+			epsilon(left, right);
+			return new Handle(left, right);
+		}
+
+		// define action AST for this rule as if we had found in grammar
         ActionAST ast =	new ActionAST(new CommonToken(ANTLRParser.ACTION, action));
 		currentRule.defineActionInAlt(currentOuterAlt, ast);
 		return action(ast);
 	}
 
+	protected Handle action(GrammarAST node, LexerAction lexerAction) {
+		ATNState left = newState(node);
+		ATNState right = newState(node);
+		boolean isCtxDependent = false;
+		int lexerActionIndex = getLexerActionIndex(lexerAction);
+		ActionTransition a =
+			new ActionTransition(right, currentRule.index, lexerActionIndex, isCtxDependent);
+		left.addTransition(a);
+		node.atnState = left;
+		Handle h = new Handle(left, right);
+		return h;
+	}
+
 	@Override
 	public Handle lexerAltCommands(Handle alt, Handle cmds) {
 		Handle h = new Handle(alt.left, cmds.right);
@@ -139,18 +214,24 @@ public class LexerATNFactory extends ParserATNFactory {
 	}
 
 	@Override
-	public String lexerCallCommand(GrammarAST ID, GrammarAST arg) {
+	public Handle lexerCallCommand(GrammarAST ID, GrammarAST arg) {
+		LexerAction lexerAction = createLexerAction(ID, arg);
+		if (lexerAction != null) {
+			return action(ID, lexerAction);
+		}
+
+		// fall back to standard action generation for the command
 		ST cmdST = codegenTemplates.getInstanceOf("Lexer" +
 												  CharSupport.capitalize(ID.getText())+
 												  "Command");
 		if (cmdST == null) {
 			g.tool.errMgr.grammarError(ErrorType.INVALID_LEXER_COMMAND, g.fileName, ID.token, ID.getText());
-			return "";
+			return epsilon(ID);
 		}
 
 		if (cmdST.impl.formalArguments == null || !cmdST.impl.formalArguments.containsKey("arg")) {
 			g.tool.errMgr.grammarError(ErrorType.UNWANTED_LEXER_COMMAND_ARGUMENT, g.fileName, ID.token, ID.getText());
-			return "";
+			return epsilon(ID);
 		}
 
 		cmdST.add("arg", arg.getText());
@@ -159,21 +240,27 @@ public class LexerATNFactory extends ParserATNFactory {
 	}
 
 	@Override
-	public String lexerCommand(GrammarAST ID) {
+	public Handle lexerCommand(GrammarAST ID) {
+		LexerAction lexerAction = createLexerAction(ID, null);
+		if (lexerAction != null) {
+			return action(ID, lexerAction);
+		}
+
+		// fall back to standard action generation for the command
 		ST cmdST = codegenTemplates.getInstanceOf("Lexer" +
-												  CharSupport.capitalize(ID.getText())+
-												  "Command");
+				CharSupport.capitalize(ID.getText()) +
+				"Command");
 		if (cmdST == null) {
 			g.tool.errMgr.grammarError(ErrorType.INVALID_LEXER_COMMAND, g.fileName, ID.token, ID.getText());
-			return "";
+			return epsilon(ID);
 		}
 
 		if (cmdST.impl.formalArguments != null && cmdST.impl.formalArguments.containsKey("arg")) {
 			g.tool.errMgr.grammarError(ErrorType.MISSING_LEXER_COMMAND_ARGUMENT, g.fileName, ID.token, ID.getText());
-			return "";
+			return epsilon(ID);
 		}
 
-		return cmdST.render();
+		return action(cmdST.render());
 	}
 
 	@Override
@@ -238,7 +325,7 @@ public class LexerATNFactory extends ParserATNFactory {
 
 	/** For a lexer, a string is a sequence of char to match.  That is,
 	 *  "fog" is treated as 'f' 'o' 'g' not as a single transition in
-	 *  the DFA.  Machine== o-'f'->o-'o'->o-'g'->o and has n+1 states
+	 *  the DFA.  Machine== o-'f'-&gt;o-'o'-&gt;o-'g'-&gt;o and has n+1 states
 	 *  for n characters.
 	 */
 	@Override
@@ -310,4 +397,113 @@ public class LexerATNFactory extends ParserATNFactory {
 		}
 		return _ruleRef(node);
 	}
+
+
+	protected LexerAction createLexerAction(GrammarAST ID, GrammarAST arg) {
+		String command = ID.getText();
+		if ("skip".equals(command) && arg == null) {
+			return LexerSkipAction.INSTANCE;
+		}
+		else if ("more".equals(command) && arg == null) {
+			return LexerMoreAction.INSTANCE;
+		}
+		else if ("popMode".equals(command) && arg == null) {
+			return LexerPopModeAction.INSTANCE;
+		}
+		else if ("mode".equals(command) && arg != null) {
+			String modeName = arg.getText();
+			checkMode(modeName, arg.token);
+			Integer mode = getConstantValue(modeName, arg.getToken());
+			if (mode == null) {
+				return null;
+			}
+
+			return new LexerModeAction(mode);
+		}
+		else if ("pushMode".equals(command) && arg != null) {
+			String modeName = arg.getText();
+			checkMode(modeName, arg.token);
+			Integer mode = getConstantValue(modeName, arg.getToken());
+			if (mode == null) {
+				return null;
+			}
+
+			return new LexerPushModeAction(mode);
+		}
+		else if ("type".equals(command) && arg != null) {
+			String typeName = arg.getText();
+			checkToken(typeName, arg.token);
+			Integer type = getConstantValue(typeName, arg.getToken());
+			if (type == null) {
+				return null;
+			}
+
+			return new LexerTypeAction(type);
+		}
+		else if ("channel".equals(command) && arg != null) {
+			String channelName = arg.getText();
+			checkChannel(channelName, arg.token);
+			Integer channel = getConstantValue(channelName, arg.getToken());
+			if (channel == null) {
+				return null;
+			}
+
+			return new LexerChannelAction(channel);
+		}
+		else {
+			return null;
+		}
+	}
+
+	protected void checkMode(String modeName, Token token) {
+		if (!modeName.equals("DEFAULT_MODE") && COMMON_CONSTANTS.containsKey(modeName)) {
+			g.tool.errMgr.grammarError(ErrorType.MODE_CONFLICTS_WITH_COMMON_CONSTANTS, g.fileName, token, token.getText());
+		}
+	}
+
+	protected void checkToken(String tokenName, Token token) {
+		if (!tokenName.equals("EOF") && COMMON_CONSTANTS.containsKey(tokenName)) {
+			g.tool.errMgr.grammarError(ErrorType.TOKEN_CONFLICTS_WITH_COMMON_CONSTANTS, g.fileName, token, token.getText());
+		}
+	}
+
+	protected void checkChannel(String channelName, Token token) {
+		if (!channelName.equals("HIDDEN") && !channelName.equals("DEFAULT_TOKEN_CHANNEL") && COMMON_CONSTANTS.containsKey(channelName)) {
+			g.tool.errMgr.grammarError(ErrorType.CHANNEL_CONFLICTS_WITH_COMMON_CONSTANTS, g.fileName, token, token.getText());
+		}
+	}
+
+	protected Integer getConstantValue(String name, Token token) {
+		if (name == null) {
+			return null;
+		}
+
+		Integer commonConstant = COMMON_CONSTANTS.get(name);
+		if (commonConstant != null) {
+			return commonConstant;
+		}
+
+		int tokenType = g.getTokenType(name);
+		if (tokenType != org.antlr.v4.runtime.Token.INVALID_TYPE) {
+			return tokenType;
+		}
+
+		int channelValue = g.getChannelValue(name);
+		if (channelValue >= org.antlr.v4.runtime.Token.MIN_USER_CHANNEL_VALUE) {
+			return channelValue;
+		}
+
+		List<String> modeNames = new ArrayList<String>(((LexerGrammar)g).modes.keySet());
+		int mode = modeNames.indexOf(name);
+		if (mode >= 0) {
+			return mode;
+		}
+
+		try {
+			return Integer.parseInt(name);
+		} catch (NumberFormatException ex) {
+			g.tool.errMgr.grammarError(ErrorType.UNKNOWN_LEXER_CONSTANT, g.fileName, token, currentRule.name, token != null ? token.getText() : null);
+			return null;
+		}
+	}
 }
diff --git a/tool/src/org/antlr/v4/automata/ParserATNFactory.java b/tool/src/org/antlr/v4/automata/ParserATNFactory.java
index 0db7b24b4..d2114b42c 100644
--- a/tool/src/org/antlr/v4/automata/ParserATNFactory.java
+++ b/tool/src/org/antlr/v4/automata/ParserATNFactory.java
@@ -68,8 +68,6 @@ import org.antlr.v4.runtime.atn.StarLoopbackState;
 import org.antlr.v4.runtime.atn.Transition;
 import org.antlr.v4.runtime.atn.WildcardTransition;
 import org.antlr.v4.runtime.misc.IntervalSet;
-import org.antlr.v4.runtime.misc.NotNull;
-import org.antlr.v4.runtime.misc.Nullable;
 import org.antlr.v4.runtime.misc.Triple;
 import org.antlr.v4.semantics.UseDefAnalyzer;
 import org.antlr.v4.tool.ErrorManager;
@@ -98,23 +96,25 @@ import java.util.List;
  *  No side-effects. It builds an {@link ATN} object and returns it.
  */
 public class ParserATNFactory implements ATNFactory {
-	@NotNull
+
 	public final Grammar g;
 
-	@NotNull
+
 	public final ATN atn;
 
 	public Rule currentRule;
 
 	public int currentOuterAlt;
 
+
 	protected final List<Triple<Rule, ATNState, ATNState>> preventEpsilonClosureBlocks =
 		new ArrayList<Triple<Rule, ATNState, ATNState>>();
 
+
 	protected final List<Triple<Rule, ATNState, ATNState>> preventEpsilonOptionalBlocks =
 		new ArrayList<Triple<Rule, ATNState, ATNState>>();
 
-	public ParserATNFactory(@NotNull Grammar g) {
+	public ParserATNFactory(Grammar g) {
 		if (g == null) {
 			throw new NullPointerException("g");
 		}
@@ -126,6 +126,7 @@ public class ParserATNFactory implements ATNFactory {
 		this.atn = new ATN(atnType, maxTokenType);
 	}
 
+
 	@Override
 	public ATN createATN() {
 		_createATN(g.rules.values());
@@ -198,6 +199,7 @@ public class ParserATNFactory implements ATNFactory {
 	}
 
 	/* start->ruleblock->end */
+
 	@Override
 	public Handle rule(GrammarAST ruleAST, String name, Handle blk) {
 		Rule r = g.getRule(name);
@@ -213,6 +215,7 @@ public class ParserATNFactory implements ATNFactory {
 	}
 
 	/** From label {@code A} build graph {@code o-A->o}. */
+
 	@Override
 	public Handle tokenRef(TerminalAST node) {
 		ATNState left = newState(node);
@@ -227,6 +230,7 @@ public class ParserATNFactory implements ATNFactory {
      *  what an alt block looks like, must have extra state on left.
 	 *  This also handles {@code ~A}, converted to {@code ~{A}} set.
      */
+
 	@Override
 	public Handle set(GrammarAST associatedAST, List<GrammarAST> terminals, boolean invert) {
 		ATNState left = newState(associatedAST);
@@ -247,9 +251,10 @@ public class ParserATNFactory implements ATNFactory {
 	}
 
 	/** Not valid for non-lexers. */
+
 	@Override
 	public Handle range(GrammarAST a, GrammarAST b) {
-		throw new UnsupportedOperationException();
+		throw new UnsupportedOperationException("This construct is not valid in parsers.");
 	}
 
 	protected int getTokenType(GrammarAST atom) {
@@ -264,12 +269,14 @@ public class ParserATNFactory implements ATNFactory {
 	}
 
 	/** For a non-lexer, just build a simple token reference atom. */
+
 	@Override
 	public Handle stringLiteral(TerminalAST stringLiteralAST) {
 		return tokenRef(stringLiteralAST);
 	}
 
 	/** {@code [Aa]} char sets not allowed in parser */
+
 	@Override
 	public Handle charSetLiteral(GrammarAST charSetAST) {
 		return null;
@@ -279,23 +286,25 @@ public class ParserATNFactory implements ATNFactory {
 	 * For reference to rule {@code r}, build
 	 *
 	 * <pre>
-	 *  o->(r)  o
+	 *  o-&gt;(r)  o
 	 * </pre>
 	 *
 	 * where {@code (r)} is the start of rule {@code r} and the trailing
 	 * {@code o} is not linked to from rule ref state directly (uses
 	 * {@link RuleTransition#followState}).
 	 */
+
 	@Override
 	public Handle ruleRef(GrammarAST node) {
 		Handle h = _ruleRef(node);
 		return h;
 	}
 
+
 	public Handle _ruleRef(GrammarAST node) {
 		Rule r = g.getRule(node.getText());
 		if ( r==null ) {
-			g.tool.errMgr.toolError(ErrorType.INTERNAL_ERROR, "Rule "+node.getText()+" undefined");
+			g.tool.errMgr.grammarError(ErrorType.INTERNAL_ERROR, g.fileName, node.getToken(), "Rule "+node.getText()+" undefined");
 			return null;
 		}
 		RuleStartState start = atn.ruleToStartState[r.index];
@@ -320,6 +329,7 @@ public class ParserATNFactory implements ATNFactory {
 	}
 
 	/** From an empty alternative build {@code o-e->o}. */
+
 	@Override
 	public Handle epsilon(GrammarAST node) {
 		ATNState left = newState(node);
@@ -333,6 +343,7 @@ public class ParserATNFactory implements ATNFactory {
 	 *  predicate action.  The {@code pred} is a pointer into the AST of
 	 *  the {@link ANTLRParser#SEMPRED} token.
 	 */
+
 	@Override
 	public Handle sempred(PredAST pred) {
 		//System.out.println("sempred: "+ pred);
@@ -358,6 +369,7 @@ public class ParserATNFactory implements ATNFactory {
 	 *  The action goes into ATN though it is ignored during prediction
 	 *  if {@link ActionTransition#actionIndex actionIndex}{@code <0}.
 	 */
+
 	@Override
 	public Handle action(ActionAST action) {
 		//System.out.println("action: "+action);
@@ -369,35 +381,37 @@ public class ParserATNFactory implements ATNFactory {
 		return new Handle(left, right);
 	}
 
+
 	@Override
 	public Handle action(String action) {
-		return null;
+		throw new UnsupportedOperationException("This element is not valid in parsers.");
 	}
 
 	/**
 	 * From {@code A|B|..|Z} alternative block build
 	 *
 	 * <pre>
-	 *  o->o-A->o->o (last ATNState is BlockEndState pointed to by all alts)
+	 *  o-&gt;o-A-&gt;o-&gt;o (last ATNState is BlockEndState pointed to by all alts)
 	 *  |          ^
-	 *  |->o-B->o--|
+	 *  |-&gt;o-B-&gt;o--|
 	 *  |          |
 	 *  ...        |
 	 *  |          |
-	 *  |->o-Z->o--|
+	 *  |-&gt;o-Z-&gt;o--|
 	 * </pre>
 	 *
 	 * So start node points at every alternative with epsilon transition and
 	 * every alt right side points at a block end ATNState.
-	 * <p/>
+	 * <p>
 	 * Special case: only one alternative: don't make a block with alt
 	 * begin/end.
-	 * <p/>
+	 * <p>
 	 * Special case: if just a list of tokens/chars/sets, then collapse to a
-	 * single edged o-set->o graph.
-	 * <p/>
+	 * single edged o-set-&gt;o graph.
+	 * <p>
 	 * TODO: Set alt number (1..n) in the states?
 	 */
+
 	@Override
 	public Handle block(BlockAST blkAST, GrammarAST ebnfRoot, List<Handle> alts) {
 		if ( ebnfRoot==null ) {
@@ -430,6 +444,7 @@ public class ParserATNFactory implements ATNFactory {
 		return null;
 	}
 
+
 	protected Handle makeBlock(BlockStartState start, BlockAST blkAST, List<Handle> alts) {
 		BlockEndState end = newState(BlockEndState.class, blkAST);
 		start.endState = end;
@@ -450,14 +465,14 @@ public class ParserATNFactory implements ATNFactory {
 		return h;
 	}
 
-	@NotNull
+
 	@Override
-	public Handle alt(@NotNull List<Handle> els) {
+	public Handle alt(List<Handle> els) {
 		return elemList(els);
 	}
 
-	@NotNull
-	public Handle elemList(@NotNull List<Handle> els) {
+
+	public Handle elemList(List<Handle> els) {
 		int n = els.size();
 		for (int i = 0; i < n - 1; i++) {	// hook up elements (visit all but last)
 			Handle el = els.get(i);
@@ -491,17 +506,17 @@ public class ParserATNFactory implements ATNFactory {
 	 * From {@code (A)?} build either:
 	 *
 	 * <pre>
-	 *  o--A->o
+	 *  o--A-&gt;o
 	 *  |     ^
-	 *  o---->|
+	 *  o----&gt;|
 	 * </pre>
 	 *
 	 * or, if {@code A} is a block, just add an empty alt to the end of the
 	 * block
 	 */
-	@NotNull
+
 	@Override
-	public Handle optional(@NotNull GrammarAST optAST, @NotNull Handle blk) {
+	public Handle optional(GrammarAST optAST, Handle blk) {
 		BlockStartState blkStart = (BlockStartState)blk.left;
 		ATNState blkEnd = blk.right;
 		preventEpsilonOptionalBlocks.add(new Triple<Rule, ATNState, ATNState>(currentRule, blkStart, blkEnd));
@@ -520,15 +535,15 @@ public class ParserATNFactory implements ATNFactory {
 	 * <pre>
 	 *   |---------|
 	 *   v         |
-	 *  [o-blk-o]->o->o
+	 *  [o-blk-o]-&gt;o-&gt;o
 	 * </pre>
 	 *
 	 * We add a decision for loop back node to the existing one at {@code blk}
 	 * start.
 	 */
-	@NotNull
+
 	@Override
-	public Handle plus(@NotNull GrammarAST plusAST, @NotNull Handle blk) {
+	public Handle plus(GrammarAST plusAST, Handle blk) {
 		PlusBlockStartState blkStart = (PlusBlockStartState)blk.left;
 		BlockEndState blkEnd = (BlockEndState)blk.right;
 		preventEpsilonClosureBlocks.add(new Triple<Rule, ATNState, ATNState>(currentRule, blkStart, blkEnd));
@@ -540,7 +555,7 @@ public class ParserATNFactory implements ATNFactory {
 		blkStart.loopBackState = loop;
 		end.loopBackState = loop;
 
-		plusAST.atnState = blkStart;
+		plusAST.atnState = loop;
 		epsilon(blkEnd, loop);		// blk can see loop back
 
 		BlockAST blkAST = (BlockAST)plusAST.getChild(0);
@@ -568,7 +583,7 @@ public class ParserATNFactory implements ATNFactory {
 	 * <pre>
 	 *   |-------------|
 	 *   v             |
-	 *   o--[o-blk-o]->o  o
+	 *   o--[o-blk-o]-&gt;o  o
 	 *   |                ^
 	 *   -----------------|
 	 * </pre>
@@ -576,9 +591,9 @@ public class ParserATNFactory implements ATNFactory {
 	 * Note that the optional bypass must jump outside the loop as
 	 * {@code (A|B)*} is not the same thing as {@code (A|B|)+}.
 	 */
-	@NotNull
+
 	@Override
-	public Handle star(@NotNull GrammarAST starAST, @NotNull Handle elem) {
+	public Handle star(GrammarAST starAST, Handle elem) {
 		StarBlockStartState blkStart = (StarBlockStartState)elem.left;
 		BlockEndState blkEnd = (BlockEndState)elem.right;
 		preventEpsilonClosureBlocks.add(new Triple<Rule, ATNState, ATNState>(currentRule, blkStart, blkEnd));
@@ -613,7 +628,7 @@ public class ParserATNFactory implements ATNFactory {
 	}
 
 	/** Build an atom with all possible values in its label. */
-	@NotNull
+
 	@Override
 	public Handle wildcard(GrammarAST node) {
 		ATNState left = newState(node);
@@ -623,11 +638,11 @@ public class ParserATNFactory implements ATNFactory {
 		return new Handle(left, right);
 	}
 
-	protected void epsilon(ATNState a, @NotNull ATNState b) {
+	protected void epsilon(ATNState a, ATNState b) {
 		epsilon(a, b, false);
 	}
 
-	protected void epsilon(ATNState a, @NotNull ATNState b, boolean prepend) {
+	protected void epsilon(ATNState a, ATNState b, boolean prepend) {
 		if ( a!=null ) {
 			int index = prepend ? 0 : a.getNumberOfTransitions();
 			a.addTransition(index, new EpsilonTransition(b));
@@ -644,7 +659,7 @@ public class ParserATNFactory implements ATNFactory {
 			RuleStartState start = newState(RuleStartState.class, r.ast);
 			RuleStopState stop = newState(RuleStopState.class, r.ast);
 			start.stopState = stop;
-			start.isPrecedenceRule = r instanceof LeftRecursiveRule;
+			start.isLeftRecursiveRule = r instanceof LeftRecursiveRule;
 			start.setRuleIndex(r.index);
 			stop.setRuleIndex(r.index);
 			atn.ruleToStartState[r.index] = start;
@@ -685,18 +700,20 @@ public class ParserATNFactory implements ATNFactory {
 		return n;
 	}
 
+
 	@Override
 	public Handle label(Handle t) {
 		return t;
 	}
 
+
 	@Override
 	public Handle listLabel(Handle t) {
 		return t;
 	}
 
-	@NotNull
-	public <T extends ATNState> T newState(@NotNull Class<T> nodeType, GrammarAST node) {
+
+	public <T extends ATNState> T newState(Class<T> nodeType, GrammarAST node) {
 		Exception cause;
 		try {
 			Constructor<T> ctor = nodeType.getConstructor();
@@ -723,19 +740,19 @@ public class ParserATNFactory implements ATNFactory {
 		throw new UnsupportedOperationException(message, cause);
 	}
 
-	@NotNull
-	public ATNState newState(@Nullable GrammarAST node) {
+
+	public ATNState newState(GrammarAST node) {
 		ATNState n = new BasicState();
 		n.setRuleIndex(currentRule.index);
 		atn.addState(n);
 		return n;
 	}
 
-	@NotNull
+
 	@Override
 	public ATNState newState() { return newState(null); }
 
-	public boolean expectNonGreedy(@NotNull BlockAST blkAST) {
+	public boolean expectNonGreedy(BlockAST blkAST) {
 		if ( blockHasWildcardAlt(blkAST) ) {
 			return true;
 		}
@@ -746,12 +763,12 @@ public class ParserATNFactory implements ATNFactory {
 	/**
 	 * {@code (BLOCK (ALT .))} or {@code (BLOCK (ALT 'a') (ALT .))}.
 	 */
-	public static boolean blockHasWildcardAlt(@NotNull GrammarAST block) {
+	public static boolean blockHasWildcardAlt(GrammarAST block) {
 		for (Object alt : block.getChildren()) {
 			if ( !(alt instanceof AltAST) ) continue;
 			AltAST altAST = (AltAST)alt;
-			if ( altAST.getChildCount()==1 ) {
-				Tree e = altAST.getChild(0);
+			if ( altAST.getChildCount()==1 || (altAST.getChildCount() == 2 && altAST.getChild(0).getType() == ANTLRParser.ELEMENT_OPTIONS) ) {
+				Tree e = altAST.getChild(altAST.getChildCount() - 1);
 				if ( e.getType()==ANTLRParser.WILDCARD ) {
 					return true;
 				}
@@ -760,18 +777,21 @@ public class ParserATNFactory implements ATNFactory {
 		return false;
 	}
 
+
 	@Override
 	public Handle lexerAltCommands(Handle alt, Handle cmds) {
-		return null;
+		throw new UnsupportedOperationException("This element is not allowed in parsers.");
 	}
 
-	@Override
-	public String lexerCallCommand(GrammarAST ID, GrammarAST arg) {
-		return null;
-	}
 
 	@Override
-	public String lexerCommand(GrammarAST ID) {
-		return null;
+	public Handle lexerCallCommand(GrammarAST ID, GrammarAST arg) {
+		throw new UnsupportedOperationException("This element is not allowed in parsers.");
+	}
+
+
+	@Override
+	public Handle lexerCommand(GrammarAST ID) {
+		throw new UnsupportedOperationException("This element is not allowed in parsers.");
 	}
 }
diff --git a/tool/src/org/antlr/v4/automata/TailEpsilonRemover.java b/tool/src/org/antlr/v4/automata/TailEpsilonRemover.java
index cf52e73d3..35d159431 100644
--- a/tool/src/org/antlr/v4/automata/TailEpsilonRemover.java
+++ b/tool/src/org/antlr/v4/automata/TailEpsilonRemover.java
@@ -32,28 +32,27 @@ package org.antlr.v4.automata;
 
 import org.antlr.v4.runtime.atn.ATN;
 import org.antlr.v4.runtime.atn.ATNState;
-import org.antlr.v4.runtime.atn.ActionTransition;
 import org.antlr.v4.runtime.atn.BlockEndState;
+import org.antlr.v4.runtime.atn.EpsilonTransition;
 import org.antlr.v4.runtime.atn.PlusLoopbackState;
 import org.antlr.v4.runtime.atn.RuleTransition;
 import org.antlr.v4.runtime.atn.StarLoopbackState;
 import org.antlr.v4.runtime.atn.Transition;
-import org.antlr.v4.runtime.misc.NotNull;
 
 /**
  *
  * @author Terence Parr
  */
 public class TailEpsilonRemover extends ATNVisitor {
-	@NotNull
+
 	private final ATN _atn;
 
-	public TailEpsilonRemover(@NotNull ATN atn) {
+	public TailEpsilonRemover(ATN atn) {
 		this._atn = atn;
 	}
 
 	@Override
-	public void visitState(@NotNull ATNState p) {
+	public void visitState(ATNState p) {
 		if (p.getStateType() == ATNState.BASIC && p.getNumberOfTransitions() == 1) {
 			ATNState q = p.transition(0).target;
 			if (p.transition(0) instanceof RuleTransition) {
@@ -64,7 +63,7 @@ public class TailEpsilonRemover extends ATNVisitor {
 				// if edge out of q is single epsilon to block end
 				// we can strip epsilon p-x->q-eps->r
 				Transition trans = q.transition(0);
-				if (q.getNumberOfTransitions() == 1 && trans.isEpsilon() && !(trans instanceof ActionTransition)) {
+				if (q.getNumberOfTransitions() == 1 && trans instanceof EpsilonTransition) {
 					ATNState r = trans.target;
 					if (r instanceof BlockEndState || r instanceof PlusLoopbackState || r instanceof StarLoopbackState) {
 						// skip over q
diff --git a/tool/src/org/antlr/v4/codegen/ActionTranslator.java b/tool/src/org/antlr/v4/codegen/ActionTranslator.java
index 6647bc40b..53a9a50ab 100644
--- a/tool/src/org/antlr/v4/codegen/ActionTranslator.java
+++ b/tool/src/org/antlr/v4/codegen/ActionTranslator.java
@@ -44,12 +44,14 @@ import org.antlr.v4.codegen.model.chunk.QRetValueRef;
 import org.antlr.v4.codegen.model.chunk.RetValueRef;
 import org.antlr.v4.codegen.model.chunk.RulePropertyRef;
 import org.antlr.v4.codegen.model.chunk.RulePropertyRef_ctx;
+import org.antlr.v4.codegen.model.chunk.RulePropertyRef_parser;
 import org.antlr.v4.codegen.model.chunk.RulePropertyRef_start;
 import org.antlr.v4.codegen.model.chunk.RulePropertyRef_stop;
 import org.antlr.v4.codegen.model.chunk.RulePropertyRef_text;
 import org.antlr.v4.codegen.model.chunk.SetAttr;
 import org.antlr.v4.codegen.model.chunk.SetNonLocalAttr;
 import org.antlr.v4.codegen.model.chunk.ThisRulePropertyRef_ctx;
+import org.antlr.v4.codegen.model.chunk.ThisRulePropertyRef_parser;
 import org.antlr.v4.codegen.model.chunk.ThisRulePropertyRef_start;
 import org.antlr.v4.codegen.model.chunk.ThisRulePropertyRef_stop;
 import org.antlr.v4.codegen.model.chunk.ThisRulePropertyRef_text;
@@ -86,6 +88,7 @@ public class ActionTranslator implements ActionSplitterListener {
 		thisRulePropToModelMap.put("stop",  ThisRulePropertyRef_stop.class);
 		thisRulePropToModelMap.put("text",  ThisRulePropertyRef_text.class);
 		thisRulePropToModelMap.put("ctx",   ThisRulePropertyRef_ctx.class);
+		thisRulePropToModelMap.put("parser",  ThisRulePropertyRef_parser.class);
 	}
 
 	public static final Map<String, Class<? extends RulePropertyRef>> rulePropToModelMap =
@@ -95,6 +98,7 @@ public class ActionTranslator implements ActionSplitterListener {
 		rulePropToModelMap.put("stop",  RulePropertyRef_stop.class);
 		rulePropToModelMap.put("text",  RulePropertyRef_text.class);
 		rulePropToModelMap.put("ctx",   RulePropertyRef_ctx.class);
+		rulePropToModelMap.put("parser",  RulePropertyRef_parser.class);
 	}
 
 	public static final Map<String, Class<? extends TokenPropertyRef>> tokenPropToModelMap =
@@ -134,7 +138,7 @@ public class ActionTranslator implements ActionSplitterListener {
 													ActionAST node)
 	{
 		String action = tokenWithinAction.getText();
-		if ( action.charAt(0)=='{' ) {
+		if ( action!=null && action.length()>0 && action.charAt(0)=='{' ) {
 			int firstCurly = action.indexOf('{');
 			int lastCurly = action.lastIndexOf('}');
 			if ( firstCurly>=0 && lastCurly>=0 ) {
@@ -154,8 +158,10 @@ public class ActionTranslator implements ActionSplitterListener {
 		translator.rf = rf;
         factory.getGrammar().tool.log("action-translator", "translate " + action);
 		String altLabel = node.getAltLabel();
-		if ( rf!=null ) translator.nodeContext = rf.ruleCtx;
-		if ( altLabel!=null ) translator.nodeContext = rf.altLabelCtxs.get(altLabel);
+		if ( rf!=null ) {
+		    translator.nodeContext = rf.ruleCtx;
+	        if ( altLabel!=null ) translator.nodeContext = rf.altLabelCtxs.get(altLabel);
+		}
 		ANTLRStringStream in = new ANTLRStringStream(action);
 		in.setLine(tokenWithinAction.getLine());
 		in.setCharPositionInLine(tokenWithinAction.getCharPositionInLine());
diff --git a/tool/src/org/antlr/v4/codegen/CodeGenPipeline.java b/tool/src/org/antlr/v4/codegen/CodeGenPipeline.java
index 45f445d66..43aa0d907 100644
--- a/tool/src/org/antlr/v4/codegen/CodeGenPipeline.java
+++ b/tool/src/org/antlr/v4/codegen/CodeGenPipeline.java
@@ -49,8 +49,9 @@ public class CodeGenPipeline {
 	}
 
 	public void process() {
-		CodeGenerator gen = new CodeGenerator(g);
+		if ( !CodeGenerator.targetExists(g.getOptionString("language")) ) return;
 
+		CodeGenerator gen = new CodeGenerator(g);
 		IntervalSet idTypes = new IntervalSet();
 		idTypes.add(ANTLRParser.ID);
 		idTypes.add(ANTLRParser.RULE_REF);
diff --git a/tool/src/org/antlr/v4/codegen/CodeGenerator.java b/tool/src/org/antlr/v4/codegen/CodeGenerator.java
index a5584f367..881906a4e 100644
--- a/tool/src/org/antlr/v4/codegen/CodeGenerator.java
+++ b/tool/src/org/antlr/v4/codegen/CodeGenerator.java
@@ -33,7 +33,6 @@ package org.antlr.v4.codegen;
 import org.antlr.v4.Tool;
 import org.antlr.v4.codegen.model.OutputModelObject;
 import org.antlr.v4.runtime.Token;
-import org.antlr.v4.runtime.misc.NotNull;
 import org.antlr.v4.tool.ErrorType;
 import org.antlr.v4.tool.Grammar;
 import org.stringtemplate.v4.AutoIndentWriter;
@@ -44,8 +43,7 @@ import org.stringtemplate.v4.STWriter;
 import java.io.IOException;
 import java.io.Writer;
 import java.lang.reflect.Constructor;
-import java.lang.reflect.InvocationTargetException;
-import java.util.HashMap;
+import java.util.LinkedHashMap;
 import java.util.Map;
 
 /** General controller for code gen.  Can instantiate sub generator(s).
@@ -54,73 +52,75 @@ public class CodeGenerator {
 	public static final String TEMPLATE_ROOT = "org/antlr/v4/tool/templates/codegen";
 	public static final String VOCAB_FILE_EXTENSION = ".tokens";
 	public static final String DEFAULT_LANGUAGE = "Java";
-	public final static String vocabFilePattern =
+	public static final String vocabFilePattern =
 		"<tokens.keys:{t | <t>=<tokens.(t)>\n}>" +
 		"<literals.keys:{t | <t>=<literals.(t)>\n}>";
 
-	@NotNull
+
 	public final Grammar g;
-	@NotNull
+
 	public final Tool tool;
-	@NotNull
+
 	public final String language;
 
 	private Target target;
 
 	public int lineWidth = 72;
 
-	public CodeGenerator(@NotNull Grammar g) {
+	private CodeGenerator(String language) {
+		this.g = null;
+		this.tool = null;
+		this.language = language;
+	}
+
+	public CodeGenerator(Grammar g) {
 		this(g.tool, g, g.getOptionString("language"));
 	}
 
-	public CodeGenerator(@NotNull Tool tool, @NotNull Grammar g, String language) {
+	public CodeGenerator(Tool tool, Grammar g, String language) {
 		this.g = g;
 		this.tool = tool;
 		this.language = language != null ? language : DEFAULT_LANGUAGE;
 	}
 
+	public static boolean targetExists(String language) {
+		String targetName = "org.antlr.v4.codegen.target."+language+"Target";
+		try {
+			Class<? extends Target> c = Class.forName(targetName).asSubclass(Target.class);
+			Constructor<? extends Target> ctor = c.getConstructor(CodeGenerator.class);
+			CodeGenerator gen = new CodeGenerator(language);
+			Target target = ctor.newInstance(gen);
+			return target.templatesExist();
+		}
+		catch (Exception e) { // ignore errors; we're detecting presence only
+		}
+		return false;
+	}
+
+
 	public Target getTarget() {
-		if (target == null) {
+		if ( target == null && targetExists(language) ) {
 			loadLanguageTarget(language);
 		}
-
 		return target;
 	}
 
+
 	public STGroup getTemplates() {
-		return getTarget().getTemplates();
+		Target t = getTarget();
+		return t==null ? null : t.getTemplates();
 	}
 
 	protected void loadLanguageTarget(String language) {
-		String targetName = "org.antlr.v4.codegen."+language+"Target";
+		String targetName = "org.antlr.v4.codegen.target."+language+"Target";
 		try {
 			Class<? extends Target> c = Class.forName(targetName).asSubclass(Target.class);
 			Constructor<? extends Target> ctor = c.getConstructor(CodeGenerator.class);
 			target = ctor.newInstance(this);
 		}
-		catch (ClassNotFoundException cnfe) {
+		catch (Exception e) {
 			tool.errMgr.toolError(ErrorType.CANNOT_CREATE_TARGET_GENERATOR,
-						 cnfe,
-						 targetName);
-		}
-		catch (NoSuchMethodException nsme) {
-			tool.errMgr.toolError(ErrorType.CANNOT_CREATE_TARGET_GENERATOR,
-						 nsme,
-						 targetName);
-		}
-		catch (InvocationTargetException ite) {
-			tool.errMgr.toolError(ErrorType.CANNOT_CREATE_TARGET_GENERATOR,
-						 ite,
-						 targetName);
-		}
-		catch (InstantiationException ie) {
-			tool.errMgr.toolError(ErrorType.CANNOT_CREATE_TARGET_GENERATOR,
-						 ie,
-						 targetName);
-		}
-		catch (IllegalAccessException cnfe) {
-			tool.errMgr.toolError(ErrorType.CANNOT_CREATE_TARGET_GENERATOR,
-						 cnfe,
+						 e,
 						 targetName);
 		}
 	}
@@ -155,7 +155,7 @@ public class CodeGenerator {
 	 */
 	ST getTokenVocabOutput() {
 		ST vocabFileST = new ST(vocabFilePattern);
-		Map<String,Integer> tokens = new HashMap<String,Integer>();
+		Map<String,Integer> tokens = new LinkedHashMap<String,Integer>();
 		// make constants for the token names
 		for (String t : g.tokenNameToTypeMap.keySet()) {
 			int tokenType = g.tokenNameToTypeMap.get(t);
@@ -166,7 +166,7 @@ public class CodeGenerator {
 		vocabFileST.add("tokens", tokens);
 
 		// now dump the strings
-		Map<String,Integer> literals = new HashMap<String,Integer>();
+		Map<String,Integer> literals = new LinkedHashMap<String,Integer>();
 		for (String literal : g.stringLiteralToTypeMap.keySet()) {
 			int tokenType = g.stringLiteralToTypeMap.get(literal);
 			if ( tokenType>=Token.MIN_USER_TOKEN_TYPE) {
diff --git a/tool/src/org/antlr/v4/codegen/DefaultOutputModelFactory.java b/tool/src/org/antlr/v4/codegen/DefaultOutputModelFactory.java
index a943fb73b..c8a149817 100644
--- a/tool/src/org/antlr/v4/codegen/DefaultOutputModelFactory.java
+++ b/tool/src/org/antlr/v4/codegen/DefaultOutputModelFactory.java
@@ -30,16 +30,18 @@
 
 package org.antlr.v4.codegen;
 
+import org.antlr.v4.codegen.model.Action;
 import org.antlr.v4.codegen.model.CodeBlockForOuterMostAlt;
 import org.antlr.v4.codegen.model.OutputModelObject;
 import org.antlr.v4.codegen.model.RuleFunction;
 import org.antlr.v4.codegen.model.SrcOp;
 import org.antlr.v4.codegen.model.decl.CodeBlock;
 import org.antlr.v4.codegen.model.decl.Decl;
-import org.antlr.v4.runtime.misc.NotNull;
-import org.antlr.v4.runtime.misc.Nullable;
 import org.antlr.v4.tool.Alternative;
 import org.antlr.v4.tool.Grammar;
+import org.antlr.v4.tool.Rule;
+import org.stringtemplate.v4.ST;
+import org.stringtemplate.v4.STGroup;
 
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -53,14 +55,14 @@ import java.util.List;
  */
 public abstract class DefaultOutputModelFactory extends BlankOutputModelFactory {
 	// Interface to outside world
-	@NotNull
+
 	public final Grammar g;
-	@NotNull
+
 	public final CodeGenerator gen;
 
 	public OutputModelController controller;
 
-	protected DefaultOutputModelFactory(@NotNull CodeGenerator gen) {
+	protected DefaultOutputModelFactory(CodeGenerator gen) {
 		this.gen = gen;
 		this.g = gen.g;
 	}
@@ -75,9 +77,25 @@ public abstract class DefaultOutputModelFactory extends BlankOutputModelFactory
 		return controller;
 	}
 
+	@Override
+	public List<SrcOp> rulePostamble(RuleFunction function, Rule r) {
+		if ( r.namedActions.containsKey("after") || r.namedActions.containsKey("finally") ) {
+			// See OutputModelController.buildLeftRecursiveRuleFunction
+			// and Parser.exitRule for other places which set stop.
+			CodeGenerator gen = getGenerator();
+			STGroup codegenTemplates = gen.getTemplates();
+			ST setStopTokenAST = codegenTemplates.getInstanceOf("recRuleSetStopToken");
+			Action setStopTokenAction = new Action(this, function.ruleCtx, setStopTokenAST);
+			List<SrcOp> ops = new ArrayList<SrcOp>(1);
+			ops.add(setStopTokenAction);
+			return ops;
+		}
+		return super.rulePostamble(function, r);
+	}
+
 	// Convenience methods
 
-	@NotNull
+
 	@Override
 	public Grammar getGrammar() { return g; }
 
@@ -107,17 +125,17 @@ public abstract class DefaultOutputModelFactory extends BlankOutputModelFactory
 
 	// MISC
 
-	@NotNull
+
 	public static List<SrcOp> list(SrcOp... values) {
 		return new ArrayList<SrcOp>(Arrays.asList(values));
 	}
 
-	@NotNull
+
 	public static List<SrcOp> list(Collection<? extends SrcOp> values) {
 		return new ArrayList<SrcOp>(values);
 	}
 
-	@Nullable
+
 	public Decl getCurrentDeclForName(String name) {
 		if ( getCurrentBlock().locals==null ) return null;
 		for (Decl d : getCurrentBlock().locals.elements()) {
diff --git a/tool/src/org/antlr/v4/codegen/OutputModelController.java b/tool/src/org/antlr/v4/codegen/OutputModelController.java
index 416312aba..179f3f7b2 100644
--- a/tool/src/org/antlr/v4/codegen/OutputModelController.java
+++ b/tool/src/org/antlr/v4/codegen/OutputModelController.java
@@ -58,6 +58,7 @@ import org.antlr.v4.misc.Utils;
 import org.antlr.v4.parse.ANTLRParser;
 import org.antlr.v4.parse.GrammarASTAdaptor;
 import org.antlr.v4.tool.Alternative;
+import org.antlr.v4.tool.ErrorType;
 import org.antlr.v4.tool.Grammar;
 import org.antlr.v4.tool.LeftRecursiveRule;
 import org.antlr.v4.tool.Rule;
@@ -107,15 +108,14 @@ public class OutputModelController {
 	 *  extensions too, not just the factory functions in this factory.
 	 */
 	public OutputModelObject buildParserOutputModel(boolean header) {
-		Grammar g = delegate.getGrammar();
 		CodeGenerator gen = delegate.getGenerator();
 		ParserFile file = parserFile(gen.getRecognizerFileName(header));
 		setRoot(file);
-		Parser parser = parser(file);
-		file.parser = parser;
+		file.parser = parser(file);
 
+		Grammar g = delegate.getGrammar();
 		for (Rule r : g.rules.values()) {
-			buildRuleFunction(parser, r);
+			buildRuleFunction(file.parser, r);
 		}
 
 		return file;
@@ -266,17 +266,26 @@ public class OutputModelController {
 		for (int i = 0; i < opAltsCode.size(); i++) {
 			ST altActionST;
 			LeftRecursiveRuleAltInfo altInfo = r.recOpAlts.getElement(i);
+			String templateName;
 			if ( altInfo.altLabel!=null ) {
-				altActionST = codegenTemplates.getInstanceOf("recRuleLabeledAltStartAction");
+				templateName = "recRuleLabeledAltStartAction";
+				altActionST = codegenTemplates.getInstanceOf(templateName);
 				altActionST.add("currentAltLabel", altInfo.altLabel);
 			}
 			else {
-				altActionST = codegenTemplates.getInstanceOf("recRuleAltStartAction");
+				templateName = "recRuleAltStartAction";
+				altActionST = codegenTemplates.getInstanceOf(templateName);
 				altActionST.add("ctxName", Utils.capitalize(r.name));
 			}
 			altActionST.add("ruleName", r.name);
 			// add label of any lr ref we deleted
 			altActionST.add("label", altInfo.leftRecursiveRuleRefLabel);
+			if (altActionST.impl.formalArguments.containsKey("isListLabel")) {
+				altActionST.add("isListLabel", altInfo.isListLabel);
+			}
+			else if (altInfo.isListLabel) {
+				delegate.getGenerator().tool.errMgr.toolError(ErrorType.CODE_TEMPLATE_ARG_ISSUE, templateName, "isListLabel");
+			}
 			Action altAction =
 				new Action(delegate, function.altLabelCtxs.get(altInfo.altLabel), altActionST);
 			CodeBlockForAlt alt = opAltsCode.get(i);
diff --git a/tool/src/org/antlr/v4/codegen/OutputModelWalker.java b/tool/src/org/antlr/v4/codegen/OutputModelWalker.java
index 51d48dc7f..914b557b1 100644
--- a/tool/src/org/antlr/v4/codegen/OutputModelWalker.java
+++ b/tool/src/org/antlr/v4/codegen/OutputModelWalker.java
@@ -53,7 +53,7 @@ import java.util.Set;
  *  We identify those nested objects by the list of arguments in the template
  *  definition. For example, here is the definition of the parser template:
  *
- *  Parser(parser, scopes, funcs) ::= <<...>>
+ *  Parser(parser, scopes, funcs) ::= &lt;&lt;...&gt;&gt;
  *
  *  The first template argument is always the output model object from which
  *  this walker will create the template. Any other arguments identify
diff --git a/tool/src/org/antlr/v4/codegen/ParserFactory.java b/tool/src/org/antlr/v4/codegen/ParserFactory.java
index 0953aaab0..dfb33f5b2 100644
--- a/tool/src/org/antlr/v4/codegen/ParserFactory.java
+++ b/tool/src/org/antlr/v4/codegen/ParserFactory.java
@@ -41,9 +41,7 @@ import org.antlr.v4.codegen.model.InvokeRule;
 import org.antlr.v4.codegen.model.LL1AltBlock;
 import org.antlr.v4.codegen.model.LL1OptionalBlock;
 import org.antlr.v4.codegen.model.LL1OptionalBlockSingleAlt;
-import org.antlr.v4.codegen.model.LL1PlusBlock;
 import org.antlr.v4.codegen.model.LL1PlusBlockSingleAlt;
-import org.antlr.v4.codegen.model.LL1StarBlock;
 import org.antlr.v4.codegen.model.LL1StarBlockSingleAlt;
 import org.antlr.v4.codegen.model.LabeledOp;
 import org.antlr.v4.codegen.model.LeftRecursiveRuleFunction;
@@ -65,7 +63,7 @@ import org.antlr.v4.codegen.model.decl.TokenDecl;
 import org.antlr.v4.codegen.model.decl.TokenListDecl;
 import org.antlr.v4.parse.ANTLRParser;
 import org.antlr.v4.runtime.atn.DecisionState;
-import org.antlr.v4.runtime.atn.PlusBlockStartState;
+import org.antlr.v4.runtime.atn.PlusLoopbackState;
 import org.antlr.v4.runtime.atn.StarLoopEntryState;
 import org.antlr.v4.runtime.misc.IntervalSet;
 import org.antlr.v4.tool.Alternative;
@@ -248,7 +246,7 @@ public class ParserFactory extends DefaultOutputModelFactory {
 		if (!g.tool.force_atn) {
 			int decision;
 			if ( ebnfRoot.getType()==ANTLRParser.POSITIVE_CLOSURE ) {
-				decision = ((PlusBlockStartState)ebnfRoot.atnState).loopBackState.decision;
+				decision = ((PlusLoopbackState)ebnfRoot.atnState).decision;
 			}
 			else if ( ebnfRoot.getType()==ANTLRParser.CLOSURE ) {
 				decision = ((StarLoopEntryState)ebnfRoot.atnState).decision;
@@ -287,11 +285,11 @@ public class ParserFactory extends DefaultOutputModelFactory {
 				break;
 			case ANTLRParser.CLOSURE :
 				if ( alts.size()==1 ) c = new LL1StarBlockSingleAlt(this, ebnfRoot, alts);
-				else c = new LL1StarBlock(this, ebnfRoot, alts);
+				else c = getComplexEBNFBlock(ebnfRoot, alts);
 				break;
 			case ANTLRParser.POSITIVE_CLOSURE :
 				if ( alts.size()==1 ) c = new LL1PlusBlockSingleAlt(this, ebnfRoot, alts);
-				else c = new LL1PlusBlock(this, ebnfRoot, alts);
+				else c = getComplexEBNFBlock(ebnfRoot, alts);
 				break;
 		}
 		return c;
@@ -318,7 +316,7 @@ public class ParserFactory extends DefaultOutputModelFactory {
 
 	@Override
 	public List<SrcOp> getLL1Test(IntervalSet look, GrammarAST blkAST) {
-		return list(new TestSetInline(this, blkAST, look));
+		return list(new TestSetInline(this, blkAST, look, gen.getTarget().getInlineTestSetWordSize()));
 	}
 
 	@Override
diff --git a/tool/src/org/antlr/v4/codegen/SourceGenTriggers.g b/tool/src/org/antlr/v4/codegen/SourceGenTriggers.g
index 2991359c1..de3154fba 100644
--- a/tool/src/org/antlr/v4/codegen/SourceGenTriggers.g
+++ b/tool/src/org/antlr/v4/codegen/SourceGenTriggers.g
@@ -99,9 +99,9 @@ alt[boolean outerMost] returns [CodeBlockForAlt altCodeBlock, List<SrcOp> ops]
 		$altCodeBlock.ops = $ops = elems;
 		controller.setCurrentBlock($altCodeBlock);
 		}
-		^( ALT ( element {if ($element.omos!=null) elems.addAll($element.omos);} )+ )
+		^( ALT elementOptions? ( element {if ($element.omos!=null) elems.addAll($element.omos);} )+ )
 
-	|	^(ALT EPSILON)
+	|	^(ALT elementOptions? EPSILON)
         {$altCodeBlock = controller.epsilon(controller.getCurrentOuterMostAlt(), outerMost);}
     ;
 
diff --git a/tool/src/org/antlr/v4/codegen/Target.java b/tool/src/org/antlr/v4/codegen/Target.java
index 4a3fbdaea..b071dbd7a 100644
--- a/tool/src/org/antlr/v4/codegen/Target.java
+++ b/tool/src/org/antlr/v4/codegen/Target.java
@@ -1,5 +1,6 @@
 /*
  * [The "BSD license"]
+ *  Copyright (c) 2016 Mike Lischke
  *  Copyright (c) 2012 Terence Parr
  *  Copyright (c) 2012 Sam Harwell
  *  All rights reserved.
@@ -30,10 +31,12 @@
 
 package org.antlr.v4.codegen;
 
+import org.antlr.v4.Tool;
 import org.antlr.v4.codegen.model.RuleFunction;
 import org.antlr.v4.codegen.model.SerializedATN;
 import org.antlr.v4.misc.Utils;
 import org.antlr.v4.parse.ANTLRParser;
+import org.antlr.v4.runtime.RuntimeMetaData;
 import org.antlr.v4.runtime.Token;
 import org.antlr.v4.tool.ErrorType;
 import org.antlr.v4.tool.Grammar;
@@ -54,7 +57,7 @@ public abstract class Target {
 	 *  predicates and such that may refer to chars that need to be escaped
 	 *  when represented as strings.  Also, templates need to be escaped so
 	 *  that the target language can hold them as a string.
-	 *  <p/>
+	 *  <p>
 	 *  I have defined (via the constructor) the set of typical escapes,
 	 *  but your {@link Target} subclass is free to alter the translated chars
 	 *  or add more definitions.  This is non-static so each target can have
@@ -87,10 +90,26 @@ public abstract class Target {
 		return language;
 	}
 
-  public boolean needsHeader() { return false; }; // Override in targets which need header files.
-  
+	/** ANTLR tool should check output templates / target are compatible with tool code generation.
+	 *  For now, a simple string match used on x.y of x.y.z scheme. We use a method to avoid mismatches
+	 *  between a template called VERSION. This value is checked against Tool.VERSION during load of templates.
+	 *
+	 *  This additional method forces all targets 4.3 and beyond to add this method.
+	 *
+	 * @since 4.3
+	 */
+	public abstract String getVersion();
+
+    public boolean needsHeader() { return false; }; // Override in targets which need header files.
+
 	public STGroup getTemplates() {
 		if (templates == null) {
+			String version = getVersion();
+			if ( version==null ||
+				 !RuntimeMetaData.getMajorMinorVersion(version).equals(RuntimeMetaData.getMajorMinorVersion(Tool.VERSION)))
+			{
+				gen.tool.errMgr.toolError(ErrorType.INCOMPATIBLE_TOOL_AND_TEMPLATES, version, Tool.VERSION, language);
+			}
 			templates = loadTemplates();
 		}
 
@@ -109,11 +128,12 @@ public abstract class Target {
 	 *  to a token type in the generated code.
 	 */
 	public String getTokenTypeAsTargetLabel(Grammar g, int ttype) {
-		String name = g.getTokenDisplayName(ttype);
-		// If name is a literal, return the token type instead
-		if ( name==null || name.charAt(0)=='\'' ) {
+		String name = g.getTokenName(ttype);
+		// If name is not valid, return the token type instead
+		if ( Grammar.INVALID_TOKEN_NAME.equals(name) ) {
 			return String.valueOf(ttype);
 		}
+
 		return name;
 	}
 
@@ -176,15 +196,106 @@ public abstract class Target {
 	}
 
 	/**
-	 * Convert from an ANTLR string literal found in a grammar file to an
+	 * <p>Convert from an ANTLR string literal found in a grammar file to an
 	 * equivalent string literal in the target language.
+	 *</p>
+	 * <p>
+	 * For Java, this is the translation {@code 'a\n"'} &rarr; {@code "a\n\""}.
+	 * Expect single quotes around the incoming literal. Just flip the quotes
+	 * and replace double quotes with {@code \"}.
+	 * </p>
+	 * <p>
+	 * Note that we have decided to allow people to use '\"' without penalty, so
+	 * we must build the target string in a loop as {@link String#replace}
+	 * cannot handle both {@code \"} and {@code "} without a lot of messing
+	 * around.
+	 * </p>
 	 */
-	public abstract String getTargetStringLiteralFromANTLRStringLiteral(
+	public String getTargetStringLiteralFromANTLRStringLiteral(
 		CodeGenerator generator,
-		String literal, boolean addQuotes);
+		String literal,
+		boolean addQuotes)
+	{
+		StringBuilder sb = new StringBuilder();
+		String is = literal;
+
+		if ( addQuotes ) sb.append('"');
+
+		for (int i = 1; i < is.length() -1; i++) {
+			if  (is.charAt(i) == '\\') {
+				// Anything escaped is what it is! We assume that
+				// people know how to escape characters correctly. However
+				// we catch anything that does not need an escape in Java (which
+				// is what the default implementation is dealing with and remove
+				// the escape. The C target does this for instance.
+				//
+				switch (is.charAt(i+1)) {
+					// Pass through any escapes that Java also needs
+					//
+					case    '"':
+					case    'n':
+					case    'r':
+					case    't':
+					case    'b':
+					case    'f':
+					case    '\\':
+						// Pass the escape through
+						sb.append('\\');
+						break;
+
+					case    'u':    // Assume unnnn
+						// Pass the escape through as double \\
+						// so that Java leaves as \u0000 string not char
+						sb.append('\\');
+						sb.append('\\');
+						break;
+
+					default:
+						// Remove the escape by virtue of not adding it here
+						// Thus \' becomes ' and so on
+						break;
+				}
+
+				// Go past the \ character
+				i++;
+			} else {
+				// Characters that don't need \ in ANTLR 'strings' but do in Java
+				if (is.charAt(i) == '"') {
+					// We need to escape " in Java
+					sb.append('\\');
+				}
+			}
+			// Add in the next character, which may have been escaped
+			sb.append(is.charAt(i));
+		}
+
+		if ( addQuotes ) sb.append('"');
+
+		return sb.toString();
+	}
 
 	/** Assume 16-bit char */
-	public abstract String encodeIntAsCharEscape(int v);
+	public String encodeIntAsCharEscape(int v) {
+		if (v < Character.MIN_VALUE || v > Character.MAX_VALUE) {
+			throw new IllegalArgumentException(String.format("Cannot encode the specified value: %d", v));
+		}
+
+		if (v >= 0 && v < targetCharValueEscape.length && targetCharValueEscape[v] != null) {
+			return targetCharValueEscape[v];
+		}
+
+		if (v >= 0x20 && v < 127 && (!Character.isDigit(v) || v == '8' || v == '9')) {
+			return String.valueOf((char)v);
+		}
+
+		if ( v>=0 && v<=127 ) {
+			String oct = Integer.toOctalString(v);
+			return "\\"+ oct;
+		}
+
+		String hex = Integer.toHexString(v|0x10000).substring(1,5);
+		return "\\u"+hex;
+	}
 
 	public String getLoopLabel(GrammarAST ast) {
 		return "loop"+ ast.token.getTokenIndex();
@@ -279,35 +390,43 @@ public abstract class Target {
 		return Integer.MAX_VALUE;
 	}
 
+	/** How many bits should be used to do inline token type tests? Java assumes
+	 *  a 64-bit word for bitsets.  Must be a valid wordsize for your target like
+	 *  8, 16, 32, 64, etc...
+	 *
+	 *  @since 4.5
+	 */
+	public int getInlineTestSetWordSize() { return 64; }
+
 	public boolean grammarSymbolCausesIssueInGeneratedCode(GrammarAST idNode) {
 		switch (idNode.getParent().getType()) {
-		case ANTLRParser.ASSIGN:
-			switch (idNode.getParent().getParent().getType()) {
+			case ANTLRParser.ASSIGN:
+				switch (idNode.getParent().getParent().getType()) {
+					case ANTLRParser.ELEMENT_OPTIONS:
+					case ANTLRParser.OPTIONS:
+						return false;
+
+					default:
+						break;
+				}
+
+				break;
+
+			case ANTLRParser.AT:
 			case ANTLRParser.ELEMENT_OPTIONS:
-			case ANTLRParser.OPTIONS:
 				return false;
 
+			case ANTLRParser.LEXER_ACTION_CALL:
+				if (idNode.getChildIndex() == 0) {
+					// first child is the command name which is part of the ANTLR language
+					return false;
+				}
+
+				// arguments to the command should be checked
+				break;
+
 			default:
 				break;
-			}
-
-			break;
-
-		case ANTLRParser.AT:
-		case ANTLRParser.ELEMENT_OPTIONS:
-			return false;
-
-		case ANTLRParser.LEXER_ACTION_CALL:
-			if (idNode.getChildIndex() == 0) {
-				// first child is the command name which is part of the ANTLR language
-				return false;
-			}
-
-			// arguments to the command should be checked
-			break;
-
-		default:
-			break;
 		}
 
 		return visibleGrammarSymbolCausesIssueInGeneratedCode(idNode);
@@ -315,8 +434,31 @@ public abstract class Target {
 
 	protected abstract boolean visibleGrammarSymbolCausesIssueInGeneratedCode(GrammarAST idNode);
 
+	public boolean templatesExist() {
+		String groupFileName = CodeGenerator.TEMPLATE_ROOT + "/" + getLanguage() + "/" + getLanguage() + STGroup.GROUP_FILE_EXTENSION;
+		STGroup result = null;
+		try {
+			result = new STGroupFile(groupFileName);
+		}
+		catch (IllegalArgumentException iae) {
+			result = null;
+		}
+		return result!=null;
+	}
+
+
 	protected STGroup loadTemplates() {
-		STGroup result = new STGroupFile(CodeGenerator.TEMPLATE_ROOT+"/"+getLanguage()+"/"+getLanguage()+STGroup.GROUP_FILE_EXTENSION);
+		String groupFileName = CodeGenerator.TEMPLATE_ROOT + "/" + getLanguage() + "/" + getLanguage() + STGroup.GROUP_FILE_EXTENSION;
+		STGroup result = null;
+		try {
+			result = new STGroupFile(groupFileName);
+		}
+		catch (IllegalArgumentException iae) {
+			gen.tool.errMgr.toolError(ErrorType.MISSING_CODE_GEN_TEMPLATES,
+						 iae,
+						 language);
+		}
+		if ( result==null ) return null;
 		result.registerRenderer(Integer.class, new NumberRenderer());
 		result.registerRenderer(String.class, new StringRenderer());
 		result.setListener(new STErrorListener() {
@@ -347,4 +489,25 @@ public abstract class Target {
 
 		return result;
 	}
+
+	/**
+	 * @since 4.3
+	 */
+	public boolean wantsBaseListener() {
+		return true;
+	}
+
+	/**
+	 * @since 4.3
+	 */
+	public boolean wantsBaseVisitor() {
+		return true;
+	}
+
+	/**
+	 * @since 4.3
+	 */
+	public boolean supportsOverloadedMethods() {
+		return true;
+	}
 }
diff --git a/tool/src/org/antlr/v4/codegen/model/ElementFrequenciesVisitor.java b/tool/src/org/antlr/v4/codegen/model/ElementFrequenciesVisitor.java
new file mode 100644
index 000000000..2226d3778
--- /dev/null
+++ b/tool/src/org/antlr/v4/codegen/model/ElementFrequenciesVisitor.java
@@ -0,0 +1,166 @@
+package org.antlr.v4.codegen.model;
+
+import org.antlr.runtime.tree.TreeNodeStream;
+import org.antlr.v4.misc.FrequencySet;
+import org.antlr.v4.misc.MutableInt;
+import org.antlr.v4.parse.GrammarTreeVisitor;
+import org.antlr.v4.tool.ErrorManager;
+import org.antlr.v4.tool.ast.ActionAST;
+import org.antlr.v4.tool.ast.AltAST;
+import org.antlr.v4.tool.ast.GrammarAST;
+import org.antlr.v4.tool.ast.TerminalAST;
+
+import java.util.ArrayDeque;
+import java.util.Deque;
+import java.util.Map;
+
+public class ElementFrequenciesVisitor extends GrammarTreeVisitor {
+	final Deque<FrequencySet<String>> frequencies;
+
+	public ElementFrequenciesVisitor(TreeNodeStream input) {
+		super(input);
+		frequencies = new ArrayDeque<FrequencySet<String>>();
+		frequencies.push(new FrequencySet<String>());
+	}
+
+	/** During code gen, we can assume tree is in good shape */
+	@Override
+	public ErrorManager getErrorManager() { return super.getErrorManager(); }
+
+	/*
+	 * Common
+	 */
+
+	/**
+	 * Generate a frequency set as the union of two input sets. If an
+	 * element is contained in both sets, the value for the output will be
+	 * the maximum of the two input values.
+	 *
+	 * @param a The first set.
+	 * @param b The second set.
+	 * @return The union of the two sets, with the maximum value chosen
+	 * whenever both sets contain the same key.
+	 */
+	protected static FrequencySet<String> combineMax(FrequencySet<String> a, FrequencySet<String> b) {
+		FrequencySet<String> result = combineAndClip(a, b, 1);
+		for (Map.Entry<String, MutableInt> entry : a.entrySet()) {
+			result.get(entry.getKey()).v = entry.getValue().v;
+		}
+
+		for (Map.Entry<String, MutableInt> entry : b.entrySet()) {
+			MutableInt slot = result.get(entry.getKey());
+			slot.v = Math.max(slot.v, entry.getValue().v);
+		}
+
+		return result;
+	}
+
+	/**
+	 * Generate a frequency set as the union of two input sets, with the
+	 * values clipped to a specified maximum value. If an element is
+	 * contained in both sets, the value for the output, prior to clipping,
+	 * will be the sum of the two input values.
+	 *
+	 * @param a The first set.
+	 * @param b The second set.
+	 * @param clip The maximum value to allow for any output.
+	 * @return The sum of the two sets, with the individual elements clipped
+	 * to the maximum value gived by {@code clip}.
+	 */
+	protected static FrequencySet<String> combineAndClip(FrequencySet<String> a, FrequencySet<String> b, int clip) {
+		FrequencySet<String> result = new FrequencySet<String>();
+		for (Map.Entry<String, MutableInt> entry : a.entrySet()) {
+			for (int i = 0; i < entry.getValue().v; i++) {
+				result.add(entry.getKey());
+			}
+		}
+
+		for (Map.Entry<String, MutableInt> entry : b.entrySet()) {
+			for (int i = 0; i < entry.getValue().v; i++) {
+				result.add(entry.getKey());
+			}
+		}
+
+		for (Map.Entry<String, MutableInt> entry : result.entrySet()) {
+			entry.getValue().v = Math.min(entry.getValue().v, clip);
+		}
+
+		return result;
+	}
+
+	@Override
+	public void tokenRef(TerminalAST ref) {
+		frequencies.peek().add(ref.getText());
+	}
+
+	@Override
+	public void ruleRef(GrammarAST ref, ActionAST arg) {
+		frequencies.peek().add(ref.getText());
+	}
+
+	/*
+	 * Parser rules
+	 */
+
+	@Override
+	protected void enterAlternative(AltAST tree) {
+		frequencies.push(new FrequencySet<String>());
+	}
+
+	@Override
+	protected void exitAlternative(AltAST tree) {
+		frequencies.push(combineMax(frequencies.pop(), frequencies.pop()));
+	}
+
+	@Override
+	protected void enterElement(GrammarAST tree) {
+		frequencies.push(new FrequencySet<String>());
+	}
+
+	@Override
+	protected void exitElement(GrammarAST tree) {
+		frequencies.push(combineAndClip(frequencies.pop(), frequencies.pop(), 2));
+	}
+
+	@Override
+	protected void exitSubrule(GrammarAST tree) {
+		if (tree.getType() == CLOSURE || tree.getType() == POSITIVE_CLOSURE) {
+			for (Map.Entry<String, MutableInt> entry : frequencies.peek().entrySet()) {
+				entry.getValue().v = 2;
+			}
+		}
+	}
+
+	/*
+	 * Lexer rules
+	 */
+
+	@Override
+	protected void enterLexerAlternative(GrammarAST tree) {
+		frequencies.push(new FrequencySet<String>());
+	}
+
+	@Override
+	protected void exitLexerAlternative(GrammarAST tree) {
+		frequencies.push(combineMax(frequencies.pop(), frequencies.pop()));
+	}
+
+	@Override
+	protected void enterLexerElement(GrammarAST tree) {
+		frequencies.push(new FrequencySet<String>());
+	}
+
+	@Override
+	protected void exitLexerElement(GrammarAST tree) {
+		frequencies.push(combineAndClip(frequencies.pop(), frequencies.pop(), 2));
+	}
+
+	@Override
+	protected void exitLexerSubrule(GrammarAST tree) {
+		if (tree.getType() == CLOSURE || tree.getType() == POSITIVE_CLOSURE) {
+			for (Map.Entry<String, MutableInt> entry : frequencies.peek().entrySet()) {
+				entry.getValue().v = 2;
+			}
+		}
+	}
+}
diff --git a/tool/src/org/antlr/v4/codegen/model/LL1PlusBlock.java b/tool/src/org/antlr/v4/codegen/model/LL1PlusBlock.java
deleted file mode 100644
index 2c4f27aee..000000000
--- a/tool/src/org/antlr/v4/codegen/model/LL1PlusBlock.java
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
- * [The "BSD license"]
- *  Copyright (c) 2012 Terence Parr
- *  Copyright (c) 2012 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.
- */
-
-package org.antlr.v4.codegen.model;
-
-import org.antlr.v4.codegen.CodeGenerator;
-import org.antlr.v4.codegen.OutputModelFactory;
-import org.antlr.v4.runtime.atn.PlusBlockStartState;
-import org.antlr.v4.runtime.misc.IntervalSet;
-import org.antlr.v4.tool.Grammar;
-import org.antlr.v4.tool.ast.GrammarAST;
-
-import java.util.List;
-
-/** */
-public class LL1PlusBlock extends LL1Loop {
-	/** Token names for each alt 0..n-1 */
-	public List<String[]> altLook;
-
-	public String loopLabel;
-	public String loopCounterVar;
-	public String[] exitLook;
-
-	@ModelElement public ThrowNoViableAlt error;
-
-	public LL1PlusBlock(OutputModelFactory factory, GrammarAST plusRoot, List<CodeBlockForAlt> alts) {
-		super(factory, plusRoot, alts);
-
-		PlusBlockStartState blkStart = (PlusBlockStartState)plusRoot.atnState;
-
-		stateNumber = blkStart.loopBackState.stateNumber;
-		blockStartStateNumber = blkStart.stateNumber;
-
-		this.decision = blkStart.decision;
-		Grammar g = factory.getGrammar();
-		CodeGenerator gen = factory.getGenerator();
-		/** Lookahead for each alt 1..n */
-		IntervalSet[] altLookSets = g.decisionLOOK.get(decision);
-		altLook = getAltLookaheadAsStringLists(altLookSets);
-		IntervalSet all = IntervalSet.or(altLookSets);
-
-		this.error = getThrowNoViableAlt(factory, plusRoot, all);
-
-		loopExpr = addCodeForLoopLookaheadTempVar(all);
-
-		loopLabel = gen.getTarget().getLoopLabel(plusRoot);
-		loopCounterVar = gen.getTarget().getLoopCounter(plusRoot);
-
-		IntervalSet exitLookSet = altLookSets[altLookSets.length-1];
-		this.exitLook = gen.getTarget().getTokenTypesAsTargetLabels(g,
-															   exitLookSet.toArray());
-	}
-}
diff --git a/tool/src/org/antlr/v4/codegen/model/LL1PlusBlockSingleAlt.java b/tool/src/org/antlr/v4/codegen/model/LL1PlusBlockSingleAlt.java
index 41723067d..a7076ceff 100644
--- a/tool/src/org/antlr/v4/codegen/model/LL1PlusBlockSingleAlt.java
+++ b/tool/src/org/antlr/v4/codegen/model/LL1PlusBlockSingleAlt.java
@@ -33,16 +33,19 @@ package org.antlr.v4.codegen.model;
 import org.antlr.v4.codegen.OutputModelFactory;
 import org.antlr.v4.runtime.atn.PlusBlockStartState;
 import org.antlr.v4.runtime.misc.IntervalSet;
+import org.antlr.v4.tool.ast.BlockAST;
 import org.antlr.v4.tool.ast.GrammarAST;
 
 import java.util.List;
 
 /** */
 public class LL1PlusBlockSingleAlt extends LL1Loop {
-	public LL1PlusBlockSingleAlt(OutputModelFactory factory, GrammarAST blkAST, List<CodeBlockForAlt> alts) {
-		super(factory, blkAST, alts);
+	public LL1PlusBlockSingleAlt(OutputModelFactory factory, GrammarAST plusRoot, List<CodeBlockForAlt> alts) {
+		super(factory, plusRoot, alts);
 
+		BlockAST blkAST = (BlockAST)plusRoot.getChild(0);
 		PlusBlockStartState blkStart = (PlusBlockStartState)blkAST.atnState;
+
 		stateNumber = blkStart.loopBackState.stateNumber;
 		blockStartStateNumber = blkStart.stateNumber;
 		PlusBlockStartState plus = (PlusBlockStartState)blkAST.atnState;
diff --git a/tool/src/org/antlr/v4/codegen/model/LeftRecursiveRuleFunction.java b/tool/src/org/antlr/v4/codegen/model/LeftRecursiveRuleFunction.java
index a4664949b..adbc3a623 100644
--- a/tool/src/org/antlr/v4/codegen/model/LeftRecursiveRuleFunction.java
+++ b/tool/src/org/antlr/v4/codegen/model/LeftRecursiveRuleFunction.java
@@ -33,6 +33,7 @@ package org.antlr.v4.codegen.model;
 import org.antlr.v4.codegen.CodeGenerator;
 import org.antlr.v4.codegen.OutputModelFactory;
 import org.antlr.v4.codegen.model.decl.RuleContextDecl;
+import org.antlr.v4.codegen.model.decl.RuleContextListDecl;
 import org.antlr.v4.codegen.model.decl.StructDecl;
 import org.antlr.v4.parse.ANTLRParser;
 import org.antlr.v4.runtime.misc.Pair;
@@ -55,7 +56,14 @@ public class LeftRecursiveRuleFunction extends RuleFunction {
 			if ( rrefAST.getType() == ANTLRParser.RULE_REF ) {
 				Rule targetRule = factory.getGrammar().getRule(rrefAST.getText());
 				String ctxName = gen.getTarget().getRuleFunctionContextStructName(targetRule);
-				RuleContextDecl d = new RuleContextDecl(factory,label,ctxName);
+				RuleContextDecl d;
+				if (idAST.getParent().getType() == ANTLRParser.ASSIGN) {
+					d = new RuleContextDecl(factory, label, ctxName);
+				}
+				else {
+					d = new RuleContextListDecl(factory, label, ctxName);
+				}
+
 				StructDecl struct = ruleCtx;
 				if ( altLabelCtxs!=null ) {
 					StructDecl s = altLabelCtxs.get(altLabel);
diff --git a/tool/src/org/antlr/v4/codegen/model/Lexer.java b/tool/src/org/antlr/v4/codegen/model/Lexer.java
index f534cf384..ef44e4c7a 100644
--- a/tool/src/org/antlr/v4/codegen/model/Lexer.java
+++ b/tool/src/org/antlr/v4/codegen/model/Lexer.java
@@ -30,77 +30,29 @@
 
 package org.antlr.v4.codegen.model;
 
-import org.antlr.v4.codegen.CodeGenerator;
 import org.antlr.v4.codegen.OutputModelFactory;
-import org.antlr.v4.codegen.model.chunk.ActionChunk;
-import org.antlr.v4.codegen.model.chunk.ActionText;
-import org.antlr.v4.codegen.model.chunk.DefaultLexerSuperClass;
 import org.antlr.v4.tool.Grammar;
 import org.antlr.v4.tool.LexerGrammar;
 import org.antlr.v4.tool.Rule;
 
-import java.io.File;
 import java.util.Collection;
 import java.util.LinkedHashMap;
 import java.util.Map;
-import java.util.Set;
 
-public class Lexer extends OutputModelObject {
-	public String name;
-	public String grammarFileName;
-	public Map<String,Integer> tokens;
+public class Lexer extends Recognizer {
+	public Map<String,Integer> channels;
 	public LexerFile file;
-	public String[] tokenNames;
-	public Set<String> ruleNames;
 	public Collection<String> modes;
-	@ModelElement public ActionChunk superClass;
 
-	@ModelElement public SerializedATN atn;
 	@ModelElement public LinkedHashMap<Rule, RuleActionFunction> actionFuncs =
 		new LinkedHashMap<Rule, RuleActionFunction>();
-	@ModelElement public LinkedHashMap<Rule, RuleSempredFunction> sempredFuncs =
-		new LinkedHashMap<Rule, RuleSempredFunction>();
 
 	public Lexer(OutputModelFactory factory, LexerFile file) {
-		this.factory = factory;
+		super(factory);
 		this.file = file; // who contains us?
+
 		Grammar g = factory.getGrammar();
-		grammarFileName = new File(g.fileName).getName();
-		name = g.getRecognizerName();
-		tokens = new LinkedHashMap<String,Integer>();
-		LexerGrammar lg = (LexerGrammar)g;
-		atn = new SerializedATN(factory, lg.atn);
-		modes = lg.modes.keySet();
-
-		for (String t : g.tokenNameToTypeMap.keySet()) {
-			Integer ttype = g.tokenNameToTypeMap.get(t);
-			if ( ttype>0 ) tokens.put(t, ttype);
-		}
-
-		tokenNames = g.getTokenDisplayNames();
-        for (int i = 0; i < tokenNames.length; i++) {
-            if ( tokenNames[i]==null ) continue;
-            CodeGenerator gen = factory.getGenerator();
-            if ( tokenNames[i].charAt(0)=='\'' ) {
-				boolean addQuotes = false;
-				tokenNames[i] =
-					gen.getTarget().getTargetStringLiteralFromANTLRStringLiteral(gen,
-																			tokenNames[i],
-																			addQuotes);
-				tokenNames[i] = "\"'"+tokenNames[i]+"'\"";
-            }
-            else {
-                tokenNames[i] = gen.getTarget().getTargetStringLiteralFromString(tokenNames[i], true);
-            }
-        }
-		ruleNames = g.rules.keySet();
-
-		if (g.getOptionString("superClass") != null) {
-			superClass = new ActionText(null, g.getOptionString("superClass"));
-		}
-		else {
-			superClass = new DefaultLexerSuperClass();
-		}
+		channels = new LinkedHashMap<String, Integer>(g.channelNameToValueMap);
+		modes = ((LexerGrammar)g).modes.keySet();
 	}
-
 }
diff --git a/tool/src/org/antlr/v4/codegen/model/ListenerFile.java b/tool/src/org/antlr/v4/codegen/model/ListenerFile.java
index 558c094b9..99f6ebf94 100644
--- a/tool/src/org/antlr/v4/codegen/model/ListenerFile.java
+++ b/tool/src/org/antlr/v4/codegen/model/ListenerFile.java
@@ -30,14 +30,16 @@
 package org.antlr.v4.codegen.model;
 
 import org.antlr.v4.codegen.OutputModelFactory;
-import org.antlr.v4.runtime.misc.Triple;
+import org.antlr.v4.runtime.misc.Pair;
 import org.antlr.v4.tool.Grammar;
 import org.antlr.v4.tool.Rule;
 import org.antlr.v4.tool.ast.ActionAST;
 import org.antlr.v4.tool.ast.AltAST;
 
-import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 
 /** A model object representing a parse tree listener file.
@@ -47,7 +49,16 @@ public class ListenerFile extends OutputFile {
 	public String genPackage; // from -package cmd-line
 	public String grammarName;
 	public String parserName;
-	public Set<String> listenerNames = new HashSet<String>();
+	/**
+	 * The names of all listener contexts.
+	 */
+	public Set<String> listenerNames = new LinkedHashSet<String>();
+	/**
+	 * For listener contexts created for a labeled outer alternative, maps from
+	 * a listener context name to the name of the rule which defines the
+	 * context.
+	 */
+	public Map<String, String> listenerLabelRuleNames = new LinkedHashMap<String, String>();
 
 	@ModelElement public Action header;
 
@@ -57,10 +68,11 @@ public class ListenerFile extends OutputFile {
 		parserName = g.getRecognizerName();
 		grammarName = g.name;
 		for (Rule r : g.rules.values()) {
-			List<Triple<Integer,AltAST,String>> labels = r.getAltLabels();
+			Map<String, List<Pair<Integer,AltAST>>> labels = r.getAltLabels();
 			if ( labels!=null ) {
-				for (Triple<Integer,AltAST,String> pair : labels) {
-					listenerNames.add(pair.c);
+				for (Map.Entry<String, List<Pair<Integer, AltAST>>> pair : labels.entrySet()) {
+					listenerNames.add(pair.getKey());
+					listenerLabelRuleNames.put(pair.getKey(), r.name);
 				}
 			}
 			else {
diff --git a/tool/src/org/antlr/v4/codegen/model/MatchSet.java b/tool/src/org/antlr/v4/codegen/model/MatchSet.java
index 364d7f43f..e6d02a10b 100644
--- a/tool/src/org/antlr/v4/codegen/model/MatchSet.java
+++ b/tool/src/org/antlr/v4/codegen/model/MatchSet.java
@@ -43,7 +43,8 @@ public class MatchSet extends MatchToken {
 	public MatchSet(OutputModelFactory factory, GrammarAST ast) {
 		super(factory, ast);
 		SetTransition st = (SetTransition)ast.atnState.transition(0);
-		expr = new TestSetInline(factory, null, st.set);
+		int wordSize = factory.getGenerator().getTarget().getInlineTestSetWordSize();
+		expr = new TestSetInline(factory, null, st.set, wordSize);
 		Decl d = new TokenTypeDecl(factory, expr.varName);
 		factory.getCurrentRuleFunction().addLocalDecl(d);
 		capture = new CaptureNextTokenType(factory,expr.varName);
diff --git a/tool/src/org/antlr/v4/codegen/model/Parser.java b/tool/src/org/antlr/v4/codegen/model/Parser.java
index 839ceaca5..770d904d0 100644
--- a/tool/src/org/antlr/v4/codegen/model/Parser.java
+++ b/tool/src/org/antlr/v4/codegen/model/Parser.java
@@ -30,75 +30,18 @@
 
 package org.antlr.v4.codegen.model;
 
-import org.antlr.v4.codegen.CodeGenerator;
 import org.antlr.v4.codegen.OutputModelFactory;
-import org.antlr.v4.codegen.model.chunk.ActionChunk;
-import org.antlr.v4.codegen.model.chunk.ActionText;
-import org.antlr.v4.codegen.model.chunk.DefaultParserSuperClass;
-import org.antlr.v4.tool.Grammar;
-import org.antlr.v4.tool.Rule;
 
-import java.io.File;
 import java.util.ArrayList;
-import java.util.Collection;
-import java.util.LinkedHashMap;
 import java.util.List;
-import java.util.Map;
-import java.util.Set;
 
-/** */
-public class Parser extends OutputModelObject {
-	public String name;
-	public String grammarFileName;
-	public String grammarName;
-	@ModelElement public ActionChunk superClass;
-	public Map<String,Integer> tokens;
-	public String[] tokenNames;
-	public Set<String> ruleNames;
-	public Collection<Rule> rules;
+public class Parser extends Recognizer {
 	public ParserFile file;
 
 	@ModelElement public List<RuleFunction> funcs = new ArrayList<RuleFunction>();
-	@ModelElement public SerializedATN atn;
-	@ModelElement public LinkedHashMap<Rule, RuleSempredFunction> sempredFuncs =
-		new LinkedHashMap<Rule, RuleSempredFunction>();
 
 	public Parser(OutputModelFactory factory, ParserFile file) {
-		this.factory = factory;
+		super(factory);
 		this.file = file; // who contains us?
-		Grammar g = factory.getGrammar();
-		grammarFileName = new File(g.fileName).getName();
-		grammarName = g.name;
-		name = g.getRecognizerName();
-		tokens = new LinkedHashMap<String,Integer>();
-		for (String t : g.tokenNameToTypeMap.keySet()) {
-			Integer ttype = g.tokenNameToTypeMap.get(t);
-			if ( ttype>0 ) tokens.put(t, ttype);
-		}
-		tokenNames = g.getTokenDisplayNames();
-		for (int i = 0; i < tokenNames.length; i++) {
-			if ( tokenNames[i]==null ) continue;
-			CodeGenerator gen = factory.getGenerator();
-			if ( tokenNames[i].charAt(0)=='\'' ) {
-				boolean addQuotes = false;
-				tokenNames[i] =
-					gen.getTarget().getTargetStringLiteralFromANTLRStringLiteral(gen,
-																			tokenNames[i],
-																			addQuotes);
-				tokenNames[i] = "\"'"+tokenNames[i]+"'\"";
-			}
-			else {
-				tokenNames[i] = gen.getTarget().getTargetStringLiteralFromString(tokenNames[i], true);
-			}
-		}
-		ruleNames = g.rules.keySet();
-		rules = g.rules.values();
-		atn = new SerializedATN(factory, g.atn);
-		if (g.getOptionString("superClass") != null) {
-			superClass = new ActionText(null, g.getOptionString("superClass"));
-		}
-		else {
-			superClass = new DefaultParserSuperClass();
-		}
 	}
 }
diff --git a/tool/src/org/antlr/v4/codegen/model/ParserFile.java b/tool/src/org/antlr/v4/codegen/model/ParserFile.java
index d1e988ee6..c28616114 100644
--- a/tool/src/org/antlr/v4/codegen/model/ParserFile.java
+++ b/tool/src/org/antlr/v4/codegen/model/ParserFile.java
@@ -31,6 +31,8 @@
 package org.antlr.v4.codegen.model;
 
 import org.antlr.v4.codegen.OutputModelFactory;
+import org.antlr.v4.codegen.model.chunk.ActionChunk;
+import org.antlr.v4.codegen.model.chunk.ActionText;
 import org.antlr.v4.tool.Grammar;
 import org.antlr.v4.tool.ast.ActionAST;
 
@@ -44,6 +46,10 @@ public class ParserFile extends OutputFile {
 	public boolean genVisitor; // from -visitor cmd-line
 	@ModelElement public Parser parser;
 	@ModelElement public Map<String, Action> namedActions;
+	@ModelElement public ActionChunk contextSuperClass;
+	public Boolean genListener = false;
+	public Boolean genVisitor = false;
+	public String grammarName;
 
 	public ParserFile(OutputModelFactory factory, String fileName) {
 		super(factory, fileName);
@@ -53,8 +59,14 @@ public class ParserFile extends OutputFile {
 			ActionAST ast = g.namedActions.get(name);
 			namedActions.put(name, new Action(factory, ast));
 		}
-		genPackage = factory.getGrammar().tool.genPackage;
-		genListener = factory.getGrammar().tool.gen_listener;
-		genVisitor = factory.getGrammar().tool.gen_visitor;
+		genPackage = g.tool.genPackage;
+		// need the below members in the ST for Python, C++
+		genListener = g.tool.gen_listener;
+		genVisitor = g.tool.gen_visitor;
+		grammarName = g.name;
+
+		if (g.getOptionString("contextSuperClass") != null) {
+			contextSuperClass = new ActionText(null, g.getOptionString("contextSuperClass"));
+		}
 	}
 }
diff --git a/tool/src/org/antlr/v4/codegen/model/PlusBlock.java b/tool/src/org/antlr/v4/codegen/model/PlusBlock.java
index 313b29837..a200d30a2 100644
--- a/tool/src/org/antlr/v4/codegen/model/PlusBlock.java
+++ b/tool/src/org/antlr/v4/codegen/model/PlusBlock.java
@@ -33,6 +33,7 @@ package org.antlr.v4.codegen.model;
 import org.antlr.v4.codegen.OutputModelFactory;
 import org.antlr.v4.runtime.atn.PlusBlockStartState;
 import org.antlr.v4.runtime.atn.PlusLoopbackState;
+import org.antlr.v4.tool.ast.BlockAST;
 import org.antlr.v4.tool.ast.GrammarAST;
 
 import java.util.List;
@@ -45,9 +46,9 @@ public class PlusBlock extends Loop {
 					 List<CodeBlockForAlt> alts)
 	{
 		super(factory, plusRoot, alts);
-
-		PlusBlockStartState blkStart = (PlusBlockStartState)plusRoot.atnState;
-		PlusLoopbackState loop = ((PlusBlockStartState)plusRoot.atnState).loopBackState;
+		BlockAST blkAST = (BlockAST)plusRoot.getChild(0);
+		PlusBlockStartState blkStart = (PlusBlockStartState)blkAST.atnState;
+		PlusLoopbackState loop = blkStart.loopBackState;
 		stateNumber = blkStart.loopBackState.stateNumber;
 		blockStartStateNumber = blkStart.stateNumber;
 		loopBackStateNumber = loop.stateNumber;
diff --git a/tool/src/org/antlr/v4/codegen/model/Recognizer.java b/tool/src/org/antlr/v4/codegen/model/Recognizer.java
new file mode 100644
index 000000000..7e3f95beb
--- /dev/null
+++ b/tool/src/org/antlr/v4/codegen/model/Recognizer.java
@@ -0,0 +1,135 @@
+/*
+ * [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.
+ */
+package org.antlr.v4.codegen.model;
+
+import org.antlr.v4.codegen.CodeGenerator;
+import org.antlr.v4.codegen.OutputModelFactory;
+import org.antlr.v4.codegen.model.chunk.ActionChunk;
+import org.antlr.v4.codegen.model.chunk.ActionText;
+import org.antlr.v4.tool.Grammar;
+import org.antlr.v4.tool.Rule;
+
+import java.io.File;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+
+public abstract class Recognizer extends OutputModelObject {
+	public String name;
+	public String grammarName;
+	public String grammarFileName;
+	public Map<String,Integer> tokens;
+
+	/**
+	 * @deprecated This field is provided only for compatibility with code
+	 * generation targets which have not yet been updated to use
+	 * {@link #literalNames} and {@link #symbolicNames}.
+	 */
+	@Deprecated
+	public String[] tokenNames;
+
+	public String[] literalNames;
+	public String[] symbolicNames;
+	public Set<String> ruleNames;
+	public Collection<Rule> rules;
+	@ModelElement public ActionChunk superClass;
+
+	@ModelElement public SerializedATN atn;
+	@ModelElement public LinkedHashMap<Rule, RuleSempredFunction> sempredFuncs =
+		new LinkedHashMap<Rule, RuleSempredFunction>();
+
+	public Recognizer(OutputModelFactory factory) {
+		super(factory);
+
+		Grammar g = factory.getGrammar();
+		grammarFileName = new File(g.fileName).getName();
+		grammarName = g.name;
+		name = g.getRecognizerName();
+		tokens = new LinkedHashMap<String,Integer>();
+		for (Map.Entry<String, Integer> entry : g.tokenNameToTypeMap.entrySet()) {
+			Integer ttype = entry.getValue();
+			if ( ttype>0 ) {
+				tokens.put(entry.getKey(), ttype);
+			}
+		}
+
+		ruleNames = g.rules.keySet();
+		rules = g.rules.values();
+		atn = new SerializedATN(factory, g.atn);
+		if (g.getOptionString("superClass") != null) {
+			superClass = new ActionText(null, g.getOptionString("superClass"));
+		}
+		else {
+			superClass = null;
+		}
+
+		CodeGenerator gen = factory.getGenerator();
+		tokenNames = translateTokenStringsToTarget(g.getTokenDisplayNames(), gen);
+		literalNames = translateTokenStringsToTarget(g.getTokenLiteralNames(), gen);
+		symbolicNames = translateTokenStringsToTarget(g.getTokenSymbolicNames(), gen);
+	}
+
+	protected static String[] translateTokenStringsToTarget(String[] tokenStrings, CodeGenerator gen) {
+		String[] result = tokenStrings.clone();
+		for (int i = 0; i < tokenStrings.length; i++) {
+			result[i] = translateTokenStringToTarget(tokenStrings[i], gen);
+		}
+
+		int lastTrueEntry = result.length - 1;
+		while (lastTrueEntry >= 0 && result[lastTrueEntry] == null) {
+			lastTrueEntry --;
+		}
+
+		if (lastTrueEntry < result.length - 1) {
+			result = Arrays.copyOf(result, lastTrueEntry + 1);
+		}
+
+		return result;
+	}
+
+	protected static String translateTokenStringToTarget(String tokenName, CodeGenerator gen) {
+		if (tokenName == null) {
+			return null;
+		}
+
+		if (tokenName.charAt(0) == '\'') {
+			boolean addQuotes = false;
+			String targetString =
+				gen.getTarget().getTargetStringLiteralFromANTLRStringLiteral(gen, tokenName, addQuotes);
+			return "\"'" + targetString + "'\"";
+		}
+		else {
+			return gen.getTarget().getTargetStringLiteralFromString(tokenName, true);
+		}
+	}
+
+}
diff --git a/tool/src/org/antlr/v4/codegen/model/RuleFunction.java b/tool/src/org/antlr/v4/codegen/model/RuleFunction.java
index 01a41e0c6..25d6d0f79 100644
--- a/tool/src/org/antlr/v4/codegen/model/RuleFunction.java
+++ b/tool/src/org/antlr/v4/codegen/model/RuleFunction.java
@@ -32,9 +32,9 @@ package org.antlr.v4.codegen.model;
 
 import org.antlr.runtime.RecognitionException;
 import org.antlr.runtime.tree.CommonTreeNodeStream;
-import org.antlr.runtime.tree.TreeNodeStream;
 import org.antlr.v4.codegen.OutputModelFactory;
 import org.antlr.v4.codegen.model.decl.AltLabelStructDecl;
+import org.antlr.v4.codegen.model.decl.AttributeDecl;
 import org.antlr.v4.codegen.model.decl.ContextRuleGetterDecl;
 import org.antlr.v4.codegen.model.decl.ContextRuleListGetterDecl;
 import org.antlr.v4.codegen.model.decl.ContextRuleListIndexedGetterDecl;
@@ -44,28 +44,24 @@ import org.antlr.v4.codegen.model.decl.ContextTokenListIndexedGetterDecl;
 import org.antlr.v4.codegen.model.decl.Decl;
 import org.antlr.v4.codegen.model.decl.StructDecl;
 import org.antlr.v4.misc.FrequencySet;
-import org.antlr.v4.misc.MutableInt;
 import org.antlr.v4.misc.Utils;
 import org.antlr.v4.parse.GrammarASTAdaptor;
-import org.antlr.v4.parse.GrammarTreeVisitor;
 import org.antlr.v4.runtime.atn.ATNState;
 import org.antlr.v4.runtime.misc.IntervalSet;
 import org.antlr.v4.runtime.misc.OrderedHashSet;
-import org.antlr.v4.runtime.misc.Triple;
+import org.antlr.v4.runtime.misc.Pair;
 import org.antlr.v4.tool.Attribute;
 import org.antlr.v4.tool.ErrorType;
 import org.antlr.v4.tool.Rule;
 import org.antlr.v4.tool.ast.ActionAST;
 import org.antlr.v4.tool.ast.AltAST;
 import org.antlr.v4.tool.ast.GrammarAST;
-import org.antlr.v4.tool.ast.TerminalAST;
 
-import java.util.ArrayDeque;
 import java.util.ArrayList;
 import java.util.Collection;
-import java.util.Deque;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -82,13 +78,13 @@ public class RuleFunction extends OutputModelObject {
 	public Collection<String> tokenLabels;
 	public ATNState startState;
 	public int index;
-	public Collection<Attribute> args = null;
 	public Rule rule;
 	public AltLabelStructDecl[] altToContext;
 	public boolean hasLookaheadBlock;
 
 	@ModelElement public List<SrcOp> code;
 	@ModelElement public OrderedHashSet<Decl> locals; // TODO: move into ctx?
+	@ModelElement public Collection<AttributeDecl> args = null;
 	@ModelElement public StructDecl ruleCtx;
 	@ModelElement public Map<String,AltLabelStructDecl> altLabelCtxs;
 	@ModelElement public Map<String,Action> namedActions;
@@ -113,9 +109,15 @@ public class RuleFunction extends OutputModelObject {
 		addContextGetters(factory, r);
 
 		if ( r.args!=null ) {
-			ruleCtx.addDecls(r.args.attributes.values());
-			args = r.args.attributes.values();
-			ruleCtx.ctorAttrs = args;
+			Collection<Attribute> decls = r.args.attributes.values();
+			if ( decls.size()>0 ) {
+				args = new ArrayList<AttributeDecl>();
+				ruleCtx.addDecls(decls);
+				for (Attribute a : decls) {
+					args.add(new AttributeDecl(factory, a));
+				}
+				ruleCtx.ctorAttrs = args;
+			}
 		}
 		if ( r.retvals!=null ) {
 			ruleCtx.addDecls(r.retvals.attributes.values());
@@ -149,17 +151,28 @@ public class RuleFunction extends OutputModelObject {
 
 		// make structs for -> labeled alts, define ctx labels for elements
 		altLabelCtxs = new HashMap<String,AltLabelStructDecl>();
-		List<Triple<Integer,AltAST,String>> labels = r.getAltLabels();
+		Map<String, List<Pair<Integer, AltAST>>> labels = r.getAltLabels();
 		if ( labels!=null ) {
-			for (Triple<Integer,AltAST,String> pair : labels) {
-				Integer altNum = pair.a;
-				AltAST altAST = pair.b;
-				String label = pair.c;
-				altToContext[altNum] = new AltLabelStructDecl(factory, r, altNum, label);
-				altLabelCtxs.put(label, altToContext[altNum]);
-				Set<Decl> decls = getDeclsForAltElements(altAST);
-				// we know which ctx to put in, so do it directly
-				for (Decl d : decls) altToContext[altNum].addDecl(d);
+			for (Map.Entry<String, List<Pair<Integer, AltAST>>> entry : labels.entrySet()) {
+				String label = entry.getKey();
+				List<AltAST> alts = new ArrayList<AltAST>();
+				for (Pair<Integer, AltAST> pair : entry.getValue()) {
+					alts.add(pair.b);
+				}
+
+				Set<Decl> decls = getDeclsForAllElements(alts);
+				for (Pair<Integer, AltAST> pair : entry.getValue()) {
+					Integer altNum = pair.a;
+					altToContext[altNum] = new AltLabelStructDecl(factory, r, altNum, label);
+					if (!altLabelCtxs.containsKey(label)) {
+						altLabelCtxs.put(label, altToContext[altNum]);
+					}
+
+					// we know which ctx to put in, so do it directly
+					for (Decl d : decls) {
+						altToContext[altNum].addDecl(d);
+					}
+				}
 			}
 		}
 	}
@@ -195,7 +208,7 @@ public class RuleFunction extends OutputModelObject {
 				}
 			}
 		}
-		Set<Decl> decls = new HashSet<Decl>();
+		Set<Decl> decls = new LinkedHashSet<Decl>();
 		for (GrammarAST t : allRefs) {
 			String refLabelName = t.getText();
 			List<Decl> d = getDeclForAltElement(t,
@@ -217,42 +230,22 @@ public class RuleFunction extends OutputModelObject {
 			}
 
 			return visitor.frequencies.peek();
-		} catch (RecognitionException ex) {
+		}
+		catch (RecognitionException ex) {
 			factory.getGrammar().tool.errMgr.toolError(ErrorType.INTERNAL_ERROR, ex);
 			return new FrequencySet<String>();
 		}
 	}
 
-	/** Get list of decls for token/rule refs.
-	 *  Single ref X becomes X() getter
-	 *  Multiple refs to X becomes List X() method, X(int i) method.
-	 *  Ref X in a loop then we get List X(), X(int i)
-	 *
-	 *  Does not gen labels for literals like '+', 'begin', ';', ...
- 	 */
-	public Set<Decl> getDeclsForAltElements(AltAST altAST) {
-		IntervalSet reftypes = new IntervalSet(RULE_REF,
-											   TOKEN_REF);
-		List<GrammarAST> refs = altAST.getNodesWithType(reftypes);
-		Set<Decl> decls = new HashSet<Decl>();
-		FrequencySet<String> freq = getElementFrequenciesForAlt(altAST);
-		for (GrammarAST t : refs) {
-			String refLabelName = t.getText();
-			boolean needList = freq.count(refLabelName)>1;
-			List<Decl> d = getDeclForAltElement(t, refLabelName, needList);
-			decls.addAll(d);
-		}
-		return decls;
-	}
-
 	public List<Decl> getDeclForAltElement(GrammarAST t, String refLabelName, boolean needList) {
 		List<Decl> decls = new ArrayList<Decl>();
 		if ( t.getType()==RULE_REF ) {
 			Rule rref = factory.getGrammar().getRule(t.getText());
 			String ctxName = factory.getGenerator().getTarget()
 							 .getRuleFunctionContextStructName(rref);
-			if ( needList ) {
-				decls.add( new ContextRuleListGetterDecl(factory, refLabelName, ctxName) );
+			if ( needList) {
+				if(factory.getGenerator().getTarget().supportsOverloadedMethods())
+					decls.add( new ContextRuleListGetterDecl(factory, refLabelName, ctxName) );
 				decls.add( new ContextRuleListIndexedGetterDecl(factory, refLabelName, ctxName) );
 			}
 			else {
@@ -261,7 +254,8 @@ public class RuleFunction extends OutputModelObject {
 		}
 		else {
 			if ( needList ) {
-				decls.add( new ContextTokenListGetterDecl(factory, refLabelName) );
+				if(factory.getGenerator().getTarget().supportsOverloadedMethods())
+					decls.add( new ContextTokenListGetterDecl(factory, refLabelName) );
 				decls.add( new ContextTokenListIndexedGetterDecl(factory, refLabelName) );
 			}
 			else {
@@ -293,129 +287,4 @@ public class RuleFunction extends OutputModelObject {
 		}
 		ruleCtx.addDecl(d); // stick in overall rule's ctx
 	}
-
-	protected static class ElementFrequenciesVisitor extends GrammarTreeVisitor {
-		final Deque<FrequencySet<String>> frequencies;
-
-		public ElementFrequenciesVisitor(TreeNodeStream input) {
-			super(input);
-			frequencies = new ArrayDeque<FrequencySet<String>>();
-			frequencies.push(new FrequencySet<String>());
-		}
-
-		/*
-		 * Common
-		 */
-
-		protected static FrequencySet<String> combineMax(FrequencySet<String> a, FrequencySet<String> b) {
-			FrequencySet<String> result = combineAndClip(a, b, 1);
-			for (Map.Entry<String, MutableInt> entry : a.entrySet()) {
-				result.get(entry.getKey()).v = entry.getValue().v;
-			}
-
-			for (Map.Entry<String, MutableInt> entry : a.entrySet()) {
-				MutableInt slot = result.get(entry.getKey());
-				slot.v = Math.max(slot.v, entry.getValue().v);
-			}
-
-			return result;
-		}
-
-		protected static FrequencySet<String> combineAndClip(FrequencySet<String> a, FrequencySet<String> b, int clip) {
-			FrequencySet<String> result = new FrequencySet<String>();
-			for (Map.Entry<String, MutableInt> entry : a.entrySet()) {
-				for (int i = 0; i < entry.getValue().v; i++) {
-					result.add(entry.getKey());
-				}
-			}
-
-			for (Map.Entry<String, MutableInt> entry : b.entrySet()) {
-				for (int i = 0; i < entry.getValue().v; i++) {
-					result.add(entry.getKey());
-				}
-			}
-
-			for (Map.Entry<String, MutableInt> entry : result.entrySet()) {
-				entry.getValue().v = Math.min(entry.getValue().v, clip);
-			}
-
-			return result;
-		}
-
-		@Override
-		public void tokenRef(TerminalAST ref) {
-			frequencies.peek().add(ref.getText());
-		}
-
-		@Override
-		public void ruleRef(GrammarAST ref, ActionAST arg) {
-			frequencies.peek().add(ref.getText());
-		}
-
-		/*
-		 * Parser rules
-		 */
-
-		@Override
-		protected void enterAlternative(AltAST tree) {
-			frequencies.push(new FrequencySet<String>());
-		}
-
-		@Override
-		protected void exitAlternative(AltAST tree) {
-			frequencies.push(combineMax(frequencies.pop(), frequencies.pop()));
-		}
-
-		@Override
-		protected void enterElement(GrammarAST tree) {
-			frequencies.push(new FrequencySet<String>());
-		}
-
-		@Override
-		protected void exitElement(GrammarAST tree) {
-			frequencies.push(combineAndClip(frequencies.pop(), frequencies.pop(), 2));
-		}
-
-		@Override
-		protected void exitSubrule(GrammarAST tree) {
-			if (tree.getType() == CLOSURE || tree.getType() == POSITIVE_CLOSURE) {
-				for (Map.Entry<String, MutableInt> entry : frequencies.peek().entrySet()) {
-					entry.getValue().v = 2;
-				}
-			}
-		}
-
-		/*
-		 * Lexer rules
-		 */
-
-		@Override
-		protected void enterLexerAlternative(GrammarAST tree) {
-			frequencies.push(new FrequencySet<String>());
-		}
-
-		@Override
-		protected void exitLexerAlternative(GrammarAST tree) {
-			frequencies.push(combineMax(frequencies.pop(), frequencies.pop()));
-		}
-
-		@Override
-		protected void enterLexerElement(GrammarAST tree) {
-			frequencies.push(new FrequencySet<String>());
-		}
-
-		@Override
-		protected void exitLexerElement(GrammarAST tree) {
-			frequencies.push(combineAndClip(frequencies.pop(), frequencies.pop(), 2));
-		}
-
-		@Override
-		protected void exitLexerSubrule(GrammarAST tree) {
-			if (tree.getType() == CLOSURE || tree.getType() == POSITIVE_CLOSURE) {
-				for (Map.Entry<String, MutableInt> entry : frequencies.peek().entrySet()) {
-					entry.getValue().v = 2;
-				}
-			}
-		}
-	}
 }
diff --git a/tool/src/org/antlr/v4/codegen/model/SemPred.java b/tool/src/org/antlr/v4/codegen/model/SemPred.java
index cecfb6f29..605091fa5 100644
--- a/tool/src/org/antlr/v4/codegen/model/SemPred.java
+++ b/tool/src/org/antlr/v4/codegen/model/SemPred.java
@@ -34,6 +34,7 @@ import org.antlr.v4.codegen.ActionTranslator;
 import org.antlr.v4.codegen.CodeGenerator;
 import org.antlr.v4.codegen.OutputModelFactory;
 import org.antlr.v4.codegen.model.chunk.ActionChunk;
+import org.antlr.v4.runtime.atn.AbstractPredicateTransition;
 import org.antlr.v4.tool.ast.ActionAST;
 import org.antlr.v4.tool.ast.GrammarAST;
 
@@ -41,14 +42,35 @@ import java.util.List;
 
 /** */
 public class SemPred extends Action {
-	public String msg;       // user-specified string in fail grammar option
-	public String predicate; // the predicate string with { }? stripped
+	/**
+	 * The user-specified terminal option {@code fail}, if it was used and the
+	 * value is a string literal. For example:
+	 *
+	 * <p>
+	 * {@code {pred}?<fail='message'>}</p>
+	 */
+	public String msg;
+	/**
+	 * The predicate string with <code>{</code> and <code>}?</code> stripped from the ends.
+	 */
+	public String predicate;
 
-	/** user-specified action in fail grammar option */
+	/**
+	 * The translated chunks of the user-specified terminal option {@code fail},
+	 * if it was used and the value is an action. For example:
+	 *
+	 * <p>
+	 * {@code {pred}?<fail={"Java literal"}>}</p>
+	 */
 	@ModelElement public List<ActionChunk> failChunks;
 
 	public SemPred(OutputModelFactory factory, ActionAST ast) {
 		super(factory,ast);
+
+		assert ast.atnState != null
+			&& ast.atnState.getNumberOfTransitions() == 1
+			&& ast.atnState.transition(0) instanceof AbstractPredicateTransition;
+
 		GrammarAST failNode = ast.getOptionAST("fail");
 		CodeGenerator gen = factory.getGenerator();
 		predicate = ast.getText();
diff --git a/tool/src/org/antlr/v4/codegen/model/TestSetInline.java b/tool/src/org/antlr/v4/codegen/model/TestSetInline.java
index 4ea5c900c..0b3956c6c 100644
--- a/tool/src/org/antlr/v4/codegen/model/TestSetInline.java
+++ b/tool/src/org/antlr/v4/codegen/model/TestSetInline.java
@@ -39,25 +39,29 @@ import java.util.List;
 
 /** */
 public class TestSetInline extends SrcOp {
+	public int bitsetWordSize;
 	public String varName;
 	public Bitset[] bitsets;
 
-	public TestSetInline(OutputModelFactory factory, GrammarAST ast, IntervalSet set) {
+	public TestSetInline(OutputModelFactory factory, GrammarAST ast, IntervalSet set, int wordSize) {
 		super(factory, ast);
-
-		Bitset[] withZeroOffset = createBitsets(factory, set, true);
-		Bitset[] withoutZeroOffset = createBitsets(factory, set, false);
+		bitsetWordSize = wordSize;
+		Bitset[] withZeroOffset = createBitsets(factory, set, wordSize, true);
+		Bitset[] withoutZeroOffset = createBitsets(factory, set, wordSize, false);
 		this.bitsets = withZeroOffset.length <= withoutZeroOffset.length ? withZeroOffset : withoutZeroOffset;
 		this.varName = "_la";
 	}
 
-	private static Bitset[] createBitsets(OutputModelFactory factory, IntervalSet set, boolean useZeroOffset) {
+	private static Bitset[] createBitsets(OutputModelFactory factory,
+										  IntervalSet set,
+										  int wordSize,
+										  boolean useZeroOffset) {
 		List<Bitset> bitsetList = new ArrayList<Bitset>();
 		for (int ttype : set.toArray()) {
 			Bitset current = !bitsetList.isEmpty() ? bitsetList.get(bitsetList.size() - 1) : null;
-			if (current == null || ttype > (current.shift + 63)) {
+			if (current == null || ttype > (current.shift + wordSize-1)) {
 				current = new Bitset();
-				if (useZeroOffset && ttype >= 0 && ttype < 63) {
+				if (useZeroOffset && ttype >= 0 && ttype < wordSize-1) {
 					current.shift = 0;
 				}
 				else {
diff --git a/tool/src/org/antlr/v4/codegen/model/VisitorFile.java b/tool/src/org/antlr/v4/codegen/model/VisitorFile.java
index 014e060d3..e1370a9f9 100644
--- a/tool/src/org/antlr/v4/codegen/model/VisitorFile.java
+++ b/tool/src/org/antlr/v4/codegen/model/VisitorFile.java
@@ -30,21 +30,32 @@
 package org.antlr.v4.codegen.model;
 
 import org.antlr.v4.codegen.OutputModelFactory;
-import org.antlr.v4.runtime.misc.Triple;
+import org.antlr.v4.runtime.misc.Pair;
 import org.antlr.v4.tool.Grammar;
 import org.antlr.v4.tool.Rule;
 import org.antlr.v4.tool.ast.ActionAST;
 import org.antlr.v4.tool.ast.AltAST;
 
-import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 
 public class VisitorFile extends OutputFile {
 	public String genPackage; // from -package cmd-line
 	public String grammarName;
 	public String parserName;
-	public Set<String> visitorNames = new HashSet<String>();
+	/**
+	 * The names of all rule contexts which may need to be visited.
+	 */
+	public Set<String> visitorNames = new LinkedHashSet<String>();
+	/**
+	 * For rule contexts created for a labeled outer alternative, maps from
+	 * a listener context name to the name of the rule which defines the
+	 * context.
+	 */
+	public Map<String, String> visitorLabelRuleNames = new LinkedHashMap<String, String>();
 
 	@ModelElement public Action header;
 
@@ -54,10 +65,11 @@ public class VisitorFile extends OutputFile {
 		parserName = g.getRecognizerName();
 		grammarName = g.name;
 		for (Rule r : g.rules.values()) {
-			List<Triple<Integer,AltAST,String>> labels = r.getAltLabels();
+			Map<String, List<Pair<Integer, AltAST>>> labels = r.getAltLabels();
 			if ( labels!=null ) {
-				for (Triple<Integer,AltAST,String> pair : labels) {
-					visitorNames.add(pair.c);
+				for (Map.Entry<String, List<Pair<Integer, AltAST>>> pair : labels.entrySet()) {
+					visitorNames.add(pair.getKey());
+					visitorLabelRuleNames.put(pair.getKey(), r.name);
 				}
 			}
 			else {
diff --git a/tool/src/org/antlr/v4/codegen/model/chunk/DefaultLexerSuperClass.java b/tool/src/org/antlr/v4/codegen/model/chunk/RulePropertyRef_parser.java
similarity index 88%
rename from tool/src/org/antlr/v4/codegen/model/chunk/DefaultLexerSuperClass.java
rename to tool/src/org/antlr/v4/codegen/model/chunk/RulePropertyRef_parser.java
index ab5497a37..a42781033 100644
--- a/tool/src/org/antlr/v4/codegen/model/chunk/DefaultLexerSuperClass.java
+++ b/tool/src/org/antlr/v4/codegen/model/chunk/RulePropertyRef_parser.java
@@ -30,6 +30,11 @@
 
 package org.antlr.v4.codegen.model.chunk;
 
-public class DefaultLexerSuperClass extends ActionChunk {
-	public DefaultLexerSuperClass() { super(null); }
+import org.antlr.v4.codegen.model.decl.StructDecl;
+
+/** */
+public class RulePropertyRef_parser extends RulePropertyRef {
+	public RulePropertyRef_parser(StructDecl ctx, String label) {
+		super(ctx, label);
+	}
 }
diff --git a/tool/src/org/antlr/v4/codegen/model/chunk/DefaultParserSuperClass.java b/tool/src/org/antlr/v4/codegen/model/chunk/ThisRulePropertyRef_parser.java
similarity index 88%
rename from tool/src/org/antlr/v4/codegen/model/chunk/DefaultParserSuperClass.java
rename to tool/src/org/antlr/v4/codegen/model/chunk/ThisRulePropertyRef_parser.java
index 0b7fa4e52..7cbf5d693 100644
--- a/tool/src/org/antlr/v4/codegen/model/chunk/DefaultParserSuperClass.java
+++ b/tool/src/org/antlr/v4/codegen/model/chunk/ThisRulePropertyRef_parser.java
@@ -30,6 +30,11 @@
 
 package org.antlr.v4.codegen.model.chunk;
 
-public class DefaultParserSuperClass extends ActionChunk {
-	public DefaultParserSuperClass() { super(null); }
+import org.antlr.v4.codegen.model.decl.StructDecl;
+
+/** */
+public class ThisRulePropertyRef_parser extends RulePropertyRef {
+	public ThisRulePropertyRef_parser(StructDecl ctx, String label) {
+		super(ctx, label);
+	}
 }
diff --git a/tool/src/org/antlr/v4/codegen/model/decl/AltLabelStructDecl.java b/tool/src/org/antlr/v4/codegen/model/decl/AltLabelStructDecl.java
index 5d49625d3..f48f45d09 100644
--- a/tool/src/org/antlr/v4/codegen/model/decl/AltLabelStructDecl.java
+++ b/tool/src/org/antlr/v4/codegen/model/decl/AltLabelStructDecl.java
@@ -38,7 +38,7 @@ import org.antlr.v4.tool.Rule;
 
 import java.util.ArrayList;
 
-/** A StructDecl to handle a -> label on alt */
+/** A StructDecl to handle a -&gt; label on alt */
 public class AltLabelStructDecl extends StructDecl {
 	public int altNum;
 	public AltLabelStructDecl(OutputModelFactory factory, Rule r,
diff --git a/tool/src/org/antlr/v4/codegen/model/decl/AttributeDecl.java b/tool/src/org/antlr/v4/codegen/model/decl/AttributeDecl.java
index 5086c825e..7b77ecd6e 100644
--- a/tool/src/org/antlr/v4/codegen/model/decl/AttributeDecl.java
+++ b/tool/src/org/antlr/v4/codegen/model/decl/AttributeDecl.java
@@ -31,10 +31,15 @@
 package org.antlr.v4.codegen.model.decl;
 
 import org.antlr.v4.codegen.OutputModelFactory;
+import org.antlr.v4.tool.Attribute;
 
 /** */
 public class AttributeDecl extends Decl {
-	public AttributeDecl(OutputModelFactory factory, String name, String decl) {
-		super(factory, name, decl);
+	public String type;
+	public String initValue;
+	public AttributeDecl(OutputModelFactory factory, Attribute a) {
+		super(factory, a.name, a.decl);
+		this.type = a.type;
+		this.initValue = a.initValue;
 	}
 }
diff --git a/tool/src/org/antlr/v4/codegen/model/decl/StructDecl.java b/tool/src/org/antlr/v4/codegen/model/decl/StructDecl.java
index 7c43a5022..309d6caed 100644
--- a/tool/src/org/antlr/v4/codegen/model/decl/StructDecl.java
+++ b/tool/src/org/antlr/v4/codegen/model/decl/StructDecl.java
@@ -52,7 +52,7 @@ public class StructDecl extends Decl {
 	public boolean provideCopyFrom;
 	@ModelElement public OrderedHashSet<Decl> attrs = new OrderedHashSet<Decl>();
 	@ModelElement public OrderedHashSet<Decl> getters = new OrderedHashSet<Decl>();
-	@ModelElement public Collection<Attribute> ctorAttrs;
+	@ModelElement public Collection<AttributeDecl> ctorAttrs;
 	@ModelElement public List<? super DispatchMethod> dispatchMethods;
 	@ModelElement public List<OutputModelObject> interfaces;
 	@ModelElement public List<OutputModelObject> extensionMembers;
@@ -85,7 +85,7 @@ public class StructDecl extends Decl {
 	}
 
 	public void addDecl(Attribute a) {
-		addDecl(new AttributeDecl(factory, a.name, a.decl));
+		addDecl(new AttributeDecl(factory, a));
 	}
 
 	public void addDecls(Collection<Attribute> attrList) {
diff --git a/tool/src/org/antlr/v4/codegen/target/CSharpTarget.java b/tool/src/org/antlr/v4/codegen/target/CSharpTarget.java
new file mode 100644
index 000000000..b4aa5843a
--- /dev/null
+++ b/tool/src/org/antlr/v4/codegen/target/CSharpTarget.java
@@ -0,0 +1,177 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2013 Terence Parr
+ *  Copyright (c) 2013 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.
+ */
+package org.antlr.v4.codegen.target;
+
+import org.antlr.v4.codegen.CodeGenerator;
+import org.antlr.v4.codegen.Target;
+import org.antlr.v4.tool.ErrorType;
+import org.antlr.v4.tool.ast.GrammarAST;
+import org.stringtemplate.v4.NumberRenderer;
+import org.stringtemplate.v4.STErrorListener;
+import org.stringtemplate.v4.STGroup;
+import org.stringtemplate.v4.STGroupFile;
+import org.stringtemplate.v4.StringRenderer;
+import org.stringtemplate.v4.misc.STMessage;
+
+public class CSharpTarget extends Target {
+
+	public CSharpTarget(CodeGenerator gen) {
+		super(gen, "CSharp");
+		targetCharValueEscape[0] = "\\0";
+		targetCharValueEscape[0x0007] = "\\a";
+		targetCharValueEscape[0x000B] = "\\v";
+	}
+
+    @Override
+    public String getVersion() {
+        return "4.5.3";
+    }
+
+	@Override
+	public String encodeIntAsCharEscape(int v) {
+		if (v < Character.MIN_VALUE || v > Character.MAX_VALUE) {
+			throw new IllegalArgumentException(String.format("Cannot encode the specified value: %d", v));
+		}
+
+		if (v >= 0 && v < targetCharValueEscape.length && targetCharValueEscape[v] != null) {
+			return targetCharValueEscape[v];
+		}
+
+		if (v >= 0x20 && v < 127 && (v < '0' || v > '9') && (v < 'a' || v > 'f') && (v < 'A' || v > 'F')) {
+			return String.valueOf((char)v);
+		}
+
+		return String.format("\\x%X", v & 0xFFFF);
+	}
+
+	@Override
+	public String getTargetStringLiteralFromANTLRStringLiteral(
+		CodeGenerator generator,
+		String literal, boolean addQuotes)
+	{
+		StringBuilder sb = new StringBuilder();
+		String is = literal;
+
+		if ( addQuotes ) sb.append('"');
+
+		for (int i = 1; i < is.length() -1; i++) {
+			if  (is.charAt(i) == '\\') {
+				// Anything escaped is what it is! We assume that
+				// people know how to escape characters correctly. However
+				// we catch anything that does not need an escape in Java (which
+				// is what the default implementation is dealing with and remove
+				// the escape. The C target does this for instance.
+				//
+				switch (is.charAt(i+1)) {
+					// Pass through any escapes that Java also needs
+					//
+					case    '"':
+					case    'n':
+					case    'r':
+					case    't':
+					case    'b':
+					case    'f':
+					case    '\\':
+						// Pass the escape through
+						sb.append('\\');
+						break;
+
+					case    'u':    // Assume unnnn
+						// Pass the escape through as double \\
+						// so that Java leaves as \u0000 string not char
+						sb.append('\\');
+						sb.append('\\');
+						break;
+
+					default:
+						// Remove the escape by virtue of not adding it here
+						// Thus \' becomes ' and so on
+						break;
+				}
+
+				// Go past the \ character
+				i++;
+			} else {
+				// Characters that don't need \ in ANTLR 'strings' but do in Java
+				if (is.charAt(i) == '"') {
+					// We need to escape " in Java
+					sb.append('\\');
+				}
+			}
+			// Add in the next character, which may have been escaped
+			sb.append(is.charAt(i));
+		}
+
+		if ( addQuotes ) sb.append('"');
+
+		return sb.toString();
+	}
+
+	@Override
+	protected boolean visibleGrammarSymbolCausesIssueInGeneratedCode(GrammarAST idNode) {
+		return false;
+	}
+
+	@Override
+	protected STGroup loadTemplates() {
+		// override the superclass behavior to put all C# templates in the same folder
+		STGroup result = new STGroupFile(CodeGenerator.TEMPLATE_ROOT+"/CSharp/"+getLanguage()+STGroup.GROUP_FILE_EXTENSION);
+		result.registerRenderer(Integer.class, new NumberRenderer());
+		result.registerRenderer(String.class, new StringRenderer());
+		result.setListener(new STErrorListener() {
+			@Override
+			public void compileTimeError(STMessage msg) {
+				reportError(msg);
+			}
+
+			@Override
+			public void runTimeError(STMessage msg) {
+				reportError(msg);
+			}
+
+			@Override
+			public void IOError(STMessage msg) {
+				reportError(msg);
+			}
+
+			@Override
+			public void internalError(STMessage msg) {
+				reportError(msg);
+			}
+
+			private void reportError(STMessage msg) {
+				getCodeGenerator().tool.errMgr.toolError(ErrorType.STRING_TEMPLATE_WARNING, msg.cause, msg.toString());
+			}
+		});
+
+		return result;
+	}
+
+}
diff --git a/tool/src/org/antlr/v4/codegen/target/CppTarget.java b/tool/src/org/antlr/v4/codegen/target/CppTarget.java
new file mode 100644
index 000000000..d950bb992
--- /dev/null
+++ b/tool/src/org/antlr/v4/codegen/target/CppTarget.java
@@ -0,0 +1,242 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2016 David Sisson, Mike Lischke
+ *  Copyright (c) 2012 Terence Parr
+ *  Copyright (c) 2012 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.
+ */
+
+package org.antlr.v4.codegen.target;
+
+import org.antlr.v4.codegen.CodeGenerator;
+import org.antlr.v4.codegen.Target;
+import org.antlr.v4.tool.ErrorType;
+import org.antlr.v4.tool.Grammar;
+import org.antlr.v4.tool.ast.GrammarAST;
+import org.stringtemplate.v4.NumberRenderer;
+import org.stringtemplate.v4.STErrorListener;
+import org.stringtemplate.v4.ST;
+import org.stringtemplate.v4.STGroup;
+import org.stringtemplate.v4.STGroupFile;
+import org.stringtemplate.v4.StringRenderer;
+import org.stringtemplate.v4.misc.STMessage;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Locale;
+import java.util.Set;
+
+public class CppTarget extends Target {
+
+	protected static final String[] cppKeywords = {
+		"alignas", "alignof", "and", "and_eq", "asm", "auto", "bitand",
+		"bitor", "bool", "break", "case", "catch", "char", "char16_t",
+		"char32_t", "class", "compl", "concept", "const", "constexpr",
+		"const_cast", "continue", "decltype", "default", "delete", "do",
+		"double", "dynamic_cast", "else", "enum", "explicit", "export",
+		"extern", "false", "float", "for", "friend", "goto", "if",
+		"inline", "int", "long", "mutable", "namespace", "new",
+        "noexcept", "not", "not_eq", "nullptr", "operator", "or",
+        "or_eq", "private", "protected", "public", "register",
+        "reinterpret_cast", "requires", "return", "short", "signed",
+        "sizeof", "static", "static_assert", "static_cast", "struct",
+        "switch", "template", "this", "thread_local", "throw", "true",
+        "try", "typedef", "typeid", "typename", "union", "unsigned",
+        "using", "virtual", "void", "volatile", "wchar_t", "while",
+        "xor", "xor_eq"
+	};
+
+	/** Avoid grammar symbols in this set to prevent conflicts in gen'd code. */
+	protected final Set<String> badWords = new HashSet<String>();
+
+	public CppTarget(CodeGenerator gen) {
+		super(gen, "Cpp");
+	}
+
+	public String getVersion() {
+		return "4.5.2";
+	}
+
+    public boolean needsHeader() { return true; }
+
+	public Set<String> getBadWords() {
+		if (badWords.isEmpty()) {
+			addBadWords();
+		}
+
+		return badWords;
+	}
+
+	protected void addBadWords() {
+		badWords.addAll(Arrays.asList(cppKeywords));
+		badWords.add("rule");
+		badWords.add("parserRule");
+	}
+
+	/**
+	 * {@inheritDoc}
+	 * <p/>
+	 * For C++, this is the translation {@code 'a\n"'} &rarr; {@code "a\n\""}.
+	 * Expect single quotes around the incoming literal. Just flip the quotes
+	 * and replace double quotes with {@code \"}.
+	 * <p/>
+	 * Note that we have decided to allow people to use '\"' without penalty, so
+	 * we must build the target string in a loop as {@link String#replace}
+	 * cannot handle both {@code \"} and {@code "} without a lot of messing
+	 * around.
+	 */
+	@Override
+	public String getTargetStringLiteralFromANTLRStringLiteral(
+		CodeGenerator generator,
+		String literal, boolean addQuotes)
+	{
+		StringBuilder sb = new StringBuilder();
+		String is = literal;
+
+		if ( addQuotes ) sb.append('"');
+
+		for (int i = 1; i < is.length() -1; i++) {
+			if  (is.charAt(i) == '\\') {
+				// Anything escaped is what it is! We assume that
+				// people know how to escape characters correctly. However
+				// we catch anything that does not need an escape in Java (which
+				// is what the default implementation is dealing with and remove
+				// the escape. The C target does this for instance.
+				//
+				switch (is.charAt(i+1)) {
+					// Pass through any escapes that Java also needs
+					//
+					case    '"':
+					case    'n':
+					case    'r':
+					case    't':
+					case    'b':
+					case    'f':
+					case    '\\':
+						// Pass the escape through
+						sb.append('\\');
+						break;
+
+					case    'u':    // Assume unnnn
+						// Pass the escape through as double \\
+						// so that Java leaves as \u0000 string not char
+						sb.append('\\');
+						sb.append('\\');
+						break;
+
+					default:
+						// Remove the escape by virtue of not adding it here
+						// Thus \' becomes ' and so on
+						break;
+				}
+
+				// Go past the \ character
+				i++;
+			} else {
+				// Characters that don't need \ in ANTLR 'strings' but do in Java
+				if (is.charAt(i) == '"') {
+					// We need to escape " in Java
+					sb.append('\\');
+				}
+			}
+			// Add in the next character, which may have been escaped
+			sb.append(is.charAt(i));
+		}
+
+		if ( addQuotes ) sb.append('"');
+
+		return sb.toString();
+	}
+
+	@Override
+	public String encodeIntAsCharEscape(int v) {
+		if (v < Character.MIN_VALUE || v > Character.MAX_VALUE) {
+			throw new IllegalArgumentException(String.format("Cannot encode the specified value: %d", v));
+		}
+
+		if (v >= 0 && v < targetCharValueEscape.length && targetCharValueEscape[v] != null) {
+			return targetCharValueEscape[v];
+		}
+
+		if (v >= 0x20 && v < 127 && (!Character.isDigit(v) || v == '8' || v == '9')) {
+			return String.valueOf((char)v);
+		}
+
+		if ( v>=0 && v<=127 ) {
+			String oct = Integer.toOctalString(v);
+			return "\\"+ oct;
+		}
+
+		String hex = Integer.toHexString(v | 0x10000).substring(1, 5);
+		return "\\u" + hex;
+	}
+
+	@Override
+	public int getSerializedATNSegmentLimit() {
+		// 65535 is the class file format byte limit for a UTF-8 encoded string literal
+		// 3 is the maximum number of bytes it takes to encode a value in the range 0-0xFFFF
+		return 65535 / 3;
+	}
+
+	@Override
+	protected boolean visibleGrammarSymbolCausesIssueInGeneratedCode(GrammarAST idNode) {
+		return getBadWords().contains(idNode.getText());
+	}
+
+	@Override
+	protected STGroup loadTemplates() {
+		STGroup result = super.loadTemplates();
+		result.registerRenderer(Integer.class, new NumberRenderer());
+		result.registerRenderer(String.class, new StringRenderer());
+		result.setListener(new STErrorListener() {
+			@Override
+			public void compileTimeError(STMessage msg) {
+				reportError(msg);
+			}
+
+			@Override
+			public void runTimeError(STMessage msg) {
+				reportError(msg);
+			}
+
+			@Override
+			public void IOError(STMessage msg) {
+				reportError(msg);
+			}
+
+			@Override
+			public void internalError(STMessage msg) {
+				reportError(msg);
+			}
+
+			private void reportError(STMessage msg) {
+				getCodeGenerator().tool.errMgr.toolError(ErrorType.STRING_TEMPLATE_WARNING, msg.cause, msg.toString());
+			}
+		});
+
+		return result;
+	}
+}
diff --git a/tool/src/org/antlr/v4/codegen/JavaTarget.java b/tool/src/org/antlr/v4/codegen/target/JavaScriptTarget.java
similarity index 77%
rename from tool/src/org/antlr/v4/codegen/JavaTarget.java
rename to tool/src/org/antlr/v4/codegen/target/JavaScriptTarget.java
index 5d112c8d9..964837626 100644
--- a/tool/src/org/antlr/v4/codegen/JavaTarget.java
+++ b/tool/src/org/antlr/v4/codegen/target/JavaScriptTarget.java
@@ -28,8 +28,10 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-package org.antlr.v4.codegen;
+package org.antlr.v4.codegen.target;
 
+import org.antlr.v4.codegen.CodeGenerator;
+import org.antlr.v4.codegen.Target;
 import org.antlr.v4.tool.ast.GrammarAST;
 import org.stringtemplate.v4.STGroup;
 import org.stringtemplate.v4.StringRenderer;
@@ -41,29 +43,41 @@ import java.util.Set;
 
 /**
  *
- * @author Sam Harwell
+ * @author Eric Vergnaud
  */
-public class JavaTarget extends Target {
+public class JavaScriptTarget extends Target {
 
-	protected static final String[] javaKeywords = {
-		"abstract", "assert", "boolean", "break", "byte", "case", "catch",
-		"char", "class", "const", "continue", "default", "do", "double", "else",
-		"enum", "extends", "false", "final", "finally", "float", "for",
-		"if", "implements", "import", "instanceof", "int", "interface",
-		"long", "native", "new", "null", "package", "private", "protected",
-		"public", "return", "short", "static", "strictfp", "super", "switch",
-		"synchronized", "this", "throw", "throws", "transient", "true", "try",
-		"void", "volatile", "while"
+	/** Source: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar */
+	protected static final String[] javaScriptKeywords = {
+		"break", "case", "class", "catch", "const", "continue", "debugger",
+		"default", "delete", "do", "else", "export", "extends", "finally", "for",
+		"function", "if", "import", "in", "instanceof", "let", "new", "return",
+		"super", "switch", "this", "throw", "try", "typeof", "var", "void",
+		"while", "with", "yield",
+		//future reserved
+		"enum", "await", "implements", "package", "protected", "static",
+		"interface", "private", "public",
+		//future reserved in older standards
+		"abstract", "boolean", "byte", "char", "double", "final", "float",
+		"goto", "int", "long", "native", "short", "synchronized", "transient",
+		"volatile",
+		//literals
+		"null", "true", "false"
 	};
 
 	/** Avoid grammar symbols in this set to prevent conflicts in gen'd code. */
 	protected final Set<String> badWords = new HashSet<String>();
 
-	public JavaTarget(CodeGenerator gen) {
-		super(gen, "Java");
+	public JavaScriptTarget(CodeGenerator gen) {
+		super(gen, "JavaScript");
 	}
 
-	public Set<String> getBadWords() {
+    @Override
+    public String getVersion() {
+        return "4.5.3";
+    }
+
+    public Set<String> getBadWords() {
 		if (badWords.isEmpty()) {
 			addBadWords();
 		}
@@ -72,18 +86,18 @@ public class JavaTarget extends Target {
 	}
 
 	protected void addBadWords() {
-		badWords.addAll(Arrays.asList(javaKeywords));
+		badWords.addAll(Arrays.asList(javaScriptKeywords));
 		badWords.add("rule");
 		badWords.add("parserRule");
 	}
 
 	/**
 	 * {@inheritDoc}
-	 * <p/>
+	 * <p>
 	 * For Java, this is the translation {@code 'a\n"'} &rarr; {@code "a\n\""}.
 	 * Expect single quotes around the incoming literal. Just flip the quotes
 	 * and replace double quotes with {@code \"}.
-	 * <p/>
+	 * <p>
 	 * Note that we have decided to allow people to use '\"' without penalty, so
 	 * we must build the target string in a loop as {@link String#replace}
 	 * cannot handle both {@code \"} and {@code "} without a lot of messing
@@ -162,24 +176,22 @@ public class JavaTarget extends Target {
 			return targetCharValueEscape[v];
 		}
 
-		if (v >= 0x20 && v < 127 && (!Character.isDigit(v) || v == '8' || v == '9')) {
+		if (v >= 0x20 && v < 127) {
 			return String.valueOf((char)v);
 		}
 
-		if ( v>=0 && v<=127 ) {
-			String oct = Integer.toOctalString(v);
-			return "\\"+ oct;
-		}
-
 		String hex = Integer.toHexString(v|0x10000).substring(1,5);
 		return "\\u"+hex;
 	}
 
 	@Override
 	public int getSerializedATNSegmentLimit() {
-		// 65535 is the class file format byte limit for a UTF-8 encoded string literal
-		// 3 is the maximum number of bytes it takes to encode a value in the range 0-0xFFFF
-		return 65535 / 3;
+		return 2 ^ 31;
+	}
+
+	@Override
+	public int getInlineTestSetWordSize() {
+		return 32;
 	}
 
 	@Override
@@ -207,4 +219,16 @@ public class JavaTarget extends Target {
 		}
 
 	}
+
+	public boolean wantsBaseListener() {
+		return false;
+	}
+
+	public boolean wantsBaseVisitor() {
+		return false;
+	}
+
+	public boolean supportsOverloadedMethods() {
+		return false;
+	}
 }
diff --git a/tool/src/org/antlr/v4/codegen/target/JavaTarget.java b/tool/src/org/antlr/v4/codegen/target/JavaTarget.java
new file mode 100644
index 000000000..6ee18da0b
--- /dev/null
+++ b/tool/src/org/antlr/v4/codegen/target/JavaTarget.java
@@ -0,0 +1,126 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2012 Terence Parr
+ *  Copyright (c) 2012 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.
+ */
+
+package org.antlr.v4.codegen.target;
+
+import org.antlr.v4.Tool;
+import org.antlr.v4.codegen.CodeGenerator;
+import org.antlr.v4.codegen.Target;
+import org.antlr.v4.tool.ast.GrammarAST;
+import org.stringtemplate.v4.STGroup;
+import org.stringtemplate.v4.StringRenderer;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Locale;
+import java.util.Set;
+
+public class JavaTarget extends Target {
+
+	/**
+	 * The Java target can cache the code generation templates.
+	 */
+	private static final ThreadLocal<STGroup> targetTemplates = new ThreadLocal<STGroup>();
+
+	protected static final String[] javaKeywords = {
+		"abstract", "assert", "boolean", "break", "byte", "case", "catch",
+		"char", "class", "const", "continue", "default", "do", "double", "else",
+		"enum", "extends", "false", "final", "finally", "float", "for", "goto",
+		"if", "implements", "import", "instanceof", "int", "interface",
+		"long", "native", "new", "null", "package", "private", "protected",
+		"public", "return", "short", "static", "strictfp", "super", "switch",
+		"synchronized", "this", "throw", "throws", "transient", "true", "try",
+		"void", "volatile", "while"
+	};
+
+	/** Avoid grammar symbols in this set to prevent conflicts in gen'd code. */
+	protected final Set<String> badWords = new HashSet<String>();
+
+	public JavaTarget(CodeGenerator gen) {
+		super(gen, "Java");
+	}
+
+    @Override
+    public String getVersion() {
+        return Tool.VERSION; // Java and tool versions move in lock step
+    }
+
+    public Set<String> getBadWords() {
+		if (badWords.isEmpty()) {
+			addBadWords();
+		}
+
+		return badWords;
+	}
+
+	protected void addBadWords() {
+		badWords.addAll(Arrays.asList(javaKeywords));
+		badWords.add("rule");
+		badWords.add("parserRule");
+	}
+
+	@Override
+	public int getSerializedATNSegmentLimit() {
+		// 65535 is the class file format byte limit for a UTF-8 encoded string literal
+		// 3 is the maximum number of bytes it takes to encode a value in the range 0-0xFFFF
+		return 65535 / 3;
+	}
+
+	@Override
+	protected boolean visibleGrammarSymbolCausesIssueInGeneratedCode(GrammarAST idNode) {
+		return getBadWords().contains(idNode.getText());
+	}
+
+	@Override
+	protected STGroup loadTemplates() {
+		STGroup result = targetTemplates.get();
+		if (result == null) {
+			result = super.loadTemplates();
+			result.registerRenderer(String.class, new JavaStringRenderer(), true);
+			targetTemplates.set(result);
+		}
+
+		return result;
+	}
+
+	protected static class JavaStringRenderer extends StringRenderer {
+
+		@Override
+		public String toString(Object o, String formatString, Locale locale) {
+			if ("java-escape".equals(formatString)) {
+				// 5C is the hex code for the \ itself
+				return ((String)o).replace("\\u", "\\u005Cu");
+			}
+
+			return super.toString(o, formatString, locale);
+		}
+
+	}
+}
diff --git a/tool/src/org/antlr/v4/codegen/target/Python2Target.java b/tool/src/org/antlr/v4/codegen/target/Python2Target.java
new file mode 100644
index 000000000..c80949af2
--- /dev/null
+++ b/tool/src/org/antlr/v4/codegen/target/Python2Target.java
@@ -0,0 +1,136 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2012 Terence Parr
+ *  Copyright (c) 2012 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.
+ */
+
+package org.antlr.v4.codegen.target;
+
+import org.antlr.v4.codegen.CodeGenerator;
+import org.antlr.v4.codegen.Target;
+import org.antlr.v4.tool.ast.GrammarAST;
+import org.stringtemplate.v4.STGroup;
+import org.stringtemplate.v4.StringRenderer;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Locale;
+import java.util.Set;
+
+/**
+ *
+ * @author Eric Vergnaud
+ */
+public class Python2Target extends Target {
+	protected static final String[] python2Keywords = {
+		"abs", "all", "any", "apply", "as",
+		"bin", "bool", "buffer", "bytearray",
+		"callable", "chr", "classmethod", "coerce", "compile", "complex",
+		"del", "delattr", "dict", "dir", "divmod",
+		"enumerate", "eval", "execfile",
+		"file", "filter", "float", "format", "frozenset",
+		"getattr", "globals",
+		"hasattr", "hash", "help", "hex",
+		"id", "input", "int", "intern", "isinstance", "issubclass", "iter",
+		"len", "list", "locals",
+		"map", "max", "min", "next",
+		"memoryview",
+		"object", "oct", "open", "ord",
+		"pow", "print", "property",
+		"range", "raw_input", "reduce", "reload", "repr", "return", "reversed", "round",
+		"set", "setattr", "slice", "sorted", "staticmethod", "str", "sum", "super",
+		"tuple", "type",
+		"unichr", "unicode",
+		"vars",
+		"with",
+		"xrange",
+		"zip",
+		"__import__",
+		"True", "False", "None"
+	};
+
+	/** Avoid grammar symbols in this set to prevent conflicts in gen'd code. */
+	protected final Set<String> badWords = new HashSet<String>();
+
+	public Python2Target(CodeGenerator gen) {
+		super(gen, "Python2");
+	}
+
+	@Override
+	protected boolean visibleGrammarSymbolCausesIssueInGeneratedCode(GrammarAST idNode) {
+		return getBadWords().contains(idNode.getText());
+	}
+
+	@Override
+	protected STGroup loadTemplates() {
+		STGroup result = super.loadTemplates();
+		result.registerRenderer(String.class, new PythonStringRenderer(), true);
+		return result;
+	}
+
+	protected static class PythonStringRenderer extends StringRenderer {
+
+		@Override
+		public String toString(Object o, String formatString, Locale locale) {
+			return super.toString(o, formatString, locale);
+		}
+	}
+
+	@Override
+	public boolean wantsBaseListener() {
+		return false;
+	}
+
+	@Override
+	public boolean wantsBaseVisitor() {
+		return false;
+	}
+
+	@Override
+	public boolean supportsOverloadedMethods() {
+		return false;
+	}
+
+	@Override
+	public String getVersion() {
+		return "4.5.3";
+	}
+
+	public Set<String> getBadWords() {
+		if (badWords.isEmpty()) {
+			addBadWords();
+		}
+
+		return badWords;
+	}
+
+	protected void addBadWords() {
+		badWords.addAll(Arrays.asList(python2Keywords));
+		badWords.add("rule");
+		badWords.add("parserRule");
+	}
+}
diff --git a/tool/src/org/antlr/v4/codegen/target/Python3Target.java b/tool/src/org/antlr/v4/codegen/target/Python3Target.java
new file mode 100644
index 000000000..f70d2a27e
--- /dev/null
+++ b/tool/src/org/antlr/v4/codegen/target/Python3Target.java
@@ -0,0 +1,143 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2012 Terence Parr
+ *  Copyright (c) 2012 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.
+ */
+
+package org.antlr.v4.codegen.target;
+
+import org.antlr.v4.codegen.CodeGenerator;
+import org.antlr.v4.codegen.Target;
+import org.antlr.v4.tool.ast.GrammarAST;
+import org.stringtemplate.v4.STGroup;
+import org.stringtemplate.v4.StringRenderer;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Locale;
+import java.util.Set;
+
+/**
+ *
+ * @author Eric Vergnaud
+ */
+public class Python3Target extends Target {
+	protected static final String[] python3Keywords = {
+		"abs", "all", "any", "apply", "as",
+		"bin", "bool", "buffer", "bytearray",
+		"callable", "chr", "classmethod", "coerce", "compile", "complex",
+		"del", "delattr", "dict", "dir", "divmod",
+		"enumerate", "eval", "execfile",
+		"file", "filter", "float", "format", "frozenset",
+		"getattr", "globals",
+		"hasattr", "hash", "help", "hex",
+		"id", "input", "int", "intern", "isinstance", "issubclass", "iter",
+		"len", "list", "locals",
+		"map", "max", "min", "next",
+		"memoryview",
+		"object", "oct", "open", "ord",
+		"pow", "print", "property",
+		"range", "raw_input", "reduce", "reload", "repr", "return", "reversed", "round",
+		"set", "setattr", "slice", "sorted", "staticmethod", "str", "sum", "super",
+		"tuple", "type",
+		"unichr", "unicode",
+		"vars",
+		"with",
+		"zip",
+		"__import__",
+		"True", "False", "None"
+	};
+
+	public Python3Target(CodeGenerator gen) {
+		super(gen, "Python3");
+	}
+
+	@Override
+	public int getSerializedATNSegmentLimit() {
+		// set to something stupid to avoid segmentation
+		return 2 ^ 31;
+	}
+
+	@Override
+	protected boolean visibleGrammarSymbolCausesIssueInGeneratedCode(GrammarAST idNode) {
+		return getBadWords().contains(idNode.getText());
+	}
+
+	@Override
+	protected STGroup loadTemplates() {
+		STGroup result = super.loadTemplates();
+		result.registerRenderer(String.class, new PythonStringRenderer(), true);
+		return result;
+	}
+
+	protected static class PythonStringRenderer extends StringRenderer {
+
+		@Override
+		public String toString(Object o, String formatString, Locale locale) {
+			return super.toString(o, formatString, locale);
+		}
+	}
+
+	@Override
+	public boolean wantsBaseListener() {
+		return false;
+	}
+
+	@Override
+	public boolean wantsBaseVisitor() {
+		return false;
+	}
+
+	@Override
+	public boolean supportsOverloadedMethods() {
+		return false;
+	}
+
+	@Override
+	public String getVersion() {
+		return "4.5.3";
+	}
+
+	/** Avoid grammar symbols in this set to prevent conflicts in gen'd code. */
+	protected final Set<String> badWords = new HashSet<String>();
+
+	public Set<String> getBadWords() {
+		if (badWords.isEmpty()) {
+			addBadWords();
+		}
+
+		return badWords;
+	}
+
+	protected void addBadWords() {
+		badWords.addAll(Arrays.asList(python3Keywords));
+		badWords.add("rule");
+		badWords.add("parserRule");
+	}
+
+
+}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/tree/gui/BasicFontMetrics.java b/tool/src/org/antlr/v4/gui/BasicFontMetrics.java
similarity index 94%
rename from runtime/Java/src/org/antlr/v4/runtime/tree/gui/BasicFontMetrics.java
rename to tool/src/org/antlr/v4/gui/BasicFontMetrics.java
index 037fbfc8c..b424a003a 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/tree/gui/BasicFontMetrics.java
+++ b/tool/src/org/antlr/v4/gui/BasicFontMetrics.java
@@ -28,7 +28,7 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-package org.antlr.v4.runtime.tree.gui;
+package org.antlr.v4.gui;
 
 /** Font metrics.  The only way to generate accurate images
  *  in any format that contain text is to know the font metrics.
@@ -39,7 +39,7 @@ package org.antlr.v4.runtime.tree.gui;
  *  for trees. Commands:
  *
  * <pre>
- *	 $ ttf2tfm /Library/Fonts/Arial\ Black.ttf > metrics
+ *	 $ ttf2tfm /Library/Fonts/Arial\ Black.ttf &gt; metrics
  * </pre>
  *
  * 	Then run metrics into python code after stripping header/footer:
@@ -57,11 +57,11 @@ package org.antlr.v4.runtime.tree.gui;
  *	 maxh = 0;
  *	 for line in lines[4:]: # skip header 0..3
  *			 all = line.split(' ')
- *			 words = [x for x in all if len(x)>0]
+ *			 words = [x for x in all if len(x)&gt;0]
  *			 ascii = int(words[1], 16)
  *			 height = int(words[8])
- *			 if height>maxh: maxh = height
- *			 if ascii>=128: break
+ *			 if height&gt;maxh: maxh = height
+ *			 if ascii&gt;=128: break
  *			 print "        widths[%d] = %s; // %s" % (ascii, words[3], words[2])
  *
  *	 print "        maxCharHeight = "+str(maxh)+";"
diff --git a/runtime/Java/src/org/antlr/v4/runtime/misc/GraphicsSupport.java b/tool/src/org/antlr/v4/gui/GraphicsSupport.java
similarity index 99%
rename from runtime/Java/src/org/antlr/v4/runtime/misc/GraphicsSupport.java
rename to tool/src/org/antlr/v4/gui/GraphicsSupport.java
index a35c17cc1..eb9546dc8 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/misc/GraphicsSupport.java
+++ b/tool/src/org/antlr/v4/gui/GraphicsSupport.java
@@ -28,7 +28,7 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-package org.antlr.v4.runtime.misc;
+package org.antlr.v4.gui;
 
 import javax.imageio.ImageIO;
 import javax.print.DocFlavor;
diff --git a/runtime/Java/src/org/antlr/v4/runtime/misc/JFileChooserConfirmOverwrite.java b/tool/src/org/antlr/v4/gui/JFileChooserConfirmOverwrite.java
similarity index 95%
rename from runtime/Java/src/org/antlr/v4/runtime/misc/JFileChooserConfirmOverwrite.java
rename to tool/src/org/antlr/v4/gui/JFileChooserConfirmOverwrite.java
index 74b7d87b2..59cbb69c2 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/misc/JFileChooserConfirmOverwrite.java
+++ b/tool/src/org/antlr/v4/gui/JFileChooserConfirmOverwrite.java
@@ -27,11 +27,9 @@
  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-package org.antlr.v4.runtime.misc;
-
-import javax.swing.JFileChooser;
-import javax.swing.JOptionPane;
+package org.antlr.v4.gui;
 
+import javax.swing.*;
 import java.io.File;
 
 /**
diff --git a/runtime/Java/src/org/antlr/v4/runtime/tree/gui/PostScriptDocument.java b/tool/src/org/antlr/v4/gui/PostScriptDocument.java
similarity index 98%
rename from runtime/Java/src/org/antlr/v4/runtime/tree/gui/PostScriptDocument.java
rename to tool/src/org/antlr/v4/gui/PostScriptDocument.java
index f6848a13e..7faf2db3a 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/tree/gui/PostScriptDocument.java
+++ b/tool/src/org/antlr/v4/gui/PostScriptDocument.java
@@ -28,15 +28,15 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-package org.antlr.v4.runtime.tree.gui;
+package org.antlr.v4.gui;
 
-import java.awt.Font;
+import java.awt.*;
 import java.util.HashMap;
 import java.util.Locale;
 import java.util.Map;
 
 public class PostScriptDocument {
-	public static final String DEFAULT_FONT = "Courier New";
+	public static final String DEFAULT_FONT = "CourierNew";
 
 	public static final Map<String, String> POSTSCRIPT_FONT_NAMES;
 	static {
diff --git a/runtime/Java/src/org/antlr/v4/runtime/tree/gui/SystemFontMetrics.java b/tool/src/org/antlr/v4/gui/SystemFontMetrics.java
similarity index 95%
rename from runtime/Java/src/org/antlr/v4/runtime/tree/gui/SystemFontMetrics.java
rename to tool/src/org/antlr/v4/gui/SystemFontMetrics.java
index 1eadafbf2..fb2b17aaf 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/tree/gui/SystemFontMetrics.java
+++ b/tool/src/org/antlr/v4/gui/SystemFontMetrics.java
@@ -28,11 +28,9 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-package org.antlr.v4.runtime.tree.gui;
+package org.antlr.v4.gui;
 
-import java.awt.Font;
-import java.awt.Graphics2D;
-import java.awt.GraphicsEnvironment;
+import java.awt.*;
 import java.awt.font.FontRenderContext;
 import java.awt.font.TextLayout;
 import java.awt.image.BufferedImage;
diff --git a/tool/src/org/antlr/v4/gui/TestRig.java b/tool/src/org/antlr/v4/gui/TestRig.java
new file mode 100644
index 000000000..e81a54cbc
--- /dev/null
+++ b/tool/src/org/antlr/v4/gui/TestRig.java
@@ -0,0 +1,267 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2012 Terence Parr
+ *  Copyright (c) 2012 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.
+ */
+
+package org.antlr.v4.gui;
+
+import org.antlr.v4.runtime.ANTLRInputStream;
+import org.antlr.v4.runtime.CharStream;
+import org.antlr.v4.runtime.CommonTokenStream;
+import org.antlr.v4.runtime.DiagnosticErrorListener;
+import org.antlr.v4.runtime.Lexer;
+import org.antlr.v4.runtime.Parser;
+import org.antlr.v4.runtime.ParserRuleContext;
+import org.antlr.v4.runtime.TokenStream;
+import org.antlr.v4.runtime.atn.PredictionMode;
+
+import javax.print.PrintException;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.Reader;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.List;
+
+/** Run a lexer/parser combo, optionally printing tree string or generating
+ *  postscript file. Optionally taking input file.
+ *
+ *  $ java org.antlr.v4.runtime.misc.TestRig GrammarName startRuleName
+ *        [-tree]
+ *        [-tokens] [-gui] [-ps file.ps]
+ *        [-trace]
+ *        [-diagnostics]
+ *        [-SLL]
+ *        [input-filename(s)]
+ */
+public class TestRig {
+	public static final String LEXER_START_RULE_NAME = "tokens";
+
+	protected String grammarName;
+	protected String startRuleName;
+	protected final List<String> inputFiles = new ArrayList<String>();
+	protected boolean printTree = false;
+	protected boolean gui = false;
+	protected String psFile = null;
+	protected boolean showTokens = false;
+	protected boolean trace = false;
+	protected boolean diagnostics = false;
+	protected String encoding = null;
+	protected boolean SLL = false;
+
+	public TestRig(String[] args) throws Exception {
+		if ( args.length < 2 ) {
+			System.err.println("java org.antlr.v4.gui.TestRig GrammarName startRuleName\n" +
+							   "  [-tokens] [-tree] [-gui] [-ps file.ps] [-encoding encodingname]\n" +
+							   "  [-trace] [-diagnostics] [-SLL]\n"+
+							   "  [input-filename(s)]");
+			System.err.println("Use startRuleName='tokens' if GrammarName is a lexer grammar.");
+			System.err.println("Omitting input-filename makes rig read from stdin.");
+			return;
+		}
+		int i=0;
+		grammarName = args[i];
+		i++;
+		startRuleName = args[i];
+		i++;
+		while ( i<args.length ) {
+			String arg = args[i];
+			i++;
+			if ( arg.charAt(0)!='-' ) { // input file name
+				inputFiles.add(arg);
+				continue;
+			}
+			if ( arg.equals("-tree") ) {
+				printTree = true;
+			}
+			if ( arg.equals("-gui") ) {
+				gui = true;
+			}
+			if ( arg.equals("-tokens") ) {
+				showTokens = true;
+			}
+			else if ( arg.equals("-trace") ) {
+				trace = true;
+			}
+			else if ( arg.equals("-SLL") ) {
+				SLL = true;
+			}
+			else if ( arg.equals("-diagnostics") ) {
+				diagnostics = true;
+			}
+			else if ( arg.equals("-encoding") ) {
+				if ( i>=args.length ) {
+					System.err.println("missing encoding on -encoding");
+					return;
+				}
+				encoding = args[i];
+				i++;
+			}
+			else if ( arg.equals("-ps") ) {
+				if ( i>=args.length ) {
+					System.err.println("missing filename on -ps");
+					return;
+				}
+				psFile = args[i];
+				i++;
+			}
+		}
+	}
+
+	public static void main(String[] args) throws Exception {
+		TestRig testRig = new TestRig(args);
+ 		if(args.length >= 2) {
+			testRig.process();
+		}
+	}
+
+	public void process() throws Exception {
+//		System.out.println("exec "+grammarName+"."+startRuleName);
+		String lexerName = grammarName+"Lexer";
+		ClassLoader cl = Thread.currentThread().getContextClassLoader();
+		Class<? extends Lexer> lexerClass = null;
+		try {
+			lexerClass = cl.loadClass(lexerName).asSubclass(Lexer.class);
+		}
+		catch (java.lang.ClassNotFoundException cnfe) {
+			// might be pure lexer grammar; no Lexer suffix then
+			lexerName = grammarName;
+			try {
+				lexerClass = cl.loadClass(lexerName).asSubclass(Lexer.class);
+			}
+			catch (ClassNotFoundException cnfe2) {
+				System.err.println("Can't load "+lexerName+" as lexer or parser");
+				return;
+			}
+		}
+
+		Constructor<? extends Lexer> lexerCtor = lexerClass.getConstructor(CharStream.class);
+		Lexer lexer = lexerCtor.newInstance((CharStream)null);
+
+		Class<? extends Parser> parserClass = null;
+		Parser parser = null;
+		if ( !startRuleName.equals(LEXER_START_RULE_NAME) ) {
+			String parserName = grammarName+"Parser";
+			parserClass = cl.loadClass(parserName).asSubclass(Parser.class);
+			Constructor<? extends Parser> parserCtor = parserClass.getConstructor(TokenStream.class);
+			parser = parserCtor.newInstance((TokenStream)null);
+		}
+
+		if ( inputFiles.size()==0 ) {
+			InputStream is = System.in;
+			Reader r;
+			if ( encoding!=null ) {
+				r = new InputStreamReader(is, encoding);
+			}
+			else {
+				r = new InputStreamReader(is);
+			}
+
+			process(lexer, parserClass, parser, is, r);
+			return;
+		}
+		for (String inputFile : inputFiles) {
+			InputStream is = System.in;
+			if ( inputFile!=null ) {
+				is = new FileInputStream(inputFile);
+			}
+			Reader r;
+			if ( encoding!=null ) {
+				r = new InputStreamReader(is, encoding);
+			}
+			else {
+				r = new InputStreamReader(is);
+			}
+
+			if ( inputFiles.size()>1 ) {
+				System.err.println(inputFile);
+			}
+			process(lexer, parserClass, parser, is, r);
+		}
+	}
+
+	protected void process(Lexer lexer, Class<? extends Parser> parserClass, Parser parser, InputStream is, Reader r) throws IOException, IllegalAccessException, InvocationTargetException, PrintException {
+		try {
+			ANTLRInputStream input = new ANTLRInputStream(r);
+			lexer.setInputStream(input);
+			CommonTokenStream tokens = new CommonTokenStream(lexer);
+
+			tokens.fill();
+
+			if ( showTokens ) {
+				for (Object tok : tokens.getTokens()) {
+					System.out.println(tok);
+				}
+			}
+
+			if ( startRuleName.equals(LEXER_START_RULE_NAME) ) return;
+
+			if ( diagnostics ) {
+				parser.addErrorListener(new DiagnosticErrorListener());
+				parser.getInterpreter().setPredictionMode(PredictionMode.LL_EXACT_AMBIG_DETECTION);
+			}
+
+			if ( printTree || gui || psFile!=null ) {
+				parser.setBuildParseTree(true);
+			}
+
+			if ( SLL ) { // overrides diagnostics
+				parser.getInterpreter().setPredictionMode(PredictionMode.SLL);
+			}
+
+			parser.setTokenStream(tokens);
+			parser.setTrace(trace);
+
+			try {
+				Method startRule = parserClass.getMethod(startRuleName);
+				ParserRuleContext tree = (ParserRuleContext)startRule.invoke(parser, (Object[])null);
+
+				if ( printTree ) {
+					System.out.println(tree.toStringTree(parser));
+				}
+				if ( gui ) {
+					Trees.inspect(tree, parser);
+				}
+				if ( psFile!=null ) {
+					Trees.save(tree, parser, psFile); // Generate postscript
+				}
+			}
+			catch (NoSuchMethodException nsme) {
+				System.err.println("No method for rule "+startRuleName+" or it has arguments");
+			}
+		}
+		finally {
+			if ( r!=null ) r.close();
+			if ( is!=null ) is.close();
+		}
+	}
+}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/tree/gui/TreeLayoutAdaptor.java b/tool/src/org/antlr/v4/gui/TreeLayoutAdaptor.java
similarity index 97%
rename from runtime/Java/src/org/antlr/v4/runtime/tree/gui/TreeLayoutAdaptor.java
rename to tool/src/org/antlr/v4/gui/TreeLayoutAdaptor.java
index b7df7978c..6024e3b69 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/tree/gui/TreeLayoutAdaptor.java
+++ b/tool/src/org/antlr/v4/gui/TreeLayoutAdaptor.java
@@ -28,7 +28,7 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-package org.antlr.v4.runtime.tree.gui;
+package org.antlr.v4.gui;
 
 import org.abego.treelayout.TreeForTreeLayout;
 import org.antlr.v4.runtime.tree.Tree;
@@ -37,7 +37,7 @@ import java.util.Iterator;
 import java.util.NoSuchElementException;
 
 /** Adaptor ANTLR trees to {@link TreeForTreeLayout}. */
-class TreeLayoutAdaptor implements TreeForTreeLayout<Tree> {
+public class TreeLayoutAdaptor implements TreeForTreeLayout<Tree> {
 	private static class AntlrTreeChildrenIterable implements Iterable<Tree> {
 		private final Tree tree;
 
diff --git a/runtime/Java/src/org/antlr/v4/runtime/tree/gui/TreePostScriptGenerator.java b/tool/src/org/antlr/v4/gui/TreePostScriptGenerator.java
similarity index 91%
rename from runtime/Java/src/org/antlr/v4/runtime/tree/gui/TreePostScriptGenerator.java
rename to tool/src/org/antlr/v4/gui/TreePostScriptGenerator.java
index 3fda60515..d78a1c873 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/tree/gui/TreePostScriptGenerator.java
+++ b/tool/src/org/antlr/v4/gui/TreePostScriptGenerator.java
@@ -28,19 +28,18 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-package org.antlr.v4.runtime.tree.gui;
+package org.antlr.v4.gui;
 
 import org.abego.treelayout.Configuration;
 import org.abego.treelayout.NodeExtentProvider;
 import org.abego.treelayout.TreeForTreeLayout;
 import org.abego.treelayout.TreeLayout;
 import org.abego.treelayout.util.DefaultConfiguration;
-import org.antlr.v4.runtime.misc.Nullable;
 import org.antlr.v4.runtime.misc.Utils;
 import org.antlr.v4.runtime.tree.ErrorNode;
 import org.antlr.v4.runtime.tree.Tree;
 
-import java.awt.Dimension;
+import java.awt.*;
 import java.awt.geom.Rectangle2D;
 import java.util.List;
 
@@ -74,11 +73,11 @@ public class TreePostScriptGenerator {
 
 	protected PostScriptDocument doc;
 
-	public TreePostScriptGenerator(@Nullable List<String> ruleNames, Tree root) {
+	public TreePostScriptGenerator(List<String> ruleNames, Tree root) {
 		this(ruleNames, root, PostScriptDocument.DEFAULT_FONT, 11);
 	}
 
-	public TreePostScriptGenerator(@Nullable List<String> ruleNames, Tree root,
+	public TreePostScriptGenerator(List<String> ruleNames, Tree root,
 								   String fontName, int fontSize)
 	{
 		this.root = root;
@@ -86,7 +85,7 @@ public class TreePostScriptGenerator {
 		doc = new PostScriptDocument(fontName, fontSize);
 		boolean compareNodeIdentities = true;
 		this.treeLayout =
-			new TreeLayout<Tree>(new TreeLayoutAdaptor(root),
+			new TreeLayout<Tree>(getTreeLayoutAdaptor(root),
 								 new VariableExtentProvide(),
 								 new DefaultConfiguration<Tree>(gapBetweenLevels,
 																gapBetweenNodes,
@@ -94,6 +93,12 @@ public class TreePostScriptGenerator {
                                  compareNodeIdentities);
 	}
 
+	/** Get an adaptor for root that indicates how to walk ANTLR trees.
+	 *  Override to change the adapter from the default of {@link TreeLayoutAdaptor}  */
+	public TreeForTreeLayout<Tree> getTreeLayoutAdaptor(Tree root) {
+		return new TreeLayoutAdaptor(root);
+	}
+
 	public String getPS() {
 		// generate the edges and boxes (with text)
 		generateEdges(getTree().getRoot());
diff --git a/runtime/Java/src/org/antlr/v4/runtime/tree/gui/TreeTextProvider.java b/tool/src/org/antlr/v4/gui/TreeTextProvider.java
similarity index 97%
rename from runtime/Java/src/org/antlr/v4/runtime/tree/gui/TreeTextProvider.java
rename to tool/src/org/antlr/v4/gui/TreeTextProvider.java
index c73037418..9a88fc083 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/tree/gui/TreeTextProvider.java
+++ b/tool/src/org/antlr/v4/gui/TreeTextProvider.java
@@ -28,7 +28,7 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-package org.antlr.v4.runtime.tree.gui;
+package org.antlr.v4.gui;
 
 import org.antlr.v4.runtime.tree.Tree;
 
diff --git a/runtime/Java/src/org/antlr/v4/runtime/tree/gui/TreeViewer.java b/tool/src/org/antlr/v4/gui/TreeViewer.java
similarity index 79%
rename from runtime/Java/src/org/antlr/v4/runtime/tree/gui/TreeViewer.java
rename to tool/src/org/antlr/v4/gui/TreeViewer.java
index 3b8504824..3cfd5e518 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/tree/gui/TreeViewer.java
+++ b/tool/src/org/antlr/v4/gui/TreeViewer.java
@@ -28,16 +28,13 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-package org.antlr.v4.runtime.tree.gui;
+package org.antlr.v4.gui;
 
 import org.abego.treelayout.NodeExtentProvider;
 import org.abego.treelayout.TreeForTreeLayout;
 import org.abego.treelayout.TreeLayout;
 import org.abego.treelayout.util.DefaultConfiguration;
-import org.antlr.v4.runtime.misc.GraphicsSupport;
-import org.antlr.v4.runtime.misc.JFileChooserConfirmOverwrite;
-import org.antlr.v4.runtime.misc.NotNull;
-import org.antlr.v4.runtime.misc.Nullable;
+import org.antlr.v4.runtime.ParserRuleContext;
 import org.antlr.v4.runtime.misc.Utils;
 import org.antlr.v4.runtime.tree.ErrorNode;
 import org.antlr.v4.runtime.tree.Tree;
@@ -45,21 +42,7 @@ import org.antlr.v4.runtime.tree.Trees;
 
 import javax.imageio.ImageIO;
 import javax.print.PrintException;
-import javax.swing.BorderFactory;
-import javax.swing.Icon;
-import javax.swing.JButton;
-import javax.swing.JComponent;
-import javax.swing.JDialog;
-import javax.swing.JFileChooser;
-import javax.swing.JFrame;
-import javax.swing.JOptionPane;
-import javax.swing.JPanel;
-import javax.swing.JScrollPane;
-import javax.swing.JSlider;
-import javax.swing.JSplitPane;
-import javax.swing.JTree;
-import javax.swing.SwingUtilities;
-import javax.swing.UIManager;
+import javax.swing.*;
 import javax.swing.event.ChangeEvent;
 import javax.swing.event.ChangeListener;
 import javax.swing.event.TreeSelectionEvent;
@@ -68,21 +51,12 @@ import javax.swing.filechooser.FileFilter;
 import javax.swing.tree.DefaultMutableTreeNode;
 import javax.swing.tree.TreePath;
 import javax.swing.tree.TreeSelectionModel;
-import java.awt.BasicStroke;
-import java.awt.BorderLayout;
-import java.awt.Color;
-import java.awt.Component;
-import java.awt.Container;
-import java.awt.Desktop;
-import java.awt.Dimension;
-import java.awt.FlowLayout;
-import java.awt.Font;
-import java.awt.FontMetrics;
-import java.awt.Graphics;
-import java.awt.Graphics2D;
-import java.awt.RenderingHints;
+import java.awt.*;
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
+import java.awt.event.WindowAdapter;
+import java.awt.event.WindowEvent;
+import java.awt.event.WindowListener;
 import java.awt.geom.CubicCurve2D;
 import java.awt.geom.Rectangle2D;
 import java.awt.image.BufferedImage;
@@ -95,6 +69,7 @@ import java.util.concurrent.Callable;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.Future;
+import java.util.prefs.Preferences;
 
 public class TreeViewer extends JComponent {
 	public static final Color LIGHT_RED = new Color(244, 213, 211);
@@ -102,7 +77,7 @@ public class TreeViewer extends JComponent {
 	public static class DefaultTreeTextProvider implements TreeTextProvider {
 		private final List<String> ruleNames;
 
-		public DefaultTreeTextProvider(@Nullable List<String> ruleNames) {
+		public DefaultTreeTextProvider(List<String> ruleNames) {
 			this.ruleNames = ruleNames;
 		}
 
@@ -158,16 +133,11 @@ public class TreeViewer extends JComponent {
 	protected Color borderColor = null;
 	protected Color textColor = Color.black;
 
-	public TreeViewer(@Nullable List<String> ruleNames, Tree tree) {
-		setTreeTextProvider(new DefaultTreeTextProvider(ruleNames));
-        boolean useIdentity = true; // compare node identity
-		this.treeLayout =
-			new TreeLayout<Tree>(new TreeLayoutAdaptor(tree),
-								 new TreeViewer.VariableExtentProvide(this),
-								 new DefaultConfiguration<Tree>(gapBetweenLevels,
-																gapBetweenNodes),
-                                 useIdentity);
-		updatePreferredSize();
+	public TreeViewer(List<String> ruleNames, Tree tree) {
+		setRuleNames(ruleNames);
+		if ( tree!=null ) {
+			setTree(tree);
+		}
 		setFont(font);
 	}
 
@@ -225,11 +195,18 @@ public class TreeViewer extends JComponent {
 	protected void paintBox(Graphics g, Tree tree) {
 		Rectangle2D.Double box = getBoundsOfNode(tree);
 		// draw the box in the background
+		boolean ruleFailedAndMatchedNothing = false;
+		if ( tree instanceof ParserRuleContext ) {
+			ParserRuleContext ctx = (ParserRuleContext) tree;
+			ruleFailedAndMatchedNothing = ctx.exception != null &&
+										  ctx.stop != null && ctx.stop.getTokenIndex() < ctx.start.getTokenIndex();
+		}
 		if ( isHighlighted(tree) || boxColor!=null ||
-			 tree instanceof ErrorNode )
+			 tree instanceof ErrorNode ||
+			 ruleFailedAndMatchedNothing)
 		{
 			if ( isHighlighted(tree) ) g.setColor(highlightedBoxColor);
-			else if ( tree instanceof ErrorNode ) g.setColor(LIGHT_RED);
+			else if ( tree instanceof ErrorNode || ruleFailedAndMatchedNothing ) g.setColor(LIGHT_RED);
 			else g.setColor(boxColor);
 			g.fillRoundRect((int) box.x, (int) box.y, (int) box.width - 1,
 							(int) box.height - 1, arcSize, arcSize);
@@ -263,6 +240,10 @@ public class TreeViewer extends JComponent {
 	public void paint(Graphics g) {
 		super.paint(g);
 
+		if ( treeLayout==null ) {
+			return;
+		}
+
 		Graphics2D g2 = (Graphics2D)g;
 		// anti-alias the lines
 		g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
@@ -296,11 +277,20 @@ public class TreeViewer extends JComponent {
 
 	// ----------------------------------------------------------------------
 
-	@NotNull
+
+    private static final String DIALOG_WIDTH_PREFS_KEY          = "dialog_width";
+    private static final String DIALOG_HEIGHT_PREFS_KEY         = "dialog_height";
+    private static final String DIALOG_X_PREFS_KEY              = "dialog_x";
+    private static final String DIALOG_Y_PREFS_KEY              = "dialog_y";
+    private static final String DIALOG_DIVIDER_LOC_PREFS_KEY    = "dialog_divider_location";
+    private static final String DIALOG_VIEWER_SCALE_PREFS_KEY   = "dialog_viewer_scale";
+
 	protected static JDialog showInDialog(final TreeViewer viewer) {
 		final JDialog dialog = new JDialog();
 		dialog.setTitle("Parse Tree Inspector");
 
+        final Preferences prefs = Preferences.userNodeForPackage(TreeViewer.class);
+
 		// Make new content panes
 		final Container mainPane = new JPanel(new BorderLayout(5,5));
 		final Container contentPane = new JPanel(new BorderLayout(0,0));
@@ -322,15 +312,14 @@ public class TreeViewer extends JComponent {
 			new ActionListener() {
 				@Override
 				public void actionPerformed(ActionEvent e) {
-					dialog.setVisible(false);
-					dialog.dispose();
+                    dialog.dispatchEvent(new WindowEvent(dialog, WindowEvent.WINDOW_CLOSING));
 				}
 			}
 		);
 		wrapper.add(ok);
 
 		// Add an export-to-png button right of the "OK" button
-		JButton png = new JButton("png");
+		JButton png = new JButton("Export as PNG");
 		png.addActionListener(
 			new ActionListener() {
 				@Override
@@ -344,9 +333,12 @@ public class TreeViewer extends JComponent {
 		bottomPanel.add(wrapper, BorderLayout.SOUTH);
 
 		// Add scale slider
-		int sliderValue = (int) ((viewer.getScale()-1.0) * 1000);
-		final JSlider scaleSlider = new JSlider(JSlider.HORIZONTAL,
-										  -999,1000,sliderValue);
+        double lastKnownViewerScale = prefs.getDouble(DIALOG_VIEWER_SCALE_PREFS_KEY, viewer.getScale());
+        viewer.setScale(lastKnownViewerScale);
+
+		int sliderValue = (int) ((lastKnownViewerScale - 1.0) * 1000);
+		final JSlider scaleSlider = new JSlider(JSlider.HORIZONTAL, -999, 1000, sliderValue);
+
 		scaleSlider.addChangeListener(
 			new ChangeListener() {
 				@Override
@@ -380,24 +372,19 @@ public class TreeViewer extends JComponent {
 
 				JTree selectedTree = (JTree) e.getSource();
 				TreePath path = selectedTree.getSelectionPath();
-				TreeNodeWrapper treeNode = (TreeNodeWrapper) path.getLastPathComponent();
+				if (path!=null) {
+					TreeNodeWrapper treeNode = (TreeNodeWrapper) path.getLastPathComponent();
 
-				// Set the clicked AST.
-				viewer.treeLayout = new TreeLayout<Tree>(
-						new TreeLayoutAdaptor((Tree) treeNode.getUserObject()),
-						new TreeViewer.VariableExtentProvide(viewer),
-						new DefaultConfiguration<Tree>(
-								viewer.gapBetweenLevels, viewer.gapBetweenNodes), true);
-
-				// Let the UI display this new AST.
-				viewer.updatePreferredSize();
+					// Set the clicked AST.
+					viewer.setTree((Tree) treeNode.getUserObject());
+				}
 			}
 		});
 
 		treePanel.add(new JScrollPane(tree));
 
 		// Create the pane for both the JTree and the AST
-		JSplitPane splitPane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT,
+		final JSplitPane splitPane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT,
 				treePanel, contentPane);
 
 		mainPane.add(splitPane, BorderLayout.CENTER);
@@ -405,14 +392,41 @@ public class TreeViewer extends JComponent {
 		dialog.setContentPane(mainPane);
 
 		// make viz
-		dialog.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
-		dialog.setPreferredSize(new Dimension(600, 500));
+        WindowListener exitListener = new WindowAdapter() {
+            public void windowClosing(WindowEvent e) {
+                prefs.putInt(DIALOG_WIDTH_PREFS_KEY, (int) dialog.getSize().getWidth());
+                prefs.putInt(DIALOG_HEIGHT_PREFS_KEY, (int) dialog.getSize().getHeight());
+                prefs.putDouble(DIALOG_X_PREFS_KEY, dialog.getLocationOnScreen().getX());
+                prefs.putDouble(DIALOG_Y_PREFS_KEY, dialog.getLocationOnScreen().getY());
+                prefs.putInt(DIALOG_DIVIDER_LOC_PREFS_KEY, splitPane.getDividerLocation());
+                prefs.putDouble(DIALOG_VIEWER_SCALE_PREFS_KEY, viewer.getScale());
+
+                dialog.setVisible(false);
+                dialog.dispose();
+            }
+        };
+        dialog.addWindowListener(exitListener);
+		dialog.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
+
+        int width = prefs.getInt(DIALOG_WIDTH_PREFS_KEY, 600);
+        int height = prefs.getInt(DIALOG_HEIGHT_PREFS_KEY, 500);
+		dialog.setPreferredSize(new Dimension(width, height));
 		dialog.pack();
 
-		// After pack(): set the divider at 1/3 of the frame.
-		splitPane.setDividerLocation(0.33);
+		// After pack(): set the divider at 1/3 (200/600) of the frame.
+        int dividerLocation = prefs.getInt(DIALOG_DIVIDER_LOC_PREFS_KEY, 200);
+		splitPane.setDividerLocation(dividerLocation);
+
+        if (prefs.getDouble(DIALOG_X_PREFS_KEY, -1) != -1) {
+            dialog.setLocation(
+                    (int)prefs.getDouble(DIALOG_X_PREFS_KEY, 100),
+                    (int)prefs.getDouble(DIALOG_Y_PREFS_KEY, 100)
+            );
+        }
+        else {
+            dialog.setLocationRelativeTo(null);
+        }
 
-		dialog.setLocationRelativeTo(null);
 		dialog.setVisible(true);
 		return dialog;
 	}
@@ -521,7 +535,7 @@ public class TreeViewer extends JComponent {
 		return scaledTreeSize;
 	}
 
-	@NotNull
+
 	public Future<JDialog> open() {
 		final TreeViewer viewer = this;
 		viewer.setScale(1.5);
@@ -677,6 +691,30 @@ public class TreeViewer extends JComponent {
 		return treeLayout.getTree();
 	}
 
+	public void setTree(Tree root) {
+		if ( root!=null ) {
+			boolean useIdentity = true; // compare node identity
+			this.treeLayout =
+				new TreeLayout<Tree>(getTreeLayoutAdaptor(root),
+									 new TreeViewer.VariableExtentProvide(this),
+									 new DefaultConfiguration<Tree>(gapBetweenLevels,
+																	gapBetweenNodes),
+									 useIdentity);
+			// Let the UI display this new AST.
+			updatePreferredSize();
+		}
+		else {
+			this.treeLayout = null;
+			repaint();
+		}
+	}
+
+	/** Get an adaptor for root that indicates how to walk ANTLR trees.
+	 *  Override to change the adapter from the default of {@link TreeLayoutAdaptor}  */
+	public TreeForTreeLayout<Tree> getTreeLayoutAdaptor(Tree root) {
+		return new TreeLayoutAdaptor(root);
+	}
+
 	public double getScale() {
 		return scale;
 	}
@@ -689,6 +727,10 @@ public class TreeViewer extends JComponent {
 		updatePreferredSize();
 	}
 
+	public void setRuleNames(List<String> ruleNames) {
+		setTreeTextProvider(new DefaultTreeTextProvider(ruleNames));
+	}
+
 	private static class TreeNodeWrapper extends DefaultMutableTreeNode {
 
 		final TreeViewer viewer;
diff --git a/tool/src/org/antlr/v4/gui/Trees.java b/tool/src/org/antlr/v4/gui/Trees.java
new file mode 100644
index 000000000..53796ab23
--- /dev/null
+++ b/tool/src/org/antlr/v4/gui/Trees.java
@@ -0,0 +1,120 @@
+package org.antlr.v4.gui;
+
+import org.antlr.v4.runtime.Parser;
+import org.antlr.v4.runtime.misc.Utils;
+import org.antlr.v4.runtime.tree.Tree;
+
+import javax.print.PrintException;
+import javax.swing.*;
+import java.io.BufferedWriter;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.Future;
+
+public class Trees {
+	/** Call this method to view a parse tree in a dialog box visually. */
+	public static Future<JDialog> inspect(Tree t, List<String> ruleNames) {
+		TreeViewer viewer = new TreeViewer(ruleNames, t);
+		return viewer.open();
+	}
+
+	/** Call this method to view a parse tree in a dialog box visually. */
+	public static Future<JDialog> inspect(Tree t, Parser parser) {
+		List<String> ruleNames = parser != null ? Arrays.asList(parser.getRuleNames()) : null;
+		return inspect(t, ruleNames);
+	}
+
+	/** Save this tree in a postscript file */
+	public static void save(Tree t, Parser parser, String fileName)
+		throws IOException, PrintException
+	{
+		List<String> ruleNames = parser != null ? Arrays.asList(parser.getRuleNames()) : null;
+		save(t, ruleNames, fileName);
+	}
+
+	/** Save this tree in a postscript file using a particular font name and size */
+	public static void save(Tree t, Parser parser, String fileName,
+					 String fontName, int fontSize)
+		throws IOException
+	{
+		List<String> ruleNames = parser != null ? Arrays.asList(parser.getRuleNames()) : null;
+		save(t, ruleNames, fileName, fontName, fontSize);
+	}
+
+	/** Save this tree in a postscript file */
+	public static void save(Tree t, List<String> ruleNames, String fileName)
+		throws IOException, PrintException
+	{
+		writePS(t, ruleNames, fileName);
+	}
+
+	/** Save this tree in a postscript file using a particular font name and size */
+	public static void save(Tree t,
+	                        List<String> ruleNames, String fileName,
+	                        String fontName, int fontSize)
+	throws IOException
+	{
+		writePS(t, ruleNames, fileName, fontName, fontSize);
+	}
+
+	public static String getPS(Tree t, List<String> ruleNames,
+							   String fontName, int fontSize)
+	{
+		TreePostScriptGenerator psgen =
+			new TreePostScriptGenerator(ruleNames, t, fontName, fontSize);
+		return psgen.getPS();
+	}
+
+	public static String getPS(Tree t, List<String> ruleNames) {
+		return getPS(t, ruleNames, "Helvetica", 11);
+	}
+
+	public static void writePS(Tree t, List<String> ruleNames,
+							   String fileName,
+							   String fontName, int fontSize)
+		throws IOException
+	{
+		String ps = getPS(t, ruleNames, fontName, fontSize);
+		FileWriter f = new FileWriter(fileName);
+		BufferedWriter bw = new BufferedWriter(f);
+		try {
+			bw.write(ps);
+		}
+		finally {
+			bw.close();
+		}
+	}
+
+	public static void writePS(Tree t, List<String> ruleNames, String fileName)
+		throws IOException
+	{
+		writePS(t, ruleNames, fileName, "Helvetica", 11);
+	}
+
+	/** Print out a whole tree in LISP form. Arg nodeTextProvider is used on the
+	 *  node payloads to get the text for the nodes.
+	 *
+	 *  @since 4.5.1
+	 */
+	public static String toStringTree(Tree t, TreeTextProvider nodeTextProvider) {
+		if ( t==null ) return "null";
+		String s = Utils.escapeWhitespace(nodeTextProvider.getText(t), false);
+		if ( t.getChildCount()==0 ) return s;
+		StringBuilder buf = new StringBuilder();
+		buf.append("(");
+		s = Utils.escapeWhitespace(nodeTextProvider.getText(t), false);
+		buf.append(s);
+		buf.append(' ');
+		for (int i = 0; i<t.getChildCount(); i++) {
+			if ( i>0 ) buf.append(' ');
+			buf.append(toStringTree(t.getChild(i), nodeTextProvider));
+		}
+		buf.append(")");
+		return buf.toString();
+	}
+
+	private Trees() {
+	}
+}
diff --git a/tool/src/org/antlr/v4/misc/Graph.java b/tool/src/org/antlr/v4/misc/Graph.java
index c2b3644c2..a7c63d50a 100644
--- a/tool/src/org/antlr/v4/misc/Graph.java
+++ b/tool/src/org/antlr/v4/misc/Graph.java
@@ -32,7 +32,7 @@ package org.antlr.v4.misc;
 import org.antlr.v4.runtime.misc.OrderedHashSet;
 
 import java.util.ArrayList;
-import java.util.HashMap;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -59,7 +59,7 @@ public class Graph<T> {
 	}
 
 	/** Map from node payload to node containing it */
-	protected Map<T,Node<T>> nodes = new HashMap<T,Node<T>>();
+	protected Map<T,Node<T>> nodes = new LinkedHashMap<T,Node<T>>();
 
 	public void addEdge(T a, T b) {
 		//System.out.println("add edge "+a+" to "+b);
@@ -81,7 +81,7 @@ public class Graph<T> {
 	 *  For sorting, I'm not following convention here since ANTLR
 	 *  needs the opposite.  Here's what I assume for sorting:
 	 *
-	 *    If there exists an edge u -> v then u depends on v and v
+	 *    If there exists an edge u -&gt; v then u depends on v and v
 	 *    must happen before u.
 	 *
 	 *  So if this gives nonreversed postorder traversal, I get the order
@@ -114,4 +114,4 @@ public class Graph<T> {
 		}
 		sorted.add(n.payload);
 	}
-}
\ No newline at end of file
+}
diff --git a/tool/src/org/antlr/v4/misc/OrderedHashMap.java b/tool/src/org/antlr/v4/misc/OrderedHashMap.java
index 4199495e0..ce37b86aa 100644
--- a/tool/src/org/antlr/v4/misc/OrderedHashMap.java
+++ b/tool/src/org/antlr/v4/misc/OrderedHashMap.java
@@ -33,6 +33,7 @@ package org.antlr.v4.misc;
 import java.util.ArrayList;
 import java.util.LinkedHashMap;
 import java.util.List;
+import java.util.Map;
 
 /** I need the get-element-i functionality so I'm subclassing
  *  LinkedHashMap.
@@ -51,9 +52,17 @@ public class OrderedHashMap<K,V> extends LinkedHashMap<K,V> {
 		return super.put(key, value);
 	}
 
+	@Override
+	public void putAll(Map<? extends K, ? extends V> m) {
+		for (Map.Entry<? extends K, ? extends V> entry : m.entrySet()) {
+			put(entry.getKey(), entry.getValue());
+		}
+	}
+
 	@Override
 	public V remove(Object key) {
-		throw new UnsupportedOperationException();
+		elements.remove(key);
+		return super.remove(key);
 	}
 
 	@Override
diff --git a/tool/src/org/antlr/v4/misc/Utils.java b/tool/src/org/antlr/v4/misc/Utils.java
index 6dd6e588e..6d63b7c6b 100644
--- a/tool/src/org/antlr/v4/misc/Utils.java
+++ b/tool/src/org/antlr/v4/misc/Utils.java
@@ -30,7 +30,6 @@
 
 package org.antlr.v4.misc;
 
-import org.antlr.v4.runtime.misc.IntegerList;
 import org.antlr.v4.tool.ast.GrammarAST;
 
 import java.util.ArrayList;
@@ -55,21 +54,6 @@ public class Utils {
 
 	static Integer[] ints = new Integer[INTEGER_POOL_MAX_VALUE+1];
 
-	/** Integer objects are immutable so share all Integers with the
-	 *  same value up to some max size.  Use an array as a perfect hash.
-	 *  Return shared object for 0..INTEGER_POOL_MAX_VALUE or a new
-	 *  Integer object with x in it.  Java's autoboxing only caches up to 127.
-	public static Integer integer(int x) {
-		if ( x<0 || x>INTEGER_POOL_MAX_VALUE ) {
-			return new Integer(x);
-		}
-		if ( ints[x]==null ) {
-			ints[x] = new Integer(x);
-		}
-		return ints[x];
-	}
-	 */
-
     public static String stripFileExtension(String name) {
         if ( name==null ) return null;
         int lastDot = name.lastIndexOf('.');
diff --git a/tool/src/org/antlr/v4/parse/ANTLRLexer.g b/tool/src/org/antlr/v4/parse/ANTLRLexer.g
index fc46ca517..4768d2e7d 100644
--- a/tool/src/org/antlr/v4/parse/ANTLRLexer.g
+++ b/tool/src/org/antlr/v4/parse/ANTLRLexer.g
@@ -150,6 +150,8 @@ import org.antlr.v4.tool.*;
 
 
 @members {
+	public static final int COMMENTS_CHANNEL = 2;
+
     public CommonTokenStream tokens; // track stream we push to; need for context info
     public boolean isLexerRule = false;
 
@@ -261,15 +263,11 @@ COMMENT
            }
        )
        {
-         // Unless we had a documentation comment, then we do not wish to
-         // pass the comments in to the parser. If you are writing a formatter
-         // then you will want to preserve the comments off channel, but could
-         // just skip and save token space if not.
+         // We do not wish to pass the comments in to the parser. If you are
+         // writing a formatter then you will want to preserve the comments off
+         // channel, but could just skip and save token space if not.
          //
-         if ($type != DOC_COMMENT) {
-
-             $channel=2;  // Comments are on channel 2
-         }
+         $channel=COMMENTS_CHANNEL;
        }
     ;
 
@@ -434,12 +432,13 @@ NESTED_ACTION
 // keywords used to specify ANTLR v3 grammars. Keywords may not be used as
 // labels for rules or in any other context where they would be ambiguous
 // with the keyword vs some other identifier
-// OPTIONS and TOKENS must also consume the opening brace that captures
-// their option block, as this is teh easiest way to parse it separate
-// to an ACTION block, despite it usingthe same {} delimiters.
+// OPTIONS, TOKENS, and CHANNELS must also consume the opening brace that captures
+// their option block, as this is the easiest way to parse it separate
+// to an ACTION block, despite it using the same {} delimiters.
 //
-OPTIONS      : 'options' WSNLCHARS* '{'  ;
-TOKENS_SPEC  : 'tokens'  WSNLCHARS* '{'  ;
+OPTIONS      : 'options'  WSNLCHARS* '{'  ;
+TOKENS_SPEC  : 'tokens'   WSNLCHARS* '{'  ;
+CHANNELS     : 'channels' WSNLCHARS* '{'  ;
 
 IMPORT       : 'import'               ;
 FRAGMENT     : 'fragment'             ;
@@ -541,7 +540,8 @@ NameStartChar
             |   '\u2C00'..'\u2FEF'
             |   '\u3001'..'\uD7FF'
             |   '\uF900'..'\uFDCF'
-            |   '\uFDF0'..'\uFFFD'
+            |   '\uFDF0'..'\uFEFE'
+            |   '\uFF00'..'\uFFFD'
             ; // ignores | ['\u10000-'\uEFFFF] ;
 
 // ----------------------------
@@ -655,8 +655,11 @@ ESC_SEQ
     	    | // An illegal escape seqeunce
     	      //
     	      {
-    	      	// TODO: Issue error message
-    	      	//
+                Token t = new CommonToken(input, state.type, state.channel, getCharIndex()-1, getCharIndex());
+                t.setText(t.getText());
+                t.setLine(input.getLine());
+                t.setCharPositionInLine(input.getCharPositionInLine()-1);
+                grammarError(ErrorType.INVALID_ESCAPE_SEQUENCE, t);
     	      }
         )
     ;
@@ -707,9 +710,12 @@ UNICODE_ESC
     	// Now check the digit count and issue an error if we need to
     	//
     	{
-    		if	(hCount != 4) {
-
-    			// TODO: Issue error message
+    		if (hCount != 4) {
+                Token t = new CommonToken(input, state.type, state.channel, getCharIndex()-3-hCount, getCharIndex()-1);
+                t.setText(t.getText());
+                t.setLine(input.getLine());
+                t.setCharPositionInLine(input.getCharPositionInLine()-hCount-2);
+                grammarError(ErrorType.INVALID_ESCAPE_SEQUENCE, t);
     		}
     	}
     ;
@@ -757,6 +763,15 @@ WSNLCHARS
     : ' ' | '\t' | '\f' | '\n' | '\r'
     ;
 
+// This rule allows ANTLR 4 to parse grammars using the UTF-8 encoding with a
+// byte order mark. Since this Unicode character doesn't appear as a token
+// anywhere else in the grammar, we can simply skip all instances of it without
+// problem. This rule will not break usage of \uFEFF inside a LEXER_CHAR_SET or
+// STRING_LITERAL.
+UnicodeBOM
+    :   '\uFEFF' {skip();}
+    ;
+
 // -----------------
 // Illegal Character
 //
@@ -777,6 +792,7 @@ ERRCHAR
          t.setCharPositionInLine(state.tokenStartCharPositionInLine);
          String msg = getTokenErrorDisplay(t) + " came as a complete surprise to me";
          grammarError(ErrorType.SYNTAX_ERROR, t, msg);
+         state.syntaxErrors++;
          skip();
       }
     ;
diff --git a/tool/src/org/antlr/v4/parse/ANTLRParser.g b/tool/src/org/antlr/v4/parse/ANTLRParser.g
index 7f5675c81..42946fa8d 100644
--- a/tool/src/org/antlr/v4/parse/ANTLRParser.g
+++ b/tool/src/org/antlr/v4/parse/ANTLRParser.g
@@ -150,13 +150,7 @@ if ( options!=null ) {
 	Grammar.setNodeOptions($tree, options);
 }
 }
-    :
-      // The grammar itself can have a documenation comment, which is the
-      // first terminal in the file.
-      //
-      DOC_COMMENT?
-
-      // Next we should see the type and name of the grammar file that
+    : // First we should see the type and name of the grammar file that
       // we are about to parse.
       //
       grammarType id SEMI
@@ -195,7 +189,6 @@ if ( options!=null ) {
 
       -> ^(grammarType       // The grammar type is our root AST node
              id              // We need to identify the grammar of course
-             DOC_COMMENT?    // We may or may not have a global documentation comment for the file
              prequelConstruct* // The set of declarations we accumulated
              rules           // And of course, we need the set of rules we discovered
              modeSpec*
@@ -237,6 +230,9 @@ prequelConstruct
       // {tree} parser.
       tokensSpec
 
+	| // A list of custom channels used by the grammar
+	  channelsSpec
+
     | // A declaration of language target implemented constructs. All such
       // action sections start with '@' and are given to the language target's
       // StringTemplate group. For instance @parser::header and @lexer::header
@@ -301,6 +297,10 @@ v3tokenSpec
 		SEMI
 	;
 
+channelsSpec
+	:	CHANNELS^ id (COMMA! id)* RBRACE!
+	;
+
 // A declaration of a language target specifc section,
 // such as @header, @includes and so on. We do not verify these
 // sections, they are just passed on to the language target.
@@ -364,10 +364,7 @@ parserRule
 		Grammar.setNodeOptions($tree, options);
 	}
 }
-    : // A rule may start with an optional documentation comment
-      DOC_COMMENT?
-
-	  // Next comes the rule name. Here we do not distinguish between
+    : // Start with the rule name. Here we do not distinguish between
 	  // parser or lexer rules, the semantic verification phase will
 	  // reject any rules that make no sense, such as lexer rules in
 	  // a pure parser or tree parser.
@@ -412,7 +409,7 @@ parserRule
 
       exceptionGroup
 
-      -> ^( RULE<RuleAST> RULE_REF DOC_COMMENT? ARG_ACTION<ActionAST>?
+      -> ^( RULE<RuleAST> RULE_REF ARG_ACTION<ActionAST>?
       		ruleReturns? throwsSpec? localsSpec? rulePrequels? ruleBlock exceptionGroup*
       	  )
     ;
@@ -522,9 +519,9 @@ lexerRule
 @after {
 	paraphrases.pop();
 }
-    : DOC_COMMENT? FRAGMENT?
+    : FRAGMENT?
 	  TOKEN_REF COLON lexerRuleBlock SEMI
-      -> ^( RULE<RuleAST> TOKEN_REF DOC_COMMENT?
+      -> ^( RULE<RuleAST> TOKEN_REF
       		^(RULEMODIFIERS FRAGMENT)? lexerRuleBlock
       	  )
 	;
@@ -547,11 +544,11 @@ lexerAlt
 		(	lexerCommands	-> ^(LEXER_ALT_ACTION<AltAST> lexerElements lexerCommands)
 		|					-> lexerElements
 		)
-	|						-> ^(ALT<AltAST> EPSILON) // empty alt
 	;
 
 lexerElements
-    :	lexerElement+ -> ^(ALT<AltAST> lexerElement+)
+    :	lexerElement+	-> ^(ALT<AltAST> lexerElement+)
+	|					-> ^(ALT<AltAST> EPSILON) // empty alt
     ;
 
 lexerElement
@@ -658,10 +655,11 @@ alternative
     paraphrases.pop();
     Grammar.setNodeOptions($tree, $o.tree);
 }
-    :	o=elementOptions?
-        e+=element+                     -> ^(ALT<AltAST> elementOptions? $e+)
-    |                                   -> ^(ALT<AltAST> EPSILON) // empty alt
-    ;
+	:	o=elementOptions?
+		(	e+=element+                     -> ^(ALT<AltAST> elementOptions? $e+)
+		|                                   -> ^(ALT<AltAST> elementOptions? EPSILON) // empty alt
+		)
+	;
 
 element
 @init {
@@ -818,8 +816,8 @@ blockSet
     ;
 
 setElement
-	:	TOKEN_REF<TerminalAST>
-	|	STRING_LITERAL<TerminalAST>
+	:	TOKEN_REF<TerminalAST>^ elementOptions?
+	|	STRING_LITERAL<TerminalAST>^ elementOptions?
 	|	range
     |   LEXER_CHAR_SET
 	;
diff --git a/tool/src/org/antlr/v4/parse/ATNBuilder.g b/tool/src/org/antlr/v4/parse/ATNBuilder.g
index d98a43a29..019f24664 100644
--- a/tool/src/org/antlr/v4/parse/ATNBuilder.g
+++ b/tool/src/org/antlr/v4/parse/ATNBuilder.g
@@ -104,19 +104,19 @@ alternative returns [ATNFactory.Handle p]
 @init {List<ATNFactory.Handle> els = new ArrayList<ATNFactory.Handle>();}
     :	^(LEXER_ALT_ACTION a=alternative lexerCommands)
         {$p = factory.lexerAltCommands($a.p,$lexerCommands.p);}
-    |	^(ALT EPSILON)							{$p = factory.epsilon($EPSILON);}
-    |   ^(ALT (e=element {els.add($e.p);})+)	{$p = factory.alt(els);}
+    |	^(ALT elementOptions? EPSILON)							{$p = factory.epsilon($EPSILON);}
+    |   ^(ALT elementOptions? (e=element {els.add($e.p);})+)	{$p = factory.alt(els);}
     ;
 
 lexerCommands returns [ATNFactory.Handle p]
-@init {StringBuilder cmds = new StringBuilder();}
-    :   (c=lexerCommand {cmds.append($c.cmd).append(' ');})+
+@init {List<ATNFactory.Handle> cmds = new ArrayList<ATNFactory.Handle>();}
+    :   (c=lexerCommand {if ($c.cmd != null) cmds.add($c.cmd);})+
         {
-        $p = factory.action(cmds.toString());
+        $p = factory.alt(cmds);
         }
     ;
 
-lexerCommand returns [String cmd]
+lexerCommand returns [ATNFactory.Handle cmd]
 	:	^(LEXER_ACTION_CALL ID lexerCommandExpr)
         {$cmd = factory.lexerCallCommand($ID, $lexerCommandExpr.start);}
 	|	ID
@@ -164,7 +164,9 @@ blockSet[boolean invert] returns [ATNFactory.Handle p]
 
 /** Don't combine with atom otherwise it will build spurious ATN nodes */
 setElement
-	:	STRING_LITERAL
+	:	^(STRING_LITERAL .)
+	|	^(TOKEN_REF .)
+	|	STRING_LITERAL
 	|	TOKEN_REF
 	|	^(RANGE a=STRING_LITERAL b=STRING_LITERAL)
     |   LEXER_CHAR_SET
@@ -198,3 +200,15 @@ terminal returns [ATNFactory.Handle p]
     |	^(TOKEN_REF .)				{$p = factory.tokenRef((TerminalAST)$start);}
     |	TOKEN_REF					{$p = factory.tokenRef((TerminalAST)$start);}
     ;
+
+elementOptions
+	:	^(ELEMENT_OPTIONS elementOption*)
+	;
+
+elementOption
+	:	ID
+	|	^(ASSIGN ID ID)
+	|	^(ASSIGN ID STRING_LITERAL)
+	|	^(ASSIGN ID ACTION)
+	|	^(ASSIGN ID INT)
+	;
diff --git a/tool/src/org/antlr/v4/parse/BlockSetTransformer.g b/tool/src/org/antlr/v4/parse/BlockSetTransformer.g
index 885bae987..2233b3006 100644
--- a/tool/src/org/antlr/v4/parse/BlockSetTransformer.g
+++ b/tool/src/org/antlr/v4/parse/BlockSetTransformer.g
@@ -95,10 +95,10 @@ boolean inLexer = Grammar.isTokenName(currentRuleName);
 	GrammarTransformPipeline.setGrammarPtr(g, $tree);
 }
 	:	{inContext("RULE")}? // top-level: rule block and > 1 alt
-		^(BLOCK ^(alt=ALT {((AltAST)$alt).altLabel==null}? setElement[inLexer]) ( ^(ALT setElement[inLexer]) )+)
+		^(BLOCK ^(alt=ALT elementOptions? {((AltAST)$alt).altLabel==null}? setElement[inLexer]) ( ^(ALT elementOptions? setElement[inLexer]) )+)
 		-> ^(BLOCK<BlockAST>[$BLOCK.token] ^(ALT<AltAST>[$BLOCK.token,"ALT"] ^(SET[$BLOCK.token, "SET"] setElement+)))
 	|	{!inContext("RULE")}? // if not rule block and > 1 alt
-		^(BLOCK ^(ALT setElement[inLexer]) ( ^(ALT setElement[inLexer]) )+)
+		^(BLOCK ^(ALT elementOptions? setElement[inLexer]) ( ^(ALT elementOptions? setElement[inLexer]) )+)
 		-> ^(SET[$BLOCK.token, "SET"] setElement+)
 	;
 
@@ -106,10 +106,24 @@ setElement[boolean inLexer]
 @after {
 	GrammarTransformPipeline.setGrammarPtr(g, $tree);
 }
-	:	(	a=STRING_LITERAL {!inLexer || CharSupport.getCharValueFromGrammarCharLiteral($a.getText())!=-1}?
-		|	{!inLexer}?=> TOKEN_REF
+	:	(	^(a=STRING_LITERAL elementOptions) {!inLexer || CharSupport.getCharValueFromGrammarCharLiteral($a.getText())!=-1}?
+		|	  a=STRING_LITERAL {!inLexer || CharSupport.getCharValueFromGrammarCharLiteral($a.getText())!=-1}?
+		|	{!inLexer}?=> ^(TOKEN_REF elementOptions)
+		|	{!inLexer}?=>   TOKEN_REF
 		|	{inLexer}?=>  ^(RANGE a=STRING_LITERAL b=STRING_LITERAL)
 			{CharSupport.getCharValueFromGrammarCharLiteral($a.getText())!=-1 &&
 			 CharSupport.getCharValueFromGrammarCharLiteral($b.getText())!=-1}?
 		)
 	;
+
+elementOptions
+	:	^(ELEMENT_OPTIONS elementOption*)
+	;
+
+elementOption
+	:	ID
+	|	^(ASSIGN id=ID v=ID)
+	|	^(ASSIGN ID v=STRING_LITERAL)
+	|	^(ASSIGN ID v=ACTION)
+	|	^(ASSIGN ID v=INT)
+	;
diff --git a/tool/src/org/antlr/v4/parse/GrammarToken.java b/tool/src/org/antlr/v4/parse/GrammarToken.java
new file mode 100644
index 000000000..3e7e1908a
--- /dev/null
+++ b/tool/src/org/antlr/v4/parse/GrammarToken.java
@@ -0,0 +1,98 @@
+/*
+ * [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.
+ */
+
+package org.antlr.v4.parse;
+
+import org.antlr.runtime.CommonToken;
+import org.antlr.runtime.Token;
+import org.antlr.v4.tool.Grammar;
+
+/** A CommonToken that can also track it's original location,
+ *  derived from options on the element ref like BEGIN&lt;line=34,...&gt;.
+ */
+public class GrammarToken extends CommonToken {
+	public Grammar g;
+	public int originalTokenIndex = -1;
+
+	public GrammarToken(Grammar g, Token oldToken) {
+		super(oldToken);
+		this.g = g;
+	}
+
+	@Override
+	public int getCharPositionInLine() {
+		if ( originalTokenIndex>=0 ) return g.originalTokenStream.get(originalTokenIndex).getCharPositionInLine();
+		return super.getCharPositionInLine();
+	}
+
+	@Override
+	public int getLine() {
+		if ( originalTokenIndex>=0 ) return g.originalTokenStream.get(originalTokenIndex).getLine();
+		return super.getLine();
+	}
+
+	@Override
+	public int getTokenIndex() {
+		return originalTokenIndex;
+	}
+
+	@Override
+	public int getStartIndex() {
+		if ( originalTokenIndex>=0 ) {
+			return ((CommonToken)g.originalTokenStream.get(originalTokenIndex)).getStartIndex();
+		}
+		return super.getStartIndex();
+	}
+
+	@Override
+	public int getStopIndex() {
+		int n = super.getStopIndex() - super.getStartIndex() + 1;
+		return getStartIndex() + n - 1;
+	}
+
+	@Override
+	public String toString() {
+		String channelStr = "";
+		if ( channel>0 ) {
+			channelStr=",channel="+channel;
+		}
+		String txt = getText();
+		if ( txt!=null ) {
+			txt = txt.replaceAll("\n","\\\\n");
+			txt = txt.replaceAll("\r","\\\\r");
+			txt = txt.replaceAll("\t","\\\\t");
+		}
+		else {
+			txt = "<no text>";
+		}
+		return "[@"+getTokenIndex()+","+getStartIndex()+":"+getStopIndex()+
+			   "='"+txt+"',<"+getType()+">"+channelStr+","+getLine()+":"+getCharPositionInLine()+"]";
+	}
+}
diff --git a/tool/src/org/antlr/v4/parse/GrammarTreeVisitor.g b/tool/src/org/antlr/v4/parse/GrammarTreeVisitor.g
index 2f4253725..9c8b1be43 100644
--- a/tool/src/org/antlr/v4/parse/GrammarTreeVisitor.g
+++ b/tool/src/org/antlr/v4/parse/GrammarTreeVisitor.g
@@ -76,8 +76,10 @@ options {
  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 package org.antlr.v4.parse;
+import org.antlr.v4.Tool;
 import org.antlr.v4.tool.*;
 import org.antlr.v4.tool.ast.*;
+import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 }
 
@@ -86,13 +88,14 @@ public String grammarName;
 public GrammarAST currentRuleAST;
 public String currentModeName = LexerGrammar.DEFAULT_MODE_NAME;
 public String currentRuleName;
-//public GrammarAST currentRuleBlock;
 public GrammarAST currentOuterAltRoot;
 public int currentOuterAltNumber = 1; // 1..n
 public int rewriteEBNFLevel = 0;
 
 public GrammarTreeVisitor() { this(null); }
 
+// Should be abstract but can't make gen'd parser abstract;
+// subclasses should implement else everything goes to stderr!
 public ErrorManager getErrorManager() { return null; }
 
 public void visitGrammar(GrammarAST t) { visit(t, "grammarSpec"); }
@@ -103,8 +106,12 @@ public void visit(GrammarAST t, String ruleName) {
 		Method m = getClass().getMethod(ruleName);
 		m.invoke(this);
 	}
-	catch (Exception e) {
+	catch (Throwable e) {
 		ErrorManager errMgr = getErrorManager();
+		if ( e instanceof InvocationTargetException ) {
+			e = e.getCause();
+		}
+		//e.printStackTrace(System.err);
 		if ( errMgr==null ) {
 			System.err.println("can't find rule "+ruleName+
 							   " or tree structure error: "+t.toStringTree()
@@ -123,6 +130,7 @@ public void grammarOption(GrammarAST ID, GrammarAST valueAST) { }
 public void ruleOption(GrammarAST ID, GrammarAST valueAST) { }
 public void blockOption(GrammarAST ID, GrammarAST valueAST) { }
 public void defineToken(GrammarAST ID) { }
+public void defineChannel(GrammarAST ID) { }
 public void globalNamedAction(GrammarAST scope, GrammarAST ID, ActionAST action) { }
 public void importGrammar(GrammarAST label, GrammarAST ID) { }
 
@@ -187,6 +195,12 @@ protected void exitTokensSpec(GrammarAST tree) { }
 protected void enterTokenSpec(GrammarAST tree) { }
 protected void exitTokenSpec(GrammarAST tree) { }
 
+protected void enterChannelsSpec(GrammarAST tree) { }
+protected void exitChannelsSpec(GrammarAST tree) { }
+
+protected void enterChannelSpec(GrammarAST tree) { }
+protected void exitChannelSpec(GrammarAST tree) { }
+
 protected void enterAction(GrammarAST tree) { }
 protected void exitAction(GrammarAST tree) { }
 
@@ -334,7 +348,7 @@ grammarSpec
 @after {
 	exitGrammarSpec($start);
 }
-    :   ^(	GRAMMAR ID {grammarName=$ID.text;} DOC_COMMENT?
+    :   ^(	GRAMMAR ID {grammarName=$ID.text;}
     		{discoverGrammar((GrammarRootAST)$GRAMMAR, $ID);}
  		   	prequelConstructs
     		{finishPrequels($prequelConstructs.firstOne);}
@@ -364,6 +378,7 @@ prequelConstruct
 	:   optionsSpec
     |   delegateGrammars
     |   tokensSpec
+    |   channelsSpec
     |   action
     ;
 
@@ -448,6 +463,26 @@ tokenSpec
 	:	ID					{defineToken($ID);}
 	;
 
+channelsSpec
+@init {
+	enterChannelsSpec($start);
+}
+@after {
+	exitChannelsSpec($start);
+}
+	:   ^(CHANNELS channelSpec+)
+	;
+
+channelSpec
+@init {
+	enterChannelSpec($start);
+}
+@after {
+	exitChannelSpec($start);
+}
+	:	ID					{defineChannel($ID);}
+	;
+
 action
 @init {
 	enterAction($start);
@@ -489,7 +524,7 @@ lexerRule
 }
 	:	^(	RULE TOKEN_REF
 			{currentRuleName=$TOKEN_REF.text; currentRuleAST=$RULE;}
-			DOC_COMMENT? (^(RULEMODIFIERS m=FRAGMENT {mods.add($m);}))?
+			(^(RULEMODIFIERS m=FRAGMENT {mods.add($m);}))?
       		{discoverLexerRule((RuleAST)$RULE, $TOKEN_REF, mods, (GrammarAST)input.LT(1));}
       		lexerRuleBlock
       		{
@@ -510,7 +545,7 @@ rule
 	exitRule($start);
 }
 	:   ^(	RULE RULE_REF {currentRuleName=$RULE_REF.text; currentRuleAST=$RULE;}
-			DOC_COMMENT? (^(RULEMODIFIERS (m=ruleModifier{mods.add($m.start);})+))?
+			(^(RULEMODIFIERS (m=ruleModifier{mods.add($m.start);})+))?
 			ARG_ACTION?
       		ret=ruleReturns?
       		thr=throwsSpec?
@@ -742,6 +777,7 @@ lexerAtom
     |   WILDCARD
     |	LEXER_CHAR_SET
     |   range
+    |   ruleref
     ;
 
 actionElement
@@ -767,7 +803,7 @@ alternative
 	exitAlternative((AltAST)$start);
 }
 	:	^(ALT elementOptions? element+)
-	|	^(ALT EPSILON)
+	|	^(ALT elementOptions? EPSILON)
     ;
 
 lexerCommand
@@ -912,8 +948,10 @@ setElement
 @after {
 	exitSetElement($start);
 }
-	:	STRING_LITERAL	{stringRef((TerminalAST)$STRING_LITERAL);}
-	|	TOKEN_REF		{tokenRef((TerminalAST)$TOKEN_REF);}
+	:	^(STRING_LITERAL elementOptions)    {stringRef((TerminalAST)$STRING_LITERAL);}
+	|	^(TOKEN_REF elementOptions) 		{tokenRef((TerminalAST)$TOKEN_REF);}
+	|	STRING_LITERAL                  	{stringRef((TerminalAST)$STRING_LITERAL);}
+	|	TOKEN_REF		                    {tokenRef((TerminalAST)$TOKEN_REF);}
 	|	^(RANGE a=STRING_LITERAL b=STRING_LITERAL)
 		{
 		stringRef((TerminalAST)$a);
diff --git a/tool/src/org/antlr/v4/parse/LeftRecursiveRuleWalker.g b/tool/src/org/antlr/v4/parse/LeftRecursiveRuleWalker.g
index 2ee03a64a..774243f14 100644
--- a/tool/src/org/antlr/v4/parse/LeftRecursiveRuleWalker.g
+++ b/tool/src/org/antlr/v4/parse/LeftRecursiveRuleWalker.g
@@ -67,7 +67,7 @@ rec_rule returns [boolean isLeftRec]
 	currentOuterAltNumber = 1;
 }
 	:	^(	r=RULE id=RULE_REF {ruleName=$id.getText();}
-			DOC_COMMENT? ruleModifier?
+			ruleModifier?
 //			(ARG_ACTION)? shouldn't allow args, right?
 			(^(RETURNS a=ARG_ACTION {setReturnValues($a);}))?
 //      		( ^(THROWS .+) )? don't allow
@@ -121,14 +121,14 @@ outerAlternative returns [boolean isLeftRec]
     ;
 
 binary
-	:	^( ALT elementOptions? recurse element+ recurse ACTION? )
+	:	^( ALT elementOptions? recurse element* recurse epsilonElement* )
         {setAltAssoc((AltAST)$ALT,currentOuterAltNumber);}
 	;
 
 prefix
 	:	^(	ALT elementOptions?
 			({!((CommonTree)input.LT(1)).getText().equals(ruleName)}? element)+
-			recurse ACTION?
+			recurse epsilonElement*
 		 )
          {setAltAssoc((AltAST)$ALT,currentOuterAltNumber);}
 	;
@@ -139,11 +139,12 @@ suffix
     ;
 
 nonLeftRecur
-    :   ^(ALT element+)  // no assoc for these; ignore if <assoc=...> present
+    :   ^(ALT elementOptions? element+)
     ;
 
 recurse
 	:	^(ASSIGN ID recurseNoLabel)
+	|	^(PLUS_ASSIGN ID recurseNoLabel)
 	|	recurseNoLabel
 	;
 
@@ -179,13 +180,21 @@ element
     |	^(SET setElement+)
     |   RULE_REF
 	|	ebnf
-	|	ACTION
+	|	epsilonElement
+	;
+
+epsilonElement
+	:	ACTION
 	|	SEMPRED
 	|	EPSILON
+	|	^(ACTION elementOptions)
+	|	^(SEMPRED elementOptions)
 	;
 
 setElement
-	:	STRING_LITERAL
+	:	^(STRING_LITERAL elementOptions)
+	|	^(TOKEN_REF elementOptions)
+	|	STRING_LITERAL
 	|	TOKEN_REF
 	;
 
diff --git a/tool/src/org/antlr/v4/parse/ScopeParser.java b/tool/src/org/antlr/v4/parse/ScopeParser.java
index 7eec947ca..743fe980d 100644
--- a/tool/src/org/antlr/v4/parse/ScopeParser.java
+++ b/tool/src/org/antlr/v4/parse/ScopeParser.java
@@ -32,13 +32,11 @@ package org.antlr.v4.parse;
 
 import org.antlr.runtime.BaseRecognizer;
 import org.antlr.runtime.CommonToken;
-import org.antlr.v4.runtime.misc.NotNull;
-import org.antlr.v4.runtime.misc.Nullable;
 import org.antlr.v4.runtime.misc.Pair;
 import org.antlr.v4.tool.Attribute;
 import org.antlr.v4.tool.AttributeDict;
-import org.antlr.v4.tool.ErrorManager;
 import org.antlr.v4.tool.ErrorType;
+import org.antlr.v4.tool.Grammar;
 import org.antlr.v4.tool.ast.ActionAST;
 
 import java.util.ArrayList;
@@ -54,25 +52,29 @@ import java.util.List;
 public class ScopeParser {
     /** Given an arg or retval scope definition list like
      *
-     *  Map<String, String>, int[] j3, char *foo32[3]
+     *  <code>
+     *  Map&lt;String, String&gt;, int[] j3, char *foo32[3]
+     *  </code>
      *
      *  or
      *
+     *  <code>
      *  int i=3, j=a[34]+20
+     *  </code>
      *
      *  convert to an attribute scope.
      */
-	public static AttributeDict parseTypedArgList(@Nullable ActionAST action, String s, ErrorManager errMgr) {
-		return parse(action, s, ',', errMgr);
+	public static AttributeDict parseTypedArgList(ActionAST action, String s, Grammar g) {
+		return parse(action, s, ',', g);
 	}
 
-    public static AttributeDict parse(@Nullable ActionAST action, String s, char separator, ErrorManager errMgr) {
+    public static AttributeDict parse(ActionAST action, String s, char separator, Grammar g) {
         AttributeDict dict = new AttributeDict();
 		List<Pair<String, Integer>> decls = splitDecls(s, separator);
 		for (Pair<String, Integer> decl : decls) {
 //            System.out.println("decl="+decl);
             if ( decl.a.trim().length()>0 ) {
-                Attribute a = parseAttributeDef(action, decl, errMgr);
+                Attribute a = parseAttributeDef(action, decl, g);
                 dict.add(a);
             }
 		}
@@ -84,7 +86,7 @@ public class ScopeParser {
      *  but if the separator is ',' you cannot use ',' in the initvalue
      *  unless you escape use "\," escape.
      */
-    public static Attribute parseAttributeDef(@Nullable ActionAST action, @NotNull Pair<String, Integer> decl, ErrorManager errMgr) {
+    public static Attribute parseAttributeDef(ActionAST action, Pair<String, Integer> decl, Grammar g) {
         if ( decl.a==null ) return null;
         Attribute attr = new Attribute();
         boolean inID = false;
@@ -113,7 +115,7 @@ public class ScopeParser {
             start = 0;
         }
         if ( start<0 ) {
-            errMgr.toolError(ErrorType.CANNOT_FIND_ATTRIBUTE_NAME_IN_DECL,decl);
+            g.tool.errMgr.grammarError(ErrorType.CANNOT_FIND_ATTRIBUTE_NAME_IN_DECL, g.fileName, action.token, decl);
         }
         // walk forwards looking for end of an ID
         int stop=-1;
diff --git a/tool/src/org/antlr/v4/parse/TokenVocabParser.java b/tool/src/org/antlr/v4/parse/TokenVocabParser.java
index 2893ae4a6..85398e6ec 100644
--- a/tool/src/org/antlr/v4/parse/TokenVocabParser.java
+++ b/tool/src/org/antlr/v4/parse/TokenVocabParser.java
@@ -34,12 +34,15 @@ import org.antlr.runtime.Token;
 import org.antlr.v4.Tool;
 import org.antlr.v4.codegen.CodeGenerator;
 import org.antlr.v4.tool.ErrorType;
+import org.antlr.v4.tool.Grammar;
+import org.antlr.v4.tool.ast.GrammarAST;
 
 import java.io.BufferedReader;
 import java.io.File;
+import java.io.FileInputStream;
 import java.io.FileNotFoundException;
-import java.io.FileReader;
 import java.io.IOException;
+import java.io.InputStreamReader;
 import java.util.LinkedHashMap;
 import java.util.Map;
 import java.util.regex.Matcher;
@@ -47,12 +50,10 @@ import java.util.regex.Pattern;
 
 /** */
 public class TokenVocabParser {
-	protected final Tool tool;
-	protected final String vocabName;
+	protected final Grammar g;
 
-	public TokenVocabParser(Tool tool, String vocabName) {
-		this.tool = tool;
-		this.vocabName = vocabName;
+	public TokenVocabParser(Grammar g) {
+		this.g = g;
 	}
 
 	/** Load a vocab file {@code <vocabName>.tokens} and return mapping. */
@@ -60,12 +61,22 @@ public class TokenVocabParser {
 		Map<String,Integer> tokens = new LinkedHashMap<String,Integer>();
 		int maxTokenType = -1;
 		File fullFile = getImportedVocabFile();
-		FileReader fr = null;
+		FileInputStream fis = null;
 		BufferedReader br = null;
+		Tool tool = g.tool;
+		String vocabName = g.getOptionString("tokenVocab");
 		try {
 			Pattern tokenDefPattern = Pattern.compile("([^\n]+?)[ \\t]*?=[ \\t]*?([0-9]+)");
-			fr = new FileReader(fullFile);
-			br = new BufferedReader(fr);
+			fis = new FileInputStream(fullFile);
+			InputStreamReader isr;
+			if (tool.grammarEncoding != null) {
+				isr = new InputStreamReader(fis, tool.grammarEncoding);
+			}
+			else {
+				isr = new InputStreamReader(fis);
+			}
+
+			br = new BufferedReader(isr);
 			String tokenDef = br.readLine();
 			int lineNum = 1;
 			while ( tokenDef!=null ) {
@@ -93,7 +104,7 @@ public class TokenVocabParser {
 					if ( tokenDef.length()>0 ) { // ignore blank lines
 						tool.errMgr.toolError(ErrorType.TOKENS_FILE_SYNTAX_ERROR,
 											  vocabName + CodeGenerator.VOCAB_FILE_EXTENSION,
-											  " bad token def: "+tokenDef,
+											  " bad token def: " + tokenDef,
 											  lineNum);
 					}
 				}
@@ -101,13 +112,25 @@ public class TokenVocabParser {
 			}
 		}
 		catch (FileNotFoundException fnfe) {
-			tool.errMgr.toolError(ErrorType.CANNOT_FIND_TOKENS_FILE,
-								  fullFile);
+			GrammarAST inTree = g.ast.getOptionAST("tokenVocab");
+			String inTreeValue = inTree.getToken().getText();
+			if ( vocabName.equals(inTreeValue) ) {
+				tool.errMgr.grammarError(ErrorType.CANNOT_FIND_TOKENS_FILE_REFD_IN_GRAMMAR,
+										 g.fileName,
+										 inTree.getToken(),
+										 fullFile);
+			}
+			else { // must be from -D option on cmd-line not token in tree
+				tool.errMgr.toolError(ErrorType.CANNOT_FIND_TOKENS_FILE_GIVEN_ON_CMDLINE,
+									  fullFile,
+									  g.name);
+			}
 		}
 		catch (Exception e) {
 			tool.errMgr.toolError(ErrorType.ERROR_READING_TOKENS_FILE,
+								  e,
 								  fullFile,
-								  e);
+								  e.getMessage());
 		}
 		finally {
 			try {
@@ -115,8 +138,9 @@ public class TokenVocabParser {
 			}
 			catch (IOException ioe) {
 				tool.errMgr.toolError(ErrorType.ERROR_READING_TOKENS_FILE,
+									  ioe,
 									  fullFile,
-									  ioe);
+									  ioe.getMessage());
 			}
 		}
 		return tokens;
@@ -132,8 +156,8 @@ public class TokenVocabParser {
 	 *  was no output directory specified.
 	 */
 	public File getImportedVocabFile() {
-
-		File f = new File(tool.libDirectory,
+		String vocabName = g.getOptionString("tokenVocab");
+		File f = new File(g.tool.libDirectory,
 						  File.separator +
 						  vocabName +
 						  CodeGenerator.VOCAB_FILE_EXTENSION);
@@ -145,7 +169,7 @@ public class TokenVocabParser {
 		// to look for it in the output directory which is where .tokens
 		// files are generated (in the base, not relative to the input
 		// location.)
-		f = new File(tool.outputDirectory, vocabName + CodeGenerator.VOCAB_FILE_EXTENSION);
+		f = new File(g.tool.outputDirectory, vocabName + CodeGenerator.VOCAB_FILE_EXTENSION);
 		return f;
 	}
 }
diff --git a/tool/src/org/antlr/v4/semantics/BasicSemanticChecks.java b/tool/src/org/antlr/v4/semantics/BasicSemanticChecks.java
index 0acc71ca2..4853c3795 100644
--- a/tool/src/org/antlr/v4/semantics/BasicSemanticChecks.java
+++ b/tool/src/org/antlr/v4/semantics/BasicSemanticChecks.java
@@ -47,6 +47,7 @@ import org.antlr.v4.tool.ast.GrammarAST;
 import org.antlr.v4.tool.ast.GrammarASTWithOptions;
 import org.antlr.v4.tool.ast.GrammarRootAST;
 import org.antlr.v4.tool.ast.RuleAST;
+import org.antlr.v4.tool.ast.RuleRefAST;
 import org.antlr.v4.tool.ast.TerminalAST;
 import org.stringtemplate.v4.misc.MultiMap;
 
@@ -101,18 +102,37 @@ public class BasicSemanticChecks extends GrammarTreeVisitor {
 	public RuleCollector ruleCollector;
 	public ErrorManager errMgr;
 
+	/**
+	 * When this is {@code true}, the semantic checks will report
+	 * {@link ErrorType#UNRECOGNIZED_ASSOC_OPTION} where appropriate. This may
+	 * be set to {@code false} to disable this specific check.
+	 *
+	 * <p>The default value is {@code true}.</p>
+	 */
+	public boolean checkAssocElementOption = true;
+
 	/**
 	 * This field is used for reporting the {@link ErrorType#MODE_WITHOUT_RULES}
 	 * error when necessary.
 	 */
 	protected int nonFragmentRuleCount;
 
+	/**
+	 * This is {@code true} from the time {@link #discoverLexerRule} is called
+	 * for a lexer rule with the {@code fragment} modifier until
+	 * {@link #exitLexerRule} is called.
+	 */
+	private boolean inFragmentRule;
+
 	public BasicSemanticChecks(Grammar g, RuleCollector ruleCollector) {
 		this.g = g;
 		this.ruleCollector = ruleCollector;
 		this.errMgr = g.tool.errMgr;
 	}
 
+	@Override
+	public ErrorManager getErrorManager() { return errMgr; }
+
 	public void process() {	visitGrammar(g.ast); }
 
 	// Routines to route visitor traffic to the checking routines
@@ -191,20 +211,24 @@ public class BasicSemanticChecks extends GrammarTreeVisitor {
 	{
 		checkInvalidRuleDef(ID.token);
 
-		boolean fragmentRule = false;
 		if (modifiers != null) {
 			for (GrammarAST tree : modifiers) {
 				if (tree.getType() == ANTLRParser.FRAGMENT) {
-					fragmentRule = true;
+					inFragmentRule = true;
 				}
 			}
 		}
 
-		if (!fragmentRule) {
+		if (!inFragmentRule) {
 			nonFragmentRuleCount++;
 		}
 	}
 
+	@Override
+	protected void exitLexerRule(GrammarAST tree) {
+		inFragmentRule = false;
+	}
+
 	@Override
 	public void ruleRef(GrammarAST ref, ActionAST arg) {
 		checkInvalidRuleRef(ref.token);
@@ -231,6 +255,21 @@ public class BasicSemanticChecks extends GrammarTreeVisitor {
 		checkTokenDefinition(ID.token);
 	}
 
+	@Override
+	protected void enterChannelsSpec(GrammarAST tree) {
+		if (g.isParser()) {
+			g.tool.errMgr.grammarError(ErrorType.CHANNELS_BLOCK_IN_PARSER_GRAMMAR, g.fileName, tree.token);
+		}
+		else if (g.isCombined()) {
+			g.tool.errMgr.grammarError(ErrorType.CHANNELS_BLOCK_IN_COMBINED_GRAMMAR, g.fileName, tree.token);
+		}
+	}
+
+	@Override
+	public void defineChannel(GrammarAST ID) {
+		checkChannelDefinition(ID.token);
+	}
+
 	@Override
 	public void elementOption(GrammarASTWithOptions elem, GrammarAST ID, GrammarAST valueAST) {
 		String v = null;
@@ -290,6 +329,11 @@ public class BasicSemanticChecks extends GrammarTreeVisitor {
 
 	void checkGrammarName(Token nameToken) {
 		String fullyQualifiedName = nameToken.getInputStream().getSourceName();
+		if (fullyQualifiedName == null) {
+			// This wasn't read from a file.
+			return;
+		}
+
 		File f = new File(fullyQualifiedName);
 		String fileName = f.getName();
 		if ( g.originalGrammar!=null ) return; // don't warn about diff if this is implicit lexer
@@ -305,7 +349,7 @@ public class BasicSemanticChecks extends GrammarTreeVisitor {
 			GrammarAST root = (GrammarAST)rulesNode.getParent();
 			GrammarAST IDNode = (GrammarAST)root.getChild(0);
 			g.tool.errMgr.grammarError(ErrorType.NO_RULES, g.fileName,
-									   null, IDNode.getText(), g);
+					null, IDNode.getText(), g);
 		}
 	}
 
@@ -350,8 +394,8 @@ public class BasicSemanticChecks extends GrammarTreeVisitor {
 	void checkInvalidRuleRef(Token ruleID) {
 		String fileName = ruleID.getInputStream().getSourceName();
 		if ( g.isLexer() && Character.isLowerCase(ruleID.getText().charAt(0)) ) {
-			g.tool.errMgr.grammarError(ErrorType.PARSER_RULES_NOT_ALLOWED,
-									   fileName, ruleID, ruleID.getText());
+			g.tool.errMgr.grammarError(ErrorType.PARSER_RULE_REF_IN_LEXER_RULE,
+									   fileName, ruleID, ruleID.getText(), currentRuleName);
 		}
 	}
 
@@ -365,16 +409,31 @@ public class BasicSemanticChecks extends GrammarTreeVisitor {
 		}
 	}
 
+	void checkChannelDefinition(Token tokenID) {
+	}
+
 	@Override
 	protected void enterLexerElement(GrammarAST tree) {
-		if ( tree.getType() == ACTION ) {
-			checkElementIsOuterMostInSingleAlt(tree);
-		}
 	}
 
 	@Override
 	protected void enterLexerCommand(GrammarAST tree) {
 		checkElementIsOuterMostInSingleAlt(tree);
+
+		if (inFragmentRule) {
+			String fileName = tree.token.getInputStream().getSourceName();
+			String ruleName = currentRuleName;
+			g.tool.errMgr.grammarError(ErrorType.FRAGMENT_ACTION_IGNORED, fileName, tree.token, ruleName);
+		}
+	}
+
+	@Override
+	public void actionInAlt(ActionAST action) {
+		if (inFragmentRule) {
+			String fileName = action.token.getInputStream().getSourceName();
+			String ruleName = currentRuleName;
+			g.tool.errMgr.grammarError(ErrorType.FRAGMENT_ACTION_IGNORED, fileName, action.token, ruleName);
+		}
 	}
 
 	/**
@@ -393,7 +452,6 @@ public class BasicSemanticChecks extends GrammarTreeVisitor {
 		if ( !outerMostAlt || blk.getChildCount()>1 )
 		{
 			ErrorType e = ErrorType.LEXER_COMMAND_PLACEMENT_ISSUE;
-			if ( tree.getType() == ACTION ) e = ErrorType.LEXER_ACTION_PLACEMENT_ISSUE;
 			g.tool.errMgr.grammarError(e,
 									   fileName,
 									   tree.getToken(),
@@ -433,6 +491,14 @@ public class BasicSemanticChecks extends GrammarTreeVisitor {
 								   label.getText());
 	}
 
+	@Override
+	protected void enterTerminal(GrammarAST tree) {
+		String text = tree.getText();
+		if (text.equals("''")) {
+			g.tool.errMgr.grammarError(ErrorType.EMPTY_STRINGS_NOT_ALLOWED, g.fileName, tree.token);
+		}
+	}
+
 	/** Check option is appropriate for grammar, rule, subrule */
 	boolean checkOptions(GrammarAST parent,
 						 Token optionID,
@@ -481,6 +547,20 @@ public class BasicSemanticChecks extends GrammarTreeVisitor {
 								GrammarAST ID,
 								GrammarAST valueAST)
 	{
+		if (checkAssocElementOption && ID != null && "assoc".equals(ID.getText())) {
+			if (elem.getType() != ANTLRParser.ALT) {
+				Token optionID = ID.token;
+				String fileName = optionID.getInputStream().getSourceName();
+				g.tool.errMgr.grammarError(ErrorType.UNRECOGNIZED_ASSOC_OPTION,
+										   fileName,
+										   optionID,
+										   currentRuleName);
+			}
+		}
+
+		if ( elem instanceof RuleRefAST ) {
+			return checkRuleRefOptions((RuleRefAST)elem, ID, valueAST);
+		}
 		if ( elem instanceof TerminalAST ) {
 			return checkTokenOptions((TerminalAST)elem, ID, valueAST);
 		}
@@ -501,7 +581,7 @@ public class BasicSemanticChecks extends GrammarTreeVisitor {
 		return false;
 	}
 
-	boolean checkRuleRefOptions(TerminalAST elem, GrammarAST ID, GrammarAST valueAST) {
+	boolean checkRuleRefOptions(RuleRefAST elem, GrammarAST ID, GrammarAST valueAST) {
 		Token optionID = ID.token;
 		String fileName = optionID.getInputStream().getSourceName();
 		// don't care about id<SimpleValue> options
diff --git a/tool/src/org/antlr/v4/semantics/RuleCollector.java b/tool/src/org/antlr/v4/semantics/RuleCollector.java
index 7791dcfe9..fa7eb2d31 100644
--- a/tool/src/org/antlr/v4/semantics/RuleCollector.java
+++ b/tool/src/org/antlr/v4/semantics/RuleCollector.java
@@ -36,6 +36,7 @@ import org.antlr.v4.misc.Utils;
 import org.antlr.v4.parse.GrammarTreeVisitor;
 import org.antlr.v4.parse.ScopeParser;
 import org.antlr.v4.tool.AttributeDict;
+import org.antlr.v4.tool.ErrorManager;
 import org.antlr.v4.tool.Grammar;
 import org.antlr.v4.tool.LeftRecursiveRule;
 import org.antlr.v4.tool.Rule;
@@ -52,13 +53,20 @@ import java.util.Map;
 public class RuleCollector extends GrammarTreeVisitor {
 	/** which grammar are we checking */
 	public Grammar g;
+	public ErrorManager errMgr;
 
 	// stuff to collect. this is the output
 	public OrderedHashMap<String, Rule> rules = new OrderedHashMap<String, Rule>();
 	public MultiMap<String,GrammarAST> ruleToAltLabels = new MultiMap<String, GrammarAST>();
 	public Map<String,String> altLabelToRuleName = new HashMap<String, String>();
 
-	public RuleCollector(Grammar g) { this.g = g; }
+	public RuleCollector(Grammar g) {
+		this.g = g;
+		this.errMgr = g.tool.errMgr;
+	}
+
+	@Override
+	public ErrorManager getErrorManager() { return errMgr; }
 
 	public void process(GrammarAST ast) { visitGrammar(ast); }
 
@@ -81,20 +89,20 @@ public class RuleCollector extends GrammarTreeVisitor {
 		rules.put(r.name, r);
 
 		if ( arg!=null ) {
-			r.args = ScopeParser.parseTypedArgList(arg, arg.getText(), g.tool.errMgr);
+			r.args = ScopeParser.parseTypedArgList(arg, arg.getText(), g);
 			r.args.type = AttributeDict.DictType.ARG;
 			r.args.ast = arg;
 			arg.resolver = r.alt[currentOuterAltNumber];
 		}
 
 		if ( returns!=null ) {
-			r.retvals = ScopeParser.parseTypedArgList(returns, returns.getText(), g.tool.errMgr);
+			r.retvals = ScopeParser.parseTypedArgList(returns, returns.getText(), g);
 			r.retvals.type = AttributeDict.DictType.RET;
 			r.retvals.ast = returns;
 		}
 
 		if ( locals!=null ) {
-			r.locals = ScopeParser.parseTypedArgList(locals, locals.getText(), g.tool.errMgr);
+			r.locals = ScopeParser.parseTypedArgList(locals, locals.getText(), g);
 			r.locals.type = AttributeDict.DictType.LOCAL;
 			r.locals.ast = locals;
 		}
diff --git a/tool/src/org/antlr/v4/semantics/SemanticPipeline.java b/tool/src/org/antlr/v4/semantics/SemanticPipeline.java
index 2621a5afb..ada4324ba 100644
--- a/tool/src/org/antlr/v4/semantics/SemanticPipeline.java
+++ b/tool/src/org/antlr/v4/semantics/SemanticPipeline.java
@@ -31,12 +31,13 @@
 package org.antlr.v4.semantics;
 
 import org.antlr.v4.analysis.LeftRecursiveRuleTransformer;
+import org.antlr.v4.automata.LexerATNFactory;
 import org.antlr.v4.parse.ANTLRParser;
 import org.antlr.v4.runtime.Token;
-import org.antlr.v4.runtime.misc.NotNull;
 import org.antlr.v4.runtime.misc.Pair;
 import org.antlr.v4.tool.ErrorType;
 import org.antlr.v4.tool.Grammar;
+import org.antlr.v4.tool.LexerGrammar;
 import org.antlr.v4.tool.Rule;
 import org.antlr.v4.tool.ast.GrammarAST;
 
@@ -85,14 +86,15 @@ public class SemanticPipeline {
 		BasicSemanticChecks basics = new BasicSemanticChecks(g, ruleCollector);
 		basics.process();
 
-		// don't continue if we get errors in this basic check
-		//if ( false ) return;
-
 		// TRANSFORM LEFT-RECURSIVE RULES
+		int prevErrors = g.tool.errMgr.getNumErrors();
 		LeftRecursiveRuleTransformer lrtrans =
 			new LeftRecursiveRuleTransformer(g.ast, ruleCollector.rules.values(), g);
 		lrtrans.translateLeftRecursiveRules();
 
+		// don't continue if we got errors during left-recursion elimination
+		if ( g.tool.errMgr.getNumErrors()>prevErrors ) return;
+
 		// STORE RULES IN GRAMMAR
 		for (Rule r : ruleCollector.rules.values()) {
 			g.defineRule(r);
@@ -127,6 +129,10 @@ public class SemanticPipeline {
 							 collector.tokenIDRefs, collector.terminals);
 		}
 
+		symcheck.checkForModeConflicts(g);
+
+		assignChannelTypes(g, collector.channelDefs);
+
 		// CHECK RULE REFS NOW (that we've defined rules in grammar)
 		symcheck.checkRuleArgs(g, collector.rulerefs);
 		identifyStartRules(collector);
@@ -186,13 +192,16 @@ public class SemanticPipeline {
 			for (String lit : conflictingLiterals) {
 				// Remove literal if repeated across rules so it's not
 				// found by parser grammar.
-				G.stringLiteralToTypeMap.remove(lit);
+				Integer value = G.stringLiteralToTypeMap.remove(lit);
+				if (value != null && value > 0 && value < G.typeToStringLiteralList.size() && lit.equals(G.typeToStringLiteralList.get(value))) {
+					G.typeToStringLiteralList.set(value, null);
+				}
 			}
 		}
 
 	}
 
-	boolean hasTypeOrMoreCommand(@NotNull Rule r) {
+	boolean hasTypeOrMoreCommand(Rule r) {
 		GrammarAST ast = r.ast;
 		if (ast == null) {
 			return false;
@@ -257,4 +266,42 @@ public class SemanticPipeline {
 		g.tool.log("semantics", "tokens="+g.tokenNameToTypeMap);
         g.tool.log("semantics", "strings="+g.stringLiteralToTypeMap);
 	}
+
+	/**
+	 * Assign constant values to custom channels defined in a grammar.
+	 *
+	 * @param g The grammar.
+	 * @param channelDefs A collection of AST nodes defining individual channels
+	 * within a {@code channels{}} block in the grammar.
+	 */
+	void assignChannelTypes(Grammar g, List<GrammarAST> channelDefs) {
+		Grammar outermost = g.getOutermostGrammar();
+		for (GrammarAST channel : channelDefs) {
+			String channelName = channel.getText();
+
+			// Channel names can't alias tokens or modes, because constant
+			// values are also assigned to them and the ->channel(NAME) lexer
+			// command does not distinguish between the various ways a constant
+			// can be declared. This method does not verify that channels do not
+			// alias rules, because rule names are not associated with constant
+			// values in ANTLR grammar semantics.
+
+			if (g.getTokenType(channelName) != Token.INVALID_TYPE) {
+				g.tool.errMgr.grammarError(ErrorType.CHANNEL_CONFLICTS_WITH_TOKEN, g.fileName, channel.token, channelName);
+			}
+
+			if (LexerATNFactory.COMMON_CONSTANTS.containsKey(channelName)) {
+				g.tool.errMgr.grammarError(ErrorType.CHANNEL_CONFLICTS_WITH_COMMON_CONSTANTS, g.fileName, channel.token, channelName);
+			}
+
+			if (outermost instanceof LexerGrammar) {
+				LexerGrammar lexerGrammar = (LexerGrammar)outermost;
+				if (lexerGrammar.modes.containsKey(channelName)) {
+					g.tool.errMgr.grammarError(ErrorType.CHANNEL_CONFLICTS_WITH_MODE, g.fileName, channel.token, channelName);
+				}
+			}
+
+			outermost.defineChannelName(channel.getText());
+		}
+	}
 }
diff --git a/tool/src/org/antlr/v4/semantics/SymbolChecks.java b/tool/src/org/antlr/v4/semantics/SymbolChecks.java
index b24273624..999d9f0b2 100644
--- a/tool/src/org/antlr/v4/semantics/SymbolChecks.java
+++ b/tool/src/org/antlr/v4/semantics/SymbolChecks.java
@@ -30,9 +30,9 @@
 
 package org.antlr.v4.semantics;
 
+import org.antlr.v4.automata.LexerATNFactory;
 import org.antlr.v4.parse.ANTLRParser;
-import org.antlr.v4.runtime.misc.NotNull;
-import org.antlr.v4.runtime.misc.Nullable;
+import org.antlr.v4.runtime.Token;
 import org.antlr.v4.tool.Alternative;
 import org.antlr.v4.tool.Attribute;
 import org.antlr.v4.tool.AttributeDict;
@@ -40,6 +40,7 @@ import org.antlr.v4.tool.ErrorManager;
 import org.antlr.v4.tool.ErrorType;
 import org.antlr.v4.tool.Grammar;
 import org.antlr.v4.tool.LabelElementPair;
+import org.antlr.v4.tool.LexerGrammar;
 import org.antlr.v4.tool.Rule;
 import org.antlr.v4.tool.ast.GrammarAST;
 
@@ -67,6 +68,11 @@ public class SymbolChecks {
 
 	public ErrorManager errMgr;
 
+	protected final Set<String> reservedNames = new HashSet<String>();
+	{
+		reservedNames.addAll(LexerATNFactory.getCommonConstants());
+	}
+
     public SymbolChecks(Grammar g, SymbolCollector collector) {
         this.g = g;
         this.collector = collector;
@@ -94,6 +100,7 @@ public class SymbolChecks {
 		if ( g.rules!=null ) {
 			for (Rule r : g.rules.values()) nameToRuleMap.put(r.name, r);
 		}
+		checkReservedNames(g.rules.values());
 		checkActionRedefinitions(collector.namedActions);
 		checkForTokenConflicts(collector.tokenIDRefs);  // sets tokenIDs
 		checkForLabelConflicts(g.rules.values());
@@ -224,7 +231,7 @@ public class SymbolChecks {
 		checkLocalConflictingDeclarations(r, r.locals, r.retvals, ErrorType.LOCAL_CONFLICTS_WITH_RETVAL);
 	}
 
-	protected void checkDeclarationRuleConflicts(@NotNull Rule r, @Nullable AttributeDict attributes, @NotNull Set<String> ruleNames, @NotNull ErrorType errorType) {
+	protected void checkDeclarationRuleConflicts(Rule r, AttributeDict attributes, Set<String> ruleNames, ErrorType errorType) {
 		if (attributes == null) {
 			return;
 		}
@@ -241,7 +248,7 @@ public class SymbolChecks {
 		}
 	}
 
-	protected void checkLocalConflictingDeclarations(@NotNull Rule r, @Nullable AttributeDict attributes, @Nullable AttributeDict referenceAttributes, @NotNull ErrorType errorType) {
+	protected void checkLocalConflictingDeclarations(Rule r, AttributeDict attributes, AttributeDict referenceAttributes, ErrorType errorType) {
 		if (attributes == null || referenceAttributes == null) {
 			return;
 		}
@@ -257,6 +264,31 @@ public class SymbolChecks {
 		}
 	}
 
+	protected void checkReservedNames(Collection<Rule> rules) {
+		for (Rule rule : rules) {
+			if (reservedNames.contains(rule.name)) {
+				errMgr.grammarError(ErrorType.RESERVED_RULE_NAME, g.fileName, ((GrammarAST)rule.ast.getChild(0)).getToken(), rule.name);
+			}
+		}
+	}
+
+	public void checkForModeConflicts(Grammar g) {
+		if (g.isLexer()) {
+			LexerGrammar lexerGrammar = (LexerGrammar)g;
+			for (String modeName : lexerGrammar.modes.keySet()) {
+				if (!modeName.equals("DEFAULT_MODE") && reservedNames.contains(modeName)) {
+					Rule rule = lexerGrammar.modes.get(modeName).iterator().next();
+					g.tool.errMgr.grammarError(ErrorType.MODE_CONFLICTS_WITH_COMMON_CONSTANTS, g.fileName, rule.ast.parent.getToken(), modeName);
+				}
+
+				if (g.getTokenType(modeName) != Token.INVALID_TYPE) {
+					Rule rule = lexerGrammar.modes.get(modeName).iterator().next();
+					g.tool.errMgr.grammarError(ErrorType.MODE_CONFLICTS_WITH_TOKEN, g.fileName, rule.ast.parent.getToken(), modeName);
+				}
+			}
+		}
+	}
+
 	// CAN ONLY CALL THE TWO NEXT METHODS AFTER GRAMMAR HAS RULE DEFS (see semanticpipeline)
 
 	public void checkRuleArgs(Grammar g, List<GrammarAST> rulerefs) {
diff --git a/tool/src/org/antlr/v4/semantics/SymbolCollector.java b/tool/src/org/antlr/v4/semantics/SymbolCollector.java
index fd2cad13c..b0c43a49b 100644
--- a/tool/src/org/antlr/v4/semantics/SymbolCollector.java
+++ b/tool/src/org/antlr/v4/semantics/SymbolCollector.java
@@ -31,6 +31,7 @@
 package org.antlr.v4.semantics;
 
 import org.antlr.v4.parse.GrammarTreeVisitor;
+import org.antlr.v4.tool.ErrorManager;
 import org.antlr.v4.tool.Grammar;
 import org.antlr.v4.tool.LabelElementPair;
 import org.antlr.v4.tool.Rule;
@@ -64,14 +65,23 @@ public class SymbolCollector extends GrammarTreeVisitor {
 	public List<GrammarAST> tokenIDRefs = new ArrayList<GrammarAST>();
 	public Set<String> strings = new HashSet<String>();
 	public List<GrammarAST> tokensDefs = new ArrayList<GrammarAST>();
+	public List<GrammarAST> channelDefs = new ArrayList<GrammarAST>();
 
 	/** Track action name node in @parser::members {...} or @members {...} */
 	List<GrammarAST> namedActions = new ArrayList<GrammarAST>();
 
+	public ErrorManager errMgr;
+
 	// context
 	public Rule currentRule;
 
-	public SymbolCollector(Grammar g) { this.g = g; }
+	public SymbolCollector(Grammar g) {
+		this.g = g;
+		this.errMgr = g.tool.errMgr;
+	}
+
+	@Override
+	public ErrorManager getErrorManager() { return errMgr; }
 
 	public void process(GrammarAST ast) { visitGrammar(ast); }
 
@@ -88,6 +98,11 @@ public class SymbolCollector extends GrammarTreeVisitor {
 		tokensDefs.add(ID);
 	}
 
+	@Override
+	public void defineChannel(GrammarAST ID) {
+		channelDefs.add(ID);
+	}
+
 	@Override
 	public void discoverRule(RuleAST rule, GrammarAST ID,
 							 List<GrammarAST> modifiers, ActionAST arg,
diff --git a/tool/src/org/antlr/v4/tool/ANTLRMessage.java b/tool/src/org/antlr/v4/tool/ANTLRMessage.java
index 5b2ca150d..36d9ab9ff 100644
--- a/tool/src/org/antlr/v4/tool/ANTLRMessage.java
+++ b/tool/src/org/antlr/v4/tool/ANTLRMessage.java
@@ -30,18 +30,19 @@
 
 package org.antlr.v4.tool;
 
-import org.antlr.v4.runtime.misc.NotNull;
-import org.antlr.v4.runtime.misc.Nullable;
+import org.antlr.runtime.Token;
+import org.stringtemplate.v4.ST;
+
 import java.util.Arrays;
 
 public class ANTLRMessage {
 	private static final Object[] EMPTY_ARGS = new Object[0];
 
-	@NotNull
+
     private final ErrorType errorType;
-	@Nullable
+
     private final Object[] args;
-	@Nullable
+
     private final Throwable e;
 
     // used for location template
@@ -49,26 +50,33 @@ public class ANTLRMessage {
     public int line = -1;
     public int charPosition = -1;
 
-    public ANTLRMessage(@NotNull ErrorType errorType) {
-        this(errorType, (Throwable)null);
+	public Grammar g;
+	/** Most of the time, we'll have a token such as an undefined rule ref
+     *  and so this will be set.
+     */
+    public Token offendingToken;
+
+	public ANTLRMessage(ErrorType errorType) {
+        this(errorType, (Throwable)null, Token.INVALID_TOKEN);
     }
 
-    public ANTLRMessage(@NotNull ErrorType errorType, Object... args) {
-        this(errorType, null, args);
-    }
+    public ANTLRMessage(ErrorType errorType, Token offendingToken, Object... args) {
+        this(errorType, null, offendingToken, args);
+	}
 
-    public ANTLRMessage(@NotNull ErrorType errorType, @Nullable Throwable e, Object... args) {
+    public ANTLRMessage(ErrorType errorType, Throwable e, Token offendingToken, Object... args) {
         this.errorType = errorType;
         this.e = e;
         this.args = args;
+		this.offendingToken = offendingToken;
     }
 
-	@NotNull
+
     public ErrorType getErrorType() {
         return errorType;
     }
 
-	@NotNull
+
     public Object[] getArgs() {
 		if (args == null) {
 			return EMPTY_ARGS;
@@ -77,7 +85,33 @@ public class ANTLRMessage {
 		return args;
     }
 
-	@Nullable
+	public ST getMessageTemplate(boolean verbose) {
+		ST messageST = new ST(getErrorType().msg);
+		messageST.impl.name = errorType.name();
+
+		messageST.add("verbose", verbose);
+		Object[] args = getArgs();
+		for (int i=0; i<args.length; i++) {
+			String attr = "arg";
+			if ( i>0 ) attr += i + 1;
+			messageST.add(attr, args[i]);
+		}
+		if ( args.length<2 ) messageST.add("arg2", null); // some messages ref arg2
+
+		Throwable cause = getCause();
+		if ( cause!=null ) {
+			messageST.add("exception", cause);
+			messageST.add("stackTrace", cause.getStackTrace());
+		}
+		else {
+			messageST.add("exception", null); // avoid ST error msg
+			messageST.add("stackTrace", null);
+		}
+
+		return messageST;
+	}
+
+
     public Throwable getCause() {
         return e;
     }
diff --git a/tool/src/org/antlr/v4/tool/Alternative.java b/tool/src/org/antlr/v4/tool/Alternative.java
index c73a38872..3d5e1cb24 100644
--- a/tool/src/org/antlr/v4/tool/Alternative.java
+++ b/tool/src/org/antlr/v4/tool/Alternative.java
@@ -92,7 +92,6 @@ public class Alternative implements AttributeResolver {
         if ( ruleRefs.get(x)!=null ) return true; // rule ref in this alt?
         LabelElementPair anyLabelDef = getAnyLabelDef(x);
         if ( anyLabelDef!=null && anyLabelDef.type==LabelType.RULE_LABEL ) return true;
-		if ( x.equals(rule.name) ) return true; // $r for action in rule r, $r is a dict
 		return false;
 	}
 
@@ -108,9 +107,6 @@ public class Alternative implements AttributeResolver {
 	 */
 	@Override
 	public Attribute resolveToAttribute(String x, String y, ActionAST node) {
-		if ( rule.name.equals(x) ) { // x is this rule?
-			return rule.resolveToAttribute(x, y, node);
-		}
         if ( tokenRefs.get(x)!=null ) { // token ref in this alt?
             return rule.getPredefinedScope(LabelType.TOKEN_LABEL).get(y);
         }
@@ -162,7 +158,6 @@ public class Alternative implements AttributeResolver {
 		if ( anyLabelDef!=null && anyLabelDef.type==LabelType.RULE_LABEL ) {
             return rule.g.getRule(anyLabelDef.element.getText());
         }
-		if ( x.equals(rule.name) ) return rule;
         return null;
     }
 }
diff --git a/tool/src/org/antlr/v4/tool/AttributeDict.java b/tool/src/org/antlr/v4/tool/AttributeDict.java
index 679bd9200..e8d487f0d 100644
--- a/tool/src/org/antlr/v4/tool/AttributeDict.java
+++ b/tool/src/org/antlr/v4/tool/AttributeDict.java
@@ -31,8 +31,6 @@
 package org.antlr.v4.tool;
 
 import org.antlr.v4.runtime.Token;
-import org.antlr.v4.runtime.misc.NotNull;
-import org.antlr.v4.runtime.misc.Nullable;
 import org.antlr.v4.tool.ast.GrammarAST;
 
 import java.util.Collections;
@@ -41,7 +39,7 @@ import java.util.LinkedHashMap;
 import java.util.Set;
 
 /** Track the attributes within retval, arg lists etc...
- *  <p/>
+ *  <p>
  *  Each rule has potentially 3 scopes: return values,
  *  parameters, and an implicitly-named scope (i.e., a scope defined in a rule).
  *  Implicitly-defined scopes are named after the rule; rules and scopes then
@@ -73,7 +71,7 @@ public class AttributeDict {
     }
 
     /** The list of {@link Attribute} objects. */
-	@NotNull
+
     public final LinkedHashMap<String, Attribute> attributes =
         new LinkedHashMap<String, Attribute>();
 
@@ -92,8 +90,8 @@ public class AttributeDict {
     /** Return the set of keys that collide from
      *  {@code this} and {@code other}.
      */
-	@NotNull
-    public Set<String> intersection(@Nullable AttributeDict other) {
+
+    public Set<String> intersection(AttributeDict other) {
         if ( other==null || other.size()==0 || size()==0 ) {
             return Collections.emptySet();
         }
diff --git a/tool/src/org/antlr/v4/tool/DOTGenerator.java b/tool/src/org/antlr/v4/tool/DOTGenerator.java
index 3788310dd..740bfe459 100644
--- a/tool/src/org/antlr/v4/tool/DOTGenerator.java
+++ b/tool/src/org/antlr/v4/tool/DOTGenerator.java
@@ -43,6 +43,7 @@ import org.antlr.v4.runtime.atn.NotSetTransition;
 import org.antlr.v4.runtime.atn.PlusBlockStartState;
 import org.antlr.v4.runtime.atn.PlusLoopbackState;
 import org.antlr.v4.runtime.atn.RangeTransition;
+import org.antlr.v4.runtime.atn.RuleStartState;
 import org.antlr.v4.runtime.atn.RuleStopState;
 import org.antlr.v4.runtime.atn.RuleTransition;
 import org.antlr.v4.runtime.atn.SetTransition;
@@ -243,7 +244,14 @@ public class DOTGenerator {
 					RuleTransition rr = ((RuleTransition)edge);
 					// don't jump to other rules, but display edge to follow node
 					edgeST = stlib.getInstanceOf("edge");
-					edgeST.add("label", "<"+ruleNames[rr.ruleIndex]+">");
+
+					String label = "<" + ruleNames[rr.ruleIndex];
+					if (((RuleStartState)rr.target).isLeftRecursiveRule) {
+						label += "[" + rr.precedence + "]";
+					}
+					label += ">";
+
+					edgeST.add("label", label);
 					edgeST.add("src", "s"+s.stateNumber);
 					edgeST.add("target", "s"+rr.followState.stateNumber);
 					edgeST.add("arrowhead", arrowhead);
@@ -284,7 +292,7 @@ public class DOTGenerator {
 					SetTransition set = (SetTransition)edge;
 					String label = set.label().toString();
 					if ( isLexer ) label = set.label().toString(true);
-					else if ( grammar!=null ) label = set.label().toString(grammar.getTokenNames());
+					else if ( grammar!=null ) label = set.label().toString(grammar.getVocabulary());
 					if ( edge instanceof NotSetTransition ) label = "~"+label;
 					edgeST.add("label", getEdgeLabel(label));
 				}
@@ -293,7 +301,7 @@ public class DOTGenerator {
 					RangeTransition range = (RangeTransition)edge;
 					String label = range.label().toString();
 					if ( isLexer ) label = range.toString();
-					else if ( grammar!=null ) label = range.label().toString(grammar.getTokenNames());
+					else if ( grammar!=null ) label = range.label().toString(grammar.getVocabulary());
 					edgeST.add("label", getEdgeLabel(label));
 				}
 				else {
diff --git a/tool/src/org/antlr/v4/tool/ErrorManager.java b/tool/src/org/antlr/v4/tool/ErrorManager.java
index 7c961b98b..983c41b45 100644
--- a/tool/src/org/antlr/v4/tool/ErrorManager.java
+++ b/tool/src/org/antlr/v4/tool/ErrorManager.java
@@ -32,12 +32,11 @@ package org.antlr.v4.tool;
 
 import org.antlr.v4.Tool;
 import org.stringtemplate.v4.ST;
-import org.stringtemplate.v4.STErrorListener;
 import org.stringtemplate.v4.STGroup;
 import org.stringtemplate.v4.STGroupFile;
 import org.stringtemplate.v4.misc.ErrorBuffer;
-import org.stringtemplate.v4.misc.STMessage;
 
+import java.io.File;
 import java.net.URL;
 import java.util.Collection;
 import java.util.EnumSet;
@@ -63,29 +62,6 @@ public class ErrorManager {
 
     ErrorBuffer initSTListener = new ErrorBuffer();
 
-    STErrorListener theDefaultSTListener =
-        new STErrorListener() {
-            @Override
-            public void compileTimeError(STMessage msg) {
-                ErrorManager.internalError(msg.toString());
-            }
-
-            @Override
-            public void runTimeError(STMessage msg) {
-                ErrorManager.internalError(msg.toString());
-            }
-
-            @Override
-            public void IOError(STMessage msg) {
-                ErrorManager.internalError(msg.toString());
-            }
-
-            @Override
-            public void internalError(STMessage msg) {
-                ErrorManager.internalError(msg.toString());
-            }
-        };
-
 	public ErrorManager(Tool tool) {
 		this.tool = tool;
 	}
@@ -96,30 +72,11 @@ public class ErrorManager {
 	}
 
 	public ST getMessageTemplate(ANTLRMessage msg) {
-		ST messageST = new ST(msg.getErrorType().msg);
+		ST messageST = msg.getMessageTemplate(tool.longMessages);
 		ST locationST = getLocationFormat();
 		ST reportST = getReportFormat(msg.getErrorType().severity);
 		ST messageFormatST = getMessageFormat();
 
-		messageST.add("verbose", tool.longMessages);
-		Object[] args = msg.getArgs();
-		for (int i=0; i<args.length; i++) {
-			String attr = "arg";
-			if ( i>0 ) attr += i + 1;
-			messageST.add(attr, args[i]);
-		}
-		if ( args.length<2 ) messageST.add("arg2", null); // some messages ref arg2
-
-		Throwable cause = msg.getCause();
-		if ( cause!=null ) {
-			messageST.add("exception", cause);
-			messageST.add("stackTrace", cause.getStackTrace());
-		}
-		else {
-			messageST.add("exception", null); // avoid ST error msg
-			messageST.add("stackTrace", null);
-		}
-
 		boolean locationValid = false;
 		if (msg.line != -1) {
 			locationST.add("line", msg.line);
@@ -130,7 +87,13 @@ public class ErrorManager {
 			locationValid = true;
 		}
 		if (msg.fileName != null) {
-			locationST.add("file", msg.fileName);
+			File f = new File(msg.fileName);
+			// Don't show path to file in messages; too long.
+			String displayFileName = msg.fileName;
+			if ( f.exists() ) {
+				displayFileName = f.getName();
+			}
+			locationST.add("file", displayFileName);
 			locationValid = true;
 		}
 
@@ -200,8 +163,7 @@ public class ErrorManager {
      * @param args The arguments to pass to the StringTemplate
      */
 	public void toolError(ErrorType errorType, Object... args) {
-		ToolMessage msg = new ToolMessage(errorType, args);
-		emit(errorType, msg);
+		toolError(errorType, null, args);
 	}
 
 	public void toolError(ErrorType errorType, Throwable e, Object... args) {
@@ -337,6 +299,16 @@ public class ErrorManager {
         e.printStackTrace(System.err);
     }
 
+	public void panic(ErrorType errorType, Object... args) {
+		ToolMessage msg = new ToolMessage(errorType, args);
+		ST msgST = getMessageTemplate(msg);
+		String outputMsg = msgST.render();
+		if ( formatWantsSingleLineMessage() ) {
+			outputMsg = outputMsg.replace('\n', ' ');
+		}
+		panic(outputMsg);
+	}
+
 	public static void panic(String msg) {
 		rawError(msg);
 		panic();
diff --git a/tool/src/org/antlr/v4/tool/ErrorType.java b/tool/src/org/antlr/v4/tool/ErrorType.java
index bc36937f7..32bb57475 100644
--- a/tool/src/org/antlr/v4/tool/ErrorType.java
+++ b/tool/src/org/antlr/v4/tool/ErrorType.java
@@ -30,108 +30,613 @@
 package org.antlr.v4.tool;
 
 import org.antlr.v4.Tool;
+import org.antlr.v4.runtime.Lexer;
 
 /**
  * A complex enumeration of all the error messages that the tool can issue.
- * <p/>
+ * <p>
  * When adding error messages, also add a description of the message to the
  * Wiki with a location under the Wiki page
  * <a href="http://www.antlr.org/wiki/display/ANTLR4/Errors+Reported+by+the+ANTLR+Tool">Errors Reported by the ANTLR Tool</a>.
  *
- * @author Jim Idle <jimi@temporal-wave.com>, Terence Parr
+ * @author Jim Idle &lt;jimi@temporal-wave.com&gt;, Terence Parr
  * @since 4.0
  */
 public enum ErrorType {
-	// Tool errors
-	CANNOT_WRITE_FILE(1, "cannot write file '<arg>': <arg2>", ErrorSeverity.ERROR),
-	INVALID_CMDLINE_ARG(2, "unknown command-line option '<arg>'", ErrorSeverity.ERROR),
-	CANNOT_FIND_TOKENS_FILE(3, "cannot find tokens file '<arg>'", ErrorSeverity.ERROR),
-	ERROR_READING_TOKENS_FILE(4, "cannot find tokens file '<arg>': <arg2>", ErrorSeverity.ERROR),
-	DIR_NOT_FOUND(5, "directory not found: <arg>", ErrorSeverity.ERROR),
-	OUTPUT_DIR_IS_FILE(6, "output directory is a file: <arg>", ErrorSeverity.ERROR),
-	CANNOT_OPEN_FILE(7, "cannot find or open file: <arg><if(exception&&verbose)>; reason: <exception><endif>", ErrorSeverity.ERROR),
-	FILE_AND_GRAMMAR_NAME_DIFFER(8, "grammar name '<arg>' and file name '<arg2>' differ", ErrorSeverity.ERROR),
-	BAD_OPTION_SET_SYNTAX(9, "invalid -Dname=value syntax: '<arg>'", ErrorSeverity.ERROR),
-	WARNING_TREATED_AS_ERROR(10, "warning treated as error", ErrorSeverity.ERROR_ONE_OFF),
+	/*
+	 * Tool errors
+	 */
 
+	/**
+	 * Compiler Error 1.
+	 *
+	 * <p>cannot write file <em>filename</em>: <em>reason</em></p>
+	 */
+	CANNOT_WRITE_FILE(1, "cannot write file <arg>: <arg2>", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 2.
+	 *
+	 * <p>unknown command-line option <em>option</em></p>
+	 */
+	INVALID_CMDLINE_ARG(2, "unknown command-line option <arg>", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 3.
+	 *
+	 * <p>cannot find tokens file <em>filename</em></p>
+	 */
+	CANNOT_FIND_TOKENS_FILE_GIVEN_ON_CMDLINE(3, "cannot find tokens file <arg> given for <arg2>", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 4.
+	 *
+	 * <p>cannot find tokens file <em>filename</em>: <em>reason</em></p>
+	 */
+	ERROR_READING_TOKENS_FILE(4, "error reading tokens file <arg>: <arg2>", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 5.
+	 *
+	 * <p>directory not found: <em>directory</em></p>
+	 */
+	DIR_NOT_FOUND(5, "directory not found: <arg>", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 6.
+	 *
+	 * <p>output directory is a file: <em>filename</em></p>
+	 */
+	OUTPUT_DIR_IS_FILE(6, "output directory is a file: <arg>", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 7.
+	 *
+	 * <p>cannot find or open file: <em>filename</em></p>
+	 */
+	CANNOT_OPEN_FILE(7, "cannot find or open file: <arg><if(exception&&verbose)>; reason: <exception><endif>", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 8.
+	 *
+	 * <p>
+	 * grammar name <em>name</em> and file name <em>filename</em> differ</p>
+	 */
+	FILE_AND_GRAMMAR_NAME_DIFFER(8, "grammar name <arg> and file name <arg2> differ", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 9.
+	 *
+	 * <p>invalid {@code -Dname=value} syntax: <em>syntax</em></p>
+	 */
+	BAD_OPTION_SET_SYNTAX(9, "invalid -Dname=value syntax: <arg>", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 10.
+	 *
+	 * <p>warning treated as error</p>
+	 */
+	WARNING_TREATED_AS_ERROR(10, "warning treated as error", ErrorSeverity.ERROR_ONE_OFF),
+	/**
+	 * Compiler Error 11.
+	 *
+	 * <p>cannot find tokens file <em>filename</em>: <em>reason</em></p>
+	 */
+	ERROR_READING_IMPORTED_GRAMMAR(11, "error reading imported grammar <arg> referenced in <arg2>", ErrorSeverity.ERROR),
+
+	/**
+	 * Compiler Error 20.
+	 *
+	 * <p>internal error: <em>message</em></p>
+	 */
 	INTERNAL_ERROR(20, "internal error: <arg> <arg2><if(exception&&verbose)>: <exception>" +
 				   "<stackTrace; separator=\"\\n\"><endif>", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 21.
+	 *
+	 * <p>.tokens file syntax error <em>filename</em>: <em>message</em></p>
+	 */
 	TOKENS_FILE_SYNTAX_ERROR(21, ".tokens file syntax error <arg>:<arg2>", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Warning 22.
+	 *
+	 * <p>template error: <em>message</em></p>
+	 */
 	STRING_TEMPLATE_WARNING(22, "template error: <arg> <arg2><if(exception&&verbose)>: <exception>" +
 				   "<stackTrace; separator=\"\\n\"><endif>", ErrorSeverity.WARNING),
 
-	// Code generation errors
-	MISSING_CODE_GEN_TEMPLATES(30, "can't find code generation templates: <arg>", ErrorSeverity.ERROR),
-	CANNOT_CREATE_TARGET_GENERATOR(31, "ANTLR cannot generate '<arg>' code as of version "+ Tool.VERSION, ErrorSeverity.ERROR),
-	CODE_TEMPLATE_ARG_ISSUE(32, "code generation template '<arg>' has missing, misnamed, or incomplete arg list; missing '<arg2>'", ErrorSeverity.ERROR),
-	CODE_GEN_TEMPLATES_INCOMPLETE(33, "missing code generation template '<arg>'", ErrorSeverity.ERROR),
-	NO_MODEL_TO_TEMPLATE_MAPPING(34, "no mapping to template name for output model class '<arg>'", ErrorSeverity.ERROR),
+	/*
+	 * Code generation errors
+	 */
 
-	// Grammar errors
-	SYNTAX_ERROR(50, "syntax error: <arg>", ErrorSeverity.ERROR),
-	RULE_REDEFINITION(51, "rule '<arg>' redefinition; previous at line <arg2>", ErrorSeverity.ERROR),
-	LEXER_RULES_NOT_ALLOWED(52, "lexer rule '<arg>' not allowed in parser", ErrorSeverity.ERROR),
-	PARSER_RULES_NOT_ALLOWED(53, "parser rule '<arg>' not allowed in lexer", ErrorSeverity.ERROR),
-    REPEATED_PREQUEL(54, "repeated grammar prequel spec (option, token, or import); please merge", ErrorSeverity.ERROR),
-	UNDEFINED_RULE_REF(56, "reference to undefined rule: <arg>", ErrorSeverity.ERROR),
-	UNDEFINED_RULE_IN_NONLOCAL_REF(57, "reference to undefined rule '<arg>' in non-local ref '<arg3>'", ErrorSeverity.ERROR),
-    TOKEN_NAMES_MUST_START_UPPER(60, "token names must start with an uppercase letter: <arg>", ErrorSeverity.ERROR),
-	UNKNOWN_SIMPLE_ATTRIBUTE(63, "unknown attribute reference '<arg>' in '<arg2>'", ErrorSeverity.ERROR),
-	INVALID_RULE_PARAMETER_REF(64, "parameter '<arg>' of rule '<arg2>' is not accessible in this scope: <arg3>", ErrorSeverity.ERROR),
-	UNKNOWN_RULE_ATTRIBUTE(65, "unknown attribute '<arg>' for rule '<arg2>' in '<arg3>'", ErrorSeverity.ERROR),
-    UNKNOWN_ATTRIBUTE_IN_SCOPE(66, "attribute '<arg>' isn't a valid property in '<arg2>'", ErrorSeverity.ERROR),
-	ISOLATED_RULE_REF(67, "missing attribute access on rule reference '<arg>' in '<arg2>'", ErrorSeverity.ERROR),
-	LABEL_CONFLICTS_WITH_RULE(69, "label '<arg>' conflicts with rule with same name", ErrorSeverity.ERROR),
-	LABEL_CONFLICTS_WITH_TOKEN(70, "label '<arg>' conflicts with token with same name", ErrorSeverity.ERROR),
-	LABEL_CONFLICTS_WITH_ARG(72, "label '<arg>' conflicts with parameter with same name", ErrorSeverity.ERROR),
-	LABEL_CONFLICTS_WITH_RETVAL(73, "label '<arg>' conflicts with return value with same name", ErrorSeverity.ERROR),
-	LABEL_CONFLICTS_WITH_LOCAL(74, "label '<arg>' conflicts with local with same name", ErrorSeverity.ERROR),
-	LABEL_TYPE_CONFLICT(75, "label '<arg>' type mismatch with previous definition: <arg2>", ErrorSeverity.ERROR),
-	RETVAL_CONFLICTS_WITH_ARG(76, "return value '<arg>' conflicts with parameter with same name", ErrorSeverity.ERROR),
-	MISSING_RULE_ARGS(79, "missing arguments(s) on rule reference: <arg>", ErrorSeverity.ERROR),
-	RULE_HAS_NO_ARGS(80, "rule '<arg>' has no defined parameters", ErrorSeverity.ERROR),
-	ILLEGAL_OPTION(83, "unsupported option '<arg>'", ErrorSeverity.WARNING),
-	ILLEGAL_OPTION_VALUE(84, "unsupported option value '<arg>=<arg2>'", ErrorSeverity.WARNING),
-    ACTION_REDEFINITION(94, "redefinition of '<arg>' action", ErrorSeverity.ERROR),
-	NO_RULES(99, "<if(arg2.implicitLexerOwner)>implicitly generated <endif>grammar '<arg>' has no rules", ErrorSeverity.ERROR),
-	NO_SUCH_GRAMMAR_SCOPE(105, "reference to undefined grammar in rule reference: <arg>.<arg2>", ErrorSeverity.ERROR),
-	NO_SUCH_RULE_IN_SCOPE(106, "rule '<arg2>' is not defined in grammar '<arg>'", ErrorSeverity.ERROR),
-	TOKEN_NAME_REASSIGNMENT(108, "token name '<arg>' is already defined", ErrorSeverity.WARNING),
-	OPTIONS_IN_DELEGATE(109, "options ignored in imported grammar '<arg>'", ErrorSeverity.WARNING),
-	CANNOT_FIND_IMPORTED_GRAMMAR(110, "can't find or load grammar '<arg>' from '<arg2>'", ErrorSeverity.ERROR),
-	INVALID_IMPORT(111, "<arg.typeString> grammar '<arg.name>' cannot import <arg2.typeString> grammar '<arg2.name>'", ErrorSeverity.ERROR),
-	IMPORT_NAME_CLASH(113, "<arg.typeString> grammar '<arg.name>' and imported <arg2.typeString> grammar '<arg2.name>' both generate '<arg2.recognizerName>'", ErrorSeverity.ERROR),
-	ALL_OPS_NEED_SAME_ASSOC(118, "all operators of alt '<arg>' of left-recursive rule must have same associativity", ErrorSeverity.WARNING),
-	LEFT_RECURSION_CYCLES(119, "The following sets of rules are mutually left-recursive <arg:{c| [<c:{r|<r.name>}; separator=\", \">]}; separator=\" and \">", ErrorSeverity.ERROR),
-	MODE_NOT_IN_LEXER(120, "lexical modes are only allowed in lexer grammars", ErrorSeverity.ERROR),
-	CANNOT_FIND_ATTRIBUTE_NAME_IN_DECL(121, "cannot find an attribute name in attribute declaration", ErrorSeverity.ERROR),
-	RULE_WITH_TOO_FEW_ALT_LABELS(122, "rule '<arg>': must label all alternatives or none", ErrorSeverity.ERROR),
-	ALT_LABEL_REDEF(123, "rule alt label '<arg>' redefined in rule '<arg2>', originally in rule '<arg3>'", ErrorSeverity.ERROR),
-	ALT_LABEL_CONFLICTS_WITH_RULE(124, "rule alt label '<arg>' conflicts with rule '<arg2>'", ErrorSeverity.ERROR),
-	IMPLICIT_TOKEN_DEFINITION(125, "implicit definition of token '<arg>' in parser", ErrorSeverity.WARNING),
-	IMPLICIT_STRING_DEFINITION(126, "cannot create implicit token for string literal in non-combined grammar: <arg>", ErrorSeverity.ERROR),
-	ATTRIBUTE_IN_LEXER_ACTION(128, "attribute references not allowed in lexer actions: $<arg>", ErrorSeverity.ERROR),
-	LABEL_BLOCK_NOT_A_SET(130, "label '<arg>' assigned to a block which is not a set", ErrorSeverity.ERROR),
-	EXPECTED_NON_GREEDY_WILDCARD_BLOCK(131, "greedy block ()<arg> contains wildcard; the non-greedy syntax ()<arg>? may be preferred", ErrorSeverity.WARNING),
-	LEXER_ACTION_PLACEMENT_ISSUE(132, "action in lexer rule '<arg>' must be last element of single outermost alt", ErrorSeverity.ERROR),
-	LEXER_COMMAND_PLACEMENT_ISSUE(133, "->command in lexer rule '<arg>' must be last element of single outermost alt", ErrorSeverity.ERROR),
-	USE_OF_BAD_WORD(134, "symbol '<arg>' conflicts with generated code in target language or runtime", ErrorSeverity.ERROR),
-	UNSUPPORTED_REFERENCE_IN_LEXER_SET(134, "rule reference '<arg>' is not currently supported in a set", ErrorSeverity.ERROR),
-	ASSIGNMENT_TO_LIST_LABEL(135, "cannot assign a value to list label '<arg>'", ErrorSeverity.ERROR),
-	RETVAL_CONFLICTS_WITH_RULE(136, "return value '<arg>' conflicts with rule with same name", ErrorSeverity.ERROR),
-	RETVAL_CONFLICTS_WITH_TOKEN(137, "return value '<arg>' conflicts with token with same name", ErrorSeverity.ERROR),
-	ARG_CONFLICTS_WITH_RULE(138, "parameter '<arg>' conflicts with rule with same name", ErrorSeverity.ERROR),
-	ARG_CONFLICTS_WITH_TOKEN(139, "parameter '<arg>' conflicts with token with same name", ErrorSeverity.ERROR),
-	LOCAL_CONFLICTS_WITH_RULE(140, "local '<arg>' conflicts with rule with same name", ErrorSeverity.ERROR),
-	LOCAL_CONFLICTS_WITH_TOKEN(141, "local '<arg>' conflicts with rule token same name", ErrorSeverity.ERROR),
-	LOCAL_CONFLICTS_WITH_ARG(142, "local '<arg>' conflicts with parameter with same name", ErrorSeverity.ERROR),
-	LOCAL_CONFLICTS_WITH_RETVAL(143, "local '<arg>' conflicts with return value with same name", ErrorSeverity.ERROR),
-	INVALID_LITERAL_IN_LEXER_SET(144, "multi-character literals are not allowed in lexer sets: <arg>", ErrorSeverity.ERROR),
-	MODE_WITHOUT_RULES(145, "lexer mode '<arg>' must contain at least one non-fragment rule", ErrorSeverity.ERROR),
 	/**
-	 * All non-fragment lexer rules must match at least one character.
-	 * <p/>
-	 * The following example shows this error.
+	 * Compiler Error 30.
+	 *
+	 * <p>can't find code generation templates: <em>group</em></p>
+	 */
+	MISSING_CODE_GEN_TEMPLATES(30, "can't find code generation templates: <arg>", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 31.
+	 *
+	 * <p>
+	 * ANTLR cannot generate <em>language</em> code as of version
+	 * <em>version</em></p>
+	 */
+	CANNOT_CREATE_TARGET_GENERATOR(31, "ANTLR cannot generate <arg> code as of version "+ Tool.VERSION, ErrorSeverity.ERROR_ONE_OFF),
+	/**
+	 * Compiler Error 32.
+	 *
+	 * <p>
+	 * code generation template <em>template</em> has missing, misnamed, or
+	 * incomplete arg list; missing <em>field</em></p>
+	 */
+	CODE_TEMPLATE_ARG_ISSUE(32, "code generation template <arg> has missing, misnamed, or incomplete arg list; missing <arg2>", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 33.
+	 *
+	 * <p>missing code generation template <em>template</em></p>
+	 */
+	CODE_GEN_TEMPLATES_INCOMPLETE(33, "missing code generation template <arg>", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 34.
+	 *
+	 * <p>
+	 * no mapping to template name for output model class <em>class</em></p>
+	 */
+	NO_MODEL_TO_TEMPLATE_MAPPING(34, "no mapping to template name for output model class <arg>", ErrorSeverity.ERROR),
+    /**
+   	 * Compiler Error 35.
+   	 *
+   	 * <p>templates/target and tool aren't compatible</p>
+   	 */
+   	INCOMPATIBLE_TOOL_AND_TEMPLATES(35, "<arg3> code generation target requires ANTLR <arg2>; it can't be loaded by the current ANTLR <arg>", ErrorSeverity.ERROR),
+
+	/*
+	 * Grammar errors
+	 */
+
+	/**
+	 * Compiler Error 50.
+	 *
+	 * <p>syntax error: <em>message</em></p>
+	 */
+	SYNTAX_ERROR(50, "syntax error: <arg>", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 51.
+	 *
+	 * <p>rule <em>rule</em> redefinition; previous at line <em>line</em></p>
+	 */
+	RULE_REDEFINITION(51, "rule <arg> redefinition; previous at line <arg2>", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 52.
+	 *
+	 * <p>lexer rule <em>rule</em> not allowed in parser</p>
+	 */
+	LEXER_RULES_NOT_ALLOWED(52, "lexer rule <arg> not allowed in parser", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 53.
+	 *
+	 * <p>parser rule <em>rule</em> not allowed in lexer</p>
+	 */
+	PARSER_RULES_NOT_ALLOWED(53, "parser rule <arg> not allowed in lexer", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 54.
+	 *
+	 * <p>
+	 * repeated grammar prequel spec ({@code options}, {@code tokens}, or
+	 * {@code import}); please merge</p>
+	 */
+    REPEATED_PREQUEL(54, "repeated grammar prequel spec (options, tokens, or import); please merge", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 56.
+	 *
+	 * <p>reference to undefined rule: <em>rule</em></p>
+	 *
+	 * @see #PARSER_RULE_REF_IN_LEXER_RULE
+	 */
+	UNDEFINED_RULE_REF(56, "reference to undefined rule: <arg>", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 57.
+	 *
+	 * <p>
+	 * reference to undefined rule <em>rule</em> in non-local ref
+	 * <em>reference</em></p>
+	 */
+	UNDEFINED_RULE_IN_NONLOCAL_REF(57, "reference to undefined rule <arg> in non-local ref <arg3>", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 60.
+	 *
+	 * <p>token names must start with an uppercase letter: <em>name</em></p>
+	 */
+    TOKEN_NAMES_MUST_START_UPPER(60, "token names must start with an uppercase letter: <arg>", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 63.
+	 *
+	 * <p>
+	 * unknown attribute reference <em>attribute</em> in
+	 * <em>expression</em></p>
+	 */
+	UNKNOWN_SIMPLE_ATTRIBUTE(63, "unknown attribute reference <arg> in <arg2>", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 64.
+	 *
+	 * <p>
+	 * parameter <em>parameter</em> of rule <em>rule</em> is not accessible
+	 * in this scope: <em>expression</em></p>
+	 */
+	INVALID_RULE_PARAMETER_REF(64, "parameter <arg> of rule <arg2> is not accessible in this scope: <arg3>", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 65.
+	 *
+	 * <p>
+	 * unknown attribute <em>attribute</em> for rule <em>rule</em> in
+	 * <em>expression</em></p>
+	 */
+	UNKNOWN_RULE_ATTRIBUTE(65, "unknown attribute <arg> for rule <arg2> in <arg3>", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 66.
+	 *
+	 * <p>
+	 * attribute <em>attribute</em> isn't a valid property in
+	 * <em>expression</em></p>
+	 */
+    UNKNOWN_ATTRIBUTE_IN_SCOPE(66, "attribute <arg> isn't a valid property in <arg2>", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 67.
+	 *
+	 * <p>
+	 * missing attribute access on rule reference <em>rule</em> in
+	 * <em>expression</em></p>
+	 */
+	ISOLATED_RULE_REF(67, "missing attribute access on rule reference <arg> in <arg2>", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 69.
+	 *
+	 * <p>label <em>label</em> conflicts with rule with same name</p>
+	 */
+	LABEL_CONFLICTS_WITH_RULE(69, "label <arg> conflicts with rule with same name", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 70.
+	 *
+	 * <p>label <em>label</em> conflicts with token with same name</p>
+	 */
+	LABEL_CONFLICTS_WITH_TOKEN(70, "label <arg> conflicts with token with same name", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 72.
+	 *
+	 * <p>label <em>label</em> conflicts with parameter with same name</p>
+	 */
+	LABEL_CONFLICTS_WITH_ARG(72, "label <arg> conflicts with parameter with same name", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 73.
+	 *
+	 * <p>label <em>label</em> conflicts with return value with same name</p>
+	 */
+	LABEL_CONFLICTS_WITH_RETVAL(73, "label <arg> conflicts with return value with same name", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 74.
+	 *
+	 * <p>label <em>label</em> conflicts with local with same name</p>
+	 */
+	LABEL_CONFLICTS_WITH_LOCAL(74, "label <arg> conflicts with local with same name", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 75.
+	 *
+	 * <p>
+	 * label <em>label</em> type mismatch with previous definition:
+	 * <em>message</em></p>
+	 */
+	LABEL_TYPE_CONFLICT(75, "label <arg> type mismatch with previous definition: <arg2>", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 76.
+	 *
+	 * <p>
+	 * return value <em>name</em> conflicts with parameter with same name</p>
+	 */
+	RETVAL_CONFLICTS_WITH_ARG(76, "return value <arg> conflicts with parameter with same name", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 79.
+	 *
+	 * <p>missing arguments(s) on rule reference: <em>rule</em></p>
+	 */
+	MISSING_RULE_ARGS(79, "missing arguments(s) on rule reference: <arg>", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 80.
+	 *
+	 * <p>rule <em>rule</em> has no defined parameters</p>
+	 */
+	RULE_HAS_NO_ARGS(80, "rule <arg> has no defined parameters", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Warning 83.
+	 *
+	 * <p>unsupported option <em>option</em></p>
+	 */
+	ILLEGAL_OPTION(83, "unsupported option <arg>", ErrorSeverity.WARNING),
+	/**
+	 * Compiler Warning 84.
+	 *
+	 * <p>unsupported option value <em>name</em>=<em>value</em></p>
+	 */
+	ILLEGAL_OPTION_VALUE(84, "unsupported option value <arg>=<arg2>", ErrorSeverity.WARNING),
+	/**
+	 * Compiler Error 94.
+	 *
+	 * <p>redefinition of <em>action</em> action</p>
+	 */
+    ACTION_REDEFINITION(94, "redefinition of <arg> action", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 99.
+	 *
+	 * <p>This error may take any of the following forms.</p>
+	 *
+	 * <ul>
+	 * <li>grammar <em>grammar</em> has no rules</li>
+	 * <li>implicitly generated grammar <em>grammar</em> has no rules</li>
+	 * </ul>
+	 */
+	NO_RULES(99, "<if(arg2.implicitLexerOwner)>implicitly generated <endif>grammar <arg> has no rules", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 105.
+	 *
+	 * <p>
+	 * reference to undefined grammar in rule reference:
+	 * <em>grammar</em>.<em>rule</em></p>
+	 */
+	NO_SUCH_GRAMMAR_SCOPE(105, "reference to undefined grammar in rule reference: <arg>.<arg2>", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 106.
+	 *
+	 * <p>rule <em>rule</em> is not defined in grammar <em>grammar</em></p>
+	 */
+	NO_SUCH_RULE_IN_SCOPE(106, "rule <arg2> is not defined in grammar <arg>", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Warning 108.
+	 *
+	 * <p>token name <em>Token</em> is already defined</p>
+	 */
+	TOKEN_NAME_REASSIGNMENT(108, "token name <arg> is already defined", ErrorSeverity.WARNING),
+	/**
+	 * Compiler Warning 109.
+	 *
+	 * <p>options ignored in imported grammar <em>grammar</em></p>
+	 */
+	OPTIONS_IN_DELEGATE(109, "options ignored in imported grammar <arg>", ErrorSeverity.WARNING),
+	/**
+	 * Compiler Error 110.
+	 *
+	 * <p>
+	 * can't find or load grammar <em>grammar</em> from
+	 * <em>filename</em></p>
+	 */
+	CANNOT_FIND_IMPORTED_GRAMMAR(110, "can't find or load grammar <arg>", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 111.
+	 *
+	 * <p>
+	 * <em>grammartype</em> grammar <em>grammar1</em> cannot import
+	 * <em>grammartype</em> grammar <em>grammar2</em></p>
+	 */
+	INVALID_IMPORT(111, "<arg.typeString> grammar <arg.name> cannot import <arg2.typeString> grammar <arg2.name>", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 113.
+	 *
+	 * <p>
+	 * <em>grammartype</em> grammar <em>grammar1</em> and imported
+	 * <em>grammartype</em> grammar <em>grammar2</em> both generate
+	 * <em>recognizer</em></p>
+	 */
+	IMPORT_NAME_CLASH(113, "<arg.typeString> grammar <arg.name> and imported <arg2.typeString> grammar <arg2.name> both generate <arg2.recognizerName>", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 160.
+	 *
+	 * <p>cannot find tokens file <em>filename</em></p>
+	 */
+	CANNOT_FIND_TOKENS_FILE_REFD_IN_GRAMMAR(160, "cannot find tokens file <arg>", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Warning 118.
+	 *
+	 * <p>
+	 * all operators of alt <em>alt</em> of left-recursive rule must have same
+	 * associativity</p>
+	 *
+	 * @deprecated This warning is no longer applicable with the current syntax for specifying associativity.
+	 */
+	@Deprecated
+	ALL_OPS_NEED_SAME_ASSOC(118, "all operators of alt <arg> of left-recursive rule must have same associativity", ErrorSeverity.WARNING),
+	/**
+	 * Compiler Error 119.
+	 *
+	 * <p>
+	 * The following sets of rules are mutually left-recursive
+	 * <em>[rules]</em></p>
+	 */
+	LEFT_RECURSION_CYCLES(119, "The following sets of rules are mutually left-recursive <arg:{c| [<c:{r|<r.name>}; separator=\", \">]}; separator=\" and \">", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 120.
+	 *
+	 * <p>lexical modes are only allowed in lexer grammars</p>
+	 */
+	MODE_NOT_IN_LEXER(120, "lexical modes are only allowed in lexer grammars", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 121.
+	 *
+	 * <p>cannot find an attribute name in attribute declaration</p>
+	 */
+	CANNOT_FIND_ATTRIBUTE_NAME_IN_DECL(121, "cannot find an attribute name in attribute declaration", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 122.
+	 *
+	 * <p>rule <em>rule</em>: must label all alternatives or none</p>
+	 */
+	RULE_WITH_TOO_FEW_ALT_LABELS(122, "rule <arg>: must label all alternatives or none", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 123.
+	 *
+	 * <p>
+	 * rule alt label <em>label</em> redefined in rule <em>rule1</em>,
+	 * originally in rule <em>rule2</em></p>
+	 */
+	ALT_LABEL_REDEF(123, "rule alt label <arg> redefined in rule <arg2>, originally in rule <arg3>", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 124.
+	 *
+	 * <p>
+	 * rule alt label <em>label</em> conflicts with rule <em>rule</em></p>
+	 */
+	ALT_LABEL_CONFLICTS_WITH_RULE(124, "rule alt label <arg> conflicts with rule <arg2>", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Warning 125.
+	 *
+	 * <p>implicit definition of token <em>Token</em> in parser</p>
+	 */
+	IMPLICIT_TOKEN_DEFINITION(125, "implicit definition of token <arg> in parser", ErrorSeverity.WARNING),
+	/**
+	 * Compiler Error 126.
+	 *
+	 * <p>
+	 * cannot create implicit token for string literal in non-combined grammar:
+	 * <em>literal</em></p>
+	 */
+	IMPLICIT_STRING_DEFINITION(126, "cannot create implicit token for string literal in non-combined grammar: <arg>", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 128.
+	 *
+	 * <p>
+	 * attribute references not allowed in lexer actions:
+	 * <em>expression</em></p>
+	 */
+	ATTRIBUTE_IN_LEXER_ACTION(128, "attribute references not allowed in lexer actions: $<arg>", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 130.
+	 *
+	 * <p>label <em>label</em> assigned to a block which is not a set</p>
+	 */
+	LABEL_BLOCK_NOT_A_SET(130, "label <arg> assigned to a block which is not a set", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Warning 131.
+	 *
+	 * <p>This warning may take any of the following forms.</p>
+	 *
+	 * <ul>
+	 * <li>greedy block {@code ()*} contains wildcard; the non-greedy syntax {@code ()*?} may be preferred</li>
+	 * <li>greedy block {@code ()+} contains wildcard; the non-greedy syntax {@code ()+?} may be preferred</li>
+	 * </ul>
+	 */
+	EXPECTED_NON_GREEDY_WILDCARD_BLOCK(131, "greedy block ()<arg> contains wildcard; the non-greedy syntax ()<arg>? may be preferred", ErrorSeverity.WARNING),
+	/**
+	 * Compiler Error 132.
+	 *
+	 * <p>
+	 * action in lexer rule <em>rule</em> must be last element of single
+	 * outermost alt</p>
+	 *
+	 * @deprecated This error is no longer issued by ANTLR 4.2.
+	 */
+	@Deprecated
+	LEXER_ACTION_PLACEMENT_ISSUE(132, "action in lexer rule <arg> must be last element of single outermost alt", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 133.
+	 *
+	 * <p>
+	 * {@code ->command} in lexer rule <em>rule</em> must be last element of
+	 * single outermost alt</p>
+	 */
+	LEXER_COMMAND_PLACEMENT_ISSUE(133, "->command in lexer rule <arg> must be last element of single outermost alt", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 134.
+	 *
+	 * <p>
+	 * symbol <em>symbol</em> conflicts with generated code in target language
+	 * or runtime</p>
+	 *
+	 * <p>
+	 * Note: This error has the same number as the unrelated error
+	 * {@link #UNSUPPORTED_REFERENCE_IN_LEXER_SET}.</p>
+	 */
+	USE_OF_BAD_WORD(134, "symbol <arg> conflicts with generated code in target language or runtime", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 134.
+	 *
+	 * <p>rule reference <em>rule</em> is not currently supported in a set</p>
+	 *
+	 * <p>
+	 * Note: This error has the same number as the unrelated error
+	 * {@link #USE_OF_BAD_WORD}.</p>
+	 */
+	UNSUPPORTED_REFERENCE_IN_LEXER_SET(134, "rule reference <arg> is not currently supported in a set", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 135.
+	 *
+	 * <p>cannot assign a value to list label <em>label</em></p>
+	 */
+	ASSIGNMENT_TO_LIST_LABEL(135, "cannot assign a value to list label <arg>", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 136.
+	 *
+	 * <p>return value <em>name</em> conflicts with rule with same name</p>
+	 */
+	RETVAL_CONFLICTS_WITH_RULE(136, "return value <arg> conflicts with rule with same name", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 137.
+	 *
+	 * <p>return value <em>name</em> conflicts with token with same name</p>
+	 */
+	RETVAL_CONFLICTS_WITH_TOKEN(137, "return value <arg> conflicts with token with same name", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 138.
+	 *
+	 * <p>parameter <em>parameter</em> conflicts with rule with same name</p>
+	 */
+	ARG_CONFLICTS_WITH_RULE(138, "parameter <arg> conflicts with rule with same name", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 139.
+	 *
+	 * <p>parameter <em>parameter</em> conflicts with token with same name</p>
+	 */
+	ARG_CONFLICTS_WITH_TOKEN(139, "parameter <arg> conflicts with token with same name", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 140.
+	 *
+	 * <p>local <em>local</em> conflicts with rule with same name</p>
+	 */
+	LOCAL_CONFLICTS_WITH_RULE(140, "local <arg> conflicts with rule with same name", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 141.
+	 *
+	 * <p>local <em>local</em> conflicts with rule token same name</p>
+	 */
+	LOCAL_CONFLICTS_WITH_TOKEN(141, "local <arg> conflicts with rule token same name", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 142.
+	 *
+	 * <p>local <em>local</em> conflicts with parameter with same name</p>
+	 */
+	LOCAL_CONFLICTS_WITH_ARG(142, "local <arg> conflicts with parameter with same name", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 143.
+	 *
+	 * <p>local <em>local</em> conflicts with return value with same name</p>
+	 */
+	LOCAL_CONFLICTS_WITH_RETVAL(143, "local <arg> conflicts with return value with same name", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 144.
+	 *
+	 * <p>
+	 * multi-character literals are not allowed in lexer sets:
+	 * <em>literal</em></p>
+	 */
+	INVALID_LITERAL_IN_LEXER_SET(144, "multi-character literals are not allowed in lexer sets: <arg>", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 145.
+	 *
+	 * <p>
+	 * lexer mode <em>mode</em> must contain at least one non-fragment
+	 * rule</p>
+	 *
+	 * <p>
+	 * Every lexer mode must contain at least one rule which is not declared
+	 * with the {@code fragment} modifier.</p>
+	 */
+	MODE_WITHOUT_RULES(145, "lexer mode <arg> must contain at least one non-fragment rule", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Warning 146.
+	 *
+	 * <p>non-fragment lexer rule <em>rule</em> can match the empty string</p>
+	 *
+	 * <p>All non-fragment lexer rules must match at least one character.</p>
+	 *
+	 * <p>The following example shows this error.</p>
 	 *
 	 * <pre>
 	 * Whitespace : [ \t]+;  // ok
@@ -142,12 +647,18 @@ public enum ErrorType {
 	 * Whitespace : [ \t]*;  // error 146
 	 * </pre>
 	 */
-	EPSILON_TOKEN(146, "non-fragment lexer rule '<arg>' can match the empty string", ErrorSeverity.WARNING),
+	EPSILON_TOKEN(146, "non-fragment lexer rule <arg> can match the empty string", ErrorSeverity.WARNING),
 	/**
-	 * Left-recursive rules must contain at least one alternative which is not
-	 * left recursive.
-	 * <p/>
-	 * The following rule produces this error.
+	 * Compiler Error 147.
+	 *
+	 * <p>
+	 * left recursive rule <em>rule</em> must contain an alternative which is
+	 * not left recursive</p>
+	 *
+	 * <p>Left-recursive rules must contain at least one alternative which is not
+	 * left recursive.</p>
+	 *
+	 * <p>The following rule produces this error.</p>
 	 *
 	 * <pre>
 	 * // error 147:
@@ -156,12 +667,18 @@ public enum ErrorType {
 	 *   ;
 	 * </pre>
 	 */
-	NO_NON_LR_ALTS(147, "left recursive rule '<arg>' must contain an alternative which is not left recursive", ErrorSeverity.ERROR),
+	NO_NON_LR_ALTS(147, "left recursive rule <arg> must contain an alternative which is not left recursive", ErrorSeverity.ERROR),
 	/**
-	 * In left-recursive rules, all left-recursive alternatives must match at
-	 * least one symbol following the recursive rule invocation.
-	 * <p/>
-	 * The following rule produces this error.
+	 * Compiler Error 148.
+	 *
+	 * <p>
+	 * left recursive rule <em>rule</em> contains a left recursive alternative
+	 * which can be followed by the empty string</p>
+	 *
+	 * <p>In left-recursive rules, all left-recursive alternatives must match at
+	 * least one symbol following the recursive rule invocation.</p>
+	 *
+	 * <p>The following rule produces this error.</p>
 	 *
 	 * <pre>
 	 * a : ID    // ok        (alternative is not left recursive)
@@ -170,59 +687,91 @@ public enum ErrorType {
 	 *   ;
 	 * </pre>
 	 */
-	EPSILON_LR_FOLLOW(148, "left recursive rule '<arg>' contains a left recursive alternative which can be followed by the empty string", ErrorSeverity.ERROR),
+	EPSILON_LR_FOLLOW(148, "left recursive rule <arg> contains a left recursive alternative which can be followed by the empty string", ErrorSeverity.ERROR),
 	/**
-	 * Each lexer command requires an explicit implementation in the target
+	 * Compiler Error 149.
+	 *
+	 * <p>
+	 * lexer command <em>command</em> does not exist or is not supported by
+	 * the current target</p>
+	 *
+	 * <p>Each lexer command requires an explicit implementation in the target
 	 * templates. This error indicates that the command was incorrectly written
-	 * or is not supported by the current target.
-	 * <p/>
-	 * The following rule produces this error.
-	 * 
-	 * <pre>
-	 * X : 'foo' -> type(Foo);  // ok
-	 * Y : 'foo' -> token(Foo); // error 149 (token is not a supported lexer command)
-	 * </pre>
-	 */
-	INVALID_LEXER_COMMAND(149, "lexer command '<arg>' does not exist or is not supported by the current target", ErrorSeverity.ERROR),
-	/**
-	 * Some lexer commands require an argument.
-	 * <p/>
-	 * The following rule produces this error.
-	 * 
-	 * <pre>
-	 * X : 'foo' -> type(Foo); // ok
-	 * Y : 'foo' -> type;      // error 150 (the type command requires an argument)
-	 * </pre>
-	 */
-	MISSING_LEXER_COMMAND_ARGUMENT(150, "missing argument for lexer command '<arg>'", ErrorSeverity.ERROR),
-	/**
-	 * A lexer command which does not take parameters was invoked with an
-	 * argument.
-	 * <p/>
-	 * The following rule produces this error.
+	 * or is not supported by the current target.</p>
+	 *
+	 * <p>The following rule produces this error.</p>
 	 *
 	 * <pre>
-	 * X : 'foo' -> popMode;    // ok
-	 * Y : 'foo' -> popMode(A); // error 151 (the popMode command does not take an argument)
+	 * X : 'foo' -&gt; type(Foo);  // ok
+	 * Y : 'foo' -&gt; token(Foo); // error 149 (token is not a supported lexer command)
 	 * </pre>
+	 *
+	 * @since 4.1
 	 */
-	UNWANTED_LEXER_COMMAND_ARGUMENT(151, "lexer command '<arg>' does not take any arguments", ErrorSeverity.ERROR),
+	INVALID_LEXER_COMMAND(149, "lexer command <arg> does not exist or is not supported by the current target", ErrorSeverity.ERROR),
 	/**
-	 * The parser contains an unterminated string literal.
-	 * <p/>
-	 * The following rule produces this error.
+	 * Compiler Error 150.
+	 *
+	 * <p>missing argument for lexer command <em>command</em></p>
+	 *
+	 * <p>Some lexer commands require an argument.</p>
+	 *
+	 * <p>The following rule produces this error.</p>
+	 *
+	 * <pre>
+	 * X : 'foo' -&gt; type(Foo); // ok
+	 * Y : 'foo' -&gt; type;      // error 150 (the type command requires an argument)
+	 * </pre>
+	 *
+	 * @since 4.1
+	 */
+	MISSING_LEXER_COMMAND_ARGUMENT(150, "missing argument for lexer command <arg>", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 151.
+	 *
+	 * <p>lexer command <em>command</em> does not take any arguments</p>
+	 *
+	 * <p>A lexer command which does not take parameters was invoked with an
+	 * argument.</p>
+	 *
+	 * <p>The following rule produces this error.</p>
+	 *
+	 * <pre>
+	 * X : 'foo' -&gt; popMode;    // ok
+	 * Y : 'foo' -&gt; popMode(A); // error 151 (the popMode command does not take an argument)
+	 * </pre>
+	 *
+	 * @since 4.1
+	 */
+	UNWANTED_LEXER_COMMAND_ARGUMENT(151, "lexer command <arg> does not take any arguments", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 152.
+	 *
+	 * <p>unterminated string literal</p>
+	 *
+	 * <p>The grammar contains an unterminated string literal.</p>
+	 *
+	 * <p>The following rule produces this error.</p>
 	 *
 	 * <pre>
 	 * x : 'x'; // ok
-	 * y : 'y;  // error 152
+	 * y : 'y';  // error 152
 	 * </pre>
+	 *
+	 * @since 4.1
 	 */
 	UNTERMINATED_STRING_LITERAL(152, "unterminated string literal", ErrorSeverity.ERROR),
 	/**
-	 * A rule contains a closure ({@code (...)*}) or positive closure
-	 * ({@code (...)+}) around an empty alternative.
-	 * <p/>
-	 * The following rule produces this error.
+	 * Compiler Error 153.
+	 *
+	 * <p>
+	 * rule <em>rule</em> contains a closure with at least one alternative
+	 * that can match an empty string</p>
+	 *
+	 * <p>A rule contains a closure ({@code (...)*}) or positive closure
+	 * ({@code (...)+}) around an empty alternative.</p>
+	 *
+	 * <p>The following rule produces this error.</p>
 	 *
 	 * <pre>
 	 * x  : ;
@@ -230,13 +779,21 @@ public enum ErrorType {
 	 * z1 : ('foo' | 'bar'? 'bar2'?)*;         // error 153
 	 * z2 : ('foo' | 'bar' 'bar2'? | 'bar2')*; // ok
 	 * </pre>
+	 *
+	 * @since 4.1
 	 */
-	EPSILON_CLOSURE(153, "rule '<arg>' contains a closure with at least one alternative that can match an empty string", ErrorSeverity.ERROR),
+	EPSILON_CLOSURE(153, "rule <arg> contains a closure with at least one alternative that can match an empty string", ErrorSeverity.ERROR),
 	/**
-	 * A rule contains an optional block ({@code (...)?}) around an empty
-	 * alternative.
-	 * <p/>
-	 * The following rule produces this warning.
+	 * Compiler Warning 154.
+	 *
+	 * <p>
+	 * rule <em>rule</em> contains an optional block with at least one
+	 * alternative that can match an empty string</p>
+	 *
+	 * <p>A rule contains an optional block ({@code (...)?}) around an empty
+	 * alternative.</p>
+	 *
+	 * <p>The following rule produces this warning.</p>
 	 *
 	 * <pre>
 	 * x  : ;
@@ -244,17 +801,308 @@ public enum ErrorType {
 	 * z1 : ('foo' | 'bar'? 'bar2'?)?;         // warning 154
 	 * z2 : ('foo' | 'bar' 'bar2'? | 'bar2')?; // ok
 	 * </pre>
+	 *
+	 * @since 4.1
 	 */
-	EPSILON_OPTIONAL(154, "rule '<arg>' contains an optional block with at least one alternative that can match an empty string", ErrorSeverity.WARNING),
+	EPSILON_OPTIONAL(154, "rule <arg> contains an optional block with at least one alternative that can match an empty string", ErrorSeverity.WARNING),
+	/**
+	 * Compiler Warning 155.
+	 *
+	 * <p>
+	 * rule <em>rule</em> contains a lexer command with an unrecognized
+	 * constant value; lexer interpreters may produce incorrect output</p>
+	 *
+	 * <p>A lexer rule contains a standard lexer command, but the constant value
+	 * argument for the command is an unrecognized string. As a result, the
+	 * lexer command will be translated as a custom lexer action, preventing the
+	 * command from executing in some interpreted modes. The output of the lexer
+	 * interpreter may not match the output of the generated lexer.</p>
+	 *
+	 * <p>The following rule produces this warning.</p>
+	 *
+	 * <pre>
+	 * &#064;members {
+	 * public static final int CUSTOM = HIDDEN + 1;
+	 * }
+	 *
+	 * X : 'foo' -&gt; channel(HIDDEN);           // ok
+	 * Y : 'bar' -&gt; channel(CUSTOM);           // warning 155
+	 * </pre>
+	 *
+	 * @since 4.2
+	 */
+	UNKNOWN_LEXER_CONSTANT(155, "rule <arg> contains a lexer command with an unrecognized constant value; lexer interpreters may produce incorrect output", ErrorSeverity.WARNING),
+	/**
+	 * Compiler Error 156.
+	 *
+	 * <p>invalid escape sequence</p>
+	 *
+	 * <p>The grammar contains a string literal with an invalid escape sequence.</p>
+	 *
+	 * <p>The following rule produces this error.</p>
+	 *
+	 * <pre>
+	 * x : 'x';  // ok
+	 * y : '\u005Cu'; // error 156
+	 * </pre>
+	 *
+	 * @since 4.2.1
+	 */
+	INVALID_ESCAPE_SEQUENCE(156, "invalid escape sequence", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Warning 157.
+	 *
+	 * <p>rule <em>rule</em> contains an assoc element option in an
+	 * unrecognized location</p>
+	 *
+	 * <p>
+	 * In ANTLR 4.2, the position of the {@code assoc} element option was moved
+	 * from the operator terminal(s) to the alternative itself. This warning is
+	 * reported when an {@code assoc} element option is specified on a grammar
+	 * element that is not recognized by the current version of ANTLR, and as a
+	 * result will simply be ignored.
+	 * </p>
+	 *
+	 * <p>The following rule produces this warning.</p>
+	 *
+	 * <pre>
+	 * x : 'x'
+	 *   | x '+'&lt;assoc=right&gt; x   // warning 157
+	 *   |&lt;assoc=right&gt; x * x   // ok
+	 *   ;
+	 * </pre>
+	 *
+	 * @since 4.2.1
+	 */
+	UNRECOGNIZED_ASSOC_OPTION(157, "rule <arg> contains an assoc terminal option in an unrecognized location", ErrorSeverity.WARNING),
+	/**
+	 * Compiler Warning 158.
+	 *
+	 * <p>fragment rule <em>rule</em> contains an action or command which can
+	 * never be executed</p>
+	 *
+	 * <p>A lexer rule which is marked with the {@code fragment} modifier
+	 * contains an embedded action or lexer command. ANTLR lexers only execute
+	 * commands and embedded actions located in the top-level matched rule.
+	 * Since fragment rules can never be the top-level rule matched by a lexer,
+	 * actions or commands placed in these rules can never be executed during
+	 * the lexing process.</p>
+	 *
+	 * <p>The following rule produces this warning.</p>
+	 *
+	 * <pre>
+	 * X1 : 'x' -&gt; more    // ok
+	 *    ;
+	 * Y1 : 'x' {more();}  // ok
+	 *    ;
+	 * fragment
+	 * X2 : 'x' -&gt; more    // warning 158
+	 *    ;
+	 * fragment
+	 * Y2 : 'x' {more();}  // warning 158
+	 *    ;
+	 * </pre>
+	 *
+	 * @since 4.2.1
+	 */
+	FRAGMENT_ACTION_IGNORED(158, "fragment rule <arg> contains an action or command which can never be executed", ErrorSeverity.WARNING),
+	/**
+	 * Compiler Error 159.
+	 *
+	 * <p>cannot declare a rule with reserved name <em>rule</em></p>
+	 *
+	 * <p>A rule was declared with a reserved name.</p>
+	 *
+	 * <p>The following rule produces this error.</p>
+	 *
+	 * <pre>
+	 * EOF :  ' '   // error 159 (EOF is a reserved name)
+	 *     ;
+	 * </pre>
+	 *
+	 * @since 4.2.1
+	 */
+	RESERVED_RULE_NAME(159, "cannot declare a rule with reserved name <arg>", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 160.
+	 *
+	 * <p>reference to parser rule <em>rule</em> in lexer rule <em>name</em></p>
+	 *
+	 * @see #UNDEFINED_RULE_REF
+	 */
+	PARSER_RULE_REF_IN_LEXER_RULE(160, "reference to parser rule <arg> in lexer rule <arg2>", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 161.
+	 *
+	 * <p>channel <em>name</em> conflicts with token with same name</p>
+	 */
+	CHANNEL_CONFLICTS_WITH_TOKEN(161, "channel <arg> conflicts with token with same name", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 162.
+	 *
+	 * <p>channel <em>name</em> conflicts with mode with same name</p>
+	 */
+	CHANNEL_CONFLICTS_WITH_MODE(162, "channel <arg> conflicts with mode with same name", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 163.
+	 *
+	 * <p>custom channels are not supported in parser grammars</p>
+	 */
+	CHANNELS_BLOCK_IN_PARSER_GRAMMAR(163, "custom channels are not supported in parser grammars", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 164.
+	 *
+	 * <p>custom channels are not supported in combined grammars</p>
+	 */
+	CHANNELS_BLOCK_IN_COMBINED_GRAMMAR(164, "custom channels are not supported in combined grammars", ErrorSeverity.ERROR),
 
-	// Backward incompatibility errors
+	NONCONFORMING_LR_RULE(169, "rule <arg> is left recursive but doesn't conform to a pattern ANTLR can handle", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 170.
+	 *
+	 * <pre>
+	 * mode M1;
+	 * A1: 'a'; // ok
+	 * mode M2;
+	 * A2: 'a'; // ok
+	 * M1: 'b'; // error 170
+	 * </pre>
+	 *
+	 * <p>mode <em>name</em> conflicts with token with same name</p>
+	 */
+	MODE_CONFLICTS_WITH_TOKEN(170, "mode <arg> conflicts with token with same name", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 171.
+	 *
+	 * <p>can not use or declare token with reserved name</p>
+	 *
+	 * <p>Reserved names: HIDDEN, DEFAULT_TOKEN_CHANNEL, SKIP, MORE, MAX_CHAR_VALUE, MIN_CHAR_VALUE.
+	 *
+	 * <p>Can be used but cannot be declared: EOF</p>
+	 */
+	TOKEN_CONFLICTS_WITH_COMMON_CONSTANTS(171, "cannot use or declare token with reserved name <arg>", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 172.
+	 *
+	 * <p>can not use or declare channel with reserved name</p>
+	 *
+	 * <p>Reserved names: DEFAULT_MODE, SKIP, MORE, EOF, MAX_CHAR_VALUE, MIN_CHAR_VALUE.
+	 *
+	 * <p>Can be used but cannot be declared: HIDDEN, DEFAULT_TOKEN_CHANNEL</p>
+	 */
+	CHANNEL_CONFLICTS_WITH_COMMON_CONSTANTS(172, "cannot use or declare channel with reserved name <arg>", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 173.
+	 *
+	 * <p>can not use or declare mode with reserved name</p>
+	 *
+	 * <p>Reserved names: HIDDEN, DEFAULT_TOKEN_CHANNEL, SKIP, MORE, MAX_CHAR_VALUE, MIN_CHAR_VALUE.
+	 *
+	 * <p>Can be used and cannot declared: DEFAULT_MODE</p>
+	 */
+	MODE_CONFLICTS_WITH_COMMON_CONSTANTS(173, "cannot use or declare mode with reserved name <arg>", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Error 174.
+	 *
+	 * <p>empty strings not allowed</p>
+	 *
+	 * <pre>A: '''test''';</pre>
+	 * <pre>B: '';</pre>
+	 * <pre>C: 'test' '';</pre>
+	 */
+	EMPTY_STRINGS_NOT_ALLOWED(174, "string literals cannot be empty", ErrorSeverity.ERROR),
+
+	/*
+	 * Backward incompatibility errors
+	 */
+
+	/**
+	 * Compiler Error 200.
+	 *
+	 * <p>tree grammars are not supported in ANTLR 4</p>
+	 *
+	 * <p>
+	 * This error message is provided as a compatibility notice for users
+	 * migrating from ANTLR 3. ANTLR 4 does not support tree grammars, but
+	 * instead offers automatically generated parse tree listeners and visitors
+	 * as a more maintainable alternative.</p>
+	 */
 	V3_TREE_GRAMMAR(200, "tree grammars are not supported in ANTLR 4", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Warning 201.
+	 *
+	 * <p>
+	 * labels in lexer rules are not supported in ANTLR 4; actions cannot
+	 * reference elements of lexical rules but you can use
+	 * {@link Lexer#getText()} to get the entire text matched for the rule</p>
+	 *
+	 * <p>
+	 * ANTLR 4 uses a DFA for recognition of entire tokens, resulting in faster
+	 * and smaller lexers than ANTLR 3 produced. As a result, sub-rules
+	 * referenced within lexer rules are not tracked independently, and cannot
+	 * be assigned to labels.</p>
+	 */
 	V3_LEXER_LABEL(201, "labels in lexer rules are not supported in ANTLR 4; " +
 		"actions cannot reference elements of lexical rules but you can use " +
 		"getText() to get the entire text matched for the rule", ErrorSeverity.WARNING),
-	V3_TOKENS_SYNTAX(202, "'tokens {A; B;}' syntax is now 'tokens {A, B}' in ANTLR 4", ErrorSeverity.WARNING),
-	V3_ASSIGN_IN_TOKENS(203, "assignments in tokens{} are not supported in ANTLR 4; use lexical rule '<arg> : <arg2>;' instead", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Warning 202.
+	 *
+	 * <p>
+	 * {@code tokens {A; B;}} syntax is now {@code tokens {A, B}} in ANTLR
+	 * 4</p>
+	 *
+	 * <p>
+	 * ANTLR 4 uses comma-separated token declarations in the {@code tokens{}}
+	 * block. This warning appears when the tokens block is written using the
+	 * ANTLR 3 syntax of semicolon-terminated token declarations.</p>
+	 *
+	 * <p>
+	 * <strong>NOTE:</strong> ANTLR 4 does not allow a trailing comma to appear following the
+	 * last token declared in the {@code tokens{}} block.</p>
+	 */
+	V3_TOKENS_SYNTAX(202, "tokens {A; B;} syntax is now tokens {A, B} in ANTLR 4", ErrorSeverity.WARNING),
+	/**
+	 * Compiler Error 203.
+	 *
+	 * <p>
+	 * assignments in {@code tokens{}} are not supported in ANTLR 4; use lexical
+	 * rule <em>TokenName</em> : <em>LiteralValue</em>; instead</p>
+	 *
+	 * <p>
+	 * ANTLR 3 allowed literal tokens to be declared and assigned a value within
+	 * the {@code tokens{}} block. ANTLR 4 no longer offers this syntax. When
+	 * migrating a grammar from ANTLR 3 to ANTLR 4, any tokens with a literal
+	 * value declared in the {@code tokens{}} block should be converted to
+	 * standard lexer rules.</p>
+	 */
+	V3_ASSIGN_IN_TOKENS(203, "assignments in tokens{} are not supported in ANTLR 4; use lexical rule <arg> : <arg2>; instead", ErrorSeverity.ERROR),
+	/**
+	 * Compiler Warning 204.
+	 *
+	 * <p>
+	 * {@code {...}?=>} explicitly gated semantic predicates are deprecated in
+	 * ANTLR 4; use {@code {...}?} instead</p>
+	 *
+	 * <p>
+	 * ANTLR 4 treats semantic predicates consistently in a manner similar to
+	 * gated semantic predicates in ANTLR 3. When migrating a grammar from ANTLR
+	 * 3 to ANTLR 4, all uses of the gated semantic predicate syntax can be
+	 * safely converted to the standard semantic predicated syntax, which is the
+	 * only form used by ANTLR 4.</p>
+	 */
 	V3_GATED_SEMPRED(204, "{...}?=> explicitly gated semantic predicates are deprecated in ANTLR 4; use {...}? instead", ErrorSeverity.WARNING),
+	/**
+	 * Compiler Error 205.
+	 *
+	 * <p>{@code (...)=>} syntactic predicates are not supported in ANTLR 4</p>
+	 *
+	 * <p>
+	 * ANTLR 4's improved lookahead algorithms do not require the use of
+	 * syntactic predicates to disambiguate long lookahead sequences. The
+	 * syntactic predicates should be removed when migrating a grammar from
+	 * ANTLR 3 to ANTLR 4.</p>
+	 */
 	V3_SYNPRED(205, "(...)=> syntactic predicates are not supported in ANTLR 4", ErrorSeverity.ERROR),
 
     // Dependency sorting errors
@@ -263,10 +1111,41 @@ public enum ErrorType {
     //CIRCULAR_DEPENDENCY(200, "your grammars contain a circular dependency and cannot be sorted into a valid build order", ErrorSeverity.ERROR),
 	;
 
+	/**
+	 * The error or warning message, in StringTemplate 4 format using {@code <}
+	 * and {@code >} as the delimiters. Arguments for the message may be
+	 * referenced using the following names:
+	 *
+	 * <ul>
+	 * <li>{@code arg}: The first template argument</li>
+	 * <li>{@code arg2}: The second template argument</li>
+	 * <li>{@code arg3}: The third template argument</li>
+	 * <li>{@code verbose}: {@code true} if verbose messages were requested; otherwise, {@code false}</li>
+	 * <li>{@code exception}: The exception which resulted in the error, if any.</li>
+	 * <li>{@code stackTrace}: The stack trace for the exception, when available.</li>
+	 * </ul>
+	 */
 	public final String msg;
-    public final int code; // unique, deterministic unchanging error code once we release
+	/**
+	 * The error or warning number.
+	 *
+	 * <p>The code should be unique, and following its
+	 * use in a release should not be altered or reassigned.</p>
+	 */
+    public final int code;
+	/**
+	 * The error severity.
+	 */
     public final ErrorSeverity severity;
 
+	/**
+	 * Constructs a new {@link ErrorType} with the specified code, message, and
+	 * severity.
+	 *
+	 * @param code The unique error number.
+	 * @param msg The error message template.
+	 * @param severity The error severity.
+	 */
 	ErrorType(int code, String msg, ErrorSeverity severity) {
         this.code = code;
 		this.msg = msg;
diff --git a/tool/src/org/antlr/v4/tool/Grammar.java b/tool/src/org/antlr/v4/tool/Grammar.java
index 3f32507e7..89e2a2627 100644
--- a/tool/src/org/antlr/v4/tool/Grammar.java
+++ b/tool/src/org/antlr/v4/tool/Grammar.java
@@ -32,6 +32,7 @@ package org.antlr.v4.tool;
 
 import org.antlr.v4.Tool;
 import org.antlr.v4.analysis.LeftRecursiveRuleTransformer;
+import org.antlr.v4.automata.ParserATNFactory;
 import org.antlr.v4.misc.CharSupport;
 import org.antlr.v4.misc.OrderedHashMap;
 import org.antlr.v4.misc.Utils;
@@ -45,19 +46,23 @@ import org.antlr.v4.runtime.LexerInterpreter;
 import org.antlr.v4.runtime.ParserInterpreter;
 import org.antlr.v4.runtime.Token;
 import org.antlr.v4.runtime.TokenStream;
+import org.antlr.v4.runtime.Vocabulary;
+import org.antlr.v4.runtime.VocabularyImpl;
 import org.antlr.v4.runtime.atn.ATN;
+import org.antlr.v4.runtime.atn.ATNDeserializer;
+import org.antlr.v4.runtime.atn.ATNSerializer;
+import org.antlr.v4.runtime.atn.SemanticContext;
 import org.antlr.v4.runtime.dfa.DFA;
 import org.antlr.v4.runtime.misc.IntSet;
-import org.antlr.v4.runtime.misc.IntegerList;
+import org.antlr.v4.runtime.misc.Interval;
 import org.antlr.v4.runtime.misc.IntervalSet;
-import org.antlr.v4.runtime.misc.NotNull;
-import org.antlr.v4.runtime.misc.Nullable;
 import org.antlr.v4.runtime.misc.Pair;
 import org.antlr.v4.tool.ast.ActionAST;
 import org.antlr.v4.tool.ast.GrammarAST;
 import org.antlr.v4.tool.ast.GrammarASTWithOptions;
 import org.antlr.v4.tool.ast.GrammarRootAST;
 import org.antlr.v4.tool.ast.PredAST;
+import org.antlr.v4.tool.ast.RuleAST;
 import org.antlr.v4.tool.ast.TerminalAST;
 
 import java.io.IOException;
@@ -66,16 +71,37 @@ import java.util.Arrays;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
 public class Grammar implements AttributeResolver {
 	public static final String GRAMMAR_FROM_STRING_NAME = "<string>";
+	/**
+	 * This value is used in the following situations to indicate that a token
+	 * type does not have an associated name which can be directly referenced in
+	 * a grammar.
+	 *
+	 * <ul>
+	 * <li>This value is the name and display name for the token with type
+	 * {@link Token#INVALID_TYPE}.</li>
+	 * <li>This value is the name for tokens with a type not represented by a
+	 * named token. The display name for these tokens is simply the string
+	 * representation of the token type as an integer.</li>
+	 * </ul>
+	 */
+	public static final String INVALID_TOKEN_NAME = "<INVALID>";
+	/**
+	 * This value is used as the name for elements in the array returned by
+	 * {@link #getRuleNames} for indexes not associated with a rule.
+	 */
+	public static final String INVALID_RULE_NAME = "<invalid>";
 
 	public static final Set<String> parserOptions = new HashSet<String>();
 	static {
 		parserOptions.add("superClass");
+		parserOptions.add("contextSuperClass");
 		parserOptions.add("TokenLabelType");
 		parserOptions.add("tokenVocab");
 		parserOptions.add("language");
@@ -89,16 +115,18 @@ public class Grammar implements AttributeResolver {
 
 	public static final Set<String> LexerBlockOptions = new HashSet<String>();
 
-	/** Legal options for rule refs like id<key=value> */
+	/** Legal options for rule refs like id&lt;key=value&gt; */
 	public static final Set<String> ruleRefOptions = new HashSet<String>();
 	static {
 		ruleRefOptions.add(LeftRecursiveRuleTransformer.PRECEDENCE_OPTION_NAME);
+		ruleRefOptions.add(LeftRecursiveRuleTransformer.TOKENINDEX_OPTION_NAME);
 	}
 
-	/** Legal options for terminal refs like ID<assoc=right> */
+	/** Legal options for terminal refs like ID&lt;assoc=right&gt; */
 	public static final Set<String> tokenOptions = new HashSet<String>();
 	static {
 		tokenOptions.add("assoc");
+		tokenOptions.add(LeftRecursiveRuleTransformer.TOKENINDEX_OPTION_NAME);
 	}
 
 	public static final Set<String> actionOptions = new HashSet<String>();
@@ -127,9 +155,21 @@ public class Grammar implements AttributeResolver {
 
 	public String name;
     public GrammarRootAST ast;
-	/** Track stream used to create this grammar */
-	@NotNull
+
+	/** Track token stream used to create this grammar */
+
 	public final org.antlr.runtime.TokenStream tokenStream;
+
+	/** If we transform grammar, track original unaltered token stream.
+	 *  This is set to the same value as tokenStream when tokenStream is
+	 *  initially set.
+	 *
+	 *  If this field differs from tokenStream, then we have transformed
+	 *  the grammar.
+	 */
+
+	public org.antlr.runtime.TokenStream originalTokenStream;
+
     public String text; // testing only
     public String fileName;
 
@@ -159,11 +199,12 @@ public class Grammar implements AttributeResolver {
 	 */
 	public ATN atn;
 
+	public Map<Integer, Interval> stateToGrammarRegionMap;
+
 	public Map<Integer, DFA> decisionDFAs = new HashMap<Integer, DFA>();
 
 	public List<IntervalSet[]> decisionLOOK;
 
-	@NotNull
 	public final Tool tool;
 
 	/** Token names and literal tokens like "void" are uniquely indexed.
@@ -176,23 +217,50 @@ public class Grammar implements AttributeResolver {
 	 */
 	int maxTokenType = Token.MIN_USER_TOKEN_TYPE -1;
 
-	/** Map token like ID (but not literals like "while") to its token type */
-	public Map<String, Integer> tokenNameToTypeMap = new LinkedHashMap<String, Integer>();
-
-	/** Map token literals like "while" to its token type.  It may be that
-	 *  WHILE="while"=35, in which case both tokenIDToTypeMap and this
-	 *  field will have entries both mapped to 35.
+	/**
+	 * Map token like {@code ID} (but not literals like {@code 'while'}) to its
+	 * token type.
 	 */
-	public Map<String, Integer> stringLiteralToTypeMap = new LinkedHashMap<String, Integer>();
+	public final Map<String, Integer> tokenNameToTypeMap = new LinkedHashMap<String, Integer>();
 
-	/** Reverse index for stringLiteralToTypeMap.  Indexed with raw token type.
-	 *  0 is invalid. */
-	public List<String> typeToStringLiteralList = new ArrayList<String>();
-
-	/** Map a token type to its token name. Indexed with raw token type.
-	 *  0 is invalid.
+	/**
+	 * Map token literals like {@code 'while'} to its token type. It may be that
+	 * {@code WHILE="while"=35}, in which case both {@link #tokenNameToTypeMap}
+	 * and this field will have entries both mapped to 35.
 	 */
-	public List<String> typeToTokenList = new ArrayList<String>();
+	public final Map<String, Integer> stringLiteralToTypeMap = new LinkedHashMap<String, Integer>();
+
+	/**
+	 * Reverse index for {@link #stringLiteralToTypeMap}. Indexed with raw token
+	 * type. 0 is invalid.
+	 */
+	public final List<String> typeToStringLiteralList = new ArrayList<String>();
+
+	/**
+	 * Map a token type to its token name. Indexed with raw token type. 0 is
+	 * invalid.
+	 */
+	public final List<String> typeToTokenList = new ArrayList<String>();
+
+	/**
+	 * The maximum channel value which is assigned by this grammar. Values below
+	 * {@link Token#MIN_USER_CHANNEL_VALUE} are assumed to be predefined.
+	 */
+	int maxChannelType = Token.MIN_USER_CHANNEL_VALUE - 1;
+
+	/**
+	 * Map channel like {@code COMMENTS_CHANNEL} to its constant channel value.
+	 * Only user-defined channels are defined in this map.
+	 */
+	public final Map<String, Integer> channelNameToValueMap = new LinkedHashMap<String, Integer>();
+
+	/**
+	 * Map a constant channel value to its name. Indexed with raw channel value.
+	 * The predefined channels {@link Token#DEFAULT_CHANNEL} and
+	 * {@link Token#HIDDEN_CHANNEL} are not stored in this list, so the values
+	 * at the corresponding indexes is {@code null}.
+	 */
+	public final List<String> channelValueToNameList = new ArrayList<String>();
 
     /** Map a name to an action.
      *  The code generator will use this to fill holes in the output files.
@@ -210,10 +278,12 @@ public class Grammar implements AttributeResolver {
 	 *  sempred index is 0..n-1
 	 */
 	public LinkedHashMap<PredAST, Integer> sempreds = new LinkedHashMap<PredAST, Integer>();
+	/** Map the other direction upon demand */
+	public LinkedHashMap<Integer, PredAST> indexToPredMap;
 
 	public static final String AUTO_GENERATED_TOKEN_NAME_PREFIX = "T__";
 
-	public Grammar(Tool tool, @NotNull GrammarRootAST ast) {
+	public Grammar(Tool tool, GrammarRootAST ast) {
 		if ( ast==null ) {
 			throw new NullPointerException("ast");
 		}
@@ -226,6 +296,7 @@ public class Grammar implements AttributeResolver {
         this.ast = ast;
         this.name = (ast.getChild(0)).getText();
 		this.tokenStream = ast.tokenStream;
+		this.originalTokenStream = this.tokenStream;
 
 		initTokenSymbolTables();
     }
@@ -254,14 +325,14 @@ public class Grammar implements AttributeResolver {
 	}
 
 	/** For testing; builds trees, does sem anal */
-	public Grammar(String fileName, String grammarText, @Nullable ANTLRToolListener listener)
+	public Grammar(String fileName, String grammarText, ANTLRToolListener listener)
 		throws org.antlr.runtime.RecognitionException
 	{
 		this(fileName, grammarText, null, listener);
 	}
 
 	/** For testing; builds trees, does sem anal */
-	public Grammar(String fileName, String grammarText, Grammar tokenVocabSource, @Nullable ANTLRToolListener listener)
+	public Grammar(String fileName, String grammarText, Grammar tokenVocabSource, ANTLRToolListener listener)
 		throws org.antlr.runtime.RecognitionException
 	{
         this.text = grammarText;
@@ -271,7 +342,7 @@ public class Grammar implements AttributeResolver {
 		org.antlr.runtime.ANTLRStringStream in = new org.antlr.runtime.ANTLRStringStream(grammarText);
 		in.name = fileName;
 
-		this.ast = tool.load(fileName, in);
+		this.ast = tool.parse(fileName, in);
 		if ( ast==null ) {
 			throw new UnsupportedOperationException();
 		}
@@ -281,6 +352,7 @@ public class Grammar implements AttributeResolver {
 		}
 
 		this.tokenStream = ast.tokenStream;
+		this.originalTokenStream = this.tokenStream;
 
 		// ensure each node has pointer to surrounding grammar
 		final Grammar thiz = this;
@@ -316,20 +388,22 @@ public class Grammar implements AttributeResolver {
             GrammarAST t = (GrammarAST)c;
             String importedGrammarName = null;
             if ( t.getType()==ANTLRParser.ASSIGN ) {
-                importedGrammarName = t.getChild(1).getText();
-                tool.log("grammar", "import "+ importedGrammarName);
+				t = (GrammarAST)t.getChild(1);
+				importedGrammarName = t.getText();
             }
             else if ( t.getType()==ANTLRParser.ID ) {
                 importedGrammarName = t.getText();
-                tool.log("grammar", "import " + t.getText());
 			}
 			Grammar g;
 			try {
-				g = tool.loadImportedGrammar(this, importedGrammarName);
+				g = tool.loadImportedGrammar(this, t);
 			}
 			catch (IOException ioe) {
-				tool.errMgr.toolError(ErrorType.CANNOT_FIND_IMPORTED_GRAMMAR, ioe,
-									  importedGrammarName);
+				tool.errMgr.grammarError(ErrorType.ERROR_READING_IMPORTED_GRAMMAR,
+										 importedGrammarName,
+										 t.getToken(),
+										 importedGrammarName,
+										 name);
 				continue;
 			}
 			// did it come back as error node or missing?
@@ -355,11 +429,59 @@ public class Grammar implements AttributeResolver {
         }
     }
 
-    public void defineRule(Rule r) {
-		if ( rules.get(r.name)!=null ) return;
+	/**
+	 * Define the specified rule in the grammar. This method assigns the rule's
+	 * {@link Rule#index} according to the {@link #ruleNumber} field, and adds
+	 * the {@link Rule} instance to {@link #rules} and {@link #indexToRule}.
+	 *
+	 * @param r The rule to define in the grammar.
+	 * @return {@code true} if the rule was added to the {@link Grammar}
+	 * instance; otherwise, {@code false} if a rule with this name already
+	 * existed in the grammar instance.
+	 */
+	public boolean defineRule(Rule r) {
+		if ( rules.get(r.name)!=null ) {
+			return false;
+		}
+
 		rules.put(r.name, r);
 		r.index = ruleNumber++;
 		indexToRule.add(r);
+		return true;
+	}
+
+	/**
+	 * Undefine the specified rule from this {@link Grammar} instance. The
+	 * instance {@code r} is removed from {@link #rules} and
+	 * {@link #indexToRule}. This method updates the {@link Rule#index} field
+	 * for all rules defined after {@code r}, and decrements {@link #ruleNumber}
+	 * in preparation for adding new rules.
+	 * <p>
+	 * This method does nothing if the current {@link Grammar} does not contain
+	 * the instance {@code r} at index {@code r.index} in {@link #indexToRule}.
+	 * </p>
+	 *
+	 * @param r
+	 * @return {@code true} if the rule was removed from the {@link Grammar}
+	 * instance; otherwise, {@code false} if the specified rule was not defined
+	 * in the grammar.
+	 */
+	public boolean undefineRule(Rule r) {
+		if (r.index < 0 || r.index >= indexToRule.size() || indexToRule.get(r.index) != r) {
+			return false;
+		}
+
+		assert rules.get(r.name) == r;
+
+		rules.remove(r.name);
+		indexToRule.remove(r.index);
+		for (int i = r.index; i < indexToRule.size(); i++) {
+			assert indexToRule.get(i).index == i + 1;
+			indexToRule.get(i).index--;
+		}
+
+		ruleNumber--;
+		return true;
 	}
 
 //	public int getNumRules() {
@@ -386,6 +508,14 @@ public class Grammar implements AttributeResolver {
 		*/
 	}
 
+	public ATN getATN() {
+		if ( atn==null ) {
+			ParserATNFactory factory = new ParserATNFactory(this);
+			atn = factory.createATN();
+		}
+		return atn;
+	}
+
 	public Rule getRule(int index) { return indexToRule.get(index); }
 
 	public Rule getRule(String grammarName, String ruleName) {
@@ -403,29 +533,38 @@ public class Grammar implements AttributeResolver {
      *  The grammars are in import tree preorder.  Don't include ourselves
      *  in list as we're not a delegate of ourselves.
      */
-    public List<Grammar> getAllImportedGrammars() {
-        if ( importedGrammars==null ) return null;
-        List<Grammar> delegates = new ArrayList<Grammar>();
-		for (Grammar d : importedGrammars) {
-			delegates.add(d);
-			List<Grammar> ds = d.getAllImportedGrammars();
-			if (ds != null) delegates.addAll(ds);
+	public List<Grammar> getAllImportedGrammars() {
+		if (importedGrammars == null) {
+			return null;
 		}
-        return delegates;
-    }
+
+		LinkedHashMap<String, Grammar> delegates = new LinkedHashMap<String, Grammar>();
+		for (Grammar d : importedGrammars) {
+			delegates.put(d.fileName, d);
+			List<Grammar> ds = d.getAllImportedGrammars();
+			if (ds != null) {
+				for (Grammar imported : ds) {
+					delegates.put(imported.fileName, imported);
+				}
+			}
+		}
+
+		return new ArrayList<Grammar>(delegates.values());
+	}
 
     public List<Grammar> getImportedGrammars() { return importedGrammars; }
 
-    /** Get delegates below direct delegates of g
-    public List<Grammar> getIndirectDelegates(Grammar g) {
-        List<Grammar> direct = getDirectDelegates(g);
-        List<Grammar> delegates = getDelegates(g);
-        delegates.removeAll(direct);
-        return delegates;
-    }
-*/
+	public LexerGrammar getImplicitLexer() {
+		return implicitLexer;
+	}
 
-    /** Return list of imported grammars from root down to our parent.
+	/** convenience method for Tool.loadGrammar() */
+	public static Grammar load(String fileName) {
+		Tool antlr = new Tool();
+		return antlr.loadGrammar(fileName);
+	}
+
+	/** Return list of imported grammars from root down to our parent.
      *  Order is [root, ..., this.parent].  (us not included).
      */
     public List<Grammar> getGrammarAncestors() {
@@ -505,37 +644,98 @@ public class Grammar implements AttributeResolver {
 	 *  char vocabulary, compute an ANTLR-valid (possibly escaped) char literal.
 	 */
 	public String getTokenDisplayName(int ttype) {
-		String tokenName;
 		// inside any target's char range and is lexer grammar?
 		if ( isLexer() &&
 			 ttype >= Lexer.MIN_CHAR_VALUE && ttype <= Lexer.MAX_CHAR_VALUE )
 		{
 			return CharSupport.getANTLRCharLiteralForChar(ttype);
 		}
-		else if ( ttype==Token.EOF ) {
-			tokenName = "EOF";
+
+		if ( ttype==Token.EOF ) {
+			return "EOF";
 		}
-		else {
-			if ( ttype>0 && ttype<typeToTokenList.size() ) {
-				tokenName = typeToTokenList.get(ttype);
-				if ( tokenName!=null &&
-					 tokenName.startsWith(AUTO_GENERATED_TOKEN_NAME_PREFIX) &&
-					 ttype < typeToStringLiteralList.size() &&
-				     typeToStringLiteralList.get(ttype)!=null)
-				{
-					tokenName = typeToStringLiteralList.get(ttype);
-				}
-			}
-			else {
-				tokenName = String.valueOf(ttype);
-			}
+
+		if ( ttype==Token.INVALID_TYPE ) {
+			return INVALID_TOKEN_NAME;
 		}
-//		tool.log("grammar", "getTokenDisplayName ttype="+ttype+", name="+tokenName);
-		return tokenName;
+
+		if (ttype >= 0 && ttype < typeToStringLiteralList.size() && typeToStringLiteralList.get(ttype) != null) {
+			return typeToStringLiteralList.get(ttype);
+		}
+
+		if (ttype >= 0 && ttype < typeToTokenList.size() && typeToTokenList.get(ttype) != null) {
+			return typeToTokenList.get(ttype);
+		}
+
+		return String.valueOf(ttype);
 	}
 
+	/**
+	 * Gets the name by which a token can be referenced in the generated code.
+	 * For tokens defined in a {@code tokens{}} block or via a lexer rule, this
+	 * is the declared name of the token. For token types generated by the use
+	 * of a string literal within a parser rule of a combined grammar, this is
+	 * the automatically generated token type which includes the
+	 * {@link #AUTO_GENERATED_TOKEN_NAME_PREFIX} prefix. For types which are not
+	 * associated with a defined token, this method returns
+	 * {@link #INVALID_TOKEN_NAME}.
+	 *
+	 * @param ttype The token type.
+	 * @return The name of the token with the specified type.
+	 */
+
+	public String getTokenName(int ttype) {
+		// inside any target's char range and is lexer grammar?
+		if ( isLexer() &&
+			 ttype >= Lexer.MIN_CHAR_VALUE && ttype <= Lexer.MAX_CHAR_VALUE )
+		{
+			return CharSupport.getANTLRCharLiteralForChar(ttype);
+		}
+
+		if ( ttype==Token.EOF ) {
+			return "EOF";
+		}
+
+		if (ttype >= 0 && ttype < typeToTokenList.size() && typeToTokenList.get(ttype) != null) {
+			return typeToTokenList.get(ttype);
+		}
+
+		return INVALID_TOKEN_NAME;
+	}
+
+	/**
+	 * Gets the constant channel value for a user-defined channel.
+	 *
+	 * <p>
+	 * This method only returns channel values for user-defined channels. All
+	 * other channels, including the predefined channels
+	 * {@link Token#DEFAULT_CHANNEL} and {@link Token#HIDDEN_CHANNEL} along with
+	 * any channel defined in code (e.g. in a {@code @members{}} block), are
+	 * ignored.</p>
+	 *
+	 * @param channel The channel name.
+	 * @return The channel value, if {@code channel} is the name of a known
+	 * user-defined token channel; otherwise, -1.
+	 */
+	public int getChannelValue(String channel) {
+		Integer I = channelNameToValueMap.get(channel);
+		int i = (I != null) ? I : -1;
+		return i;
+	}
+
+	/**
+	 * Gets an array of rule names for rules defined or imported by the
+	 * grammar. The array index is the rule index, and the value is the name of
+	 * the rule with the corresponding {@link Rule#index}.
+	 *
+	 * <p>If no rule is defined with an index for an element of the resulting
+	 * array, the value of that element is {@link #INVALID_RULE_NAME}.</p>
+	 *
+	 * @return The names of all rules defined in the grammar.
+	 */
 	public String[] getRuleNames() {
 		String[] result = new String[rules.size()];
+		Arrays.fill(result, INVALID_RULE_NAME);
 		for (Rule rule : rules.values()) {
 			result[rule.index] = rule.name;
 		}
@@ -543,39 +743,141 @@ public class Grammar implements AttributeResolver {
 		return result;
 	}
 
-	public List<String> getTokenDisplayNames(IntegerList types) {
-		List<String> names = new ArrayList<String>();
-		for (int t : types.toArray()) names.add(getTokenDisplayName(t));
-		return names;
-	}
-
+	/**
+	 * Gets an array of token names for tokens defined or imported by the
+	 * grammar. The array index is the token type, and the value is the result
+	 * of {@link #getTokenName} for the corresponding token type.
+	 *
+	 * @see #getTokenName
+	 * @return The token names of all tokens defined in the grammar.
+	 */
 	public String[] getTokenNames() {
 		int numTokens = getMaxTokenType();
 		String[] tokenNames = new String[numTokens+1];
-		for (String tokenName : tokenNameToTypeMap.keySet()) {
-			Integer ttype = tokenNameToTypeMap.get(tokenName);
-			if ( tokenName!=null && tokenName.startsWith(AUTO_GENERATED_TOKEN_NAME_PREFIX) ) {
-				tokenName = typeToStringLiteralList.get(ttype);
-			}
-			if ( ttype>0 ) tokenNames[ttype] = tokenName;
+		for (int i = 0; i < tokenNames.length; i++) {
+			tokenNames[i] = getTokenName(i);
 		}
+
 		return tokenNames;
 	}
 
+	/**
+	 * Gets an array of display names for tokens defined or imported by the
+	 * grammar. The array index is the token type, and the value is the result
+	 * of {@link #getTokenDisplayName} for the corresponding token type.
+	 *
+	 * @see #getTokenDisplayName
+	 * @return The display names of all tokens defined in the grammar.
+	 */
 	public String[] getTokenDisplayNames() {
 		int numTokens = getMaxTokenType();
 		String[] tokenNames = new String[numTokens+1];
-		for (String t : tokenNameToTypeMap.keySet()) {
-			Integer ttype = tokenNameToTypeMap.get(t);
-			if ( ttype>0 ) tokenNames[ttype] = t;
-		}
-		for (String t : stringLiteralToTypeMap.keySet()) {
-			Integer ttype = stringLiteralToTypeMap.get(t);
-			if ( ttype>0 ) tokenNames[ttype] = t;
+		for (int i = 0; i < tokenNames.length; i++) {
+			tokenNames[i] = getTokenDisplayName(i);
 		}
+
 		return tokenNames;
 	}
 
+	/**
+	 * Gets the literal names assigned to tokens in the grammar.
+	 */
+
+	public String[] getTokenLiteralNames() {
+		int numTokens = getMaxTokenType();
+		String[] literalNames = new String[numTokens+1];
+		for (int i = 0; i < Math.min(literalNames.length, typeToStringLiteralList.size()); i++) {
+			literalNames[i] = typeToStringLiteralList.get(i);
+		}
+
+		for (Map.Entry<String, Integer> entry : stringLiteralToTypeMap.entrySet()) {
+			if (entry.getValue() >= 0 && entry.getValue() < literalNames.length && literalNames[entry.getValue()] == null) {
+				literalNames[entry.getValue()] = entry.getKey();
+			}
+		}
+
+		return literalNames;
+	}
+
+	/**
+	 * Gets the symbolic names assigned to tokens in the grammar.
+	 */
+
+	public String[] getTokenSymbolicNames() {
+		int numTokens = getMaxTokenType();
+		String[] symbolicNames = new String[numTokens+1];
+		for (int i = 0; i < Math.min(symbolicNames.length, typeToTokenList.size()); i++) {
+			if (typeToTokenList.get(i) == null || typeToTokenList.get(i).startsWith(AUTO_GENERATED_TOKEN_NAME_PREFIX)) {
+				continue;
+			}
+
+			symbolicNames[i] = typeToTokenList.get(i);
+		}
+
+		return symbolicNames;
+	}
+
+	/**
+	 * Gets a {@link Vocabulary} instance describing the vocabulary used by the
+	 * grammar.
+	 */
+
+	public Vocabulary getVocabulary() {
+		return new VocabularyImpl(getTokenLiteralNames(), getTokenSymbolicNames());
+	}
+
+	/** Given an arbitrarily complex SemanticContext, walk the "tree" and get display string.
+	 *  Pull predicates from grammar text.
+	 */
+	public String getSemanticContextDisplayString(SemanticContext semctx) {
+		if ( semctx instanceof SemanticContext.Predicate ) {
+			return getPredicateDisplayString((SemanticContext.Predicate)semctx);
+		}
+		if ( semctx instanceof SemanticContext.AND ) {
+			SemanticContext.AND and = (SemanticContext.AND)semctx;
+			return joinPredicateOperands(and, " and ");
+		}
+		if ( semctx instanceof SemanticContext.OR ) {
+			SemanticContext.OR or = (SemanticContext.OR)semctx;
+			return joinPredicateOperands(or, " or ");
+		}
+		return semctx.toString();
+	}
+
+	public String joinPredicateOperands(SemanticContext.Operator op, String separator) {
+		StringBuilder buf = new StringBuilder();
+		for (SemanticContext operand : op.getOperands()) {
+			if (buf.length() > 0) {
+				buf.append(separator);
+			}
+
+			buf.append(getSemanticContextDisplayString(operand));
+		}
+
+		return buf.toString();
+	}
+
+	public LinkedHashMap<Integer, PredAST> getIndexToPredicateMap() {
+		LinkedHashMap<Integer, PredAST> indexToPredMap = new LinkedHashMap<Integer, PredAST>();
+		for (Rule r : rules.values()) {
+			for (ActionAST a : r.actions) {
+				if (a instanceof PredAST) {
+					PredAST p = (PredAST) a;
+					indexToPredMap.put(sempreds.get(p), p);
+				}
+			}
+		}
+		return indexToPredMap;
+	}
+
+	public String getPredicateDisplayString(SemanticContext.Predicate pred) {
+		if ( indexToPredMap==null ) {
+			indexToPredMap = getIndexToPredicateMap();
+		}
+		ActionAST actionAST = indexToPredMap.get(pred.predIndex);
+		return actionAST.getText();
+	}
+
 	/** What is the max char value possible for this grammar's target?  Use
 	 *  unicode max if no target defined.
 	 */
@@ -615,10 +917,16 @@ public class Grammar implements AttributeResolver {
 		return maxTokenType;
 	}
 
+	/** Return a new unique integer in the channel value space. */
+	public int getNewChannelNumber() {
+		maxChannelType++;
+		return maxChannelType;
+	}
+
 	public void importTokensFromTokensFile() {
 		String vocab = getOptionString("tokenVocab");
 		if ( vocab!=null ) {
-			TokenVocabParser vparser = new TokenVocabParser(tool, vocab);
+			TokenVocabParser vparser = new TokenVocabParser(this);
 			Map<String,Integer> tokens = vparser.load();
 			tool.log("grammar", "tokens=" + tokens);
 			for (String t : tokens.keySet()) {
@@ -635,6 +943,9 @@ public class Grammar implements AttributeResolver {
 		for (String tokenName: importG.stringLiteralToTypeMap.keySet()) {
 			defineStringLiteral(tokenName, importG.stringLiteralToTypeMap.get(tokenName));
 		}
+		for (Map.Entry<String, Integer> channel : importG.channelNameToValueMap.entrySet()) {
+			defineChannelName(channel.getKey(), channel.getValue());
+		}
 //		this.tokenNameToTypeMap.putAll( importG.tokenNameToTypeMap );
 //		this.stringLiteralToTypeMap.putAll( importG.stringLiteralToTypeMap );
 		int max = Math.max(this.typeToTokenList.size(), importG.typeToTokenList.size());
@@ -643,6 +954,13 @@ public class Grammar implements AttributeResolver {
 			maxTokenType = Math.max(maxTokenType, ttype);
 			this.typeToTokenList.set(ttype, importG.typeToTokenList.get(ttype));
 		}
+
+		max = Math.max(this.channelValueToNameList.size(), importG.channelValueToNameList.size());
+		Utils.setSize(channelValueToNameList, max);
+		for (int channelValue = 0; channelValue < importG.channelValueToNameList.size(); channelValue++) {
+			maxChannelType = Math.max(maxChannelType, channelValue);
+			this.channelValueToNameList.set(channelValue, importG.channelValueToNameList.get(channelValue));
+		}
 	}
 
 	public int defineTokenName(String name) {
@@ -691,6 +1009,11 @@ public class Grammar implements AttributeResolver {
 	}
 
 	public void setTokenForType(int ttype, String text) {
+		if (ttype == Token.EOF) {
+			// ignore EOF, it will be reported as an error separately
+			return;
+		}
+
 		if ( ttype>=typeToTokenList.size() ) {
 			Utils.setSize(typeToTokenList, ttype+1);
 		}
@@ -701,6 +1024,68 @@ public class Grammar implements AttributeResolver {
 		}
 	}
 
+	/**
+	 * Define a token channel with a specified name.
+	 *
+	 * <p>
+	 * If a channel with the specified name already exists, the previously
+	 * assigned channel value is returned.</p>
+	 *
+	 * @param name The channel name.
+	 * @return The constant channel value assigned to the channel.
+	 */
+	public int defineChannelName(String name) {
+		Integer prev = channelNameToValueMap.get(name);
+		if (prev == null) {
+			return defineChannelName(name, getNewChannelNumber());
+		}
+
+		return prev;
+	}
+
+	/**
+	 * Define a token channel with a specified name.
+	 *
+	 * <p>
+	 * If a channel with the specified name already exists, the previously
+	 * assigned channel value is not altered.</p>
+	 *
+	 * @param name The channel name.
+	 * @return The constant channel value assigned to the channel.
+	 */
+	public int defineChannelName(String name, int value) {
+		Integer prev = channelNameToValueMap.get(name);
+		if (prev != null) {
+			return prev;
+		}
+
+		channelNameToValueMap.put(name, value);
+		setChannelNameForValue(value, name);
+		maxChannelType = Math.max(maxChannelType, value);
+		return value;
+	}
+
+	/**
+	 * Sets the channel name associated with a particular channel value.
+	 *
+	 * <p>
+	 * If a name has already been assigned to the channel with constant value
+	 * {@code channelValue}, this method does nothing.</p>
+	 *
+	 * @param channelValue The constant value for the channel.
+	 * @param name The channel name.
+	 */
+	public void setChannelNameForValue(int channelValue, String name) {
+		if (channelValue >= channelValueToNameList.size()) {
+			Utils.setSize(channelValueToNameList, channelValue + 1);
+		}
+
+		String prevChannel = channelValueToNameList.get(channelValue);
+		if (prevChannel == null) {
+			channelValueToNameList.set(channelValue, name);
+		}
+	}
+
 	// no isolated attr at grammar action level
 	@Override
 	public Attribute resolveToAttribute(String x, ActionAST node) {
@@ -854,12 +1239,14 @@ public class Grammar implements AttributeResolver {
 	}
 
 	public Set<String> getStringLiterals() {
-		final Set<String> strings = new HashSet<String>();
+		final Set<String> strings = new LinkedHashSet<String>();
 		GrammarTreeVisitor collector = new GrammarTreeVisitor() {
 			@Override
 			public void stringRef(TerminalAST ref) {
 				strings.add(ref.getText());
 			}
+			@Override
+			public ErrorManager getErrorManager() { return tool.errMgr; }
 		};
 		collector.visitGrammar(ast);
 		return strings;
@@ -869,6 +1256,49 @@ public class Grammar implements AttributeResolver {
 		decisionDFAs.put(decision, lookaheadDFA);
 	}
 
+	public static Map<Integer, Interval> getStateToGrammarRegionMap(GrammarRootAST ast, IntervalSet grammarTokenTypes) {
+		Map<Integer, Interval> stateToGrammarRegionMap = new HashMap<Integer, Interval>();
+		if ( ast==null ) return stateToGrammarRegionMap;
+
+		List<GrammarAST> nodes = ast.getNodesWithType(grammarTokenTypes);
+		for (GrammarAST n : nodes) {
+			if (n.atnState != null) {
+				Interval tokenRegion = Interval.of(n.getTokenStartIndex(), n.getTokenStopIndex());
+				org.antlr.runtime.tree.Tree ruleNode = null;
+				// RULEs, BLOCKs of transformed recursive rules point to original token interval
+				switch ( n.getType() ) {
+					case ANTLRParser.RULE :
+						ruleNode = n;
+						break;
+					case ANTLRParser.BLOCK :
+					case ANTLRParser.CLOSURE :
+						ruleNode = n.getAncestor(ANTLRParser.RULE);
+						break;
+				}
+				if ( ruleNode instanceof RuleAST ) {
+					String ruleName = ((RuleAST) ruleNode).getRuleName();
+					Rule r = ast.g.getRule(ruleName);
+					if ( r instanceof LeftRecursiveRule ) {
+						RuleAST originalAST = ((LeftRecursiveRule) r).getOriginalAST();
+						tokenRegion = Interval.of(originalAST.getTokenStartIndex(), originalAST.getTokenStopIndex());
+					}
+				}
+				stateToGrammarRegionMap.put(n.atnState.stateNumber, tokenRegion);
+			}
+		}
+		return stateToGrammarRegionMap;
+	}
+
+	/** Given an ATN state number, return the token index range within the grammar from which that ATN state was derived. */
+	public Interval getStateToGrammarRegion(int atnStateNumber) {
+		if ( stateToGrammarRegionMap==null ) {
+			stateToGrammarRegionMap = getStateToGrammarRegionMap(ast, null); // map all nodes with non-null atn state ptr
+		}
+		if ( stateToGrammarRegionMap==null ) return Interval.INVALID;
+
+		return stateToGrammarRegionMap.get(atnStateNumber);
+	}
+
 	public LexerInterpreter createLexerInterpreter(CharStream input) {
 		if (this.isParser()) {
 			throw new IllegalStateException("A lexer interpreter can only be created for a lexer or combined grammar.");
@@ -878,7 +1308,19 @@ public class Grammar implements AttributeResolver {
 			return implicitLexer.createLexerInterpreter(input);
 		}
 
-		return new LexerInterpreter(fileName, Arrays.asList(getTokenNames()), Arrays.asList(getRuleNames()), ((LexerGrammar)this).modes.keySet(), atn, input);
+		char[] serializedAtn = ATNSerializer.getSerializedAsChars(atn);
+		ATN deserialized = new ATNDeserializer().deserialize(serializedAtn);
+		return new LexerInterpreter(fileName, getVocabulary(), Arrays.asList(getRuleNames()), ((LexerGrammar)this).modes.keySet(), deserialized, input);
+	}
+
+	/** @since 4.5.1 */
+	public GrammarParserInterpreter createGrammarParserInterpreter(TokenStream tokenStream) {
+		if (this.isLexer()) {
+			throw new IllegalStateException("A parser interpreter can only be created for a parser or combined grammar.");
+		}
+		char[] serializedAtn = ATNSerializer.getSerializedAsChars(atn);
+		ATN deserialized = new ATNDeserializer().deserialize(serializedAtn);
+		return new GrammarParserInterpreter(this, deserialized, tokenStream);
 	}
 
 	public ParserInterpreter createParserInterpreter(TokenStream tokenStream) {
@@ -886,6 +1328,8 @@ public class Grammar implements AttributeResolver {
 			throw new IllegalStateException("A parser interpreter can only be created for a parser or combined grammar.");
 		}
 
-		return new ParserInterpreter(fileName, Arrays.asList(getTokenNames()), Arrays.asList(getRuleNames()), atn, tokenStream);
+		char[] serializedAtn = ATNSerializer.getSerializedAsChars(atn);
+		ATN deserialized = new ATNDeserializer().deserialize(serializedAtn);
+		return new ParserInterpreter(fileName, getVocabulary(), Arrays.asList(getRuleNames()), deserialized, tokenStream);
 	}
 }
diff --git a/tool/src/org/antlr/v4/tool/GrammarInterpreterRuleContext.java b/tool/src/org/antlr/v4/tool/GrammarInterpreterRuleContext.java
new file mode 100644
index 000000000..936b8dca2
--- /dev/null
+++ b/tool/src/org/antlr/v4/tool/GrammarInterpreterRuleContext.java
@@ -0,0 +1,68 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2012 Terence Parr
+ *  Copyright (c) 2012 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.
+ */
+package org.antlr.v4.tool;
+
+import org.antlr.v4.runtime.InterpreterRuleContext;
+import org.antlr.v4.runtime.ParserRuleContext;
+
+/** An {@link InterpreterRuleContext} that knows which alternative
+ *  for a rule was matched.
+ *
+ *  @see GrammarParserInterpreter
+ *  @since 4.5.1
+ */
+public class GrammarInterpreterRuleContext extends InterpreterRuleContext {
+	protected int outerAltNum = 1;
+
+	public GrammarInterpreterRuleContext(ParserRuleContext parent, int invokingStateNumber, int ruleIndex) {
+		super(parent, invokingStateNumber, ruleIndex);
+	}
+
+	/** The predicted outermost alternative for the rule associated
+	 *  with this context object.  If this node left recursive, the true original
+	 *  outermost alternative is returned.
+	 */
+	public int getOuterAltNum() { return outerAltNum; }
+
+	public void setOuterAltNum(int outerAltNum) {
+		this.outerAltNum = outerAltNum;
+	}
+
+	@Override
+	public int getAltNumber() {
+		// override here and called old functionality; makes it backward compatible vs changing names
+		return getOuterAltNum();
+	}
+
+	@Override
+	public void setAltNumber(int altNumber) {
+		setOuterAltNum(altNumber);
+	}
+}
diff --git a/tool/src/org/antlr/v4/tool/GrammarParserInterpreter.java b/tool/src/org/antlr/v4/tool/GrammarParserInterpreter.java
new file mode 100644
index 000000000..1e77d57f8
--- /dev/null
+++ b/tool/src/org/antlr/v4/tool/GrammarParserInterpreter.java
@@ -0,0 +1,474 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2012 Terence Parr
+ *  Copyright (c) 2012 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.
+ */
+package org.antlr.v4.tool;
+
+import org.antlr.v4.runtime.BailErrorStrategy;
+import org.antlr.v4.runtime.DefaultErrorStrategy;
+import org.antlr.v4.runtime.InputMismatchException;
+import org.antlr.v4.runtime.InterpreterRuleContext;
+import org.antlr.v4.runtime.Parser;
+import org.antlr.v4.runtime.ParserInterpreter;
+import org.antlr.v4.runtime.ParserRuleContext;
+import org.antlr.v4.runtime.RecognitionException;
+import org.antlr.v4.runtime.Token;
+import org.antlr.v4.runtime.TokenStream;
+import org.antlr.v4.runtime.Vocabulary;
+import org.antlr.v4.runtime.atn.ATN;
+import org.antlr.v4.runtime.atn.ATNDeserializer;
+import org.antlr.v4.runtime.atn.ATNSerializer;
+import org.antlr.v4.runtime.atn.ATNState;
+import org.antlr.v4.runtime.atn.DecisionState;
+import org.antlr.v4.runtime.atn.PredictionMode;
+import org.antlr.v4.runtime.atn.RuleStartState;
+import org.antlr.v4.runtime.atn.StarLoopEntryState;
+import org.antlr.v4.runtime.tree.Trees;
+
+import java.lang.reflect.Constructor;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.BitSet;
+import java.util.Collection;
+import java.util.List;
+
+/** A heavier weight {@link ParserInterpreter} that creates parse trees
+ *  that track alternative numbers for subtree roots.
+ *
+ * @since 4.5.1
+ *
+ */
+public class GrammarParserInterpreter extends ParserInterpreter {
+	/** The grammar associated with this interpreter. Unlike the
+	 *  {@link ParserInterpreter} from the standard distribution,
+	 *  this can reference Grammar, which is in the tools area not
+	 *  purely runtime.
+	 */
+	protected final Grammar g;
+
+	protected BitSet decisionStatesThatSetOuterAltNumInContext;
+
+	/** Cache {@link LeftRecursiveRule#getPrimaryAlts()} and
+	 *  {@link LeftRecursiveRule#getRecursiveOpAlts()} for states in
+	 *  {@link #decisionStatesThatSetOuterAltNumInContext}. It only
+	 *  caches decisions in left-recursive rules.
+	 */
+	protected int[][] stateToAltsMap;
+
+	public GrammarParserInterpreter(Grammar g,
+									String grammarFileName,
+									Vocabulary vocabulary,
+									Collection<String> ruleNames,
+									ATN atn,
+									TokenStream input) {
+		super(grammarFileName, vocabulary, ruleNames, atn, input);
+		this.g = g;
+	}
+
+	public GrammarParserInterpreter(Grammar g, ATN atn, TokenStream input) {
+		super(g.fileName, g.getVocabulary(),
+			  Arrays.asList(g.getRuleNames()),
+			  atn, // must run ATN through serializer to set some state flags
+			  input);
+		this.g = g;
+		decisionStatesThatSetOuterAltNumInContext = findOuterMostDecisionStates();
+		stateToAltsMap = new int[g.atn.states.size()][];
+	}
+
+	@Override
+	protected InterpreterRuleContext createInterpreterRuleContext(ParserRuleContext parent,
+																  int invokingStateNumber,
+																  int ruleIndex)
+	{
+		return new GrammarInterpreterRuleContext(parent, invokingStateNumber, ruleIndex);
+	}
+
+	@Override
+	public void reset() {
+		super.reset();
+		overrideDecisionRoot = null;
+	}
+
+	/** identify the ATN states where we need to set the outer alt number.
+	 *  For regular rules, that's the block at the target to rule start state.
+	 *  For left-recursive rules, we track the primary block, which looks just
+	 *  like a regular rule's outer block, and the star loop block (always
+	 *  there even if 1 alt).
+	 */
+	public BitSet findOuterMostDecisionStates() {
+		BitSet track = new BitSet(atn.states.size());
+		int numberOfDecisions = atn.getNumberOfDecisions();
+		for (int i = 0; i < numberOfDecisions; i++) {
+			DecisionState decisionState = atn.getDecisionState(i);
+			RuleStartState startState = atn.ruleToStartState[decisionState.ruleIndex];
+			// Look for StarLoopEntryState that is in any left recursive rule
+			if ( decisionState instanceof StarLoopEntryState) {
+				StarLoopEntryState loopEntry = (StarLoopEntryState)decisionState;
+				if ( loopEntry.isPrecedenceDecision ) {
+					// Recursive alts always result in a (...)* in the transformed
+					// left recursive rule and that always has a BasicBlockStartState
+					// even if just 1 recursive alt exists.
+					ATNState blockStart = loopEntry.transition(0).target;
+					// track the StarBlockStartState associated with the recursive alternatives
+					track.set(blockStart.stateNumber);
+				}
+			}
+			else if ( startState.transition(0).target == decisionState ) {
+				// always track outermost block for any rule if it exists
+				track.set(decisionState.stateNumber);
+			}
+		}
+		return track;
+	}
+
+	/** Override this method so that we can record which alternative
+	 *  was taken at each decision point. For non-left recursive rules,
+	 *  it's simple. Set decisionStatesThatSetOuterAltNumInContext
+	 *  indicates which decision states should set the outer alternative number.
+	 *
+	 *  <p>Left recursive rules are much more complicated to deal with:
+	 *  there is typically a decision for the primary alternatives and a
+	 *  decision to choose between the recursive operator alternatives.
+	 *  For example, the following left recursive rule has two primary and 2
+	 *  recursive alternatives.</p>
+	 *
+		 e : e '*' e
+		   | '-' INT
+		   | e '+' e
+		   | ID
+		   ;
+
+	 *  <p>ANTLR rewrites that rule to be</p>
+
+		 e[int precedence]
+			 : ('-' INT | ID)
+			 ( {...}? '*' e[5]
+			 | {...}? '+' e[3]
+			 )*
+			;
+
+	 *
+	 *  <p>So, there are two decisions associated with picking the outermost alt.
+	 *  This complicates our tracking significantly. The outermost alternative number
+	 *  is a function of the decision (ATN state) within a left recursive rule and the
+	 *  predicted alternative coming back from adaptivePredict().
+	 *
+	 *  We use stateToAltsMap as a cache to avoid expensive calls to
+	 *  getRecursiveOpAlts().
+	 */
+	@Override
+	protected int visitDecisionState(DecisionState p) {
+		int predictedAlt = super.visitDecisionState(p);
+		if( p.getNumberOfTransitions() > 1) {
+//			System.out.println("decision "+p.decision+": "+predictedAlt);
+			if( p.decision == this.overrideDecision &&
+				this._input.index() == this.overrideDecisionInputIndex )
+			{
+				overrideDecisionRoot = (GrammarInterpreterRuleContext)getContext();
+			}
+		}
+
+		GrammarInterpreterRuleContext ctx = (GrammarInterpreterRuleContext)_ctx;
+		if ( decisionStatesThatSetOuterAltNumInContext.get(p.stateNumber) ) {
+			ctx.outerAltNum = predictedAlt;
+			Rule r = g.getRule(p.ruleIndex);
+			if ( atn.ruleToStartState[r.index].isLeftRecursiveRule ) {
+				int[] alts = stateToAltsMap[p.stateNumber];
+				LeftRecursiveRule lr = (LeftRecursiveRule) g.getRule(p.ruleIndex);
+				if (p.getStateType() == ATNState.BLOCK_START) {
+					if ( alts==null ) {
+						alts = lr.getPrimaryAlts();
+						stateToAltsMap[p.stateNumber] = alts; // cache it
+					}
+				}
+				else if ( p.getStateType() == ATNState.STAR_BLOCK_START ) {
+					if ( alts==null ) {
+						alts = lr.getRecursiveOpAlts();
+						stateToAltsMap[p.stateNumber] = alts; // cache it
+					}
+				}
+				ctx.outerAltNum = alts[predictedAlt];
+			}
+		}
+
+		return predictedAlt;
+	}
+
+	/** Given an ambiguous parse information, return the list of ambiguous parse trees.
+	 *  An ambiguity occurs when a specific token sequence can be recognized
+	 *  in more than one way by the grammar. These ambiguities are detected only
+	 *  at decision points.
+	 *
+	 *  The list of trees includes the actual interpretation (that for
+	 *  the minimum alternative number) and all ambiguous alternatives.
+	 *  The actual interpretation is always first.
+	 *
+	 *  This method reuses the same physical input token stream used to
+	 *  detect the ambiguity by the original parser in the first place.
+	 *  This method resets/seeks within but does not alter originalParser.
+	 *
+	 *  The trees are rooted at the node whose start..stop token indices
+	 *  include the start and stop indices of this ambiguity event. That is,
+	 *  the trees returned will always include the complete ambiguous subphrase
+	 *  identified by the ambiguity event.  The subtrees returned will
+	 *  also always contain the node associated with the overridden decision.
+	 *
+	 *  Be aware that this method does NOT notify error or parse listeners as
+	 *  it would trigger duplicate or otherwise unwanted events.
+	 *
+	 *  This uses a temporary ParserATNSimulator and a ParserInterpreter
+	 *  so we don't mess up any statistics, event lists, etc...
+	 *  The parse tree constructed while identifying/making ambiguityInfo is
+	 *  not affected by this method as it creates a new parser interp to
+	 *  get the ambiguous interpretations.
+	 *
+	 *  Nodes in the returned ambig trees are independent of the original parse
+	 *  tree (constructed while identifying/creating ambiguityInfo).
+	 *
+	 *  @since 4.5.1
+	 *
+	 *  @param g              From which grammar should we drive alternative
+	 *                        numbers and alternative labels.
+	 *
+	 *  @param originalParser The parser used to create ambiguityInfo; it
+	 *                        is not modified by this routine and can be either
+	 *                        a generated or interpreted parser. It's token
+	 *                        stream *is* reset/seek()'d.
+	 *  @param tokens		  A stream of tokens to use with the temporary parser.
+	 *                        This will often be just the token stream within the
+	 *                        original parser but here it is for flexibility.
+	 *
+	 *  @param decision       Which decision to try different alternatives for.
+	 *
+	 *  @param alts           The set of alternatives to try while re-parsing.
+	 *
+	 *  @param startIndex	  The index of the first token of the ambiguous
+	 *                        input or other input of interest.
+	 *
+	 *  @param stopIndex      The index of the last token of the ambiguous input.
+	 *                        The start and stop indexes are used primarily to
+	 *                        identify how much of the resulting parse tree
+	 *                        to return.
+	 *
+	 *  @param startRuleIndex The start rule for the entire grammar, not
+	 *                        the ambiguous decision. We re-parse the entire input
+	 *                        and so we need the original start rule.
+	 *
+	 *  @return               The list of all possible interpretations of
+	 *                        the input for the decision in ambiguityInfo.
+	 *                        The actual interpretation chosen by the parser
+	 *                        is always given first because this method
+	 *                        retests the input in alternative order and
+	 *                        ANTLR always resolves ambiguities by choosing
+	 *                        the first alternative that matches the input.
+	 *                        The subtree returned
+	 *
+	 *  @throws RecognitionException Throws upon syntax error while matching
+	 *                               ambig input.
+	 */
+	public static List<ParserRuleContext> getAllPossibleParseTrees(Grammar g,
+																   Parser originalParser,
+																   TokenStream tokens,
+																   int decision,
+																   BitSet alts,
+																   int startIndex,
+																   int stopIndex,
+																   int startRuleIndex)
+		throws RecognitionException
+	{
+		List<ParserRuleContext> trees = new ArrayList<ParserRuleContext>();
+		// Create a new parser interpreter to parse the ambiguous subphrase
+		ParserInterpreter parser = deriveTempParserInterpreter(g, originalParser, tokens);
+
+		// get ambig trees
+		int alt = alts.nextSetBit(0);
+		while (alt >= 0) {
+			// re-parse entire input for all ambiguous alternatives
+			// (don't have to do first as it's been parsed, but do again for simplicity
+			//  using this temp parser.)
+			parser.reset();
+			parser.addDecisionOverride(decision, startIndex, alt);
+			ParserRuleContext t = parser.parse(startRuleIndex);
+			GrammarInterpreterRuleContext ambigSubTree =
+				(GrammarInterpreterRuleContext) Trees.getRootOfSubtreeEnclosingRegion(t, startIndex, stopIndex);
+			// Use higher of overridden decision tree or tree enclosing all tokens
+			if ( Trees.isAncestorOf(parser.getOverrideDecisionRoot(), ambigSubTree) ) {
+				ambigSubTree = (GrammarInterpreterRuleContext)parser.getOverrideDecisionRoot();
+			}
+			trees.add(ambigSubTree);
+			alt = alts.nextSetBit(alt + 1);
+		}
+
+		return trees;
+	}
+
+
+	/** Return a list of parse trees, one for each alternative in a decision
+	 *  given the same input.
+	 *
+	 *  Very similar to {@link #getAllPossibleParseTrees} except
+	 *  that it re-parses the input for every alternative in a decision,
+	 *  not just the ambiguous ones (there is no alts parameter here).
+	 *  This method also tries to reduce the size of the parse trees
+	 *  by stripping away children of the tree that are completely out of range
+	 *  of startIndex..stopIndex. Also, because errors are expected, we
+	 *  use a specialized error handler that more or less bails out
+	 *  but that also consumes the first erroneous token at least. This
+	 *  ensures that an error node will be in the parse tree for display.
+	 *
+	 *  NOTES:
+    // we must parse the entire input now with decision overrides
+	// we cannot parse a subset because it could be that a decision
+	// above our decision of interest needs to read way past
+	// lookaheadInfo.stopIndex. It seems like there is no escaping
+	// the use of a full and complete token stream if we are
+	// resetting to token index 0 and re-parsing from the start symbol.
+	// It's not easy to restart parsing somewhere in the middle like a
+	// continuation because our call stack does not match the
+	// tree stack because of left recursive rule rewriting. grrrr!
+	 *
+	 * @since 4.5.1
+	 */
+	public static List<ParserRuleContext> getLookaheadParseTrees(Grammar g,
+																 ParserInterpreter originalParser,
+																 TokenStream tokens,
+																 int startRuleIndex,
+																 int decision,
+																 int startIndex,
+																 int stopIndex)
+	{
+		List<ParserRuleContext> trees = new ArrayList<ParserRuleContext>();
+		// Create a new parser interpreter to parse the ambiguous subphrase
+		ParserInterpreter parser = deriveTempParserInterpreter(g, originalParser, tokens);
+		BailButConsumeErrorStrategy errorHandler = new BailButConsumeErrorStrategy();
+		parser.setErrorHandler(errorHandler);
+
+		DecisionState decisionState = originalParser.getATN().decisionToState.get(decision);
+
+		for (int alt=1; alt<=decisionState.getTransitions().length; alt++) {
+			// re-parse entire input for all ambiguous alternatives
+			// (don't have to do first as it's been parsed, but do again for simplicity
+			//  using this temp parser.)
+			parser.reset();
+			parser.addDecisionOverride(decision, startIndex, alt);
+			ParserRuleContext tt = parser.parse(startRuleIndex);
+			int stopTreeAt = stopIndex;
+			if ( errorHandler.firstErrorTokenIndex>=0 ) {
+				stopTreeAt = errorHandler.firstErrorTokenIndex; // cut off rest at first error
+			}
+			ParserRuleContext subtree =
+				Trees.getRootOfSubtreeEnclosingRegion(tt,
+													  startIndex,
+													  stopTreeAt);
+			// Use higher of overridden decision tree or tree enclosing all tokens
+			if ( Trees.isAncestorOf(parser.getOverrideDecisionRoot(), subtree) ) {
+				subtree = parser.getOverrideDecisionRoot();
+			}
+			Trees.stripChildrenOutOfRange(subtree, parser.getOverrideDecisionRoot(), startIndex, stopTreeAt);
+			trees.add(subtree);
+		}
+
+		return trees;
+	}
+
+	/** Derive a new parser from an old one that has knowledge of the grammar.
+	 *  The Grammar object is used to correctly compute outer alternative
+	 *  numbers for parse tree nodes. A parser of the same type is created
+	 *  for subclasses of {@link ParserInterpreter}.
+	 */
+	public static ParserInterpreter deriveTempParserInterpreter(Grammar g, Parser originalParser, TokenStream tokens) {
+		ParserInterpreter parser;
+		if (originalParser instanceof ParserInterpreter) {
+			Class<? extends ParserInterpreter> c = originalParser.getClass().asSubclass(ParserInterpreter.class);
+			try {
+				Constructor<? extends ParserInterpreter> ctor = c.getConstructor(Grammar.class, ATN.class, TokenStream.class);
+				parser = ctor.newInstance(g, originalParser.getATN(), originalParser.getTokenStream());
+			}
+			catch (Exception e) {
+				throw new IllegalArgumentException("can't create parser to match incoming "+originalParser.getClass().getSimpleName(), e);
+			}
+		}
+		else { // must've been a generated parser
+			char[] serializedAtn = ATNSerializer.getSerializedAsChars(originalParser.getATN());
+			ATN deserialized = new ATNDeserializer().deserialize(serializedAtn);
+			parser = new ParserInterpreter(originalParser.getGrammarFileName(),
+										   originalParser.getVocabulary(),
+										   Arrays.asList(originalParser.getRuleNames()),
+										   deserialized,
+										   tokens);
+		}
+
+		parser.setInputStream(tokens);
+
+		// Make sure that we don't get any error messages from using this temporary parser
+		parser.setErrorHandler(new BailErrorStrategy());
+		parser.removeErrorListeners();
+		parser.removeParseListeners();
+		parser.getInterpreter().setPredictionMode(PredictionMode.LL_EXACT_AMBIG_DETECTION);
+		return parser;
+	}
+
+	/** We want to stop and track the first error but we cannot bail out like
+	 *  {@link BailErrorStrategy} as consume() constructs trees. We make sure
+	 *  to create an error node during recovery with this strategy. We
+	 *  consume() 1 token during the "bail out of rule" mechanism in recover()
+	 *  and let it fall out of the rule to finish constructing trees. For
+	 *  recovery in line, we throw InputMismatchException to engage recover().
+	 */
+	public static class BailButConsumeErrorStrategy extends DefaultErrorStrategy {
+		public int firstErrorTokenIndex = -1;
+		@Override
+		public void recover(Parser recognizer, RecognitionException e) {
+			int errIndex = recognizer.getInputStream().index();
+			if ( firstErrorTokenIndex == -1 ) {
+				firstErrorTokenIndex = errIndex; // latch
+			}
+//			System.err.println("recover: error at " + errIndex);
+			TokenStream input = recognizer.getInputStream();
+			if ( input.index()<input.size()-1 ) { // don't consume() eof
+				recognizer.consume(); // just kill this bad token and let it continue.
+			}
+		}
+
+		@Override
+		public Token recoverInline(Parser recognizer) throws RecognitionException {
+			int errIndex = recognizer.getInputStream().index();
+			if ( firstErrorTokenIndex == -1 ) {
+				firstErrorTokenIndex = errIndex; // latch
+			}
+//			System.err.println("recoverInline: error at " + errIndex);
+			InputMismatchException e = new InputMismatchException(recognizer);
+//			TokenStream input = recognizer.getInputStream(); // seek EOF
+//			input.seek(input.size() - 1);
+			throw e;
+		}
+
+		@Override
+		public void sync(Parser recognizer) { } // don't consume anything; let it fail later
+	}
+}
diff --git a/tool/src/org/antlr/v4/tool/GrammarSemanticsMessage.java b/tool/src/org/antlr/v4/tool/GrammarSemanticsMessage.java
index 9f1475a96..72e750122 100644
--- a/tool/src/org/antlr/v4/tool/GrammarSemanticsMessage.java
+++ b/tool/src/org/antlr/v4/tool/GrammarSemanticsMessage.java
@@ -33,40 +33,17 @@ package org.antlr.v4.tool;
 import org.antlr.runtime.Token;
 
 /** A problem with the symbols and/or meaning of a grammar such as rule
- *  redefinition.
+ *  redefinition. Any msg where we can point to a location in the grammar.
  */
 public class GrammarSemanticsMessage extends ANTLRMessage {
-	public Grammar g;
-	/** Most of the time, we'll have a token such as an undefined rule ref
-     *  and so this will be set.
-     */
-    public Token offendingToken;
-
-	/*
-    public GrammarSemanticsMessage(ErrorType etype,
-                                   Grammar g,
-                                   Token offendingToken,
-                                   Object... args)
-    {
-        super(etype,args);
-        this.g = g;
-        if ( g!=null ) fileName = g.fileName;
-        this.offendingToken = offendingToken;
-        if ( offendingToken!=null ) {
-            line = offendingToken.getLine();
-            charPosition = offendingToken.getCharPositionInLine();
-        }
-    }
-*/
     public GrammarSemanticsMessage(ErrorType etype,
                                    String fileName,
                                    Token offendingToken,
                                    Object... args)
     {
-        super(etype,args);
+        super(etype,offendingToken,args);
         this.fileName = fileName;
-        this.offendingToken = offendingToken;
-        if ( offendingToken!=null ) {
+		if ( offendingToken!=null ) {
             line = offendingToken.getLine();
             charPosition = offendingToken.getCharPositionInLine();
         }
diff --git a/tool/src/org/antlr/v4/tool/GrammarSyntaxMessage.java b/tool/src/org/antlr/v4/tool/GrammarSyntaxMessage.java
index 8c4767c29..4648a84d1 100644
--- a/tool/src/org/antlr/v4/tool/GrammarSyntaxMessage.java
+++ b/tool/src/org/antlr/v4/tool/GrammarSyntaxMessage.java
@@ -37,17 +37,13 @@ import org.antlr.runtime.Token;
  *  "The '{' came as a complete surprise to me at this point in your program"
  */
 public class GrammarSyntaxMessage extends ANTLRMessage {
-	public Grammar g;
-	/** Most of the time, we'll have a token and so this will be set. */
-	public Token offendingToken;
-
 	public GrammarSyntaxMessage(ErrorType etype,
 								String fileName,
 								Token offendingToken,
 								RecognitionException antlrException,
 								Object... args)
 	{
-		super(etype, antlrException, args);
+		super(etype, antlrException, offendingToken, args);
 		this.fileName = fileName;
 		this.offendingToken = offendingToken;
 		if ( offendingToken!=null ) {
diff --git a/tool/src/org/antlr/v4/tool/GrammarTransformPipeline.java b/tool/src/org/antlr/v4/tool/GrammarTransformPipeline.java
index 52d69b2b9..9668838f0 100644
--- a/tool/src/org/antlr/v4/tool/GrammarTransformPipeline.java
+++ b/tool/src/org/antlr/v4/tool/GrammarTransformPipeline.java
@@ -31,14 +31,17 @@
 package org.antlr.v4.tool;
 
 import org.antlr.runtime.CommonToken;
+import org.antlr.runtime.tree.CommonTree;
 import org.antlr.runtime.tree.CommonTreeNodeStream;
 import org.antlr.runtime.tree.Tree;
 import org.antlr.runtime.tree.TreeVisitor;
 import org.antlr.runtime.tree.TreeVisitorAction;
 import org.antlr.v4.Tool;
+import org.antlr.v4.analysis.LeftRecursiveRuleTransformer;
 import org.antlr.v4.parse.ANTLRParser;
 import org.antlr.v4.parse.BlockSetTransformer;
 import org.antlr.v4.parse.GrammarASTAdaptor;
+import org.antlr.v4.parse.GrammarToken;
 import org.antlr.v4.runtime.misc.DoubleKeyMap;
 import org.antlr.v4.runtime.misc.Pair;
 import org.antlr.v4.tool.ast.AltAST;
@@ -53,6 +56,7 @@ import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 
 /** Handle left-recursion and block-set transforms */
@@ -126,14 +130,47 @@ public class GrammarTransformPipeline {
 		});
 	}
 
+	public static void augmentTokensWithOriginalPosition(final Grammar g, GrammarAST tree) {
+		if ( tree==null ) return;
+
+		List<GrammarAST> optionsSubTrees = tree.getNodesWithType(ANTLRParser.ELEMENT_OPTIONS);
+		for (int i = 0; i < optionsSubTrees.size(); i++) {
+			GrammarAST t = optionsSubTrees.get(i);
+			CommonTree elWithOpt = t.parent;
+			if ( elWithOpt instanceof GrammarASTWithOptions ) {
+				Map<String, GrammarAST> options = ((GrammarASTWithOptions) elWithOpt).getOptions();
+				if ( options.containsKey(LeftRecursiveRuleTransformer.TOKENINDEX_OPTION_NAME) ) {
+					GrammarToken newTok = new GrammarToken(g, elWithOpt.getToken());
+					newTok.originalTokenIndex = Integer.valueOf(options.get(LeftRecursiveRuleTransformer.TOKENINDEX_OPTION_NAME).getText());
+					elWithOpt.token = newTok;
+
+					GrammarAST originalNode = g.ast.getNodeWithTokenIndex(newTok.getTokenIndex());
+					if (originalNode != null) {
+						// update the AST node start/stop index to match the values
+						// of the corresponding node in the original parse tree.
+						elWithOpt.setTokenStartIndex(originalNode.getTokenStartIndex());
+						elWithOpt.setTokenStopIndex(originalNode.getTokenStopIndex());
+					}
+					else {
+						// the original AST node could not be located by index;
+						// make sure to assign valid values for the start/stop
+						// index so toTokenString will not throw exceptions.
+						elWithOpt.setTokenStartIndex(newTok.getTokenIndex());
+						elWithOpt.setTokenStopIndex(newTok.getTokenIndex());
+					}
+				}
+			}
+		}
+	}
+
 	/** Merge all the rules, token definitions, and named actions from
 		imported grammars into the root grammar tree.  Perform:
 
-	 	(tokens { X (= Y 'y')) + (tokens { Z )	->	(tokens { X (= Y 'y') Z)
+	 	(tokens { X (= Y 'y')) + (tokens { Z )	-&gt;	(tokens { X (= Y 'y') Z)
 
-	 	(@ members {foo}) + (@ members {bar})	->	(@ members {foobar})
+	 	(@ members {foo}) + (@ members {bar})	-&gt;	(@ members {foobar})
 
-	 	(RULES (RULE x y)) + (RULES (RULE z))	->	(RULES (RULE x y z))
+	 	(RULES (RULE x y)) + (RULES (RULE z))	-&gt;	(RULES (RULE x y z))
 
 	 	Rules in root prevent same rule from being appended to RULES node.
 
@@ -155,16 +192,9 @@ public class GrammarTransformPipeline {
 		// Compute list of rules in root grammar and ensure we have a RULES node
 		GrammarAST RULES = (GrammarAST)root.getFirstChildWithType(ANTLRParser.RULES);
 		Set<String> rootRuleNames = new HashSet<String>();
-		if ( RULES==null ) { // no rules in root, make RULES node, hook in
-			RULES = (GrammarAST)adaptor.create(ANTLRParser.RULES, "RULES");
-			RULES.g = rootGrammar;
-			root.addChild(RULES);
-		}
-		else {
-			// make list of rules we have in root grammar
-			List<GrammarAST> rootRules = RULES.getNodesWithType(ANTLRParser.RULE);
-			for (GrammarAST r : rootRules) rootRuleNames.add(r.getChild(0).getText());
-		}
+		// make list of rules we have in root grammar
+		List<GrammarAST> rootRules = RULES.getNodesWithType(ANTLRParser.RULE);
+		for (GrammarAST r : rootRules) rootRuleNames.add(r.getChild(0).getText());
 
 		for (Grammar imp : imports) {
 			// COPY TOKENS
@@ -252,8 +282,28 @@ public class GrammarTransformPipeline {
 
 			GrammarAST optionsRoot = (GrammarAST)imp.ast.getFirstChildWithType(ANTLRParser.OPTIONS);
 			if ( optionsRoot!=null ) {
-				rootGrammar.tool.errMgr.grammarError(ErrorType.OPTIONS_IN_DELEGATE,
-									optionsRoot.g.fileName, optionsRoot.token, imp.name);
+				// suppress the warning if the options match the options specified
+				// in the root grammar
+				// https://github.com/antlr/antlr4/issues/707
+
+				boolean hasNewOption = false;
+				for (Map.Entry<String, GrammarAST> option : imp.ast.getOptions().entrySet()) {
+					String importOption = imp.ast.getOptionString(option.getKey());
+					if (importOption == null) {
+						continue;
+					}
+
+					String rootOption = rootGrammar.ast.getOptionString(option.getKey());
+					if (!importOption.equals(rootOption)) {
+						hasNewOption = true;
+						break;
+					}
+				}
+
+				if (hasNewOption) {
+					rootGrammar.tool.errMgr.grammarError(ErrorType.OPTIONS_IN_DELEGATE,
+										optionsRoot.g.fileName, optionsRoot.token, imp.name);
+				}
 			}
 		}
 		rootGrammar.tool.log("grammar", "Grammar: "+rootGrammar.ast.toStringTree());
@@ -272,7 +322,7 @@ public class GrammarTransformPipeline {
 	 *  We'll have this Grammar share token symbols later; don't generate
 	 *  tokenVocab or tokens{} section.  Copy over named actions.
 	 *
-	 *  Side-effects: it removes children from GRAMMAR & RULES nodes
+	 *  Side-effects: it removes children from GRAMMAR &amp; RULES nodes
 	 *                in combined AST.  Anything cut out is dup'd before
 	 *                adding to lexer to avoid "who's ur daddy" issues
 	 */
@@ -302,7 +352,9 @@ public class GrammarTransformPipeline {
 				if ( Grammar.lexerOptions.contains(optionName) &&
 					 !Grammar.doNotCopyOptionsToLexer.contains(optionName) )
 				{
-					lexerOptionsRoot.addChild((Tree)adaptor.dupTree(o));
+					GrammarAST optionTree = (GrammarAST)adaptor.dupTree(o);
+					lexerOptionsRoot.addChild(optionTree);
+					lexerAST.setOption(optionName, (GrammarAST)optionTree.getChild(1));
 				}
 			}
 		}
@@ -359,6 +411,7 @@ public class GrammarTransformPipeline {
 		// add strings from combined grammar (and imported grammars) into lexer
 		// put them first as they are keywords; must resolve ambigs to these rules
 //		tool.log("grammar", "strings from parser: "+stringLiterals);
+		int insertIndex = 0;
 		nextLit:
 		for (String lit : stringLiterals) {
 			// if lexer already has a rule for literal, continue
@@ -380,9 +433,12 @@ public class GrammarTransformPipeline {
 			CommonToken idToken = new CommonToken(ANTLRParser.TOKEN_REF, rname);
 			litRule.addChild(new TerminalAST(idToken));
 			litRule.addChild(blk);
-			lexerRulesRoot.insertChild(0, litRule);        // add first
+			lexerRulesRoot.insertChild(insertIndex, litRule);
 //			lexerRulesRoot.getChildren().add(0, litRule);
 			lexerRulesRoot.freshenParentAndChildIndexes(); // reset indexes and set litRule parent
+
+			// next literal will be added after the one just added
+			insertIndex++;
 		}
 
 		// TODO: take out after stable if slow
diff --git a/tool/src/org/antlr/v4/tool/LeftRecursionCyclesMessage.java b/tool/src/org/antlr/v4/tool/LeftRecursionCyclesMessage.java
index c04d6e515..3e0740b2a 100644
--- a/tool/src/org/antlr/v4/tool/LeftRecursionCyclesMessage.java
+++ b/tool/src/org/antlr/v4/tool/LeftRecursionCyclesMessage.java
@@ -30,14 +30,32 @@
 
 package org.antlr.v4.tool;
 
+import org.antlr.runtime.Token;
+
 import java.util.Collection;
 
 public class LeftRecursionCyclesMessage extends ANTLRMessage {
-	public Collection<? extends Collection<Rule>> cycles;
-
 	public LeftRecursionCyclesMessage(String fileName, Collection<? extends Collection<Rule>> cycles) {
-		super(ErrorType.LEFT_RECURSION_CYCLES, cycles);
-		this.cycles = cycles;
+		super(ErrorType.LEFT_RECURSION_CYCLES, getStartTokenOfFirstRule(cycles), cycles);
 		this.fileName = fileName;
 	}
+
+	protected static Token getStartTokenOfFirstRule(Collection<? extends Collection<Rule>> cycles) {
+	    if (cycles == null) {
+	        return null;
+	    }
+
+	    for (Collection<Rule> collection : cycles) {
+	        if (collection == null) {
+	            return null;
+	        }
+
+	        for (Rule rule : collection) {
+	            if (rule.ast != null) {
+	                return rule.ast.getToken();
+	            }
+	        }
+	    }
+		return null;
+	}
 }
diff --git a/tool/src/org/antlr/v4/tool/LeftRecursiveRule.java b/tool/src/org/antlr/v4/tool/LeftRecursiveRule.java
index ea79734cb..ad06e343d 100644
--- a/tool/src/org/antlr/v4/tool/LeftRecursiveRule.java
+++ b/tool/src/org/antlr/v4/tool/LeftRecursiveRule.java
@@ -33,17 +33,19 @@ package org.antlr.v4.tool;
 import org.antlr.v4.analysis.LeftRecursiveRuleAltInfo;
 import org.antlr.v4.misc.OrderedHashMap;
 import org.antlr.v4.runtime.misc.Pair;
-import org.antlr.v4.runtime.misc.Triple;
 import org.antlr.v4.tool.ast.AltAST;
 import org.antlr.v4.tool.ast.GrammarAST;
 import org.antlr.v4.tool.ast.RuleAST;
 
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
 public class LeftRecursiveRule extends Rule {
 	public List<LeftRecursiveRuleAltInfo> recPrimaryAlts;
 	public OrderedHashMap<Integer, LeftRecursiveRuleAltInfo> recOpAlts;
+	public RuleAST originalAST;
 
 	/** Did we delete any labels on direct left-recur refs? Points at ID of ^(= ID el) */
 	public List<Pair<GrammarAST,String>> leftRecursiveRuleRefLabels =
@@ -51,6 +53,7 @@ public class LeftRecursiveRule extends Rule {
 
 	public LeftRecursiveRule(Grammar g, String name, RuleAST ast) {
 		super(g, name, ast, 1);
+		originalAST = ast;
 		alt = new Alternative[numberOfAlts+1]; // always just one
 		for (int i=1; i<=numberOfAlts; i++) alt[i] = new Alternative(this, i);
 	}
@@ -68,6 +71,10 @@ public class LeftRecursiveRule extends Rule {
 		return n;
 	}
 
+	public RuleAST getOriginalAST() {
+		return originalAST;
+	}
+
 	@Override
 	public List<AltAST> getUnlabeledAltASTs() {
 		List<AltAST> alts = new ArrayList<AltAST>();
@@ -82,18 +89,69 @@ public class LeftRecursiveRule extends Rule {
 		return alts;
 	}
 
-	/** Get -> labels from those alts we deleted for left-recursive rules. */
+	/** Return an array that maps predicted alt from primary decision
+	 *  to original alt of rule. For following rule, return [0, 2, 4]
+	 *
+		e : e '*' e
+		  | INT
+		  | e '+' e
+		  | ID
+		  ;
+
+	 *  That maps predicted alt 1 to original alt 2 and predicted 2 to alt 4.
+	 *
+	 *  @since 4.5.1
+	 */
+	public int[] getPrimaryAlts() {
+		if ( recPrimaryAlts.size()==0 ) return null;
+		int[] alts = new int[recPrimaryAlts.size()+1];
+		for (int i = 0; i < recPrimaryAlts.size(); i++) { // recPrimaryAlts is a List not Map like recOpAlts
+			LeftRecursiveRuleAltInfo altInfo = recPrimaryAlts.get(i);
+			alts[i+1] = altInfo.altNum;
+		}
+		return alts;
+	}
+
+	/** Return an array that maps predicted alt from recursive op decision
+	 *  to original alt of rule. For following rule, return [0, 1, 3]
+	 *
+		e : e '*' e
+		  | INT
+		  | e '+' e
+		  | ID
+		  ;
+
+	 *  That maps predicted alt 1 to original alt 1 and predicted 2 to alt 3.
+	 *
+	 *  @since 4.5.1
+	 */
+	public int[] getRecursiveOpAlts() {
+		if ( recOpAlts.size()==0 ) return null;
+		int[] alts = new int[recOpAlts.size()+1];
+		int alt = 1;
+		for (LeftRecursiveRuleAltInfo altInfo : recOpAlts.values()) {
+			alts[alt] = altInfo.altNum;
+			alt++; // recOpAlts has alts possibly with gaps
+		}
+		return alts;
+	}
+
+	/** Get -&gt; labels from those alts we deleted for left-recursive rules. */
 	@Override
-	public List<Triple<Integer,AltAST,String>> getAltLabels() {
-		List<Triple<Integer,AltAST,String>> labels = new ArrayList<Triple<Integer,AltAST,String>>();
-		List<Triple<Integer,AltAST,String>> normalAltLabels = super.getAltLabels();
-		if ( normalAltLabels!=null ) labels.addAll(normalAltLabels);
+	public Map<String, List<Pair<Integer, AltAST>>> getAltLabels() {
+		Map<String, List<Pair<Integer, AltAST>>> labels = new HashMap<String, List<Pair<Integer, AltAST>>>();
+		Map<String, List<Pair<Integer, AltAST>>> normalAltLabels = super.getAltLabels();
+		if ( normalAltLabels!=null ) labels.putAll(normalAltLabels);
 		if ( recPrimaryAlts!=null ) {
 			for (LeftRecursiveRuleAltInfo altInfo : recPrimaryAlts) {
 				if (altInfo.altLabel != null) {
-					labels.add(new Triple<Integer, AltAST, String>(altInfo.altNum,
-																   altInfo.originalAltAST,
-																   altInfo.altLabel));
+					List<Pair<Integer, AltAST>> pairs = labels.get(altInfo.altLabel);
+					if (pairs == null) {
+						pairs = new ArrayList<Pair<Integer, AltAST>>();
+						labels.put(altInfo.altLabel, pairs);
+					}
+
+					pairs.add(new Pair<Integer, AltAST>(altInfo.altNum, altInfo.originalAltAST));
 				}
 			}
 		}
@@ -101,9 +159,13 @@ public class LeftRecursiveRule extends Rule {
 			for (int i = 0; i < recOpAlts.size(); i++) {
 				LeftRecursiveRuleAltInfo altInfo = recOpAlts.getElement(i);
 				if ( altInfo.altLabel!=null ) {
-					labels.add(new Triple<Integer,AltAST,String>(altInfo.altNum,
-																 altInfo.originalAltAST,
-																 altInfo.altLabel));
+					List<Pair<Integer, AltAST>> pairs = labels.get(altInfo.altLabel);
+					if (pairs == null) {
+						pairs = new ArrayList<Pair<Integer, AltAST>>();
+						labels.put(altInfo.altLabel, pairs);
+					}
+
+					pairs.add(new Pair<Integer, AltAST>(altInfo.altNum, altInfo.originalAltAST));
 				}
 			}
 		}
diff --git a/tool/src/org/antlr/v4/tool/LexerGrammar.java b/tool/src/org/antlr/v4/tool/LexerGrammar.java
index 4eeceeb2a..5b92a80a6 100644
--- a/tool/src/org/antlr/v4/tool/LexerGrammar.java
+++ b/tool/src/org/antlr/v4/tool/LexerGrammar.java
@@ -62,9 +62,24 @@ public class LexerGrammar extends Grammar {
 	}
 
 	@Override
-	public void defineRule(Rule r) {
-		super.defineRule(r);
+	public boolean defineRule(Rule r) {
+		if (!super.defineRule(r)) {
+			return false;
+		}
+
 		if ( modes==null ) modes = new MultiMap<String, Rule>();
 		modes.map(r.mode, r);
+		return true;
+	}
+
+	@Override
+	public boolean undefineRule(Rule r) {
+		if (!super.undefineRule(r)) {
+			return false;
+		}
+
+		boolean removed = modes.get(r.mode).remove(r);
+		assert removed;
+		return true;
 	}
 }
diff --git a/tool/src/org/antlr/v4/tool/Rule.java b/tool/src/org/antlr/v4/tool/Rule.java
index 69b0ced45..38f5c8849 100644
--- a/tool/src/org/antlr/v4/tool/Rule.java
+++ b/tool/src/org/antlr/v4/tool/Rule.java
@@ -30,7 +30,7 @@
 
 package org.antlr.v4.tool;
 
-import org.antlr.v4.runtime.misc.Triple;
+import org.antlr.v4.runtime.misc.Pair;
 import org.antlr.v4.tool.ast.ActionAST;
 import org.antlr.v4.tool.ast.AltAST;
 import org.antlr.v4.tool.ast.GrammarAST;
@@ -41,6 +41,7 @@ import org.stringtemplate.v4.misc.MultiMap;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -54,6 +55,7 @@ public class Rule implements AttributeResolver {
 	public static final AttributeDict predefinedRulePropertiesDict =
 		new AttributeDict(AttributeDict.DictType.PREDEFINED_RULE);
 	static {
+		predefinedRulePropertiesDict.add(new Attribute("parser"));
 		predefinedRulePropertiesDict.add(new Attribute("text"));
 		predefinedRulePropertiesDict.add(new Attribute("start"));
 		predefinedRulePropertiesDict.add(new Attribute("stop"));
@@ -205,13 +207,24 @@ public class Rule implements AttributeResolver {
 		return numberOfAlts;
 	}
 
-	/** Get -> labels. */
-	public List<Triple<Integer,AltAST,String>> getAltLabels() {
-		List<Triple<Integer,AltAST,String>> labels = new ArrayList<Triple<Integer,AltAST,String>>();
+	/**
+	 * Get {@code #} labels. The keys of the map are the labels applied to outer
+	 * alternatives of a lexer rule, and the values are collections of pairs
+	 * (alternative number and {@link AltAST}) identifying the alternatives with
+	 * this label. Unlabeled alternatives are not included in the result.
+	 */
+	public Map<String, List<Pair<Integer, AltAST>>> getAltLabels() {
+		Map<String, List<Pair<Integer, AltAST>>> labels = new LinkedHashMap<String, List<Pair<Integer, AltAST>>>();
 		for (int i=1; i<=numberOfAlts; i++) {
 			GrammarAST altLabel = alt[i].ast.altLabel;
 			if ( altLabel!=null ) {
-				labels.add(new Triple<Integer,AltAST,String>(i,alt[i].ast,altLabel.getText()));
+				List<Pair<Integer, AltAST>> list = labels.get(altLabel.getText());
+				if (list == null) {
+					list = new ArrayList<Pair<Integer, AltAST>>();
+					labels.put(altLabel.getText(), list);
+				}
+
+				list.add(new Pair<Integer, AltAST>(i, alt[i].ast));
 			}
 		}
 		if ( labels.isEmpty() ) return null;
@@ -248,9 +261,6 @@ public class Rule implements AttributeResolver {
 	/** $x.y	Attribute: x is surrounding rule, label ref (in any alts) */
 	@Override
 	public Attribute resolveToAttribute(String x, String y, ActionAST node) {
-		if ( this.name.equals(x) ) { // x is this rule?
-			return resolveToAttribute(y, node);
-		}
 		LabelElementPair anyLabelDef = getAnyLabelDef(x);
 		if ( anyLabelDef!=null ) {
 			if ( anyLabelDef.type==LabelType.RULE_LABEL ) {
@@ -295,7 +305,6 @@ public class Rule implements AttributeResolver {
 	@Override
 	public boolean resolvesToAttributeDict(String x, ActionAST node) {
 		if ( resolvesToToken(x, node) ) return true;
-		if ( x.equals(name) ) return true; // $r for action in rule r, $r is a dict
 		return false;
 	}
 
diff --git a/tool/src/org/antlr/v4/tool/ToolMessage.java b/tool/src/org/antlr/v4/tool/ToolMessage.java
index 3283d4bde..422eda232 100644
--- a/tool/src/org/antlr/v4/tool/ToolMessage.java
+++ b/tool/src/org/antlr/v4/tool/ToolMessage.java
@@ -30,6 +30,8 @@
 
 package org.antlr.v4.tool;
 
+import org.antlr.runtime.Token;
+
 /** A generic message from the tool such as "file not found" type errors; there
  *  is no reason to create a special object for each error unlike the grammar
  *  errors, which may be rather complex.
@@ -43,9 +45,9 @@ public class ToolMessage extends ANTLRMessage {
 		super(errorType);
 	}
     public ToolMessage(ErrorType errorType, Object... args) {
-        super(errorType, null, args);
+        super(errorType, null, Token.INVALID_TOKEN, args);
     }
     public ToolMessage(ErrorType errorType, Throwable e, Object... args) {
-        super(errorType, e, args);
+        super(errorType, e, Token.INVALID_TOKEN, args);
     }
 }
diff --git a/tool/src/org/antlr/v4/tool/ast/AltAST.java b/tool/src/org/antlr/v4/tool/ast/AltAST.java
index 2c6008fc6..77e2106c7 100644
--- a/tool/src/org/antlr/v4/tool/ast/AltAST.java
+++ b/tool/src/org/antlr/v4/tool/ast/AltAST.java
@@ -41,7 +41,7 @@ public class AltAST extends GrammarASTWithOptions {
 	/** If we transformed this alt from a left-recursive one, need info on it */
 	public LeftRecursiveRuleAltInfo leftRecursiveAltInfo;
 
-	/** If someone specified an outermost alternative label with -> foo.
+	/** If someone specified an outermost alternative label with #foo.
 	 *  Token type will be ID.
 	 */
 	public GrammarAST altLabel;
diff --git a/tool/src/org/antlr/v4/tool/ast/GrammarAST.java b/tool/src/org/antlr/v4/tool/ast/GrammarAST.java
index 0dc75db48..a794b8861 100644
--- a/tool/src/org/antlr/v4/tool/ast/GrammarAST.java
+++ b/tool/src/org/antlr/v4/tool/ast/GrammarAST.java
@@ -67,18 +67,13 @@ public class GrammarAST extends CommonTree {
 	}
     public GrammarAST(int type) { super(new CommonToken(type, ANTLRParser.tokenNames[type])); }
     public GrammarAST(int type, Token t) {
-		this(new CommonToken(type, t.getText()));
-		token.setInputStream(t.getInputStream());
-		token.setLine(t.getLine());
-		token.setCharPositionInLine(t.getCharPositionInLine());
-		token.setTokenIndex(t.getTokenIndex());
+		this(new CommonToken(t));
+		token.setType(type);
 	}
     public GrammarAST(int type, Token t, String text) {
-		this(new CommonToken(type, text));
-		token.setInputStream(t.getInputStream());
-		token.setLine(t.getLine());
-		token.setCharPositionInLine(t.getCharPositionInLine());
-		token.setTokenIndex(t.getTokenIndex());
+		this(new CommonToken(t));
+		token.setType(type);
+		token.setText(text);
     }
 
 	public GrammarAST[] getChildrenAsArray() {
@@ -107,7 +102,7 @@ public class GrammarAST extends CommonTree {
 		GrammarAST t;
 		while ( !work.isEmpty() ) {
 			t = work.remove(0);
-			if ( types.contains(t.getType()) ) nodes.add(t);
+			if ( types==null || types.contains(t.getType()) ) nodes.add(t);
 			if ( t.children!=null ) {
 				work.addAll(Arrays.asList(t.getChildrenAsArray()));
 			}
@@ -130,6 +125,21 @@ public class GrammarAST extends CommonTree {
 		}
 	}
 
+	public GrammarAST getNodeWithTokenIndex(int index) {
+		if ( this.getToken()!=null && this.getToken().getTokenIndex()==index ) {
+			return this;
+		}
+		// walk all children of root.
+		for (int i= 0; i < getChildCount(); i++) {
+			GrammarAST child = (GrammarAST)getChild(i);
+			GrammarAST result = child.getNodeWithTokenIndex(index);
+			if ( result!=null ) {
+				return result;
+			}
+		}
+		return null;
+	}
+
 	public AltAST getOutermostAltNode() {
 		if ( this instanceof AltAST && parent.parent instanceof RuleAST ) {
 			return (AltAST)this;
diff --git a/tool/src/org/antlr/v4/tool/ast/GrammarASTWithOptions.java b/tool/src/org/antlr/v4/tool/ast/GrammarASTWithOptions.java
index 7f86f5539..b492c93cc 100644
--- a/tool/src/org/antlr/v4/tool/ast/GrammarASTWithOptions.java
+++ b/tool/src/org/antlr/v4/tool/ast/GrammarASTWithOptions.java
@@ -32,7 +32,6 @@ package org.antlr.v4.tool.ast;
 
 import org.antlr.runtime.Token;
 import org.antlr.v4.misc.CharSupport;
-import org.antlr.v4.runtime.misc.NotNull;
 
 import java.util.Collections;
 import java.util.HashMap;
@@ -86,7 +85,7 @@ public abstract class GrammarASTWithOptions extends GrammarAST {
 	@Override
 	public abstract GrammarASTWithOptions dupNode();
 
-	@NotNull
+
 	public Map<String, GrammarAST> getOptions() {
 		if (options == null) {
 			return Collections.emptyMap();
diff --git a/tool/src/org/antlr/v4/tool/ast/GrammarRootAST.java b/tool/src/org/antlr/v4/tool/ast/GrammarRootAST.java
index 61bf5d287..bf4ef9607 100644
--- a/tool/src/org/antlr/v4/tool/ast/GrammarRootAST.java
+++ b/tool/src/org/antlr/v4/tool/ast/GrammarRootAST.java
@@ -33,7 +33,6 @@ package org.antlr.v4.tool.ast;
 import org.antlr.runtime.Token;
 import org.antlr.runtime.TokenStream;
 import org.antlr.runtime.tree.Tree;
-import org.antlr.v4.runtime.misc.NotNull;
 
 import java.util.HashMap;
 import java.util.Map;
@@ -47,7 +46,7 @@ public class GrammarRootAST extends GrammarASTWithOptions {
     public int grammarType; // LEXER, PARSER, GRAMMAR (combined)
 	public boolean hasErrors;
 	/** Track stream used to create this tree */
-	@NotNull
+
 	public final TokenStream tokenStream;
 	public Map<String, String> cmdLineOptions; // -DsuperClass=T on command line
 	public String fileName;
diff --git a/tool/test/org/antlr/v4/test/TestCompositeGrammars.java b/tool/test/org/antlr/v4/test/TestCompositeGrammars.java
deleted file mode 100644
index 803ce0d33..000000000
--- a/tool/test/org/antlr/v4/test/TestCompositeGrammars.java
+++ /dev/null
@@ -1,713 +0,0 @@
-/*
- * [The "BSD license"]
- *  Copyright (c) 2012 Terence Parr
- *  Copyright (c) 2012 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.
- */
-
-package org.antlr.v4.test;
-
-import org.antlr.v4.tool.ErrorType;
-import org.antlr.v4.tool.Grammar;
-import org.antlr.v4.tool.GrammarSemanticsMessage;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-public class TestCompositeGrammars extends BaseTest {
-	protected boolean debug = false;
-
-	@Test public void testDelegatorInvokesDelegateRule() throws Exception {
-		String slave =
-			"parser grammar S;\n" +
-			"a : B {System.out.println(\"S.a\");} ;\n";
-		mkdir(tmpdir);
-		writeFile(tmpdir, "S.g4", slave);
-		String master =
-			"grammar M;\n" +
-			"import S;\n" +
-			"s : a ;\n" +
-			"B : 'b' ;" + // defines B from inherited token space
-			"WS : (' '|'\\n') -> skip ;\n" ;
-		String found = execParser("M.g4", master, "MParser", "MLexer",
-								  "s", "b", debug);
-		assertEquals("S.a\n", found);
-	}
-
-	@Test public void testBringInLiteralsFromDelegate() throws Exception {
-		String slave =
-			"parser grammar S;\n" +
-			"a : '=' 'a' {System.out.println(\"S.a\");} ;\n";
-		mkdir(tmpdir);
-		writeFile(tmpdir, "S.g4", slave);
-		String master =
-			"grammar M;\n" +
-			"import S;\n" +
-			"s : a ;\n" +
-			"WS : (' '|'\\n') -> skip ;\n" ;
-		String found = execParser("M.g4", master, "MParser", "MLexer",
-								  "s", "=a", debug);
-		assertEquals("S.a\n", found);
-	}
-
-	@Test public void testDelegatorInvokesDelegateRuleWithArgs() throws Exception {
-		// must generate something like:
-		// public int a(int x) throws RecognitionException { return gS.a(x); }
-		// in M.
-		String slave =
-			"parser grammar S;\n" +
-			"a[int x] returns [int y] : B {System.out.print(\"S.a\"); $y=1000;} ;\n";
-		mkdir(tmpdir);
-		writeFile(tmpdir, "S.g4", slave);
-		String master =
-			"grammar M;\n" +
-			"import S;\n" +
-			"s : label=a[3] {System.out.println($label.y);} ;\n" +
-			"B : 'b' ;" + // defines B from inherited token space
-			"WS : (' '|'\\n') -> skip ;\n" ;
-		String found = execParser("M.g4", master, "MParser", "MLexer",
-								  "s", "b", debug);
-		assertEquals("S.a1000\n", found);
-	}
-
-	@Test public void testDelegatorInvokesDelegateRuleWithReturnStruct() throws Exception {
-		// must generate something like:
-		// public int a(int x) throws RecognitionException { return gS.a(x); }
-		// in M.
-		String slave =
-			"parser grammar S;\n" +
-			"a : B {System.out.print(\"S.a\");} ;\n";
-		mkdir(tmpdir);
-		writeFile(tmpdir, "S.g4", slave);
-		String master =
-			"grammar M;\n" +
-			"import S;\n" +
-			"s : a {System.out.println($a.text);} ;\n" +
-			"B : 'b' ;" + // defines B from inherited token space
-			"WS : (' '|'\\n') -> skip ;\n" ;
-		String found = execParser("M.g4", master, "MParser", "MLexer",
-								  "s", "b", debug);
-		assertEquals("S.ab\n", found);
-	}
-
-	@Test public void testDelegatorAccessesDelegateMembers() throws Exception {
-		String slave =
-			"parser grammar S;\n" +
-			"@members {\n" +
-			"  public void foo() {System.out.println(\"foo\");}\n" +
-			"}\n" +
-			"a : B ;\n";
-		mkdir(tmpdir);
-		writeFile(tmpdir, "S.g4", slave);
-		String master =
-			"grammar M;\n" +		// uses no rules from the import
-			"import S;\n" +
-			"s : 'b' {foo();} ;\n" + // gS is import pointer
-			"WS : (' '|'\\n') -> skip ;\n" ;
-		String found = execParser("M.g4", master, "MParser", "MLexer",
-								  "s", "b", debug);
-		assertEquals("foo\n", found);
-	}
-
-	@Test public void testDelegatorInvokesFirstVersionOfDelegateRule() throws Exception {
-		String slave =
-			"parser grammar S;\n" +
-			"a : b {System.out.println(\"S.a\");} ;\n" +
-			"b : B ;\n" ;
-		mkdir(tmpdir);
-		writeFile(tmpdir, "S.g4", slave);
-		String slave2 =
-			"parser grammar T;\n" +
-			"a : B {System.out.println(\"T.a\");} ;\n"; // hidden by S.a
-		writeFile(tmpdir, "T.g4", slave2);
-		String master =
-			"grammar M;\n" +
-			"import S,T;\n" +
-			"s : a ;\n" +
-			"B : 'b' ;\n" +
-			"WS : (' '|'\\n') -> skip ;\n" ;
-		String found = execParser("M.g4", master, "MParser", "MLexer",
-								  "s", "b", debug);
-		assertEquals("S.a\n", found);
-	}
-
-	@Test public void testDelegatesSeeSameTokenType() throws Exception {
-		String slave =
-			"parser grammar S;\n" + // A, B, C token type order
-			"tokens { A, B, C }\n" +
-			"x : A {System.out.println(\"S.x\");} ;\n";
-		mkdir(tmpdir);
-		writeFile(tmpdir, "S.g4", slave);
-		String slave2 =
-			"parser grammar T;\n" +
-			"tokens { C, B, A }\n" + // reverse order
-			"y : A {System.out.println(\"T.y\");} ;\n";
-		mkdir(tmpdir);
-		writeFile(tmpdir, "T.g4", slave2);
-		// The lexer will create rules to match letters a, b, c.
-		// The associated token types A, B, C must have the same value
-		// and all import'd parsers.  Since ANTLR regenerates all imports
-		// for use with the delegator M, it can generate the same token type
-		// mapping in each parser:
-		// public static final int C=6;
-		// public static final int EOF=-1;
-		// public static final int B=5;
-		// public static final int WS=7;
-		// public static final int A=4;
-
-		String master =
-			"grammar M;\n" +
-			"import S,T;\n" +
-			"s : x y ;\n" + // matches AA, which should be "aa"
-			"B : 'b' ;\n" + // another order: B, A, C
-			"A : 'a' ;\n" +
-			"C : 'c' ;\n" +
-			"WS : (' '|'\\n') -> skip ;\n" ;
-		String found = execParser("M.g4", master, "MParser", "MLexer",
-								  "s", "aa", debug);
-		assertEquals("S.x\n" +
-					 "T.y\n", found);
-	}
-
-	@Test public void testDelegatesSeeSameTokenType2() throws Exception {
-		ErrorQueue equeue = new ErrorQueue();
-		String slave =
-			"parser grammar S;\n" + // A, B, C token type order
-			"tokens { A, B, C }\n" +
-			"x : A {System.out.println(\"S.x\");} ;\n";
-		mkdir(tmpdir);
-		writeFile(tmpdir, "S.g4", slave);
-		String slave2 =
-			"parser grammar T;\n" +
-			"tokens { C, B, A }\n" + // reverse order
-			"y : A {System.out.println(\"T.y\");} ;\n";
-		mkdir(tmpdir);
-		writeFile(tmpdir, "T.g4", slave2);
-
-		String master =
-			"grammar M;\n" +
-			"import S,T;\n" +
-			"s : x y ;\n" + // matches AA, which should be "aa"
-			"B : 'b' ;\n" + // another order: B, A, C
-			"A : 'a' ;\n" +
-			"C : 'c' ;\n" +
-			"WS : (' '|'\\n') -> skip ;\n" ;
-		writeFile(tmpdir, "M.g4", master);
-		Grammar g = new Grammar(tmpdir+"/M.g4", master, equeue);
-
-		String expectedTokenIDToTypeMap = "{EOF=-1, B=1, A=2, C=3, WS=4}";
-		String expectedStringLiteralToTypeMap = "{'a'=2, 'b'=1, 'c'=3}";
-		String expectedTypeToTokenList = "[B, A, C, WS]";
-
-		assertEquals(expectedTokenIDToTypeMap, g.tokenNameToTypeMap.toString());
-		assertEquals(expectedStringLiteralToTypeMap, sort(g.stringLiteralToTypeMap).toString());
-		assertEquals(expectedTypeToTokenList, realElements(g.typeToTokenList).toString());
-
-		assertEquals("unexpected errors: "+equeue, 0, equeue.errors.size());
-
-		String found = execParser("M.g4", master, "MParser", "MLexer",
-								  "s", "aa", debug);
-		assertEquals("S.x\n" +
-					 "T.y\n", found);
-	}
-
-	@Test public void testCombinedImportsCombined() throws Exception {
-		ErrorQueue equeue = new ErrorQueue();
-		String slave =
-			"grammar S;\n" + // A, B, C token type order
-			"tokens { A, B, C }\n" +
-			"x : 'x' INT {System.out.println(\"S.x\");} ;\n" +
-			"INT : '0'..'9'+ ;\n" +
-			"WS : (' '|'\\n') -> skip ;\n";
-		mkdir(tmpdir);
-		writeFile(tmpdir, "S.g4", slave);
-
-		String master =
-			"grammar M;\n" +
-			"import S;\n" +
-			"s : x INT ;\n";
-		writeFile(tmpdir, "M.g4", master);
-		Grammar g = new Grammar(tmpdir+"/M.g4", master, equeue);
-
-		assertEquals("unexpected errors: "+equeue, 0, equeue.errors.size());
-
-		String found = execParser("M.g4", master, "MParser", "MLexer",
-								  "s", "x 34 9", debug);
-		assertEquals("S.x\n", found);
-	}
-
-	@Test public void testImportedTokenVocabIgnoredWithWarning() throws Exception {
-		ErrorQueue equeue = new ErrorQueue();
-		String slave =
-			"parser grammar S;\n" +
-			"options {tokenVocab=whatever;}\n" +
-			"tokens { A }\n" +
-			"x : A {System.out.println(\"S.x\");} ;\n";
-		mkdir(tmpdir);
-		writeFile(tmpdir, "S.g4", slave);
-
-		String master =
-			"grammar M;\n" +
-			"import S;\n" +
-			"s : x ;\n" +
-			"WS : (' '|'\\n') -> skip ;\n" ;
-		writeFile(tmpdir, "M.g4", master);
-		Grammar g = new Grammar(tmpdir+"/M.g4", master, equeue);
-
-		Object expectedArg = "S";
-		ErrorType expectedMsgID = ErrorType.OPTIONS_IN_DELEGATE;
-		GrammarSemanticsMessage expectedMessage =
-			new GrammarSemanticsMessage(expectedMsgID, g.fileName, null, expectedArg);
-		checkGrammarSemanticsWarning(equeue, expectedMessage);
-
-		assertEquals("unexpected errors: "+equeue, 0, equeue.errors.size());
-		assertEquals("unexpected warnings: "+equeue, 1, equeue.warnings.size());
-	}
-
-	@Test public void testSyntaxErrorsInImportsNotThrownOut() throws Exception {
-		ErrorQueue equeue = new ErrorQueue();
-		String slave =
-			"parser grammar S;\n" +
-			"options {toke\n";
-		mkdir(tmpdir);
-		writeFile(tmpdir, "S.g4", slave);
-
-		String master =
-			"grammar M;\n" +
-			"import S;\n" +
-			"s : x ;\n" +
-			"WS : (' '|'\\n') -> skip ;\n" ;
-		writeFile(tmpdir, "M.g4", master);
-		Grammar g = new Grammar(tmpdir+"/M.g4", master, equeue);
-
-		assertEquals(ErrorType.SYNTAX_ERROR, equeue.errors.get(0).getErrorType());
-	}
-
-	@Test public void testDelegatorRuleOverridesDelegate() throws Exception {
-		String slave =
-			"parser grammar S;\n" +
-			"a : b {System.out.println(\"S.a\");} ;\n" +
-			"b : B ;\n" ;
-		mkdir(tmpdir);
-		writeFile(tmpdir, "S.g4", slave);
-		String master =
-			"grammar M;\n" +
-			"import S;\n" +
-			"b : 'b'|'c' ;\n" +
-			"WS : (' '|'\\n') -> skip ;\n" ;
-		String found = execParser("M.g4", master, "MParser", "MLexer",
-								  "a", "c", debug);
-		assertEquals("S.a\n", found);
-	}
-
-	@Test public void testDelegatorRuleOverridesLookaheadInDelegate() throws Exception {
-		String slave =
-			"parser grammar JavaDecl;\n" +
-			"type : 'int' ;\n" +
-			"decl : type ID ';'\n" +
-			"     | type ID init ';' {System.out.println(\"JavaDecl: \"+$text);}\n" +
-			"     ;\n" +
-			"init : '=' INT ;\n";
-		mkdir(tmpdir);
-		writeFile(tmpdir, "JavaDecl.g4", slave);
-		String master =
-			"grammar Java;\n" +
-			"import JavaDecl;\n" +
-			"prog : decl ;\n" +
-			"type : 'int' | 'float' ;\n" +
-			"\n" +
-			"ID  : 'a'..'z'+ ;\n" +
-			"INT : '0'..'9'+ ;\n" +
-			"WS : (' '|'\\n') -> skip ;\n" ;
-		// for float to work in decl, type must be overridden
-		String found = execParser("Java.g4", master, "JavaParser", "JavaLexer",
-								  "prog", "float x = 3;", debug);
-		assertEquals("JavaDecl: floatx=3;\n", found);
-	}
-
-    @Test public void testDelegatorRuleOverridesDelegates() throws Exception {
-        String slave =
-            "parser grammar S;\n" +
-            "a : b {System.out.println(\"S.a\");} ;\n" +
-            "b : 'b' ;\n" ;
-        mkdir(tmpdir);
-        writeFile(tmpdir, "S.g4", slave);
-
-        String slave2 =
-            "parser grammar T;\n" +
-            "tokens { A }\n" +
-            "b : 'b' {System.out.println(\"T.b\");} ;\n";
-        writeFile(tmpdir, "T.g4", slave2);
-
-        String master =
-            "grammar M;\n" +
-            "import S, T;\n" +
-            "b : 'b'|'c' {System.out.println(\"M.b\");}|B|A ;\n" +
-            "WS : (' '|'\\n') -> skip ;\n" ;
-        String found = execParser("M.g4", master, "MParser", "MLexer",
-                                  "a", "c", debug);
-        assertEquals("M.b\n" +
-                     "S.a\n", found);
-    }
-	// LEXER INHERITANCE
-
-	@Test public void testLexerDelegatorInvokesDelegateRule() throws Exception {
-		String slave =
-			"lexer grammar S;\n" +
-			"A : 'a' {System.out.println(\"S.A\");} ;\n" +
-			"C : 'c' ;\n";
-		mkdir(tmpdir);
-		writeFile(tmpdir, "S.g4", slave);
-		String master =
-			"lexer grammar M;\n" +
-			"import S;\n" +
-			"B : 'b' ;\n" +
-			"WS : (' '|'\\n') -> skip ;\n" ;
-		String expecting =
-			"S.A\n" +
-			"[@0,0:0='a',<3>,1:0]\n" +
-			"[@1,1:1='b',<1>,1:1]\n" +
-			"[@2,2:2='c',<4>,1:2]\n" +
-			"[@3,3:2='<EOF>',<-1>,1:3]\n";
-		String found = execLexer("M.g4", master, "M", "abc", debug);
-		assertEquals(expecting, found);
-	}
-
-	@Test public void testLexerDelegatorRuleOverridesDelegate() throws Exception {
-		String slave =
-			"lexer grammar S;\n" +
-			"A : 'a' {System.out.println(\"S.A\");} ;\n" +
-			"B : 'b' {System.out.println(\"S.B\");} ;\n";
-		mkdir(tmpdir);
-		writeFile(tmpdir, "S.g4", slave);
-		String master =
-			"lexer grammar M;\n" +
-			"import S;\n" +
-			"A : 'a' B {System.out.println(\"M.A\");} ;\n" +
-			"WS : (' '|'\\n') -> skip ;\n" ;
-		String found = execLexer("M.g4", master, "M", "ab", debug);
-		assertEquals("M.A\n" +
-					 "[@0,0:1='ab',<1>,1:0]\n" +
-					 "[@1,2:1='<EOF>',<-1>,1:2]\n", found);
-	}
-
-	@Test public void testKeywordVSIDOrder() throws Exception {
-		// rules in lexer are imported at END so rules in master override
-		// *and* get priority over imported rules. So importing ID doesn't
-		// mess up keywords in master grammar
-		ErrorQueue equeue = new ErrorQueue();
-		String slave =
-			"lexer grammar S;\n" +
-			"ID : 'a'..'z'+ ;\n";
-		mkdir(tmpdir);
-		writeFile(tmpdir, "S.g4", slave);
-		String master =
-			"grammar M;\n" +
-			"import S;\n" +
-			"a : A {System.out.println(\"M.a: \"+$A);} ;\n" +
-			"A : 'abc' {System.out.println(\"M.A\");} ;\n" +
-			"WS : (' '|'\\n') -> skip ;\n" ;
-		String found = execParser("M.g4", master, "MParser", "MLexer",
-								  "a", "abc", debug);
-
-		assertEquals("unexpected errors: "+equeue, 0, equeue.errors.size());
-		assertEquals("unexpected warnings: "+equeue, 0, equeue.warnings.size());
-
-		assertEquals("M.A\n" +
-					 "M.a: [@0,0:2='abc',<1>,1:0]\n", found);
-	}
-
-	// Make sure that M can import S that imports T.
-	@Test public void test3LevelImport() throws Exception {
-		ErrorQueue equeue = new ErrorQueue();
-		String slave =
-			"parser grammar T;\n" +
-			"a : T ;\n" ;
-		mkdir(tmpdir);
-		writeFile(tmpdir, "T.g4", slave);
-		String slave2 =
-			"parser grammar S;\n" +
-			"import T;\n" +
-			"a : S ;\n" ;
-		mkdir(tmpdir);
-		writeFile(tmpdir, "S.g4", slave2);
-
-		String master =
-			"grammar M;\n" +
-			"import S;\n" +
-			"a : M ;\n" ;
-		writeFile(tmpdir, "M.g4", master);
-		Grammar g = new Grammar(tmpdir+"/M.g4", master, equeue);
-
-		String expectedTokenIDToTypeMap = "{EOF=-1, M=1}"; // S and T aren't imported; overridden
-		String expectedStringLiteralToTypeMap = "{}";
-		String expectedTypeToTokenList = "[M]";
-
-		assertEquals(expectedTokenIDToTypeMap,
-					 g.tokenNameToTypeMap.toString());
-		assertEquals(expectedStringLiteralToTypeMap, g.stringLiteralToTypeMap.toString());
-		assertEquals(expectedTypeToTokenList,
-					 realElements(g.typeToTokenList).toString());
-
-		assertEquals("unexpected errors: "+equeue, 0, equeue.errors.size());
-
-		boolean ok =
-			rawGenerateAndBuildRecognizer("M.g4", master, "MParser", null);
-		boolean expecting = true; // should be ok
-		assertEquals(expecting, ok);
-	}
-
-	@Test public void testBigTreeOfImports() throws Exception {
-		ErrorQueue equeue = new ErrorQueue();
-		String slave =
-			"parser grammar T;\n" +
-			"tokens{T}\n" +
-			"x : T ;\n" ;
-		mkdir(tmpdir);
-		writeFile(tmpdir, "T.g4", slave);
-		slave =
-			"parser grammar S;\n" +
-			"import T;\n" +
-			"tokens{S}\n" +
-			"y : S ;\n" ;
-		mkdir(tmpdir);
-		writeFile(tmpdir, "S.g4", slave);
-
-		slave =
-			"parser grammar C;\n" +
-			"tokens{C}\n" +
-			"i : C ;\n" ;
-		mkdir(tmpdir);
-		writeFile(tmpdir, "C.g4", slave);
-		slave =
-			"parser grammar B;\n" +
-			"tokens{B}\n" +
-			"j : B ;\n" ;
-		mkdir(tmpdir);
-		writeFile(tmpdir, "B.g4", slave);
-		slave =
-			"parser grammar A;\n" +
-			"import B,C;\n" +
-			"tokens{A}\n" +
-			"k : A ;\n" ;
-		mkdir(tmpdir);
-		writeFile(tmpdir, "A.g4", slave);
-
-		String master =
-			"grammar M;\n" +
-			"import S,A;\n" +
-			"tokens{M}\n" +
-			"a : M ;\n" ;
-		writeFile(tmpdir, "M.g4", master);
-		Grammar g = new Grammar(tmpdir+"/M.g4", master, equeue);
-
-		assertEquals("[]", equeue.errors.toString());
-		assertEquals("[]", equeue.warnings.toString());
-		String expectedTokenIDToTypeMap = "{EOF=-1, M=1, S=2, T=3, A=4, B=5, C=6}";
-		String expectedStringLiteralToTypeMap = "{}";
-		String expectedTypeToTokenList = "[M, S, T, A, B, C]";
-
-		assertEquals(expectedTokenIDToTypeMap,
-					 g.tokenNameToTypeMap.toString());
-		assertEquals(expectedStringLiteralToTypeMap, g.stringLiteralToTypeMap.toString());
-		assertEquals(expectedTypeToTokenList,
-					 realElements(g.typeToTokenList).toString());
-
-		boolean ok =
-			rawGenerateAndBuildRecognizer("M.g4", master, "MParser", null);
-		boolean expecting = true; // should be ok
-		assertEquals(expecting, ok);
-	}
-
-	@Test public void testRulesVisibleThroughMultilevelImport() throws Exception {
-		ErrorQueue equeue = new ErrorQueue();
-		String slave =
-			"parser grammar T;\n" +
-			"x : T ;\n" ;
-		mkdir(tmpdir);
-		writeFile(tmpdir, "T.g4", slave);
-		String slave2 =
-			"parser grammar S;\n" + // A, B, C token type order
-			"import T;\n" +
-			"a : S ;\n" ;
-		mkdir(tmpdir);
-		writeFile(tmpdir, "S.g4", slave2);
-
-		String master =
-			"grammar M;\n" +
-			"import S;\n" +
-			"a : M x ;\n" ; // x MUST BE VISIBLE TO M
-		writeFile(tmpdir, "M.g4", master);
-		Grammar g = new Grammar(tmpdir+"/M.g4", master, equeue);
-
-		String expectedTokenIDToTypeMap = "{EOF=-1, M=1, T=2}";
-		String expectedStringLiteralToTypeMap = "{}";
-		String expectedTypeToTokenList = "[M, T]";
-
-		assertEquals(expectedTokenIDToTypeMap,
-					 g.tokenNameToTypeMap.toString());
-		assertEquals(expectedStringLiteralToTypeMap, g.stringLiteralToTypeMap.toString());
-		assertEquals(expectedTypeToTokenList,
-					 realElements(g.typeToTokenList).toString());
-
-		assertEquals("unexpected errors: "+equeue, 0, equeue.errors.size());
-	}
-
-	@Test public void testNestedComposite() throws Exception {
-		// Wasn't compiling. http://www.antlr.org/jira/browse/ANTLR-438
-		ErrorQueue equeue = new ErrorQueue();
-		String gstr =
-			"lexer grammar L;\n" +
-			"T1: '1';\n" +
-			"T2: '2';\n" +
-			"T3: '3';\n" +
-			"T4: '4';\n" ;
-		mkdir(tmpdir);
-		writeFile(tmpdir, "L.g4", gstr);
-		gstr =
-			"parser grammar G1;\n" +
-			"s: a | b;\n" +
-			"a: T1;\n" +
-			"b: T2;\n" ;
-		mkdir(tmpdir);
-		writeFile(tmpdir, "G1.g4", gstr);
-
-		gstr =
-			"parser grammar G2;\n" +
-			"import G1;\n" +
-			"a: T3;\n" ;
-		mkdir(tmpdir);
-		writeFile(tmpdir, "G2.g4", gstr);
-		String G3str =
-			"grammar G3;\n" +
-			"import G2;\n" +
-			"b: T4;\n" ;
-		mkdir(tmpdir);
-		writeFile(tmpdir, "G3.g4", G3str);
-
-		Grammar g = new Grammar(tmpdir+"/G3.g4", G3str, equeue);
-
-		String expectedTokenIDToTypeMap = "{EOF=-1, T4=1, T3=2}";
-		String expectedStringLiteralToTypeMap = "{}";
-		String expectedTypeToTokenList = "[T4, T3]";
-
-		assertEquals(expectedTokenIDToTypeMap,
-					 g.tokenNameToTypeMap.toString());
-		assertEquals(expectedStringLiteralToTypeMap, g.stringLiteralToTypeMap.toString());
-		assertEquals(expectedTypeToTokenList,
-					 realElements(g.typeToTokenList).toString());
-
-		assertEquals("unexpected errors: "+equeue, 0, equeue.errors.size());
-
-		boolean ok =
-			rawGenerateAndBuildRecognizer("G3.g4", G3str, "G3Parser", null);
-		boolean expecting = true; // should be ok
-		assertEquals(expecting, ok);
-	}
-
-	@Test public void testHeadersPropogatedCorrectlyToImportedGrammars() throws Exception {
-		String slave =
-			"parser grammar S;\n" +
-			"a : B {System.out.print(\"S.a\");} ;\n";
-		mkdir(tmpdir);
-		writeFile(tmpdir, "S.g4", slave);
-		String master =
-			"grammar M;\n" +
-			"import S;\n" +
-			"@header{package mypackage;}\n" +
-			"s : a ;\n" +
-			"B : 'b' ;" + // defines B from inherited token space
-			"WS : (' '|'\\n') -> skip ;\n" ;
-		ErrorQueue equeue = antlr("M.g4", "M.g4", master, false);
-		int expecting = 0; // should be ok
-		assertEquals(expecting, equeue.errors.size());
-	}
-
-	@Test public void testImportedRuleWithAction() throws Exception {
-		// wasn't terminating. @after was injected into M as if it were @members
-		String slave =
-			"parser grammar S;\n" +
-			"a @after {int x;} : B ;\n";
-		mkdir(tmpdir);
-		writeFile(tmpdir, "S.g4", slave);
-		String master =
-			"grammar M;\n" +
-			"import S;\n" +
-			"s : a ;\n" +
-			"B : 'b' ;" +
-			"WS : (' '|'\\n') -> skip ;\n" ;
-		String found = execParser("M.g4", master, "MParser", "MLexer",
-								  "s", "b", debug);
-		assertEquals("", found);
-	}
-
-	@Test public void testImportedGrammarWithEmptyOptions() throws Exception {
-		String slave =
-			"parser grammar S;\n" +
-			"options {}\n" +
-			"a : B ;\n";
-		mkdir(tmpdir);
-		writeFile(tmpdir, "S.g4", slave);
-		String master =
-			"grammar M;\n" +
-			"import S;\n" +
-			"s : a ;\n" +
-			"B : 'b' ;" +
-			"WS : (' '|'\\n') -> skip ;\n" ;
-		String found = execParser("M.g4", master, "MParser", "MLexer",
-								  "s", "b", debug);
-		assertEquals("", found);
-	}
-
-	/**
-	 * This is a regression test for antlr/antlr4#248 "Including grammar with
-	 * only fragments breaks generated lexer".
-	 * https://github.com/antlr/antlr4/issues/248
-	 */
-	@Test public void testImportLexerWithOnlyFragmentRules() {
-		String slave =
-			"lexer grammar Unicode;\n" +
-			"\n" +
-			"fragment\n" +
-			"UNICODE_CLASS_Zs    : '\\u0020' | '\\u00A0' | '\\u1680' | '\\u180E'\n" +
-			"                    | '\\u2000'..'\\u200A'\n" +
-			"                    | '\\u202F' | '\\u205F' | '\\u3000'\n" +
-			"                    ;\n";
-		String master =
-			"grammar Test;\n" +
-			"import Unicode;\n" +
-			"\n" +
-			"program : 'test' 'test' ;\n" +
-			"\n" +
-			"WS : (UNICODE_CLASS_Zs)+ -> skip;\n";
-
-		mkdir(tmpdir);
-		writeFile(tmpdir, "Unicode.g4", slave);
-		String found = execParser("Test.g4", master, "TestParser", "TestLexer", "program", "test test", debug);
-		assertEquals("", found);
-		assertNull(stderrDuringParse);
-	}
-}
diff --git a/tool/test/org/antlr/v4/test/TestFullContextParsing.java b/tool/test/org/antlr/v4/test/TestFullContextParsing.java
deleted file mode 100644
index 2e4d1b093..000000000
--- a/tool/test/org/antlr/v4/test/TestFullContextParsing.java
+++ /dev/null
@@ -1,350 +0,0 @@
-/*
- * [The "BSD license"]
- *  Copyright (c) 2012 Terence Parr
- *  Copyright (c) 2012 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.
- */
-
-package org.antlr.v4.test;
-
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-
-/*
-	 cover these cases:
-	    dead end
-	    single alt
-	    single alt + preds
-	    conflict
-	    conflict + preds
-
- */
-public class TestFullContextParsing extends BaseTest {
-	@Test public void testAmbigYieldsCtxSensitiveDFA() {
-		String grammar =
-			"grammar T;\n"+
-			"s" +
-			"@after {dumpDFA();}\n" +
-			"    : ID | ID {;} ;\n" +
-			"ID : 'a'..'z'+ ;\n"+
-			"WS : (' '|'\\t'|'\\n')+ -> skip ;\n";
-		String result = execParser("T.g4", grammar, "TParser", "TLexer", "s",
-								   "abc", true);
-		String expecting =
-			"Decision 0:\n" +
-			"s0-ID->:s1^=>1\n"; // ctx sensitive
-		assertEquals(expecting, result);
-		assertEquals("line 1:0 reportAttemptingFullContext d=0 (s), input='abc'\n",
-					 this.stderrDuringParse);
-	}
-
-	@Test public void testCtxSensitiveDFA() {
-		String grammar =
-			"grammar T;\n"+
-			"s @after {dumpDFA();}\n" +
-			"  : '$' a | '@' b ;\n" +
-			"a : e ID ;\n" +
-			"b : e INT ID ;\n" +
-			"e : INT | ;\n" +
-			"ID : 'a'..'z'+ ;\n"+
-			"INT : '0'..'9'+ ;\n"+
-			"WS : (' '|'\\t'|'\\n')+ -> skip ;\n";
-		String result = execParser("T.g4", grammar, "TParser", "TLexer", "s",
-								   "$ 34 abc", true);
-		String expecting =
-			"Decision 1:\n" +
-			"s0-INT->s1\n" +
-			"s1-ID->:s2^=>1\n";
-		assertEquals(expecting, result);
-		assertEquals("line 1:5 reportAttemptingFullContext d=1 (e), input='34abc'\n" +
-					 "line 1:2 reportContextSensitivity d=1 (e), input='34'\n",
-					 this.stderrDuringParse);
-
-		result = execParser("T.g4", grammar, "TParser", "TLexer", "s",
-							"@ 34 abc", true);
-		expecting =
-			"Decision 1:\n" +
-			"s0-INT->s1\n" +
-			"s1-ID->:s2^=>1\n";
-		assertEquals(expecting, result);
-		assertEquals("line 1:5 reportAttemptingFullContext d=1 (e), input='34abc'\n" +
-					 "line 1:5 reportContextSensitivity d=1 (e), input='34abc'\n",
-					 this.stderrDuringParse);
-	}
-
-	@Test public void testCtxSensitiveDFATwoDiffInput() {
-		String grammar =
-			"grammar T;\n"+
-			"s @after {dumpDFA();}\n" +
-			"  : ('$' a | '@' b)+ ;\n" +
-			"a : e ID ;\n" +
-			"b : e INT ID ;\n" +
-			"e : INT | ;\n" +
-			"ID : 'a'..'z'+ ;\n"+
-			"INT : '0'..'9'+ ;\n"+
-			"WS : (' '|'\\t'|'\\n')+ -> skip ;\n";
-		String result = execParser("T.g4", grammar, "TParser", "TLexer", "s",
-								   "$ 34 abc @ 34 abc", true);
-		String expecting =
-			"Decision 2:\n" +
-			"s0-INT->s1\n" +
-			"s1-ID->:s2^=>1\n";
-		assertEquals(expecting, result);
-		assertEquals("line 1:5 reportAttemptingFullContext d=2 (e), input='34abc'\n" +
-					 "line 1:2 reportContextSensitivity d=2 (e), input='34'\n" +
-					 "line 1:14 reportAttemptingFullContext d=2 (e), input='34abc'\n" +
-					 "line 1:14 reportContextSensitivity d=2 (e), input='34abc'\n",
-					 this.stderrDuringParse);
-	}
-
-	@Test
-	public void testSLLSeesEOFInLLGrammar() {
-		String grammar =
-			"grammar T;\n"+
-			"s @after {dumpDFA();}\n" +
-			"  : a ;\n" +
-			"a : e ID ;\n" +
-			"b : e INT ID ;\n" +
-			"e : INT | ;\n" +
-			"ID : 'a'..'z'+ ;\n"+
-			"INT : '0'..'9'+ ;\n"+
-			"WS : (' '|'\\t'|'\\n')+ -> skip ;\n";
-		String result = execParser("T.g4", grammar, "TParser", "TLexer", "s",
-								   "34 abc", true);
-		String expecting =
-			"Decision 0:\n" +
-			"s0-INT->s1\n" +
-			"s1-ID->:s2^=>1\n"; // Must point at accept state
-		assertEquals(expecting, result);
-		assertEquals("line 1:3 reportAttemptingFullContext d=0 (e), input='34abc'\n" +
-					 "line 1:0 reportContextSensitivity d=0 (e), input='34'\n",
-					 this.stderrDuringParse);
-	}
-
-	@Test public void testFullContextIF_THEN_ELSEParse() {
-		String grammar =
-			"grammar T;\n"+
-			"s" +
-			"@init {_interp.setPredictionMode(PredictionMode.LL_EXACT_AMBIG_DETECTION);}\n" +
-			"@after {dumpDFA();}\n" +
-			"    : '{' stat* '}'" +
-			"    ;\n" +
-			"stat: 'if' ID 'then' stat ('else' ID)?\n" +
-			"    | 'return'\n" +
-			"    ;" +
-			"ID : 'a'..'z'+ ;\n"+
-			"WS : (' '|'\\t'|'\\n')+ -> skip ;\n";
-		String input = "{ if x then return }";
-		String result = execParser("T.g4", grammar, "TParser", "TLexer", "s",
-								   input, true);
-		String expecting =
-			"Decision 1:\n" +
-			"s0-'}'->:s1=>2\n";
-		assertEquals(expecting, result);
-		assertEquals(null, this.stderrDuringParse);
-
-		input = "{ if x then return else foo }";
-		result = execParser("T.g4", grammar, "TParser", "TLexer", "s",
-							input, true);
-		expecting =
-			"Decision 1:\n" +
-			"s0-'else'->:s1^=>1\n";
-		assertEquals(expecting, result);
-		// Technically, this input sequence is not ambiguous because else
-		// uniquely predicts going into the optional subrule. else cannot
-		// be matched by exiting stat since that would only match '}' or
-		// the start of a stat. But, we are using the theory that
-		// SLL(1)=LL(1) and so we are avoiding full context parsing
-		// by declaring all else clause parsing to be ambiguous.
-		assertEquals("line 1:19 reportAttemptingFullContext d=1 (stat), input='else'\n" +
-					 "line 1:19 reportContextSensitivity d=1 (stat), input='else'\n",
-					 this.stderrDuringParse);
-
-		input =
-			"{ if x then if y then return else foo }";
-		result = execParser("T.g4", grammar, "TParser", "TLexer", "s",
-							input, true);
-		expecting =
-			"Decision 1:\n" +
-			"s0-'else'->:s1^=>1\n" +
-			"s0-'}'->:s2=>2\n";
-		assertEquals(expecting, result);
-		assertEquals("line 1:29 reportAttemptingFullContext d=1 (stat), input='else'\n" +
-					 "line 1:38 reportAmbiguity d=1 (stat): ambigAlts={1, 2}, input='elsefoo}'\n",
-					 this.stderrDuringParse);
-
-		// should not be ambiguous because the second 'else bar' clearly
-		// indicates that the first else should match to the innermost if.
-		// LL_EXACT_AMBIG_DETECTION makes us keep going to resolve
-
-		input =
-			"{ if x then if y then return else foo else bar }";
-		result = execParser("T.g4", grammar, "TParser", "TLexer", "s",
-							input, true);
-		expecting =
-			"Decision 1:\n" +
-			"s0-'else'->:s1^=>1\n";
-		assertEquals(expecting, result);
-		assertEquals("line 1:29 reportAttemptingFullContext d=1 (stat), input='else'\n" +
-					 "line 1:38 reportContextSensitivity d=1 (stat), input='elsefooelse'\n" +
-					 "line 1:38 reportAttemptingFullContext d=1 (stat), input='else'\n" +
-					 "line 1:38 reportContextSensitivity d=1 (stat), input='else'\n",
-					 this.stderrDuringParse);
-
-		input =
-			"{ if x then return else foo\n" +
-			"if x then if y then return else foo }";
-		result = execParser("T.g4", grammar, "TParser", "TLexer", "s",
-							input, true);
-		expecting =
-			"Decision 1:\n" +
-			"s0-'else'->:s1^=>1\n" +
-			"s0-'}'->:s2=>2\n";
-		assertEquals(expecting, result);
-		assertEquals("line 1:19 reportAttemptingFullContext d=1 (stat), input='else'\n" +
-					 "line 1:19 reportContextSensitivity d=1 (stat), input='else'\n" +
-					 "line 2:27 reportAttemptingFullContext d=1 (stat), input='else'\n" +
-					 "line 2:36 reportAmbiguity d=1 (stat): ambigAlts={1, 2}, input='elsefoo}'\n",
-					 this.stderrDuringParse);
-
-		input =
-			"{ if x then return else foo\n" +
-			"if x then if y then return else foo }";
-		result = execParser("T.g4", grammar, "TParser", "TLexer", "s",
-							input, true);
-		expecting =
-				"Decision 1:\n" +
-				"s0-'else'->:s1^=>1\n" +
-				"s0-'}'->:s2=>2\n";
-		assertEquals(expecting, result);
-		assertEquals("line 1:19 reportAttemptingFullContext d=1 (stat), input='else'\n" +
-					 "line 1:19 reportContextSensitivity d=1 (stat), input='else'\n" +
-					 "line 2:27 reportAttemptingFullContext d=1 (stat), input='else'\n" +
-					 "line 2:36 reportAmbiguity d=1 (stat): ambigAlts={1, 2}, input='elsefoo}'\n",
-					 this.stderrDuringParse);
-	}
-
-	/**
-	 *  Tests predictions for the following case involving closures.
-	 *  http://www.antlr.org/wiki/display/~admin/2011/12/29/Flaw+in+ANTLR+v3+LL(*)+analysis+algorithm
-	 */
-	@Test
-	public void testLoopsSimulateTailRecursion() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"prog\n" +
-			"@init {_interp.setPredictionMode(PredictionMode.LL_EXACT_AMBIG_DETECTION);}\n" +
-			"    : expr_or_assign*;\n" +
-			"expr_or_assign\n" +
-			"    :   expr '++' {System.out.println(\"fail.\");}\n" +
-			"    |   expr {System.out.println(\"pass: \"+$expr.text);}\n" +
-			"    ;\n" +
-			"expr: expr_primary ('<-' ID)? ;\n" +
-			"expr_primary\n" +
-			"    : '(' ID ')'\n" +
-			"    | ID '(' ID ')'\n" +
-			"    | ID\n" +
-			"    ;\n" +
-			"ID  : [a-z]+ ;\n" +
-			"";
-
-		String found = execParser("T.g4", grammar, "TParser", "TLexer", "prog", "a(i)<-x", true);
-		assertEquals("pass: a(i)<-x\n", found);
-
-		String expecting =
-			"line 1:3 reportAttemptingFullContext d=3 (expr_primary), input='a(i)'\n" +
-			"line 1:7 reportAmbiguity d=3 (expr_primary): ambigAlts={2, 3}, input='a(i)<-x'\n";
-		assertEquals(expecting, this.stderrDuringParse);
-	}
-
-	@Test
-	public void testAmbiguityNoLoop() throws Exception {
-		// simpler version of testLoopsSimulateTailRecursion, no loops
-		String grammar =
-			"grammar T;\n" +
-			"prog\n" +
-			"@init {_interp.setPredictionMode(PredictionMode.LL_EXACT_AMBIG_DETECTION);}\n" +
-			"    : expr expr {System.out.println(\"alt 1\");}\n" +
-			"    | expr\n" +
-			"    ;\n" +
-			"expr: '@'\n" +
-			"    | ID '@'\n" +
-			"    | ID\n" +
-			"    ;\n" +
-			"ID  : [a-z]+ ;\n" +
-			"WS  : [ \\r\\n\\t]+ -> skip ;\n";
-
-		String found = execParser("T.g4", grammar, "TParser", "TLexer", "prog", "a@", true);
-		assertEquals("alt 1\n", found);
-
-		String expecting =
-			"line 1:2 reportAttemptingFullContext d=0 (prog), input='a@'\n" +
-			"line 1:2 reportAmbiguity d=0 (prog): ambigAlts={1, 2}, input='a@'\n" +
-			"line 1:2 reportAttemptingFullContext d=1 (expr), input='a@'\n" +
-			"line 1:2 reportContextSensitivity d=1 (expr), input='a@'\n";
-		assertEquals(expecting, this.stderrDuringParse);
-	}
-
-	@Test
-	public void testExprAmbiguity() throws Exception {
-		// translated left-recursive expr rule to test ambig detection
-		String grammar =
-			"grammar T;\n" +
-			"s\n" +
-			"@init {_interp.setPredictionMode(PredictionMode.LL_EXACT_AMBIG_DETECTION);}\n" +
-			"    :   expr[0] {System.out.println($expr.ctx.toStringTree(this));} ;\n" +
-			"\n" +
-			"expr[int _p]\n" +
-			"    :   ID\n" +
-			"        ( {5 >= $_p}? '*' expr[6]\n" +
-			"        | {4 >= $_p}? '+' expr[5]\n" +
-			"        )*\n" +
-			"    ;\n" +
-			"\n" +
-			"ID  :   [a-zA-Z]+ ;      // match identifiers\n" +
-			"WS  :   [ \\t\\r\\n]+ -> skip ; // toss out whitespace\n";
-
-		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", "a+b", true);
-		assertEquals("(expr a + (expr b))\n", found);
-
-		String expecting =
-			"line 1:1 reportAttemptingFullContext d=1 (expr), input='+'\n" +
-			"line 1:2 reportContextSensitivity d=1 (expr), input='+b'\n";
-		assertEquals(expecting, this.stderrDuringParse);
-
-		found = execParser("T.g4", grammar, "TParser", "TLexer", "s", "a+b*c", true);
-		assertEquals("(expr a + (expr b * (expr c)))\n", found);
-
-		expecting =
-			"line 1:1 reportAttemptingFullContext d=1 (expr), input='+'\n" +
-			"line 1:2 reportContextSensitivity d=1 (expr), input='+b'\n" +
-			"line 1:3 reportAttemptingFullContext d=1 (expr), input='*'\n" +
-			"line 1:5 reportAmbiguity d=1 (expr): ambigAlts={1, 2}, input='*c'\n";
-		assertEquals(expecting, this.stderrDuringParse);
-	}
-
-}
diff --git a/tool/test/org/antlr/v4/test/TestLeftRecursion.java b/tool/test/org/antlr/v4/test/TestLeftRecursion.java
deleted file mode 100644
index 798864420..000000000
--- a/tool/test/org/antlr/v4/test/TestLeftRecursion.java
+++ /dev/null
@@ -1,524 +0,0 @@
-/*
- * [The "BSD license"]
- *  Copyright (c) 2012 Terence Parr
- *  Copyright (c) 2012 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.
- */
-
-package org.antlr.v4.test;
-
-import org.antlr.v4.tool.ErrorType;
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
-
-/** */
-public class TestLeftRecursion extends BaseTest {
-	protected boolean debug = false;
-
-	@Test public void testSimple() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"s @after {System.out.println($ctx.toStringTree(this));} : a ;\n" +
-			"a : a ID\n" +
-			"  | ID" +
-			"  ;\n" +
-			"ID : 'a'..'z'+ ;\n" +
-			"WS : (' '|'\\n') -> skip ;\n";
-		String found = execParser("T.g4", grammar, "TParser", "TLexer",
-								  "s", "x", debug);
-		String expecting = "(s (a x))\n";
-		assertEquals(expecting, found);
-
-		found = execParser("T.g4", grammar, "TParser", "TLexer",
-						   "s", "x y", debug);
-		expecting = "(s (a (a x) y))\n";
-		assertEquals(expecting, found);
-
-		found = execParser("T.g4", grammar, "TParser", "TLexer",
-						   "s", "x y z", debug);
-		expecting = "(s (a (a (a x) y) z))\n";
-		assertEquals(expecting, found);
-	}
-
-	/**
-	 * This is a regression test for "Support direct calls to left-recursive
-	 * rules".
-	 * https://github.com/antlr/antlr4/issues/161
-	 */
-	@Test public void testDirectCallToLeftRecursiveRule() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"a @after {System.out.println($ctx.toStringTree(this));} : a ID\n" +
-			"  | ID" +
-			"  ;\n" +
-			"ID : 'a'..'z'+ ;\n" +
-			"WS : (' '|'\\n') -> skip ;\n";
-		String found = execParser("T.g4", grammar, "TParser", "TLexer",
-								  "a", "x", debug);
-		String expecting = "(a x)\n";
-		assertEquals(expecting, found);
-
-		found = execParser("T.g4", grammar, "TParser", "TLexer",
-						   "a", "x y", debug);
-		expecting = "(a (a x) y)\n";
-		assertEquals(expecting, found);
-
-		found = execParser("T.g4", grammar, "TParser", "TLexer",
-						   "a", "x y z", debug);
-		expecting = "(a (a (a x) y) z)\n";
-		assertEquals(expecting, found);
-	}
-
-	@Test public void testSemPred() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"s @after {System.out.println($ctx.toStringTree(this));} : a ;\n" +
-			"a : a {true}? ID\n" +
-			"  | ID" +
-			"  ;\n" +
-			"ID : 'a'..'z'+ ;\n" +
-			"WS : (' '|'\\n') -> skip ;\n";
-		String found = execParser("T.g4", grammar, "TParser", "TLexer",
-								  "s", "x y z", debug);
-		String expecting = "(s (a (a (a x) y) z))\n";
-		assertEquals(expecting, found);
-	}
-
-	@Test public void testTernaryExpr() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"s @after {System.out.println($ctx.toStringTree(this));} : e EOF ;\n" + // must indicate EOF can follow or 'a<EOF>' won't match
-			"e : e '*' e" +
-			"  | e '+' e" +
-			"  |<assoc=right> e '?' e ':' e" +
-			"  |<assoc=right> e '=' e" +
-			"  | ID" +
-			"  ;\n" +
-			"ID : 'a'..'z'+ ;\n" +
-			"WS : (' '|'\\n') -> skip ;\n";
-		String[] tests = {
-			"a",			"(s (e a) <EOF>)",
-			"a+b",			"(s (e (e a) + (e b)) <EOF>)",
-			"a*b",			"(s (e (e a) * (e b)) <EOF>)",
-			"a?b:c",		"(s (e (e a) ? (e b) : (e c)) <EOF>)",
-			"a=b=c",		"(s (e (e a) = (e (e b) = (e c))) <EOF>)",
-			"a?b+c:d",		"(s (e (e a) ? (e (e b) + (e c)) : (e d)) <EOF>)",
-			"a?b=c:d",		"(s (e (e a) ? (e (e b) = (e c)) : (e d)) <EOF>)",
-			"a? b?c:d : e",	"(s (e (e a) ? (e (e b) ? (e c) : (e d)) : (e e)) <EOF>)",
-			"a?b: c?d:e",	"(s (e (e a) ? (e b) : (e (e c) ? (e d) : (e e))) <EOF>)",
-		};
-		runTests(grammar, tests, "s");
-	}
-
-
-	@Test public void testExpressions() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"s @after {System.out.println($ctx.toStringTree(this));} : e EOF ;\n" + // must indicate EOF can follow
-			"e : e '.' ID\n" +
-			"  | e '.' 'this'\n" +
-			"  | '-' e\n" +
-			"  | e '*' e\n" +
-			"  | e ('+'|'-') e\n" +
-			"  | INT\n" +
-			"  | ID\n" +
-			"  ;\n" +
-			"ID : 'a'..'z'+ ;\n" +
-			"INT : '0'..'9'+ ;\n" +
-			"WS : (' '|'\\n') -> skip ;\n";
-		String[] tests = {
-			"a",		"(s (e a) <EOF>)",
-			"1",		"(s (e 1) <EOF>)",
-			"a-1",		"(s (e (e a) - (e 1)) <EOF>)",
-			"a.b",		"(s (e (e a) . b) <EOF>)",
-			"a.this",	"(s (e (e a) . this) <EOF>)",
-			"-a",		"(s (e - (e a)) <EOF>)",
-			"-a+b",		"(s (e (e - (e a)) + (e b)) <EOF>)",
-		};
-		runTests(grammar, tests, "s");
-	}
-
-	@Test public void testJavaExpressions() throws Exception {
-		// Generates about 7k in bytecodes for generated e_ rule;
-		// Well within the 64k method limit. e_primary compiles
-		// to about 2k in bytecodes.
-		// this is simplified from real java
-		String grammar =
-			"grammar T;\n" +
-			"s @after {System.out.println($ctx.toStringTree(this));} : e EOF ;\n" + // must indicate EOF can follow
-			"expressionList\n" +
-			"    :   e (',' e)*\n" +
-			"    ;\n" +
-			"e   :   '(' e ')'\n" +
-			"    |   'this' \n" +
-			"    |   'super'\n" +
-			"    |   INT\n" +
-			"    |   ID\n" +
-			"    |   type '.' 'class'\n" +
-			"    |   e '.' ID\n" +
-			"    |   e '.' 'this'\n" +
-			"    |   e '.' 'super' '(' expressionList? ')'\n" +
-			"    |   e '.' 'new' ID '(' expressionList? ')'\n" +
-			"	 |	 'new' type ( '(' expressionList? ')' | ('[' e ']')+)\n" +
-			"    |   e '[' e ']'\n" +
-			"    |   '(' type ')' e\n" +
-			"    |   e ('++' | '--')\n" +
-			"    |   e '(' expressionList? ')'\n" +
-			"    |   ('+'|'-'|'++'|'--') e\n" +
-			"    |   ('~'|'!') e\n" +
-			"    |   e ('*'|'/'|'%') e\n" +
-			"    |   e ('+'|'-') e\n" +
-			"    |   e ('<<' | '>>>' | '>>') e\n" +
-			"    |   e ('<=' | '>=' | '>' | '<') e\n" +
-			"    |   e 'instanceof' e\n" +
-			"    |   e ('==' | '!=') e\n" +
-			"    |   e '&' e\n" +
-			"    |<assoc=right> e '^' e\n" +
-			"    |   e '|' e\n" +
-			"    |   e '&&' e\n" +
-			"    |   e '||' e\n" +
-			"    |   e '?' e ':' e\n" +
-			"    |<assoc=right>" +
-			"        e ('='\n" +
-			"          |'+='\n" +
-			"          |'-='\n" +
-			"          |'*='\n" +
-			"          |'/='\n" +
-			"          |'&='\n" +
-			"          |'|='\n" +
-			"          |'^='\n" +
-			"          |'>>='\n" +
-			"          |'>>>='\n" +
-			"          |'<<='\n" +
-			"          |'%=') e\n" +
-			"    ;\n" +
-			"type: ID \n" +
-			"    | ID '[' ']'\n" +
-			"    | 'int'\n" +
-			"	 | 'int' '[' ']' \n" +
-			"    ;\n" +
-			"ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;\n" +
-			"INT : '0'..'9'+ ;\n" +
-			"WS : (' '|'\\n') -> skip ;\n";
-		String[] tests = {
-			"a|b&c",	"(s (e (e a) | (e (e b) & (e c))) <EOF>)",
-			"(a|b)&c",	"(s (e (e ( (e (e a) | (e b)) )) & (e c)) <EOF>)",
-            "a > b",	"(s (e (e a) > (e b)) <EOF>)",
-			"a >> b",	"(s (e (e a) >> (e b)) <EOF>)",
-			"a=b=c",	"(s (e (e a) = (e (e b) = (e c))) <EOF>)",
-			"a^b^c",	"(s (e (e a) ^ (e (e b) ^ (e c))) <EOF>)",
-			"(T)x",							"(s (e ( (type T) ) (e x)) <EOF>)",
-			"new A().b",					"(s (e (e new (type A) ( )) . b) <EOF>)",
-			"(T)t.f()",						"(s (e (e ( (type T) ) (e (e t) . f)) ( )) <EOF>)",
-			"a.f(x)==T.c",					"(s (e (e (e (e a) . f) ( (expressionList (e x)) )) == (e (e T) . c)) <EOF>)",
-			"a.f().g(x,1)",					"(s (e (e (e (e (e a) . f) ( )) . g) ( (expressionList (e x) , (e 1)) )) <EOF>)",
-			"new T[((n-1) * x) + 1]",		"(s (e new (type T) [ (e (e ( (e (e ( (e (e n) - (e 1)) )) * (e x)) )) + (e 1)) ]) <EOF>)",
-		};
-		runTests(grammar, tests, "s");
-	}
-
-	@Test public void testDeclarations() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"s @after {System.out.println($ctx.toStringTree(this));} : declarator EOF ;\n" + // must indicate EOF can follow
-			"declarator\n" +
-			"        : declarator '[' e ']'\n" +
-			"        | declarator '[' ']'\n" +
-			"        | declarator '(' ')'\n" +
-			"        | '*' declarator\n" + // binds less tight than suffixes
-			"        | '(' declarator ')'\n" +
-			"        | ID\n" +
-			"        ;\n" +
-			"e : INT ;\n" +
-			"ID : 'a'..'z'+ ;\n" +
-			"INT : '0'..'9'+ ;\n" +
-			"WS : (' '|'\\n') -> skip ;\n";
-		String[] tests = {
-			"a",		"(s (declarator a) <EOF>)",
-			"*a",		"(s (declarator * (declarator a)) <EOF>)",
-			"**a",		"(s (declarator * (declarator * (declarator a))) <EOF>)",
-			"a[3]",		"(s (declarator (declarator a) [ (e 3) ]) <EOF>)",
-			"b[]",		"(s (declarator (declarator b) [ ]) <EOF>)",
-			"(a)",		"(s (declarator ( (declarator a) )) <EOF>)",
-			"a[]()",	"(s (declarator (declarator (declarator a) [ ]) ( )) <EOF>)",
-			"a[][]",	"(s (declarator (declarator (declarator a) [ ]) [ ]) <EOF>)",
-			"*a[]",		"(s (declarator * (declarator (declarator a) [ ])) <EOF>)",
-			"(*a)[]",	"(s (declarator (declarator ( (declarator * (declarator a)) )) [ ]) <EOF>)",
-		};
-		runTests(grammar, tests, "s");
-	}
-
-	@Test public void testReturnValueAndActions() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"s : e {System.out.println($e.v);} ;\n" +
-			"e returns [int v, List<String> ignored]\n" +
-			"  : a=e '*' b=e {$v = $a.v * $b.v;}\n" +
-			"  | a=e '+' b=e {$v = $a.v + $b.v;}\n" +
-			"  | INT {$v = $INT.int;}\n" +
-			"  | '(' x=e ')' {$v = $x.v;}\n" +
-			"  ;\n" +
-			"INT : '0'..'9'+ ;\n" +
-			"WS : (' '|'\\n') -> skip ;\n";
-		String[] tests = {
-			"4",			"4",
-		"1+2",			"3",
-		"1+2*3",		"7",
-		"(1+2)*3",		"9",
-		};
-		runTests(grammar, tests, "s");
-	}
-
-	@Test public void testLabelsOnOpSubrule() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"s @after {System.out.println($ctx.toStringTree(this));} : e ;\n" +
-			"e : a=e op=('*'|'/') b=e  {}\n" +
-			"  | INT {}\n" +
-			"  | '(' x=e ')' {}\n" +
-			"  ;\n" +
-			"INT : '0'..'9'+ ;\n" +
-			"WS : (' '|'\\n') -> skip ;\n";
-		String[] tests = {
-			"4",		"(s (e 4))",
-		"1*2/3",		"(s (e (e (e 1) * (e 2)) / (e 3)))",
-		"(1/2)*3",		"(s (e (e ( (e (e 1) / (e 2)) )) * (e 3)))",
-		};
-		runTests(grammar, tests, "s");
-	}
-
-	@Test public void testReturnValueAndActionsAndLabels() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"s : q=e {System.out.println($e.v);} ;\n" +
-			"\n" +
-			"e returns [int v]\n" +
-			"  : a=e op='*' b=e {$v = $a.v * $b.v;}  # mult\n" +
-			"  | a=e '+' b=e {$v = $a.v + $b.v;}     # add\n" +
-			"  | INT         {$v = $INT.int;}        # anInt\n" +
-			"  | '(' x=e ')' {$v = $x.v;}            # parens\n" +
-			"  | x=e '++'    {$v = $x.v+1;}          # inc\n" +
-			"  | e '--'                              # dec\n" +
-			"  | ID          {$v = 3;}               # anID\n" +
-			"  ; \n" +
-			"\n" +
-			"ID : 'a'..'z'+ ;\n" +
-			"INT : '0'..'9'+ ;\n" +
-			"WS : (' '|'\\n') -> skip ;\n";
-		String[] tests = {
-			"4",			"4",
-			"1+2",			"3",
-			"1+2*3",		"7",
-			"i++*3",		"12",
-		};
-		runTests(grammar, tests, "s");
-	}
-
-	@Test public void testPrefixOpWithActionAndLabel() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"s : e {System.out.println($e.result);} ;\n" +
-			"\n" +
-			"e returns [String result]\n" +
-			"    :   ID '=' e1=e    { $result = \"(\" + $ID.getText() + \"=\" + $e1.result + \")\"; }\n" +
-			"    |   ID             { $result = $ID.getText(); }\n" +
-			"    |   e1=e '+' e2=e  { $result = \"(\" + $e1.result + \"+\" + $e2.result + \")\"; }\n" +
-			"    ;\n" +
-			"ID : 'a'..'z'+ ;\n" +
-			"INT : '0'..'9'+ ;\n" +
-			"WS : (' '|'\\n') -> skip ;\n";
-		String[] tests = {
-			"a",			"a",
-			"a+b",			"(a+b)",
-			"a=b+c",		"((a=b)+c)",
-		};
-		runTests(grammar, tests, "s");
-	}
-
-	@Test
-	public void testAmbigLR() throws Exception {
-		String grammar =
-			"grammar Expr;\n" +
-			"prog:   stat ;\n" +
-			"stat:   expr NEWLINE                # printExpr\n" +
-			"    |   ID '=' expr NEWLINE         # assign\n" +
-			"    |   NEWLINE                     # blank\n" +
-			"    ;\n" +
-			"expr:   expr ('*'|'/') expr      # MulDiv\n" +
-			"    |   expr ('+'|'-') expr      # AddSub\n" +
-			"    |   INT                      # int\n" +
-			"    |   ID                       # id\n" +
-			"    |   '(' expr ')'             # parens\n" +
-			"    ;\n" +
-			"\n" +
-			"MUL :   '*' ; // assigns token name to '*' used above in grammar\n" +
-			"DIV :   '/' ;\n" +
-			"ADD :   '+' ;\n" +
-			"SUB :   '-' ;\n" +
-			"ID  :   [a-zA-Z]+ ;      // match identifiers\n" +
-			"INT :   [0-9]+ ;         // match integers\n" +
-			"NEWLINE:'\\r'? '\\n' ;     // return newlines to parser (is end-statement signal)\n" +
-			"WS  :   [ \\t]+ -> skip ; // toss out whitespace\n";
-		String result = execParser("Expr.g4", grammar, "ExprParser", "ExprLexer", "prog", "1\n", true);
-		assertNull(stderrDuringParse);
-
-		result = execParser("Expr.g4", grammar, "ExprParser", "ExprLexer", "prog", "a = 5\n", true);
-		assertNull(stderrDuringParse);
-
-		result = execParser("Expr.g4", grammar, "ExprParser", "ExprLexer", "prog", "b = 6\n", true);
-		assertNull(stderrDuringParse);
-
-		result = execParser("Expr.g4", grammar, "ExprParser", "ExprLexer", "prog", "a+b*2\n", true);
-		assertEquals("line 1:1 reportAttemptingFullContext d=3 (expr), input='+'\n" +
-					 "line 1:1 reportContextSensitivity d=3 (expr), input='+'\n" +
-					 "line 1:3 reportAttemptingFullContext d=3 (expr), input='*'\n",
-					 stderrDuringParse);
-
-		result = execParser("Expr.g4", grammar, "ExprParser", "ExprLexer", "prog", "(1+2)*3\n", true);
-		assertEquals("line 1:2 reportAttemptingFullContext d=3 (expr), input='+'\n" +
-					 "line 1:2 reportContextSensitivity d=3 (expr), input='+'\n" +
-					 "line 1:5 reportAttemptingFullContext d=3 (expr), input='*'\n" +
-					 "line 1:5 reportContextSensitivity d=3 (expr), input='*'\n",
-					 stderrDuringParse);
-	}
-
-	@Test public void testCheckForNonLeftRecursiveRule() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"s @after {System.out.println($ctx.toStringTree(this));} : a ;\n" +
-			"a : a ID\n" +
-			"  ;\n" +
-			"ID : 'a'..'z'+ ;\n" +
-			"WS : (' '|'\\n') -> skip ;\n";
-		String expected =
-			"error(" + ErrorType.NO_NON_LR_ALTS.code + "): T.g4:3:0: left recursive rule 'a' must contain an alternative which is not left recursive\n";
-		testErrors(new String[] { grammar, expected }, false);
-	}
-
-	@Test public void testCheckForLeftRecursiveEmptyFollow() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"s @after {System.out.println($ctx.toStringTree(this));} : a ;\n" +
-			"a : a ID?\n" +
-			"  | ID\n" +
-			"  ;\n" +
-			"ID : 'a'..'z'+ ;\n" +
-			"WS : (' '|'\\n') -> skip ;\n";
-		String expected =
-			"error(" + ErrorType.EPSILON_LR_FOLLOW.code + "): T.g4:3:0: left recursive rule 'a' contains a left recursive alternative which can be followed by the empty string\n";
-		testErrors(new String[] { grammar, expected }, false);
-	}
-
-	/**
-	 * This is a regression test for #239 "recoursive parser using implicit
-	 * tokens ignore white space lexer rule".
-	 * https://github.com/antlr/antlr4/issues/239
-	 */
-	@Test public void testWhitespaceInfluence() {
-		String grammar =
-			"grammar Expr;\n" +
-			"prog : expression EOF;\n" +
-			"expression\n" +
-			"    : ID '(' expression (',' expression)* ')'               # doFunction\n" +
-			"    | '(' expression ')'                                    # doParenthesis\n" +
-			"    | '!' expression                                        # doNot\n" +
-			"    | '-' expression                                        # doNegate\n" +
-			"    | '+' expression                                        # doPositiv\n" +
-			"    | expression '^' expression                             # doPower\n" +
-			"    | expression '*' expression                             # doMultipy\n" +
-			"    | expression '/' expression                             # doDivide\n" +
-			"    | expression '%' expression                             # doModulo\n" +
-			"    | expression '-' expression                             # doMinus\n" +
-			"    | expression '+' expression                             # doPlus\n" +
-			"    | expression '=' expression                             # doEqual\n" +
-			"    | expression '!=' expression                            # doNotEqual\n" +
-			"    | expression '>' expression                             # doGreather\n" +
-			"    | expression '>=' expression                            # doGreatherEqual\n" +
-			"    | expression '<' expression                             # doLesser\n" +
-			"    | expression '<=' expression                            # doLesserEqual\n" +
-			"    | expression K_IN '(' expression (',' expression)* ')'  # doIn\n" +
-			"    | expression ( '&' | K_AND) expression                  # doAnd\n" +
-			"    | expression ( '|' | K_OR) expression                   # doOr\n" +
-			"    | '[' expression (',' expression)* ']'                  # newArray\n" +
-			"    | K_TRUE                                                # newTrueBoolean\n" +
-			"    | K_FALSE                                               # newFalseBoolean\n" +
-			"    | NUMBER                                                # newNumber\n" +
-			"    | DATE                                                  # newDateTime\n" +
-			"    | ID                                                    # newIdentifier\n" +
-			"    | SQ_STRING                                             # newString\n" +
-			"    | K_NULL                                                # newNull\n" +
-			"    ;\n" +
-			"\n" +
-			"// Fragments\n" +
-			"fragment DIGIT    : '0' .. '9';  \n" +
-			"fragment UPPER    : 'A' .. 'Z';\n" +
-			"fragment LOWER    : 'a' .. 'z';\n" +
-			"fragment LETTER   : LOWER | UPPER;\n" +
-			"fragment WORD     : LETTER | '_' | '$' | '#' | '.';\n" +
-			"fragment ALPHANUM : WORD | DIGIT;  \n" +
-			"\n" +
-			"// Tokens\n" +
-			"ID              : LETTER ALPHANUM*;\n" +
-			"NUMBER          : DIGIT+ ('.' DIGIT+)? (('e'|'E')('+'|'-')? DIGIT+)?;\n" +
-			"DATE            : '\\'' DIGIT DIGIT DIGIT DIGIT '-' DIGIT DIGIT '-' DIGIT DIGIT (' ' DIGIT DIGIT ':' DIGIT DIGIT ':' DIGIT DIGIT ('.' DIGIT+)?)? '\\'';\n" +
-			"SQ_STRING       : '\\'' ('\\'\\'' | ~'\\'')* '\\'';\n" +
-			"DQ_STRING       : '\"' ('\\\\\"' | ~'\"')* '\"';\n" +
-			"WS              : [ \\t\\n\\r]+ -> skip ;\n" +
-			"COMMENTS        : ('/*' .*? '*/' | '//' ~'\\n'* '\\n' ) -> skip;\n";
-
-		String expected =
-			"";
-		String result = execParser("Expr.g4", grammar, "ExprParser", "ExprLexer", "prog", "Test(1,3)", false);
-		assertEquals(expected, result);
-		assertNull(stderrDuringParse);
-
-		expected =
-			"";
-		result = execParser("Expr.g4", grammar, "ExprParser", "ExprLexer", "prog", "Test(1, 3)", false);
-		assertEquals(expected, result);
-		assertNull(stderrDuringParse);
-	}
-
-	public void runTests(String grammar, String[] tests, String startRule) {
-		rawGenerateAndBuildRecognizer("T.g4", grammar, "TParser", "TLexer");
-		writeRecognizerAndCompile("TParser",
-								  "TLexer",
-								  startRule,
-								  debug);
-
-		for (int i=0; i<tests.length; i+=2) {
-			String test = tests[i];
-			String expecting = tests[i+1]+"\n";
-			writeFile(tmpdir, "input", test);
-			String found = execRecognizer();
-			System.out.print(test+" -> "+found);
-			assertEquals(expecting, found);
-		}
-	}
-
-}
diff --git a/tool/test/org/antlr/v4/test/TestLexerErrors.java b/tool/test/org/antlr/v4/test/TestLexerErrors.java
deleted file mode 100644
index a9b20fa30..000000000
--- a/tool/test/org/antlr/v4/test/TestLexerErrors.java
+++ /dev/null
@@ -1,213 +0,0 @@
-/*
- * [The "BSD license"]
- *  Copyright (c) 2012 Terence Parr
- *  Copyright (c) 2012 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.
- */
-
-package org.antlr.v4.test;
-
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-public class TestLexerErrors extends BaseTest {
-	// TEST DETECTION
-	@Test public void testInvalidCharAtStart() throws Exception {
-		String grammar =
-			"lexer grammar L;\n" +
-			"A : 'a' 'b' ;\n";
-		String tokens = execLexer("L.g4", grammar, "L", "x");
-		String expectingTokens =
-			"[@0,1:0='<EOF>',<-1>,1:1]\n";
-		assertEquals(expectingTokens, tokens);
-		String expectingError = "line 1:0 token recognition error at: 'x'\n";
-		String error = stderrDuringParse;
-		assertEquals(expectingError, error);
-	}
-
-	@Test
-	public void testStringsEmbeddedInActions() {
-		String grammar =
-			"lexer grammar Actions;\n"
-			+ "ACTION2 : '[' (STRING | ~'\"')*? ']';\n"
-			+ "STRING : '\"' ('\\\"' | .)*? '\"';\n"
-			+ "WS : [ \\t\\r\\n]+ -> skip;\n";
-		String tokens = execLexer("Actions.g4", grammar, "Actions", "[\"foo\"]");
-		String expectingTokens =
-			"[@0,0:6='[\"foo\"]',<1>,1:0]\n" +
-			"[@1,7:6='<EOF>',<-1>,1:7]\n";
-		assertEquals(expectingTokens, tokens);
-		assertNull(stderrDuringParse);
-
-		tokens = execLexer("Actions.g4", grammar, "Actions", "[\"foo]");
-		expectingTokens =
-			"[@0,6:5='<EOF>',<-1>,1:6]\n";
-		assertEquals(expectingTokens, tokens);
-		assertEquals("line 1:0 token recognition error at: '[\"foo]'\n", stderrDuringParse);
-	}
-
-	@Test public void testEnforcedGreedyNestedBrances() {
-		String grammar =
-			"lexer grammar R;\n"
-			+ "ACTION : '{' (ACTION | ~[{}])* '}';\n"
-			+ "WS : [ \\r\\n\\t]+ -> skip;\n";
-		String tokens = execLexer("R.g4", grammar, "R", "{ { } }");
-		String expectingTokens =
-			"[@0,0:6='{ { } }',<1>,1:0]\n" +
-			"[@1,7:6='<EOF>',<-1>,1:7]\n";
-		assertEquals(expectingTokens, tokens);
-		assertEquals(null, stderrDuringParse);
-
-		tokens = execLexer("R.g4", grammar, "R", "{ { }");
-		expectingTokens =
-			"[@0,5:4='<EOF>',<-1>,1:5]\n";
-		assertEquals(expectingTokens, tokens);
-		assertEquals("line 1:0 token recognition error at: '{ { }'\n", stderrDuringParse);
-	}
-
-	@Test public void testInvalidCharAtStartAfterDFACache() throws Exception {
-		String grammar =
-			"lexer grammar L;\n" +
-			"A : 'a' 'b' ;\n";
-		String tokens = execLexer("L.g4", grammar, "L", "abx");
-		String expectingTokens =
-			"[@0,0:1='ab',<1>,1:0]\n" +
-			"[@1,3:2='<EOF>',<-1>,1:3]\n";
-		assertEquals(expectingTokens, tokens);
-		String expectingError = "line 1:2 token recognition error at: 'x'\n";
-		String error = stderrDuringParse;
-		assertEquals(expectingError, error);
-	}
-
-	@Test public void testInvalidCharInToken() throws Exception {
-		String grammar =
-			"lexer grammar L;\n" +
-			"A : 'a' 'b' ;\n";
-		String tokens = execLexer("L.g4", grammar, "L", "ax");
-		String expectingTokens =
-			"[@0,2:1='<EOF>',<-1>,1:2]\n";
-		assertEquals(expectingTokens, tokens);
-		String expectingError = "line 1:0 token recognition error at: 'ax'\n";
-		String error = stderrDuringParse;
-		assertEquals(expectingError, error);
-	}
-
-	@Test public void testInvalidCharInTokenAfterDFACache() throws Exception {
-		String grammar =
-			"lexer grammar L;\n" +
-			"A : 'a' 'b' ;\n";
-		String tokens = execLexer("L.g4", grammar, "L", "abax");
-		String expectingTokens =
-			"[@0,0:1='ab',<1>,1:0]\n" +
-			"[@1,4:3='<EOF>',<-1>,1:4]\n";
-		assertEquals(expectingTokens, tokens);
-		String expectingError = "line 1:2 token recognition error at: 'ax'\n";
-		String error = stderrDuringParse;
-		assertEquals(expectingError, error);
-	}
-
-	@Test public void testDFAToATNThatFailsBackToDFA() throws Exception {
-		String grammar =
-			"lexer grammar L;\n" +
-			"A : 'ab' ;\n"+
-			"B : 'abc' ;\n";
-		// The first ab caches the DFA then abx goes through the DFA but
-		// into the ATN for the x, which fails. Must go back into DFA
-		// and return to previous dfa accept state
-		String tokens = execLexer("L.g4", grammar, "L", "ababx");
-		String expectingTokens =
-			"[@0,0:1='ab',<1>,1:0]\n" +
-			"[@1,2:3='ab',<1>,1:2]\n" +
-			"[@2,5:4='<EOF>',<-1>,1:5]\n";
-		assertEquals(expectingTokens, tokens);
-		String expectingError = "line 1:4 token recognition error at: 'x'\n";
-		String error = stderrDuringParse;
-		assertEquals(expectingError, error);
-	}
-
-	@Test public void testDFAToATNThatMatchesThenFailsInATN() throws Exception {
-		String grammar =
-			"lexer grammar L;\n" +
-			"A : 'ab' ;\n"+
-			"B : 'abc' ;\n"+
-			"C : 'abcd' ;\n";
-		// The first ab caches the DFA then abx goes through the DFA but
-		// into the ATN for the c.  It marks that hasn't except state
-		// and then keeps going in the ATN. It fails on the x, but
-		// uses the previous accepted in the ATN not DFA
-		String tokens = execLexer("L.g4", grammar, "L", "ababcx");
-		String expectingTokens =
-			"[@0,0:1='ab',<1>,1:0]\n" +
-			"[@1,2:4='abc',<2>,1:2]\n" +
-			"[@2,6:5='<EOF>',<-1>,1:6]\n";
-		assertEquals(expectingTokens, tokens);
-		String expectingError = "line 1:5 token recognition error at: 'x'\n";
-		String error = stderrDuringParse;
-		assertEquals(expectingError, error);
-	}
-
-	@Test public void testErrorInMiddle() throws Exception {
-		String grammar =
-			"lexer grammar L;\n" +
-			"A : 'abc' ;\n";
-		String tokens = execLexer("L.g4", grammar, "L", "abx");
-		String expectingTokens =
-			"[@0,3:2='<EOF>',<-1>,1:3]\n";
-		assertEquals(expectingTokens, tokens);
-		String expectingError = "line 1:0 token recognition error at: 'abx'\n";
-		String error = stderrDuringParse;
-		assertEquals(expectingError, error);
-	}
-
-	// TEST RECOVERY
-
-	/**
-	 * This is a regression test for #45 "NullPointerException in LexerATNSimulator.execDFA".
-	 * https://github.com/antlr/antlr4/issues/46
-	 */
-	@Test
-	public void testLexerExecDFA() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"start : ID ':' expr;\n" +
-			"expr : primary expr? {} | expr '->' ID;\n" +
-			"primary : ID;\n" +
-			"ID : [a-z]+;\n" +
-			"\n";
-		String result = execLexer("T.g4", grammar, "TLexer", "x : x", false);
-		String expecting =
-			"[@0,0:0='x',<3>,1:0]\n" +
-			"[@1,2:2=':',<2>,1:2]\n" +
-			"[@2,4:4='x',<3>,1:4]\n" +
-			"[@3,5:4='<EOF>',<-1>,1:5]\n";
-		assertEquals(expecting, result);
-		assertEquals("line 1:1 token recognition error at: ' '\n" +
-					 "line 1:3 token recognition error at: ' '\n",
-					 this.stderrDuringParse);
-	}
-
-}
diff --git a/tool/test/org/antlr/v4/test/TestLexerExec.java b/tool/test/org/antlr/v4/test/TestLexerExec.java
deleted file mode 100644
index b71944bdf..000000000
--- a/tool/test/org/antlr/v4/test/TestLexerExec.java
+++ /dev/null
@@ -1,769 +0,0 @@
-/*
- * [The "BSD license"]
- *  Copyright (c) 2012 Terence Parr
- *  Copyright (c) 2012 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.
- */
-
-package org.antlr.v4.test;
-
-import org.antlr.v4.runtime.misc.Nullable;
-import org.junit.Test;
-
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-
-import static org.junit.Assert.*;
-
-public class TestLexerExec extends BaseTest {
-    @Test public void testQuoteTranslation() throws Exception {
-   		String grammar =
-   			"lexer grammar L;\n"+
-   			"QUOTE : '\"' ;\n"; // make sure this compiles
-   		String found = execLexer("L.g4", grammar, "L", "\"");
-   		String expecting =
-   			"[@0,0:0='\"',<1>,1:0]\n" +
-            "[@1,1:0='<EOF>',<-1>,1:1]\n";
-   		assertEquals(expecting, found);
-   	}
-
-    @Test public void testRefToRuleDoesNotSetTokenNorEmitAnother() throws Exception {
-   		String grammar =
-   			"lexer grammar L;\n"+
-   			"A : '-' I ;\n" +
-   			"I : '0'..'9'+ ;\n"+
-   			"WS : (' '|'\\n') -> skip ;";
-   		String found = execLexer("L.g4", grammar, "L", "34 -21 3");
-   		String expecting =
-   			"[@0,0:1='34',<2>,1:0]\n" +
-   			"[@1,3:5='-21',<1>,1:3]\n" +
-   			"[@2,7:7='3',<2>,1:7]\n" +
-   			"[@3,8:7='<EOF>',<-1>,1:8]\n"; // EOF has no length so range is 8:7 not 8:8
-   		assertEquals(expecting, found);
-   	}
-
-	@Test public void testSlashes() throws Exception {
-		String grammar =
-			"lexer grammar L;\n"+
-			"Backslash : '\\\\';\n" +
-			"Slash : '/';\n" +
-			"Vee : '\\\\/';\n" +
-			"Wedge : '/\\\\';\n"+
-			"WS : [ \\t] -> skip;";
-		String found = execLexer("L.g4", grammar, "L", "\\ / \\/ /\\");
-		String expecting =
-			"[@0,0:0='\\',<1>,1:0]\n" +
-			"[@1,2:2='/',<2>,1:2]\n" +
-			"[@2,4:5='\\/',<3>,1:4]\n" +
-			"[@3,7:8='/\\',<4>,1:7]\n" +
-			"[@4,9:8='<EOF>',<-1>,1:9]\n";
-		assertEquals(expecting, found);
-	}
-
-	/**
-	 * This is a regression test for antlr/antlr4#224: "Parentheses without
-	 * quantifier in lexer rules have unclear effect".
-	 * https://github.com/antlr/antlr4/issues/224
-	 */
-	@Test public void testParentheses() {
-		String grammar =
-			"lexer grammar Demo;\n" +
-			"\n" +
-			"START_BLOCK: '-.-.-';\n" +
-			"\n" +
-			"ID : (LETTER SEPARATOR) (LETTER SEPARATOR)+;\n" +
-			"fragment LETTER: L_A|L_K;\n" +
-			"fragment L_A: '.-';\n" +
-			"fragment L_K: '-.-';\n" +
-			"\n" +
-			"SEPARATOR: '!';\n";
-		String found = execLexer("Demo.g4", grammar, "Demo", "-.-.-!");
-		String expecting =
-			"[@0,0:4='-.-.-',<1>,1:0]\n" +
-			"[@1,5:5='!',<3>,1:5]\n" +
-			"[@2,6:5='<EOF>',<-1>,1:6]\n";
-		assertEquals(expecting, found);
-	}
-
-	@Test
-	public void testNonGreedyTermination() throws Exception {
-		String grammar =
-			"lexer grammar L;\n"
-			+ "STRING : '\"' ('\"\"' | .)*? '\"';";
-
-		String found = execLexer("L.g4", grammar, "L", "\"hi\"\"mom\"");
-		assertEquals(
-			"[@0,0:3='\"hi\"',<1>,1:0]\n" +
-			"[@1,4:8='\"mom\"',<1>,1:4]\n" +
-			"[@2,9:8='<EOF>',<-1>,1:9]\n", found);
-		assertNull(stderrDuringParse);
-	}
-
-	@Test
-	public void testNonGreedyTermination2() throws Exception {
-		String grammar =
-			"lexer grammar L;\n"
-			+ "STRING : '\"' ('\"\"' | .)+? '\"';";
-
-		String found = execLexer("L.g4", grammar, "L", "\"\"\"mom\"");
-		assertEquals(
-			"[@0,0:6='\"\"\"mom\"',<1>,1:0]\n" +
-			"[@1,7:6='<EOF>',<-1>,1:7]\n", found);
-		assertNull(stderrDuringParse);
-	}
-
-	@Test
-	public void testGreedyOptional() throws Exception {
-		String grammar =
-			"lexer grammar L;\n"
-			+ "CMT : '//' .*? '\\n' CMT?;\n"
-			+ "WS : (' '|'\\t')+;";
-
-		String found = execLexer("L.g4", grammar, "L", "//blah\n//blah\n");
-		assertEquals(
-			"[@0,0:13='//blah\\n//blah\\n',<1>,1:0]\n" +
-			"[@1,14:13='<EOF>',<-1>,3:14]\n", found);
-		assertNull(stderrDuringParse);
-	}
-
-	@Test
-	public void testNonGreedyOptional() throws Exception {
-		String grammar =
-			"lexer grammar L;\n"
-			+ "CMT : '//' .*? '\\n' CMT??;\n"
-			+ "WS : (' '|'\\t')+;";
-
-		String found = execLexer("L.g4", grammar, "L", "//blah\n//blah\n");
-		assertEquals(
-			"[@0,0:6='//blah\\n',<1>,1:0]\n" +
-			"[@1,7:13='//blah\\n',<1>,2:0]\n" +
-			"[@2,14:13='<EOF>',<-1>,3:7]\n", found);
-		assertNull(stderrDuringParse);
-	}
-
-	@Test
-	public void testGreedyClosure() throws Exception {
-		String grammar =
-			"lexer grammar L;\n"
-			+ "CMT : '//' .*? '\\n' CMT*;\n"
-			+ "WS : (' '|'\\t')+;";
-
-		String found = execLexer("L.g4", grammar, "L", "//blah\n//blah\n");
-		assertEquals(
-			"[@0,0:13='//blah\\n//blah\\n',<1>,1:0]\n" +
-			"[@1,14:13='<EOF>',<-1>,3:14]\n", found);
-		assertNull(stderrDuringParse);
-	}
-
-	@Test
-	public void testNonGreedyClosure() throws Exception {
-		String grammar =
-			"lexer grammar L;\n"
-			+ "CMT : '//' .*? '\\n' CMT*?;\n"
-			+ "WS : (' '|'\\t')+;";
-
-		String found = execLexer("L.g4", grammar, "L", "//blah\n//blah\n");
-		assertEquals(
-			"[@0,0:6='//blah\\n',<1>,1:0]\n" +
-			"[@1,7:13='//blah\\n',<1>,2:0]\n" +
-			"[@2,14:13='<EOF>',<-1>,3:7]\n", found);
-		assertNull(stderrDuringParse);
-	}
-
-	@Test
-	public void testGreedyPositiveClosure() throws Exception {
-		String grammar =
-			"lexer grammar L;\n"
-			+ "CMT : ('//' .*? '\\n')+;\n"
-			+ "WS : (' '|'\\t')+;";
-
-		String found = execLexer("L.g4", grammar, "L", "//blah\n//blah\n");
-		assertEquals(
-			"[@0,0:13='//blah\\n//blah\\n',<1>,1:0]\n" +
-			"[@1,14:13='<EOF>',<-1>,3:14]\n", found);
-		assertNull(stderrDuringParse);
-	}
-
-	@Test
-	public void testNonGreedyPositiveClosure() throws Exception {
-		String grammar =
-			"lexer grammar L;\n"
-			+ "CMT : ('//' .*? '\\n')+?;\n"
-			+ "WS : (' '|'\\t')+;";
-
-		String found = execLexer("L.g4", grammar, "L", "//blah\n//blah\n");
-		assertEquals(
-			"[@0,0:6='//blah\\n',<1>,1:0]\n" +
-			"[@1,7:13='//blah\\n',<1>,2:0]\n" +
-			"[@2,14:13='<EOF>',<-1>,3:7]\n", found);
-		assertNull(stderrDuringParse);
-	}
-
-	@Test public void testRecursiveLexerRuleRefWithWildcardStar() throws Exception {
-		String grammar =
-			"lexer grammar L;\n"+
-			"CMT : '/*' (CMT | .)*? '*/' ;\n" +
-			"WS : (' '|'\\n')+ ;\n"
-			/*+ "ANY : .;"*/;
-
-		String expecting =
-			"[@0,0:8='/* ick */',<1>,1:0]\n" +
-			"[@1,9:9='\\n',<2>,1:9]\n" +
-			"[@2,10:34='/* /* */\\n/* /*nested*/ */',<1>,2:0]\n" +
-			"[@3,35:35='\\n',<2>,3:16]\n" +
-			"[@4,36:35='<EOF>',<-1>,4:17]\n";
-
-		// stuff on end of comment matches another rule
-		String found = execLexer("L.g4", grammar, "L",
-						  "/* ick */\n" +
-						  "/* /* */\n" +
-						  "/* /*nested*/ */\n");
-		assertEquals(expecting, found);
-		assertNull(stderrDuringParse);
-		// stuff on end of comment doesn't match another rule
-		expecting =
-			"[@0,0:8='/* ick */',<1>,1:0]\n" +
-			"[@1,10:10='\\n',<2>,1:10]\n" +
-			"[@2,11:36='/* /* */x\\n/* /*nested*/ */',<1>,2:0]\n" +
-			"[@3,38:38='\\n',<2>,3:17]\n" +
-			"[@4,39:38='<EOF>',<-1>,4:18]\n";
-		found = execLexer("L.g4", grammar, "L",
-						  "/* ick */x\n" +
-						  "/* /* */x\n" +
-						  "/* /*nested*/ */x\n");
-		assertEquals(expecting, found);
-		assertEquals(
-			"line 1:9 token recognition error at: 'x'\n" +
-			"line 3:16 token recognition error at: 'x'\n", stderrDuringParse);
-	}
-
-	@Test public void testRecursiveLexerRuleRefWithWildcardPlus() throws Exception {
-		String grammar =
-			"lexer grammar L;\n"+
-			"CMT : '/*' (CMT | .)+? '*/' ;\n" +
-			"WS : (' '|'\\n')+ ;\n"
-			/*+ "ANY : .;"*/;
-
-		String expecting =
-			"[@0,0:8='/* ick */',<1>,1:0]\n" +
-			"[@1,9:9='\\n',<2>,1:9]\n" +
-			"[@2,10:34='/* /* */\\n/* /*nested*/ */',<1>,2:0]\n" +
-			"[@3,35:35='\\n',<2>,3:16]\n" +
-			"[@4,36:35='<EOF>',<-1>,4:17]\n";
-
-		// stuff on end of comment matches another rule
-		String found = execLexer("L.g4", grammar, "L",
-						  "/* ick */\n" +
-						  "/* /* */\n" +
-						  "/* /*nested*/ */\n");
-		assertEquals(expecting, found);
-		assertNull(stderrDuringParse);
-		// stuff on end of comment doesn't match another rule
-		expecting =
-			"[@0,0:8='/* ick */',<1>,1:0]\n" +
-			"[@1,10:10='\\n',<2>,1:10]\n" +
-			"[@2,11:36='/* /* */x\\n/* /*nested*/ */',<1>,2:0]\n" +
-			"[@3,38:38='\\n',<2>,3:17]\n" +
-			"[@4,39:38='<EOF>',<-1>,4:18]\n";
-		found = execLexer("L.g4", grammar, "L",
-						  "/* ick */x\n" +
-						  "/* /* */x\n" +
-						  "/* /*nested*/ */x\n");
-		assertEquals(expecting, found);
-		assertEquals(
-			"line 1:9 token recognition error at: 'x'\n" +
-			"line 3:16 token recognition error at: 'x'\n", stderrDuringParse);
-	}
-
-	@Test public void testGreedyConfigs() throws Exception {
-		String grammar =
-			"lexer grammar L;\n"+
-			"I : ('a' | 'ab') {System.out.println(getText());} ;\n"+
-			"WS : (' '|'\\n') -> skip ;\n" +
-			"J : .;\n";
-		String found = execLexer("L.g4", grammar, "L", "ab");
-		String expecting =
-			"ab\n" +
-			"[@0,0:1='ab',<1>,1:0]\n" +
-			"[@1,2:1='<EOF>',<-1>,1:2]\n";
-		assertEquals(expecting, found);
-	}
-
-	@Test public void testNonGreedyConfigs() throws Exception {
-		String grammar =
-			"lexer grammar L;\n"+
-			"I : .*? ('a' | 'ab') {System.out.println(getText());} ;\n"+
-			"WS : (' '|'\\n') -> skip ;\n" +
-			"J : . {System.out.println(getText());};\n";
-		String found = execLexer("L.g4", grammar, "L", "ab");
-		String expecting =
-			"a\n" +
-			"b\n" +
-			"[@0,0:0='a',<1>,1:0]\n" +
-			"[@1,1:1='b',<3>,1:1]\n" +
-			"[@2,2:1='<EOF>',<-1>,1:2]\n";
-		assertEquals(expecting, found);
-	}
-
-	@Test public void testActionExecutedInDFA() throws Exception {
-		String grammar =
-			"lexer grammar L;\n"+
-			"I : '0'..'9'+ {System.out.println(\"I\");} ;\n"+
-			"WS : (' '|'\\n') -> skip ;";
-		String found = execLexer("L.g4", grammar, "L", "34 34");
-		String expecting =
-			"I\n" +
-			"I\n" +
-			"[@0,0:1='34',<1>,1:0]\n" +
-			"[@1,3:4='34',<1>,1:3]\n" +
-			"[@2,5:4='<EOF>',<-1>,1:5]\n";
-		assertEquals(expecting, found);
-	}
-
-	@Test public void testSkipCommand() throws Exception {
-		String grammar =
-			"lexer grammar L;\n"+
-			"I : '0'..'9'+ {System.out.println(\"I\");} ;\n"+
-			"WS : (' '|'\\n') -> skip ;";
-		String found = execLexer("L.g4", grammar, "L", "34 34");
-		String expecting =
-			"I\n" +
-			"I\n" +
-			"[@0,0:1='34',<1>,1:0]\n" +
-			"[@1,3:4='34',<1>,1:3]\n" +
-			"[@2,5:4='<EOF>',<-1>,1:5]\n";
-		assertEquals(expecting, found);
-	}
-
-	@Test public void testMoreCommand() throws Exception {
-		String grammar =
-			"lexer grammar L;\n"+
-			"I : '0'..'9'+ {System.out.println(\"I\");} ;\n"+
-			"WS : '#' -> more ;";
-		String found = execLexer("L.g4", grammar, "L", "34#10");
-		String expecting =
-			"I\n" +
-			"I\n" +
-			"[@0,0:1='34',<1>,1:0]\n" +
-			"[@1,2:4='#10',<1>,1:2]\n" +
-			"[@2,5:4='<EOF>',<-1>,1:5]\n";
-		assertEquals(expecting, found);
-	}
-
-	@Test public void testTypeCommand() throws Exception {
-		String grammar =
-			"lexer grammar L;\n"+
-			"I : '0'..'9'+ {System.out.println(\"I\");} ;\n"+
-			"HASH : '#' -> type(HASH) ;";
-		String found = execLexer("L.g4", grammar, "L", "34#");
-		String expecting =
-			"I\n" +
-			"[@0,0:1='34',<1>,1:0]\n" +
-			"[@1,2:2='#',<2>,1:2]\n" +
-			"[@2,3:2='<EOF>',<-1>,1:3]\n";
-		assertEquals(expecting, found);
-	}
-
-	@Test public void testCombinedCommand() throws Exception {
-		String grammar =
-			"lexer grammar L;\n"+
-			"I : '0'..'9'+ {System.out.println(\"I\");} ;\n"+
-			"HASH : '#' -> type(100), skip, more  ;";
-		String found = execLexer("L.g4", grammar, "L", "34#11");
-		String expecting =
-			"I\n" +
-			"I\n" +
-			"[@0,0:1='34',<1>,1:0]\n" +
-			"[@1,2:4='#11',<1>,1:2]\n" +
-			"[@2,5:4='<EOF>',<-1>,1:5]\n";
-		assertEquals(expecting, found);
-	}
-
-	@Test public void testLexerMode() throws Exception {
-		String grammar =
-			"lexer grammar L;\n" +
-			"STRING_START : '\"' -> pushMode(STRING_MODE), more;\n" +
-			"WS : (' '|'\\n') -> skip ;\n"+
-			"mode STRING_MODE;\n"+
-			"STRING : '\"' -> popMode;\n"+
-			"ANY : . -> more;\n";
-		String found = execLexer("L.g4", grammar, "L", "\"abc\" \"ab\"");
-		String expecting =
-			"[@0,0:4='\"abc\"',<2>,1:0]\n" +
-			"[@1,6:9='\"ab\"',<2>,1:6]\n" +
-			"[@2,10:9='<EOF>',<-1>,1:10]\n";
-		assertEquals(expecting, found);
-	}
-
-	@Test public void testLexerPushPopModeAction() throws Exception {
-		String grammar =
-			"lexer grammar L;\n" +
-			"STRING_START : '\"' -> pushMode(STRING_MODE), more ;\n" +
-			"WS : (' '|'\\n') -> skip ;\n"+
-			"mode STRING_MODE;\n"+
-			"STRING : '\"' -> popMode ;\n"+  // token type 2
-			"ANY : . -> more ;\n";
-		String found = execLexer("L.g4", grammar, "L", "\"abc\" \"ab\"");
-		String expecting =
-			"[@0,0:4='\"abc\"',<2>,1:0]\n" +
-			"[@1,6:9='\"ab\"',<2>,1:6]\n" +
-			"[@2,10:9='<EOF>',<-1>,1:10]\n";
-		assertEquals(expecting, found);
-	}
-
-	@Test public void testLexerModeAction() throws Exception {
-		String grammar =
-			"lexer grammar L;\n" +
-			"STRING_START : '\"' -> mode(STRING_MODE), more ;\n" +
-			"WS : (' '|'\\n') -> skip ;\n"+
-			"mode STRING_MODE;\n"+
-			"STRING : '\"' -> mode(DEFAULT_MODE) ;\n"+ // ttype 2 since '"' ambiguity
-			"ANY : . -> more ;\n";
-		String found = execLexer("L.g4", grammar, "L", "\"abc\" \"ab\"");
-		String expecting =
-			"[@0,0:4='\"abc\"',<2>,1:0]\n" +
-			"[@1,6:9='\"ab\"',<2>,1:6]\n" +
-			"[@2,10:9='<EOF>',<-1>,1:10]\n";
-		assertEquals(expecting, found);
-	}
-
-	@Test public void testKeywordID() throws Exception {
-		String grammar =
-			"lexer grammar L;\n"+
-			"KEND : 'end' ;\n" + // has priority
-			"ID : 'a'..'z'+ ;\n" +
-			"WS : (' '|'\\n')+ ;";
-		String found = execLexer("L.g4", grammar, "L", "end eend ending a");
-		String expecting =
-			"[@0,0:2='end',<1>,1:0]\n" +
-			"[@1,3:3=' ',<3>,1:3]\n" +
-			"[@2,4:7='eend',<2>,1:4]\n" +
-			"[@3,8:8=' ',<3>,1:8]\n" +
-			"[@4,9:14='ending',<2>,1:9]\n" +
-			"[@5,15:15=' ',<3>,1:15]\n" +
-			"[@6,16:16='a',<2>,1:16]\n" +
-			"[@7,17:16='<EOF>',<-1>,1:17]\n";
-		assertEquals(expecting, found);
-	}
-
-	@Test public void testHexVsID() throws Exception {
-		String grammar =
-			"lexer grammar L;\n"+
-			"HexLiteral : '0' ('x'|'X') HexDigit+ ;\n"+
-			"DecimalLiteral : ('0' | '1'..'9' '0'..'9'*) ;\n" +
-			"FloatingPointLiteral : ('0x' | '0X') HexDigit* ('.' HexDigit*)? ;\n" +
-			"DOT : '.' ;\n" +
-			"ID : 'a'..'z'+ ;\n" +
-			"fragment HexDigit : ('0'..'9'|'a'..'f'|'A'..'F') ;\n" +
-			"WS : (' '|'\\n')+ ;";
-		String found = execLexer("L.g4", grammar, "L", "x 0 1 a.b a.l");
-		String expecting =
-			"[@0,0:0='x',<5>,1:0]\n" +
-			"[@1,1:1=' ',<6>,1:1]\n" +
-			"[@2,2:2='0',<2>,1:2]\n" +
-			"[@3,3:3=' ',<6>,1:3]\n" +
-			"[@4,4:4='1',<2>,1:4]\n" +
-			"[@5,5:5=' ',<6>,1:5]\n" +
-			"[@6,6:6='a',<5>,1:6]\n" +
-			"[@7,7:7='.',<4>,1:7]\n" +
-			"[@8,8:8='b',<5>,1:8]\n" +
-			"[@9,9:9=' ',<6>,1:9]\n" +
-			"[@10,10:10='a',<5>,1:10]\n" +
-			"[@11,11:11='.',<4>,1:11]\n" +
-			"[@12,12:12='l',<5>,1:12]\n" +
-			"[@13,13:12='<EOF>',<-1>,1:13]\n";
-		assertEquals(expecting, found);
-	}
-
-	// must get DONE EOF
-	@Test public void testEOFByItself() throws Exception {
-		String grammar =
-			"lexer grammar L;\n" +
-			"DONE : EOF ;\n" +
-			"A : 'a';\n";
-		String found = execLexer("L.g4", grammar, "L", "");
-		String expecting =
-			"[@0,0:-1='<EOF>',<1>,1:0]\n" +
-			"[@1,0:-1='<EOF>',<-1>,1:0]\n";
-		assertEquals(expecting, found);
-	}
-
-	@Test public void testEOFSuffixInFirstRule() throws Exception {
-		String grammar =
-			"lexer grammar L;\n"+
-			"A : 'a' EOF ;\n"+
-			"B : 'a';\n"+
-			"C : 'c';\n";
-		String found = execLexer("L.g4", grammar, "L", "");
-		String expecting =
-			"[@0,0:-1='<EOF>',<-1>,1:0]\n";
-		assertEquals(expecting, found);
-
-		found = execLexer("L.g4", grammar, "L", "a");
-		expecting =
-			"[@0,0:0='a',<1>,1:0]\n" +
-			"[@1,1:0='<EOF>',<-1>,1:1]\n";
-		assertEquals(expecting, found);
-	}
-
-	@Test public void testCharSet() throws Exception {
-		String grammar =
-			"lexer grammar L;\n"+
-			"I : '0'..'9'+ {System.out.println(\"I\");} ;\n"+
-			"WS : [ \\n\\u000D] -> skip ;";
-		String found = execLexer("L.g4", grammar, "L", "34\r\n 34");
-		String expecting =
-			"I\n" +
-			"I\n" +
-			"[@0,0:1='34',<1>,1:0]\n" +
-			"[@1,5:6='34',<1>,2:1]\n" +
-			"[@2,7:6='<EOF>',<-1>,2:3]\n";
-		assertEquals(expecting, found);
-	}
-
-	@Test public void testCharSetPlus() throws Exception {
-		String grammar =
-			"lexer grammar L;\n"+
-			"I : '0'..'9'+ {System.out.println(\"I\");} ;\n"+
-			"WS : [ \\n\\u000D]+ -> skip ;";
-		String found = execLexer("L.g4", grammar, "L", "34\r\n 34");
-		String expecting =
-			"I\n" +
-			"I\n" +
-			"[@0,0:1='34',<1>,1:0]\n" +
-			"[@1,5:6='34',<1>,2:1]\n" +
-			"[@2,7:6='<EOF>',<-1>,2:3]\n";
-		assertEquals(expecting, found);
-	}
-
-	@Test public void testCharSetNot() throws Exception {
-		String grammar =
-			"lexer grammar L;\n"+
-			"I : ~[ab \\n] ~[ \\ncd]* {System.out.println(\"I\");} ;\n"+
-			"WS : [ \\n\\u000D]+ -> skip ;";
-		String found = execLexer("L.g4", grammar, "L", "xaf");
-		String expecting =
-			"I\n" +
-			"[@0,0:2='xaf',<1>,1:0]\n" +
-			"[@1,3:2='<EOF>',<-1>,1:3]\n";
-		assertEquals(expecting, found);
-	}
-
-	@Test public void testCharSetInSet() throws Exception {
-		String grammar =
-			"lexer grammar L;\n"+
-			"I : (~[ab \\n]|'a') {System.out.println(\"I\");} ;\n"+
-			"WS : [ \\n\\u000D]+ -> skip ;";
-		String found = execLexer("L.g4", grammar, "L", "a x");
-		String expecting =
-			"I\n" +
-			"I\n" +
-			"[@0,0:0='a',<1>,1:0]\n" +
-			"[@1,2:2='x',<1>,1:2]\n" +
-			"[@2,3:2='<EOF>',<-1>,1:3]\n";
-		assertEquals(expecting, found);
-	}
-
-	@Test public void testCharSetRange() throws Exception {
-		String grammar =
-			"lexer grammar L;\n"+
-			"I : [0-9]+ {System.out.println(\"I\");} ;\n"+
-			"ID : [a-zA-Z] [a-zA-Z0-9]* {System.out.println(\"ID\");} ;\n"+
-			"WS : [ \\n\\u0009\\r]+ -> skip ;";
-		String found = execLexer("L.g4", grammar, "L", "34\r 34 a2 abc \n   ");
-		String expecting =
-			"I\n" +
-			"I\n" +
-			"ID\n" +
-			"ID\n" +
-			"[@0,0:1='34',<1>,1:0]\n" +
-			"[@1,4:5='34',<1>,1:4]\n" +
-			"[@2,7:8='a2',<2>,1:7]\n" +
-			"[@3,10:12='abc',<2>,1:10]\n" +
-			"[@4,18:17='<EOF>',<-1>,2:3]\n";
-		assertEquals(expecting, found);
-	}
-
-	@Test public void testCharSetWithMissingEndRange() throws Exception {
-		String grammar =
-			"lexer grammar L;\n"+
-			"I : [0-]+ {System.out.println(\"I\");} ;\n"+
-			"WS : [ \\n\\u000D]+ -> skip ;";
-		String found = execLexer("L.g4", grammar, "L", "00\r\n");
-		String expecting =
-			"I\n" +
-			"[@0,0:1='00',<1>,1:0]\n" +
-			"[@1,4:3='<EOF>',<-1>,2:0]\n";
-		assertEquals(expecting, found);
-	}
-
-	@Test public void testCharSetWithMissingEscapeChar() throws Exception {
-		String grammar =
-			"lexer grammar L;\n"+
-			"I : [0-9]+ {System.out.println(\"I\");} ;\n"+
-			"WS : [ \\u]+ -> skip ;";
-		String found = execLexer("L.g4", grammar, "L", "34 ");
-		String expecting =
-			"I\n" +
-			"[@0,0:1='34',<1>,1:0]\n" +
-			"[@1,3:2='<EOF>',<-1>,1:3]\n";
-		assertEquals(expecting, found);
-	}
-
-	@Test public void testCharSetWithEscapedChar() throws Exception {
-		String grammar =
-			"lexer grammar L;\n"+
-			"DASHBRACK : [\\-\\]]+ {System.out.println(\"DASHBRACK\");} ;\n"+
-			"WS : [ \\u]+ -> skip ;";
-		String found = execLexer("L.g4", grammar, "L", "- ] ");
-		String expecting =
-			"DASHBRACK\n" +
-			"DASHBRACK\n" +
-			"[@0,0:0='-',<1>,1:0]\n" +
-			"[@1,2:2=']',<1>,1:2]\n" +
-			"[@2,4:3='<EOF>',<-1>,1:4]\n";
-		assertEquals(expecting, found);
-	}
-
-	@Test public void testCharSetWithReversedRange() throws Exception {
-		String grammar =
-			"lexer grammar L;\n"+
-			"A : [z-a9]+ {System.out.println(\"A\");} ;\n"+
-			"WS : [ \\u]+ -> skip ;";
-		String found = execLexer("L.g4", grammar, "L", "9");
-		String expecting =
-			"A\n" +
-			"[@0,0:0='9',<1>,1:0]\n" +
-			"[@1,1:0='<EOF>',<-1>,1:1]\n";
-		assertEquals(expecting, found);
-	}
-
-	@Test public void testCharSetWithQuote() throws Exception {
-		String grammar =
-			"lexer grammar L;\n"+
-			"A : [\"a-z]+ {System.out.println(\"A\");} ;\n"+
-			"WS : [ \\n\\t]+ -> skip ;";
-		String found = execLexer("L.g4", grammar, "L", "b\"a");
-		String expecting =
-			"A\n" +
-			"[@0,0:2='b\"a',<1>,1:0]\n" +
-			"[@1,3:2='<EOF>',<-1>,1:3]\n";
-		assertEquals(expecting, found);
-	}
-
-	@Test public void testCharSetWithQuote2() throws Exception {
-		String grammar =
-			"lexer grammar L;\n"+
-			"A : [\"\\\\ab]+ {System.out.println(\"A\");} ;\n"+
-			"WS : [ \\n\\t]+ -> skip ;";
-		String found = execLexer("L.g4", grammar, "L", "b\"\\a");
-		String expecting =
-			"A\n" +
-			"[@0,0:3='b\"\\a',<1>,1:0]\n" +
-			"[@1,4:3='<EOF>',<-1>,1:4]\n";
-		assertEquals(expecting, found);
-	}
-
-	@Test
-	public void testPositionAdjustingLexer() throws Exception {
-		String grammar = load("PositionAdjustingLexer.g4", null);
-		String input =
-			"tokens\n" +
-			"tokens {\n" +
-			"notLabel\n" +
-			"label1 =\n" +
-			"label2 +=\n" +
-			"notLabel\n";
-		String found = execLexer("PositionAdjustingLexer.g4", grammar, "PositionAdjustingLexer", input);
-
-		final int TOKENS = 4;
-		final int LABEL = 5;
-		final int IDENTIFIER = 6;
-		String expecting =
-			"[@0,0:5='tokens',<" + IDENTIFIER + ">,1:0]\n" +
-			"[@1,7:12='tokens',<" + TOKENS + ">,2:0]\n" +
-			"[@2,14:14='{',<3>,2:7]\n" +
-			"[@3,16:23='notLabel',<" + IDENTIFIER + ">,3:0]\n" +
-			"[@4,25:30='label1',<" + LABEL + ">,4:0]\n" +
-			"[@5,32:32='=',<1>,4:7]\n" +
-			"[@6,34:39='label2',<" + LABEL + ">,5:0]\n" +
-			"[@7,41:42='+=',<2>,5:7]\n" +
-			"[@8,44:51='notLabel',<" + IDENTIFIER + ">,6:0]\n" +
-			"[@9,53:52='<EOF>',<-1>,7:0]\n";
-
-		assertEquals(expecting, found);
-	}
-
-	/**
-	 * This is a regression test for antlr/antlr4#76 "Serialized ATN strings
-	 * should be split when longer than 2^16 bytes (class file limitation)"
-	 * https://github.com/antlr/antlr4/issues/76
-	 */
-	@Test
-	public void testLargeLexer() throws Exception {
-		StringBuilder grammar = new StringBuilder();
-		grammar.append("lexer grammar L;\n");
-		grammar.append("WS : [ \\t\\r\\n]+ -> skip;\n");
-		for (int i = 0; i < 4000; i++) {
-			grammar.append("KW").append(i).append(" : '").append("KW").append(i).append("';\n");
-		}
-
-		String input = "KW400";
-		String found = execLexer("L.g4", grammar.toString(), "L", input);
-		String expecting =
-			"[@0,0:4='KW400',<402>,1:0]\n" +
-			"[@1,5:4='<EOF>',<-1>,1:5]\n";
-		assertEquals(expecting, found);
-	}
-
-	protected String load(String fileName, @Nullable String encoding)
-		throws IOException
-	{
-		if ( fileName==null ) {
-			return null;
-		}
-
-		String fullFileName = getClass().getPackage().getName().replace('.', '/') + '/' + fileName;
-		int size = 65000;
-		InputStreamReader isr;
-		InputStream fis = getClass().getClassLoader().getResourceAsStream(fullFileName);
-		if ( encoding!=null ) {
-			isr = new InputStreamReader(fis, encoding);
-		}
-		else {
-			isr = new InputStreamReader(fis);
-		}
-		try {
-			char[] data = new char[size];
-			int n = isr.read(data);
-			return new String(data, 0, n);
-		}
-		finally {
-			isr.close();
-		}
-	}
-}
diff --git a/tool/test/org/antlr/v4/test/TestListeners.java b/tool/test/org/antlr/v4/test/TestListeners.java
deleted file mode 100644
index 710cd4c65..000000000
--- a/tool/test/org/antlr/v4/test/TestListeners.java
+++ /dev/null
@@ -1,226 +0,0 @@
-/*
- * [The "BSD license"]
- *  Copyright (c) 2012 Terence Parr
- *  Copyright (c) 2012 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.
- */
-
-package org.antlr.v4.test;
-
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-public class TestListeners extends BaseTest {
-	@Test public void testBasic() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"@header {import org.antlr.v4.runtime.tree.*;}\n"+
-			"@members {\n" +
-			"public static class LeafListener extends TBaseListener {\n" +
-			"    public void visitTerminal(TerminalNode node) {\n" +
-			"      System.out.println(node.getSymbol().getText());\n" +
-			"    }\n" +
-			"  }}\n" +
-			"s\n" +
-			"@after {" +
-			"  System.out.println($r.ctx.toStringTree(this));" +
-			"  ParseTreeWalker walker = new ParseTreeWalker();\n" +
-			"  walker.walk(new LeafListener(), $r.ctx);" +
-			"}\n" +
-			"  : r=a ;\n" +
-			"a : INT INT" +
-			"  | ID" +
-			"  ;\n" +
-			"MULT: '*' ;\n" +
-			"ADD : '+' ;\n" +
-			"INT : [0-9]+ ;\n" +
-			"ID  : [a-z]+ ;\n" +
-			"WS : [ \\t\\n]+ -> skip ;\n";
-		String result = execParser("T.g4", grammar, "TParser", "TLexer", "s", "1 2", false);
-		String expecting = "(a 1 2)\n" +
-						   "1\n" +
-						   "2\n";
-		assertEquals(expecting, result);
-	}
-
-	@Test public void testTokenGetters() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"@members {\n" +
-			"public static class LeafListener extends TBaseListener {\n" +
-			"    public void exitA(TParser.AContext ctx) {\n" +
-			"      if (ctx.getChildCount()==2) System.out.printf(\"%s %s %s\",ctx.INT(0).getSymbol().getText(),ctx.INT(1).getSymbol().getText(),ctx.INT());\n" +
-			"      else System.out.println(ctx.ID().getSymbol());\n" +
-			"    }\n" +
-			"  }}\n" +
-			"s\n" +
-			"@after {" +
-			"  System.out.println($r.ctx.toStringTree(this));" +
-			"  ParseTreeWalker walker = new ParseTreeWalker();\n" +
-			"  walker.walk(new LeafListener(), $r.ctx);" +
-			"}\n" +
-			"  : r=a ;\n" +
-			"a : INT INT" +
-			"  | ID" +
-			"  ;\n" +
-			"MULT: '*' ;\n" +
-			"ADD : '+' ;\n" +
-			"INT : [0-9]+ ;\n" +
-			"ID  : [a-z]+ ;\n" +
-			"WS : [ \\t\\n]+ -> skip ;\n";
-		String result = execParser("T.g4", grammar, "TParser", "TLexer", "s", "1 2", false);
-		String expecting =
-			"(a 1 2)\n" +
-			"1 2 [1, 2]\n";
-		assertEquals(expecting, result);
-
-		result = execParser("T.g4", grammar, "TParser", "TLexer", "s", "abc", false);
-		expecting = "(a abc)\n" +
-					"[@0,0:2='abc',<4>,1:0]\n";
-		assertEquals(expecting, result);
-	}
-
-	@Test public void testRuleGetters() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"@members {\n" +
-			"public static class LeafListener extends TBaseListener {\n" +
-			"    public void exitA(TParser.AContext ctx) {\n" +
-			"      if (ctx.getChildCount()==2) {\n" +
-			"        System.out.printf(\"%s %s %s\",ctx.b(0).start.getText(),\n" +
-			"                          ctx.b(1).start.getText(),ctx.b().get(0).start.getText());\n" +
-			"      }\n" +
-			"      else System.out.println(ctx.b(0).start.getText());\n" +
-			"    }\n" +
-			"  }}\n" +
-			"s\n" +
-			"@after {" +
-			"  System.out.println($r.ctx.toStringTree(this));" +
-			"  ParseTreeWalker walker = new ParseTreeWalker();\n" +
-			"  walker.walk(new LeafListener(), $r.ctx);" +
-			"}\n" +
-			"  : r=a ;\n" +
-			"a : b b" +		// forces list
-			"  | b" +		// a list still
-			"  ;\n" +
-			"b : ID | INT ;\n" +
-			"MULT: '*' ;\n" +
-			"ADD : '+' ;\n" +
-			"INT : [0-9]+ ;\n" +
-			"ID  : [a-z]+ ;\n" +
-			"WS : [ \\t\\n]+ -> skip ;\n";
-		String result = execParser("T.g4", grammar, "TParser", "TLexer", "s", "1 2", false);
-		String expecting = "(a (b 1) (b 2))\n" +
-						   "1 2 1\n";
-		assertEquals(expecting, result);
-
-		result = execParser("T.g4", grammar, "TParser", "TLexer", "s", "abc", false);
-		expecting = "(a (b abc))\n" +
-					"abc\n";
-		assertEquals(expecting, result);
-	}
-
-	@Test public void testLR() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"@members {\n" +
-			"public static class LeafListener extends TBaseListener {\n" +
-			"    public void exitE(TParser.EContext ctx) {\n" +
-			"      if (ctx.getChildCount()==3) {\n" +
-			"        System.out.printf(\"%s %s %s\\n\",ctx.e(0).start.getText(),\n" +
-			"                          ctx.e(1).start.getText()," +
-			"                          ctx.e().get(0).start.getText());\n" +
-			"      }\n" +
-			"      else System.out.println(ctx.INT().getSymbol().getText());\n" +
-			"    }\n" +
-			"  }" +
-			"}\n" +
-			"s\n" +
-			"@after {" +
-			"  System.out.println($r.ctx.toStringTree(this));" +
-			"  ParseTreeWalker walker = new ParseTreeWalker();\n" +
-			"  walker.walk(new LeafListener(), $r.ctx);" +
-			"}\n" +
-			"  : r=e ;\n" +
-			"e : e op='*' e\n" +
-			"  | e op='+' e\n" +
-			"  | INT\n" +
-			"  ;\n" +
-			"MULT: '*' ;\n" +
-			"ADD : '+' ;\n" +
-			"INT : [0-9]+ ;\n" +
-			"WS : [ \\t\\n]+ -> skip ;\n";
-		String result = execParser("T.g4", grammar, "TParser", "TLexer", "s", "1+2*3", false);
-		String expecting =
-			"(e (e 1) + (e (e 2) * (e 3)))\n" +
-			"1\n" +
-			"2\n" +
-			"3\n" +
-			"2 3 2\n" +
-			"1 2 1\n";
-		assertEquals(expecting, result);
-	}
-
-	@Test public void testLRWithLabels() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"@members {\n" +
-			"  public static class LeafListener extends TBaseListener {\n" +
-			"    public void exitCall(TParser.CallContext ctx) {\n" +
-			"      System.out.printf(\"%s %s\",ctx.e().start.getText(),\n" +
-			"                ctx.eList());\n" +
-			"    }\n" +
-			"    public void exitInt(TParser.IntContext ctx) {\n" +
-			"      System.out.println(ctx.INT().getSymbol().getText());\n" +
-			"    }\n" +
-			"  }\n" +
-			"}\n" +
-			"s\n" +
-			"@after {" +
-			"  System.out.println($r.ctx.toStringTree(this));" +
-			"  ParseTreeWalker walker = new ParseTreeWalker();\n" +
-			"  walker.walk(new LeafListener(), $r.ctx);" +
-			"}\n" +
-			"  : r=e ;\n" +
-			"e : e '(' eList ')' # Call\n" +
-			"  | INT             # Int\n" +
-			"  ;     \n" +
-			"eList : e (',' e)* ;\n" +
-			"MULT: '*' ;\n" +
-			"ADD : '+' ;\n" +
-			"INT : [0-9]+ ;\n" +
-			"WS : [ \\t\\n]+ -> skip ;\n";
-		String result = execParser("T.g4", grammar, "TParser", "TLexer", "s", "1(2,3)", false);
-		String expecting =
-			"(e (e 1) ( (eList (e 2) , (e 3)) ))\n" +
-			"1\n" +
-			"2\n" +
-			"3\n" +
-			"1 [13 6]\n";
-		assertEquals(expecting, result);
-	}
-}
diff --git a/tool/test/org/antlr/v4/test/TestParseErrors.java b/tool/test/org/antlr/v4/test/TestParseErrors.java
deleted file mode 100644
index c4af68c9c..000000000
--- a/tool/test/org/antlr/v4/test/TestParseErrors.java
+++ /dev/null
@@ -1,388 +0,0 @@
-/*
- * [The "BSD license"]
- *  Copyright (c) 2012 Terence Parr
- *  Copyright (c) 2012 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.
- */
-
-package org.antlr.v4.test;
-
-import org.antlr.v4.runtime.atn.ATNSerializer;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-/** test runtime parse errors */
-public class TestParseErrors extends BaseTest {
-	@Test public void testTokenMismatch() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"a : 'a' 'b' ;";
-		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", "aa", false);
-		String expecting = "line 1:1 mismatched input 'a' expecting 'b'\n";
-		String result = stderrDuringParse;
-		assertEquals(expecting, result);
-	}
-
-	@Test public void testSingleTokenDeletion() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"a : 'a' 'b' ;";
-		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", "aab", false);
-		String expecting = "line 1:1 extraneous input 'a' expecting 'b'\n";
-		String result = stderrDuringParse;
-		assertEquals(expecting, result);
-	}
-
-	@Test public void testSingleTokenDeletionExpectingSet() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"a : 'a' ('b'|'c') ;";
-		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", "aab", false);
-		String expecting = "line 1:1 extraneous input 'a' expecting {'b', 'c'}\n";
-		String result = stderrDuringParse;
-		assertEquals(expecting, result);
-	}
-
-	@Test public void testSingleTokenInsertion() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"a : 'a' 'b' 'c' ;";
-		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", "ac", false);
-		String expecting = "line 1:1 missing 'b' at 'c'\n";
-		String result = stderrDuringParse;
-		assertEquals(expecting, result);
-	}
-
-	@Test public void testConjuringUpToken() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"a : 'a' x='b' {System.out.println(\"conjured=\"+$x);} 'c' ;";
-		String result = execParser("T.g4", grammar, "TParser", "TLexer", "a", "ac", false);
-		String expecting = "conjured=[@-1,-1:-1='<missing 'b'>',<1>,1:1]\n";
-		assertEquals(expecting, result);
-	}
-
-	@Test public void testSingleSetInsertion() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"a : 'a' ('b'|'c') 'd' ;";
-		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", "ad", false);
-		String expecting = "line 1:1 missing {'b', 'c'} at 'd'\n";
-		String result = stderrDuringParse;
-		assertEquals(expecting, result);
-	}
-
-	@Test public void testConjuringUpTokenFromSet() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"a : 'a' x=('b'|'c') {System.out.println(\"conjured=\"+$x);} 'd' ;";
-		String result = execParser("T.g4", grammar, "TParser", "TLexer", "a", "ad", false);
-		String expecting = "conjured=[@-1,-1:-1='<missing 'b'>',<1>,1:1]\n";
-		assertEquals(expecting, result);
-	}
-
-	@Test public void testLL2() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"a : 'a' 'b'" +
-			"  | 'a' 'c'" +
-			";\n" +
-			"q : 'e' ;\n";
-		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", "ae", false);
-		String expecting = "line 1:1 no viable alternative at input 'ae'\n";
-		String result = stderrDuringParse;
-		assertEquals(expecting, result);
-	}
-
-	@Test public void testLL3() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"a : 'a' 'b'* 'c'" +
-			"  | 'a' 'b' 'd'" +
-			"  ;\n" +
-			"q : 'e' ;\n";
-		System.out.println(grammar);
-		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", "abe", false);
-		String expecting = "line 1:2 no viable alternative at input 'abe'\n";
-		String result = stderrDuringParse;
-		assertEquals(expecting, result);
-	}
-
-	@Test public void testLLStar() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"a : 'a'+ 'b'" +
-			"  | 'a'+ 'c'" +
-			";\n" +
-			"q : 'e' ;\n";
-		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", "aaae", false);
-		String expecting = "line 1:3 no viable alternative at input 'aaae'\n";
-		String result = stderrDuringParse;
-		assertEquals(expecting, result);
-	}
-
-	@Test public void testSingleTokenDeletionBeforeLoop() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"a : 'a' 'b'*;";
-		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", "aabc", false);
-		String expecting = "line 1:1 extraneous input 'a' expecting {<EOF>, 'b'}\n" +
-			"line 1:3 token recognition error at: 'c'\n";
-		String result = stderrDuringParse;
-		assertEquals(expecting, result);
-	}
-
-	@Test public void testMultiTokenDeletionBeforeLoop() throws Exception {
-		// can only delete 1 before loop
-		String grammar =
-			"grammar T;\n" +
-			"a : 'a' 'b'* 'c';";
-		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", "aacabc", false);
-		String expecting =
-			"line 1:1 extraneous input 'a' expecting {'b', 'c'}\n";
-		String result = stderrDuringParse;
-		assertEquals(expecting, result);
-	}
-
-	@Test public void testSingleTokenDeletionDuringLoop() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"a : 'a' 'b'* 'c' ;";
-		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", "ababbc", false);
-		String expecting = "line 1:2 extraneous input 'a' expecting {'b', 'c'}\n";
-		String result = stderrDuringParse;
-		assertEquals(expecting, result);
-	}
-
-	@Test public void testMultiTokenDeletionDuringLoop() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"a : 'a' 'b'* 'c' ;";
-		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", "abaaababc", false);
-		String expecting =
-				"line 1:2 extraneous input 'a' expecting {'b', 'c'}\n" +
-				"line 1:6 extraneous input 'a' expecting {'b', 'c'}\n";
-		String result = stderrDuringParse;
-		assertEquals(expecting, result);
-	}
-
-	// ------
-
-	@Test public void testSingleTokenDeletionBeforeLoop2() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"a : 'a' ('b'|'z'{;})*;";
-		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", "aabc", false);
-		String expecting = "line 1:1 extraneous input 'a' expecting {<EOF>, 'b', 'z'}\n" +
-			"line 1:3 token recognition error at: 'c'\n";
-		String result = stderrDuringParse;
-		assertEquals(expecting, result);
-	}
-
-	@Test public void testMultiTokenDeletionBeforeLoop2() throws Exception {
-		// can only delete 1 before loop
-		String grammar =
-			"grammar T;\n" +
-			"a : 'a' ('b'|'z'{;})* 'c';";
-		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", "aacabc", false);
-		String expecting =
-			"line 1:1 extraneous input 'a' expecting {'b', 'z', 'c'}\n";
-		String result = stderrDuringParse;
-		assertEquals(expecting, result);
-	}
-
-	@Test public void testSingleTokenDeletionDuringLoop2() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"a : 'a' ('b'|'z'{;})* 'c' ;";
-		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", "ababbc", false);
-		String expecting = "line 1:2 extraneous input 'a' expecting {'b', 'z', 'c'}\n";
-		String result = stderrDuringParse;
-		assertEquals(expecting, result);
-	}
-
-	@Test public void testMultiTokenDeletionDuringLoop2() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"a : 'a' ('b'|'z'{;})* 'c' ;";
-		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a", "abaaababc", false);
-		String expecting =
-				"line 1:2 extraneous input 'a' expecting {'b', 'z', 'c'}\n" +
-				"line 1:6 extraneous input 'a' expecting {'b', 'z', 'c'}\n";
-		String result = stderrDuringParse;
-		assertEquals(expecting, result);
-	}
-
-	@Test public void testLL1ErrorInfo() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"start : animal (AND acClass)? service EOF;\n" +
-			"animal : (DOG | CAT );\n" +
-			"service : (HARDWARE | SOFTWARE) ;\n" +
-			"AND : 'and';\n" +
-			"DOG : 'dog';\n" +
-			"CAT : 'cat';\n" +
-			"HARDWARE: 'hardware';\n" +
-			"SOFTWARE: 'software';\n" +
-			"WS : ' ' -> skip ;" +
-			"acClass\n" +
-			"@init\n" +
-			"{ System.out.println(getExpectedTokens().toString(tokenNames)); }\n" +
-			"  : ;\n";
-		String result = execParser("T.g4", grammar, "TParser", "TLexer", "start", "dog and software", false);
-		String expecting = "{'hardware', 'software'}\n";
-		assertEquals(expecting, result);
-	}
-
-	/**
-	 * This is a regression test for #6 "NullPointerException in getMissingSymbol".
-	 * https://github.com/antlr/antlr4/issues/6
-	 */
-	@Test
-	public void testInvalidEmptyInput() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"start : ID+;\n" +
-			"ID : [a-z]+;\n" +
-			"\n";
-		String result = execParser("T.g4", grammar, "TParser", "TLexer", "start", "", true);
-		String expecting = "";
-		assertEquals(expecting, result);
-		assertEquals("line 1:0 missing ID at '<EOF>'\n", this.stderrDuringParse);
-	}
-
-	/**
-	 * Regression test for "Getter for context is not a list when it should be".
-	 * https://github.com/antlr/antlr4/issues/19
-	 */
-	@Test
-	public void testContextListGetters() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"@parser::members{\n" +
-			"  void foo() {\n" +
-			"    SContext s = null;\n" +
-			"    List<? extends AContext> a = s.a();\n" +
-			"    List<? extends BContext> b = s.b();\n" +
-			"  }\n" +
-			"}\n" +
-			"s : (a | b)+;\n" +
-			"a : 'a' {System.out.print('a');};\n" +
-			"b : 'b' {System.out.print('b');};\n" +
-			"";
-		String result = execParser("T.g", grammar, "TParser", "TLexer", "s", "abab", true);
-		String expecting = "abab\n";
-		assertEquals(expecting, result);
-		assertNull(this.stderrDuringParse);
-	}
-
-	/**
-	 * This is a regression test for #26 "an exception upon simple rule with double recursion in an alternative".
-	 * https://github.com/antlr/antlr4/issues/26
-	 */
-	@Test
-	public void testDuplicatedLeftRecursiveCall() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"start : expr EOF;\n" +
-			"expr : 'x'\n" +
-			"     | expr expr\n" +
-			"     ;\n" +
-			"\n";
-
-		String result = execParser("T.g4", grammar, "TParser", "TLexer", "start", "x", true);
-		assertEquals("", result);
-		assertNull(this.stderrDuringParse);
-
-		result = execParser("T.g4", grammar, "TParser", "TLexer", "start", "xx", true);
-		assertEquals("", result);
-		assertEquals(
-			"line 1:1 reportAttemptingFullContext d=0 (expr), input='x'\n" +
-			"line 1:1 reportContextSensitivity d=0 (expr), input='x'\n",
-			this.stderrDuringParse);
-
-		result = execParser("T.g4", grammar, "TParser", "TLexer", "start", "xxx", true);
-		assertEquals("", result);
-		assertEquals(
-			"line 1:1 reportAttemptingFullContext d=0 (expr), input='x'\n" +
-			"line 1:1 reportContextSensitivity d=0 (expr), input='x'\n" +
-			"line 1:2 reportAttemptingFullContext d=0 (expr), input='x'\n",
-			this.stderrDuringParse);
-
-		result = execParser("T.g4", grammar, "TParser", "TLexer", "start", "xxxx", true);
-		assertEquals("", result);
-		assertEquals(
-			"line 1:1 reportAttemptingFullContext d=0 (expr), input='x'\n" +
-			"line 1:1 reportContextSensitivity d=0 (expr), input='x'\n" +
-			"line 1:2 reportAttemptingFullContext d=0 (expr), input='x'\n" +
-			"line 1:3 reportAttemptingFullContext d=0 (expr), input='x'\n",
-			this.stderrDuringParse);
-	}
-
-	/**
-	 * This is a regression test for #45 "NullPointerException in ATNConfig.hashCode".
-	 * https://github.com/antlr/antlr4/issues/45
-	 * <p/>
-	 * The original cause of this issue was an error in the tool's ATN state optimization,
-	 * which is now detected early in {@link ATNSerializer} by ensuring that all
-	 * serialized transitions point to states which were not removed.
-	 */
-	@Test
-	public void testInvalidATNStateRemoval() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"start : ID ':' expr;\n" +
-			"expr : primary expr? {} | expr '->' ID;\n" +
-			"primary : ID;\n" +
-			"ID : [a-z]+;\n" +
-			"\n";
-		String result = execParser("T.g4", grammar, "TParser", "TLexer", "start", "x:x", true);
-		String expecting = "";
-		assertEquals(expecting, result);
-		assertNull(this.stderrDuringParse);
-	}
-
-	@Test public void testNoViableAltAvoidance() throws Exception {
-		// "a." matches 'a' to rule e but then realizes '.' won't match.
-		// previously would cause noviablealt. now prediction pretends to
-		// have "a' predict 2nd alt of e. Will get syntax error later so
-		// let it get farther.
-		String grammar =
-			"grammar T;\n" +
-			"s : e '!' ;\n" +
-			"e : 'a' 'b'\n" +
-			"  | 'a'\n" +
-			"  ;\n" +
-			"DOT : '.' ;\n" +
-			"WS : [ \\t\\r\\n]+ -> skip;\n";
-		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s", "a.", false);
-		String expecting =
-				"line 1:1 mismatched input '.' expecting '!'\n";
-		String result = stderrDuringParse;
-		assertEquals(expecting, result);
-	}
-}
diff --git a/tool/test/org/antlr/v4/test/TestParseTrees.java b/tool/test/org/antlr/v4/test/TestParseTrees.java
deleted file mode 100644
index 0fa017d14..000000000
--- a/tool/test/org/antlr/v4/test/TestParseTrees.java
+++ /dev/null
@@ -1,154 +0,0 @@
-/*
- * [The "BSD license"]
- *  Copyright (c) 2012 Terence Parr
- *  Copyright (c) 2012 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.
- */
-
-package org.antlr.v4.test;
-
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-public class TestParseTrees extends BaseTest {
-	@Test public void testTokenAndRuleContextString() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"s\n" +
-			"@init {setBuildParseTree(true);}\n" +
-			"@after {System.out.println($r.ctx.toStringTree(this));}\n" +
-			"  :r=a ;\n" +
-			"a : 'x' {System.out.println(getRuleInvocationStack());} ;\n";
-		String result = execParser("T.g4", grammar, "TParser", "TLexer", "s", "x", false);
-		String expecting = "[a, s]\n(a x)\n";
-		assertEquals(expecting, result);
-	}
-
-	@Test public void testToken2() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"s\n" +
-			"@init {setBuildParseTree(true);}\n" +
-			"@after {System.out.println($r.ctx.toStringTree(this));}\n" +
-			"  :r=a ;\n" +
-			"a : 'x' 'y'\n" +
-			"  ;\n";
-		String result = execParser("T.g4", grammar, "TParser", "TLexer", "s", "xy", false);
-		String expecting = "(a x y)\n";
-		assertEquals(expecting, result);
-	}
-
-	@Test public void test2Alts() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"s\n" +
-			"@init {setBuildParseTree(true);}\n" +
-			"@after {System.out.println($r.ctx.toStringTree(this));}\n" +
-			"  :r=a ;\n" +
-			"a : 'x' | 'y'\n" +
-			"  ;\n";
-		String result = execParser("T.g4", grammar, "TParser", "TLexer", "s", "y", false);
-		String expecting = "(a y)\n";
-		assertEquals(expecting, result);
-	}
-
-	@Test public void test2AltLoop() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"s\n" +
-			"@init {setBuildParseTree(true);}\n" +
-			"@after {System.out.println($r.ctx.toStringTree(this));}\n" +
-			"  :r=a ;\n" +
-			"a : ('x' | 'y')* 'z'\n" +
-			"  ;\n";
-		String result = execParser("T.g4", grammar, "TParser", "TLexer", "s", "xyyxyxz", false);
-		String expecting = "(a x y y x y x z)\n";
-		assertEquals(expecting, result);
-	}
-
-	@Test public void testRuleRef() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"s\n" +
-			"@init {setBuildParseTree(true);}\n" +
-			"@after {System.out.println($r.ctx.toStringTree(this));}\n" +
-			"  : r=a ;\n" +
-			"a : b 'x'\n" +
-			"  ;\n" +
-			"b : 'y' ;\n";
-		String result = execParser("T.g4", grammar, "TParser", "TLexer", "s", "yx", false);
-		String expecting = "(a (b y) x)\n";
-		assertEquals(expecting, result);
-	}
-
-	// ERRORS
-
-	@Test public void testExtraToken() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"s\n" +
-			"@init {setBuildParseTree(true);}\n" +
-			"@after {System.out.println($r.ctx.toStringTree(this));}\n" +
-			"  : r=a ;\n" +
-			"a : 'x' 'y'\n" +
-			"  ;\n" +
-			"Z : 'z'; \n";
-		String result = execParser("T.g4", grammar, "TParser", "TLexer", "s", "xzy", false);
-		String expecting = "(a x z y)\n"; // ERRORs not shown. z is colored red in tree view
-		assertEquals(expecting, result);
-	}
-
-	@Test public void testNoViableAlt() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"s\n" +
-			"@init {setBuildParseTree(true);}\n" +
-			"@after {System.out.println($r.ctx.toStringTree(this));}\n" +
-			"  : r=a ;\n" +
-			"a : 'x' | 'y'\n" +
-			"  ;\n" +
-			"Z : 'z'; \n";
-		String result = execParser("T.g4", grammar, "TParser", "TLexer", "s", "z", false);
-		String expecting = "(a z)\n";
-		assertEquals(expecting, result);
-	}
-
-	@Test public void testSync() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"s\n" +
-			"@init {setBuildParseTree(true);}\n" +
-			"@after {System.out.println($r.ctx.toStringTree(this));}\n" +
-			"  : r=a ;\n" +
-			"a : 'x' 'y'* '!'\n" +
-			"  ;\n" +
-			"Z : 'z'; \n";
-		String result = execParser("T.g4", grammar, "TParser", "TLexer", "s", "xzyy!", false);
-		String expecting = "(a x z y y !)\n";
-		assertEquals(expecting, result);
-	}
-}
diff --git a/tool/test/org/antlr/v4/test/TestParserExec.java b/tool/test/org/antlr/v4/test/TestParserExec.java
deleted file mode 100644
index ab5dff89e..000000000
--- a/tool/test/org/antlr/v4/test/TestParserExec.java
+++ /dev/null
@@ -1,380 +0,0 @@
-/*
- * [The "BSD license"]
- *  Copyright (c) 2012 Terence Parr
- *  Copyright (c) 2012 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.
- */
-
-package org.antlr.v4.test;
-
-import org.junit.Ignore;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-/** Test parser execution.
- *
- *  For the non-greedy stuff, the rule is that .* or any other non-greedy loop
- *  (any + or * loop that has an alternative with '.' in it is automatically
- *  non-greedy) never sees past the end of the rule containing that loop.
- *  There is no automatic way to detect when the exit branch of a non-greedy
- *  loop has seen enough input to determine how much the loop should consume
- *  yet still allow matching the entire input. Of course, this is extremely
- *  inefficient, particularly for things like
- *
- *     block : '{' (block|.)* '}' ;
- *
- *  that need only see one symbol to know when it hits a '}'. So, I
- *  came up with a practical solution.  During prediction, the ATN
- *  simulator never fall off the end of a rule to compute the global
- *  FOLLOW. Instead, we terminate the loop, choosing the exit branch.
- *  Otherwise, we predict to reenter the loop.  For example, input
- *  "{ foo }" will allow the loop to match foo, but that's it. During
- *  prediction, the ATN simulator will see that '}' reaches the end of a
- *  rule that contains a non-greedy loop and stop prediction. It will choose
- *  the exit branch of the inner loop. So, the way in which you construct
- *  the rule containing a non-greedy loop dictates how far it will scan ahead.
- *  Include everything after the non-greedy loop that you know it must scan
- *  in order to properly make a prediction decision. these beasts are tricky,
- *  so be careful. don't liberally sprinkle them around your code.
- *
- *  To simulate filter mode, use ( .* (pattern1|pattern2|...) )*
- *
- *  Nongreedy loops match as much input as possible while still allowing
- *  the remaining input to match.
- */
-public class TestParserExec extends BaseTest {
-	@Test public void testLabels() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"a : b1=b b2+=b* b3+=';' ;\n" +
-			"b : id=ID val+=INT*;\n" +
-			"ID : 'a'..'z'+ ;\n" +
-			"INT : '0'..'9'+;\n" +
-			"WS : (' '|'\\n') -> skip ;\n";
-
-		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a",
-								  "abc 34;", false);
-		assertEquals("", found);
-		assertEquals(null, stderrDuringParse);
-	}
-
-	/**
-	 * This is a regression test for #270 "Fix operator += applied to a set of
-	 * tokens".
-	 * https://github.com/antlr/antlr4/issues/270
-	 */
-	@Test public void testListLabelOnSet() {
-		String grammar =
-			"grammar T;\n" +
-			"a : b b* ';' ;\n" +
-			"b : ID val+=(INT | FLOAT)*;\n" +
-			"ID : 'a'..'z'+ ;\n" +
-			"INT : '0'..'9'+;\n" +
-			"FLOAT : [0-9]+ '.' [0-9]+;\n" +
-			"WS : (' '|'\\n') -> skip ;\n";
-
-		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a",
-								  "abc 34;", false);
-		assertEquals("", found);
-		assertEquals(null, stderrDuringParse);
-	}
-
-	@Test public void testBasic() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"a : ID INT {System.out.println($text);} ;\n" +
-			"ID : 'a'..'z'+ ;\n" +
-			"INT : '0'..'9'+;\n" +
-			"WS : (' '|'\\n') -> skip ;\n";
-
-		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a",
-								  "abc 34", false);
-		assertEquals("abc34\n", found);
-	}
-
-	@Test public void testAorB() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"a : ID {System.out.println(\" alt 1\");}" +
-			"  | INT {System.out.println(\"alt 2\");}" +
-				";\n" +
-			"ID : 'a'..'z'+ ;\n" +
-			"INT : '0'..'9'+;\n" +
-			"WS : (' '|'\\n') -> skip ;\n";
-
-		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a",
-								  "34", false);
-		assertEquals("alt 2\n", found);
-	}
-
-	@Test public void testAPlus() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"a : ID+ {System.out.println($text);} ;\n" +
-			"ID : 'a'..'z'+ ;\n" +
-			"WS : (' '|'\\n') -> skip ;\n";
-
-		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a",
-								  "a b c", false);
-		assertEquals("abc\n", found);
-	}
-
-	// force complex decision
-	@Test public void testAorAPlus() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"a : (ID|ID)+ {System.out.println($text);} ;\n" +
-			"ID : 'a'..'z'+ ;\n" +
-			"WS : (' '|'\\n') -> skip ;\n";
-
-		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a",
-								  "a b c", false);
-		assertEquals("abc\n", found);
-	}
-
-	private static final String ifIfElseGrammarFormat =
-		"grammar T;\n" +
-		"start : statement+ ;\n" +
-		"statement : 'x' | ifStatement;\n" +
-		"ifStatement : 'if' 'y' statement %s {System.out.println($text);};\n" +
-		"ID : 'a'..'z'+ ;\n" +
-		"WS : (' '|'\\n') -> channel(HIDDEN);\n";
-
-	@Test public void testIfIfElseGreedyBinding() throws Exception {
-		final String input = "if y if y x else x";
-		final String expectedInnerBound = "if y x else x\nif y if y x else x\n";
-
-		String grammar = String.format(ifIfElseGrammarFormat, "('else' statement)?");
-		String found = execParser("T.g4", grammar, "TParser", "TLexer", "start", input, false);
-		assertEquals(expectedInnerBound, found);
-
-		grammar = String.format(ifIfElseGrammarFormat, "('else' statement|)");
-		found = execParser("T.g4", grammar, "TParser", "TLexer", "start", input, false);
-		assertEquals(expectedInnerBound, found);
-	}
-
-	@Test public void testIfIfElseNonGreedyBinding() throws Exception {
-		final String input = "if y if y x else x";
-		final String expectedOuterBound = "if y x\nif y if y x else x\n";
-
-		String grammar = String.format(ifIfElseGrammarFormat, "('else' statement)??");
-		String found = execParser("T.g4", grammar, "TParser", "TLexer", "start", input, false);
-		assertEquals(expectedOuterBound, found);
-
-		grammar = String.format(ifIfElseGrammarFormat, "(|'else' statement)");
-		found = execParser("T.g4", grammar, "TParser", "TLexer", "start", input, false);
-		assertEquals(expectedOuterBound, found);
-	}
-
-	@Test public void testAStar() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"a : ID* {System.out.println($text);} ;\n" +
-			"ID : 'a'..'z'+ ;\n" +
-			"WS : (' '|'\\n') -> skip ;\n";
-
-		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a",
-								  "", false);
-		assertEquals("\n", found);
-		found = execParser("T.g4", grammar, "TParser", "TLexer", "a",
-								  "a b c", false);
-		assertEquals("abc\n", found);
-	}
-
-	// force complex decision
-	@Test public void testAorAStar() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"a : (ID|ID)* {System.out.println($text);} ;\n" +
-			"ID : 'a'..'z'+ ;\n" +
-			"WS : (' '|'\\n') -> skip ;\n";
-
-		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a",
-								  "", false);
-		assertEquals("\n", found);
-		found = execParser("T.g4", grammar, "TParser", "TLexer", "a",
-								  "a b c", false);
-		assertEquals("abc\n", found);
-	}
-
-	@Test public void testAorBPlus() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"a : (ID|INT{;})+ {System.out.println($text);} ;\n" +
-			"ID : 'a'..'z'+ ;\n" +
-			"INT : '0'..'9'+;\n" +
-			"WS : (' '|'\\n') -> skip ;\n";
-
-		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a",
-								  "a 34 c", false);
-		assertEquals("a34c\n", found);
-	}
-
-	@Test public void testAorBStar() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"a : (ID|INT{;})* {System.out.println($text);} ;\n" +
-			"ID : 'a'..'z'+ ;\n" +
-			"INT : '0'..'9'+;\n" +
-			"WS : (' '|'\\n') -> skip ;\n";
-
-		String found = execParser("T.g4", grammar, "TParser", "TLexer", "a",
-								  "", false);
-		assertEquals("\n", found);
-		found = execParser("T.g4", grammar, "TParser", "TLexer", "a",
-								  "a 34 c", false);
-		assertEquals("a34c\n", found);
-	}
-
-
-	/**
-	 * This test is meant to detect regressions of bug antlr/antlr4#41.
-	 * https://github.com/antlr/antlr4/issues/41
-	 */
-	@Test
-	public void testOptional() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"stat : ifstat | 'x';\n" +
-			"ifstat : 'if' stat ('else' stat)?;\n" +
-			"WS : [ \\n\\t]+ -> skip ;"
-			;
-
-		String found = execParser("T.g4", grammar, "TParser", "TLexer", "stat", "x", false);
-		assertEquals("", found);
-		assertNull(this.stderrDuringParse);
-
-		found = execParser("T.g4", grammar, "TParser", "TLexer", "stat", "if x else x", false);
-		assertEquals("", found);
-		assertNull(this.stderrDuringParse);
-
-		found = execParser("T.g4", grammar, "TParser", "TLexer", "stat", "if x", false);
-		assertEquals("", found);
-		assertNull(this.stderrDuringParse);
-
-		found = execParser("T.g4", grammar, "TParser", "TLexer", "stat", "if if x else x", false);
-		assertEquals("", found);
-		assertNull(this.stderrDuringParse);
-	}
-
-	/**
-	 * This test is meant to test the expected solution to antlr/antlr4#42.
-	 * https://github.com/antlr/antlr4/issues/42
-	 */
-	@Test
-	public void testPredicatedIfIfElse() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"s : stmt EOF ;\n" +
-			"stmt : ifStmt | ID;\n" +
-			"ifStmt : 'if' ID stmt ('else' stmt | {_input.LA(1) != ELSE}?);\n" +
-			"ELSE : 'else';\n" +
-			"ID : [a-zA-Z]+;\n" +
-			"WS : [ \\n\\t]+ -> skip;\n"
-			;
-
-		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s",
-								  "if x if x a else b", true);
-		String expecting = "";
-		assertEquals(expecting, found);
-		assertNull(this.stderrDuringParse);
-	}
-
-	/**
-	 * This is a regression test for antlr/antlr4#118.
-	 * https://github.com/antlr/antlr4/issues/118
-	 */
-	@Ignore("Performance impact of passing this test may not be worthwhile")
-	@Test public void testStartRuleWithoutEOF() {
-		String grammar =
-			"grammar T;\n"+
-			"s @after {dumpDFA();}\n" +
-			"  : ID | ID INT ID ;\n" +
-			"ID : 'a'..'z'+ ;\n"+
-			"INT : '0'..'9'+ ;\n"+
-			"WS : (' '|'\\t'|'\\n')+ -> skip ;\n";
-		String result = execParser("T.g4", grammar, "TParser", "TLexer", "s",
-								   "abc 34", true);
-		String expecting =
-			"Decision 0:\n" +
-			"s0-ID->s1\n" +
-			"s1-INT->s2\n" +
-			"s2-EOF->:s3=>1\n"; // Must point at accept state
-		assertEquals(expecting, result);
-		assertNull(this.stderrDuringParse);
-	}
-
-	/**
-	 * This is a regression test for antlr/antlr4#195 "label 'label' type
-	 * mismatch with previous definition: TOKEN_LABEL!=RULE_LABEL"
-	 * https://github.com/antlr/antlr4/issues/195
-	 */
-	@Test public void testLabelAliasingAcrossLabeledAlternatives() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"start : a* EOF;\n" +
-			"a\n" +
-			"  : label=subrule {System.out.println($label.text);} #One\n" +
-			"  | label='y' {System.out.println($label.text);} #Two\n" +
-			"  ;\n" +
-			"subrule : 'x';\n" +
-			"WS : (' '|'\\n') -> skip ;\n";
-
-		String found = execParser("T.g4", grammar, "TParser", "TLexer", "start",
-								  "xy", false);
-		assertEquals("x\ny\n", found);
-	}
-
-	/**
-	 * This is a regression test for antlr/antlr4#334 "BailErrorStrategy: bails
-	 * out on proper input".
-	 * https://github.com/antlr/antlr4/issues/334
-	 */
-	@Test public void testPredictionIssue334() {
-		String grammar =
-			"grammar T;\n" +
-			"\n" +
-			"file @init{setErrorHandler(new BailErrorStrategy());} \n" +
-			"@after {System.out.println($ctx.toStringTree(this));}\n" +
-			"  :   item (SEMICOLON item)* SEMICOLON? EOF ;\n" +
-			"item : A B?;\n" +
-			"\n" +
-			"\n" +
-			"\n" +
-			"SEMICOLON: ';';\n" +
-			"\n" +
-			"A : 'a'|'A';\n" +
-			"B : 'b'|'B';\n" +
-			"\n" +
-			"WS      : [ \\r\\t\\n]+ -> skip;\n";
-
-		String input = "a";
-		String found = execParser("T.g4", grammar, "TParser", "TLexer", "file", input, false);
-		assertEquals("(file (item a) <EOF>)\n", found);
-		assertNull(stderrDuringParse);
-	}
-}
diff --git a/tool/test/org/antlr/v4/test/TestSemPredEvalLexer.java b/tool/test/org/antlr/v4/test/TestSemPredEvalLexer.java
deleted file mode 100644
index 95934d397..000000000
--- a/tool/test/org/antlr/v4/test/TestSemPredEvalLexer.java
+++ /dev/null
@@ -1,183 +0,0 @@
-/*
- * [The "BSD license"]
- *  Copyright (c) 2012 Terence Parr
- *  Copyright (c) 2012 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.
- */
-
-package org.antlr.v4.test;
-
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-public class TestSemPredEvalLexer extends BaseTest {
-
-	@Test public void testDisableRule() throws Exception {
-		String grammar =
-			"lexer grammar L;\n"+
-			"E1 : 'enum' {false}? ;\n" +
-			"E2 : 'enum' {true}? ;\n" +  // winner not E1 or ID
-			"ID : 'a'..'z'+ ;\n"+
-			"WS : (' '|'\\n') -> skip ;";
-		String found = execLexer("L.g4", grammar, "L", "enum abc", true);
-		String expecting =
-			"[@0,0:3='enum',<2>,1:0]\n" +
-			"[@1,5:7='abc',<3>,1:5]\n" +
-			"[@2,8:7='<EOF>',<-1>,1:8]\n" +
-			"s0-' '->:s5=>4\n" +
-			"s0-'a'->:s6=>3\n" +
-			"s0-'e'->:s1=>3\n" +
-			":s1=>3-'n'->:s2=>3\n" +
-			":s2=>3-'u'->:s3=>3\n" +
-			":s6=>3-'b'->:s6=>3\n" +
-			":s6=>3-'c'->:s6=>3\n";
-		assertEquals(expecting, found);
-	}
-
-	@Test public void testIDvsEnum() throws Exception {
-		String grammar =
-			"lexer grammar L;\n"+
-			"ENUM : 'enum' {false}? ;\n" +
-			"ID : 'a'..'z'+ ;\n"+
-			"WS : (' '|'\\n') -> skip ;";
-		String found = execLexer("L.g4", grammar, "L", "enum abc enum", true);
-		String expecting =
-			"[@0,0:3='enum',<2>,1:0]\n" +
-			"[@1,5:7='abc',<2>,1:5]\n" +
-			"[@2,9:12='enum',<2>,1:9]\n" +
-			"[@3,13:12='<EOF>',<-1>,1:13]\n" +
-			"s0-' '->:s5=>3\n" +
-			"s0-'a'->:s4=>2\n" +
-			"s0-'e'->:s1=>2\n" +
-			":s1=>2-'n'->:s2=>2\n" +
-			":s2=>2-'u'->:s3=>2\n" +
-			":s4=>2-'b'->:s4=>2\n" +
-			":s4=>2-'c'->:s4=>2\n"; // no 'm'-> transition...conflicts with pred
-		assertEquals(expecting, found);
-	}
-
-	@Test public void testIDnotEnum() throws Exception {
-		String grammar =
-			"lexer grammar L;\n"+
-			"ENUM : [a-z]+ {false}? ;\n" +
-			"ID   : [a-z]+ ;\n"+
-			"WS : (' '|'\\n') -> skip ;";
-		String found = execLexer("L.g4", grammar, "L", "enum abc enum", true);
-		String expecting =
-			"[@0,0:3='enum',<2>,1:0]\n" +
-			"[@1,5:7='abc',<2>,1:5]\n" +
-			"[@2,9:12='enum',<2>,1:9]\n" +
-			"[@3,13:12='<EOF>',<-1>,1:13]\n" +
-			"s0-' '->:s2=>3\n"; // no edges in DFA for enum/id. all paths lead to pred.
-		assertEquals(expecting, found);
-	}
-
-	@Test public void testEnumNotID() throws Exception {
-		String grammar =
-			"lexer grammar L;\n"+
-			"ENUM : [a-z]+ {getText().equals(\"enum\")}? ;\n" +
-			"ID   : [a-z]+ ;\n"+
-			"WS : (' '|'\\n') -> skip ;";
-		String found = execLexer("L.g4", grammar, "L", "enum abc enum", true);
-		String expecting =
-			"[@0,0:3='enum',<1>,1:0]\n" +
-			"[@1,5:7='abc',<2>,1:5]\n" +
-			"[@2,9:12='enum',<1>,1:9]\n" +
-			"[@3,13:12='<EOF>',<-1>,1:13]\n" +
-			"s0-' '->:s3=>3\n"; // no edges in DFA for enum/id. all paths lead to pred.
-		assertEquals(expecting, found);
-	}
-
-	@Test public void testIndent() throws Exception {
-		String grammar =
-			"lexer grammar L;\n"+
-			"ID : [a-z]+ ;\n"+
-			"INDENT : [ \\t]+ {_tokenStartCharPositionInLine==0}? \n" +
-			"         {System.out.println(\"INDENT\");}  ;"+
-			"NL     : '\\n' ;"+
-			"WS     : [ \\t]+ ;";
-		String found = execLexer("L.g4", grammar, "L", "abc\n  def  \n", true);
-		String expecting =
-			"INDENT\n" +                        // action output
-			"[@0,0:2='abc',<1>,1:0]\n" +		// ID
-			"[@1,3:3='\\n',<3>,1:3]\n" +  		// NL
-			"[@2,4:5='  ',<2>,2:0]\n" +			// INDENT
-			"[@3,6:8='def',<1>,2:2]\n" +		// ID
-			"[@4,9:10='  ',<4>,2:5]\n" +		// WS
-			"[@5,11:11='\\n',<3>,2:7]\n" +
-			"[@6,12:11='<EOF>',<-1>,3:8]\n" +
-			"s0-'\n" +
-			"'->:s2=>3\n" +
-			"s0-'a'->:s1=>1\n" +
-			"s0-'d'->:s1=>1\n" +
-			":s1=>1-'b'->:s1=>1\n" +
-			":s1=>1-'c'->:s1=>1\n" +
-			":s1=>1-'e'->:s1=>1\n" +
-			":s1=>1-'f'->:s1=>1\n";
-		assertEquals(expecting, found);
-	}
-
-	@Test public void testLexerInputPositionSensitivePredicates() throws Exception {
-		String grammar =
-			"lexer grammar L;\n"+
-			"WORD1 : ID1+ {System.out.println(getText());} ;\n"+
-			"WORD2 : ID2+ {System.out.println(getText());} ;\n"+
-			"fragment ID1 : {getCharPositionInLine()<2}? [a-zA-Z];\n"+
-			"fragment ID2 : {getCharPositionInLine()>=2}? [a-zA-Z];\n"+
-			"WS : (' '|'\\n') -> skip;\n";
-		String found = execLexer("L.g4", grammar, "L", "a cde\nabcde\n");
-		String expecting =
-			"a\n" +
-			"cde\n" +
-			"ab\n" +
-			"cde\n" +
-			"[@0,0:0='a',<1>,1:0]\n" +
-			"[@1,2:4='cde',<2>,1:2]\n" +
-			"[@2,6:7='ab',<1>,2:0]\n" +
-			"[@3,8:10='cde',<2>,2:2]\n" +
-			"[@4,12:11='<EOF>',<-1>,3:0]\n";
-		assertEquals(expecting, found);
-	}
-
-	@Test public void testPredicatedKeywords() {
-		String grammar =
-			"lexer grammar A;" +
-			"ENUM : [a-z]+ {getText().equals(\"enum\")}? {System.out.println(\"enum!\");} ;\n" +
-			"ID   : [a-z]+ {System.out.println(\"ID \"+getText());} ;\n" +
-			"WS   : [ \\n] -> skip ;";
-		String found = execLexer("A.g4", grammar, "A", "enum enu a");
-		String expecting =
-			"enum!\n" +
-			"ID enu\n" +
-			"ID a\n" +
-			"[@0,0:3='enum',<1>,1:0]\n" +
-			"[@1,5:7='enu',<2>,1:5]\n" +
-			"[@2,9:9='a',<2>,1:9]\n" +
-			"[@3,10:9='<EOF>',<-1>,1:10]\n";
-		assertEquals(expecting, found);
-	}
-}
diff --git a/tool/test/org/antlr/v4/test/TestSemPredEvalParser.java b/tool/test/org/antlr/v4/test/TestSemPredEvalParser.java
deleted file mode 100644
index 688e656e8..000000000
--- a/tool/test/org/antlr/v4/test/TestSemPredEvalParser.java
+++ /dev/null
@@ -1,597 +0,0 @@
-/*
- * [The "BSD license"]
- *  Copyright (c) 2012 Terence Parr
- *  Copyright (c) 2012 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.
- */
-
-package org.antlr.v4.test;
-
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-public class TestSemPredEvalParser extends BaseTest {
-	// TEST VALIDATING PREDS
-
-	@Test public void testSimpleValidate() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-				"s : a ;\n" +
-				"a : {false}? ID  {System.out.println(\"alt 1\");}\n" +
-				"  | {true}?  INT {System.out.println(\"alt 2\");}\n" +
-				"  ;\n" +
-				"ID : 'a'..'z'+ ;\n" +
-				"INT : '0'..'9'+;\n" +
-				"WS : (' '|'\\n') -> skip ;\n";
-
-		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s",
-								  "x", false);
-
-		String expecting = "line 1:0 no viable alternative at input 'x'\n";
-		assertEquals(expecting, stderrDuringParse);
-	}
-
-	@Test public void testSimpleValidate2() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-				"s : a a a;\n" +
-				"a : {false}? ID  {System.out.println(\"alt 1\");}\n" +
-				"  | {true}?  INT {System.out.println(\"alt 2\");}\n" +
-				"  ;\n" +
-				"ID : 'a'..'z'+ ;\n" +
-				"INT : '0'..'9'+;\n" +
-				"WS : (' '|'\\n') -> skip ;\n";
-
-		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s",
-								  "3 4 x", false);
-		String expecting =
-			"alt 2\n" +
-			"alt 2\n";
-		assertEquals(expecting, found);
-
-		expecting = "line 1:4 no viable alternative at input 'x'\n";
-		assertEquals(expecting, stderrDuringParse);
-	}
-
-	/**
-	 * This is a regression test for antlr/antlr4#196
-	 * "element+ in expression grammar doesn't parse properly"
-	 * https://github.com/antlr/antlr4/issues/196
-	 */
-	@Test public void testAtomWithClosureInTranslatedLRRule() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"start : e[0] EOF;\n" +
-			"e[int _p]\n" +
-			"    :   ( 'a'\n" +
-			"        | 'b'+\n" +
-			"        )\n" +
-			"        ( {3 >= $_p}? '+' e[4]\n" +
-			"        )*\n" +
-			"    ;\n";
-
-		String found = execParser("T.g4", grammar, "TParser", "TLexer", "start",
-								  "a+b+a", false);
-		String expecting = "";
-		assertEquals(expecting, found);
-		assertNull(stderrDuringParse);
-	}
-
-	@Test public void testValidateInDFA() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-				"s : a ';' a;\n" +
-				// ';' helps us to resynchronize without consuming
-				// 2nd 'a' reference. We our testing that the DFA also
-				// throws an exception if the validating predicate fails
-				"a : {false}? ID  {System.out.println(\"alt 1\");}\n" +
-				"  | {true}?  INT {System.out.println(\"alt 2\");}\n" +
-				"  ;\n" +
-				"ID : 'a'..'z'+ ;\n" +
-				"INT : '0'..'9'+;\n" +
-				"WS : (' '|'\\n') -> skip ;\n";
-
-		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s",
-								  "x ; y", false);
-		String expecting = "";
-		assertEquals(expecting, found);
-
-		expecting =
-			"line 1:0 no viable alternative at input 'x'\n" +
-			"line 1:4 no viable alternative at input 'y'\n";
-		assertEquals(expecting, stderrDuringParse);
-	}
-
-	// TEST DISAMBIG PREDS
-
-	@Test public void testSimple() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-				"s : a a a;\n" + // do 3x: once in ATN, next in DFA then INT in ATN
-				"a : {false}? ID {System.out.println(\"alt 1\");}\n" +
-				"  | {true}?  ID {System.out.println(\"alt 2\");}\n" +
-				"  | INT         {System.out.println(\"alt 3\");}\n" +
-				"  ;\n" +
-				"ID : 'a'..'z'+ ;\n" +
-				"INT : '0'..'9'+;\n" +
-				"WS : (' '|'\\n') -> skip ;\n";
-
-		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s",
-								  "x y 3", false);
-		String expecting =
-			"alt 2\n" +
-				"alt 2\n" +
-				"alt 3\n";
-		assertEquals(expecting, found);
-	}
-
-	@Test public void testOrder() throws Exception {
-		// Under new predicate ordering rules (see antlr/antlr4#29), the first
-		// alt with an acceptable config (unpredicated, or predicated and evaluates
-		// to true) is chosen.
-		String grammar =
-			"grammar T;\n" +
-				"s : a {} a;\n" + // do 2x: once in ATN, next in DFA;
-								  // action blocks lookahead from falling off of 'a'
-								  // and looking into 2nd 'a' ref. !ctx dependent pred
-				"a :          ID {System.out.println(\"alt 1\");}\n" +
-				"  | {true}?  ID {System.out.println(\"alt 2\");}\n" +
-				"  ;\n" +
-				"ID : 'a'..'z'+ ;\n" +
-				"INT : '0'..'9'+;\n" +
-				"WS : (' '|'\\n') -> skip ;\n";
-
-		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s",
-								  "x y", false);
-		String expecting =
-			"alt 1\n" +
-			"alt 1\n";
-		assertEquals(expecting, found);
-	}
-
-	@Test public void test2UnpredicatedAlts() throws Exception {
-		// We have n-2 predicates for n alternatives. pick first alt
-		String grammar =
-			"grammar T;\n" +
-			"@header {" +
-			"import java.util.*;" +
-			"}" +
-			"s : {_interp.setPredictionMode(PredictionMode.LL_EXACT_AMBIG_DETECTION);}\n" +
-			"    a ';' a;\n" + // do 2x: once in ATN, next in DFA
-			"a :          ID {System.out.println(\"alt 1\");}\n" +
-			"  |          ID {System.out.println(\"alt 2\");}\n" +
-			"  | {false}? ID {System.out.println(\"alt 3\");}\n" +
-			"  ;\n" +
-			"ID : 'a'..'z'+ ;\n" +
-			"INT : '0'..'9'+;\n" +
-			"WS : (' '|'\\n') -> skip ;\n";
-
-		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s",
-								  "x; y", true);
-		String expecting =
-			"alt 1\n" +
-			"alt 1\n";
-		assertEquals(expecting, found);
-		assertEquals("line 1:0 reportAttemptingFullContext d=0 (a), input='x'\n" +
-					 "line 1:0 reportAmbiguity d=0 (a): ambigAlts={1, 2}, input='x'\n" +
-					 "line 1:3 reportAttemptingFullContext d=0 (a), input='y'\n" +
-					 "line 1:3 reportAmbiguity d=0 (a): ambigAlts={1, 2}, input='y'\n",
-                     this.stderrDuringParse);
-	}
-
-	@Test public void test2UnpredicatedAltsAndOneOrthogonalAlt() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"@header {" +
-			"import java.util.*;" +
-			"}" +
-			"s : {_interp.setPredictionMode(PredictionMode.LL_EXACT_AMBIG_DETECTION);}\n" +
-			"    a ';' a ';' a;\n" +
-			"a : INT         {System.out.println(\"alt 1\");}\n" +
-			"  |          ID {System.out.println(\"alt 2\");}\n" + // must pick this one for ID since pred is false
-			"  |          ID {System.out.println(\"alt 3\");}\n" +
-			"  | {false}? ID {System.out.println(\"alt 4\");}\n" +
-			"  ;\n" +
-			"ID : 'a'..'z'+ ;\n" +
-			"INT : '0'..'9'+;\n" +
-			"WS : (' '|'\\n') -> skip ;\n";
-
-		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s",
-								  "34; x; y", true);
-		String expecting =
-			"alt 1\n" +
-			"alt 2\n" +
-			"alt 2\n";
-		assertEquals(expecting, found);
-		assertEquals("line 1:4 reportAttemptingFullContext d=0 (a), input='x'\n" +
-					 "line 1:4 reportAmbiguity d=0 (a): ambigAlts={2, 3}, input='x'\n" +
-					 "line 1:7 reportAttemptingFullContext d=0 (a), input='y'\n" +
-					 "line 1:7 reportAmbiguity d=0 (a): ambigAlts={2, 3}, input='y'\n",
-					 this.stderrDuringParse);
-	}
-
-	@Test public void testRewindBeforePredEval() throws Exception {
-		// The parser consumes ID and moves to the 2nd token INT.
-		// To properly evaluate the predicates after matching ID INT,
-		// we must correctly see come back to starting index so LT(1) works
-		String grammar =
-			"grammar T;\n" +
-				"s : a a;\n" +
-				"a : {_input.LT(1).getText().equals(\"x\")}? ID INT {System.out.println(\"alt 1\");}\n" +
-				"  | {_input.LT(1).getText().equals(\"y\")}? ID INT {System.out.println(\"alt 2\");}\n" +
-				"  ;\n" +
-				"ID : 'a'..'z'+ ;\n" +
-				"INT : '0'..'9'+;\n" +
-				"WS : (' '|'\\n') -> skip ;\n";
-
-		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s",
-								  "y 3 x 4", false);
-		String expecting =
-			"alt 2\n" +
-			"alt 1\n";
-		assertEquals(expecting, found);
-	}
-
-	@Test public void testNoTruePredsThrowsNoViableAlt() throws Exception {
-		// checks that we throw exception if all alts
-		// are covered with a predicate and none succeeds
-		String grammar =
-			"grammar T;\n" +
-			"s : a a;\n" +
-			"a : {false}? ID INT {System.out.println(\"alt 1\");}\n" +
-			"  | {false}? ID INT {System.out.println(\"alt 2\");}\n" +
-			"  ;\n" +
-			"ID : 'a'..'z'+ ;\n" +
-			"INT : '0'..'9'+;\n" +
-			"WS : (' '|'\\n') -> skip ;\n";
-
-		execParser("T.g4", grammar, "TParser", "TLexer", "s",
-				   "y 3 x 4", false);
-		String expecting = "line 1:0 no viable alternative at input 'y'\n";
-		String result = stderrDuringParse;
-		assertEquals(expecting, result);
-	}
-
-	@Test public void testToLeft() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-				"s : a+ ;\n" +
-   			"a : {false}? ID {System.out.println(\"alt 1\");}\n" +
-   			"  | {true}?  ID {System.out.println(\"alt 2\");}\n" +
-   			"  ;\n" +
-   			"ID : 'a'..'z'+ ;\n" +
-   			"INT : '0'..'9'+;\n" +
-   			"WS : (' '|'\\n') -> skip ;\n";
-
-   		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s",
-   								  "x x y", false);
-   		String expecting =
-   			"alt 2\n" +
-   			"alt 2\n" +
-   			"alt 2\n";
-   		assertEquals(expecting, found);
-   	}
-
-	@Test
-	public void testUnpredicatedPathsInAlt() throws Exception{
-		String grammar =
-			"grammar T;\n" +
-				"s : a {System.out.println(\"alt 1\");}\n" +
-				"  | b {System.out.println(\"alt 2\");}\n" +
-				"  ;\n" +
-				"a : {false}? ID INT\n" +
-				"  | ID INT\n" +
-				"  ;\n" +
-				"b : ID ID\n" +
-				"  ;\n" +
-				"ID : 'a'..'z'+ ;\n" +
-				"INT : '0'..'9'+;\n" +
-				"WS : (' '|'\\n') -> skip ;\n";
-
-		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s",
-								  "x 4", false);
-		String expecting =
-			"alt 1\n";
-		assertEquals(expecting, found);
-
-		expecting = null;
-		assertEquals(expecting, stderrDuringParse);
-	}
-
-	@Test public void testActionHidesPreds() throws Exception {
-		// can't see preds, resolves to first alt found (1 in this case)
-		String grammar =
-			"grammar T;\n" +
-			"@members {int i;}\n" +
-			"s : a+ ;\n" +
-			"a : {i=1;} ID {i==1}? {System.out.println(\"alt 1\");}\n" +
-			"  | {i=2;} ID {i==2}? {System.out.println(\"alt 2\");}\n" +
-			"  ;\n" +
-			"ID : 'a'..'z'+ ;\n" +
-			"INT : '0'..'9'+;\n" +
-			"WS : (' '|'\\n') -> skip ;\n";
-
-		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s",
-								  "x x y", false);
-		String expecting =
-			"alt 1\n" +
-			"alt 1\n" +
-			"alt 1\n";
-		assertEquals(expecting, found);
-	}
-
-	/** In this case, we use predicates that depend on global information
-	 *  like we would do for a symbol table. We simply execute
-	 *  the predicates assuming that all necessary information is available.
-	 *  The i++ action is done outside of the prediction and so it is executed.
-	 */
-	@Test public void testToLeftWithVaryingPredicate() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"@members {int i=0;}\n" +
-			"s : ({i++; System.out.println(\"i=\"+i);} a)+ ;\n" +
-			"a : {i % 2 == 0}? ID {System.out.println(\"alt 1\");}\n" +
-			"  | {i % 2 != 0}? ID {System.out.println(\"alt 2\");}\n" +
-			"  ;\n" +
-			"ID : 'a'..'z'+ ;\n" +
-			"INT : '0'..'9'+;\n" +
-			"WS : (' '|'\\n') -> skip ;\n";
-
-		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s",
-								  "x x y", false);
-		String expecting =
-			"i=1\n" +
-			"alt 2\n" +
-			"i=2\n" +
-			"alt 1\n" +
-			"i=3\n" +
-			"alt 2\n";
-		assertEquals(expecting, found);
-	}
-
-	/**
-	 * In this case, we're passing a parameter into a rule that uses that
-	 * information to predict the alternatives. This is the special case
-	 * where we know exactly which context we are in. The context stack
-	 * is empty and we have not dipped into the outer context to make a decision.
-	 */
-	@Test public void testPredicateDependentOnArg() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"@members {int i=0;}\n" +
-			"s : a[2] a[1];\n" +
-			"a[int i]" +
-			"  : {$i==1}? ID {System.out.println(\"alt 1\");}\n" +
-			"  | {$i==2}? ID {System.out.println(\"alt 2\");}\n" +
-			"  ;\n" +
-			"ID : 'a'..'z'+ ;\n" +
-			"INT : '0'..'9'+;\n" +
-			"WS : (' '|'\\n') -> skip ;\n";
-
-		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s",
-								  "a b", false);
-		String expecting =
-			"alt 2\n" +
-			"alt 1\n";
-		assertEquals(expecting, found);
-	}
-
-	/** In this case, we have to ensure that the predicates are not
-	 tested during the closure after recognizing the 1st ID. The
-	 closure will fall off the end of 'a' 1st time and reach into the
-	 a[1] rule invocation. It should not execute predicates because it
-	 does not know what the parameter is. The context stack will not
-	 be empty and so they should be ignored. It will not affect
-	 recognition, however. We are really making sure the ATN
-     simulation doesn't crash with context object issues when it
-     encounters preds during FOLLOW.
-     */
-    @Test public void testPredicateDependentOnArg2() throws Exception {
-        String grammar =
-            "grammar T;\n" +
-            "s : a[2] a[1];\n" +
-            "a[int i]" +
-            "  : {$i==1}? ID\n" +
-            "  | {$i==2}? ID\n" +
-            "  ;\n" +
-            "ID : 'a'..'z'+ ;\n" +
-            "INT : '0'..'9'+;\n" +
-            "WS : (' '|'\\n') -> skip ;\n";
-
-        String found = execParser("T.g4", grammar, "TParser", "TLexer", "s",
-                                  "a b", false);
-        String expecting =
-        "";
-        assertEquals(expecting, found);
-    }
-
-    @Test public void testDependentPredNotInOuterCtxShouldBeIgnored() throws Exception {
-        // uses ID ';' or ID '.' lookahead to solve s. preds not tested.
-        String grammar =
-            "grammar T;\n" +
-            "s : b[2] ';' |  b[2] '.' ;\n" + // decision in s drills down to ctx-dependent pred in a;
-            "b[int i] : a[i] ;\n" +
-            "a[int i]" +
-            "  : {$i==1}? ID {System.out.println(\"alt 1\");}\n" +
-            "  | {$i==2}? ID {System.out.println(\"alt 2\");}\n" +
-            "  ;" +
-            "ID : 'a'..'z'+ ;\n" +
-            "INT : '0'..'9'+;\n" +
-            "WS : (' '|'\\n') -> skip ;\n";
-
-        String found = execParser("T.g4", grammar, "TParser", "TLexer", "s",
-                                  "a;", false);
-        String expecting =
-            "alt 2\n";
-        assertEquals(expecting, found);
-    }
-
-    @Test public void testIndependentPredNotPassedOuterCtxToAvoidCastException() throws Exception {
-        String grammar =
-            "grammar T;\n" +
-            "s : b ';' |  b '.' ;\n" +
-            "b : a ;\n" +
-            "a" +
-            "  : {false}? ID {System.out.println(\"alt 1\");}\n" +
-            "  | {true}? ID {System.out.println(\"alt 2\");}\n" +
-            "  ;" +
-            "ID : 'a'..'z'+ ;\n" +
-            "INT : '0'..'9'+;\n" +
-            "WS : (' '|'\\n') -> skip ;\n";
-
-        String found = execParser("T.g4", grammar, "TParser", "TLexer", "s",
-                                  "a;", false);
-        String expecting =
-            "alt 2\n";
-        assertEquals(expecting, found);
-    }
-
-    /** During a global follow operation, we still collect semantic
-     *  predicates as long as they are not dependent on local context
-     */
-    @Test public void testPredsInGlobalFOLLOW() throws Exception {
-        String grammar =
-        "grammar T;\n" +
-        "@members {" +
-        "void f(Object s) {System.out.println(s);}\n" +
-        "boolean p(boolean v) {System.out.println(\"eval=\"+v); return v;}\n" +
-        "}\n" +
-        "s : e {p(true)}? {f(\"parse\");} '!' ;\n" +
-        "t : e {p(false)}? ID ;\n" +
-        "e : ID | ;\n" + // non-LL(1) so we use ATN
-        "ID : 'a'..'z'+ ;\n" +
-        "INT : '0'..'9'+;\n" +
-        "WS : (' '|'\\n') -> skip ;\n";
-
-   		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s",
-   								  "a!", false);
-   		String expecting =
-   			"eval=true\n" + // now we are parsing
-   			"parse\n";
-   		assertEquals(expecting, found);
-   	}
-
-   	/** We cannot collect predicates that are dependent on local context if
-   	 *  we are doing a global follow. They appear as if they were not there at all.
-   	 */
-   	@Test public void testDepedentPredsInGlobalFOLLOW() throws Exception {
-   		String grammar =
-   			"grammar T;\n" +
-   			"@members {" +
-   			"void f(Object s) {System.out.println(s);}\n" +
-   			"boolean p(boolean v) {System.out.println(\"eval=\"+v); return v;}\n" +
-   			"}\n" +
-   			"s : a[99] ;\n" +
-   			"a[int i] : e {p($i==99)}? {f(\"parse\");} '!' ;\n" +
-   			"b[int i] : e {p($i==99)}? ID ;\n" +
-   			"e : ID | ;\n" + // non-LL(1) so we use ATN
-   			"ID : 'a'..'z'+ ;\n" +
-   			"INT : '0'..'9'+;\n" +
-   			"WS : (' '|'\\n') -> skip ;\n";
-
-   		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s",
-   								  "a!", false);
-   		String expecting =
-   			"eval=true\n" +
-   			"parse\n";
-   		assertEquals(expecting, found);
-   	}
-
-	/** Regular non-forced actions can create side effects used by semantic
-	 *  predicates and so we cannot evaluate any semantic predicate
-	 *  encountered after having seen a regular action. This includes
-	 *  during global follow operations.
-	 */
-	@Test public void testActionsHidePredsInGlobalFOLLOW() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"@members {" +
-			"void f(Object s) {System.out.println(s);}\n" +
-			"boolean p(boolean v) {System.out.println(\"eval=\"+v); return v;}\n" +
-			"}\n" +
-			"s : e {} {p(true)}? {f(\"parse\");} '!' ;\n" +
-			"t : e {} {p(false)}? ID ;\n" +
-			"e : ID | ;\n" + // non-LL(1) so we use ATN
-			"ID : 'a'..'z'+ ;\n" +
-			"INT : '0'..'9'+;\n" +
-			"WS : (' '|'\\n') -> skip ;\n";
-
-		String found = execParser("T.g4", grammar, "TParser", "TLexer", "s",
-								  "a!", false);
-		String expecting =
-			"eval=true\n" +
-			"parse\n";
-		assertEquals(expecting, found);
-	}
-
-	@Test public void testPredTestedEvenWhenUnAmbig() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"\n" +
-			"@members {boolean enumKeyword = true;}\n" +
-			"\n" +
-			"primary\n" +
-			"    :   ID                       {System.out.println(\"ID \"+$ID.text);}\n" +
-			"    |   {!enumKeyword}? 'enum'   {System.out.println(\"enum\");}\n" +
-			"    ;\n" +
-			"\n" +
-			"ID : [a-z]+ ;\n" +
-			"\n" +
-			"WS : [ \\t\\n\\r]+ -> skip ;\n";
-
-		String found = execParser("T.g4", grammar, "TParser", "TLexer", "primary",
-								  "abc", false);
-		assertEquals("ID abc\n", found);
-
-		execParser("T.g4", grammar, "TParser", "TLexer", "primary",
-				   "enum", false);
-		assertEquals("line 1:0 no viable alternative at input 'enum'\n", stderrDuringParse);
-	}
-
-	/**
-	 * This is a regression test for antlr/antlr4#218 "ANTLR4 EOF Related Bug".
-	 * https://github.com/antlr/antlr4/issues/218
-	 */
-	@Test public void testDisabledAlternative() {
-		String grammar =
-			"grammar AnnotProcessor;\n" +
-			"\n" +
-			"cppCompilationUnit : content+ EOF;\n" +
-			"\n" +
-			"content: anything | {false}? .;\n" +
-			"\n" +
-			"anything: ANY_CHAR;\n" +
-			"\n" +
-			"ANY_CHAR: [_a-zA-Z0-9];\n";
-
-		String input = "hello";
-		String found = execParser("AnnotProcessor.g4", grammar, "AnnotProcessorParser", "AnnotProcessorLexer", "cppCompilationUnit",
-								  input, false);
-		assertEquals("", found);
-		assertNull(stderrDuringParse);
-	}
-}
diff --git a/tool/test/org/antlr/v4/test/TestSets.java b/tool/test/org/antlr/v4/test/TestSets.java
deleted file mode 100644
index da9ef1c28..000000000
--- a/tool/test/org/antlr/v4/test/TestSets.java
+++ /dev/null
@@ -1,283 +0,0 @@
-/*
- * [The "BSD license"]
- *  Copyright (c) 2012 Terence Parr
- *  Copyright (c) 2012 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.
- */
-package org.antlr.v4.test;
-
-import org.antlr.v4.tool.ErrorType;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-/** Test the set stuff in lexer and parser */
-public class TestSets extends BaseTest {
-	protected boolean debug = false;
-
-	/** Public default constructor used by TestRig */
-	public TestSets() {
-	}
-
-	@Test public void testSeqDoesNotBecomeSet() throws Exception {
-		// this must return A not I to the parser; calling a nonfragment rule
-		// from a nonfragment rule does not set the overall token.
-		String grammar =
-			"grammar P;\n" +
-			"a : C {System.out.println(_input.getText());} ;\n" +
-			"fragment A : '1' | '2';\n" +
-			"fragment B : '3' '4';\n" +
-			"C : A | B;\n";
-		String found = execParser("P.g4", grammar, "PParser", "PLexer",
-								  "a", "34", debug);
-		assertEquals("34\n", found);
-	}
-
-	@Test public void testParserSet() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"a : t=('x'|'y') {System.out.println($t.text);} ;\n";
-		String found = execParser("T.g4", grammar, "TParser", "TLexer",
-								  "a", "x", debug);
-		assertEquals("x\n", found);
-	}
-
-	@Test public void testParserNotSet() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"a : t=~('x'|'y') 'z' {System.out.println($t.text);} ;\n";
-		String found = execParser("T.g4", grammar, "TParser", "TLexer",
-								  "a", "zz", debug);
-		assertEquals("z\n", found);
-	}
-
-	@Test public void testParserNotToken() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"a : ~'x' 'z' {System.out.println(_input.getText());} ;\n";
-		String found = execParser("T.g4", grammar, "TParser", "TLexer",
-								  "a", "zz", debug);
-		assertEquals("zz\n", found);
-	}
-
-	@Test public void testParserNotTokenWithLabel() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"a : t=~'x' 'z' {System.out.println($t.text);} ;\n";
-		String found = execParser("T.g4", grammar, "TParser", "TLexer",
-								  "a", "zz", debug);
-		assertEquals("z\n", found);
-	}
-
-	@Test public void testRuleAsSet() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"a @after {System.out.println(_input.getText());} : 'a' | 'b' |'c' ;\n";
-		String found = execParser("T.g4", grammar, "TParser", "TLexer",
-								  "a", "b", debug);
-		assertEquals("b\n", found);
-	}
-
-	@Test public void testNotChar() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"a : A {System.out.println($A.text);} ;\n" +
-			"A : ~'b' ;\n";
-		String found = execParser("T.g4", grammar, "TParser", "TLexer",
-								  "a", "x", debug);
-		assertEquals("x\n", found);
-	}
-
-	@Test public void testOptionalSingleElement() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"a : A? 'c' {System.out.println(_input.getText());} ;\n" +
-			"A : 'b' ;\n";
-		String found = execParser("T.g4", grammar, "TParser", "TLexer",
-								  "a", "bc", debug);
-		assertEquals("bc\n", found);
-	}
-
-	@Test public void testOptionalLexerSingleElement() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"a : A {System.out.println(_input.getText());} ;\n" +
-			"A : 'b'? 'c' ;\n";
-		String found = execParser("T.g4", grammar, "TParser", "TLexer",
-								  "a", "bc", debug);
-		assertEquals("bc\n", found);
-	}
-
-	@Test public void testStarLexerSingleElement() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"a : A {System.out.println(_input.getText());} ;\n" +
-			"A : 'b'* 'c' ;\n";
-		String found = execParser("T.g4", grammar, "TParser", "TLexer",
-								  "a", "bbbbc", debug);
-		assertEquals("bbbbc\n", found);
-		found = execParser("T.g4", grammar, "TParser", "TLexer",
-								  "a", "c", debug);
-		assertEquals("c\n", found);
-	}
-
-	@Test public void testPlusLexerSingleElement() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"a : A {System.out.println(_input.getText());} ;\n" +
-			"A : 'b'+ 'c' ;\n";
-		String found = execParser("T.g4", grammar, "TParser", "TLexer",
-								  "a", "bbbbc", debug);
-		assertEquals("bbbbc\n", found);
-	}
-
-	@Test public void testOptionalSet() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"a : ('a'|'b')? 'c' {System.out.println(_input.getText());} ;\n";
-		String found = execParser("T.g4", grammar, "TParser", "TLexer",
-								  "a", "ac", debug);
-		assertEquals("ac\n", found);
-	}
-
-	@Test public void testStarSet() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"a : ('a'|'b')* 'c' {System.out.println(_input.getText());} ;\n";
-		String found = execParser("T.g4", grammar, "TParser", "TLexer",
-								  "a", "abaac", debug);
-		assertEquals("abaac\n", found);
-	}
-
-	@Test public void testPlusSet() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"a : ('a'|'b')+ 'c' {System.out.println(_input.getText());} ;\n";
-		String found = execParser("T.g4", grammar, "TParser", "TLexer",
-								  "a", "abaac", debug);
-		assertEquals("abaac\n", found);
-	}
-
-	@Test public void testLexerOptionalSet() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"a : A {System.out.println(_input.getText());} ;\n" +
-			"A : ('a'|'b')? 'c' ;\n";
-		String found = execParser("T.g4", grammar, "TParser", "TLexer",
-								  "a", "ac", debug);
-		assertEquals("ac\n", found);
-	}
-
-	@Test public void testLexerStarSet() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"a : A {System.out.println(_input.getText());} ;\n" +
-			"A : ('a'|'b')* 'c' ;\n";
-		String found = execParser("T.g4", grammar, "TParser", "TLexer",
-								  "a", "abaac", debug);
-		assertEquals("abaac\n", found);
-	}
-
-	@Test public void testLexerPlusSet() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"a : A {System.out.println(_input.getText());} ;\n" +
-			"A : ('a'|'b')+ 'c' ;\n";
-		String found = execParser("T.g4", grammar, "TParser", "TLexer",
-								  "a", "abaac", debug);
-		assertEquals("abaac\n", found);
-	}
-
-	@Test public void testNotCharSet() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"a : A {System.out.println($A.text);} ;\n" +
-			"A : ~('b'|'c') ;\n";
-		String found = execParser("T.g4", grammar, "TParser", "TLexer",
-								  "a", "x", debug);
-		assertEquals("x\n", found);
-	}
-
-	@Test public void testNotCharSetWithLabel() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"a : A {System.out.println($A.text);} ;\n" +
-			"A : h=~('b'|'c') ;\n";
-		String found = execParser("T.g4", grammar, "TParser", "TLexer",
-								  "a", "x", debug);
-		assertEquals("x\n", found);
-	}
-
-	@Test public void testNotCharSetWithRuleRef() throws Exception {
-		// might be a useful feature to add someday
-		String[] pair = new String[] {
-			"grammar T;\n" +
-			"a : A {System.out.println($A.text);} ;\n" +
-			"A : ~('a'|B) ;\n" +
-			"B : 'b' ;\n",
-			"error(" + ErrorType.UNSUPPORTED_REFERENCE_IN_LEXER_SET.code + "): T.g4:3:10: rule reference 'B' is not currently supported in a set\n"
-		};
-		super.testErrors(pair, true);
-	}
-
-	@Test public void testNotCharSetWithString() throws Exception {
-		// might be a useful feature to add someday
-		String[] pair = new String[] {
-			"grammar T;\n" +
-			"a : A {System.out.println($A.text);} ;\n" +
-			"A : ~('a'|'aa') ;\n" +
-			"B : 'b' ;\n",
-			"error(" + ErrorType.INVALID_LITERAL_IN_LEXER_SET.code + "): T.g4:3:10: multi-character literals are not allowed in lexer sets: 'aa'\n"
-		};
-		super.testErrors(pair, true);
-	}
-
-	@Test public void testNotCharSetWithRuleRef3() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"a : A {System.out.println($A.text);} ;\n" +
-			"A : ('a'|B) ;\n" +  // this doesn't collapse to set but works
-			"fragment\n" +
-			"B : ~('a'|'c') ;\n";
-		String found = execParser("T.g4", grammar, "TParser", "TLexer",
-								  "a", "x", debug);
-		assertEquals("x\n", found);
-	}
-
-	@Test public void testCharSetLiteral() throws Exception {
-		String grammar =
-			"grammar T;\n" +
-			"a : (A {System.out.println($A.text);})+ ;\n" +
-			"A : [AaBb] ;\n" +
-			"WS : (' '|'\\n')+ -> skip ;\n";
-		String found = execParser("T.g4", grammar, "TParser", "TLexer",
-								  "a", "A a B b", debug);
-		assertEquals("A\n" +
-					 "a\n" +
-					 "B\n" +
-					 "b\n", found);
-	}
-}